常用加密算法的Java实现总结(二) ——对称加密算法AES

最新推荐文章于 2025-02-09 07:00:00 发布
转载 最新推荐文章于 2025-02-09 07:00:00 发布 · 459 阅读 · 0

本文详细介绍如何使用Java实现AES加密和解密操作，并提供两种不同方式的实现代码，同时解决常见错误。

1. 因子

       近些年DES使用越来越少，原因就在于其使用56位密钥，比较容易被破解，近些年来逐渐被AES替代，AES已经变成目前对称加密中最流行算法之一；AES可以使用128、192、和256位密钥，并且用128位分组加密和解密数据。本文就简单介绍如何通过JAVA实现AES加密。

2. JAVA实现

闲话少许，掠过AES加密原理及算法，关于这些直接搜索专业网站吧，我们直接看JAVA的具体实现。

2.1 加密

代码有详细解释，不多废话。
[java] view plain copy
  1. /** 
  2.  * 加密 
  3.  *  
  4.  * @param content 需要加密的内容 
  5.  * @param password  加密密码 
  6.  * @return 
  7.  */  
  8. public static byte[] encrypt(String content, String password) {  
  9.         try {             
  10.                 KeyGenerator kgen = KeyGenerator.getInstance("AES");  
  11.                 kgen.init(128, new SecureRandom(password.getBytes()));  
  12.                 SecretKey secretKey = kgen.generateKey();  
  13.                 byte[] enCodeFormat = secretKey.getEncoded();  
  14.                 SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");  
  15.                 Cipher cipher = Cipher.getInstance("AES");// 创建密码器  
  16.                 byte[] byteContent = content.getBytes("utf-8");  
  17.                 cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化  
  18.                 byte[] result = cipher.doFinal(byteContent);  
  19.                 return result; // 加密  
  20.         } catch (NoSuchAlgorithmException e) {  
  21.                 e.printStackTrace();  
  22.         } catch (NoSuchPaddingException e) {  
  23.                 e.printStackTrace();  
  24.         } catch (InvalidKeyException e) {  
  25.                 e.printStackTrace();  
  26.         } catch (UnsupportedEncodingException e) {  
  27.                 e.printStackTrace();  
  28.         } catch (IllegalBlockSizeException e) {  
  29.                 e.printStackTrace();  
  30.         } catch (BadPaddingException e) {  
  31.                 e.printStackTrace();  
  32.         }  
  33.         return null;  
  34. }  

2.2 解密

代码有详细注释，不多废话
注意：解密的时候要传入byte数组
[java] view plain copy
  1. /**解密 
  2.  * @param content  待解密内容 
  3.  * @param password 解密密钥 
  4.  * @return 
  5.  */  
  6. public static byte[] decrypt(byte[] content, String password) {  
  7.         try {  
  8.                  KeyGenerator kgen = KeyGenerator.getInstance("AES");  
  9.                  kgen.init(128, new SecureRandom(password.getBytes()));  
  10.                  SecretKey secretKey = kgen.generateKey();  
  11.                  byte[] enCodeFormat = secretKey.getEncoded();  
  12.                  SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");              
  13.                  Cipher cipher = Cipher.getInstance("AES");// 创建密码器  
  14.                 cipher.init(Cipher.DECRYPT_MODE, key);// 初始化  
  15.                 byte[] result = cipher.doFinal(content);  
  16.                 return result; // 加密  
  17.         } catch (NoSuchAlgorithmException e) {  
  18.                 e.printStackTrace();  
  19.         } catch (NoSuchPaddingException e) {  
  20.                 e.printStackTrace();  
  21.         } catch (InvalidKeyException e) {  
  22.                 e.printStackTrace();  
  23.         } catch (IllegalBlockSizeException e) {  
  24.                 e.printStackTrace();  
  25.         } catch (BadPaddingException e) {  
  26.                 e.printStackTrace();  
  27.         }  
  28.         return null;  
  29. }  

2.3 测试代码

