AES加密工具

最新推荐文章于 2026-04-24 09:48:19 发布
原创 最新推荐文章于 2026-04-24 09:48:19 发布 · 908 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#AES
本文整理了AES加密工具的相关内容，旨在消除之前的使用困惑，提供清晰的加密步骤和注意事项。

AES加密工具 之前有些坑在里面，现在整理一下，条理清晰点


import android.text.TextUtils;
import android.util.Base64;

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.Provider;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * AES 加密工具
 */
public class AESUtils {
    /**
     * 算法/模式/填充
     * 加密模式（Cipher Mode）有CBC、ECB、CTR、OFB、CFB五种。
     * 初始向量Iv(Initialization Vector)，使用除ECB以外的其他加密模式均需要传入一个初始向量，其大小与块大小相等，
     * AES块大小是128bit，所以Iv的长度是16字节，秘钥也要是16字节，初始向量可以加强算法强度。
     **/

    /**
     * 加密算法
     */
    private static final String Algorithm_AES = "AES";//AES算法
    private static final String Algorithm_DES = "DES";//DES算法

    /**
     * 加密模式
     */
    private static final String CipherMode_CBC_PKCS5 = "AES/CBC/PKCS5Padding";
    private static final String CipherMode_ECB_PKCS5 = "AES/ECB/PKCS5Padding";

    private static final String CipherMode_CBC_PKCS7 = "AES/CBC/PKCS7Padding";
    private static final String CipherMode_ECB_PKCS7 = "AES/ECB/PKCS7Padding";


    public static String encryptAES_ECB7_2Base64(String contentStr, String key) {
        return encryptAES2Base64(contentStr, key, CipherMode_ECB_PKCS7, null);
    }

    public static String decryptBase64AES_ECB7(String base64Str, String key) {
        return decryptBase64AES(base64Str, key, CipherMode_ECB_PKCS7, null);
    }

