前后端分离使用RSA加密

news/2024/7/15 19:46:32 标签: java, spring boot, react.js, 前端

简介

1、前提

本篇文章前端使用的react，后端用的springboot，前端用什么框架都可以，大体实现逻辑是一样的，而且也是用jsencrypt这个库，只是后端可以我写的（大部分是copy的别人的代码）用RAS的工具类，直接用就好了

2、什么是RSA（非对称加密）

RSA是什么：RSA公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在（美国麻省理工学院）开发的。RSA取名来自开发他们三者的名字。RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的所有密码攻击，已被ISO推荐为公钥数据加密标准。目前该加密方式广泛用于网上银行、数字签名等场合。RSA算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

3、为什么前后端交互用使用非对称加密，而不使用对称加密

以下是我的一些见解，如果有不对希望大佬可以指出，我后续如果发现有问题我也会更改

非对称加密：简单来说就是数据通过RSA的算法得到的公钥和私钥，可以用公钥给数据加密，然后只能用私钥解密，公钥给前端（公钥可以明文），加密数据后可以把数据给后端解密，而私钥只存于后端，所以是非常安全的

对称加密：如果是对称加密用于前后端交互的话（最经典是AES），用于存在前端，而前端的js，如果有心都可以看见有什么内容，所以就可以拿到AES的秘钥，那么就可以破解密文了，所以用于前后端交互是不安全的，但只用于后端的加密是很安全的，因为私钥基本不好获取

由于非对称加密是非常消耗资源的，所以也不用啥都加密，因为一般前后端交互，登录后之后的操作都会传token给后端进行判断，所以也算是安全的，但是登录的时候肯定没有token，而且账户密码明文在网络中传输肯定是不安全的，所以我这篇文章讲的就是前段登录的时候给密码加密

如果你的网页用了证书（就是从http变成了https），那么访问后端就自动加密了（非对称加密和对称加密都用到了）

后端（主要把工具类看一下就好）

1、直接上工具类（该方法我大部分copy的网上一位大佬的，但是他写的不是很全，我自己加了一些比较好用的方法）

我公钥私钥都是改过的了，所以别想搞我（主要可以看main方法）

java">/**
 * 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);
    }
}

2、登录Demo：路径：/login

java">    @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","登录失败，请检查账号和密码");
        }
    }

3、给前端返回公钥（就不用前端写死了，想改的时候后端随时改）路径：/login/queryPublicKey

java">    @PostMapping("login/queryPublicKey")
    public Results<String> queryPublicKey() {
        return Results.success("成功",RSAUtils.getPublicKey());
    }

前端(使用 jsencrypt 进行RSA加密)

1、安装 jsencrypt

npm install jsencrypt

2、封装一个工具类

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);
}

3、登录的时候，先调用/login/queryPublicKey，并给密码加密后，调用/login登录


http://www.niftyadmin.cn/n/5125308.html

相关文章

React之Jsx如何转换成真实DOM

React之Jsx如何转换成真实DOM

一、是什么 react通过将组件编写的JSX映射到屏幕&#xff0c;以及组件中的状态发生了变化之后 React会将这些「变化」更新到屏幕上 在前面文章了解中&#xff0c;JSX通过babel最终转化成React.createElement这种形式&#xff0c;例如&#xff1a; <div>< img src&q…
阅读更多...
基于springboot+vue实现地方美食分享网站项目【项目源码+论文说明】

基于springboot+vue实现地方美食分享网站项目【项目源码+论文说明】

基于springbootvue实现地方美食分享网站演示 摘要 首先&#xff0c;论文一开始便是清楚的论述了系统的研究内容。其次&#xff0c;剖析系统需求分析&#xff0c;弄明白“做什么”&#xff0c;分析包括业务分析和业务流程的分析以及用例分析&#xff0c;更进一步明确系统的需求…
阅读更多...
@AutoConfigurationPackage注解类

@AutoConfigurationPackage注解类

包名package org.springframework.boot.autoconfigure 方法 String[] basePackages() 向AutoConfigurationPackages中注册的基本包&#xff0c;使用basePackageClasses作为基于字符串的包的类型安全替代方案 Class<?>[] basePackageClasses() 键入basePackage…
阅读更多...
8位机adc采样正弦波频率

8位机adc采样正弦波频率

相位/峰峰值高电平&#xff1f; 检 测峰值电压&#xff1f; y 开始计数 检测零电压 y 计数器值16ms/20ms 斩波开x关x延时 tt 频率 1/2t 电路 增减常数 aT
阅读更多...
【JavaEE初阶】 线程安全的集合类

【JavaEE初阶】 线程安全的集合类

文章目录 &#x1f340;前言&#x1f332;多线程环境使用 ArrayList&#x1f6a9;自己使用同步机制 (synchronized 或者 ReentrantLock)&#x1f6a9;Collections.synchronizedList(new ArrayList);&#x1f6a9;使用 CopyOnWriteArrayList &#x1f38d;多线程环境使用队列&am…
阅读更多...
MarkDown详细入门笔记

MarkDown详细入门笔记

本帖整理了MarkDown的入门学习笔记~ 一.介绍 Markdown 是一种轻量级的「标记语言」&#xff0c;它的优点很多&#xff0c;目前也被越来越多的写作爱好者&#xff0c;撰稿者广泛使用。 诸如微信公众平台、CSDN博客、还有Typora中写文档的部分&#xff0c;均涉及到MD的功能~ 它…
阅读更多...
数据库扫描工具scuba

数据库扫描工具scuba

目录: Scuba的简单介绍 Scuba的安装 ：Windows安装 、Linux安装 Scuba的扫描及结果分析 一、什么是Scuba？ Scuba是一款网络安全扫描工具，而非数据库扫描软件。Scuba支持对Web应用程序、操作系统、网络协议等进行扫描，以发现潜在的安全漏洞和风险，并提供详细的扫描结果报告…
阅读更多...
代码审计及示例

代码审计及示例

简介&#xff1a; 代码安全测试是从安全的角度对代码进行的安全测试评估。 结合丰富的安全知识、编程经验、测试技术&#xff0c;利用静态分析和人工审核的方法寻找代码在架构和编码上的安全缺陷&#xff0c;在代码形成软件产品前将业务软件的安全风险降到最低。 方法&#x…
阅读更多...
最新文章

Copyright @ 2022~2023