Java - AES加密解密

2020-05-11追加内容:

 新增base64字符串加密解密 ,  传递type进行对应方式的加密解密

 

内容: 使用Java中Cipher工具类进行AES加密，并将加密后的byte数组转换成16进制字符串。(也可以转换成base64字符串)

 

加密过程:

1.数组扩容(需要是16的倍数)

2. 加密得到byte数组 

3. 遍历byte数组，对byte字节进行补码成正十进制数值

4. 十进制数值转换成十六进制数值

5. 十六进制数值如果只有一位需要在前面追加0补充。 这是为了解密时十六进制进行转换成10进制。

解密过程:

1.十六进制字符串转换成byte数组时需要每两个字符进行， 因为前面加密时进行了补0.

2.进行10进制换算 第一位是进1的，所以要乘以16 然后加上第二位。如果是0的话，乘的时候也是0，所以这是为什么加密的时候要在前面加0(还有一个是为了两两换算).

3. 十进制进行byte转换, java会自动反转和加密时的byte数组对应起来 4. 拿到原加密数组后进行解密并返回字符串

package com.cli.example.util;

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

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.util.Arrays;

/**
 *  AES加密工具类
 *
 * @author Cr
 * @date 2020-03-22
 *
 * **/
public class AESUtil {

    /**
     * 加密
     *
     * <p>
     *     根据指定返回的加密内容格式进行加密
     * </p>
     *
     * @param type 0 == 16进制字符串, 1 == base64字符串
     * @author Cr
     * @date 2020-05-11
     * */
    public static String encrypt(String data, String key, int type){
        return type == 0 ? encryptIntoHexString(data, key) : encryptIntoBase64String(data, key);
    }

    /**
     * 加密
     *
     * <p>
     *     根据指定返回的加密内容格式进行加密
     * </p>
     *
     * @param type 0 == 16进制字符串, 1 == base64字符串
     * @author Cr
     * @date 2020-05-11
     * */
    public static String decrypt(String data, String key, int type){
        return type == 0 ? decryptByHexString(data, key) : decryptByBase64String(data, key);
    }

    /**
     *  加密成十六进制字符串
     *
     *  <p>
     *     使用AES加密，并将Cipher加密后的byte数组转换成16进制字符串
     *  </p>
     *
     * @author Cr
     * @date 2020-03-22
     * */
    public static String encryptIntoHexString(String data, String key){
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
            cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key.getBytes(), "AES"), new IvParameterSpec("0000000000000000".getBytes()));
            return bytesConvertHexString(cipher.doFinal(Arrays.copyOf(data.getBytes(), 16 * ((data.getBytes().length / 16) + 1))));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 将加密后的十六进制字符串进行解密
     *
     * @author Cr
     * @date 2020-03-22
     *
     * **/
    public static String decryptByHexString(String data, String key){
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
            cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getBytes(), "AES"), new IvParameterSpec("0000000000000000".getBytes()));
            return new String(cipher.doFinal(hexStringConvertBytes(data.toLowerCase())),"UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     *  加密成Base64字符串
     *
     *  <p>
     *     使用AES加密，并将Cipher加密后的byte数组转换成Base64字符串
     *  </p>
     *
     * @author Cr
     * @date 2020-03-22
     * */
    public static String encryptIntoBase64String(String data, String key){
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
            cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key.getBytes(), "AES"), new IvParameterSpec("0000000000000000".getBytes()));
            return new BASE64Encoder().encode(cipher.doFinal(Arrays.copyOf(data.getBytes(), 16 * ((data.getBytes().length / 16) + 1)))).replaceAll("\r\n", "");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 将加密后的Base64字符串进行解密
     *
     * @author Cr
     * @date 2020-03-22
     *
     * **/
    public static String decryptByBase64String(String data, String key){
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
            cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getBytes(), "AES"), new IvParameterSpec("0000000000000000".getBytes()));
            return new String(cipher.doFinal(new BASE64Decoder().decodeBuffer(data)),"UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     *  byte数组转换成十六进制字符串
     *
     *  <p>
     *      先对每个byte数值补码成十进制,
     *      然后在将十进制转换成对应的十六进制.
     *      如果单次转换, 十六进制只有一位时， 将在前面追加0变成两位.
     *  </p>
     *
     * @author Cr
     * @date 2020-03-22
     * */
    private static String bytesConvertHexString(byte [] data){
        StringBuffer result = new StringBuffer();
        String hexString = "";
        for (byte b : data) {
            // 补码成正十进制后转换成16进制
            hexString = Integer.toHexString(b & 255);
            result.append(hexString.length() == 1 ? "0" + hexString : hexString);
        }
        return result.toString().toUpperCase();
    }

    /**
     * 十六进制字符串转换成byte数组
     *
     *  <p>
     *      在加密时, 十六进制数值和byte字节的对应关系 是:  2个十六进制数值对应  1个byte字节  (2: 1)
     *      所以byte数组的长度应该是十六进制字符串的一半, 并且在转换时
     *      应是两个十六进制数值转换成一个byte字节  (2个2个十六进制数值进行转换)
     *     这也是为什么可以*2的原因， 例如: 0, 2, 4, 6, 8, 10, 12 依次遍历
     *  </p>
     *
     * @author Cr
     * @date 2020-04-22
     * */
    private static byte [] hexStringConvertBytes(String data){
        int length = data.length() / 2;
        byte [] result = new byte[length];
        for (int i = 0; i < length; i++) {
            int first = Integer.parseInt(data.substring(i * 2, i * 2 + 1), 16);
            int second = Integer.parseInt(data.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (first * 16 + second);
        }
        return result;
    }

}

public static void main(String[] args) {
        String key = "2bc73dw20ebf4d46";
        String data = "{username: 哈哈哈哈哈哈哈惺惺惜惺惺}";
        System.out.println("加密前: " + data);
        String encode = MyAESUtil.encryptIntoHexString(data, key);
        System.out.println("加密后: " + encode);
        String decode = MyAESUtil.decryptByHexString(encode, key);
        System.out.println("解密后: " + decode);


    }