RSA加密解密

今天药忘吃喽~ 2022-08-02 07:30 156阅读 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<String, Object> getKeys() throws NoSuchAlgorithmException\{    
        HashMap<String, Object> map = new HashMap<String, Object>();    
        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;    
        \}    
    \}    
    
    /\*\*   
     \* 使用模和指数生成RSA私钥   
       
     \* /None/NoPadding】   
     \*    
     \* @param modulus   
     \*            模   
     \* @param exponent   
     \*            指数   
     \* @return   
     \*/    
    public static RSAPrivateKey getPrivateKey(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());    
            RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);    
            return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);    
        \} catch (Exception e) \{    
            e.printStackTrace();    
            return null;    
        \}    
    \}    
    
    /\*\*   
     \* 公钥加密   
     \*    
     \* @param data   
     \* @param publicKey   
     \* @return   
     \* @throws Exception   
     \*/    
    public static String encryptByPublicKey(String data, RSAPublicKey publicKey)    
            throws Exception \{    
        Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());    
        cipher.init(Cipher.ENCRYPT\_MODE, publicKey);    
        // 模长    
        int key\_len = publicKey.getModulus().bitLength() / 8;    
        // 加密数据长度 <= 模长-11    
        String\[\] datas = splitString(data, key\_len - 11);    
        String mi = "";    
        //如果明文长度大于模长-11则要分组加密    
        for (String s : datas) \{    
            mi += bcd2Str(cipher.doFinal(s.getBytes()));    
        \}    
        return mi;    
    \}    
    
    /\*\*   
     \* 私钥解密   
     \*    
     \* @param data   
     \* @param privateKey   
     \* @return   
     \* @throws Exception   
     \*/    
    public static String decryptByPrivateKey(String data, RSAPrivateKey privateKey)    
            throws Exception \{    
        Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());    
        cipher.init(Cipher.DECRYPT\_MODE, privateKey);    
        //模长    
        int key\_len = privateKey.getModulus().bitLength() / 8;    
        byte\[\] bytes = data.getBytes();    
        byte\[\] bcd = ASCII\_To\_BCD(bytes, bytes.length);    
        //System.err.println(bcd.length);    
        //如果密文长度大于模长则要分组解密    
        String ming = "";    
        byte\[\]\[\] arrays = splitArray(bcd, key\_len);    
        for(byte\[\] arr : arrays)\{    
            ming += new String(cipher.doFinal(arr));    
        \}    
        return ming;    
    \}    
      
    /\*\*   
     \* 私钥加密   
     \*    
     \* @param data   
     \* @param publicKey   
     \* @return   
     \* @throws Exception   
     \*/    
    public static String encryptByPrivateKey(String data, RSAPrivateKey privateKey)    
            throws Exception \{    
        Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());    
        cipher.init(Cipher.ENCRYPT\_MODE, privateKey);    
        // 模长    
        int key\_len = privateKey.getModulus().bitLength() / 8;    
        // 加密数据长度 <= 模长-11    
        String\[\] datas = splitString(data, key\_len - 11);    
        String mi = "";    
        //如果明文长度大于模长-11则要分组加密    
        for (String s : datas) \{    
            mi += bcd2Str(cipher.doFinal(s.getBytes()));    
        \}    
        return mi;    
    \}    
      
    /\*\*   
     \* 公钥解密   
     \*    
     \* @param data   
     \* @param privateKey   
     \* @return   
     \* @throws Exception   
     \*/    
    public static String decryptByPublicKey(String data, RSAPublicKey publicKey)    
            throws Exception \{    
        Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());    
        cipher.init(Cipher.DECRYPT\_MODE, publicKey);    
        //模长    
        int key\_len = publicKey.getModulus().bitLength() / 8;    
        byte\[\] bytes = data.getBytes();    
        byte\[\] bcd = ASCII\_To\_BCD(bytes, bytes.length);    
        //System.err.println(bcd.length);    
        //如果密文长度大于模长则要分组解密    
        String ming = "";    
        byte\[\]\[\] arrays = splitArray(bcd, key\_len);    
        for(byte\[\] arr : arrays)\{    
            ming += new String(cipher.doFinal(arr));    
        \}    
        return ming;    
    \}    
      
      
    /\*\*   
     \* ASCII码转BCD码   
     \*    
     \*/    
    public static byte\[\] ASCII\_To\_BCD(byte\[\] ascii, int asc\_len) \{    
        byte\[\] bcd = new byte\[asc\_len / 2\];    
        int j = 0;    
        for (int i = 0; i < (asc\_len + 1) / 2; i++) \{    
            bcd\[i\] = asc\_to\_bcd(ascii\[j++\]);    
            bcd\[i\] = (byte) (((j >= asc\_len) ? 0x00 : asc\_to\_bcd(ascii\[j++\])) + (bcd\[i\] << 4));    
        \}    
        return bcd;    
    \}    
    public static byte asc\_to\_bcd(byte asc) \{    
        byte bcd;    
    
        if ((asc >= '0') && (asc <= '9'))    
            bcd = (byte) (asc - '0');    
        else if ((asc >= 'A') && (asc <= 'F'))    
            bcd = (byte) (asc - 'A' + 10);    
        else if ((asc >= 'a') && (asc <= 'f'))    
            bcd = (byte) (asc - 'a' + 10);    
        else    
            bcd = (byte) (asc - 48);    
        return bcd;    
    \}    
    /\*\*   
     \* BCD转字符串   
     \*/    
    public static String bcd2Str(byte\[\] bytes) \{    
        char temp\[\] = new char\[bytes.length \* 2\], val;    
    
        for (int i = 0; i < bytes.length; i++) \{    
            val = (char) (((bytes\[i\] & 0xf0) >> 4) & 0x0f);    
            temp\[i \* 2\] = (char) (val > 9 ? val + 'A' - 10 : val + '0');    
    
            val = (char) (bytes\[i\] & 0x0f);    
            temp\[i \* 2 + 1\] = (char) (val > 9 ? val + 'A' - 10 : val + '0');    
        \}    
        return new String(temp);    
    \}    
    /\*\*   
     \* 拆分字符串   
     \*/    
    public static String\[\] splitString(String string, int len) \{    
        int x = string.length() / len;    
        int y = string.length() % len;    
        int z = 0;    
        if (y != 0) \{    
            z = 1;    
        \}    
        String\[\] strings = new String\[x + z\];    
        String str = "";    
        for (int i=0; i<x+z; i++) \{    
            if (i==x+z-1 && y!=0) \{    
                str = string.substring(i\*len, i\*len+y);    
            \}else\{    
                str = string.substring(i\*len, i\*len+len);    
            \}    
            strings\[i\] = str;    
        \}    
        return strings;    
    \}    
    /\*\*   
     \*拆分数组    
     \*/    
    public static byte\[\]\[\] splitArray(byte\[\] data,int len)\{    
        int x = data.length / len;    
        int y = data.length % len;    
        int z = 0;    
        if(y!=0)\{    
            z = 1;    
        \}    
        byte\[\]\[\] arrays = new byte\[x+z\]\[\];    
        byte\[\] arr;    
        for(int i=0; i<x+z; i++)\{    
            arr = new byte\[len\];    
            if(i==x+z-1 && y!=0)\{    
                System.arraycopy(data, i\*len, arr, 0, y);    
            \}else\{    
                System.arraycopy(data, i\*len, arr, 0, len);    
            \}    
            arrays\[i\] = arr;   
        \}    
        return arrays;    
    \}  
    public static void main(String\[\] args) throws Exception\{  
    HashMap<String, Object> map = getKeys();    
        //生成公钥和私钥    
        RSAPublicKey publicKey = (RSAPublicKey) map.get("public");    
        RSAPrivateKey privateKey = (RSAPrivateKey) map.get("private");    
            
        //模    
        String modulus = publicKey.getModulus().toString();    
        System.out.println("pubkey modulus="+modulus);  
        //公钥指数    
        String public\_exponent = publicKey.getPublicExponent().toString();  
        System.out.println("pubkey exponent="+public\_exponent);  
        //私钥指数    
        String private\_exponent = privateKey.getPrivateExponent().toString();    
        System.out.println("private exponent="+private\_exponent);  
        System.out.println("private modulus="+privateKey.getModulus().toString());  
        //明文    
        String ming = "111";    
        //使用模和指数生成公钥和私钥    
        RSAPublicKey pubKey = RSAUtils.getPublicKey(modulus, public\_exponent);    
        RSAPrivateKey priKey = RSAUtils.getPrivateKey(modulus, private\_exponent);    
        //加密后的密文    
        String mi = RSAUtils.encryptByPublicKey(ming, pubKey);    
        System.err.println("公钥加密：mi="+mi);    
        //解密后的明文    
        String ming2 = RSAUtils.decryptByPrivateKey(mi, priKey);    
        System.err.println("私钥解密：ming2="+ming2);    
        //私钥加密  
        mi = RSAUtils.encryptByPrivateKey(ming, priKey);    
        System.err.println("私钥加密：mi="+mi);    
        //公钥解密  
        ming2 = RSAUtils.decryptByPublicKey(mi, pubKey);    
        System.err.println("公钥解密：ming2="+ming2);   
    \}  
      
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;  
// \}  
\}