RSA加密解密

今天药忘吃喽~ 2022-08-02 07:30 289阅读 0赞

package com.isoftstone.cms.common.utils;

import java.math.BigInteger;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.util.HashMap;
import java.util.Random;

import javax.crypto.Cipher;
import javax.servlet.http.HttpSession;

public class RSAUtils {
/**
* 生成公钥和私钥
* @throws NoSuchAlgorithmException
*
*/
public static HashMap getKeys() throws NoSuchAlgorithmException{
HashMap map = new HashMap();
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(“RSA”, new org.bouncycastle.jce.provider.BouncyCastleProvider());
keyPairGen.initialize(1024);
KeyPair keyPair = keyPairGen.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
map.put(“public”, publicKey);
map.put(“private”, privateKey);
return map;
}
/**
* 使用模和指数生成RSA公钥
*
*
* @param modulus
* 模
* @param exponent
* 指数
* @return
*/
public static RSAPublicKey getPublicKey(String modulus, String exponent) {
try {
BigInteger b1 = new BigInteger(modulus);
BigInteger b2 = new BigInteger(exponent);
KeyFactory keyFactory = KeyFactory.getInstance(“RSA”, new org.bouncycastle.jce.provider.BouncyCastleProvider());
RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);
return (RSAPublicKey) keyFactory.generatePublic(keySpec);
} catch (Exception e) {
e.printStackTrace();
return null;
}
} 

  1. /\*\*   
  2.  \* 使用模和指数生成RSA私钥   
  4.  \* /None/NoPadding】   
  5.  \*    
  6.  \* @param modulus   
  7.  \*            模   
  8.  \* @param exponent   
  9.  \*            指数   
  10.  \* @return   
  11.  \*/    
  12. public static RSAPrivateKey getPrivateKey(String modulus, String exponent) \{    
  13.     try \{    
  14.         BigInteger b1 = new BigInteger(modulus);    
  15.         BigInteger b2 = new BigInteger(exponent);    
  16.         KeyFactory keyFactory = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());    
  17.         RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);    
  18.         return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);    
  19.     \} catch (Exception e) \{    
  20.         e.printStackTrace();    
  21.         return null;    
  22.     \}    
  23. \}    
  25. /\*\*   
  26.  \* 公钥加密   
  27.  \*    
  28.  \* @param data   
  29.  \* @param publicKey   
  30.  \* @return   
  31.  \* @throws Exception   
  32.  \*/    
  33. public static String encryptByPublicKey(String data, RSAPublicKey publicKey)    
  34.         throws Exception \{    
  35.     Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());    
  36.     cipher.init(Cipher.ENCRYPT\_MODE, publicKey);    
  37.     // 模长    
  38.     int key\_len = publicKey.getModulus().bitLength() / 8;    
  39.     // 加密数据长度 <= 模长-11    
  40.     String\[\] datas = splitString(data, key\_len - 11);    
  41.     String mi = "";    
  42.     //如果明文长度大于模长-11则要分组加密    
  43.     for (String s : datas) \{    
  44.         mi += bcd2Str(cipher.doFinal(s.getBytes()));    
  45.     \}    
  46.     return mi;    
  47. \}    
  49. /\*\*   
  50.  \* 私钥解密   
  51.  \*    
  52.  \* @param data   
  53.  \* @param privateKey   
  54.  \* @return   
  55.  \* @throws Exception   
  56.  \*/    
  57. public static String decryptByPrivateKey(String data, RSAPrivateKey privateKey)    
  58.         throws Exception \{    
  59.     Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());    
  60.     cipher.init(Cipher.DECRYPT\_MODE, privateKey);    
  61.     //模长    
  62.     int key\_len = privateKey.getModulus().bitLength() / 8;    
  63.     byte\[\] bytes = data.getBytes();    
  64.     byte\[\] bcd = ASCII\_To\_BCD(bytes, bytes.length);    
  65.     //System.err.println(bcd.length);    
  66.     //如果密文长度大于模长则要分组解密    
  67.     String ming = "";    
  68.     byte\[\]\[\] arrays = splitArray(bcd, key\_len);    
  69.     for(byte\[\] arr : arrays)\{    
  70.         ming += new String(cipher.doFinal(arr));    
  71.     \}    
  72.     return ming;    
  73. \}    
  75. /\*\*   
  76.  \* 私钥加密   
  77.  \*    
  78.  \* @param data   
  79.  \* @param publicKey   
  80.  \* @return   
  81.  \* @throws Exception   
  82.  \*/    
  83. public static String encryptByPrivateKey(String data, RSAPrivateKey privateKey)    
  84.         throws Exception \{    
  85.     Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());    
  86.     cipher.init(Cipher.ENCRYPT\_MODE, privateKey);    
  87.     // 模长    
  88.     int key\_len = privateKey.getModulus().bitLength() / 8;    
  89.     // 加密数据长度 <= 模长-11    
  90.     String\[\] datas = splitString(data, key\_len - 11);    
  91.     String mi = "";    
  92.     //如果明文长度大于模长-11则要分组加密    
  93.     for (String s : datas) \{    
  94.         mi += bcd2Str(cipher.doFinal(s.getBytes()));    
  95.     \}    
  96.     return mi;    
  97. \}    
  99. /\*\*   
  100.  \* 公钥解密   
  101.  \*    
  102.  \* @param data   
  103.  \* @param privateKey   
  104.  \* @return   
  105.  \* @throws Exception   
  106.  \*/    
  107. public static String decryptByPublicKey(String data, RSAPublicKey publicKey)    
  108.         throws Exception \{    
  109.     Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());    
  110.     cipher.init(Cipher.DECRYPT\_MODE, publicKey);    
  111.     //模长    
  112.     int key\_len = publicKey.getModulus().bitLength() / 8;    
  113.     byte\[\] bytes = data.getBytes();    
  114.     byte\[\] bcd = ASCII\_To\_BCD(bytes, bytes.length);    
  115.     //System.err.println(bcd.length);    
  116.     //如果密文长度大于模长则要分组解密    
  117.     String ming = "";    
  118.     byte\[\]\[\] arrays = splitArray(bcd, key\_len);    
  119.     for(byte\[\] arr : arrays)\{    
  120.         ming += new String(cipher.doFinal(arr));    
  121.     \}    
  122.     return ming;    
  123. \}    
  126. /\*\*   
  127.  \* ASCII码转BCD码   
  128.  \*    
  129.  \*/    
  130. public static byte\[\] ASCII\_To\_BCD(byte\[\] ascii, int asc\_len) \{    
  131.     byte\[\] bcd = new byte\[asc\_len / 2\];    
  132.     int j = 0;    
  133.     for (int i = 0; i < (asc\_len + 1) / 2; i++) \{    
  134.         bcd\[i\] = asc\_to\_bcd(ascii\[j++\]);    
  135.         bcd\[i\] = (byte) (((j >= asc\_len) ? 0x00 : asc\_to\_bcd(ascii\[j++\])) + (bcd\[i\] << 4));    
  136.     \}    
  137.     return bcd;    
  138. \}    
  139. public static byte asc\_to\_bcd(byte asc) \{    
  140.     byte bcd;    
  142.     if ((asc >= '0') && (asc <= '9'))    
  143.         bcd = (byte) (asc - '0');    
  144.     else if ((asc >= 'A') && (asc <= 'F'))    
  145.         bcd = (byte) (asc - 'A' + 10);    
  146.     else if ((asc >= 'a') && (asc <= 'f'))    
  147.         bcd = (byte) (asc - 'a' + 10);    
  148.     else    
  149.         bcd = (byte) (asc - 48);    
  150.     return bcd;    
  151. \}    
  152. /\*\*   
  153.  \* BCD转字符串   
  154.  \*/    
  155. public static String bcd2Str(byte\[\] bytes) \{    
  156.     char temp\[\] = new char\[bytes.length \* 2\], val;    
  158.     for (int i = 0; i < bytes.length; i++) \{    
  159.         val = (char) (((bytes\[i\] & 0xf0) >> 4) & 0x0f);    
  160.         temp\[i \* 2\] = (char) (val > 9 ? val + 'A' - 10 : val + '0');    
  162.         val = (char) (bytes\[i\] & 0x0f);    
  163.         temp\[i \* 2 + 1\] = (char) (val > 9 ? val + 'A' - 10 : val + '0');    
  164.     \}    
  165.     return new String(temp);    
  166. \}    
  167. /\*\*   
  168.  \* 拆分字符串   
  169.  \*/    
  170. public static String\[\] splitString(String string, int len) \{    
  171.     int x = string.length() / len;    
  172.     int y = string.length() % len;    
  173.     int z = 0;    
  174.     if (y != 0) \{    
  175.         z = 1;    
  176.     \}    
  177.     String\[\] strings = new String\[x + z\];    
  178.     String str = "";    
  179.     for (int i=0; i<x+z; i++) \{    
  180.         if (i==x+z-1 && y!=0) \{    
  181.             str = string.substring(i\*len, i\*len+y);    
  182.         \}else\{    
  183.             str = string.substring(i\*len, i\*len+len);    
  184.         \}    
  185.         strings\[i\] = str;    
  186.     \}    
  187.     return strings;    
  188. \}    
  189. /\*\*   
  190.  \*拆分数组    
  191.  \*/    
  192. public static byte\[\]\[\] splitArray(byte\[\] data,int len)\{    
  193.     int x = data.length / len;    
  194.     int y = data.length % len;    
  195.     int z = 0;    
  196.     if(y!=0)\{    
  197.         z = 1;    
  198.     \}    
  199.     byte\[\]\[\] arrays = new byte\[x+z\]\[\];    
  200.     byte\[\] arr;    
  201.     for(int i=0; i<x+z; i++)\{    
  202.         arr = new byte\[len\];    
  203.         if(i==x+z-1 && y!=0)\{    
  204.             System.arraycopy(data, i\*len, arr, 0, y);    
  205.         \}else\{    
  206.             System.arraycopy(data, i\*len, arr, 0, len);    
  207.         \}    
  208.         arrays\[i\] = arr;   
  209.     \}    
  210.     return arrays;    
  211. \}  
  212. public static void main(String\[\] args) throws Exception\{  
  213. HashMap<String, Object> map = getKeys();    
  214.     //生成公钥和私钥    
  215.     RSAPublicKey publicKey = (RSAPublicKey) map.get("public");    
  216.     RSAPrivateKey privateKey = (RSAPrivateKey) map.get("private");    
  218.     //模    
  219.     String modulus = publicKey.getModulus().toString();    
  220.     System.out.println("pubkey modulus="+modulus);  
  221.     //公钥指数    
  222.     String public\_exponent = publicKey.getPublicExponent().toString();  
  223.     System.out.println("pubkey exponent="+public\_exponent);  
  224.     //私钥指数    
  225.     String private\_exponent = privateKey.getPrivateExponent().toString();    
  226.     System.out.println("private exponent="+private\_exponent);  
  227.     System.out.println("private modulus="+privateKey.getModulus().toString());  
  228.     //明文    
  229.     String ming = "111";    
  230.     //使用模和指数生成公钥和私钥    
  231.     RSAPublicKey pubKey = RSAUtils.getPublicKey(modulus, public\_exponent);    
  232.     RSAPrivateKey priKey = RSAUtils.getPrivateKey(modulus, private\_exponent);    
  233.     //加密后的密文    
  234.     String mi = RSAUtils.encryptByPublicKey(ming, pubKey);    
  235.     System.err.println("公钥加密：mi="+mi);    
  236.     //解密后的明文    
  237.     String ming2 = RSAUtils.decryptByPrivateKey(mi, priKey);    
  238.     System.err.println("私钥解密：ming2="+ming2);    
  239.     //私钥加密  
  240.     mi = RSAUtils.encryptByPrivateKey(ming, priKey);    
  241.     System.err.println("私钥加密：mi="+mi);    
  242.     //公钥解密  
  243.     ming2 = RSAUtils.decryptByPublicKey(mi, pubKey);    
  244.     System.err.println("公钥解密：ming2="+ming2);   
  245. \}

