关键词搜索

源码搜索 ×
×

java之RSA和Base64加密帮助类

发布2017-07-24浏览2745次

详情内容

1、RSAUtils.java类

 

  1. package com.sangfor.vpn.client.service.utils;
  2. import java.io.BufferedReader;  
  3. import java.io.ByteArrayOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.io.InputStreamReader;  
  7. import java.math.BigInteger;  
  8. import java.security.KeyFactory;  
  9. import java.security.KeyPair;  
  10. import java.security.KeyPairGenerator;  
  11. import java.security.NoSuchAlgorithmException;  
  12. import java.security.PrivateKey;  
  13. import java.security.PublicKey;  
  14. import java.security.interfaces.RSAPrivateKey;  
  15. import java.security.interfaces.RSAPublicKey;  
  16. import java.security.spec.InvalidKeySpecException;  
  17. import java.security.spec.PKCS8EncodedKeySpec;  
  18. import java.security.spec.RSAPublicKeySpec;  
  19. import java.security.spec.X509EncodedKeySpec;  
  20.   
  21. import javax.crypto.Cipher;  
  22.   
  23. /** 
  24.  * Created by wk on 2017https://cdn.jxasp.com:9143/image/2/14. 
  25.  */  
  26.   
  27. public class RSAUtils {  
  28.     private static String RSA = "RSA";  
  29.     /** *//**  
  30.      * RSA最大加密明文大小  
  31.      */    
  32.     private static final int MAX_ENCRYPT_BLOCK = 117;    
  33.     /** 
  34.      * 随机生成RSA密钥对(默认密钥长度为1024) 
  35.      * 
  36.      * @return 
  37.      */  
  38.     public static KeyPair generateRSAKeyPair()  
  39.     {  
  40.         return generateRSAKeyPair(1024);  
  41.     }  
  42.   
  43.     /** 
  44.      * 随机生成RSA密钥对 
  45.      * 
  46.      * @param keyLength 
  47.      *            密钥长度，范围：512～2048<br> 
  48.      *            一般1024 
  49.      * @return 
  50.      */  
  51.     public static KeyPair generateRSAKeyPair(int keyLength)  
  52.     {  
  53.         try  
  54.         {  
  55.             KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);  
  56.             kpg.initialize(keyLength);  
  57.             return kpg.genKeyPair();  
  58.         } catch (NoSuchAlgorithmException e)  
  59.         {  
  60.             e.printStackTrace();  
  61.             return null;  
  62.         }  
  63.     }  
  64.   
  65.     /** 
  66.      * 用公钥加密 <br> 
  67.      * 每次加密的字节数，不能超过密钥的长度值减去11 
  68.      * 
  69.      * @param data 
  70.      *            需加密数据的byte数据 
  71.      * @param publicKey 公钥 
  72.      * @return 加密后的byte型数据 
  73.      */  
  74.     public static byte[] encryptData(byte[] data, PublicKey publicKey)  
  75.     {  
  76.           
  77.         try  
  78.         {  
  79.             Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");  
  80.             // 编码前设定编码方式及密钥  
  81.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
  82.             // 传入编码数据并返回编码结果  
  83.             int inputLen = data.length;    
  84.             ByteArrayOutputStream out = new ByteArrayOutputStream();    
  85.             int offSet = 0;    
  86.             byte[] cache;    
  87.             int i = 0;    
  88.             // 对数据分段加密    
  89.             while (inputLen - offSet > 0) {    
  90.                 if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {    
  91.                     cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);    
  92.                 } else {    
  93.                     cache = cipher.doFinal(data, offSet, inputLen - offSet);    
  94.                 }    
  95.                 out.write(cache, 0, cache.length);    
  96.                 i++;    
  97.                 offSet = i * MAX_ENCRYPT_BLOCK;    
  98.             }    
  99.             byte[] encryptedData = out.toByteArray();    
  100.             out.close();    
  101.             return encryptedData;    
  102.         } catch (Exception e)  
  103.         {  
  104.             e.printStackTrace();  
  105.             return null;  
  106.         }  
  107.     }  
  108.   
  109.     /** 
  110.      * 用私钥解密 
  111.      * 
  112.      * @param encryptedData 
  113.      *            经过encryptedData()加密返回的byte数据 
  114.      * @param privateKey 
  115.      *            私钥 
  116.      * @return 
  117.      */  
  118.     public static byte[] decryptData(byte[] encryptedData, PrivateKey privateKey)  
  119.     {  
  120.         try  
  121.         {  
  122.             Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");  
  123.             cipher.init(Cipher.DECRYPT_MODE, privateKey);  
  124.             return cipher.doFinal(encryptedData);  
  125.         } catch (Exception e)  
  126.         {     
  127.             e.printStackTrace();  
  128.             return null;  
  129.         }  
  130.     }  
  131.   
  132.     /** 
  133.      * 通过公钥byte[](publicKey.getEncoded())将公钥还原，适用于RSA算法 
  134.      * 
  135.      * @param keyBytes 
  136.      * @return 
  137.      * @throws NoSuchAlgorithmException 
  138.      * @throws InvalidKeySpecException 
  139.      */  
  140.     public static PublicKey getPublicKey(byte[] keyBytes) throws NoSuchAlgorithmException,  
  141.             InvalidKeySpecException  
  142.     {  
  143.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);  
  144.         KeyFactory keyFactory = KeyFactory.getInstance(RSA);  
  145.         PublicKey publicKey = keyFactory.generatePublic(keySpec);  
  146.         return publicKey;  
  147.     }  
  148.   
  149.     /** 
  150.      * 通过私钥byte[]将公钥还原，适用于RSA算法 
  151.      * 
  152.      * @param keyBytes 
  153.      * @return 
  154.      * @throws NoSuchAlgorithmException 
  155.      * @throws InvalidKeySpecException 
  156.      */  
  157.     public static PrivateKey getPrivateKey(byte[] keyBytes) throws NoSuchAlgorithmException,  
  158.             InvalidKeySpecException  
  159.     {  
  160.         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);  
  161.         KeyFactory keyFactory = KeyFactory.getInstance(RSA);  
  162.         PrivateKey privateKey = keyFactory.generatePrivate(keySpec);  
  163.         return privateKey;  
  164.     }  
  165.   
  166.     /** 
  167.      * 使用N、e值还原公钥 
  168.      * 
  169.      * @param modulus 
  170.      * @param publicExponent 
  171.      * @return 
  172.      * @throws NoSuchAlgorithmException 
  173.      * @throws InvalidKeySpecException 
  174.      */  
  175.     public static PublicKey getPublicKey(String modulus, String publicExponent)  
  176.             throws NoSuchAlgorithmException, InvalidKeySpecException  
  177.     {  
  178.         BigInteger bigIntModulus = new BigInteger(modulus);  
  179.         BigInteger bigIntPrivateExponent = new BigInteger(publicExponent);  
  180.         RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);  
  181.         KeyFactory keyFactory = KeyFactory.getInstance(RSA);  
  182.         PublicKey publicKey = keyFactory.generatePublic(keySpec);  
  183.         return publicKey;  
  184.     }  
  185.   
  186.     /** 
  187.      * 使用N、d值还原私钥 
  188.      * 
  189.      * @param modulus 
  190.      * @param privateExponent 
  191.      * @return 
  192.      * @throws NoSuchAlgorithmException 
  193.      * @throws InvalidKeySpecException 
  194.      */  
  195.     public static PrivateKey getPrivateKey(String modulus, String privateExponent)  
  196.             throws NoSuchAlgorithmException, InvalidKeySpecException  
  197.     {  
  198.         BigInteger bigIntModulus = new BigInteger(modulus);  
  199.         BigInteger bigIntPrivateExponent = new BigInteger(privateExponent);  
  200.         RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);  
  201.         KeyFactory keyFactory = KeyFactory.getInstance(RSA);  
  202.         PrivateKey privateKey = keyFactory.generatePrivate(keySpec);  
  203.         return privateKey;  
  204.     }  
  205.   
  206.     /** 
  207.      * 从字符串中加载公钥 
  208.      * 
  209.      * @param publicKeyStr 
  210.      *            公钥数据字符串 
  211.      * @throws Exception 
  212.      *             加载公钥时产生的异常 
  213.      */  
  214.     public static PublicKey loadPublicKey(String publicKeyStr) throws Exception  
  215.     {  
  216.         try  
  217.         {  
  218.             byte[] buffer = Base64Utils.decode(publicKeyStr);  
  219.             KeyFactory keyFactory = KeyFactory.getInstance(RSA);  
  220.             X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);  
  221.             return (RSAPublicKey) keyFactory.generatePublic(keySpec);  
  222.         } catch (NoSuchAlgorithmException e)  
  223.         {  
  224.             throw new Exception("无此算法");  
  225.         } catch (InvalidKeySpecException e)  
  226.         {  
  227.             throw new Exception("公钥非法");  
  228.         } catch (NullPointerException e)  
  229.         {  
  230.             throw new Exception("公钥数据为空");  
  231.         }  
  232.     }  
  233.   
  234.     /** 
  235.      * 从字符串中加载私钥<br> 
  236.      * 加载时使用的是PKCS8EncodedKeySpec（PKCS#8编码的Key指令）。 
  237.      * 
  238.      * @param privateKeyStr 
  239.      * @return 
  240.      * @throws Exception 
  241.      */  
  242.     public static PrivateKey loadPrivateKey(String privateKeyStr) throws Exception  
  243.     {  
  244.         try  
  245.         {  
  246.             byte[] buffer = Base64Utils.decode(privateKeyStr);  
  247.             // X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);  
  248.             PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);  
  249.             KeyFactory keyFactory = KeyFactory.getInstance(RSA);  
  250.             return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);  
  251.         } catch (NoSuchAlgorithmException e)  
  252.         {  
  253.             throw new Exception("无此算法");  
  254.         } catch (InvalidKeySpecException e)  
  255.         {  
  256.             throw new Exception("私钥非法");  
  257.         } catch (NullPointerException e)  
  258.         {  
  259.             throw new Exception("私钥数据为空");  
  260.         }  
  261.     }  
  262.   
  263.     /** 
  264.      * 从文件中输入流中加载公钥 
  265.      * 
  266.      * @param in 
  267.      *            公钥输入流 
  268.      * @throws Exception 
  269.      *             加载公钥时产生的异常 
  270.      */  
  271.     public static PublicKey loadPublicKey(InputStream in) throws Exception  
  272.     {  
  273.         try  
  274.         {  
  275.             return loadPublicKey(readKey(in));  
  276.         } catch (IOException e)  
  277.         {  
  278.             throw new Exception("公钥数据流读取错误");  
  279.         } catch (NullPointerException e)  
  280.         {  
  281.             throw new Exception("公钥输入流为空");  
  282.         }  
  283.     }  
  284.   
  285.     /** 
  286.      * 从文件中加载私钥 
  287.      * 
  288.      * @param in 
  289.      *            私钥文件名 
  290.      * @return 是否成功 
  291.      * @throws Exception 
  292.      */  
  293.     public static PrivateKey loadPrivateKey(InputStream in) throws Exception  
  294.     {  
  295.         try  
  296.         {  
  297.             return loadPrivateKey(readKey(in));  
  298.         } catch (IOException e)  
  299.         {  
  300.             throw new Exception("私钥数据读取错误");  
  301.         } catch (NullPointerException e)  
  302.         {  
  303.             throw new Exception("私钥输入流为空");  
  304.         }  
  305.     }  
  306.   
  307.     /** 
  308.      * 读取密钥信息 
  309.      * 
  310.      * @param in 
  311.      * @return 
  312.      * @throws IOException 
  313.      */  
  314.     private static String readKey(InputStream in) throws IOException  
  315.     {  
  316.         BufferedReader br = new BufferedReader(new InputStreamReader(in));  
  317.         String readLine = null;  
  318.         StringBuilder sb = new StringBuilder();  
  319.         while ((readLine = br.readLine()) != null)  
  320.         {  
  321.             if (readLine.charAt(0) == '-')  
  322.             {  
  323.                 continue;  
  324.             } else  
  325.             {  
  326.                 sb.append(readLine);  
  327.                 sb.append('\r');  
  328.             }  
  329.         }  
  330.   
  331.         return sb.toString();  
  332.     }  
  333.   
  334.     /** 
  335.      * 打印公钥信息 
  336.      * 
  337.      * @param publicKey 
  338.      */  
  339.     public static void printPublicKeyInfo(PublicKey publicKey)  
  340.     {  
  341.         RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;  
  342.         System.out.println("----------RSAPublicKey----------");  
  343.         System.out.println("Modulus.length=" + rsaPublicKey.getModulus().bitLength());  
  344.         System.out.println("Modulus=" + rsaPublicKey.getModulus().toString());  
  345.         System.out.println("PublicExponent.length=" + rsaPublicKey.getPublicExponent().bitLength());  
  346.         System.out.println("PublicExponent=" + rsaPublicKey.getPublicExponent().toString());  
  347.     }  
  348.   
  349.     public static void printPrivateKeyInfo(PrivateKey privateKey)  
  350.     {  
  351.         RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) privateKey;  
  352.         System.out.println("----------RSAPrivateKey ----------");  
  353.         System.out.println("Modulus.length=" + rsaPrivateKey.getModulus().bitLength());  
  354.         System.out.println("Modulus=" + rsaPrivateKey.getModulus().toString());  
  355.         System.out.println("PrivateExponent.length=" + rsaPrivateKey.getPrivateExponent().bitLength());  
  356.         System.out.println("PrivatecExponent=" + rsaPrivateKey.getPrivateExponent().toString());  
  357.   
  358.     }  
  359. }

 

 

 

 

 

 

 

