2. public class RsaUtil {
    3.     private static final String KEY_ALGORITHM = "RSA";
    4.     private static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    6.     private static final String PUBLIC_KEY = "RSAPublicKey";
    7.     private static final String PRIVATE_KEY = "RSAPrivateKey";
    9.     private static byte[] decryptBASE64(String key) {
    10.         return Base64.getDecoder().decode(key);
    11.     }
    13.     public static String encryptBASE64(byte[] bytes) {
    14.         return Base64.getEncoder().encodeToString(bytes);
    15.     }
    17.     /**
    18.      * 用私钥对信息生成数字签名
    19.      *
    20.      * @param data       加密数据
    21.      * @param privateKey 私钥
    22.      * @return
    23.      * @throws Exception
    24.      */
    25.     public static String sign(byte[] data, String privateKey) throws Exception {
    26.         // 解密由base64编码的私钥
    27.         byte[] keyBytes = decryptBASE64(privateKey);
    28.         // 构造PKCS8EncodedKeySpec对象
    29.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
    30.         // KEY_ALGORITHM 指定的加密算法
    31.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    32.         // 取私钥匙对象
    33.         PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
    34.         // 用私钥对信息生成数字签名
    35.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
    36.         signature.initSign(priKey);
    37.         signature.update(data);
    38.         return encryptBASE64(signature.sign());
    39.     }
    41.     /**
    42.      * 校验数字签名
    43.      *
    44.      * @param data      加密数据
    45.      * @param publicKey 公钥
    46.      * @param sign      数字签名
    47.      * @return 校验成功返回true 失败返回false
    48.      * @throws Exception
    49.      */
    50.     public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
    51.         // 解密由base64编码的公钥
    52.         byte[] keyBytes = decryptBASE64(publicKey);
    53.         // 构造X509EncodedKeySpec对象
    54.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
    55.         // KEY_ALGORITHM 指定的加密算法
    56.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    57.         // 取公钥匙对象
    58.         PublicKey pubKey = keyFactory.generatePublic(keySpec);
    59.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
    60.         signature.initVerify(pubKey);
    61.         signature.update(data);
    62.         // 验证签名是否正常
    63.         return signature.verify(decryptBASE64(sign));
    64.     }
    66.     public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception {
    67.         // 对密钥解密
    68.         byte[] keyBytes = decryptBASE64(key);
    69.         // 取得私钥
    70.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
    71.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    72.         Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
    73.         // 对数据解密
    74.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    75.         cipher.init(Cipher.DECRYPT_MODE, privateKey);
    76.         return cipher.doFinal(data);
    77.     }
    79.     /**
    80.      * 解密<br>
    81.      * 用私钥解密
    82.      *
    83.      * @param data
    84.      * @param key
    85.      * @return
    86.      * @throws Exception
    87.      */
    88.     public static byte[] decryptByPrivateKey(String data, String key) throws Exception {
    89.         return decryptByPrivateKey(decryptBASE64(data), key);
    90.     }
    92.     /**
    93.      * 解密<br>
    94.      * 用公钥解密
    95.      *
    96.      * @param data
    97.      * @param key
    98.      * @return
    99.      * @throws Exception
    100.      */
    101.     public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception {
    102.         // 对密钥解密
    103.         byte[] keyBytes = decryptBASE64(key);
    104.         // 取得公钥
    105.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
    106.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    107.         Key publicKey = keyFactory.generatePublic(x509KeySpec);
    108.         // 对数据解密
    109.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    110.         cipher.init(Cipher.DECRYPT_MODE, publicKey);
    111.         return cipher.doFinal(data);
    112.     }
    114.     /**
    115.      * 加密<br>
    116.      * 用公钥加密
    117.      *
    118.      * @param data
    119.      * @param key
    120.      * @return
    121.      * @throws Exception
    122.      */
    123.     public static byte[] encryptByPublicKey(String data, String key) throws Exception {
    124.         // 对公钥解密
    125.         byte[] keyBytes = decryptBASE64(key);
    126.         // 取得公钥
    127.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
    128.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    129.         Key publicKey = keyFactory.generatePublic(x509KeySpec);
    130.         // 对数据加密
    131.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    132.         cipher.init(Cipher.ENCRYPT_MODE, publicKey);
    133.         return cipher.doFinal(data.getBytes("utf-8"));
    134.     }
    136.     /**
    137.      * 加密<br>
    138.      * 用私钥加密
    139.      *
    140.      * @param data
    141.      * @param key
    142.      * @return
    143.      * @throws Exception
    144.      */
    145.     public static byte[] encryptByPrivateKey(byte[] data, String key) throws Exception {
    146.         // 对密钥解密
    147.         byte[] keyBytes = decryptBASE64(key);
    148.         // 取得私钥
    149.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
    150.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    151.         Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
    152.         // 对数据加密
    153.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    154.         cipher.init(Cipher.ENCRYPT_MODE, privateKey);
    155.         return cipher.doFinal(data);
    156.     }
    158.     /**
    159.      * 取得私钥
    160.      *
    161.      * @param keyMap
    162.      * @return
    163.      * @throws Exception
    164.      */
    165.     public static String getPrivateKey(Map<String, Key> keyMap) throws Exception {
    166.         Key key = keyMap.get(PRIVATE_KEY);
    167.         return encryptBASE64(key.getEncoded());
    168.     }
    170.     /**
    171.      * 取得公钥
    172.      *
    173.      * @param keyMap
    174.      * @return
    175.      * @throws Exception
    176.      */
    177.     public static String getPublicKey(Map<String, Key> keyMap) throws Exception {
    178.         Key key = keyMap.get(PUBLIC_KEY);
    179.         return encryptBASE64(key.getEncoded());
    180.     }
    182.     /**
    183.      * 初始化密钥
    184.      *
    185.      * @return
    186.      * @throws Exception
    187.      */
    188.     public static Map<String, Key> initKey() throws Exception {
    189.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    190.         keyPairGen.initialize(2048);
    191.         KeyPair keyPair = keyPairGen.generateKeyPair();
    192.         Map<String, Key> keyMap = new HashMap<String, Key>(2);
    193.         // 公钥
    194.         keyMap.put(PUBLIC_KEY, keyPair.getPublic());
    195.         // 私钥
    196.         keyMap.put(PRIVATE_KEY, keyPair.getPrivate());
    198.         return keyMap;
    199.     }
    201.     public static void main(String[] args) throws Exception {
    202. //        System.out.println(URLEncoder.encode("http://10.19.120.216:8099/idatafusion/"));
    203. //        System.out.println(URLEncoder.encode("http://10.19.120.216:8099/idatafusion/","utf-8"));
    204.        /* Map<String, Key> map = initKey();
    205.         System.out.println(getPublicKey(map));
    206.         System.out.println(getPrivateKey(map));*/
    207. //        System.out.println(Base64.getEncoder().encodeToString(encryptByPublicKey("330621198809143813"
    208. //        ,"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsYcEqcYeD9m3QZoDsNqTmPrbCjIGCKEd+CpV1Jgid94ilYFsnyJ+kKWMn/EfWEGx5JSQF3jrPduXclnZacg9BcoH1AWN0bfsNZOrKE9GF20/QqHkFsZk0wCBcphUagr0z5ShZn4bcRdiFSwgpXnLaEYaeL+hF69ySaY1UJPxLmZTTj63bxC7Q2u+c0GaRgaCqkiDUne7jPw6Dal66yeNFw3QS2MBRHY8+bgeGH3FHJZJQ7acbFl6+M44LniFtamfXodwiZaqSsl3FlxlGFIK68e59Qv6LJArJC5TXUZ1m9gjqrTKl7NpTeUP5Wfeo59eXY1j85hnTnDh3cTOssvWEQIDAQAB")));
    209. //        System.out.println(Base64.getEncoder().encodeToString(encryptByPublicKey("Abc123@@", "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyoKqrJZGLyfo7K38cBub7uR091nns0gZBReeJUwfNqqWZE/iyOV/bklr1NTrrGtdAn8wn34AX5YMsWM9s9M+aQQ5MsVH/SEPngE87Vjt17kcScIDIGgmygLooSRQhqB9ckiykyfYVkGUYCE2XTj10t+dsA57g0GxphPbdCdPze5ZPBM8HyJo/uNZRHh6xqu4Lb6qye2sHNQyz4uX/xcps7AvN2VH/j/wSvU58qnilLtJzu6OwLXUaLECyy9QEMdsy47cs+8UAA2jEvmwp/fUWv23QcudS+YfX48wNejMtWwg9rvdLGzV6ff7LjhtCOq0aBFrEkg5RDCzaVGkhR/azQIDAQAB")));
    211.     }
    212. }