public static String getPwd(String encrypedPwd, HttpSession session) throws Exception {
System.out.println(“从请求中获得密文：”+encrypedPwd);
String public_modulus=(String)session.getAttribute(“public_modulus”);
String private_exponent=(String)session.getAttribute(“private_exponent”);
RSAPrivateKey priKey = RSAUtils.getPrivateKey(public_modulus, private_exponent);
String pwd=RSAUtils.decryptByPrivateKey(encrypedPwd, priKey);
pwd= java.net.URLDecoder.decode(pwd,”UTF-8”);
System.out.println(“解密后结果：”+pwd);
return pwd;
}

public static String getRandomString(int length) { //length表示生成字符串的长度
String base = “abcdefghijklmnopqrstuvwxyz0123456789_“;
Random random = new Random();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < length; i++) {
int number = random.nextInt(base.length());
sb.append(base.charAt(number));
}
return sb.toString();
}

// public static void setPubkeyAndModulus(HttpServletRequest request,
// Model model) throws NoSuchAlgorithmException {
// RSAModel rsa = getPrivateKeyFromRedis();
// request.getSession().setAttribute(“public_modulus”, rsa.getPublic_modulus());
// request.getSession().setAttribute(“private_exponent”, rsa.getPrivate_exponent());
// model.addAttribute(“publicKeyExponent”, rsa.getPublicKeyExponent());
// model.addAttribute(“publicKeyModulus”, rsa.getPublicKeyModulus());
// }

