Node Java相互使用AES-256-CBC对数据进行加密解密实现

Node代码

/**
 *    加密,解密方法
 *
 */
let crypto = require('crypto');
/**
 * 加密解密方式
 */
let algorithm = 'aes-256-cbc';

let key = '9815c9e69268bc2fc2085c1lc6q75a42';
let charset = 'utf8';
let cipherEncoding = 'base64';
let iv = '9183296589LSCQEG';


let encrypt = function (plaintext) {
    //加密
	let cipher = crypto.createCipheriv(algorithm, key, iv);
	let cipherChunks = [];
    cipherChunks.push(cipher.update(plaintext, charset, cipherEncoding));
    cipherChunks.push(cipher.final(cipherEncoding));
	let encrypt = cipherChunks.join('');
    encrypt = encrypt.replace(/\+/g, '%2b');
    return encrypt;
};

let decrypt = function (encrypttext) {
    encrypttext = encrypttext.replace(/(%2b)/g, '+');
    //解密start
	let decipher = crypto.createDecipheriv(algorithm, key, iv);
	let plainChunks = [];
    plainChunks.push(decipher.update(encrypttext, cipherEncoding, charset));
    plainChunks.push(decipher.final(charset));
    return plainChunks.join('');
}


let encryptStr = encrypt('bbbb');

let decryptStr = decrypt(encryptStr);

console.log('加' + encryptStr);
console.log('解' + decryptStr);

Java代码

import org.apache.tomcat.util.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import java.io.UnsupportedEncodingException;
import java.security.Key;
import java.security.Security;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;


/**
 * AES加解密工具类
 * @.Desc AES对称加密算法，调用方法：
 * 1) 对明文进行加密，并对密文进行Base64编码：AESUtil.encrypt(plainText, keyStr); plainText为需要加密的字符串，keyStr为**。
 * 2) 先对密文进行Base64解码，然后再进行解密：AESUtil.decrypt(secretText, keyStr); secretText为需要解密的字符串，keyStr为**。
 */
public class AesCbcUtil {

    /**
     * 默认AES Key
     */
    private static final String DEFAULT_AES_KEY_STR = "9815c9e69268bc2fc2085c1lc6q75a42";

    private static final String CHARSET = "UTF-8";

    private static final String ENCRYPT = "AES";
    // ECB 模式下不适用 向量定义
    //CBC模式需要制定向量
    private static final String ENCRYPT_TYPE = "AES/CBC/PKCS7Padding";

    private static final String PROVIDER = "BC";

    private static final String IV = "9183296589LSCQEG";

    /**
     * 加密，并对密文进行Base64编码，采用默认**
     * @param plainText
     * 					明文
     * @return String
     * 		  			做了Base64编码的密文
     * @throws Exception
     */
    public static String encrypt(String plainText) throws Exception{
        return encrypt(plainText, DEFAULT_AES_KEY_STR);
    }


    public static IvParameterSpec makeIv() throws UnsupportedEncodingException{
        return new IvParameterSpec(IV.getBytes(CHARSET));
    }

    /**
     * 加密，并对密文进行Base64编码，可指定**
     * @param plainText
     * 					明文
     * @param keyStr
     * 					**
     * @return String
     * 		  			做了Base64编码的密文
     * @throws Exception
     */
    public static String encrypt(String plainText, String keyStr) throws Exception{
        try {
            byte[] keyBytes = keyStr.getBytes(CHARSET);
            Key ckey = new SecretKeySpec(keyBytes, ENCRYPT);
            Security.addProvider(new BouncyCastleProvider());
            Cipher cp = Cipher.getInstance(ENCRYPT_TYPE,PROVIDER);
            IvParameterSpec iv = makeIv();
            cp.init(Cipher.ENCRYPT_MODE, ckey,iv);
            byte[] inputByteArray = plainText.getBytes(CHARSET);
            byte[] cipherBytes = cp.doFinal(inputByteArray);
            String result = Base64.encodeBase64String(cipherBytes);
            result = result.replace("+", "%2b");
            result = result.replace("\r\n", "").replace("\n", "");
            return result;
        } catch (Exception e) {
            throw e;
        }
    }

    /**
     * 对做了Base64编码的密文进行解密，采用默认**
     * @param secretText
     * 						做了Base64编码的密文
     * @return String
     * 						解密后的字符串
     * @throws Exception
     */
    public static String decrypt(String secretText) throws Exception{
        return decrypt(secretText, DEFAULT_AES_KEY_STR);
    }

    /**
     * 对做了Base64编码的密文进行解密
     * @param secretText
     * 						做了Base64编码的密文
     * @param keyStr
     * 						**
     * @return String
     * 						解密后的字符串
     * @throws Exception
     */
    public static String decrypt(String secretText, String keyStr) throws Exception{
        secretText = secretText.replace("%2b", "+");
        byte[] cipherByte = Base64.decodeBase64(secretText);
        byte[] keyBytes = keyStr.getBytes(CHARSET);
        try {
            Key ckey = new SecretKeySpec(keyBytes, ENCRYPT);
            Security.addProvider(new BouncyCastleProvider());
            Cipher cp = Cipher.getInstance(ENCRYPT_TYPE,PROVIDER);
            IvParameterSpec iv = makeIv();
            cp.init(Cipher.DECRYPT_MODE, ckey,iv);
            byte[] decryptBytes = cp.doFinal(cipherByte);
            return new String(decryptBytes, CHARSET).replace("", "");
        } catch (Exception e) {
            throw e;
        }
    }

    // 测试
    public static void main(String[] args) {
        try {
			String content = "hello world";
			System.out.println("加密前：" + content);
             //加密
			String encryptResult = encrypt(content);
			System.out.println("加密后：" + encryptResult);
            // 解密
            String decryptResult = decrypt(encryptResult);
            System.out.println("解密后：" + decryptResult);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

}

就 先 说 到 这 \color{#008B8B}{ 就先说到这} 就先说到这
在 下 A p o l l o \color{#008B8B}{在下Apollo} 在下Apollo
一 个 爱 分 享 J a v a 、 生 活 的 小 人 物 ， \color{#008B8B}{一个爱分享Java、生活的小人物，} 一个爱分享Java、生活的小人物，
咱 们 来 日 方 长 ， 有 缘 江 湖 再 见 ， 告 辞 ！ \color{#008B8B}{咱们来日方长，有缘江湖再见，告辞！} 咱们来日方长，有缘江湖再见，告辞！