rsa前后端传参

最新推荐文章于 2025-11-23 21:07:11 发布

原创最新推荐文章于 2025-11-23 21:07:11 发布 · 166 阅读

CC 4.0 BY-SA版权

文章标签：

package com.joinsoft.core.utils.encrypt;

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.ArrayList;
import java.util.Base64;
import java.util.List;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

import org.apache.commons.codec.digest.DigestUtils;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;


public class EncryptUtils {

    /**
     *
     * 功能: 对字符串进行sha1加密[密文40位]
     *
     * @param input
     * @return
     *
     * 作者：Exodus
     */
    public static String sha1(String input){
        return DigestUtils.shaHex(input);
    }

    /**
     *
     * 功能: 字符串进行md5加密
     *
     * @param input
     * @return
     *
     * 作者：
     */
    public static String md5(String input){
        return DigestUtils.md5Hex(input);
    }

    /**
     * 常量字符串
     */
    private static final String RSA = "RSA";


    /**
     * 私钥
     */
    private static final String PRIVATE_KEY = "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCw3NprtiBI5bxqcx1pPyWpNku6AW7b0VMdlvFLxRf6OEQ5CzWKqw6KqR4RQlUfjHlWvGcGtwjKQYr0AjW7N5vRXCjkjvZ8enTO5JZop04d7VPzwBMZxdQmR/vJfqSIewJ0dVwoWNQ1ZAqqwn/ZwKRA2bFYeniyPrsesA3Ek1InhlIukLYFZ8S3m9GL7GrLG5b4FVgy/SPtn1Rug6i++Iz1W5gMqLk/DYIJqmZms2mvvCFRGOOOS7EyhFYFj7S/O7QwOTgckawbd1h8EyR7H2je5Hjt4jEo6AyVVAEQNT3/THuMtX2IfVgztTxQaCBCi2L2mKVOgKaSXzwA+eZ55nhhAgMBAAECggEASNDExG/ZXunm5tS6GSi8cqw+BTit0aae16HbelyNAKHFxM6OnqbKd+Ak1uo+bZzCICm1KRiWb98IPGnkgU3lww50b5VEef9YtA18t12aVcvuMn6z3nqKW7BrQ4v2ZZJvck8XQC1CQTENCzzEsnwTo/d8gnb51jjphTrqkDIvMsH1FLj9aqafss4+bMax/1ezVt+xYjyjR+57rm+8c6cowmXWusi8OaaQ9Zlmbd4NyRqcIToG3MO3BOm1VhnyEGMgcAFTn/NczFuQf1donSRZQruq3NTe3EF6WB8QBJVJztTJ/ZXjfIzCYuOHQnsueJL/jvAphiQuv8PCWCXPvDFb+QKBgQDeiUvsmKWNsr2oDnImnmHqm12IndZn1hLa5PFNkKj53b+m4DNtpSzPaPlfWLim8II321+/noDizguiJBrhdAKKQyp2bvD59B60DOAJ2eGUR7o3aCHlwclPklhlEZBfeYUmOaKwv5YR241U275nCWq3t2z5mksRER0UwbrYGrvCuwKBgQDLdVEQDjPp2cF6bjENEbT1+2uVWN2WnBh7Aj4/ccD854nKa2fGbTOdi1JR65wwh2VuKGpCBkXYnUcPYgXflj3Xye+e/2c7C+KWQEE9xHhY72SSZEy3jZlyq0Ojs8D8xMDHZv+8/i9CZpjdUpj6XmaXwmiY1tyPmp+9cJ6Pv1gFkwKBgDIG8X+NzWHudb5rCPRvlJmWNc+5k/Kh6Hk3EJwcUjBhzmzoaAdVI564/Z6WpmQ5Gz0NXxgHvPe/1FOuBDD80HleohQf2qKGY8ScRF1Skuivu0gra7tn9iaiQqbt7OPZwLoYKN/NIiJ/leUmxUYKkugcHy55pjh+/WemKafdUqpzAoGBAMAkdv22rAg5AaNh1SkGg+OaISvV1M6bc/MXVzoLb7pn35Uugb6++nPaU0/SNpsOAxhZSqA31FaRkb5RUEKrXJQhvQ5nHVKCEuban8J5fT5gNpaZ6mmebEACxcofxC3ykiy+dN5DHtaSleLOUnKAHFtN2gIdSAbGe/0oElam2bXJAoGBAJr6Nzu3IBbiOgYM/5XIRb6wk8ubwA+g6HtXsISif57htupIOFIdjAeg5vGUAYt5qGwtsS8q+w45xWgiEiOE6v0t2bEJjArecl8Abnx/9EaLrlmuZhthCpungvoprYk8VXu7i+38QCRnBVYQn4mb6ac89cOp2CLZv+TLD/mlHp3G";