[java] view plain copy
  1. String content = "test";  
  2. String password = "12345678";  
  3. //加密  
  4. System.out.println("加密前：" + content);  
  5. byte[] encryptResult = encrypt(content, password);  
  6. //解密  
  7. byte[] decryptResult = decrypt(encryptResult,password);  
  8. System.out.println("解密后：" + new String(decryptResult));  
输出结果如下：
加密前：test
解密后：test

2.4 容易出错的地方

但是如果我们将测试代码修改一下，如下：
[javascript] view plain copy
  1. String content = "test";  
  2. String password = "12345678";  
  3. //加密  
  4. System.out.println("加密前：" + content);  
  5. byte[] encryptResult = encrypt(content, password);  
  6. try {  
  7.         String encryptResultStr = new String(encryptResult,"utf-8");  
  8.         //解密  
  9.         byte[] decryptResult = decrypt(encryptResultStr.getBytes("utf-8"),password);  
  10.         System.out.println("解密后：" + new String(decryptResult));  
  11. } catch (UnsupportedEncodingException e) {  
  12.         e.printStackTrace();  
  13. }  
则，系统会报出如下异常：
javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher
        at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)
        at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)
        at com.sun.crypto.provider.AESCipher.engineDoFinal(DashoA13*..)
        at javax.crypto.Cipher.doFinal(DashoA13*..)
这主要是因为加密后的byte数组是不能强制转换成字符串的，换言之：字符串和byte数组在这种情况下不是互逆的；要避免这种情况，我们需要做一些修订，可以考虑将二进制数据转换成十六进制表示，主要有如下两个方法：
2.4.1将二进制转换成16进制
[java] view plain copy
  1. /**将二进制转换成16进制 
  2.  * @param buf 
  3.  * @return 
  4.  */  
  5. public static String parseByte2HexStr(byte buf[]) {  
  6.         StringBuffer sb = new StringBuffer();  
  7.         for (int i = 0; i < buf.length; i++) {  
  8.                 String hex = Integer.toHexString(buf[i] & 0xFF);  
  9.                 if (hex.length() == 1) {  
  10.                         hex = '0' + hex;  
  11.                 }  
  12.                 sb.append(hex.toUpperCase());  
  13.         }  
  14.         return sb.toString();  
  15. }  
2.4.2 将16进制转换为二进制
[java] view plain copy
  1. /**将16进制转换为二进制 
  2.  * @param hexStr 
  3.  * @return 
  4.  */  
  5. public static byte[] parseHexStr2Byte(String hexStr) {  
  6.         if (hexStr.length() < 1)  
  7.                 return null;  
  8.         byte[] result = new byte[hexStr.length()/2];  
  9.         for (int i = 0;i< hexStr.length()/2; i++) {  
  10.                 int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);  
  11.                 int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);  
  12.                 result[i] = (byte) (high * 16 + low);  
  13.         }  
  14.         return result;  
  15. }  
然后，我们再修订以上测试代码，如下：
[java] view plain copy
  1. String content = "test";  
  2. String password = "12345678";  
  3. //加密  
  4. System.out.println("加密前：" + content);  
  5. byte[] encryptResult = encrypt(content, password);  
  6. String encryptResultStr = parseByte2HexStr(encryptResult);  
  7. System.out.println("加密后：" + encryptResultStr);  
  8. //解密  
  9. byte[] decryptFrom = parseHexStr2Byte(encryptResultStr);  
  10. byte[] decryptResult = decrypt(decryptFrom,password);  
  11. System.out.println("解密后：" + new String(decryptResult));  
测试结果如下：
加密前：test
加密后：73C58BAFE578C59366D8C995CD0B9D6D
解密后：test
 

2.5 另外一种加密方式