// public static RSAModel getPrivateKeyFromRedis() {
// RSAModel rsa;
// //从JedisConnectionFactory获得Jedis对象
// JedisConnectionFactory jedisConnectionFactory=(JedisConnectionFactory)SpringUtils.getBean(“jedisConnectionFactory”);
// JedisConnection jedisConnection =jedisConnectionFactory.getConnection();
// Jedis jedis=jedisConnection.getNativeConnection();
// //切换数据库到11
// jedis.select(11);
//
// int max=100;
// int min=1;
// Random random = new Random();
// int s = random.nextInt(max)%(max-min+1) + min;
// String key = “privateKey” + s;
//
// rsa = (RSAModel)SerializeUtil.unserialize(jedis.get(key.getBytes()));
String keyValue = rsa.getPrivate_exponent();
System.out.println(key + “ “ + keyValue);
System.out.println(“查看”+key + “的剩余生存时间：”+jedis.ttl(key));
//
//
// return rsa;
// }
}

发表评论

表情：
评论列表 （有 0 条评论，289人围观）

还没有评论，来说两句吧...

相关阅读

    相关 RSA加密与解密

    RSA加密与解密 RSA算法的密钥由公钥和私钥组成，公钥用于加密，私钥用于解密。顾名思义，公钥就是可以进行公开的密钥，一般可以公开给你的合作伙伴；私钥就是私有的，也就是只

    骑猪看日落骑猪看日落/ 0 赞/ 387 阅读

    相关 JS-RSA加密解密

    　　在上一篇文章《Java使用RSA加密解密签名及校验》中，用java实现加密解密，但是在实际应用中，如前端页面用户输入的密码传输给后台服务前，需加密，也就是公钥加密，私钥解密

    朱雀朱雀/ 0 赞/ 515 阅读