    /**
     * 公钥
     */
    private static final String PUBLIC_KEY = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsNzaa7YgSOW8anMdaT8lqTZLugFu29FTHZbxS8UX+jhEOQs1iqsOiqkeEUJVH4x5VrxnBrcIykGK9AI1uzeb0Vwo5I72fHp0zuSWaKdOHe1T88ATGcXUJkf7yX6kiHsCdHVcKFjUNWQKqsJ/2cCkQNmxWHp4sj67HrANxJNSJ4ZSLpC2BWfEt5vRi+xqyxuW+BVYMv0j7Z9UboOovviM9VuYDKi5Pw2CCapmZrNpr7whURjjjkuxMoRWBY+0vzu0MDk4HJGsG3dYfBMkex9o3uR47eIxKOgMlVQBEDU9/0x7jLV9iH1YM7U8UGggQoti9pilToCmkl88APnmeeZ4YQIDAQAB";

    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

    /**
     * 获取密钥对象
     * @param keySize RSA算法模长(个人理解应该是模长越大加密安全性越高，但加密过程可能也越长)
     * @return List
     */
    public static List<Key> getRsaObject(int keySize) throws NoSuchAlgorithmException {
        //创建list用来接收公钥对象和私钥对象
        List<Key> keyList = new ArrayList<>();
        //创建RSA密钥生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA);
        //设置密钥大小，RSA算法的模长=最大加密数据的大小
        keyPairGenerator.initialize(keySize);
        //调用函数生成公钥私钥对象（以对生成密钥）
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //获取公钥放入list
        keyList.add(keyPair.getPublic());
        //获取私钥放入list
        keyList.add(keyPair.getPrivate());
        //返回list
        return keyList;
    }

