RSA前后加密，后端解密

た入场券 2022-01-12 11:43 270阅读 0赞

### 1.前端加密 ###

引入jsencrypt.min.js包

地址：

[https://pan.baidu.com/s/1Z7il-nhBhwDK8CvnidLGlg][https_pan.baidu.com_s_1Z7il-nhBhwDK8CvnidLGlg]：erkh

<!DOCTYPE html>  
<html>  
<head>  
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>  
    <meta name=viewport content="width=device-width,initial-scale=1,minimum-scale=1,maximum-scale=1,user-scalable=no">  
    <meta http-equiv="Cache-Control" content="no-transform"/>  
    <meta http-equiv="Cache-Control" content="no-siteapp"/>  
    <meta name="applicable-device" content="pc,mobile">  
<script  type="text/javascript" src="./js/jquery.js"></script>  
<script  type="text/javascript" src="./js/jsencrypt.min.js"></script>  
    <title>RSA</title>  
</head>  
<body>  
    <script type="text/javascript">  
        // 这个是后台生成并返回的RSA信息（公钥）  
        // 加密：要测试的明文数据  
        var str = '123456'  
        var publicKey ="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCk100ocM6DSzuQty+uLBVFavMkQyzuJjLA2/StV11YRSToSZwwwDkh+net0gMaSshPrAQ3TOMU7itQl58nV/ntfHyinUeNhTMM0IhHIUlRBjRriMH4cFB3OZ1uD1BKG5gRLrDN//il9i+OZLgaZ1DszEkNaSTOfCv6JbtJ5OPJ4wIDAQAB"  
        var encrypt = new JSEncrypt()  
        encrypt.setPublicKey(publicKey)  
        var data = encrypt.encrypt(str)  
        console.log('密文', data)  
    </script>  
</body>  
</html>

###    2.后端解密   package com.yitao.api.utils; ###

import lombok.extern.slf4j.Slf4j;  
import org.apache.tomcat.util.codec.binary.Base64;

import javax.crypto.Cipher;  
import java.security.\*;  
import java.security.spec.PKCS8EncodedKeySpec;  
import java.security.spec.X509EncodedKeySpec;  
import java.util.HashMap;  
import java.util.LinkedList;  
import java.util.List;  
import java.util.Map;

/\*\*  
\* @Author: wwl  
\* @Date: 2019/6/21 14:32  
\* @Description:  
\*/  
@Slf4j  
public class RSAByJsUtils \{  
    private static String KEY\_RSA\_TYPE = "RSA";  
    private static int KEY\_SIZE = 1024;//JDK方式RSA加密最大只有1024位  
    private static int ENCODE\_PART\_SIZE = KEY\_SIZE / 8;  
    public static final String PUBLIC\_KEY\_NAME = "public";  
    public static final String PRIVATE\_KEY\_NAME = "private";

/\*\*  
     \* 创建公钥秘钥  
     \*  
     \* @return  
     \*/  
    public static Map<String, String> createRSAKeys() \{  
        Map<String, String> keyPairMap = new HashMap<>();//里面存放公私秘钥的Base64位加密  
        try \{  
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY\_RSA\_TYPE);  
            keyPairGenerator.initialize(KEY\_SIZE, new SecureRandom());  
            KeyPair keyPair = keyPairGenerator.generateKeyPair();

//获取公钥秘钥  
            String publicKeyValue = Base64.encodeBase64String(keyPair.getPublic().getEncoded());  
            String privateKeyValue = Base64.encodeBase64String(keyPair.getPrivate().getEncoded());

//存入公钥秘钥，以便以后获取  
            keyPairMap.put(PUBLIC\_KEY\_NAME, publicKeyValue);  
            keyPairMap.put(PRIVATE\_KEY\_NAME, privateKeyValue);  
            System.out.println("PUBLIC\_KEY\_NAME:" + publicKeyValue);  
            System.out.println("PRIVATE\_KEY\_NAME:" + privateKeyValue);  
        \} catch (NoSuchAlgorithmException e) \{  
            log.error("当前JDK版本没找到RSA加密算法！");  
            e.printStackTrace();  
        \}  
        return keyPairMap;  
    \}

/\*\*  
     \* 公钥加密  
     \* 描述：  
     \* 1字节 = 8位；  
     \* 最大加密长度如 1024位私钥时，最大加密长度为 128-11 = 117字节，不管多长数据，加密出来都是 128 字节长度。  
     \*  
     \* @param sourceStr  
     \* @param publicKeyBase64Str  
     \* @return  
     \*/  
    public static String encode(String sourceStr, String publicKeyBase64Str) \{  
        byte\[\] publicBytes = Base64.decodeBase64(publicKeyBase64Str);  
        //公钥加密  
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicBytes);  
        List<byte\[\]> alreadyEncodeListData = new LinkedList<>();

int maxEncodeSize = ENCODE\_PART\_SIZE - 11;  
        String encodeBase64Result = null;  
        try \{  
            KeyFactory keyFactory = KeyFactory.getInstance(KEY\_RSA\_TYPE);  
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);  
            Cipher cipher = Cipher.getInstance(KEY\_RSA\_TYPE);  
            cipher.init(Cipher.ENCRYPT\_MODE, publicKey);  
            byte\[\] sourceBytes = sourceStr.getBytes("utf-8");  
            int sourceLen = sourceBytes.length;  
            for (int i = 0; i < sourceLen; i += maxEncodeSize) \{  
                int curPosition = sourceLen - i;  
                int tempLen = curPosition;  
                if (curPosition > maxEncodeSize) \{  
                    tempLen = maxEncodeSize;  
                \}  
                byte\[\] tempBytes = new byte\[tempLen\];//待加密分段数据  
                System.arraycopy(sourceBytes, i, tempBytes, 0, tempLen);  
                byte\[\] tempAlreadyEncodeData = cipher.doFinal(tempBytes);  
                alreadyEncodeListData.add(tempAlreadyEncodeData);  
            \}  
            int partLen = alreadyEncodeListData.size();//加密次数

int allEncodeLen = partLen \* ENCODE\_PART\_SIZE;  
            byte\[\] encodeData = new byte\[allEncodeLen\];//存放所有RSA分段加密数据  
            for (int i = 0; i < partLen; i++) \{  
                byte\[\] tempByteList = alreadyEncodeListData.get(i);  
                System.arraycopy(tempByteList, 0, encodeData, i \* ENCODE\_PART\_SIZE, ENCODE\_PART\_SIZE);  
            \}  
            encodeBase64Result = Base64.encodeBase64String(encodeData);  
        \} catch (Exception e) \{  
            e.printStackTrace();  
        \}  
        return encodeBase64Result;  
    \}

