前后端分离数据加密

最新推荐文章于 2024-09-02 21:46:29 发布
最新推荐文章于 2024-09-02 21:46:29 发布
阅读量1.6k 收藏 2
点赞数 3
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44694072/article/details/106929929
版权
  • 今天我们来聊一下前后端分离，数据的安全怎么保证
  • 现代随着网络的进步，数据的安全愈发重要，那么怎么保证数据的安全性呢？今天我来叫大家一种简单的方法。
  • 首先简单介绍，我今天要说的这套方法是用于 RSA+ASE+SHA256 的加密方式。
  • 然后咱们先从后端打起（不需要引用jar包）。代码如下：
package com.srx.Util;


import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
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.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
 
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
 
import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.digest.DigestUtils;
import org.junit.Test;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;


/**
 *  @Description: RSA+ASE+SHA256(非对称加密（对称秘钥），对称加密数据，Sha256消息摘要，RSA签名)
 *  @author 刘潇    2020年6月16日09:14:17 
 *  @version 1.0
 */
public class RAS {

	// 加密数据和秘钥的编码方式
    public static final String UTF_8 = "UTF-8";
    
	// 填充方式
    public static final String AES_ALGORITHM = "AES/CFB/PKCS5Padding";
    public static final String RSA_ALGORITHM = "RSA/ECB/PKCS1Padding";
    public static final String RSA_ALGORITHM_NOPADDING = "RSA";
    
     /**
      *  Description: 解密接收数据
      *  @author  wh.huang  DateTime 2018年11月15日 下午5:06:42
      *  @param externalPublicKey
      *  @param selfPrivateKey
      *  @param receivedMap
      *  @throws InvalidKeyException
      *  @throws NoSuchPaddingException
      *  @throws NoSuchAlgorithmException
      *  @throws BadPaddingException
      *  @throws IllegalBlockSizeException
      *  @throws UnsupportedEncodingException
      *  @throws InvalidAlgorithmParameterException
      *  @throws DecoderException
      */
    public static String decryptReceivedData(PublicKey externalPublicKey, PrivateKey selfPrivateKey, String receiveData) throws InvalidKeyException, NoSuchPaddingException, NoSuchAlgorithmException, BadPaddingException, IllegalBlockSizeException, UnsupportedEncodingException, InvalidAlgorithmParameterException, DecoderException {
        
    	@SuppressWarnings("unchecked")
    	Map<String, String> receivedMap = (Map<String, String>) JSON.parse(receiveData);
    	
    	// receivedMap为请求方通过from urlencoded方式，请求过来的参数列表
        String inputSign = receivedMap.get("sign");
        
        // 用请求方提供的公钥验签，能配对sign，说明来源正确
        inputSign = decryptRSA(externalPublicKey, inputSign);
        
        // 校验sign是否一致
        String sign = sha256(receivedMap);
        if (!sign.equals(inputSign)) {
            // sign校验不通过，说明双方发送出的数据和对方收到的数据不一致
            System.out.println("input sign: " + inputSign + ", calculated sign: " + sign);
            return null;
        }
        
        // 解密请求方在发送请求时，加密data字段所用的对称加密密钥
        String key = receivedMap.get("key");
        String salt = receivedMap.get("salt");
        key = decryptRSA(selfPrivateKey, key);
        salt = decryptRSA(selfPrivateKey, salt);
        
        // 解密data数据
        String data = decryptAES(key, salt, receivedMap.get("data"));
        System.out.println("接收到的data内容：" + data);
        return data;
    }
    