2、Base64Utils.java类

 

  1. package com.sangfor.vpn.client.service.utils;
  2.  
  3. import java.io.UnsupportedEncodingException;  
  4.  
  5. /** 
  6.  * Created by wk on 2017https://cdn.jxasp.com:9143/image/2/14. 
  7.  */  
  8.   
  9. public class Base64Utils {  
  10.     private static char[] base64EncodeChars = new char[]  
  11.             { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',  
  12.                     'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',  
  13.                     'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5',  
  14.                     '6', '7', '8', '9', '+', '/' };  
  15.     private static byte[] base64DecodeChars = new byte[]  
  16.             { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  
  17.                     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53,  
  18.                     54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,  
  19.                     12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29,  
  20.                     30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1,  
  21.                     -1, -1, -1 };  
  22.   
  23.     /** 
  24.      * 加密 
  25.      * 
  26.      * @param data 
  27.      * @return 
  28.      */  
  29.     public static String encode(byte[] data)  
  30.     {  
  31.         StringBuffer sb = new StringBuffer();  
  32.         int len = data.length;  
  33.         int i = 0;  
  34.         int b1, b2, b3;  
  35.         while (i < len)  
  36.         {  
  37.             b1 = data[i++] & 0xff;  
  38.             if (i == len)  
  39.             {  
  40.                 sb.append(base64EncodeChars[b1 >>> 2]);  
  41.                 sb.append(base64EncodeChars[(b1 & 0x3) << 4]);  
  42.                 sb.append("==");  
  43.                 break;  
  44.             }  
  45.             b2 = data[i++] & 0xff;  
  46.             if (i == len)  
  47.             {  
  48.                 sb.append(base64EncodeChars[b1 >>> 2]);  
  49.                 sb.append(base64EncodeChars[((b1 & 0x03) << 4) | ((b2 & 0xf0) >>> 4)]);  
  50.                 sb.append(base64EncodeChars[(b2 & 0x0f) << 2]);  
  51.                 sb.append("=");  
  52.                 break;  
  53.             }  
  54.             b3 = data[i++] & 0xff;  
  55.             sb.append(base64EncodeChars[b1 >>> 2]);  
  56.             sb.append(base64EncodeChars[((b1 & 0x03) << 4) | ((b2 & 0xf0) >>> 4)]);  
  57.             sb.append(base64EncodeChars[((b2 & 0x0f) << 2) | ((b3 & 0xc0) >>> 6)]);  
  58.             sb.append(base64EncodeChars[b3 & 0x3f]);  
  59.         }  
  60.         return sb.toString();  
  61.     }  
  62.   
  63.     /** 
  64.      * 解密 
  65.      * 
  66.      * @param str 
  67.      * @return 
  68.      */  
  69.     public static byte[] decode(String str)  
  70.     {  
  71.         try  
  72.         {  
  73.             return decodePrivate(str);  
  74.         } catch (UnsupportedEncodingException e)  
  75.         {  
  76.             e.printStackTrace();  
  77.         }  
  78.         return new byte[]  
  79.                 {};  
  80.     }  
  81.   
  82.     private static byte[] decodePrivate(String str) throws UnsupportedEncodingException  
  83.     {  
  84.         StringBuffer sb = new StringBuffer();  
  85.         byte[] data = null;  
  86.         data = str.getBytes("US-ASCII");  
  87.         int len = data.length;  
  88.         int i = 0;  
  89.         int b1, b2, b3, b4;  
  90.         while (i < len)  
  91.         {  
  92.   
  93.             do  
  94.             {  
  95.                 b1 = base64DecodeChars[data[i++]];  
  96.             } while (i < len && b1 == -1);  
  97.             if (b1 == -1)  
  98.                 break;  
  99.   
  100.             do  
  101.             {  
  102.                 b2 = base64DecodeChars[data[i++]];  
  103.             } while (i < len && b2 == -1);  
  104.             if (b2 == -1)  
  105.                 break;  
  106.             sb.append((char) ((b1 << 2) | ((b2 & 0x30) >>> 4)));  
  107.   
  108.             do  
  109.             {  
  110.                 b3 = data[i++];  
  111.                 if (b3 == 61)  
  112.                     return sb.toString().getBytes("iso8859-1");  
  113.                 b3 = base64DecodeChars[b3];  
  114.             } while (i < len && b3 == -1);  
  115.             if (b3 == -1)  
  116.                 break;  
  117.             sb.append((char) (((b2 & 0x0f) << 4) | ((b3 & 0x3c) >>> 2)));  
  118.   
  119.             do  
  120.             {  
  121.                 b4 = data[i++];  
  122.                 if (b4 == 61)  
  123.                     return sb.toString().getBytes("iso8859-1");  
  124.                 b4 = base64DecodeChars[b4];  
  125.             } while (i < len && b4 == -1);  
  126.             if (b4 == -1)  
  127.                 break;  
  128.             sb.append((char) (((b3 & 0x03) << 6) | b4));  
  129.         }  
  130.         return sb.toString().getBytes("iso8859-1");  
  131.     }  
  132.   
  133. }

 

 

 

 

