java AES对称加密，微信aes解密，对应js aes加解密

曾经终败给现在 2023-07-19 06:00 34阅读 0赞

AES是对称加密算法，顾名思义就是加密和解密的密钥是同一个。

更多的详情可以先百度了解一下，这里不多介绍了。

直接看代码如何使用。

为了更好的兼容不同的算法，先添加一个辅助包

<dependency>
                <groupId>org.bouncycastle</groupId>
                <artifactId>bcprov-jdk15</artifactId>
                <version>1.46</version>
            </dependency>

工具类，直接拖到工程可用。使用方式很简单，就两个方法，加密和解密，直接看代码就明白。

import java.security.AlgorithmParameters;
    import java.security.InvalidAlgorithmParameterException;
    import java.security.Key;
    import java.security.MessageDigest;
    import java.security.NoSuchProviderException;
    import java.security.SecureRandom;
    import java.security.Security;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
    
    import org.bouncycastle.jce.provider.BouncyCastleProvider;
    
    
    /**
     * 〈AES对称加密工具类〉
     *
     * @author gogym
     * @version 2017年9月19日
     * @see AESEncryptUtil
     * @since
     */
    public class AESEncryptUtil {
        private static final String DEFAULT_CODING = "utf-8";
        //密匙，可换成自己需要的
        private static String key = "209f04ad11cafd80bf2d4fd66665a19c";
    
        //测试
        public static void main(String[] args) {
            // getKey();
            String en = AESEncode("7c4a8d09ca3762af61e59520943dc26494f8941b");
            System.out.println(en);
            System.out.println(AESDncode(en));
        }
    
        /**
         * 随机生成原始对称密钥
         */
        public static void getKey() {
            try {
                KeyGenerator kg = KeyGenerator.getInstance("AES");
                kg.init(128);// 要生成多少位，只需要修改这里即可128, 192或256
                SecretKey sk = kg.generateKey();
                byte[] b = sk.getEncoded();
                String s = byteToHexString(b);
                System.out.println(s);
                System.out.println("十六进制密钥长度为" + s.length());
                System.out.println("二进制密钥的长度为" + s.length() * 4);
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("没有此算法。");
            }
        }
    
        /**
         * 使用指定的字符串产生原始对称密钥
         */
        public static void getKeyByPass(String password) {
            // 生成秘钥
            try {
                KeyGenerator kg = KeyGenerator.getInstance("AES");
                // SecureRandom是生成安全随机数序列，password.getBytes()是种子，只要种子相同，序列就一样，所以生成的秘钥就一样。
                kg.init(128, new SecureRandom(password.getBytes()));
                SecretKey sk = kg.generateKey();
                byte[] b = sk.getEncoded();
                String s = byteToHexString(b);
                System.out.println(s);
                System.out.println("十六进制密钥长度为" + s.length());
                System.out.println("二进制密钥的长度为" + s.length() * 4);
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("没有此算法。");
            }
        }
    
    
        /**
         * 加密
         */
        public static String AESEncode(String content) {
            try {
    
                byte[] input = content.getBytes(DEFAULT_CODING);
    
                MessageDigest md = MessageDigest.getInstance("MD5");
                byte[] thedigest = md.digest(key.getBytes(DEFAULT_CODING));
                SecretKeySpec skc = new SecretKeySpec(thedigest, "AES");
    
                Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
                cipher.init(Cipher.ENCRYPT_MODE, skc);
                byte[] cipherText = new byte[cipher.getOutputSize(input.length)];
                int ctLength = cipher.update(input, 0, input.length, cipherText, 0);
                ctLength += cipher.doFinal(cipherText, ctLength);
                String str = Base64Util.encode(cipherText);
                return str;
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            // 如果有错就返加null
            return null;
        }
    
        /**
         * 解密
         */
        public static String AESDncode(String encrypted) {
            try {
                MessageDigest md = MessageDigest.getInstance("MD5");
                byte[] thedigest = md.digest(key.getBytes(DEFAULT_CODING));
                SecretKeySpec skc = new SecretKeySpec(thedigest, "AES");
    
                Cipher dcipher = Cipher.getInstance("AES");
                dcipher.init(Cipher.DECRYPT_MODE, skc);
                byte[] enByte = Base64Util.decode(encrypted);
                byte[] clearbyte = dcipher.doFinal(enByte);
                return new String(clearbyte);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            // 如果有错就返加null
            return null;
        }
    
        /**
         * 对应微信AES解密
         *
         * @param content 密文
         * @return
         * @throws InvalidAlgorithmParameterException
         * @throws NoSuchProviderException
         */
        public static byte[] decrypt(byte[] content, byte[] keyByte, byte[] ivByte)
                throws InvalidAlgorithmParameterException {
            Security.addProvider(new BouncyCastleProvider());
            try {
                Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");
                Key sKeySpec = new SecretKeySpec(keyByte, "AES");
    
                cipher.init(Cipher.DECRYPT_MODE, sKeySpec, generateIV(ivByte));// 初始化
                byte[] result = cipher.doFinal(content);
                return result;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        // 生成iv
        public static AlgorithmParameters generateIV(byte[] iv)
                throws Exception {
            AlgorithmParameters params = AlgorithmParameters.getInstance("AES");
            params.init(new IvParameterSpec(iv));
            return params;
        }
    
    
        /**
         * Description: 转成二进制
         *
         * @param src
         * @return
         * @see
         */
        private static byte[] asBin(String src) {
            if (src.length() < 1) return null;
            byte[] encrypted = new byte[src.length() / 2];
            for (int i = 0; i < src.length() / 2; i++) {
                int high = Integer.parseInt(src.substring(i * 2, i * 2 + 1), 16);
                int low = Integer.parseInt(src.substring(i * 2 + 1, i * 2 + 2), 16);
                encrypted[i] = (byte) (high * 16 + low);
            }
            return encrypted;
        }
    
        /**
         * byte数组转化为16进制字符串
         *
         * @param bytes
         * @return
         */
        private static String byteToHexString(byte[] bytes) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < bytes.length; i++) {
                String strHex = Integer.toHexString(bytes[i]);
                if (strHex.length() > 3) {
                    sb.append(strHex.substring(6));
                } else {
                    if (strHex.length() < 2) {
                        sb.append("0" + strHex);
                    } else {
                        sb.append(strHex);
                    }
                }
            }
            return sb.toString();
        }
    }

和js中提供的aes加解密要结合使用的话，需要做一下兼容，因为js里面使用的算法与在java里面的不一样，直接使用可能会无法兼容，这里提供一个工具类，跟js实现的算法是对应的，如果前端是js，可以搭配这个类使用

import java.math.BigInteger;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.spec.SecretKeySpec;
    
    import org.apache.commons.codec.binary.Base64;
    import org.apache.commons.lang3.StringUtils;
    
    import sun.misc.BASE64Decoder;
    
    
    /**
     * AES的加密和解密对应JS
     *
     * @author libo
     */
    public class AESJSEncryptUtils {
        // 密钥必须16位 (需要前端和后端保持一致)
        private static final String KEY = "E8N3Rfk51nbm810V";
    
        // 算法
        private static final String ALGORITHMSTR = "AES/ECB/PKCS5Padding";
    
        /**
         * aes解密
         *
         * @param encrypt 内容
         * @return
         * @throws Exception
         */
        public static String aesDecrypt(String encrypt) {
            try {
                return aesDecrypt(encrypt, KEY);
            } catch (Exception e) {
                e.printStackTrace();
                return "";
            }
        }
    
        /**
         * aes加密
         *
         * @param content
         * @return
         * @throws Exception
         */
        public static String aesEncrypt(String content) {
            try {
                return aesEncrypt(content, KEY);
            } catch (Exception e) {
                e.printStackTrace();
                return "";
            }
        }
    
        /**
         * 将byte[]转为各种进制的字符串
         *
         * @param bytes byte[]
         * @param radix 可以转换进制的范围，从Character.MIN_RADIX到Character.MAX_RADIX，超出范围后变为10进制
         * @return 转换后的字符串
         */
        public static String binary(byte[] bytes, int radix) {
            return new BigInteger(1, bytes).toString(radix);// 这里的1代表正数
        }
    
        /**
         * base 64 encode
         *
         * @param bytes 待编码的byte[]
         * @return 编码后的base 64 code
         */
        public static String base64Encode(byte[] bytes) {
            return Base64.encodeBase64String(bytes);
        }
    
        /**
         * base 64 decode
         *
         * @param base64Code 待解码的base 64 code
         * @return 解码后的byte[]
         * @throws Exception
         */
        public static byte[] base64Decode(String base64Code) throws Exception {
            return StringUtils.isEmpty(base64Code) ? null : new BASE64Decoder().decodeBuffer(base64Code);
        }
    
        /**
         * AES加密
         *
         * @param content    待加密的内容
         * @param encryptKey 加密密钥
         * @return 加密后的byte[]
         * @throws Exception
         */
        public static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            kgen.init(128);
            Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
            cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(encryptKey.getBytes(), "AES"));
    
            return cipher.doFinal(content.getBytes("utf-8"));
        }
    
        /**
         * AES加密为base 64 code
         *
         * @param content    待加密的内容
         * @param encryptKey 加密密钥
         * @return 加密后的base 64 code
         * @throws Exception
         */
        public static String aesEncrypt(String content, String encryptKey) throws Exception {
            return base64Encode(aesEncryptToBytes(content, encryptKey));
        }
    
        /**
         * AES解密
         *
         * @param encryptBytes 待解密的byte[]
         * @param decryptKey   解密密钥
         * @return 解密后的String
         * @throws Exception
         */
        public static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) throws Exception {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            kgen.init(128);
    
            Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
            cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(decryptKey.getBytes(), "AES"));
            byte[] decryptBytes = cipher.doFinal(encryptBytes);
            return new String(decryptBytes);
        }
    
        /**
         * 将base 64 code AES解密
         *
         * @param encryptStr 待解密的base 64 code
         * @param decryptKey 解密密钥
         * @return 解密后的string
         * @throws Exception
         */
        public static String aesDecrypt(String encryptStr, String decryptKey) throws Exception {
            return StringUtils.isEmpty(encryptStr) ? null : aesDecryptByBytes(base64Decode(encryptStr), decryptKey);
        }
    
        /**
         * 测试
         */
        public static void main(String[] args)
                throws Exception {
            String content = "123";
            System.out.println("加密前：" + content);
            System.out.println("加密密钥和解密密钥：" + KEY);
            String encrypt = aesEncrypt(content, KEY);
            System.out.println("加密后：" + encrypt);
            String decrypt = aesDecrypt(encrypt, KEY);
            System.out.println("解密后：" + decrypt);
        }
    }

完