2019-09-26/RSA加密解密

在开发中我们会遇到这样的需求，前端的发送参数需要做加密处理，后端需要解密参数，再做业务处理。听起来是个无法让人拒绝的需求，不是吗？
这个有点跟https类似，在浏览器安装了证书，传输参数的时候就会使用证书中的公钥对参数加密处理，到达接收方之前在根据私钥去解密参数。那么既然https都给我们提供了这样的功能，在https之下，是否还需要我们的加密解密了，其实我也不是很理解，到底是多余呢还是更加安全。就让我们纠结一秒钟，继续往下读吧。
我的思路是这样的：先生成一个密钥对，把公钥放入前端，使用js对参数进行加密，后端使用私钥进行解密。
先来做密钥对的生成吧，这里我选择RSA加密解密算法，后端依赖的pom:

<dependency>
  <groupId>commons-codec</groupId>
  <artifactId>commons-codec</artifactId>
  <version>1.10</version>
</dependency>

改依赖是apache提供的base64加密解密的便捷类。如果你是jdk8+版本，也可以使用jdk自带的。
下面是java代码：

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
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.SecureRandom;
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 javax.crypto.Cipher;

/**
 * 公钥和私钥是一对
 */
public class RsaUtil {
    /**
     * 从base64的加密串中获取RSA公钥
     * @param base64String
     */
    private static PublicKey getPublicKeyFromString(String base64String)throws NoSuchAlgorithmException, InvalidKeySpecException, UnsupportedEncodingException {
        byte[] bt = Base64.decodeBase64(base64String.getBytes("utf-8"));
        X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(bt);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);
        return publicKey;
    }

    /**
     * 从base64的加密串中获取RSA私钥
     * @param base64String
     */
    private static PrivateKey getPrivateKeyFromString(String base64String)throws InvalidKeySpecException, NoSuchAlgorithmException,UnsupportedEncodingException {
        byte[] bt = Base64.decodeBase64(base64String.getBytes("utf-8"));
        PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(bt);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec);
        return privateKey;
    }

    /**
     * RSA非对称算法 公钥加密 
     * @param inputStr 明文
     * @param publicKey 公钥
     */
    public static String encryptByRSAPublicKey(String inputStr, String publicKey) throws Exception {
        PublicKey key = getPublicKeyFromString(publicKey);
        byte[] bt = Base64.encodeBase64(encryptByRSA(inputStr.getBytes(), key));
        return new String(bt,"utf-8");
    }
    private static byte[] encryptByRSA(byte[] input, Key key) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] output = cipher.doFinal(input);
        return output;
    }
    /**
     * RSA非对称算法 私钥解密
     * @param inputStr 密文
     * @param privateKey 私钥
     */
    public static String decryptByRSAPrivateKey(String inputStr, String privateKey) throws Exception {
        PrivateKey key = getPrivateKeyFromString(privateKey);
        return new String(decryptByRSA(Base64.decodeBase64(inputStr.getBytes("utf-8")), key));
    }
    private static byte[] decryptByRSA(byte[] input, Key key) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] output = cipher.doFinal(input);
        return output;
    }

    /**
     * 生成公私钥对
     */
    public static void getKeyPair() {
        KeyPairGenerator keyPairGenerator = null;
        try{
            keyPairGenerator = keyPairGenerator.getInstance("RSA");
        }catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        keyPairGenerator.initialize(1024, new SecureRandom());
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        String publicKeyString = Base64.encodeBase64String(publicKey.getEncoded());
        String privateKeyString = Base64.encodeBase64String(privateKey.getEncoded());
        System.out.println("公钥--"+publicKeyString);
        System.out.println("私钥--"+privateKeyString);
    }
}

调用getKeyPair()方法获得密钥对。
前端js使用公钥加密,这里使用jsencrypt.js进行加密：

var publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCN7t9X8nGnIsokeoI0Bazr9EslDoy14JwZOmx/2BeFGCOchLpHInnf80iJIQ+xxx5d8hjCvGlRbCnlSEixvmlfZKaCbx9BgA5eoLVzaPS625/9cWIz3JqYmOmtD+eujcCK3XymwwRMW1jbF+q0PR4aYF2F82yjQIDAQAB";
function getEncryptedStr(str){
    if(!str){
        return str;
    }
    //加密
    var encrypt = new JSEncrypt();
    encrypt.setPublicKey(publicKey);
    var encryptedStr = encrypt.encrypt(str);
    console.log('加密后数据：'+encryptedStr);
    return encryptedStr;
}

后端写个过滤器进行解密，这里过滤器各位自己写吧，这里提供简单的解密：

RsaUtil.decryptByRSAPrivateKey(要解密的参数值, ras私钥);

注意点：前端加密，会有返回false的情况。在java生成密钥对之后，我使用了base64进行加密，在js端我还使用了base64对公钥进行解密，得到了公钥。用这个公钥加密，总是返回false.后来发现直接使用后台base64加密后的公钥进行js加密就可以了，js不需要做base64解密公钥的操作。