本篇文章前端使用的react,后端用的springboot,前端用什么框架都可以,大体实现逻辑是一样的,而且也是用jsencrypt这个库,只是后端可以我写的(大部分是copy的别人的代码)用RAS的工具类,直接用就好了
RSA是什么:RSA公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在(美国麻省理工学院)开发的。RSA取名来自开发他们三者的名字。RSA是目前最有影响力的公钥加密算法,它能够抵抗到目前为止已知的所有密码攻击,已被ISO推荐为公钥数据加密标准。目前该加密方式广泛用于网上银行、数字签名等场合。RSA算法基于一个十分简单的数论事实:将两个大素数相乘十分容易,但那时想要对其乘积进行因式分解却极其困难,因此可以将乘积公开作为加密密钥。
以下是我的一些见解,如果有不对希望大佬可以指出,我后续如果发现有问题我也会更改
非对称加密:简单来说就是数据通过RSA的算法得到的公钥和私钥,可以用公钥给数据加密,然后只能用私钥解密,公钥给前端(公钥可以明文),加密数据后可以把数据给后端解密,而私钥只存于后端,所以是非常安全的
对称加密:如果是对称加密用于前后端交互的话(最经典是AES),用于存在前端,而前端的js,如果有心都可以看见有什么内容,所以就可以拿到AES的秘钥,那么就可以破解密文了,所以用于前后端交互是不安全的,但只用于后端的加密是很安全的,因为私钥基本不好获取
由于非对称加密是非常消耗资源的,所以也不用啥都加密,因为一般前后端交互,登录后之后的操作都会传token给后端进行判断,所以也算是安全的,但是登录的时候肯定没有token,而且账户密码明文在网络中传输肯定是不安全的,所以我这篇文章讲的就是前段登录的时候给密码加密
如果你的网页用了证书(就是从http变成了https),那么访问后端就自动加密了(非对称加密和对称加密都用到了)
我公钥私钥都是改过的了,所以别想搞我(主要可以看main方法)
/**
* RSA加密解密工具类
*/
public class RSAUtils {
/**
* 常量字符串
*/
private static final String RSA = "RSA";
/**
* 私钥
*/
private static final String PRIVATE_KEY = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAItn9b5IvrTh1rnhzJJFNQ4UnJBL9kRitVHHklkz28ykYB5IWWM4lvZ7VzBP01AFG/I+otjr62Xx+gurInr22/F8FA4uKOmiYCPPf5h1mEvRK0y20ShYtDiwu9eM8hYkCqBvBHDKYjNAFmw3+HRzgCmGFEnmAG44bKCnZiMqUEf9AgMBAAECgYA05uCksypbrhA0PfHJ2CWIEF5Ri+IKlYLFY/yviTRx9jbbhw0U0BbJtoihtskz5pxyUz6tHuoXp7oBz5GoJCHWcvUGHTfJx8aq2IJwfJKGfi5V1I7ke3H6A8fI9lE8Y62lFSJmZITbUv3TsBiec/GhotYn3x5cu329MFX6miY7QQJBANwuq/jRM9RB+d8NUdO9XsWHVqCVp59J1KyKR7UHTgshH5ahHUGiSBtqM9yirKPnPHJLZpDsloNUDm7xhoLfULkCQQCiFWw7VZ7gKwY6q4nxBcb5BXDb3Fa5JKr7ggduvF8C90nue7TMbVMr0z8HHDvqhjzD06XTYG2P4+xPBwm5E2dlAkAMHkl6xVDb8tGk1B/Xzoljx8Idzn7ORor9ABNYRFGoTSdm6/EnRp4/XAYEs7NaxgROqhW4Dj1udvbgZkyn8VCJAkAJPV9mIoNkFA/O2GiMrN+i4oSEhBMNiuGUZN03mtVvvdkhFzw/Sxwqq2g0Z4+i1vQv1ajmW+DjCwM1nhkXy9thAkBPh46mKPQ58yURs9hlhLlUziUFjq83sSzXJkZQx7EWOud0U8Nriq+xsrVKJRkzntmIhLBacdwQSyImIWkStd7v";
/**
* 公钥
*/
private static final String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCLZ/W+SL604da54cySRTUOFJyQS/ZEYrVRx5JZM9vMpGAeSFljOJb2e1cwT9NQBRvyPqLY6+tl8foLqyJ69tvxfBQOLijpomAjz3+YdZhL0StMttEoWLQ4sLvXjPIWJAqgbwRwymIzQBZsN/h0c4AphhRJ5gBuOGygp2YjKlBH/QIDAQAB";
/**
* 获取密钥对象
* @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);
//私钥字符串转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();
}
/**
* 私钥解密密
* @param encryptedMessage 信息加密后的字符串
* @param privateKey rsa私钥字符串
* @return 返回解密后的字符串
*/
public static String decryptByPrivateKey(String encryptedMessage, String privateKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, IOException, InvalidKeySpecException {
RSAPrivateKey rsaPublicKeyByX509 = getRSAPrivateKeyByPKCS8(privateKey);
return decryptByPrivateKey(encryptedMessage,rsaPublicKeyByX509);
}
/**
* 私钥解密密
* @param encryptedMessage 信息加密后的字符串
* @return 返回解密后的字符串
*/
public static String decryptByPrivateKey(String encryptedMessage) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, IOException, InvalidKeySpecException {
return decryptByPrivateKey(encryptedMessage,PRIVATE_KEY);
}
/**
* 按指定长度切分数组
* @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 = "fdsihufdiuheiuhasfd";
System.out.println("加密前的信息内容:"+message);
System.out.println("-----------------------RSA密钥对象加密解密--------------------------------");
//生成密钥对象
List<Key> keyList = RSAUtils.getRsaObject(1024);
//RSA类型的公钥对象
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyList.get(0);
//RSA类型的私钥对象
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyList.get(1);
//通过RSA类型的公钥对象加密信息
String encryptedMsg = RSAUtils.encryptByPublicKey(message, rsaPublicKey);
System.out.println("加密后的字符串encryptedMsg:\r\n"+encryptedMsg);
//通过RSA类型的私钥对象解密
String decryptedMsg = RSAUtils.decryptByPrivateKey(encryptedMsg, rsaPrivateKey);
System.out.println("------");
System.out.println("解密后的字符串decryptedMsg:\r\n"+decryptedMsg);
System.out.println();
System.out.println("-----------------------字符串类型的密钥对象转为RSA密钥对象后的加密解密--------------------------");
//生成密钥(字符串类型的密钥)
List<String> keyStringList = RSAUtils.getRsaKeyString(1024);
//字符串类型的公钥
String publicKeyString = keyStringList.get(0);
System.out.println("生成的公钥,可以把 PUBLIC_KEY 改为此值:\r\n"+publicKeyString);
//字符串类型的私钥
String privateKeyString = keyStringList.get(1);
System.out.println("生成的私钥,可以把 PRIVATE_KEY 改为此值:\r\n"+publicKeyString);
//将字符串类型的公钥私钥转为RSA类型
RSAPublicKey rsaPublicKey1 = RSAUtils.getRSAPublicKeyByX509(publicKeyString);
RSAPrivateKey rsaPrivateKey1 = RSAUtils.getRSAPrivateKeyByPKCS8(privateKeyString);
//通过字符串公钥转为RSA类型的公钥 加密
String encryptedMsg1 = RSAUtils.encryptByPublicKey(message, rsaPublicKey1);
System.out.println("使用字符串转的rsa公钥对象加密后的字符串encryptedMsg1:\r\n"+encryptedMsg1);
//通过字符串私钥转为RSA类型的私钥 解密
String decryptedMsg1 = RSAUtils.decryptByPrivateKey(encryptedMsg1, rsaPrivateKey1);
System.out.println("------");
System.out.println("使用字符串转的私钥对象解密后的字符串decryptedMsg1:\r\n"+decryptedMsg1);
}
}
@PostMapping("login")
public Results<UserInfo> login(@RequestBody LoginDto loginDto){
try {
// 解密
String password = RSAUtils.decryptByPrivateKey(loginDto.getPassword());
// 这个加密是为了比对数据库中的值
password = AESUtils.encode(password);
// ......
return Results.success("成功",userInfo);
} catch (Exception e) {
log.error("密码解析报错",e);
return Results.failed("500","登录失败,请检查账号和密码");
}
}
@PostMapping("login/queryPublicKey")
public Results<String> queryPublicKey() {
return Results.success("成功",RSAUtils.getPublicKey());
}
npm install jsencrypt
import JSEncrypt from 'jsencrypt';
const JSE = new JSEncrypt();
// 封装加密方法
// publicKey 也可以写死,也可以调用后端接口得到,这样后端就可以随时改了,而明文的公钥放在网上也没啥
export const encodeStr = (str: string, publicKey: string) => {
// 设置公钥
JSE.setPublicKey(publicKey)
return JSE.encrypt(str); // 就这样简单,就可以返回加密后的密文了
}
// 封装加密方法,这里就是写死的,都可以
export const encodeStr = (str: string) => {
JSE.setPublicKey(`MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCLZ/W+SL604da54cySRTUOFJyQS/ZEYrVRx5JZM9vMpGAeSFljOJb2e1cwT9NQBRvyPqLY6+tl8foLqyJ69tvxfBQOLijpomAjz3+YdZhL0StMttEoWLQ4sLvXjPIWJAqgbwRwymIzQBZsN/h0c4AphhRJ5gBuOGygp2YjKlBH/QIDAQAB`)
return JSE.encrypt(str);
}