/\*\*  
     \* 私钥解密  
     \*  
     \* @param sourceBase64RSA  
     \* @param privateKeyBase64Str  
     \*/  
    public static String decode(String sourceBase64RSA, String privateKeyBase64Str) \{  
        byte\[\] privateBytes = Base64.decodeBase64(privateKeyBase64Str);  
        byte\[\] encodeSource = Base64.decodeBase64(sourceBase64RSA);  
        int encodePartLen = encodeSource.length / ENCODE\_PART\_SIZE;  
        List<byte\[\]> decodeListData = new LinkedList<>();//所有解密数据  
        String decodeStrResult = null;  
        //私钥解密  
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateBytes);  
        try \{  
            KeyFactory keyFactory = KeyFactory.getInstance(KEY\_RSA\_TYPE);  
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);  
            Cipher cipher = Cipher.getInstance(KEY\_RSA\_TYPE);  
            cipher.init(Cipher.DECRYPT\_MODE, privateKey);  
            int allDecodeByteLen = 0;//初始化所有被解密数据长度  
            for (int i = 0; i < encodePartLen; i++) \{  
                byte\[\] tempEncodedData = new byte\[ENCODE\_PART\_SIZE\];  
                System.arraycopy(encodeSource, i \* ENCODE\_PART\_SIZE, tempEncodedData, 0, ENCODE\_PART\_SIZE);  
                byte\[\] decodePartData = cipher.doFinal(tempEncodedData);  
                decodeListData.add(decodePartData);  
                allDecodeByteLen += decodePartData.length;  
            \}  
            byte\[\] decodeResultBytes = new byte\[allDecodeByteLen\];  
            for (int i = 0, curPosition = 0; i < encodePartLen; i++) \{  
                byte\[\] tempSorceBytes = decodeListData.get(i);  
                int tempSourceBytesLen = tempSorceBytes.length;  
                System.arraycopy(tempSorceBytes, 0, decodeResultBytes, curPosition, tempSourceBytesLen);  
                curPosition += tempSourceBytesLen;  
            \}  
            decodeStrResult = new String(decodeResultBytes, "UTF-8");  
        \} catch (Exception e) \{  
            e.printStackTrace();  
        \}  
        return decodeStrResult;  
    \}

public static void main(String\[\] args) \{  
        //生成RSA公钥和私钥，并Base64编码  
        try \{  
            Map<String, String> map = RSAByJsUtils.createRSAKeys();  
            System.out.println("PUBLIC\_KEY\_NAME:" + map.get("public"));  
            System.out.println("PRIVATE\_KEY\_NAME:" + map.get("private"));  
            String password = "123sdfksjdgkjsjdgkjsdkjgsdj";  
            String encode = RSAByJsUtils.encode(password, map.get("public"));  
  
            System.out.println("密文:" + encode);  
            
            String decode = RSAByJsUtils.decode(encode, map.get("private"));  
            System.out.println("明文:" + decode);  
        \} catch (Exception e) \{  
            e.printStackTrace();  
        \}  
    \}  
\}

[https_pan.baidu.com_s_1Z7il-nhBhwDK8CvnidLGlg]: https://pan.baidu.com/s/1Z7il-nhBhwDK8CvnidLGlg