Java实现AES对称加密算法的加密和解密

前言

近期在工作中遇到这样一个需求，详细如下：
服务A向服务B请求数据，服务B查询对应的数据并对数据进行加密响应至服务A。
加密流程如下：

• 随机生成AES KEY，对数据进行对称加密，得到密文
• 使用服务A传过来的公钥对随机生成的AES KEY 进行加密
• 将数据密文与加密后的AES KEY一并返回给服务A

在实现过程中，查阅了大量的资料。其中参考了以下这两篇文章。本文大致内容摘用了这两篇文章中的内容，以此记录实现过程。方便需要时查阅

• https://blog.csdn.net/hbcui1984/article/details/5201247
• https://blog.csdn.net/xietansheng/article/details/88389515

加密解密工具类

package cn.com.hugedata.mcsearchforpubliccloud.utils;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.SecureRandom;

/**
 * @Desc AES 对称算法加密/解密工具类
 * @auth tangling
 * @Date 2021-04-19 14:33:57
 */
public class AESUtils {
     

    /** 密钥长度: 128, 192 or 256 */
    private static final int KEY_SIZE = 128;

    /** 加密/解密算法名称 */
    private static final String ALGORITHM = "AES";

    /** 随机数生成器（RNG）算法名称 */
    private static final String RNG_ALGORITHM = "SHA1PRNG";

    /**
     * 生成密钥对象
     */
    private static SecretKey generateKey(byte[] key) throws Exception {
     
        // 创建安全随机数生成器
        SecureRandom random = SecureRandom.getInstance(RNG_ALGORITHM);
        // 设置 密钥key的字节数组 作为安全随机数生成器的种子
        random.setSeed(key);

        // 创建 AES算法生成器
        KeyGenerator gen = KeyGenerator.getInstance(ALGORITHM);
        // 初始化算法生成器
        gen.init(KEY_SIZE, random);

        // 生成 AES密钥对象, 也可以直接创建密钥对象: return new SecretKeySpec(key, ALGORITHM);
        return gen.generateKey();
    }

    /**
     * 数据加密: 明文 -> 密文
     */
    public static byte[] encrypt(byte[] plainBytes, byte[] key) throws Exception {
     
        // 生成密钥对象
        SecretKey secKey = generateKey(key);

        // 获取 AES 密码器
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        // 初始化密码器（加密模型）
        cipher.init(Cipher.ENCRYPT_MODE, secKey);

        // 加密数据, 返回密文
        byte[] cipherBytes = cipher.doFinal(plainBytes);

        return cipherBytes;
    }

    /**
     * 数据解密: 密文 -> 明文
     */
    public static byte[] decrypt(byte[] cipherBytes, byte[] key) throws Exception {
     
        // 生成密钥对象
        SecretKey secKey = generateKey(key);

        // 获取 AES 密码器
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        // 初始化密码器（解密模型）
        cipher.init(Cipher.DECRYPT_MODE, secKey);

        // 解密数据, 返回明文
        byte[] plainBytes = cipher.doFinal(cipherBytes);

        return plainBytes;
    }

    /**
     * 加密文件: 明文输入 -> 密文输出
     */
    public static void encryptFile(File plainIn, File cipherOut, byte[] key) throws Exception {
     
        aesFile(plainIn, cipherOut, key, true);
    }

    /**
     * 解密文件: 密文输入 -> 明文输出
     */
    public static void decryptFile(File cipherIn, File plainOut, byte[] key) throws Exception {
     
        aesFile(plainOut, cipherIn, key, false);
    }

    /**
     * AES 加密/解密文件
     */
    private static void aesFile(File plainFile, File cipherFile, byte[] key, boolean isEncrypt) throws Exception {
     
        // 获取 AES 密码器
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        // 生成密钥对象
        SecretKey secKey = generateKey(key);
        // 初始化密码器
        cipher.init(isEncrypt ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE, secKey);

        // 加密/解密数据
        InputStream in = null;
        OutputStream out = null;

        try {
     
            if (isEncrypt) {
     
                // 加密: 明文文件为输入, 密文文件为输出
                in = new FileInputStream(plainFile);
                out = new FileOutputStream(cipherFile);
            } else {
     
                // 解密: 密文文件为输入, 明文文件为输出
                in = new FileInputStream(cipherFile);
                out = new FileOutputStream(plainFile);
            }

            byte[] buf = new byte[1024];
            int len = -1;

            // 循环读取数据 加密/解密
            while ((len = in.read(buf)) != -1) {
     
                out.write(cipher.update(buf, 0, len));
            }
            out.write(cipher.doFinal());    // 最后需要收尾

            out.flush();

        } finally {
     
            close(in);
            close(out);
        }
    }

    private static void close(Closeable c) {
     
        if (c != null) {
     
            try {
     
                c.close();
            } catch (IOException e) {
     
                e.printStackTrace();
            }
        }
    }

    /**
     * 将二进制转换成16进制
     */
    public static String parseByte2HexStr(byte buf[]) {
     
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < buf.length; i++) {
     
            String hex = Integer.toHexString(buf[i] & 0xFF);
            if (hex.length() == 1) {
     
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 将16进制转换为二进制
     */
    public static byte[] parseHexStr2Byte(String hexStr) {
     
        if (hexStr.length() < 1)
            return null;
        byte[] result = new byte[hexStr.length()/2];
        for (int i = 0;i< hexStr.length()/2; i++) {
     
            int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);
            int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }
}

测试用例

public static void main(String[] args) throws Exception {
     


    //随机生成的 aes key
    String sourceAesKey = UUID.randomUUID().toString();
    //准备需要加密的对象内容
    JSONObject content = new JSONObject(){
     {
     
        put("name", "张三");
        put("age", 23);
        put("sex", "男");
    }};
    String contentStr = JSON.toJSONString(content);

    /*
           加密
           这里将加密后的内容（byte[]）数组由二进制转换成十六进制，再转换成字符串的原因是：
            在解密过程中发现当把字节数组转为字符串后,在把字符串.getBytes()获得数组,发现两个字节数组前后不一样了
            因为并不是每个字节数和编码集上的字符都有对应关系,如果一个字节数在编码集上没有对应,编码new String(byte[]) 后,往往解出来的会是一些乱码无意义的符号:例如:��,
            但是解码的时候,�这个字符也是一个字符在编码表中也有固定的字节数用来表示,所有解码出来的值必定是编码表中对应的值,除非你的字节数组中的字节数正好在编码表中有对应的值,
            否则编码,解码后的字节数组会不一样。
            在解密的过程中会出现 javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher 异常
            通过查询资料，如下做法可以解决这个问题
         */
    String encryptContent = AESUtils.parseByte2HexStr(AESUtils.encrypt(contentStr.getBytes(StandardCharsets.UTF_8), sourceAesKey.getBytes(StandardCharsets.UTF_8)));
    System.out.println("加密后的对象内容：" + encryptContent);

    //解密 同样密文在处理的时候由二进制转换成十六进制再转换成字符串。所以在解密的时候第一步就是将它由十六进制转回二进制
    byte[] decrypt = AESUtils.decrypt(AESUtils.parseHexStr2Byte(encryptContent), sourceAesKey.getBytes(StandardCharsets.UTF_8));
    System.out.println("密文解密后："+new String(decrypt));
}