     /**
      *  Description: 加密数据组织示例
      *  @author  wh.huang DateTime 2018年11月15日 下午5:20:11
      *  @param externalPublicKey
      *  @param selfPrivateKey
      *  @return 加密后的待发送数据
      *  @throws NoSuchAlgorithmException
      *  @throws InvalidKeySpecException
      *  @throws InvalidKeyException
      *  @throws NoSuchPaddingException
      *  @throws UnsupportedEncodingException
      *  @throws BadPaddingException
      *  @throws IllegalBlockSizeException
      *  @throws InvalidAlgorithmParameterException
      */
    public static String encryptSendData(PublicKey externalPublicKey, PrivateKey selfPrivateKey,JSONObject sendData) throws NoSuchAlgorithmException, InvalidKeySpecException,
            InvalidKeyException, NoSuchPaddingException, UnsupportedEncodingException, BadPaddingException,
            IllegalBlockSizeException, InvalidAlgorithmParameterException {
        
        // 随机生成对称加密的密钥和IV (IV就是加盐的概念，加密的偏移量)
        String aesKeyWithBase64 = genRandomAesSecretKey();
        String aesIVWithBase64 = genRandomIV();
        
        // 用接收方提供的公钥加密key和salt，接收方会用对应的私钥解密
        String key = encryptRSA(externalPublicKey, aesKeyWithBase64);
        String salt = encryptRSA(externalPublicKey, aesIVWithBase64);
        
        // 组织业务数据信息，并用上面生成的对称加密的密钥和IV进行加密
        System.out.println("发送的data内容：" + sendData.toJSONString());
        String cipherData = encryptAES(aesKeyWithBase64, aesIVWithBase64, sendData.toJSONString());
        
        // 组织请求的key、value对
        Map<String, String> requestMap = new TreeMap<String, String>();
        requestMap.put("key", key);
        requestMap.put("salt", salt);
        requestMap.put("data", cipherData);
        requestMap.put("source", "由接收方提供"); // 添加来源标识
 
        // 计算sign，并用请求方的私钥加签，接收方会用请求方发放的公钥验签
        String sign = sha256(requestMap);
        requestMap.put("sign", encryptRSA(selfPrivateKey, sign));
        
        // TODO: 以form urlencoded方式调用，参数为上面组织出来的requestMap
        
        // 注意：请务必以form urlencoded方式，否则base64转码后的个别字符可能会被转成空格，对方接收后将无法正常处理
        JSONObject json = new JSONObject();
        json.putAll(requestMap);
        return json.toString();
    }
    
     /**
      *  Description: 获取随机的对称加密的密钥
      *  @author  wh.huang  DateTime 2018年11月15日 下午5:25:53
      *  @return  对称秘钥字符
      *  @throws NoSuchAlgorithmException
      *  @throws UnsupportedEncodingException
      *  @throws IllegalBlockSizeException
      *  @throws BadPaddingException
      *  @throws InvalidKeyException
      *  @throws NoSuchPaddingException
     */
    private static String genRandomAesSecretKey() throws NoSuchAlgorithmException, UnsupportedEncodingException,
            IllegalBlockSizeException, BadPaddingException, InvalidKeyException, NoSuchPaddingException {        
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(128);
        SecretKey secretKey = keyGen.generateKey();
        String keyWithBase64 = Base64.encodeBase64(secretKey.getEncoded()).toString();
        
        return keyWithBase64;
        
    }
    
    private static String genRandomIV() {
        SecureRandom r = new SecureRandom();
        byte[] iv = new byte[16];
        r.nextBytes(iv);
        String ivParam = Base64.encodeBase64(iv)+"";
        return ivParam;
    }
    
    /**
     * 对称加密数据
     * 
     * @param keyWithBase64
     * @param aesIVWithBase64
     * @param plainText
     * @return
     * @throws NoSuchAlgorithmException
     * @throws NoSuchPaddingException
     * @throws InvalidKeyException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     * @throws UnsupportedEncodingException
     * @throws InvalidAlgorithmParameterException 
     */
    private static String encryptAES(String keyWithBase64, String ivWithBase64, String plainText)
            throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException,
            BadPaddingException, UnsupportedEncodingException, InvalidAlgorithmParameterException {
    	byte[] keyWithBase64Arry = keyWithBase64.getBytes();
    	byte[] ivWithBase64Arry = ivWithBase64.getBytes();
        SecretKeySpec key = new SecretKeySpec(Base64.decodeBase64(keyWithBase64Arry), "AES");
        IvParameterSpec iv = new IvParameterSpec(Base64.decodeBase64(ivWithBase64Arry));
        
        Cipher cipher = Cipher.getInstance(AES_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key, iv);
       
        return Base64.encodeBase64(cipher.doFinal(plainText.getBytes(UTF_8))).toString();
    }
    
