SpringBoot+VUE登录加密解密

最新推荐文章于 2024-06-23 17:44:38 发布
最新推荐文章于 2024-06-23 17:44:38 发布
阅读量5.2k 收藏 8
点赞数 1
分类专栏： 工具类 文章标签： spring boot vue.js 后端 登录加密解密 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012417405/article/details/131126924
版权
  • 前端首先调用后端的公钥接口,再在前端加密密码传输至后端登录接口, 后端用私钥解密码,拿着用户名去数据库查询出来的盐值加密的密码1,用私钥解密密码登录密码加盐值得到密码2, 比较密码1与密码2,相同则登录成功

1.前端

methods:{
    login(formName) {
      var param = new FormData()
      param.append('account', this.form.account)
      this.password = this.passwordEncryption(this.form.password)
      param.append('password', this.password)
      this.$refs[formName].validate((valid) => {
        if (valid) {
          postLogin(param, res=> {
            if (res.code === 200) {
              window.sessionStorage.setItem('token', res.data.token)
              setCookie('token', res.data.token)
              setCookie('userName', res.data.userInfo.account)
              setCookie('userId', res.data.userInfo.id)
              let loginData = JSON.stringify(res.data.permission)
              setCookie('permission', loginData)
              this.$notify({
                type: 'success',
                message: '登录成功'
              })
              this.$router.push({ path: '/Home' })

            } else {
              this.$notify({
                type: 'error',
                message: res.msg || '登录失败'
              })
            }
          })
        } else {
          console.log('error submit!!');
          return false;
        }
      })
    },
    /**
     * 加密
     * @param {String}  需要加密的参数
     */
    passwordEncryption (param) {
      // 后台给的公钥
      let encryptor = new JsEncrypt() // 新建JSEncrypt对象
      encryptor.setPublicKey(this.publicKey) // 设置公钥
      let passwordEncryp = encryptor.encrypt(param) // 对密码进行加密
      return passwordEncryp
    }
  },
  created() {
    getpublicKey(res => {
      if (res.code === 200) {
        this.publicKey = res.data
      }
    })
  }

在这里插入图片描述

2.后端

  • 2.1
