JAVA实现AES加密

最新推荐文章于 2024-02-29 20:16:30 发布
最新推荐文章于 2024-02-29 20:16:30 发布
阅读量80 收藏
点赞数
分类专栏： JaveEE 文章标签： Java SUN 算法 F#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/edicky/article/details/83680749
版权

1. 因子

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

2. JAVA实现

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

2.1 加密

代码有详细解释，不多废话。
/**    * 加密    *     * @param content 需要加密的内容    * @param password  加密密码    * @return    */    public   static   byte [] encrypt(String content, String password) {           try  {                              KeyGenerator kgen = KeyGenerator.getInstance("AES" );                   kgen.init(128 ,  new  SecureRandom(password.getBytes()));                   SecretKey secretKey = kgen.generateKey();                   byte [] enCodeFormat = secretKey.getEncoded();                   SecretKeySpec key = new  SecretKeySpec(enCodeFormat,  "AES" );                   Cipher cipher = Cipher.getInstance("AES" ); // 创建密码器                    byte [] byteContent = content.getBytes( "utf-8" );                   cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化                    byte [] result = cipher.doFinal(byteContent);                   return  result;  // 加密            } catch  (NoSuchAlgorithmException e) {                   e.printStackTrace();           } catch  (NoSuchPaddingException e) {                   e.printStackTrace();           } catch  (InvalidKeyException e) {                   e.printStackTrace();           } catch  (UnsupportedEncodingException e) {                   e.printStackTrace();           } catch  (IllegalBlockSizeException e) {                   e.printStackTrace();           } catch  (BadPaddingException e) {                   e.printStackTrace();           }           return   null ;   }
/** * 加密 * * @param content 需要加密的内容 * @param password 加密密码 * @return */ public static byte[] encrypt(String content, String password) { try { KeyGenerator kgen = KeyGenerator.getInstance("AES"); kgen.init(128, new SecureRandom(password.getBytes())); SecretKey secretKey = kgen.generateKey(); byte[] enCodeFormat = secretKey.getEncoded(); SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES"); Cipher cipher = Cipher.getInstance("AES");// 创建密码器 byte[] byteContent = content.getBytes("utf-8"); cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化 byte[] result = cipher.doFinal(byteContent); return result; // 加密 } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (NoSuchPaddingException e) { e.printStackTrace(); } catch (InvalidKeyException e) { e.printStackTrace(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } catch (IllegalBlockSizeException e) { e.printStackTrace(); } catch (BadPaddingException e) { e.printStackTrace(); } return null; }

2.2 解密

代码有详细注释，不多废话
注意：解密的时候要传入byte数组
view plain copy to clipboard print ?
  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. }  
/**解密 * @param content 待解密内容 * @param password 解密密钥 * @return */ public static byte[] decrypt(byte[] content, String password) { try { KeyGenerator kgen = KeyGenerator.getInstance("AES"); kgen.init(128, new SecureRandom(password.getBytes())); SecretKey secretKey = kgen.generateKey(); byte[] enCodeFormat = secretKey.getEncoded(); SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES"); Cipher cipher = Cipher.getInstance("AES");// 创建密码器 cipher.init(Cipher.DECRYPT_MODE, key);// 初始化 byte[] result = cipher.doFinal(content); return result; // 加密 } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (NoSuchPaddingException e) { e.printStackTrace(); } catch (InvalidKeyException e) { e.printStackTrace(); } catch (IllegalBlockSizeException e) { e.printStackTrace(); } catch (BadPaddingException e) { e.printStackTrace(); } return null; }

2.3 测试代码

view plain copy to clipboard print ?
  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));  
String content = "test"; String password = "12345678"; //加密 System.out.println("加密前：" + content); byte[] encryptResult = encrypt(content, password); //解密 byte[] decryptResult = decrypt(encryptResult,password); System.out.println("解密后：" + new String(decryptResult));
输出结果如下：
加密前：test
解密后：test

2.4 容易出错的地方

但是如果我们将测试代码修改一下，如下：
view plain copy to clipboard print ?
  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. }  
String content = "test"; String password = "12345678"; //加密 System.out.println("加密前：" + content); byte[] encryptResult = encrypt(content, password); try { String encryptResultStr = new String(encryptResult,"utf-8"); //解密 byte[] decryptResult = decrypt(encryptResultStr.getBytes("utf-8"),password); System.out.println("解密后：" + new String(decryptResult)); } catch (UnsupportedEncodingException e) { e.printStackTrace(); }
则，系统会报出如下异常：
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进制
view plain copy to clipboard print ?
  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. }  
/**将二进制转换成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(); }
2.4.2 将16进制转换为二进制
view plain copy to clipboard print ?
  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. }  
/**将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; }
然后，我们再修订以上测试代码，如下：
view plain copy to clipboard print ?
  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));  
String content = "test"; String password = "12345678"; //加密 System.out.println("加密前：" + content); byte[] encryptResult = encrypt(content, password); String encryptResultStr = parseByte2HexStr(encryptResult); System.out.println("加密后：" + encryptResultStr); //解密 byte[] decryptFrom = parseHexStr2Byte(encryptResultStr); byte[] decryptResult = decrypt(decryptFrom,password); System.out.println("解密后：" + new String(decryptResult));
测试结果如下：
加密前：test
加密后：73C58BAFE578C59366D8C995CD0B9D6D
解密后：test
 

2.5 另外一种加密方式

还有一种加密方式，大家可以参考如下：
view plain copy to clipboard print ?
  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.      }  
/** * 加密 * * @param content 需要加密的内容 * @param password 加密密码 * @return */ public static byte[] encrypt2(String content, String password) { try { SecretKeySpec key = new SecretKeySpec(password.getBytes(), "AES"); Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding"); byte[] byteContent = content.getBytes("utf-8"); cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化 byte[] result = cipher.doFinal(byteContent); return result; // 加密 } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (NoSuchPaddingException e) { e.printStackTrace(); } catch (InvalidKeyException e) { e.printStackTrace(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } catch (IllegalBlockSizeException e) { e.printStackTrace(); } catch (BadPaddingException e) { e.printStackTrace(); } return null; }
这种加密方式有两种限制
  • 密钥必须是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*..)
要解决如上异常，可以通过补全传入加密内容等方式进行避免。
edicky
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 基于AES实现对文件的加密 解密
02-02
java 基于AES实现对文件的加密 解密 有问题 www.willvc.com.cn 能联系到我
Java 实现 AES 加密和解密完整示例
热门推荐
蜗牛的博客
05-12 2万+
AES，全称为 Advanced Encryption Standard，是一种分组密码算法，用于保护敏感数据的传输和存储。AES 分为 128 位和 256 位两种密钥长度，可以对数据进行加密和解密，保证数据的安全性和完整性。AES 主要应用于电子商务、移动支付、网络安全等领域，被广泛运用于现代社会的各个方面。AES 算法被设计为高度安全，可以在理论上保证其分组密码的安全性。然而，由于其复杂性和密钥长度，AES 算法的实现和应用也具有一定的技术难度。
java 实现AES加密
qq_35004315的博客
02-29 664
【代码】java 实现AES加密。
Java实现AES加密算法
qq_45984772的博客
02-07 586
AES加密
Java实现AES加密解密
king的专栏
05-05 2104
AES（Advanced Encryption Standard）高级加密标准，是一种被广泛使用的对称加密算法，用于加密和解密数据。它曾经是美国政府的一个机密标准，但现在已成为公开的加密算法，并被广泛使用于商业、政府及军事领域。AES算法有三种不同的密钥长度：128位、192位和256位，每种长度有不同数量的轮数，其中128位密钥需要进行10轮加密，192位密钥需要进行12轮加密，256位密钥需要进行14轮加密。
JAVA 实现AES加密解密
juanqiao7497的博客
03-24 2万+
AES加密模式有ECB,CBC,CTR等 AES填充模式有pkcs5padding， pkcs7padding， no padding等 AES数据块则有128位 192位 256位 AES加密密码，如果选择数据块128位，则要求密码长度为16,数据块192位则要求密码长度为24，数据块长度为256位，则要求密码长度为32 AES的偏移量和AES加密类似 AES输出则有base64和hex两种 AES字符集有gb2312，gbk,utf-8等 1 使用CBC+PKCS5Padding+ba.
如何用java实现AES加密和解密
weixin_57604284的博客
05-12 2629
AES算法是一种对称加密算法，也就是说，加密和解密使用的是同一个密钥。它是美国国家标准技术研究所（NIST）在2001年选定的一种高级加密标准（Advanced Encryption Standard），用来替代之前的DES算法。AES算法的优点是安全性高、效率高、易于实现、不需要专利授权等。
Java实现AES加密文件
Zhaozhinet的博客
09-30 889
用Java的AES实现文件加密。
Java实现AES加密算法的简单示例分享
09-02
Java实现AES加密算法的简单示例主要涉及到的是高级加密标准（AES）在Java编程语言中的应用。AES是一种广泛使用的块加密标准，它基于密码值的置换和替代操作，用于保护数据的安全。AES已被美国联邦政府采纳，取代了...
JAVA实现AES加密和解密
08-15
总的来说，理解并正确使用Java实现AES加密和解密，需要注意秘钥的生成、工作模式的选择、填充方式以及字符编码的一致性，这样才能确保数据的安全传输和正确解密。通过实际操作和实践，你可以更深入地掌握这些知识点...
JAVA实现AES加密算法代码.doc
最新发布
06-28
### JAVA实现AES加密算法知识点详解 #### 一、AES加密算法简介 AES（Advanced Encryption Standard，高级加密标准）是一种对称加密算法，用于保护敏感数据的安全传输和存储。相较于之前的DES（Data Encryption ...
java实现aes加密
06-03
java实现aes加解密
JAVA实现AES加密算法.rar
08-18
这个RAR文件"JAVA实现AES加密算法"很可能是包含了一个示例项目，展示如何在JAVA中具体实现AES加密算法，对于初学者来说，是一个很好的学习资源。通过阅读和理解代码，你可以更深入地了解AES的工作原理，以及如何在...
java 文件aes加密解密,java实现AES加密解密 -- 对文件的加密解密
weixin_36138524的博客
03-20 857
对文件的加密解密但是这样写的工具类Cipher ，会出现一个异常，在Linux中会解密失败，具体解决办法，见另一篇博客：https://blog..net/weixin_43276786/article/details/90381086工具类：package cn.com.dh.util;import java.security.SecureRandom;import javax.crypto.C...
Java 实现Aes加密解密
12-16
采用固定AES密钥加密，AES使用PKCS5规则进行补位，加密模式使用AES-ECB
java实现AES可逆加密算法
08-26
在 Java 中使用 Cipher 类实现AES加密。在加密之前，需要将密钥转换为 byte 数组，然后使用 Cipher.init() 方法初始化加密模式。最后，使用 doFinal() 方法对数据进行加密。 4. 解密 解密过程与加密过程相似，首先...
AES_Java:使用Java实现AES加密算法的全过程
05-16
在Java中实现AES加密算法，你需要了解以下关键知识点： 1. **AES算法基础**：AES是基于Rijndael算法的，它支持128、192和256位的密钥长度，以及128位的数据块大小。AES加密过程分为多个步骤，包括字节替换、行移位...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值