    /**
     * 对称解密数据
     * 
     * @param keyWithBase64
     * @param cipherText
     * @return
     * @throws NoSuchAlgorithmException
     * @throws NoSuchPaddingException
     * @throws InvalidKeyException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     * @throws UnsupportedEncodingException
     * @throws InvalidAlgorithmParameterException 
     */
    private static String decryptAES(String keyWithBase64, String ivWithBase64, String cipherText)
            throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException,
            BadPaddingException, UnsupportedEncodingException, InvalidAlgorithmParameterException {
    	byte[] keyWithBase64Arry = keyWithBase64.getBytes();
    	byte[] ivWithBase64Arry = ivWithBase64.getBytes();
    	byte[] cipherTextArry = cipherText.getBytes();
    	SecretKeySpec key = new SecretKeySpec(Base64.decodeBase64(keyWithBase64Arry), "AES");
        IvParameterSpec iv = new IvParameterSpec(Base64.decodeBase64(ivWithBase64Arry));
        
        Cipher cipher = Cipher.getInstance(AES_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key, iv);
        return new String(cipher.doFinal(Base64.decodeBase64(cipherTextArry)), UTF_8);
    }
    
    /**
     * 非对称加密，根据公钥和原始内容产生加密内容
     * 
     * @param key
     * @param content
     * @return
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeyException
     * @throws UnsupportedEncodingException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws InvalidAlgorithmParameterException
     */
    private static String encryptRSA(Key key, String plainText)
            throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException,
            BadPaddingException, IllegalBlockSizeException, InvalidAlgorithmParameterException {
        Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        return Base64.encodeBase64(cipher.doFinal(plainText.getBytes(UTF_8))).toString();
    }
    
    /**
     * 根据私钥和加密内容产生原始内容
     * @param key
     * @param content
     * @return
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeyException
     * @throws DecoderException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws UnsupportedEncodingException
     * @throws InvalidAlgorithmParameterException
     */
    private static String decryptRSA(Key key, String content) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, DecoderException, BadPaddingException, IllegalBlockSizeException, UnsupportedEncodingException, InvalidAlgorithmParameterException {
        Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] contentArry = content.getBytes();
        return new String(cipher.doFinal(Base64.decodeBase64(contentArry)), UTF_8);
    }
    
    /**
     * 计算sha256值
     * 
     * @param paramMap
     * @return 签名后的所有数据，原始数据+签名
     */
    private static String sha256(Map<String, String> paramMap) {
        Map<String, String> params = new TreeMap<String, String>(paramMap);
        
        StringBuilder concatStr = new StringBuilder();
        for (Entry<String, String> entry : params.entrySet()) {
            if ("sign".equals(entry.getKey())) {
                continue;
            }
            concatStr.append(entry.getKey() + "=" + entry.getValue() + "&");
        }
        
        return DigestUtils.md5Hex(concatStr.toString());
    }
    
    /**
     * 创建RSA的公钥和私钥示例 将生成的公钥和私钥用Base64编码后打印出来
     * @throws NoSuchAlgorithmException
     */
    public static void createKeyPairs() throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(1234);  //根据这个值生成公私钥 2048
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
        System.out.println("公钥"+Base64.encodeBase64(publicKey.getEncoded()));
        System.out.println("私钥"+Base64.encodeBase64(privateKey.getEncoded()));
//      查看公私钥        
        String s = new String(Base64.encodeBase64(publicKey.getEncoded()));
        String sr = new String(Base64.encodeBase64(privateKey.getEncoded()));
        System.out.println("公"+s);
        System.out.println("私"+sr);
    
       
    }
    
    
//	 测试公私钥生成    
    @Test
    public void aaa(){
    	try {
			RAS.createKeyPairs();
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
    
    /**
     *  Description:默认的RSA解密方法 一般用来解密 参数 小数据
     *  @author  wh.huang  DateTime 2018年12月14日 下午3:43:11
     *  @param privateKeyStr
     *  @param data
     *  @return
     *  @throws NoSuchAlgorithmException
     *  @throws InvalidKeySpecException
     *  @throws NoSuchPaddingException
     *  @throws InvalidKeyException
     *  @throws IllegalBlockSizeException
     *  @throws BadPaddingException
    */
   public static String decryptRSADefault(String privateKeyStr,String data) throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
     KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM_NOPADDING);
     byte[] privateKeyArray = privateKeyStr.getBytes();
     byte[] dataArray = data.getBytes();
     PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyArray));
     PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
     
     Cipher cipher = Cipher.getInstance(RSA_ALGORITHM_NOPADDING);
     cipher.init(Cipher.DECRYPT_MODE, privateKey);
     return new String(cipher.doFinal(Base64.decodeBase64(dataArray)), UTF_8);
   }

}

后端打起了咱们就要从前端正式开始编码，
1、咱们先用后端代码中的@test单元测试生成公私钥，并记录下来，然后创建一个隐藏域将记录的公钥cv一下

