前台使用RSA非对称安全加密用户信息

最新推荐文章于 2024-07-10 19:41:59 发布

波斯_辣椒

最新推荐文章于 2024-07-10 19:41:59 发布

阅读量278

点赞数

文章标签： java javascript 安全

本文链接：https://blog.csdn.net/chwensrong/article/details/119674347

版权

本文介绍了在前端使用RSA非对称加密来保护用户信息的安全性。通过生成加密模块、公钥和私钥，公钥用于前端加密数据，私钥保留在后端进行解密。强调每次加密解密必须使用同一套密钥，同时总结了不同场景下的加解密处理方式，以应对各种框架和异常处理需求。

摘要由CSDN通过智能技术生成

首先简单明确一下对称加密和非对称加密之间的区别：
对称加密：即加密解密使用的是同一个密钥；
非对称加密：即生成两个密钥，加密时使用公钥，解密是使用的私钥；

说明：本次实践的加密操作主要生成以下三个关键对象
1.加密模块
2.加密公钥
3.加密私钥
思路：公钥的作用是加密指定字符串；私钥则是解密指定字符串；每次前台发送http请求至后台都将新生成加密模块、加密公钥、加密私钥，而公钥和加密模块则会送到前台对数据进行加密；私钥则保留在后台等待。当前台使用公钥加密过后，将数据传输到后台，再使用保留的私钥进行解密。
注意： 每次生成的 加密模块、加密公钥、加密私钥 都是组合产生的，非同一次产生的，将会包解密失败的错误！

下面我对于前台后台所有的加解密的情况做汇总，根据实际开发情况做灵活变通：

工具类：新建工具类，用于数据转换

public class HexUtil {
   
	 
    /**
     * 二进制byte数组转十六进制byte数组
     * byte array to hex
     *
     * @param b byte array
     * @return hex string
     */
    public static String byte2hex(byte[] b) {
   
        StringBuilder hs = new StringBuilder();
        String stmp;
        for (int i = 0; i < b.length; i++) {
   
            stmp = Integer.toHexString(b[i] & 0xFF).toUpperCase();
            if (stmp.length() == 1) {
   
                hs.append("0").append(stmp);
            } else {
   
                hs.append(stmp);
            }
        }
        return hs.toString();
    }
 
    /**
     * 十六进制byte数组转二进制byte数组
     * hex to byte array
     *
     * @param hex hex string
     * @return byte array
     */
    public static byte[] hex2byte(String hex)
             throws IllegalArgumentException{
   
        if (hex.length() % 2 != 0) {
   
            throw new IllegalArgumentException ("invalid hex string");
        }
        char[] arr = hex.toCharArray();
        byte[] b = new byte[hex.length() / 2];
        for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {
   
            String swap = "" + arr[i++] + arr[i];
            int byteint = Integer.parseInt(swap, 16) & 0xFF;
            b[j] = new Integer(byteint).byteValue();
        }
        return b;
    }
    
 
	 public static String bytesToHexString(byte[] src){
   
	        StringBuilder stringBuilder = new StringBuilder("");
	        if (src == null || src.length <= 0) {
   
	            return null;
	        }
	        for (int i = 0; i < src.length; i++) {
   
	            int v = src[i] & 0xFF;
	            String hv = Integer.toHexString(v);
	            if (hv.length() < 2) {
   
	                stringBuilder.append(0);
	            }
	            stringBuilder.append(hv);
	        }
	        return stringBuilder.toString();
	    }
	 private static byte charToByte(char c) {
     
		    return (byte) "0123456789ABCDEF".indexOf(c);  
		}
	 public static byte[] hexStringToBytes(String hexString) {
     
		    if (hexString == null || hexString.equals("")) {
     
		        return null;  
		    }  
		    hexString = hexString.toUpperCase();  
		    int length = hexString.length() / 2;  
		    char[] hexChars = hexString.toCharArray();  
		    byte[] d = new byte[length];  
		    for (int i = 0; i < length; i++) {
     
		        int pos = i * 2;  
		        d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));  
		    }  
		    return d;  
		}  
	   
}

核心：RSA加密类

import java.io.ByteArrayOutputStream;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
import java.math.BigInteger;  
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.SecureR