使用crypto 对Vue传参的字符串进行加密，springboot解密字符串

使用crypto 对Vue传参的字符串进行加密，springboot解密字符串

首先我的项目需要实现的功能是用户修改密码，前台输入“+”号，点击请求后台的时候，传到后台发现＋变为了空，浏览器默认进行了拼接，所以想到了将原始密码，以及新密码进行加密，后台进行解密的操作。

前台部分

首先 npm install crypto-js --save-dev
安装 crypto
然后在项目中新建utils文件夹，文件夹下新建secret.js文件
secret.js文件内容如下

import CryptoJS from 'crypto-js/crypto-js'
 
// 默认的 KEY 与 iv
const KEY = CryptoJS.enc.Utf8.parse('qwertyuiopasdf12') // ''中与后台一样  密码
const IV = CryptoJS.enc.Utf8.parse('qwertyuiopasdf12') // ''中与后台一样，
// qwertyuiopasdf12  可随意自己定义，但是必须满足十六位，必须与后台的一致
 
/**
 * AES加密 ：字符串 key iv  返回base64
 */
export function encrypt(word) {
  const key = KEY
  const iv = IV
  const srcs = CryptoJS.enc.Utf8.parse(word)
  var encrypted = CryptoJS.AES.encrypt(srcs, key, {
    iv: iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.ZeroPadding
  })
  return CryptoJS.enc.Base64.stringify(encrypted.ciphertext)
}
 
/**
 * AES 解密 ：字符串 key iv  返回base64
 *
 */
export function decrypt(word) {
  const key = KEY
  const iv = IV
  const base64 = CryptoJS.enc.Base64.parse(word)
  const src = CryptoJS.enc.Base64.stringify(base64)
  var decrypt = CryptoJS.AES.decrypt(src, key, {
    iv: iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.ZeroPadding
  })
  var decryptedStr = decrypt.toString(CryptoJS.enc.Utf8)
  return decryptedStr.toString()
}

然后再需要加密的页面

import {encrypt,decrypt} from './utils/secret.js'

encrypt,decrypt，方法名必须与JS中的方法名一致
使用方法如下

		//原始密码
		let oPassword = encrypt(that.form.oldPassword);
		//新密码
        let nPassword = encrypt(that.form.newPassword); 
        //然后进行传参
        that.$refs[form].validate(valid => {
          if (valid) {
            axios.get(that.GLOBAL.myhf + `/user/updatePassword?id=${that.form.id}&oldPassword=${oPassword}&newPassword=${nPassword}`, {
                withCredentials: true
              })
              .then(function(response) {
                if (response.data.info == "success") {
                  that.$message({
                    message: "保存成功",
                    type: "success"
                  });
                  that.exit();
                } else {
                }

后台代码

首先创建加解密工具类

package manage.util;
 
/**
 * 参数加解密工具类
 */
import org.apache.commons.codec.binary.Base64;
 
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
 
public class AesEncryptUtil {
 
    // 使用AES-128-CBC加密模式，key需要为16位,key和iv可以相同！
    //密钥必须与前台的密钥保持一致
    private static String KEY = "qwertyuiopasdf12";
 
    private static String IV = "qwertyuiopasdf12";
 
    /**
     * 加密方法
     * 
     * @param data 要加密的数据
     * @param key 加密key
     * @param iv 加密iv
     * @return 加密的结果
     * @throws Exception
     */
    public static String encrypt(String data, String key, String iv) throws Exception
    {
        try
        {
            Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");// "算法/模式/补码方式"NoPadding PkcsPadding
            int blockSize = cipher.getBlockSize();
 
            byte[] dataBytes = data.getBytes();
            int plaintextLength = dataBytes.length;
            if (plaintextLength % blockSize != 0)
            {
                plaintextLength = plaintextLength + (blockSize - (plaintextLength % blockSize));
            }
 
            byte[] plaintext = new byte[plaintextLength];
            System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);
 
            SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
            IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());
 
            cipher.init(Cipher.ENCRYPT_MODE, keyspec, ivspec);
            byte[] encrypted = cipher.doFinal(plaintext);
 
            return new Base64().encodeToString(encrypted);
 
        }
        catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
    }
 
    /**
     * 解密方法
     * 
     * @param data 要解密的数据
     * @param key 解密key
     * @param iv 解密iv
     * @return 解密的结果
     * @throws Exception
     */
    public static String desEncrypt(String data, String key, String iv) throws Exception
    {
        try
        {
            byte[] encrypted1 = new Base64().decode(data);
 
            Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
            SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
            IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());
 
            cipher.init(Cipher.DECRYPT_MODE, keyspec, ivspec);
 
            byte[] original = cipher.doFinal(encrypted1);
            String originalString = new String(original);
            return originalString;
        }
        catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
    }
 
    /**
     * 使用默认的key和iv加密
     * 
     * @param data
     * @return
     * @throws Exception
     */
    public static String encrypt(String data) throws Exception
    {
        return encrypt(data, KEY, IV);
    }
 
    /**
     * 使用默认的key和iv解密
     * 
     * @param data
     * @return
     * @throws Exception
     */
    public static String desEncrypt(String data) throws Exception
    {
        return desEncrypt(data, KEY, IV);
    }
 
    /**
     * 测试
     */
    public static void main(String args[]) throws Exception
    {
 
        String test1 = "Dm123456";
        String test = new String(test1.getBytes(), "UTF-8");
        String data = null;
        String key = KEY;
        String iv = IV;
        // /g2wzfqvMOeazgtsUVbq1kmJawROa6mcRAzwG1/GeJ4=
        data = encrypt(test, key, iv);
        System.out.println("数据：" + test);
        System.out.println("加密：" + data);
        String jiemi = desEncrypt(data, key, iv).trim();
        System.out.println("解密：" + jiemi);
 
    }
}

直接使用

				oldPassword = AesEncryptUtil.desEncrypt(oldPassword);
				newPassword = AesEncryptUtil.desEncrypt(newPassword);

注意，如果你传输的字符串，不够十六位，解密之后，会使用空字符串进行补位，你需要在解密之后，对字符串进行去空字符串操作如下

				if(user.getPassword().equals(oldPassword.trim())) {
						if(null!=user) {
							user.setPassword(newPassword.trim());
							user.setPassword1(Base64Utils.encode(newPassword.trim()));
							userServicee.update(user);
							return Result.success("密码修改成功！");
						}
					}

此方法要求传入的内容必须为16的倍数，要不然就会报错。所以我在测试了几次，发现错误之后，使用了base64加密的方式，可以看我的另外一篇文章
如有问题，欢迎指出