【Java工具类】非对称加密之RSA算法工具类(分段处理)

爱被打了一巴掌 2022-11-13 04:21 657阅读 0赞

### 文章目录 ###

*  RAS工具类
 *  AES工具类

需要注意的是`RSA加密内容是有长度限制的`，1024位密钥可以加密128字节（1024位），不满128字节的使用随机数填充，但是RSA实现中必须要加`随机数（11字节以上）`，所以`明文长度最大为117字节`，然后剩下的加入随机数。这也产生了每次加密结果每一次都不一样的特点。

**如果明文长度超过限制怎么办？**

1.  可以`和对称加密混合使用`，一次一密产生对称加密的密钥，然后使用此密钥进行数据对称加密，再使用RSA私钥对对称密钥加密，一起保存。解密时使用公钥解密出密钥，然后进行数据解密。
2.  可以`分段加密`。将明文按117字节分成多段，加密后再拼接起来。由于每一段密文长度都是128字节，所以解密时按照128字节分段解密。

--------------------

RSA加密内容过长导致抛异常`javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes......`解决方案

1.  是分段进行加密数据，
2.  是使用RSA加密AES的密码，然后使用AES来加密数据。

两者比较推荐使用后者，前者的加密方式确实安全，每次加密解密太慢了，如果使用AES加密速度就快了很多，但是不足够安全，这时候使用RSA来加密一下AES的秘钥，这样就更加的安全了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]

# RAS工具类 #

