vue3.x实现AES对称加密

import * as CryptoJS from "crypto-js";
//秘钥
const CRYPTOJSKEY= "你自己的加密密钥，16位的就是长度 = 16的字符，因为我的后端Aes是采用的16位的加密";


export class AesManager {


    /*
    * 加密方法
    * {param} plaintText 加密明文
    * return  str 加密结果
    */
    public static encrypt(plaintText : any) {
        const options = {
            mode: CryptoJS.mode.ECB,
            padding: CryptoJS.pad.Pkcs7
        };
        const key = CryptoJS.enc.Utf8.parse(CRYPTOJSKEY);
        const encryptedData = CryptoJS.AES.encrypt(plaintText, key, options);
        const encryptedBase64Str = encryptedData.toString();
        return encryptedBase64Str;
    }
    /*
    * 解密方法
    * {param} plaintText 解密密文
    * return  str 解密结果
    */
    public static decrypt(encryptedBase64Str  : any ) {
        const options = {
            mode: CryptoJS.mode.ECB,
            padding: CryptoJS.pad.Pkcs7
        };
        const key = CryptoJS.enc.Utf8.parse(CRYPTOJSKEY);
        const decryptedData = CryptoJS.AES.decrypt(encryptedBase64Str, key, options);
        const decryptedStr = decryptedData.toString(CryptoJS.enc.Utf8);
        return decryptedStr;
    }
}

package com.wlc.doc.util.aes;


import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;


import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;


public class Crypt {
    // --------------------------------------------------------------------------------------------
    // 获得密钥
    public SecretKey getKey(String s) throws Exception {
    //s ="g8TlgLEc6oqZxdwGe6pDiKB8Y";
        System.out.println("s==" + s);
        char[] ss = s.toCharArray();
        String sss = "";
        for (int i = 0; i < ss.length; i = i + 2) {
            sss = sss + ss[i];
        }
        SecretKeyFactory kf = SecretKeyFactory.getInstance("DES");
        DESKeySpec ks = new DESKeySpec(sss.substring(0, 8).getBytes());
        SecretKey kd = kf.generateSecret(ks);
        return kd;
    }


    // --------------------------------------------------------------------------------------------------
    // 返回加密后的字符串
    // key是用于生成密钥的字符串，input是要加密的字符串
    public String getEncryptedString(String key, String input) {
        String base64 = "";
        try {
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, getKey(key));
            System.out.print("getKey(key)===" + getKey(key) + "key==" + key);
            byte[] inputBytes = input.getBytes("UTF8");
            byte[] outputBytes = cipher.doFinal(inputBytes);
            BASE64Encoder encoder = new BASE64Encoder();
            base64 = encoder.encode(outputBytes);
        } catch (Exception e) {
            base64 = e.getMessage();
        }
        return base64;
    }


    // --------------------------------------------------------------------------------------------------
    // 返回解密后的字符串
    // key是用于生成密钥的字符串，input是要解密的字符串
    public String getDecryptedString(String key, String input) {
        String result = null;
        try {
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, getKey(key));
            BASE64Decoder decoder = new BASE64Decoder();
            byte[] raw = decoder.decodeBuffer(input);
            byte[] stringBytes = cipher.doFinal(raw);
            result = new String(stringBytes, "UTF8");
        } catch (Exception e) {
            result = e.getMessage();
        }
        return result;
    }


    public static void main(String[] args) {
        Crypt mycrypt = new Crypt();
        try {
            //SecretKey skey = mycrypt.getKey("g8TlgLEc6oqZxdwGe6pDiKB8Y");
            String ss = mycrypt.getEncryptedString("6678912345678906", "{'name':'王林冲','age':18}");
            System.out.println("ss==" + ss);
            String ss2 = mycrypt.getDecryptedString("6678912345678906", ss);
            System.out.println("ss2==" + ss2);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


        //String ss = Messages.getString("SendToMemberTag.5");
        //System.out.print(ss);


    }
}

package com.wlc.doc.util.aes;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;




/**
 * @author IT学习道场
 * @date 2019/12/24 11:20 上午
 */
public class AesUtil {
    private static final Logger logger = LoggerFactory.getLogger(AesUtil.class);
    public final static String ECB = "AES/ECB/PKCS5Padding";
    public final static String CBC = "AES/CBC/PKCS5Padding";
    final static String UTF_8 = "UTF-8";


    /**
     * 加密
     * @param text 文本
     * @param key 加密密钥
     * @return String - 加密后的文本
     */
    public static String encrypt(String text, String key){
        return encrypt(text, key, null, UTF_8);
    }


    /**
     * 加密
     * @param text 文本
     * @param key 加密密钥
     * @param ivKey 加密偏移量
     * @return String - 加密后的文本
     */
    public static String encrypt(String text, String key,String ivKey){
        return encrypt(text, key, ivKey, UTF_8);
    }


    /**
     * 加密
     * @param text 文本
     * @param key 加密密钥
     * @param ivKey aes的加密偏移量
     * @param charset aes的加密编码格式
     * @return String - 加密后的文本
     */
    public static String encrypt(String text, String key, String ivKey, String charset){
        try {
            boolean hasIV = ivKey != null;
            Cipher cipher = Cipher.getInstance(hasIV ? CBC : ECB);
            SecretKeySpec aesKey = new SecretKeySpec(key.getBytes(charset), "AES");
            if (hasIV) {
                // 加密和解密工作模式为CBC、CFB、OFB时必需指定初始化向量
                IvParameterSpec iv = new IvParameterSpec(ivKey.getBytes(charset));
                cipher.init(Cipher.ENCRYPT_MODE, aesKey, iv);
            } else {
                // 工作模式为ECB时不可初始化向量
                cipher.init(Cipher.ENCRYPT_MODE, aesKey);
            }
            byte[] bytes = cipher.doFinal(text.getBytes(charset));
            return Base64.getEncoder().encodeToString(bytes);
        } catch (Exception e) {
            logger.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 解密
     * @param cipherText 加密文本
     * @param key 加密密钥
     * @return String - 解密后文本
     */
    public static String decrypt(String cipherText, String key){
        return decrypt(cipherText, key, null, UTF_8);
    }


    /**
     * 解密
     * @param cipherText 加密文本
     * @param key 加密密钥
     * @param iv 加密偏移量
     * @return String - 解密后文本
     */
    public static String decrypt(String cipherText, String key,String iv){
        return decrypt(cipherText, key, iv, UTF_8);
    }


    /**
     * 解密
     * @param cipherText 加密文本
     * @param key 加密密钥
     * @param ivKey 加密偏移量
     * @param charset 编码格式
     * @return String - 解密后文本
     */
    public static String decrypt(String cipherText, String key,String ivKey, String charset){
        try {
            boolean hasIV = ivKey != null;
            Cipher cipher = Cipher.getInstance(hasIV ? CBC : ECB);
            SecretKeySpec aesKey = new SecretKeySpec(key.getBytes(charset), "AES");
            if (hasIV) {
                IvParameterSpec iv = new IvParameterSpec(ivKey.getBytes(charset));
                cipher.init(Cipher.DECRYPT_MODE, aesKey, iv);
            } else {
                cipher.init(Cipher.DECRYPT_MODE,aesKey);
            }
            byte[] bytes = cipher.doFinal(Base64.getDecoder().decode(cipherText));
            return new String(bytes, "utf-8");
        } catch (Exception e) {
            logger.error(e.getMessage(),e);
        }
        return null;
    }
}