还有一种加密方式，大家可以参考如下：
[java] view plain copy
  1. /** 
  2.       * 加密 
  3.       * 
  4.       * @param content 需要加密的内容 
  5.       * @param password  加密密码 
  6.       * @return 
  7.       */  
  8.      public static byte[] encrypt2(String content, String password) {  
  9.              try {  
  10.                      SecretKeySpec key = new SecretKeySpec(password.getBytes(), "AES");  
  11.                      Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");  
  12.                      byte[] byteContent = content.getBytes("utf-8");  
  13.                      cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化  
  14.                      byte[] result = cipher.doFinal(byteContent);  
  15.                      return result; // 加密  
  16.              } catch (NoSuchAlgorithmException e) {  
  17.                      e.printStackTrace();  
  18.              } catch (NoSuchPaddingException e) {  
  19.                      e.printStackTrace();  
  20.              } catch (InvalidKeyException e) {  
  21.                      e.printStackTrace();  
  22.              } catch (UnsupportedEncodingException e) {  
  23.                      e.printStackTrace();  
  24.              } catch (IllegalBlockSizeException e) {  
  25.                      e.printStackTrace();  
  26.              } catch (BadPaddingException e) {  
  27.                      e.printStackTrace();  
  28.              }  
  29.              return null;  
  30.      }  
这种加密方式有两种限制
  • 密钥必须是16位的
  • 待加密内容的长度必须是16的倍数，如果不是16的倍数，就会出如下异常：
javax.crypto.IllegalBlockSizeException: Input length not multiple of 16 bytes
        at com.sun.crypto.provider.SunJCE_f.a(DashoA13*..)
        at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)
        at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)
        at com.sun.crypto.provider.AESCipher.engineDoFinal(DashoA13*..)
        at javax.crypto.Cipher.doFinal(DashoA13*..)
要解决如上异常，可以通过补全传入加密内容等方式进行避免。
AES加密算法的原理和代码实现
wsrzsfgst的博客
03-05 933
AES（Advanced Encryption Standard）是一种对称加密算法，常用于加密和解密数据。AES算法使用相同的密钥来加密和解密数据，安全性较高，速度较快。
【Java】全网最详细的对称加密AES详解
weixin_43219644的博客
08-21 6349
AES（Advanced Encryption Standard，高级加密标准）是一种对称加密算法，用于加密电子数据。它是由比利时密码学家Joan Daemen和Vincent Rijmen设计的，并于2001年由美国国家标准与技术研究院（NIST）采纳为官方标准。
转的JAVA实现AES加密
babyduncan的专栏
12-07 373
  JAVA实现AES加密 1. 因子        上次介绍了《JAVA实现AES加密 》， 中间提到近些年DES使用越来越少，原因就在于其使用56位密钥，比较容易被破解，近些年来逐渐被AES替代，AES已经变成目前对称加密中最流行算法之 一；AES可以使用128、192、和256位密钥，并且用128位分组加密和解密数据。本文就简单介绍如何通过JAVA实现AES...
