Springboot集成RSA加密

r囧r小猫 2023-09-25 17:03 39阅读 0赞

#### Springboot集成RSA加密 ####

*   *  1 : RSA加密介绍
     *  2 : RSA依赖
     *  3 : RSA加密工具类
     *  4 : 测试截图
     *  5 : 相关链接
     *  6 : 资源链接

### 1 : RSA加密介绍 ###

RSA公开密钥密码体制是一种使用不同的加密密钥与解密密钥，“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。  
特点：安全性高，运算速度相对较慢。  
其余可以搜一下，很多介绍。

### 2 : RSA依赖 ###

依赖

<dependency>
    	<groupId>org.apache.poi</groupId>
    	<artifactId>poi</artifactId>
    	<version>4.1.2</version>
    </dependency>
    <dependency>
    	<groupId>org.apache.poi</groupId>
    	<artifactId>poi-ooxml</artifactId>
    	<version>4.1.2</version>
    </dependency>

完成pom文件

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.7.5</version>
    		<relativePath/> 
    	</parent>
    	<groupId>com.export</groupId>
    	<artifactId>export</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>export</name>
    	<description>Demo project for Spring Boot</description>
    	<properties>
    		<java.version>1.8</java.version>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-aop</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    			<exclusions>
    				<exclusion>
    					<groupId>org.junit.vintage</groupId>
    					<artifactId>junit-vintage-engine</artifactId>
    				</exclusion>
    			</exclusions>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.apache.poi</groupId>
    			<artifactId>poi</artifactId>
    			<version>4.1.2</version>
    		</dependency>
    		<dependency>
    			<groupId>org.apache.poi</groupId>
    			<artifactId>poi-ooxml</artifactId>
    			<version>4.1.2</version>
    		</dependency>
    
    	</dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    				<configuration>
    					<mainClass>com.encrypt.EncryptApplication</mainClass>
    				</configuration>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>

### 3 : RSA加密工具类 ###

Base64Utils.java

package com.encrypt.config.utils;
    
    import org.apache.xmlbeans.impl.util.Base64;
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    public class Base64Utils {
        
        /**
         * 文件读取缓冲区大小
         */
        private static final int CACHE_SIZE = 1024;
    
        /**
         * BASE64字符串解码为二进制数据
         */
        public static byte[] decode(String base64) throws Exception {
        
            return Base64.decode(base64.getBytes());
        }
    
        /**
         * 二进制数据编码为BASE64字符串
         */
        public static String encode(byte[] bytes){
        
            return new String(Base64.encode(bytes));
        }
    
        /**
         * 将文件编码为BASE64字符串，大文件慎用，可能会导致内存溢出
         * @param filePath 文件绝对路径
         */
        public static String encodeFile(String filePath) throws Exception {
        
            byte[] bytes = fileToByte(filePath);
            return encode(bytes);
        }
    
        /**
         * BASE64字符串转回文件
         * @param filePath 文件绝对路径
         * @param base64 编码字符串
         */
        public static void decodeToFile(String filePath, String base64) throws Exception {
        
            byte[] bytes = decode(base64);
            byteArrayToFile(bytes, filePath);
        }
    
        /**
         * 文件转换为二进制数组
         * @param filePath 文件路径
         */
        public static byte[] fileToByte(String filePath) throws Exception {
        
            byte[] data = new byte[0];
            File file = new File(filePath);
            if (file.exists()) {
        
                try ( FileInputStream in = new FileInputStream(file);
                      ByteArrayOutputStream out = new ByteArrayOutputStream(2048);) {
        
                    byte[] cache = new byte[CACHE_SIZE];
                    int nRead = 0;
                    while ((nRead = in.read(cache)) != -1) {
        
                        out.write(cache, 0, nRead);
                        out.flush();
                    }
                    data = out.toByteArray();
                }
            }
            return data;
        }
    
        /**
         * 二进制数据写文件
         * @param bytes 二进制数据
         * @param filePath 文件生成目录
         */
        public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {
        
            File destFile = new File(filePath);
            try (InputStream in = new ByteArrayInputStream(bytes);
                 OutputStream out = new FileOutputStream(destFile);) {
        
                if (!destFile.getParentFile().exists()) {
        
                    destFile.getParentFile().mkdirs();
                }
                destFile.createNewFile();
                byte[] cache = new byte[CACHE_SIZE];
                int nRead = 0;
                while ((nRead = in.read(cache)) != -1) {
        
                    out.write(cache, 0, nRead);
                    out.flush();
                }
            }
        }
    
    }