    /**
     * AES加密 输出base64字符串
     *
     * @param content        加密内容
     * @param key            秘钥 长度16
     * @param transformation 加密模式  例：AES/CBC/PKCS5Padding
     * @param iv             偏移量 长度16 ，可选 ，除ECB外 都需要加
     * @return
     */
    public static String encryptAES2Base64(String content, String key, String transformation, String iv) {
        if (TextUtils.isEmpty(content)) return "";
        try {
            key = create128BitsKey(key);//截取key 16位
            byte[] strByte = content.getBytes("UTF-8");
            byte[] keyByte = key.getBytes("UTF-8");
            byte[] ivByte = null;
            if (!TextUtils.isEmpty(iv)) {
                ivByte = create128BitsIV(iv).getBytes("UTF-8");
            }
            byte[] result = encryptAES(strByte, keyByte, transformation, ivByte);//AES加密

            return Base64.encodeToString(result, Base64.NO_WRAP);//要进行base64再一次加密 NO_WRAP不带换行符 DEFAULT带
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * AES解密  输入base64字符串
     *
     * @param base64Str      加密内容
     * @param key            秘钥 长度16
     * @param transformation 加密模式  例：AES/CBC/PKCS5Padding
     * @param iv             偏移量 长度16 ，可选 ，除ECB外 都需要加
     * @return
     */
    public static String decryptBase64AES(String base64Str, String key, String transformation, String iv) {
        if (TextUtils.isEmpty(base64Str)) return "";
        try {
            key = create128BitsKey(key);//截取key 16位

            byte[] strByte = Base64.decode(base64Str, Base64.NO_WRAP);//要先base64解密 NO_WRAP不带换行符 DEFAULT带

            byte[] keyByte = key.getBytes("UTF-8");
            byte[] ivByte = null;
            if (!TextUtils.isEmpty(iv)) {
                ivByte = create128BitsIV(iv).getBytes("UTF-8");
            }
            byte[] result = decryptAES(strByte, keyByte, transformation, ivByte);//AES解密

            return new String(result, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * AES加密 输出16进制字符串
     *
     * @param content        加密内容
     * @param key            秘钥 长度16
     * @param transformation 加密模式  例：AES/CBC/PKCS5Padding
     * @param iv             偏移量 长度16 ，可选 ，除ECB外 都需要加
     * @return
     */
    public static String encryptAES2Hex(String content, String key, String transformation, String iv) {
        key = create128BitsKey(key);//截取key 16位
        try {
            byte[] strByte = content.getBytes("UTF-8");
            byte[] keyByte = key.getBytes("UTF-8");
            byte[] ivByte = null;
            if (!TextUtils.isEmpty(iv)) {
                ivByte = create128BitsIV(iv).getBytes("UTF-8");
            }
            byte[] result = encryptAES(strByte, keyByte, transformation, ivByte);//AES加密
            if (result != null) return bytesToHexString(result);//输出16进制字符串
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * AES解密 输入16进制字符串
     *
     * @param hexStr         加密内容
     * @param key            秘钥 长度16
     * @param transformation 加密模式  例：AES/CBC/PKCS5Padding
     * @param iv             偏移量 长度16 ，可选 ，除ECB外 都需要加
     * @return
     */
    public static String decryptHexAES(String hexStr, String key, String transformation, String iv) {
        key = create128BitsKey(key);//截取key 16位
        try {
            byte[] strByte = hexStringToBytes(hexStr);//16进制字符串转换bytes

            byte[] keyByte = key.getBytes("UTF-8");
            byte[] ivByte = null;
            if (!TextUtils.isEmpty(iv)) {
                ivByte = create128BitsIV(iv).getBytes("UTF-8");
            }
            byte[] result = decryptAES(strByte, keyByte, transformation, ivByte);//AES解密

            return new String(result, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * JDK只支持AES-128加密，也就是密钥长度必须是128bit；参数为密钥key，key的长度小于16字符时用"0"补充，key长度大于16字符时截取前16位
     **/
    private static String create128BitsKey(String key) {
        if (key == null || key.length() != 16) {
            throw new RuntimeException("Unsupported key size，秘钥长度必须为16字节");
        }
        StringBuffer buffer = new StringBuffer(16);
        buffer.append(key);
        //小于16后面补0
        while (buffer.length() < 16) {
            buffer.append("0");
        }
        //大于16，截取前16个字符
        if (buffer.length() > 16) {
            buffer.setLength(16);
        }
        return buffer.toString();
    }

    /**
     * 创建128位的偏移量，iv的长度小于16时后面补0，大于16，截取前16个字符;
     *
     * @param iv
     * @return
     */
    private static String create128BitsIV(String iv) {
        if (iv == null || iv.length() != 16) {
            throw new RuntimeException("Unsupported iv size，iv长度必须为16字节");
        }
        StringBuffer buffer = new StringBuffer(16);
        buffer.append(iv);
        while (buffer.length() < 16) {
            buffer.append("0");
        }
        if (buffer.length() > 16) {
            buffer.setLength(16);
        }

        return buffer.toString();
    }


    /**
     * AES加密
     *
     * @param content        加密内容
     * @param keyBytes       秘钥 长度16
     * @param transformation 加密模式  例：AES/CBC/PKCS5Padding
     * @param iv             偏移量 长度16 ，可选 ，除ECB外 都需要加
     * @return
     */
    public static byte[] encryptAES(byte[] content, byte[] keyBytes, String transformation, byte[] iv) {
        return encrypt(content, keyBytes, Algorithm_AES, transformation, iv);
    }

    /**
     * DES加密
     *
     * @param content        加密内容
     * @param keyBytes       秘钥 长度16
     * @param transformation 加密模式  例：DES/CBC/PKCS5Padding
     * @param iv             偏移量 长度16 ，可选 ，除ECB外 都需要加
     * @return
     */
    public static byte[] encryptDES(byte[] content, byte[] keyBytes, String transformation, byte[] iv) {
        return encrypt(content, keyBytes, Algorithm_DES, transformation, iv);
    }

    /**
     * 加密
     *
     * @param content        加密内容
     * @param keyBytes       秘钥 长度16
     * @param transformation 加密算法  AES或DES
     * @param transformation 加密模式  例：AES/CBC/PKCS5Padding
     * @param iv             偏移量 长度16 ，可选 ，除ECB外 都需要加
     * @return
     */
    public static byte[] encrypt(byte[] content, byte[] keyBytes, String algorithm, String transformation, byte[] iv) {
        try {
            SecretKey key;
            if (Algorithm_DES.equals(algorithm)) {
                DESKeySpec desKey = new DESKeySpec(keyBytes);
                SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(algorithm);
                key = keyFactory.generateSecret(desKey);
            } else {
                key = new SecretKeySpec(keyBytes, algorithm);
            }

            Cipher cipher;
            if (iv == null || iv.length == 0) {
                cipher = Cipher.getInstance(transformation);//ECB不需要iv
                cipher.init(Cipher.ENCRYPT_MODE, key);
            } else {
                cipher = Cipher.getInstance(transformation);
                cipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(iv));
            }

            return cipher.doFinal(content);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * AES解密
     *
     * @param content        加密内容
     * @param keyBytes       秘钥 长度16
     * @param transformation 加密模式  例：AES/CBC/PKCS5Padding
     * @param iv             偏移量 长度16 ，可选 ，除ECB外 都需要加
     * @return
     */
    public static byte[] decryptAES(byte[] content, byte[] keyBytes, String transformation, byte[] iv) {
        return decrypt(content, keyBytes, Algorithm_AES, transformation, iv);
    }

    /**
     * DES解密
     *
     * @param content        加密内容
     * @param keyBytes       秘钥 长度16
     * @param transformation 加密模式  例：DES/CBC/PKCS5Padding
     * @param iv             偏移量 长度16 ，可选 ，除ECB外 都需要加
     * @return
     */
    public static byte[] decryptDES(byte[] content, byte[] keyBytes, String transformation, byte[] iv) {
        return decrypt(content, keyBytes, Algorithm_DES, transformation, iv);
    }

    /**
     * 解密
     *
     * @param content        加密内容
     * @param keyBytes       秘钥 长度16
     * @param algorithm      加密算法  AES或DES
     * @param transformation 加密模式  例：AES/CBC/PKCS5Padding
     * @param iv             偏移量 长度16 ，可选 ，除ECB外 都需要加
     * @return
     */
    public static byte[] decrypt(byte[] content, byte[] keyBytes, String algorithm, String transformation, byte[] iv) {
        try {
            SecretKey key;
            if (Algorithm_DES.equals(algorithm)) {
                DESKeySpec desKey = new DESKeySpec(keyBytes);
                SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(algorithm);
                key = keyFactory.generateSecret(desKey);
            } else {
                key = new SecretKeySpec(keyBytes, algorithm);
            }

            Cipher cipher;
            if (iv == null || iv.length == 0) {
                cipher = Cipher.getInstance(transformation);//ECB不需要iv
                cipher.init(Cipher.DECRYPT_MODE, key);
            } else {
                cipher = Cipher.getInstance(transformation);
                cipher.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(iv));
            }

            return cipher.doFinal(content);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return null;
    }


    // 对密钥进行处理
    private static byte[] getRawKey(byte[] seed) throws Exception {
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        //for android
        SecureRandom sr = null;
        int sdk_version = android.os.Build.VERSION.SDK_INT;
        if (sdk_version > 23) {  // Android  6.0 以上
            sr = SecureRandom.getInstance("SHA1PRNG", new CryptoProvider());
        } else if (sdk_version >= 17) {
            sr = SecureRandom.getInstance("SHA1PRNG", "Crypto");
        } else {
            sr = SecureRandom.getInstance("SHA1PRNG");
        }

        // for Java
        // secureRandom = SecureRandom.getInstance(SHA1PRNG);
        sr.setSeed(seed);
        kgen.init(128, sr); //256 bits or 128 bits,192bits
        //AES中128位密钥版本有10个加密循环，192比特密钥版本有12个加密循环，256比特密钥版本则有14个加密循环。
        SecretKey skey = kgen.generateKey();
        byte[] raw = skey.getEncoded();
        return raw;
    }


    /**
     * 将二进制转换成16进制
     *
     * @param buf
     * @return
     */
    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进制字符串转换成字节数组
     *
     * @param hex
     * @return byte[]
     */
    public static byte[] hexStringToBytes(String hex) {
        int len = (hex.length() / 2);
        byte[] result = new byte[len];
        char[] achar = hex.toCharArray();
        for (int i = 0; i < len; i++) {
            int pos = i * 2;
            result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
        }
        return result;
    }

    private static int toByte(char c) {
        byte b = (byte) "0123456789ABCDEF".indexOf(c);
        return b;
    }

    /**
     * 数组转换成十六进制字符串
     *
     * @param bArray
     * @return HexString
     */
    public static final String bytesToHexString(byte[] bArray) {
        StringBuffer sb = new StringBuffer(bArray.length);
        String sTemp;
        for (int i = 0; i < bArray.length; i++) {
            sTemp = Integer.toHexString(0xFF & bArray[i]);
            if (sTemp.length() < 2)
                sb.append(0);
            sb.append(sTemp.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 将16进制转换为二进制
     *
     * @param hexStr
     * @return
     */
    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;
    }
AES 加密工具（ECB,CBC,CMAC）
06-25
AES工具，支持ECB，CBC加解密运算，以及CMAC运算。支持多种PADDING
手把手教你用C语言实现AES-128-CBC加密解密（附完整代码和在线验证）
最新发布
weixin_28715953的博客
04-24 233
本文详细介绍了如何使用C语言从零实现AES-128-CBC加密解密算法，包括核心算法解析、CBC模式实现关键细节、实战验证与调试技巧。通过完整的代码示例和在线验证方法，帮助开发者在资源受限环境中实现高效安全的数据加密，特别适合嵌入式开发和物联网应用场景。
AES加解密工具类
expect521的博客
05-14 921
AES介绍 AES(Advanced Encryption Standard),高级加密标准.是java中常用的加密算法之一。 在线AES加密 | AES解密 - 在线工具 AESUtil Java AES 加密解密工具类 使用注意： 加密后通常配合 Base64 进行编码。 Base64编码 编码后若作为 URL 参数还需进行 URI 转换。url转码 package com.example.demo.util; import org.springframework.util.Base64Utils
AES 加解密 带偏移量 Pkcs5Padding（Pkcs7Padding） CBC
柠檬麻麻
09-27 3138
AES 加解密 带偏移量 Pkcs5Padding（Pkcs7Padding） CBC aes.js var CryptoJS = CryptoJS || function(u, p) {aes.js var d = {}, l = d.lib = {}, s = function() {}, t = l.Base = { extend: function(a) { s.prototype = this; var c = new s;
AES在线加解密工具
封神之路~
05-05 6785
总的来说，AES加密/解密工具为业内提供了一个简单易用、免费开放的在线工具，让大家无需安装软件或下载工具，只要有一个网络连接就能完成AES加密过程。AES加密/解密工具操作简单明了，只需要输入明文和密钥，就能快速进行加密和解密操作。此外，AES加密/解密工具还提供了多种加密模式，如CBC、ECB、CFB、OFB等，可以让用户充分自由选择最适合自己情况的加密模式，以尽量保护加密信息的安全性。现在，有一款免费的在线AES加密工具——AES加密/解密工具来帮助大家快速实现AES加密，让加密变得简单易用。
在线AES加密/解密工具
AI的博客
10-25 4206
在线AES加密/解密工具
AES加密、解密工具类
Wang_WY的博客
03-20 4215
一、AES介绍 AES（Advanced Encryption Standard），中文名称高级加密标准。 AES是开发中常用的加密算法之一。然而由于前后端开发使用的语言不统一，导致经常出现前端加密而后端不能解密的情况出现。然而无论什么语言系统，AES 的算法总是相同的， 因此导致结果不一致的原因在于 加密设置的参数不一致 。于是先来看看在两个平台使用AES加密时需要统一的几个参数。 密钥长...
SpringBoot + Vue 实现 AES 加密和 AES 工具类总结
白白白鲤鱼的博客
06-21 2595
SpringBoot + Vue 实现 AES 加密和 AES 工具类总结
aes-tool（AES加密工具）
gitblog_06724的博客
05-06 888
aes-tool（AES加密工具） 去发现同类优质开源项目:https://gitcode.com/ 简介 aes-tool 是一款基于 Rijndael 加密法实现的 AES 加密工具。它支持更大范围的区块和密钥长度。AES 的区块长度固定为 128 比特，密钥长度则可以是 128、192 或 256 比特。而 Rijndael 使用的密钥和区块长度可以是 32 位的整数倍，以 128 位为下限...
AES加密的工具类
killppyou的博客
03-05 261
package com.galaxyfintech.bigdata.das.eyes.utils; import javax.crypto.*; import javax.crypto.spec.SecretKeySpec; import java.io.UnsupportedEncodingException; import java.security.InvalidKeyException...
使用AES_GCM加密模式创造一个Windows加密工具
qq_54226199的博客
04-10 1261
手搓AES_GCM文件加密工具
AES加密算法介绍（附AES在线工具）
迷失蒲公英
05-16 8314
，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。现在，高级加密标准已然成为对称密钥加密中最流行的算法之一。AES是一种对称密钥算法，意味着加密和解密使用相同的密钥。这种算法非常高效，可以在处理大量数据时提供快速的加密和解密操作。
AES加解密工具,AES加密解密在线工具-站长工具网
zhaoxiaoming4444的博客
10-11 1080
本文介绍了AES加密算法及其在网络安全领域的重要性，并详细阐述了如何使用站长工具网上的AES加解密在线工具进行实验和测试。AES算法具有较高的计算效率，同时保持了良好的安全性能，因此在许多场景下得到了广泛应用。本文将介绍AES加解密工具的重要性，以及如何使用在线工具进行AES加密和解密。现在，许多网站提供了免费的AES加解密在线工具，方便用户进行实验和测试。需要注意的是，虽然在线工具方便快捷，但用户仍需注意保护个人信息和密码安全，避免在公共网络环境下使用。，找到“AES加解密在线工具”栏目。
AES对称加密、解密工具
weixin_58403235的博客
06-29 1651
【代码】AES对称加密、解密工具。
C#之AES加密解密
AI的博客
10-25 2544
AES加密标准又称为高级加密标准Rijndael加密法，是美国国家标准技术研究所NIST旨在取代DES的21世纪的加密标准。AES的基本要求是，采用对称分组密码体制，密钥长度可以为128、192或256位，分组长度128位，算法应易在各种硬件和软件上实现。1998年NIST开始AES第一轮分析、测试和征集，共产生了15个候选算法。
AES加密解密工具类
weixin_39093006的博客
11-23 216
【代码】AES加密解密工具类。
AES加密工具类AESUtil
weixin_38399962的博客
10-15 4979
本文工具类针对的是Java环境下, AES对称加密的工具类, 包括加密和解密 package com.alicom.flow.util; import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec; import org.apache.commons.codec.binary.Base64; /** * * @author zhouzhou * 2020-9-29 15:27:42 * */ public clas
AES加密工具类
watcher7035的博客
11-15 123
package com.lxb.manage.common.utils; import org.springframework.util.Base64Utils; import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import java.nio.charset.StandardCharset
AES加密的使用 Hutool 工具包SecureUtil.aes
分析知识
01-02 2216
Hutool 工具包
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值