AES解密报错，Input length must be multiple of 16 when decrypting with padded cipher
虽千万人,吾往矣
07-06 3万+
在做登录页面的用户名和密码加密时，前端加密后端解密，但是抛出报错：Input length must be multiple of 16 when decrypting with padded cipher，仔细检查过偏移向量，没有问题，但还是不行，于是在后端测试，先加密，后解密，测试发现一切正常，那问题就应该出现在传参上面，应该是字符转义的问题； .........
SpringCloud 请求报错 Input length must be multiple of 16 when decrypting with padded cipher
神秘的凯
04-08 5915
今天在调试某个接口的时候 app那边反馈说其中一个接口加密的数据解密不出来。 一开始我没当回事 觉得是他们的解密方法有问题，直到他们百般尝试以后还是不行才引起了我的注意！ 于是就来调试一下吧。反正闲着也是闲着！ 分析：一开始可能觉得是api服务端返回的数据有问题导致AES加密的串出了问题 所以导致没发解密！ 后来一顿分析 过程如下！ 报错信息 报错的接口： 当时在这个接口服务分析错误 花费了非常多时间 大概是觉得原因有两点 1:这个接口返回的数据有问题 可能会有特殊符号导致无法被返回
常用加密算法的Java实现总结(二)——对称加密算法DES、3DES和AES.pdf
02-10
对称加密算法包括了多种算法，本文主要介绍DES、3DES和AES这三种常见的对称加密算法，并对它们进行Java实现的总结。 首先，对称加密算法的一个关键优势在于其算法公开、计算量小、加密速度快、加密效率高，但它们也...
对称加密算法——AES加密算法
专注分享技术、实用优质教程、资源
02-09 1320
对称加密算法——AES加密算法详解
Java实现的对称加密算法AES定义与用法详解
08-27
"Java实现的对称加密算法AES定义与用法详解" 对称加密算法AES是当前使用最多的加密算法之一，其主要特点是高级的、安全的、快速的和灵活的。下面我们将详细介绍Java实现的对称加密算法AES的定义、特点、用法及使用...
AES加密算法（java实现）.zip_aes java_cmM0 解密_java aes加密 demo_js aes加密算法_
09-20
AES，全称Advanced Encryption Standard，即高级加密标准，是一种广泛应用于现代网络安全的对称加密算法。它是基于块密码，每个块大小为128位，使用128、192或256位的密钥进行加密。AES在Java中的实现通常包括加密和...
Java环境下AES加密算法的实现方法
最新发布
06-13
凭借其卓越的安全性和高效性，AES在发布后的短短几年内便迅速在全球范围内得到广泛应用，到2006年已经成为对称密钥加密算法中最受欢迎的选项之一。 本软件采用Java语言开发，成功实现了AES算法对文件的加密与解密...
javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with pad
qq_30624649的博客
03-17 1万+
javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher异常是AES加密解密的报错异常，在向方法传输参数进行解密的过程中会报错， AESUtils 工具类： package ctd.util.codec; import com.fasterxml.jackson.databind.ObjectMapper; import ctd.util
AES出现Input length must be multiple of 16 when decrypting with padded cipher
eternally_zh128@sina.com的博客
04-06 5610
解决办法：增加二进制与十六进制互转的相关方法。
JAVA实现AES 解密报错Input length must be multiple of 16 when decrypting with padded cipher
热门推荐
Willian的博客屋
12-04 7万+
博客引用处（以下内容在原有博客基础上进行补充或更改，谢谢这些大牛的博客指导）： JAVA实现AES加密 加密代码 /** * 加密 * * @param content 需要加密的内容 * @param password 加密密码 * @return */ ...
java AES 加密,报javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decryp
hyy
08-30 6651
java 使用AES解密报这个异常,字面理解很容易,就是解密的字符串的数组必须是16的倍数 javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher at com.sun.crypto.provider.CipherCore.doFinal(CipherCore.java:922) at com.sun.crypto.provid
Java Input length must be multiple of 16 when decrypting with padded cipher问题解决
旭东怪的博客
03-12 1万+
问题描述： Caused by: javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher 问题分析： 1、已经使用AES解密了，然后又把解密后的结果再次进行AES解密导致的。
Java实现加密（一）AES加解密
ACGkaka的博客
09-19 4万+
AES：高级加密标准（Advanced Encryption Standard）是美国联邦政府采用的一种区块加密标准，是目前最流行的一种对称加密算法。是用来替代DES的新一代分组加密算法。AES支持三种长度的密钥：128位、192位、256位。
Java使用Cipher.getInstance(“AES/ECB/PKCS5Padding“)；加解密算法工具类实现
九七的博客
08-01 8981
Java使用Cipher.getInstance("AES/ECB/PKCS5Padding");加解密算法工具类实现。
Java 实现 AES 加密和解密完整示例
蜗牛的博客
05-12 3万+
AES，全称为 Advanced Encryption Standard，是一种分组密码算法，用于保护敏感数据的传输和存储。AES 分为 128 位和 256 位两种密钥长度，可以对数据进行加密和解密，保证数据的安全性和完整性。AES 主要应用于电子商务、移动支付、网络安全等领域，被广泛运用于现代社会的各个方面。AES 算法被设计为高度安全，可以在理论上保证其分组密码的安全性。然而，由于其复杂性和密钥长度，AES 算法的实现和应用也具有一定的技术难度。
前后端对称加密AES算法实现详解
AES（Advanced Encryption Standard，高级加密标准）是一种广泛使用的对称加密算法，由美国国家标准与技术研究院（NIST）于2001年标准化。AES支持多种密钥长度，常见的有128位、192位和256位。AES算法的安全性很高，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值