在开发中我们会遇到这样的需求，前端的发送参数需要做加密处理，后端需要解密参数，再做业务处理。听起来是个无法让人拒绝的需求，不是吗？
这个有点跟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解密公钥的操作。