    /**
     * 生成公钥私钥的字符串
     * @param keySize 模长
     * @return List
     */
    public static List<String> getRsaKeyString(int keySize) throws NoSuchAlgorithmException {
        //创建list用来接收公钥对象和私钥对象
        List<String> keyList = new ArrayList<>();
        //创建RSA密钥生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA);
        //设置密钥大小，RSA算法的模长=最大加密数据的大小
        keyPairGenerator.initialize(keySize);
        //调用函数生成公钥私钥对象（以对生成密钥）
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //将公钥对象转换为字符串通过base64加密
        String publicKey = Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());
        //将私钥对象转换为字符串通过base64加密
        String privateKey = Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded());
        //获取公钥放入list
        keyList.add(publicKey);
        //获取私钥放入list
        keyList.add(privateKey);
        //返回list
        return keyList;
    }

    /**
     * 通过公钥字符串生成公钥对象（RSAPublicKey类型）
     * X509EncodeKeySpec方式（字符串公钥转为RSAPublicKey公钥）
     * @param publicKeyStr  公钥字符串
     * @return 返回RSAPublicKey类型的公钥对象
     */
    public static RSAPublicKey getRSAPublicKeyByX509(String publicKeyStr) throws NoSuchAlgorithmException, InvalidKeySpecException {
        //密钥工厂创建
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        //公钥字符解密为bytes数组
        byte[] keyBytes = Base64.getDecoder().decode(publicKeyStr);
        //公钥字符串转x509
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
        //x509转RSAPublicKey
        return (RSAPublicKey) keyFactory.generatePublic(x509EncodedKeySpec);
    }

    /**
     * 通过私钥字符串生成私钥对象（RSAPrivateKey类型）
     * PKCS8EncodedKeySpec方式（字符串私钥转为RSAPrivateKey公钥）
     * @param privateKey 私钥字符串
     * @return 返回RSAPrivateKey类型的私钥对象
     */
    public static RSAPrivateKey getRSAPrivateKeyByPKCS8(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        //密钥工厂创建
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        //私钥字符串解密为bytes数组
        byte[] keyBytes = Base64.getDecoder().decode(privateKey);
        //Security.addProvider(new BouncyCastleProvider());
        //私钥字符串转pkcs8
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
        //pkcs8转RSAPrivateKey
        return (RSAPrivateKey) keyFactory.generatePrivate(pkcs8EncodedKeySpec);
    }

    /**
     * 公钥加密
     * @param message 需要加密的信息
     * @param rsaPublicKey rsa公钥对象
     * @return 返回信息被加密后的字符串
     */
    public static String encryptByPublicKey(String message, RSAPublicKey rsaPublicKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, IOException {
        //RSA加密实例
        Cipher cipher = Cipher.getInstance(RSA);
        //初始化公钥
        cipher.init(Cipher.ENCRYPT_MODE, rsaPublicKey);
        //模长转为字节数
        int modulusSize = rsaPublicKey.getModulus().bitLength()/8;
        //PKCS PADDING长度为11字节，解密数据是除去这11byte
        int maxSingleSize = modulusSize-11;
        //切分字节数，每段不大于maxSingleSize
        byte[][] dataArray = splitArray(message.getBytes(), maxSingleSize);
        //字节数组输出流
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        //分组加密，加密后内容写入输出字节流
        for (byte[] s : dataArray){
            byteArrayOutputStream.write(cipher.doFinal(s));
        }
        //使用base64将字节数组转为string类型
        return Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray());
    }

    /**
     * 公钥加密
     * @param message 需要加密的信息
     * @param publicKey rsa公钥字符串
     * @return 返回信息被加密后的字符串
     */
    public static String encryptByPublicKey(String message, String publicKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, IOException, InvalidKeySpecException {
        RSAPublicKey rsaPublicKeyByX509 = getRSAPublicKeyByX509(publicKey);
        return encryptByPublicKey(message,rsaPublicKeyByX509);
    }

    /**
     * 私钥解密密
     * @param encryptedMessage 信息加密后的字符串
     * @param rsaPrivateKey rsa私钥对象
     * @return 返回解密后的字符串
     */
    public static String decryptByPrivateKey(String encryptedMessage, RSAPrivateKey rsaPrivateKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, IOException {
        //RSA加密实例
//        Cipher cipher = Cipher.getInstance(RSA);
//        //初始化公钥
//        cipher.init(Cipher.DECRYPT_MODE, rsaPrivateKey);
//        //加密算法模长
//        int modulusSize = rsaPrivateKey.getModulus().bitLength()/8;
//        byte[] dataBytes = encryptedMessage.getBytes();
//        //加密做了转码，这里也要用base64转回来
//        byte[] decodeData = Base64.getDecoder().decode(dataBytes);
//        //切分字节数，每段不大于maxSingleSize
//        byte[][] dataArray = splitArray(decodeData, modulusSize);
//        //字节数组输出流
//        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
//        //分组解密，解密后内容写入输出字节流
//        for (byte[] s : dataArray){
//            byteArrayOutputStream.write(cipher.doFinal(s));
//        }
//        //使用base64将字节数组转为string类型
//        return byteArrayOutputStream.toString();
        //64位解码加密后的字符串
        byte[] inputByte = new byte[0];
        try {
            inputByte = decryptBASE64(encryptedMessage);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        //RSA解密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, rsaPrivateKey);
        String outStr = new String(cipher.doFinal(inputByte));
        return outStr;

    }
    //编码返回字符串
    public static String encryptBASE64(byte[] key) throws Exception {
        return (new BASE64Encoder()).encodeBuffer(key);
    }

    //解码返回byte
    public static byte[] decryptBASE64(String key) throws Exception {
        return (new BASE64Decoder()).decodeBuffer(key);
    }
    /**
     * 私钥解密密
     * @param encryptedMessage 信息加密后的字符串
     * @return 返回解密后的字符串
     */
    public static String decrypt(String encryptedMessage) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, IOException, InvalidKeySpecException {
        RSAPrivateKey rsaPublicKeyByX509 = getRSAPrivateKeyByPKCS8(PRIVATE_KEY);
        return decryptByPrivateKey(encryptedMessage,rsaPublicKeyByX509);
    }



    /**
     * 按指定长度切分数组
     * @param byteArrayInfo 需要切分的byte数组
     * @param maxSize 单个字节数组长度
     * @return byte[][]
     */
    private static byte[][] splitArray(byte[] byteArrayInfo, int maxSize){
        int dataLen = byteArrayInfo.length;
        if(dataLen<=maxSize){
            return new byte[][]{byteArrayInfo};
        }
        byte[][] result = new byte[(dataLen-1)/maxSize+1][];
        int resultLen = result.length;
        for (int i = 0; i < resultLen; i++) {
            if(i==resultLen-1){
                int sLen = dataLen-maxSize*i;
                byte[] single = new byte[sLen];
                System.arraycopy(byteArrayInfo, maxSize*i, single, 0, sLen);
                result[i] = single;
                break;
            }
            byte[] single = new byte[maxSize];
            System.arraycopy(byteArrayInfo, maxSize*i, single, 0, maxSize);
            result[i] = single;
        }
        return result;
    }

    /**
     * 返回公钥
     * @return String
     */
    public static String getPublicKey(){
        return PUBLIC_KEY;
    }

    public static void main(String[]args) throws NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, IOException, InvalidKeyException, InvalidKeySpecException {
        String message = "AiweOroQdIjSl9pv2GbRbx6NmJIUKrmGMbDtwUWAPjysHapIuZQ9UA9fhicbF3v8KNAqizMlAXWrtzKueVN8aC++mNN++dpQwQT1QNGMSiveGcH3BuWvW0A8AOmHiVtwHt6ybctzlxunoHdeg86dfVSx5mY1MVphmP+WbacHGbfppd6xIAamsAmU+";

        String message1 = decrypt(message);
        System.out.println("使用字符串转的rsa公钥对象加密后的字符串encryptedMsg1：\r\n"+message1);


    }

}

phone = EncryptUtils.decrypt(URLDecoder.decode(request.getParameter("phone"), StandardCharsets.UTF_8.toString()));

 let encrypt = new JSEncrypt();
        encrypt.setPublicKey(
          "....."
        );
          let datas = {
            phone: encodeURIComponent(encrypt.encrypt(this.Phone)),
            pwd: encodeURIComponent(encrypt.encrypt(this.pwd)),
          };