RSAUtils.java

package com.encrypt.config.utils;
    
    import javax.crypto.Cipher;
    import java.io.ByteArrayOutputStream;
    import java.security.Key;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.Signature;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;
    
    public class RSAUtils {
        
    
        //RSA 获取公钥的key
        public static final String RSA_PUBLIC_KEY = "RSA_PublicKey";
        //RSA 获取私钥的key
        public static final String RSA_PRIVATE_KEY = "RSA_PrivateKey";
        // 加密算法RSA
        public static final String KEY_ALGORITHM = "RSA";
        //初始化密钥大小
        public static final Integer INITIALIZE = 1024;
        //RSA最大加密明文大小
        public static final Integer MAX_ENCRYPT_BLOCK = 117;
        //RSA最大解密密文大小
        public static final Integer MAX_DECRYPT_BLOCK = 128;
        //签名算法
        public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    
        /**
         * 生成密钥对(公钥和私钥)
         */
        public static Map<String, Object> generateRSAKeyPair() throws NoSuchAlgorithmException {
        
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            keyPairGen.initialize(INITIALIZE);
            KeyPair keyPair = keyPairGen.generateKeyPair();
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            return new HashMap<String, Object>(){
        {
        
                put(RSA_PUBLIC_KEY, publicKey);
                put(RSA_PRIVATE_KEY, privateKey);
            }};
        }
    
        /**
         * 获取公钥
         * @param keyMap 密钥对
         */
        public static String getRSAPublicKey(Map<String, Object> keyMap){
        
            Key key = (Key) keyMap.get(RSA_PUBLIC_KEY);
            return Base64Utils.encode(key.getEncoded());
        }
    
        /**
         * 获取私钥
         * @param keyMap 密钥对
         */
        public static String getRSAPrivateKey(Map<String, Object> keyMap){
        
            Key key = (Key) keyMap.get(RSA_PRIVATE_KEY);
            return Base64Utils.encode(key.getEncoded());
        }
    
        /**
         * 公钥加密
         * @param data 源数据
         * @param publicKey 公钥(BASE64编码)
         */
        public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
        
            byte[] keyBytes = Base64Utils.decode(publicKey);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key publicK = keyFactory.generatePublic(x509KeySpec);
            // 对数据加密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicK);
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0) {
        
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
        
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else {
        
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            out.close();
            return encryptedData;
        }
    
        /**
         * 私钥解密
         * @param encryptedData 已加密数据
         * @param privateKey 私钥(BASE64编码)
         */
        public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
        
            byte[] keyBytes = Base64Utils.decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateK);
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) {
        
                if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
        
                    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                } else {
        
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return decryptedData;
        }
    
    
        /**
         * 公钥解密
         * @param encryptedData 已加密数据
         * @param publicKey 公钥(BASE64编码)
         */
        public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
        
            byte[] keyBytes = Base64Utils.decode(publicKey);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key publicK = keyFactory.generatePublic(x509KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicK);
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) {
        
                if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
        
                    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                } else {
        
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return decryptedData;
        }
    
        /**
         * 私钥加密
         * @param data 源数据
         * @param privateKey 私钥(BASE64编码)
         */
        public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
        
            byte[] keyBytes = Base64Utils.decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateK);
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0) {
        
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
        
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else {
        
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            out.close();
            return encryptedData;
        }
    
        /**
         * 用私钥对信息生成数字签名
         * @param data 已加密数据
         * @param privateKey 私钥(BASE64编码)
         */
        public static String sign(byte[] data, String privateKey) throws Exception {
        
            byte[] keyBytes = Base64Utils.decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initSign(privateK);
            signature.update(data);
            return Base64Utils.encode(signature.sign());
        }
    
        /**
         * 校验数字签名
         * @param data 已加密数据
         * @param publicKey 公钥(BASE64编码)
         * @param sign 数字签名
         *
         */
        public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
        
            byte[] keyBytes = Base64Utils.decode(publicKey);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PublicKey publicK = keyFactory.generatePublic(keySpec);
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initVerify(publicK);
            signature.update(data);
            return signature.verify(Base64Utils.decode(sign));
        }
    
    
        public static void main(String[] args) throws Exception{
        
            System.out.println("********************生成公钥、私钥********************");
            Map<String, Object> map = generateRSAKeyPair();
            System.out.println("RSA公钥：" + getRSAPublicKey(map));
            System.out.println("RSA私钥：" + getRSAPrivateKey(map));
            String publicKey = getRSAPublicKey(map);
            String privateKey = getRSAPrivateKey(map);
            String json = "中文，abc,！@#";
    
            //公钥加密
            System.out.println("********************公钥加密、生成数字签名、数字签名校验、私钥解密********************");
            System.out.println("字符串：" + json);
            String encryptPublic = Base64Utils.encode(encryptByPublicKey(json.getBytes(), publicKey));
            System.out.println("公钥加密后字符串：" + encryptPublic);
    
            //生成数字签名
            String signKey = sign(Base64Utils.decode(encryptPublic), privateKey);
            System.out.println("公钥加密后数字签名：" + signKey);
            //校验数字签名
            boolean verify = verify(Base64Utils.decode(encryptPublic), publicKey, signKey);
            System.out.println("公钥加密后数字签名校验：" + verify);
    
            //私钥解密
            System.out.println("私钥解密后字符串：" + new String(decryptByPrivateKey(Base64Utils.decode(encryptPublic), privateKey)));
    
            System.out.println("********************私钥加密、公钥解密********************");
            //私钥加密
            System.out.println();
            System.out.println("字符串：" + json);
            String encryptPrivate = Base64Utils.encode(encryptByPrivateKey(json.getBytes(), privateKey));
            System.out.println("私钥加密后字符串：" + encryptPrivate);
            //公钥解密
            System.out.println("公钥解密后字符串：" + new String(decryptByPublicKey(Base64Utils.decode(encryptPrivate), publicKey)));
    
        }
    
    }