import lombok.Data;
    import org.springframework.util.Base64Utils;
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.security.*;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.Base64;
    public class RSAHelper { 
    
        /** * 生成的公钥 */
        public static final String PUBLIC_KEY_VALUES = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0bb7yxuvRIWOUxlTbTXE\n" +
                "cKX5f4Q6+BBOf1fYJKic9l6Wf1QPmyt6ML7PywaPH861D7eYoQl0bGNK2fKsgcAG\n" +
                "ZzObG5CpmP8ESnSzqcjltdAgx+neCZQy7yUmXUIhpBEQMN80CNYoasOxeZTdPh2w\n" +
                "zhlmwa27ubkvpINtKUfZbg8sQ5wiDGbLM32ej8z2Rl8DNY4vrusJaNXB7LWaRQm7\n" +
                "4lPhLN2B/hMv/Ktif4iNxUCYDY97Xws2kVVu7ffWkn4rnhiCrTw2XMZRjIJq3a4o\n" +
                "4zGWUhYm0usVOLz+yG22cLSCIDhM8tBXL2f3960l4OIQbSObfQkGnqlmi0Fe686p\n" +
                "gwIDAQAB";
        /** * 生成的私钥钥 */
        public static final String PRIVATE_KEY_VALUES = "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDRtvvLG69EhY5T\n" +
                "GVNtNcRwpfl/hDr4EE5/V9gkqJz2XpZ/VA+bK3owvs/LBo8fzrUPt5ihCXRsY0rZ\n" +
                "8qyBwAZnM5sbkKmY/wRKdLOpyOW10CDH6d4JlDLvJSZdQiGkERAw3zQI1ihqw7F5\n" +
                "lN0+HbDOGWbBrbu5uS+kg20pR9luDyxDnCIMZsszfZ6PzPZGXwM1ji+u6wlo1cHs\n" +
                "tZpFCbviU+Es3YH+Ey/8q2J/iI3FQJgNj3tfCzaRVW7t99aSfiueGIKtPDZcxlGM\n" +
                "gmrdrijjMZZSFibS6xU4vP7IbbZwtIIgOEzy0FcvZ/f3rSXg4hBtI5t9CQaeqWaL\n" +
                "QV7rzqmDAgMBAAECggEBAIpVZ5Y8tso+RvmttQhO9TtRYFirArLrHryFV4Am8RLa\n" +
                "pe9rpbe3YCyTUUIdG3/hvDGX68geEnwEqzVFDGGyJwcgVWpDbHwNi+kJPhH7APuD\n" +
                "RHxaWip7ZXW2Ta4ql0JANyvlr888ZQC4AXOvrJjywNPSkaOkVDZYX4LnZrRaPqSH\n" +
                "j9iVGuKK4nbqbXP1tuLyto6bsn3L2KuwrBthtiDPaZ1cRm3aSu/XND030iSGloW/\n" +
                "/f6vHI3U//cPFPdi8p54nbpGTB0E66D2xbfK5+z9dZYoFDZUdMsloR1JgS4vQErr\n" +
                "17165RS7cpWx2HejiKat6qmNFXkHbREpcLDT+lq91LECgYEA7wqm+mIFIYyXEARc\n" +
                "lKKabCKaufKE+7kyBGpAEyon1lYZHw62dCYkGmuXULam4IAz7TesWsbG5SEgDx/A\n" +
                "jeFSoC6NTyyTzSh1I08UHdOJ4xhAa67GnlJG7WLNZFK+itl7v3VOOlGsAYAxaG5q\n" +
                "kQKQ1mKk6C6oGRpQ0aqKxVhoDc0CgYEA4Je2flPUYs33qy4m09UBFx6Xf91/5LvL\n" +
                "iTtEo+HGcMzxmfeV3sawUwtjHhyippN5lTR80JLbYoEvoUMyKt+N5Jnic206alSH\n" +
                "hujsQnO4LCRHz/XwkHnB8Ncd3J67Uaq9PUPY630NIA/ChBAQchsqntJSdVn65PZf\n" +
                "mw7+hO2WxI8CgYB4eX/qlVhMrlS8R9Z5OvJlKZOdv/LyA0aIHxyoDAkD52TF2F5w\n" +
                "b4CmqC8dCNFWOIbzOanuHlzDwkwsEy6y0ysXfB7QFoFvVsKixwo2dhT6lZByNSX5\n" +
                "STJiFfe6ZlGOHUpXFkIU9nCgWQGNxoiDCS4CPrkqI8mozTCKW0+RYpseyQKBgQCR\n" +
                "cK21UQQQl+Dy8YgjVaTHHABvxTi1HwfHbqIcnnCrS4yJcFOVWIWGwbEGJvUNeiMa\n" +
                "BEtvpip7t7zoaWNrcCmrCBwlM27IvMSnEN8uiVGTBEuc2F9YsABvvl6QKBqV4EN8\n" +
                "ERvAI9MEGDCW5PBBdGY9Q2YyqHpZG1L+Ts9ztYgU8QKBgB7bP9eNMrDzgZ6i9pFP\n" +
                "djlcJ+NE0veOLwTA1eQhiIZFSJTI5eyiePTYNIS3GwIyGauzePw5LeBb6rLVBt4Y\n" +
                "NAOgJDeHbPV2bnstONjE7FyUswJivIVD3n3UaVGgBTe6xc468Ws4rmeKZ8/Ph1Nq\n" +
                "ylaViyPWz486JAibF3Kudl5B";
        /** * RSA密钥长度必须是64的倍数，在512~65536之间。默认是1024 */
        public static final int KEY_SIZE = 2048;
    
    
        //==============================================公共方法start===============================================
    
        /** * 生成公钥、私钥对(keysize=1024) */
        public static RSAHelper.KeyPairInfo getKeyPair() { 
            return getKeyPair(KEY_SIZE);
        }
    
        /** * 生成公钥、私钥对 * * @param keySize * @return */
        public static RSAHelper.KeyPairInfo getKeyPair(int keySize) { 
            try { 
                /** 指定加密算法为RSA */
                KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
                keyPairGen.initialize(keySize);
                // 生成一个密钥对，保存在keyPair中
                KeyPair keyPair = keyPairGen.generateKeyPair();
                // 得到私钥
                RSAPrivateKey oraprivateKey = (RSAPrivateKey) keyPair.getPrivate();
                // 得到公钥
                RSAPublicKey orapublicKey = (RSAPublicKey) keyPair.getPublic();
    
                RSAHelper.KeyPairInfo pairInfo = new RSAHelper.KeyPairInfo(keySize);
                //公钥
                byte[] publicKeybyte = orapublicKey.getEncoded();
                //Base64编码公钥
                String publicKeyString = Base64.getEncoder().encodeToString(publicKeybyte);//由于加密后的密文都是字节码形式的，我们要以字符串方式保存或传输的话，可以使用Base64编码。
                pairInfo.setPublicKey(publicKeyString);
    
                //私钥
                byte[] privateKeybyte = oraprivateKey.getEncoded();
                //Base64编码私钥
                String privateKeyString = Base64.getEncoder().encodeToString(privateKeybyte);//由于加密后的密文都是字节码形式的，我们要以字符串方式保存或传输的话，可以使用Base64编码。
                pairInfo.setPrivateKey(privateKeyString);
                return pairInfo;
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
    
        /** * 获取公钥对象 * * @param publicKeyBase64 * @return * @throws InvalidKeySpecException * @throws NoSuchAlgorithmException */
        public static PublicKey getPublicKey(String publicKeyBase64)
                throws InvalidKeySpecException, NoSuchAlgorithmException { 
    
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            X509EncodedKeySpec publicpkcs8KeySpec =
                    new X509EncodedKeySpec(Base64.getDecoder().decode(publicKeyBase64));//由于加密后的密文都是字节码形式的，我们要以字符串方式保存或传输的话，可以使用Base64编码。
            PublicKey publicKey = keyFactory.generatePublic(publicpkcs8KeySpec);
            return publicKey;
        }
    
        /** * 获取私钥对象 * * @param privateKeyBase64 * @return * @throws NoSuchAlgorithmException * @throws InvalidKeySpecException */
        public static PrivateKey getPrivateKey(String privateKeyBase64)
                throws NoSuchAlgorithmException, InvalidKeySpecException { 
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PKCS8EncodedKeySpec privatekcs8KeySpec =
                    new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKeyBase64));//由于加密后的密文都是字节码形式的，我们要以字符串方式保存或传输的话，可以使用Base64编码。
            PrivateKey privateKey = keyFactory.generatePrivate(privatekcs8KeySpec);
            return privateKey;
        }
    
    
        /** * 分段加密 * * @param ciphertext 密文 * @param key 加密秘钥 * @param segmentSize 分段大小，<=0 不分段 * @return */
        public static String encipher(String ciphertext, java.security.Key key, int segmentSize) { 
            try { 
                // 用公钥加密
                byte[] srcBytes = ciphertext.getBytes();
    
                // Cipher负责完成加密或解密工作，基于RSA
                Cipher cipher = Cipher.getInstance("RSA");
                // 根据公钥，对Cipher对象进行初始化
                cipher.init(Cipher.ENCRYPT_MODE, key);
                byte[] resultBytes = null;
    
                if (segmentSize > 0) { 
                    resultBytes = cipherDoFinal(cipher, srcBytes, segmentSize); //分段加密
                } else { 
                    resultBytes = cipher.doFinal(srcBytes);
                }
    
                return Base64.getEncoder().encodeToString(resultBytes);
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
    
        /** * 分段大小 * * @param cipher * @param srcBytes * @param segmentSize * @return * @throws IllegalBlockSizeException * @throws BadPaddingException * @throws IOException */
        public static byte[] cipherDoFinal(Cipher cipher, byte[] srcBytes, int segmentSize)
                throws IllegalBlockSizeException, BadPaddingException, IOException { 
            if (segmentSize <= 0) { 
                throw new RuntimeException("分段大小必须大于0");
            }
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int inputLen = srcBytes.length;
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) { 
                if (inputLen - offSet > segmentSize) { 
                    cache = cipher.doFinal(srcBytes, offSet, segmentSize);
                } else { 
                    cache = cipher.doFinal(srcBytes, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * segmentSize;
            }
            byte[] data = out.toByteArray();
            out.close();
            return data;
        }
    
        /** * 分段解密 * * @param contentBase64 密文 * @param key 解密秘钥 * @param segmentSize 分段大小（小于等于0不分段） * @return */
        public static String decipher(String contentBase64, java.security.Key key, int segmentSize) { 
            try { 
                // 用私钥解密
                byte[] srcBytes = Base64Utils.decodeFromString(contentBase64);
                // Cipher负责完成加密或解密工作，基于RSA
                Cipher deCipher = Cipher.getInstance("RSA");
                // 根据公钥，对Cipher对象进行初始化
                deCipher.init(Cipher.DECRYPT_MODE, key);
                byte[] decBytes = null;//deCipher.doFinal(srcBytes);
                if (segmentSize > 0) { 
                    decBytes = cipherDoFinal(deCipher, srcBytes, segmentSize); //分段加密
                } else { 
                    decBytes = deCipher.doFinal(srcBytes);
                }
    
                String decrytStr = new String(decBytes);
                return decrytStr;
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
        //==============================================公共方法end===============================================
    
        //==============================================私钥加密start===============================================
    
        /** * 使用私钥加密 * * @param content 待加密内容 * @param privateKeyBase64 私钥 base64 编码 * @return 经过 base64 编码后的字符串 */
        public static String encipherPrivate(String content, String privateKeyBase64) { 
            return encipherPrivate(content, privateKeyBase64, KEY_SIZE / 8 - 11);
        }
    
        /** * 使用私钥加密（分段加密） * * @param content 待加密内容 * @param privateKeyBase64 私钥 base64 编码 * @param segmentSize 分段大小,一般小于 keySize/8（段小于等于0时，将不使用分段加密） * @return 经过 base64 编码后的字符串 */
        public static String encipherPrivate(String content, String privateKeyBase64, int segmentSize) { 
            try { 
                PrivateKey privateKey = getPrivateKey(privateKeyBase64);
                return encipher(content, privateKey, segmentSize);
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
        //==============================================私钥加密start===============================================
    
    
        //==============================================公钥加密start===============================================
    
        /** * 使用公钥加密 * * @param content 待加密内容 * @param publicKeyBase64 公钥 base64 编码 * @return 经过 base64 编码后的字符串 */
        public static String encipherPublicKey(String content, String publicKeyBase64) { 
            return encipherPublicKey(content, publicKeyBase64, KEY_SIZE / 8 - 11);
        }
    
        /** * 使用公钥加密（分段加密） * * @param content 待加密内容 * @param publicKeyBase64 公钥 base64 编码 * @param segmentSize 分段大小,一般小于 keySize/8（段小于等于0时，将不使用分段加密） * @return 经过 base64 编码后的字符串 */
        public static String encipherPublicKey(String content, String publicKeyBase64, int segmentSize) { 
            try { 
                PublicKey publicKey = getPublicKey(publicKeyBase64);
                return encipher(content, publicKey, segmentSize);
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
        //==============================================公钥加密end===============================================
    
    
        //==============================================公钥解密start===============================================
    
        /** * 使用公钥解密 * * @param contentBase64 待加密内容,base64 编码 * @param publicKeyBase64 公钥钥 base64 编码 * @return * @segmentSize 分段大小 */
        public static String decipherPublic(String contentBase64, String publicKeyBase64) { 
            return decipherPublic(contentBase64, publicKeyBase64, KEY_SIZE / 8);
        }
    
        /** * 使用公钥解密（分段解密） * * @param contentBase64 待加密内容,base64 编码 * @param publicKeyBase64 公钥钥 base64 编码 * @return * @segmentSize 分段大小 */
        public static String decipherPublic(String contentBase64, String publicKeyBase64, int segmentSize) { 
            try { 
                PublicKey publicKey = getPublicKey(publicKeyBase64);
                return decipher(contentBase64, publicKey, segmentSize);
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
        //==============================================公钥解密end===============================================
    
    
        //==============================================私钥解密start===============================================
    
        /** * 使用私钥解密 * * @param contentBase64 待加密内容,base64 编码 * @param privateKeyBase64 私钥 base64 编码 * @return * @segmentSize 分段大小 */
        public static String decipherPrivateKey(String contentBase64, String privateKeyBase64) { 
            return decipherPrivateKey(contentBase64, privateKeyBase64, KEY_SIZE / 8);
        }
    
        /** * 使用私钥解密（分段解密） * * @param contentBase64 待加密内容,base64 编码 * @param privateKeyBase64 私钥 base64 编码 * @return * @segmentSize 分段大小 */
        public static String decipherPrivateKey(String contentBase64, String privateKeyBase64, int segmentSize) { 
            try { 
                PrivateKey privateKey = getPrivateKey(privateKeyBase64);
                return decipher(contentBase64, privateKey, segmentSize);
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            }
        }
        //==============================================私钥解密end===============================================
    
        /** * 秘钥对 */
        @Data
        public static class KeyPairInfo { 
            String privateKey;
            String publicKey;
            int keySize = 0;
    
            public KeyPairInfo(int keySize) { 
                setKeySize(keySize);
            }
    
            public KeyPairInfo(String publicKey, String privateKey) { 
                setPrivateKey(privateKey);
                setPublicKey(publicKey);
            }
        }
    
    
        public static void main(String[] args) { 
            RSAHelper.KeyPairInfo keyPairInfo = getKeyPair();
            System.out.println("\n公钥：" + keyPairInfo.getPublicKey());
            System.out.println("\n私钥：" + keyPairInfo.getPrivateKey());
    
            System.out.println("==============1.使用公钥加密,私钥解密==================");
            String str = "aaa111aaa111";
            System.out.println("原文：" + str);
    
            //公钥加密
            String encrypt = encipherPublicKey(str, keyPairInfo.getPublicKey());
            System.out.println("公钥加密后的结果:" + encrypt);
            //私钥解密
            String decrypt = decipherPrivateKey(encrypt, keyPairInfo.getPrivateKey());
            System.out.println("私钥解密后的结果:" + decrypt);
    
    
            System.out.println("==============2.使用私钥加密,公钥解密==================");
            String str2 = "撒旦教爱丽丝到家撒旦教撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的";
            System.out.println("原文：" + str2);
            //私钥加密
            String encrypt2 = encipherPrivate(str2, keyPairInfo.getPrivateKey());
            System.out.println("私钥加密后的结果:" + encrypt2);
            //公钥解密
            String decrypt2 = decipherPublic(encrypt2, keyPairInfo.getPublicKey());
            System.out.println("公钥解密后的结果:" + decrypt2);
    
        }
    }

main方法执行结果

公钥：MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAgPha1HDSBTbq4GYiiCRlziy3ys5VrH+ChjXEYo2TWXZyKdQ/lBCKxPD7t1OrWyz0c2NvyyFla3G2mIlmzvDq/LCsHqPB2v7dusfM+yFdlYErrdcI4rBb3zQ8NivJeoAP+ohTdBewizcG8XIEc5Ewy2lIUOryHXNB705EFKlGQz7lelGwtN9RyGUYOEKj+6tZnQKPODnZUUJ2SXXq9PSs/rNAZ90dK+tNxBQDpkyGK8w+dbjHXxqjU5aOYvapSvv8RK3+JW0fECPrDBnX0B16mJa1IEa9nBxsnXjmmWMdyTidGxFktPW1E1xZWyarL+GJAEU52coHJhEYiFyYP46TlQIDAQAB
    
    私钥：MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCA+FrUcNIFNurgZiKIJGXOLLfKzlWsf4KGNcRijZNZdnIp1D+UEIrE8Pu3U6tbLPRzY2/LIWVrcbaYiWbO8Or8sKweo8Ha/t26x8z7IV2VgSut1wjisFvfNDw2K8l6gA/6iFN0F7CLNwbxcgRzkTDLaUhQ6vIdc0HvTkQUqUZDPuV6UbC031HIZRg4QqP7q1mdAo84OdlRQnZJder09Kz+s0Bn3R0r603EFAOmTIYrzD51uMdfGqNTlo5i9qlK+/xErf4lbR8QI+sMGdfQHXqYlrUgRr2cHGydeOaZYx3JOJ0bEWS09bUTXFlbJqsv4YkARTnZygcmERiIXJg/jpOVAgMBAAECggEAP0sjMG0p9Rsti/Ez80KBn/x8OpCmpSByyzDp7z/x1470miirBxxTLjHiJuduCjH2ygY74CHEp0VISnXsOZUsjdSas/LD+Zjo8niJ1ZlbVzrsV8VXfAD3JYR6JE+68l6U+OwcoLXbk4bu5mGBY8IWg01pCyUyq1dcPXhYmxcz/13VXM8HzydxaCMZGV8yZ2y5n3iGkTBNVyK4Mz7sRjs8CZ6bgqgCVSGUwGGcOluhUb4zkG4WT1xy0FpEFaQtldjTDdDhg6aYDipgC3xePnBFy4oAb5RJN+lumW5k+ntbqHv0/XtJbQZuzrMWSrTQHco+Cksxt/3MZw9CK5u3Eg8vYQKBgQC4W6uA/hgQpLpXvbGfdYvGx/vZFnduEyhMJRbpKUrNTwBeyb9hny6Fn9dc5mbRUONl0qtJvbqAVTZwcml6bl8iPkwsR6dl2hHB4DEFKpAAZa9h99nX6v8KbS3Ja8rc3Ksi0mrD++ctuS+qmrSs3S3Yi5+N05ArBscIm2gP0KbHPQKBgQCzFpM86tC0sKotSeyDbri0heBOiKsV5dbdX5anx+UKz9NxQoXFUJzFEcq/J07EEhSSszqllVGiF4LC0ATkN8DQMqczInQiKJeXa0eExd0qYgZ0WB7jYc00MSk6MPmOjcpZCqcI1ICIiYKg/9uBYvnknh88lR42qYQTrPI4I9iDOQKBgFzbv4zfb1uivUFIiNkaqebcAByeVlWZTKjd3aZfaA/1hOg5ki4nsZUYp69hVdSEe6Vj8WbZK8FMKnmFB1/ljAGBg3iiNsz0hBE1TTue7p1kmmwsHQvGj+O+jltv8eRBOen2NlS04wKCzmGOPwb6+QajfSBAudMSPNo2/LlKjVa5AoGAFMVMhGczl5FZ23DUdpXz5DQWxOUC+sIyfnBkt8buYKej/WHaw/zKgezDWBJGB2WVb0JMTgIYerVBXDjmKFXzDfKiA8M+NuwAUPaHT/Xm5dCCsSG7S2H/e8sr3ezqNMdrLZKXtuV2lt9kACpMmiARnZtdQhiFbY+RmvqXCT3XEbkCgYBvfz6bEkNrQF/vV67jDMovsIdJPcNDK7jXQ34clTEiKdg6CwUPy19CLmI+RBsDUjbpconUxOFudNoxkwZxfV3opdYtKQpwAda2RHh+vN6Aaw3kHGrRSni/vWkJEAKWohAcXI/ruXt/1M3CmHgWeT91tuN4lqDNAL8zHZ32jaK8qA==
    
    ==============1.使用公钥加密,私钥解密==================
    原文：aaa111aaa111
    公钥加密后的结果:OAOwREnK6U2VcPA18ryFv8MvT/Fa6mqAkbfPFBtC9ltSbIHsc/WWT8ZyT9FL1kP5bCTpzVBdn8c5Z4cgo6auGhIATbnqhcqkFrVIFxbYFQ/imYNnOKYAAHuqkfbVUD/r5bW56p3HXvOF1hAzq83lDwR1ecOqssBDcmy3hFlo+SPojSTHOVp8ec1dmFh8tfYlHPPET8EZEf6bqn27sWCpL/GRCuHsJ/iy5l9LOsbSyI5fh1ctdK5YAqoYmDbANt1p3lOcrg+v6VmJ77OycaRF0Q2nbT5ycUV36ZCQzcyy1aVXFTqD3etCnsqHGBu5PgcQSd8KctsK1WKpa+jKvyGNQw==
    私钥解密后的结果:aaa111aaa111
    
    ==============2.使用私钥加密,公钥解密==================
    原文：撒旦教爱丽丝到家撒旦教撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的
    私钥加密后的结果:cyDvraC6DHQvi5PZkNrSDdTURU1XZsBjzSlCreYBqNsg5XXR2OtOZE6X8hLC/Hf2dJetSwCIx56bZYuAMwHSmlg9qI81s2PGAlmWQOa8TsHOqOv4ea5eL+JgpLzW9NR8u2Vwj3I3iCJ3wolckwkPlu/Dq6WEzoaFHQh2nin72n2ab4yHQFWbJbhrm40ZdWrhzVuaNSorcST/DDClbJ2oO8NQ00gLdJeeISLIik1Vdgaz57kBMci1jMkNpXLhsLhagr3ly2tegMciSKrkHREJkt/vrFORV70HIsf5lLqCXxBYitKkkZGnuwY3EGR6qZvVMVFBq0xjgLQdN3Eu93Yqei4P3iINlxKge2irDiIjOnIS5mkxJl+/eNKX0Zm2BxtCN8p1lId+7ysSjjTQ0s3tLIIYnjLUqM6sAO7AvZygJRYafiaIXpfNTAoQSXiNlVqdtLHQy2DSUg4aBz29osvcp+eWl1riNpt/KrpHOKyGU2Qhdnqy1Xx38MF6E1R7mQiPHE/E2upSymoVbGkkdnDswdfDU8+9/NRckmpCpJjPVFavcHQpB3O6aTycypTExfA4iNyq+GJEnui6JMwmcJ6T5jcYiD06AIGACsZ267Xm43V3JphEz+4irQ61uPgLwXh7zL11i2oXfzy7RganCw3qcM+/sWWl9asdJ5FnPeco5ixxfrS7KahbEUSh4lG95pK3B184LYkQKn0hgSQuIHvUNA45KVyFtsG2AgJRQM5bN4pyjRewc2IJ7CNXQS4BfpcUOrNPlZ4zMJIpZX3BI/VUqD27jllZ6fpFjNLH22eDQpLma2iQ0xJ36KHVkwKGQ7TdTpn/+T4cPOSIUWVnhOErgIxGxA3GL0WxlSUOQBbS9CjjayFrNZcreoRXg0omHiIB9m4V1xfcY7xfLN4LBI4rhmm3C5gEpteLy6wzw/kNp3xaNuam1XpPVSM0Wc0ZPXVo+w1M282vTOgKGJC7MBBhUsgvUjvwlzbU6AVdq85cYgVMOUhyDMSjh7Kf1s34ChSH
    公钥解密后的结果:撒旦教爱丽丝到家撒旦教撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的

# AES工具类 #

import org.springframework.util.Base64Utils;
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import java.security.Key;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.util.UUID;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    import java.nio.charset.StandardCharsets;
    
    public class AESUtil { 
    
        private static final String KEY_ALGORITHM = "AES";
        private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//默认的加密算法
    
        /** * AES 加密操作 * * @param content 待加密内容 * @param password 加密密码 * @return 返回Base64转码后的加密数据 */
        public static String encrypt(String content, String password) { 
            try { 
                Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器
    
                byte[] byteContent = content.getBytes(StandardCharsets.UTF_8);
    
                cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(password));// 初始化为加密模式的密码器
    
                byte[] result = cipher.doFinal(byteContent);// 加密
    
                return Base64Utils.encodeToString(result);//通过Base64转码返回
            } catch (Exception ex) { 
                Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
    
            return null;
        }
    
        /** * AES 解密操作 * * @param content * @param password * @return */
        public static String decrypt(String content, String password) { 
    
            try { 
                //实例化
                Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
    
                //使用密钥初始化，设置为解密模式
                cipher.init(Cipher.DECRYPT_MODE, getSecretKey(password));
    
                //执行操作
                byte[] result = cipher.doFinal(Base64Utils.decodeFromString(content));
    
                return new String(result, StandardCharsets.UTF_8);
            } catch (Exception ex) { 
                Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
    
            return null;
        }
    
        /** * 生成加密秘钥 * * @return */
        private static SecretKeySpec getSecretKey(String password) { 
            //返回生成指定算法密钥生成器的 KeyGenerator 对象
            KeyGenerator kg = null;
            try { 
                kg = KeyGenerator.getInstance(KEY_ALGORITHM);
                //AES 要求密钥长度为 128
                kg.init(128, new SecureRandom(password.getBytes()));
                //生成一个密钥
                SecretKey secretKey = kg.generateKey();
                return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为AES专用密钥
            } catch (NoSuchAlgorithmException ex) { 
                Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
        }
    
        /** * 根据密钥和算法生成Key * * @return * @throws Exception */
        private static Key generateKey(String keyString) throws Exception { 
            Key key = new SecretKeySpec(keyString.getBytes(), KEY_ALGORITHM);
            return key;
        }
    
        public static String generateKeyString() { 
            //必须长度为16
            return UUID.randomUUID().toString().replaceAll("-", "").substring(0, 16);
        }
    
        public static void main(String[] args) throws Exception { 
            String password = generateKeyString();
            System.out.println("密钥：" + password);
    
            String source = "撒旦教爱丽丝到家撒旦教撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的!";// 要加密的字符串
            System.out.println("准备用密钥加密的字符串为：" + source);
    
            String cryptograph = encrypt(source, password);// 生成的密文
            System.out.print("用密钥加密后的结果为:" + cryptograph);
            System.out.println();
    
            String target = decrypt(cryptograph, password);// 解密密文
            System.out.println("用密钥解密后的字符串为：" + target);
            System.out.println();
        }
    }

main方法执行结果

密钥：d46b04d60a4a4d8b
    准备用密钥加密的字符串为：撒旦教爱丽丝到家撒旦教撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的!
    用密钥加密后的结果为:fn6m2JLrNZET2mEY0EO8eJHwFnT/qpeOgC3RhQOGTDc3QNusK51BodBBVYv/k5o2ZX7RvXfuWfa184+sgJrYNMvPyo0b2KeFHrpE8LQrMshEPwNgbDpoI+DtQT5/QLzzfn6m2JLrNZET2mEY0EO8eOgHAgXrAqewon1r0gVT3fkG0nbIrvzZ2f6dd4EOargVTd9LdJq676Zi05kT7RREoQFwnthpp/zzHOWKk8fLXKa9evujL9Zbd6nB5XDihsye51qW3RNDWhC2tscWyZPwQb366OOiM/Cl7rJvtlv6TiXqFa0CoAnpaHQWwIfuk1dmUevWq6MPegYhlLD8K7byBjV2JQ7jdjyLHbDi762JOOtXSi/d3gXIWfPfPxbh+3wPIcKjeOqsMGXRaWESeqxANNeGAYlJDo5jjNKLB7hwO5Vh7xq0vB/9wbpJ04Fv2MFs2PlOPzstdiq3RQCyTC7j3cvPyo0b2KeFHrpE8LQrMsi2DzbaIoHOOvO3rPiRXddmfZAo0y210JgwEWlXBWP8KF038QfPm4bI8botwuKqidJQKwntbKhvQ2+qXl0VCqcODnHTSLoMxFRxRjdJMfQK3VvydJPqXR2VWgXKxhsxPGeb1CztHmR94gaToulAs6wP/AAWw3eQVaONgO1HOZ4u+G6mCha6l1YNZHHpOoZ/gMpXSi/d3gXIWfPfPxbh+3wPIcKjeOqsMGXRaWESeqxANNeGAYlJDo5jjNKLB7hwO5URS93jn5dE1n/WblVX8MFhczLu0SHaK652x1cxQlB9ZpN7WfpbIJ3DtrfA7YrLnB+NI7p3XCemx5Ijq7hy1VFPsWiWiEEyyBfK7z7TL6VyKQ==
    用密钥解密后的字符串为：撒旦教爱丽丝到家撒旦教撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的撒旦教爱丽丝到家撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的撒旦教爱丽丝到家啦是可敬的啦是可敬的!

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]: /images/20221022/bc869095155b4e0abd9da313df655349.png