<textarea id="publickey" rows="20" cols="60" style="display:none">
	     -----BEGIN PUBLIC KEY-----
		你的私钥
		-----END PUBLIC KEY-----
</textarea>

2、导入相应的js

<script src="js/jquery.js" type="text/javascript"></script>
 
<!-- 引入非对称RSA加密工具 -->
<script src="js/encrypt/csoft_encrypt.min.js"></script>

3、我在这里提供一个简单的前端加密方法，代码如下：

function qyzx(nbxh,url,ff){
  
        // 获取公钥
        var publicKey = $('#publickey').val();
            
	    // 创建加密实例
        var jsencrypt = new JSEncrypt();
 
		// 初始化公钥
        jsencrypt.setPublicKey(publicKey);
			
	    // 加密数据
        nbxh =jsencrypt.encrypt(nbxh);
                
 	    var e = document.createElement("a");
 
 		e.href = url+"xxxx.do?method="+ff+"&nbxh="+nbxh+"&bqz=hz";
 
        e.target="_blank";
 
 		document.body.appendChild(e);
 
 		e.click();
 	}

4、到了这一步，前端向后端发送加密数据就已经成功了，接下来我们进行后端的解密工作，就可以使用加密数据了，代码如下：

	final String PRIVATE_KEY_STR = "你的私钥";
	try {
		String aaa = RAS.decryptRSADefault(PRIVATE_KEY_STR,"111111");
	} catch (InvalidKeyException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (NoSuchAlgorithmException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (InvalidKeySpecException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (NoSuchPaddingException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IllegalBlockSizeException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (BadPaddingException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (UnsupportedEncodingException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

就此一个简单的公私钥加密就完成了。
前端加密js下载地址：https://github.com/travist/jsencrypt

前后端分离加密通讯（AES）
weixin_43884534的博客
05-05 644
前后端加密通讯
前后端分离------后端创建笔记（09）密码加密网络安全
weixin_54048131的博客
08-15 738
本文章转载于【SpringBoot+Vue】全网最简单但实用的前后端分离项目实战笔记 - 前端_大菜007的博客-CSDN博客仅用于学习和讨论，如有侵权请联系源码：https://gitee.com/green_vegetables/x-admin-project.git素材：https://pan.baidu.com/s/1ZZ8c-kRPUxY6FWzsoOOjtA 提取码：up4c。
前后端分离使用RSA加密
我认不到你的博客
10-26 2850
RSA公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在（美国麻省理工学院）开发的。RSA取名来自开发他们三者的名字。RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的所有密码攻击，已被ISO推荐为公钥数据加密标准。目前该加密方式广泛用于网上银行、数字签名等场合。RSA算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。
SpringBoot实现前后端传输加密设计
最新发布
LiuCJ_20000的博客
09-02 2043
在Web应用中，确保前后端之间的数据传输安全是非常重要的。这通常涉及到使用HTTPS协议、数据加密、令牌验证等安全措施。本文通过将前后端之间的传输数据进行加密，用于在Spring Boot应用中实现前后端传输加密设计。 即使使用了HTTPS，也可能需要在应用层对数据进行额外的加密。这可以通过以下方式实现：这里就赘述介绍每种加密的实现方式和原理。
前后端分离密码登陆加密RSA方案(java后端)
haoweng4800的博客
03-22 1145
前言：密码加密有很多种方案，这里不做过多讨论，本篇文章是基于RSA加密实现。 首先在前端工程中需要引入加密js："jsencrypt": "2.3.1",（注意单独导入可能报错，可以删除整个node_modules，然后重新npm install） 然后在登陆提交表单的地方代码修改如下： // 引入js import {JSEncrypt} from 'jsencrypt'...
系列一、RuoYi前后端分离（登录密码加密）
热门推荐
仰望星空，脚踏实地！安全感是自己给的，努力才是一辈子的安全感。
05-27 1万+
RSAUtil中添加了@Component注解，generateKeyPair()构建秘钥对添加了@Bean注解，在项目启动时通过@Bean的方式将普通类实例化到Spring容器中，所以当系统启动后，每次调用接口得到的公钥&私钥是一样的，服务重启后，公钥&私钥重新生成。==========================O(∩_∩)O 后端修改over O(∩_∩)O==========================④、后端通过私钥对加密后的秘钥进行解密，验证密码。③、前端传输加密后的秘密给后端；
前后端分离数据的加密和验签
weixin_30642305的博客
11-09 293
数据加密 　　加密规则：将前端传来的所有参数中，pop掉sign参数<待校验的加密结果>，将其余所有的参数按照ascii码的升序排序，在拼接上前后端预定的规定的api_key，将拼接结果MD5加密。 　　备注：示例中参数之间的拼接使用的为 "&"，可根据具体情况自定义 后端代码示例： #!/usr/bin/env python # -*- coding: utf-...
前后端分离数据加密传输
03-30
前后端分离数据加密传输主要是通过...通过以上步骤，就能够实现前后端分离数据加密传输，保证数据的安全性。需要注意的是，SSL证书的申请和安装需要一定的技术和资金支持，而且证书的有效期一般为一年，需要定期更新。
VUE+node（express）实现前后端分离
01-19
无数据库，使用端口保存数据。 VUE: 使用vue-cli构建vue项目（vueapp）。 npm install -g vue-cli（安装，安装过的就不用了） vue init webpack vueapp axios：（与ajax相似） import axios from 'axios' var url...
14-SpringSecurity：前后端分离项目中用户名与密码通过RSA加密传输
2401_84046545的博客
05-03 839
1.12/**RSA公钥加密@param str 待加密字符串@param publicKey 公钥@return 密文*/try {//base64编码的公钥//RSA加密/**RSA私钥解密@param str 已加密字符串@param privateKey 私钥@return 明文*/try {//64位解码加密后的字符串//base64编码的私钥//RSA解密。
前后端分离，请求加密思路
liluo101的博客
02-02 1643
1.声明，Access-Control-Allow-Origin 可以指定某个地址访问，可以保证安全 2.多个地址想要访问一个后台地址，似乎有点难，尝试了写正则，不过不太好 3.用的koa2写的后台， vue3前台，本来想着 用crytojs来加密解密，但是感觉有点太杀鸡用牛刀的感觉，个人不喜欢 import各种包，能自己实现的就尽可能自己实现 4.直到我发现了window.btoa，一番折腾，找到了还算可行的加密方法 下面贴给大家 前端代码，写在axios里面的， 主要是添加了一个自定义Hea
前后端加密CryptoJS包
06-13
前后端分离时会遇到一些数据传输安全问题，这时候大家就考虑到前后端能互通加密解密，前端就使用这个包可以搞定
今日学习--前后端数据加密及在线客户系统
shybiubiuccy的博客
11-15 394
最近工作涉及到相关知识故学习并记录一下。1、前后端分离开发时的前后端之间的数据如何加密保证数据安全等情况2、在线客服功能如何实现。
Jeecg-Boot前后端分离，针对敏感数据，加密传递方案
weixin_30807677的博客
07-05 258
# 针对敏感数据，加密传递方案 第一步： 在vue页面引入aesEncrypt.js encryption方法。示例代码： import { encryption } from '@/utils/encryption/aesEncrypt' 第二步： 请求后台获取 /sys/getEncryptedString 接口，以此获取加密所需要的key和iv 第三步： ...
前后端分离API接口如何加密 —— AES加密方案
zhengTornado的博客
08-18 5708
场景还原：页面中需要展示手机号，身份证号，因为是前后端分离，所有接口API地址有可能暴露，这样不怀好意的人可以拿到个人敏感信息 解决方案： 1. 敏感信息加掩码，例如：接口返回130**12这样的手机号。弊端：在有表单中无法实现这种方案。 2. 后端加密，前端解密的方式（本文采用的方式），前后端统一加密方案，salt字符串等信息。弊端：前端js无法做到高级加密，salt可以被查到，但是成本相对较高。 后台加密工具类 package org.jeecg.modules.system.util; im.
前后端分离的参数加解密
YSOLA4的专栏
07-01 1172
前后端分离, 加解密参数请求
【Java】RuoYi+SpringBoot+前后端分离版添加接口加密（参考）
New_hl的博客
02-05 1804
这次更新参考了其他博主内容，在基础上做了备注及调整。
前后端数据加密传输基于AES+RSA实现
孙霸天的专栏
09-03 4717
前后端数据加密传输基于AES+RSA实现，优化升级版本
前后端分离通过RSA加密解密传输数据
HH_KELE的专栏
02-25 2280
Provider p = new BouncyCastleProvider(); KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA", p); keyPairGen.initialize(1024, new SecureRandom()); KeyPair ke...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值