### 4 : 测试截图 ###

![在这里插入图片描述][17da56c2011a41a39259c3f80ff4133b.png]

### 5 : 相关链接 ###

Springboot项目报文加密（采用AES、RSA动态加密策略）：  
[https://blog.csdn.net/qq\_38254635/article/details/129275971][https_blog.csdn.net_qq_38254635_article_details_129275971]  
Springboot集成AES加密：  
[https://blog.csdn.net/qq\_38254635/article/details/129622075][https_blog.csdn.net_qq_38254635_article_details_129622075]

### 6 : 资源链接 ###

CSDN源项目下载：[https://download.csdn.net/download/qq\_38254635/87587334][https_download.csdn.net_download_qq_38254635_87587334]  
百度网盘下载：[https://pan.baidu.com/s/1OZBrTYIuoKmWknIPFvZ8Vw?pwd=nnm8][https_pan.baidu.com_s_1OZBrTYIuoKmWknIPFvZ8Vw_pwd_nnm8]  
提取码：nnm8

[17da56c2011a41a39259c3f80ff4133b.png]: https://img-blog.csdnimg.cn/17da56c2011a41a39259c3f80ff4133b.png
[https_blog.csdn.net_qq_38254635_article_details_129275971]: https://blog.csdn.net/qq_38254635/article/details/129275971
[https_blog.csdn.net_qq_38254635_article_details_129622075]: https://blog.csdn.net/qq_38254635/article/details/129622075
[https_download.csdn.net_download_qq_38254635_87587334]: https://download.csdn.net/download/qq_38254635/87587334
[https_pan.baidu.com_s_1OZBrTYIuoKmWknIPFvZ8Vw_pwd_nnm8]: https://pan.baidu.com/s/1OZBrTYIuoKmWknIPFvZ8Vw?pwd=nnm8