3、SecurityUtils类

 

  1. package com.sangfor.vpn.client.service.utils;
  2.  
  3. import java.io.FileInputStream;  
  4. import java.io.FileNotFoundException;  
  5. import java.io.InputStream;  
  6. import java.security.PrivateKey;  
  7. import java.security.PublicKey;  
  8.   
  9. public class SecurityUtils {  
  10.     /** 
  11.      * 解密 
  12.      * @param cipherText 密文 
  13.      * @return 返回解密后的字符串 
  14.      * @throws Exception  
  15.      */  
  16.     public static String decrypt(String cipherText) throws Exception{  
  17.          // 从文件中得到私钥  
  18.         FileInputStream inPrivate = new FileInputStream(  
  19.                 SecurityUtils.class.getClassLoader().getResource("").getPath() + "/pkcs8_private_key.pem");  
  20.         PrivateKey privateKey = RSAUtils.loadPrivateKey(inPrivate);  
  21.         byte[] decryptByte = RSAUtils.decryptData(Base64Utils.decode(cipherText), privateKey);  
  22.         String decryptStr = new String(decryptByte,"utf-8");  
  23.         return decryptStr;  
  24.     }  
  25.     /** 
  26.      * 加密 
  27.      * @param plainTest 明文 
  28.      * @return  返回加密后的密文 
  29.      * @throws Exception  
  30.      */  
  31.     public static String encrypt(String plainTest) throws Exception{  
  32.         PublicKey publicKey = RSAUtils.loadPublicKey(plainTest);  
  33.         // 加密  
  34.         byte[] encryptByte = RSAUtils.encryptData(plainTest.getBytes(), publicKey);  
  35.         String afterencrypt = Base64Utils.encode(encryptByte);  
  36.         return afterencrypt;  
  37.     }  
  38.     
  39.     /** 
  40.      * 加密 
  41.      * @param plainTest 明文 
  42.      * @return  返回加密后的密文 
  43.      * @throws Exception  
  44.      */  
  45.     public static String encrypt(String plainTest, String key) throws Exception{  
  46.         PublicKey publicKey = RSAUtils.loadPublicKey(key);  
  47.         // 加密  
  48.         byte[] encryptByte = RSAUtils.encryptData(plainTest.getBytes(), publicKey);  
  49.         String afterencrypt = Base64Utils.encode(encryptByte);  
  50.         return afterencrypt;  
  51.     }  
  52. }

 

 

 

 

 

 

 

 

 

 

 

相关技术文章

最新源码

下载排行榜
点击QQ咨询
开通会员
返回顶部
×
微信扫码支付 元
微信扫码支付
确定支付下载
请使用微信描二维码支付
×

提示信息

×

选择支付方式

  • 微信支付
  • 支付宝付款
确定支付下载