/**
	 * 获取公钥
	 * @param request
	 * @return
	 */
	@ApiOperation(value = "获取公钥", httpMethod = "GET")
	@RequestMapping("/publicKey")
	@ResponseBody
	public CommonResult publicKey(HttpServletRequest request) {
		String publicKey = generateKey(request);
		return CommonResult.success("操作成功！",publicKey);
	}

	/**
	 * 生成随机码
	 * @param request
	 */
	private String generateKey(HttpServletRequest request) {
		try {
			Map<String, Object> keyMap = RSAUtils.genKeyPair();
			String publicKey = RSAUtils.getPublicKey(keyMap);
			String privateKey = RSAUtils.getPrivateKey(keyMap);
			request.getSession().setAttribute("privateKey", privateKey);
			return publicKey;
//              request.setAttribute("publicKey", publicKey);
//              request.setAttribute("privateKey", privateKey);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
  • 2.2
@ApiOperation(value = "登录", httpMethod = "POST")
    @RequestMapping(value = "/login")
    @ResponseBody
    public CommonResult login(HttpServletRequest request,
							@RequestParam(value = "account", required = true) String account,
							@RequestParam(value = "password", required = true) String password,
							@RequestParam(value = "rememberMe", required = true, defaultValue = "1") int rememberMe) {
		try {
			String privateKey = (String) request.getSession().getAttribute("privateKey");
			if (privateKey == null) {
				return CommonResult.failed("鉴权失败，请刷新页面,重新登陆！");
			}
			try {
				password = RSAUtils.decryptDataOnJava(password, privateKey);
			} catch (Exception e) {
				return CommonResult.failed("鉴权失败，请刷新页面,重新登陆！");
			}
			RcSysUserEntity byAccount = rcSysUserRepository.findByAccount(account);
			if (null!=byAccount) {
				if (byAccount.getStatus()==0) {
					return CommonResult.failed("账户已禁用！");
				}
				String md5_pwd = EncryptUtil.MD5(password+"{"+byAccount.getSalt()+"}");
				if (md5_pwd.equals(byAccount.getPassword())) {
					return loginService.loginV2(byAccount);
				}else{
					return CommonResult.failed("用户名或密码输入错误!");
				}
			}else{
				return CommonResult.failed("用户名或密码输入错误!");
			}
		} catch (Exception e) {
			e.printStackTrace();
			return CommonResult.failed("用户名或密码输入错误!");
		}
	}

3.工具类

package com.zkdj.data.common.domain;

import lombok.Data;

import java.io.Serializable;

/**
 * 通用返回对象
 *
 * @author Administrator
 */
@Data
public class CommonResult<T> implements Serializable {

    private static final long serialVersionUID = 5190371721822680303L;
    /**
     * 状态码
     */
    private int code;
    /**
     * 提示信息
     */
    private String message;
    /**
     * 数据封装
     */
    private T data;

    public CommonResult(int code, String message, T data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }

    /**
     * 返回成功信息
     *
     * @return
     */
    public static <T> CommonResult<T> success() {
        return new CommonResult<T>(ResultCode.SUCCESS.getCode(), ResultCode.SUCCESS.getMessage(), null);
    }

    public static <T> CommonResult<T> success(T data) {
        return new CommonResult<T>(ResultCode.SUCCESS.getCode(), ResultCode.SUCCESS.getMessage(), data);
    }

    public static <T> CommonResult<T> success(String message, T data) {
        return new CommonResult<T>(ResultCode.SUCCESS.getCode(), message, data);
    }

    /**
     * 返回失败信息
     *
     * @return
     */
    public static <T> CommonResult<T> failed() {
        return new CommonResult<T>(ResultCode.FAILED.getCode(), ResultCode.FAILED.getMessage(), null);
    }

    public static <T> CommonResult<T> failed(String message) {
        return new CommonResult<T>(ResultCode.FAILED.getCode(), message, null);
    }

    public static <T> CommonResult<T> failed(int code, String message) {
        return new CommonResult<T>(code, message, null);
    }

    /**
     * 返回参数校验失败信息
     *
     * @return
     */
    public static <T> CommonResult<T> validateFailed() {
        return new CommonResult<T>(ResultCode.VALIDATE_FAILED.getCode(), ResultCode.VALIDATE_FAILED.getMessage(), null);
    }

    public static <T> CommonResult<T> validateFailed(String message) {
        return new CommonResult<T>(ResultCode.VALIDATE_FAILED.getCode(), message, null);
    }

    public static <T> CommonResult<T> forbidden() {
        return new CommonResult<T>(ResultCode.FORBIDDEN.getCode(), ResultCode.FORBIDDEN.getMessage(), null);
    }

}


package com.zkdj.data.utils;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.Key;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * Java加密解密工具.3DES SHA1 MD5 BASE64编码 AES加密 
 * @author gq
 */
public class EncryptUtil {
	// 无需创建对象
	private EncryptUtil() {
		
	}
 
	
 
	/**
	 * SHA1加密Bit数据
	 * 
	 * @param source
	 *            byte数组
	 * @return 加密后的byte数组
	 */
	public static byte[] SHA1Bit(byte[] source) {
		try {
			MessageDigest sha1Digest = MessageDigest.getInstance("SHA-1");
			sha1Digest.update(source);
			byte targetDigest[] = sha1Digest.digest();
			return targetDigest;
		} catch (NoSuchAlgorithmException e) {
			throw new RuntimeException(e);
		}
	}
 
	/**
	 * SHA1加密字符串数据
	 * 
	 * @param source
	 *            要加密的字符串
	 * @return 加密后的字符串
	 */
	public static String SHA1(String source) {
		return byte2HexStr(SHA1Bit(source.getBytes()));
	}
 
	/**
	 * MD5加密Bit数据
	 * 
	 * @param source
	 *            byte数组
	 * @return 加密后的byte数组
	 */
	public static byte[] MD5Bit(byte[] source) {
		try {
			// 获得MD5摘要算法的 MessageDigest对象
			MessageDigest md5Digest = MessageDigest.getInstance("MD5");
			// 使用指定的字节更新摘要
			md5Digest.update(source);
			// 获得密文
			return md5Digest.digest();
		} catch (NoSuchAlgorithmException e) {
			throw new RuntimeException(e);
		}
	}
 
	/**
	 * MD5加密字符串,32位长
	 * 
	 * @param source
	 *            要加密的内容
	 * @return 加密后的内容
	 */
	public static String MD5(String source) {
		return byte2HexStr(MD5Bit(source.getBytes()));
	}
 
	/**
	 * BASE64编码
	 * 
	 * @param source
	 *            要编码的字符串
	 * @return 编码过的字符串
	 * @throws UnsupportedEncodingException 
	 */
	public static String encodeBASE64(String source) throws UnsupportedEncodingException {
		return Base64.getEncoder().encodeToString(source.getBytes(encoding));
	}
 
	/**
	 * BASE64解码
	 * 
	 * @param encodeSource
	 *            编码过的字符串
	 * @return 编码前的字符串
	 * @throws UnsupportedEncodingException 
	 */
	public static String decodeBASE64(String encodeSource) throws UnsupportedEncodingException {
		return new String(Base64.getDecoder().decode(encodeSource),encoding);
	}
 
	/**
	 * AES加密
	 * 
	 * @param content
	 *            待加密的内容
	 * @param password
	 *            加密密码
	 * @return
	 */
	public static byte[] encryptBitAES(byte[] content, String password) {
		try {
			Cipher encryptCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");// 创建密码器
			encryptCipher.init(Cipher.ENCRYPT_MODE, getKey(password));// 初始化
			byte[] result = encryptCipher.doFinal(content);
			return result; // 加密
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		// return null;
	}
 
	/**
	 * AES解密
	 * 
	 * @param content
	 *            待解密内容
	 * @param password
	 *            解密密钥
	 * @return
	 */
	public static byte[] decryptBitAES(byte[] content, String password) {
		try {
			Cipher decryptCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");// 创建密码器
			decryptCipher.init(Cipher.DECRYPT_MODE, getKey(password));// 初始化
			byte[] result = decryptCipher.doFinal(content);
			return result; // 加密结果
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		// return null;
	}
 
	/**
	 * AES字符串加密
	 * 
	 * @param content
	 *            待加密的内容
	 * @param password
	 *            加密密码
	 * @return
	 */
	public static String encryptAES(String content, String password) {
		return byte2HexStr(encryptBitAES(content.getBytes(), password));
	}
 
	/**
	 * AES字符串解密
	 * 
	 * @param content
	 *            待解密内容
	 * @param password
	 *            解密密钥
	 * @return
	 */
	public static String decryptAES(String content, String password) {
		return new String(decryptBitAES(hexStr2Bytes(content), password));
	}
 
	/**
	 * 从指定字符串生成密钥
	 * 
	 * @param password
	 *            构成该秘钥的字符串
	 * @return 生成的密钥
	 * @throws NoSuchAlgorithmException
	 */
	private static Key getKey(String password) throws NoSuchAlgorithmException {
		SecureRandom secureRandom = new SecureRandom(password.getBytes());
		// 生成KEY
		KeyGenerator kgen = KeyGenerator.getInstance("AES");
		kgen.init(128, secureRandom);
		SecretKey secretKey = kgen.generateKey();
		byte[] enCodeFormat = secretKey.getEncoded();
		// 转换KEY
		SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
		return key;
	}
 
	/**
	 * 将byte数组转换为表示16进制值的字符串. 如：byte[]{8,18}转换为：0812 和 byte[]
	 * hexStr2Bytes(String strIn) 互为可逆的转换过程.
	 * 
	 * @param bytes
	 *            需要转换的byte数组
	 * @return 转换后的字符串
	 */
	public static String byte2HexStr(byte[] bytes) {
		int bytesLen = bytes.length;
		// 每个byte用两个字符才能表示，所以字符串的长度是数组长度的两倍
		StringBuffer hexString = new StringBuffer(bytesLen * 2);
		for (int i = 0; i < bytesLen; i++) {
			// 将每个字节与0xFF进行与运算，然后转化为10进制，然后借助于Integer再转化为16进制
			String hex = Integer.toHexString(bytes[i] & 0xFF);
			if (hex.length() < 2) {
				hexString.append(0);// 如果为1位 前面补个0
			}
			hexString.append(hex);
		}
		return hexString.toString();
	}
 
	/**
	 * 将表示16进制值的字符串转换为byte数组, 和 String byte2HexStr(byte[] bytes) 互为可逆的转换过程.
	 * 
	 * @param bytes
	 * @return 转换后的byte数组
	 */
	public static byte[] hexStr2Bytes(String strIn) {
		byte[] arrB = strIn.getBytes();
		int iLen = arrB.length;
 
		// 两个字符表示一个字节，所以字节数组长度是字符串长度除以2
		byte[] arrOut = new byte[iLen / 2];
		for (int i = 0; i < iLen; i = i + 2) {
			String strTmp = new String(arrB, i, 2);
			arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
		}
		return arrOut;
	}
 
	// 密钥
	private final static String secretKey = "gongquan2008@lx100$#365#";
	// 向量
	private final static String iv = "01234567";
	// 加解密统一使用的编码方式
	private final static String encoding = "utf-8";
 
	/**
	 * 3DES加密
	 * 
	 * @param plainText
	 *            普通文本
	 * @return
	 * @throws Exception
	 */
	public static String d3esEncode(String plainText) {
		Key deskey = null;
		byte[] encryptData = null;
		try {
			DESedeKeySpec spec = new DESedeKeySpec(secretKey.getBytes());
			SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
			deskey = keyfactory.generateSecret(spec);
 
			Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
			IvParameterSpec ips = new IvParameterSpec(iv.getBytes());
			cipher.init(Cipher.ENCRYPT_MODE, deskey, ips);
			encryptData = cipher.doFinal(plainText.getBytes(encoding));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return  Base64.getEncoder().encodeToString(encryptData);
 
	}
 
	/**
	 * 3DES解密
	 * 
	 * @param encryptText
	 *            加密文本
	 * @return
	 * @throws Exception
	 */
	public static String d3esDecode(String encryptText) {
		Key deskey = null;
		byte[] decryptData = null;
		String result = "";
		if (null != encryptText && !"".equals(encryptText)) {
			try {
				DESedeKeySpec spec = new DESedeKeySpec(secretKey.getBytes());
				SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
				deskey = keyfactory.generateSecret(spec);
				Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
				IvParameterSpec ips = new IvParameterSpec(iv.getBytes());
				cipher.init(Cipher.DECRYPT_MODE, deskey, ips);
 
				decryptData = cipher.doFinal(Base64.getDecoder().decode(encryptText));
				result = new String(decryptData, encoding);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return result;
	}
	public static void main(String[] args) {
//		byte[] arr1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 22 };
//		System.out.println("SHA1 加密 ： " + SHA1Bit(arr1));
//		System.out.println("SHA1 解密 ： " + SHA1("arr1"));
//		System.out.println("MD5 加密 ： " + MD5Bit(arr1));
//		System.out.println("MD5 加密 ： " + MD5("arr1"));// 54f04b52a75382a157f69457810c41bd
//		System.out.println("BASE64 加密 ： " + encodeBASE64("arr1"));
//		System.out.println("BASE64 解密 ： " + decodeBASE64(encodeBASE64("arr1")));
//		System.out.println("3DES 加密 ： " + d3esEncode("arr1"));
//		System.out.println("d3esDecode(decodeBASE64(encodeBASE64(d3esEncode('arr1')))) = "
//				+ d3esDecode(decodeBASE64(encodeBASE64(d3esEncode("arr1")))));
//		System.out.println("3DES 解密 ： " + d3esDecode(d3esEncode("arr1")));
//		System.out.println("AES 加密 ： " + encryptBitAES(arr1, "arr1"));
//		System.out.println("AES 解密 ： " + decryptBitAES(encryptBitAES(arr1, "arr1"), "arr1"));
		try{
		String password = EncryptUtil.encodeBASE64("11111111111111");
		System.out.println(password+":"+EncryptUtil.decodeBASE64(password));
		}catch(Exception ex){
			ex.printStackTrace();
		}
 
	}
}


package com.zkdj.data.utils;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/** */

/**
 * <p>
 * RSA公钥/私钥/签名工具包
 * </p>
 * <p>
 * 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）
 * </p>
 * <p>
 * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
 * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
 * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全
 * </p>
 * 
 * @author IceWee
 * @date 2012-4-26
 * @version 1.0
 */
public class RSAUtils {

    /** */
    /**
     * 加密算法RSA
     */
    public static final String KEY_ALGORITHM = "RSA";

    /** */
    /**
     * 签名算法
     */
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    /** */
    /**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";

    /** */
    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /** */
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /** */
    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

    /** */
    /**
     * <p>
     * 生成密钥对(公钥和私钥)
     * </p>
     * 
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    /** */
    /**
     * <p>
     * 用私钥对信息生成数字签名
     * </p>
     * 
     * @param data
     *            已加密数据
     * @param privateKey
     *            私钥(BASE64编码)
     * 
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        return Base64Utils.encode(signature.sign());
    }

    /** */
    /**
     * <p>
     * 校验数字签名
     * </p>
     * 
     * @param data
     *            已加密数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @param sign
     *            数字签名
     * 
     * @return
     * @throws Exception
     * 
     */
    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(Base64Utils.decode(sign));
    }

    /** */
    /**
     * <P>
     * 私钥解密
     * </p>
     * 
     * @param encryptedData
     *            已加密数据
     * @param privateKey
     *            私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /** */
    /**
     * <p>
     * 公钥解密
     * </p>
     * 
     * @param encryptedData
     *            已加密数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /** */
    /**
     * <p>
     * 公钥加密
     * </p>
     * 
     * @param data
     *            源数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /** */
    /**
     * <p>
     * 私钥加密
     * </p>
     * 
     * @param data
     *            源数据
     * @param privateKey
     *            私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /** */
    /**
     * <p>
     * 获取私钥
     * </p>
     * 
     * @param keyMap
     *            密钥对
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return Base64Utils.encode(key.getEncoded());
    }

    /** */
    /**
     * <p>
     * 获取公钥
     * </p>
     * 
     * @param keyMap
     *            密钥对
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return Base64Utils.encode(key.getEncoded());
    }

    /**
     * java端公钥加密
     */
    public static String encryptedDataOnJava(String data, String PUBLICKEY) {
        try {
            data = Base64Utils.encode(encryptByPublicKey(data.getBytes(), PUBLICKEY));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return data;
    }

    /**
     * java端私钥解密
     */
    public static String decryptDataOnJava(String data, String PRIVATEKEY) {
        String temp = "";
        try {
            byte[] rs = Base64Utils.decode(data);
            temp = new String(RSAUtils.decryptByPrivateKey(rs, PRIVATEKEY),"UTF-8"); //以utf-8的方式生成字符串

        } catch (Exception e) {
            e.printStackTrace();
        }
        return temp;
    }

}

4.实体类

package com.zkdj.data.entity.model;

import com.zkdj.data.entity.pojo.TMenu;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import javax.persistence.*;
import java.io.Serializable;
import java.util.List;

/**
 * @description 系统登录用户信息
 * @author gxf
 * @date 2023-05-31
 */
@Entity
@Data
@Table(name="t_rc_sys_user")
@ApiModel("系统登录用户信息")
public class RcSysUserEntity implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @Id
    @ApiModelProperty("主键")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", nullable = false)
    private Long id;

    /**
     * 账号
     */
    @ApiModelProperty("账号")
    @Column(name="account")
    private String account;

    /**
     * 密码
     */
    @ApiModelProperty("密码")
    @Column(name="password")
    private String password;

    /**
     * 真实姓名
     */
    @ApiModelProperty("真实姓名")
    @Column(name="realname")
    private String realname;

    /**
     * 角色id
     */
    @ApiModelProperty("角色id")
    @Column(name="role_id")
    private String roleId;

    /**
     * 盐值
     */
    @ApiModelProperty("盐值")
    @Column(name="salt")
    private String salt;

    /**
     * 类型
     */
    @ApiModelProperty("类型")
    @Column(name="type")
    private Integer type;

    /**
     * 创建时间
     */
    @ApiModelProperty("创建时间")
    @Column(name="ctime")
    private String ctime;

    /**
     * 创建用户
     */
    @ApiModelProperty("创建用户")
    @Column(name="cuser")
    private String cuser;

    /**
     * 更新时间
     */
    @ApiModelProperty("更新时间")
    @Column(name="utime")
    private String utime;

    /**
     * 令牌
     */
    @ApiModelProperty("令牌")
    @Column(name="token")
    private String token;

    /**
     * 电话
     */
    @ApiModelProperty("电话")
    @Column(name="tel")
    private String tel;

    /**
     * 邮箱
     */
    @ApiModelProperty("邮箱")
    @Column(name="email")
    private String email;

    /**
     * 启用禁用 0禁用1启用
     */
    @ApiModelProperty("启用禁用 0禁用1启用")
    @Column(name="status")
    private Integer status;

    /**
     * 列表的角色名称
     */
    @ApiModelProperty("列表的角色名称")
    @Transient
    private String rname;

    /**
     * 登录的角色权限树
     */
    @ApiModelProperty("登录的角色权限树")
    @Transient
    private List<TMenu> menus;

    /**
     * 修改密码时的新密码
     */
    @ApiModelProperty("修改密码时的新密码")
    @Transient
    private String newPassword;

    public RcSysUserEntity() {
    }

}
10000guo
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
springboot＋vue接口加密：RSA+AES
Java技术攻略的博客
02-27 4573
先使用AES对数据进行加密，再使用RSA对AES密钥进行加密。至于RSA和AES是什么？文章篇幅有限，还请大家到网上自行了解。接下来是实现加密的具体流程。
SpringBoot+vue加解密
04-25
通过一个简单的登录Demo演示SpringBoot+vue的加解密, vue前端实现密码加密，SpringBoot后端实现密码解密，前期准备:前端需要npm install crypto-js，后端基于JDK17
vue加密传输，后端获取进行解密。
柠檬味的cat的博客
05-15 346
前端加密后端解密
vue登陆密码加密，java后端解密
最新发布
while(life)++；
06-23 530
登陆之前调用encrypt给pwd加密。
springboot+vue AES加密使用
strongsto的博客
12-28 935
/"算法/模式/补码方式"NoPadding PkcsPadding。// psd是需要加密的字符,pwd是加密后的字符。// 默认的 KEY 与 iv 如果没有给。* @param data 要加密的数据。* @param pwd 要解密的数据。* @param key 加密key。* @param sig 校验的签名。* @param key 解密key。* @param iv 加密iv。* key和iv值可以随机生成。* @return 加密的结果。* @return 解密的结果。
SpringBoot+Vue使用AES进行接口加密
qq_54421200的博客
02-02 2527
在当今信息化社会，数据安全的重要性不言而喻。为了应对这一挑战，我们采用了SpringBoot和Vue技术，结合AES对称加密，实现了接口请求的安全传输。AES加密算法以其高效性和安全性，被广泛应用于各类场景。通过在SpringBoot后端实现加密和解密逻辑，我们确保了数据在传输过程中的安全。而在Vue前端，我们同样利用相应的加密和解密方法，实现了与后端的无缝对接。这一方案不仅提高了系统的安全性，也增强了用户对数据安全的信心。
SpringBoot+Vue请求及响应数据加密
m0_48521482的博客
06-04 526
*** 只对 @RequestBody 参数有效* @author 陶祎祎} }/*** 只对 @RequestBody 参数有效* @author 陶祎祎} }/*** 只对 @RequestBody 参数有效* @author 陶祎祎} }import org/*** 只对 @RequestBody 参数有效* @author 陶祎祎} }/**
Springboot +vue Aes加密
凉薄的博客
06-10 1300
首先导入aes依赖 编写aes工具类 在需要使用的地方最直接调用即可。引入 crypto-js npm install -S crypto-js 新建全局工具类 前后端秘钥和key和加密方式，填充方式要一致。不然无法校验。
SpringBoot + Vue 实现 AES 加密和 AES 工具类总结
白白白鲤鱼的博客
06-21 1181
SpringBoot + Vue 实现 AES 加密和 AES 工具类总结
SpringBoot+Vue 后端输出加密，前端请求统一解密
NaiveFox的博客
02-08 5377
Ruoyi Springboot后端请求返回加密，Vue解密
SpringBoot+Vue实现大文件分块上传
weixin_45525177的博客
06-06 725
SpringBoot+Vue实现大文件分块上传，SpringBoot+Vue实现大文件分块上传思路，SpringBoot+Vue实现大文件分块上传源码，SpringBoot+Vue实现大文件分块上传实例，SpringBoot+Vue实现大文件分块上传解决方案，SpringBoot+Vue实现大文件分块上传实现方法，SpringBoot+Vue实现大文件分片上传，SpringBoot+Vue实现大文件加密上传，SpringBoot+Vue实现文件夹上传，SpringBoot+Vue实现大文件断点续传，
基于SpringBoot+Vue的个人博客开发
05-14
基于SpringBoot+Vue的个人博客开发： 功能点： 1.前后端数据传输采用ASE进行加密传输，前端通过修改发送请求头将明文进行加密，后端2.通过Aop对数据进行加密和解密； 3.token令牌，通过username加密生成token，存入...
Springboot实现密码的加密解密
08-28
除了使用 Java 的加密解密 API 之外，我们还可以使用 Springboot 的一些插件来实现密码的加密解密，例如 Spring Security 等。这些插件提供了更加便捷的方式来实现密码的加密解密。 在 Springboot 中，我们可以使用...
Vue+Jwt+SpringBoot+Ldap完成登录认证的示例代码
08-27
Vue+Jwt+SpringBoot+Ldap完成登录认证的示例代码 本篇文章主要介绍了使用Vue、Jwt、SpringBoot和Ldap完成登录认证的示例代码，旨在帮助读者了解如何使用这些技术来实现安全的登录认证机制。 首先，让我们了解一下...
一个基于Vue和springboot+mybatisplus实现的文件云盘管理系统+源代码+文档说明
11-28
- 基于网页的加密文件下载与解密（20分） - 已完成《基于网页的文件上传加密与数字签名系统》所有要求 - 提供匿名用户加密后文件和关联的数字签名文件的下载 - 客户端对下载后的文件进行数字签名验证 【 *非对称...
Spring JdbcTemplate之批量插入
热门推荐
10000guo的博客
03-11 1万+
JdbcTemplate简介 　　Spring对数据库的操作在jdbc上面做了深层次的封装，使用spring的注入功能，可以把DataSource注册到JdbcTemplate之中。 　　JdbcTemplate位于spring-jdbc-5.0.6.RELEASE.jar中。其全限定命名为org.springframework.jdbc.core.JdbcTemplate。要使用JdbcTe...
MySQL表上亿级数据量实现删除重复记录
10000guo的博客
09-29 5086
上周从数据采集部门拿到一批400份的json文件,每个文件里30w+的json对象,对象里有uid,对重复的uid,需要去重下. 电脑配置4核8G 废话不多说,直接上干货. 1.创建表datatest5 CREATE TABLE `datatest5` ( `id` int(11) NOT NULL AUTO_INCREMENT, `val` varchar(16) DEFAU...
Spring JdbcTemplate查询结果集生成Java实体
10000guo的博客
03-11 4480
1.实体类 2.BeanPropertyRowMapper和EntityRowMapper(全文重点) 在使用JdbcTemplate的时候，可以使用query方法来查询指定的sql语句，来返回我们需要的结果。query提供了RowMapper接口，可以方便的将查询结果转换为对象。 RowMapper常见的有2个实现类BeanPropertyRowMapper和EntityRowMapp...
如何实现springboot+vue传输的数据加密
09-18
综上所述，实现Spring Boot和Vue传输的数据加密需要建立安全连接，配置加密算法，使用相应的加密库进行加密和解密操作，并对传输的敏感数据进行加密处理。同时，还需要定义加密相关的数据传输约定，确保前后端按照...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

10000guo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值