Java加密技术（二）——对称加密算法DES&AES

最新推荐文章于 2021-12-09 11:31:03 发布
最新推荐文章于 2021-12-09 11:31:03 发布
阅读量249 收藏
点赞数
分类专栏： java 加密解密 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014467099/article/details/45245205
版权

接下来我们介绍对称加密算法，最常用的莫过于DES数据加密算法。 
DES 
DES-Data Encryption Standard,即数据加密算法。是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密。 
　　DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位。 

 

通过java代码实现如下：Coder类见 Java加密技术（一） 

Java代码   收藏代码
  1. import java.security.Key;  
  2. import java.security.SecureRandom;  
  3.   
  4. import javax.crypto.Cipher;  
  5. import javax.crypto.KeyGenerator;  
  6. import javax.crypto.SecretKey;  
  7. import javax.crypto.SecretKeyFactory;  
  8. import javax.crypto.spec.DESKeySpec;  
  9.   
  10.   
  11. /** 
  12.  * DES安全编码组件 
  13.  *  
  14.  * <pre> 
  15.  * 支持 DES、DESede(TripleDES,就是3DES)、AES、Blowfish、RC2、RC4(ARCFOUR) 
  16.  * DES                  key size must be equal to 56 
  17.  * DESede(TripleDES)    key size must be equal to 112 or 168 
  18.  * AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available 
  19.  * Blowfish             key size must be multiple of 8, and can only range from 32 to 448 (inclusive) 
  20.  * RC2                  key size must be between 40 and 1024 bits 
  21.  * RC4(ARCFOUR)         key size must be between 40 and 1024 bits 
  22.  * 具体内容 需要关注 JDK Document http://.../docs/technotes/guides/security/SunProviders.html 
  23.  * </pre> 
  24.  *  
  25.  * @version 1.0 
  26.  * @since 1.0 
  27.  */  
  28. public abstract class DESCoder extends Coder {  
  29.     /** 
  30.      * ALGORITHM 算法 <br> 
  31.      * 可替换为以下任意一种算法，同时key值的size相应改变。 
  32.      *  
  33.      * <pre> 
  34.      * DES                  key size must be equal to 56 
  35.      * DESede(TripleDES)    key size must be equal to 112 or 168 
  36.      * AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available 
  37.      * Blowfish             key size must be multiple of 8, and can only range from 32 to 448 (inclusive) 
  38.      * RC2                  key size must be between 40 and 1024 bits 
  39.      * RC4(ARCFOUR)         key size must be between 40 and 1024 bits 
  40.      * </pre> 
  41.      *  
  42.      * 在Key toKey(byte[] key)方法中使用下述代码 
  43.      * <code>SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);</code> 替换 
  44.      * <code> 
  45.      * DESKeySpec dks = new DESKeySpec(key); 
  46.      * SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM); 
  47.      * SecretKey secretKey = keyFactory.generateSecret(dks); 
  48.      * </code> 
  49.      */  
  50.     public static final String ALGORITHM = "DES";  
  51.   
  52.     /** 
  53.      * 转换密钥<br> 
  54.      *  
  55.      * @param key 
  56.      * @return 
  57.      * @throws Exception 
  58.      */  
  59.     private static Key toKey(byte[] key) throws Exception {  
  60.         DESKeySpec dks = new DESKeySpec(key);  
  61.         SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);  
  62.         SecretKey secretKey = keyFactory.generateSecret(dks);  
  63.   
  64.         // 当使用其他对称加密算法时，如AES、Blowfish等算法时，用下述代码替换上述三行代码  
  65.         // SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);  
  66.   
  67.         return secretKey;  
  68.     }  
  69.   
  70.     /** 
  71.      * 解密 
  72.      *  
  73.      * @param data 
  74.      * @param key 
  75.      * @return 
  76.      * @throws Exception 
  77.      */  
  78.     public static byte[] decrypt(byte[] data, String key) throws Exception {  
  79.         Key k = toKey(decryptBASE64(key));  
  80.   
  81.         Cipher cipher = Cipher.getInstance(ALGORITHM);  
  82.         cipher.init(Cipher.DECRYPT_MODE, k);  
  83.   
  84.         return cipher.doFinal(data);  
  85.     }  
  86.   
  87.     /** 
  88.      * 加密 
  89.      *  
  90.      * @param data 
  91.      * @param key 
  92.      * @return 
  93.      * @throws Exception 
  94.      */  
  95.     public static byte[] encrypt(byte[] data, String key) throws Exception {  
  96.         Key k = toKey(decryptBASE64(key));  
  97.         Cipher cipher = Cipher.getInstance(ALGORITHM);  
  98.         cipher.init(Cipher.ENCRYPT_MODE, k);  
  99.   
  100.         return cipher.doFinal(data);  
  101.     }  
  102.   
  103.     /** 
  104.      * 生成密钥 
  105.      *  
  106.      * @return 
  107.      * @throws Exception 
  108.      */  
  109.     public static String initKey() throws Exception {  
  110.         return initKey(null);  
  111.     }  
  112.   
  113.     /** 
  114.      * 生成密钥 
  115.      *  
  116.      * @param seed 
  117.      * @return 
  118.      * @throws Exception 
  119.      */  
  120.     public static String initKey(String seed) throws Exception {  
  121.         SecureRandom secureRandom = null;  
  122.   
  123.         if (seed != null) {  
  124.             secureRandom = new SecureRandom(decryptBASE64(seed));  
  125.         } else {  
  126.             secureRandom = new SecureRandom();  
  127.         }  
  128.   
  129.         KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM);  
  130.         kg.init(secureRandom);  
  131.   
  132.         SecretKey secretKey = kg.generateKey();  
  133.   
  134.         return encryptBASE64(secretKey.getEncoded());  
  135.     }  
  136. }  


延续上一个类的实现，我们通过MD5以及SHA对字符串加密生成密钥，这是比较常见的密钥生成方式。 
再给出一个测试类： 

Java代码   收藏代码
  1. import static org.junit.Assert.*;  
  2.   
  3.   
  4. import org.junit.Test;  
  5.   
  6. /** 
  7.  *   
  8.  * @version 1.0 
  9.  * @since 1.0 
  10.  */  
  11. public class DESCoderTest {  
  12.   
  13.     @Test  
  14.     public void test() throws Exception {  
  15.         String inputStr = "DES";  
  16.         String key = DESCoder.initKey();  
  17.         System.err.println("原文:\t" + inputStr);  
  18.   
  19.         System.err.println("密钥:\t" + key);  
  20.   
  21.         byte[] inputData = inputStr.getBytes();  
  22.         inputData = DESCoder.encrypt(inputData, key);  
  23.   
  24.         System.err.println("加密后:\t" + DESCoder.encryptBASE64(inputData));  
  25.   
  26.         byte[] outputData = DESCoder.decrypt(inputData, key);  
  27.         String outputStr = new String(outputData);  
  28.   
  29.         System.err.println("解密后:\t" + outputStr);  
  30.   
  31.         assertEquals(inputStr, outputStr);  
  32.     }  
  33. }  


得到的输出内容如下： 

Console代码   收藏代码
  1. 原文: DES  
  2. 密钥: f3wEtRrV6q0=  
  3.   
  4. 加密后:    C6qe9oNIzRY=  
  5.   
  6. 解密后:    DES  


    由控制台得到的输出，我们能够比对加密、解密后结果一致。这是一种简单的加密解密方式，只有一个密钥。 
    其实DES有很多同胞兄弟，如DESede(TripleDES)、AES、Blowfish、RC2、RC4(ARCFOUR)。这里就不过多阐述了，大同小异，只要换掉ALGORITHM换成对应的值，同时做一个代码替换SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);就可以了，此外就是密钥长度不同了。 

Java代码   收藏代码
  1. /** 
  2.  * DES          key size must be equal to 56 
  3.  * DESede(TripleDES) key size must be equal to 112 or 168 
  4.  * AES          key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available 
  5.  * Blowfish     key size must be multiple of 8, and can only range from 32 to 448 (inclusive) 
  6.  * RC2          key size must be between 40 and 1024 bits 
  7.  * RC4(ARCFOUR) key size must be between 40 and 1024 bits 
  8.  **/  
Maddisons
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
前后端DES加解密及Wrong key size错误处理
weixin_39876990的博客
04-02 5299
前后端DES加解密及Wrong key size错误处理 前端使用 CryptoJS 进行DES加密，后端Java进行解密。 前端 function encryptByDES(message, key) { var keyHex = CryptoJS.enc.Utf8.parse(key); var encrypted = CryptoJS.DES.encrypt(message, keyHex, { mode: CryptoJS.mode.ECB,
java DES加解密及Wrong key size错误
weixin_30642561的博客
07-11 7139
如下的DES加密方法会报错：Wrong key size public static String encryptDES(String source) throws Exception{ SecretKeySpec skeySpec = new SecretKeySpec(ckplayerkey.getBytes(), "DES"); Cip...
DES加密算法DES加密算法
03-15
// Java crypt example SJ import javax.crypto.*; import javax.crypto.spec.*; import java.io.*; import java.lang.*; import java.util.*; import java.security.*; public class EncryptionExample { protected String calg = "Blowfish"; // AES. DES, Blowfish protected int keyLen = 128; // 128 for AES, Blowfish, 64 for DES public static void main(String[] args) { EncryptionExample s = new EncryptionExample(); // to call nonstatic methods SecretKeySpec key = s.readkey(); String mess = new String("Hello, world!"); byte[] messb = mess.getBytes(); System.out.println("Plain|" + mess +"|=|" + s.bintohex(messb)); byte[] ct = s.encrypt(messb, key); System.out.println("Encry:" + s.bintohex(ct)); byte[] pt = s.decrypt(ct, key); String dmess = new String(pt); System.out.println("Decry|" + dmess +"|=|" + s.bintohex(pt)); } // main() // encrypt message t with key k public byte[] encrypt(byte[] t, SecretKeySpec k) { try { Cipher c = Cipher.getInstance(calg); c.init(Cipher.ENCRYPT_MODE, k); return c.doFinal(t); } catch (Exception e) { System.err.println("Encryption failed: " + e); } return null; } // decrypt message t with key k public byte[] decrypt(byte[] t, SecretKeySpec k) { try { Cipher c = Cipher.getInstance(calg); c.init(Cipher.DECRYPT_MODE, k); return c.doFinal(t); } catch (Exception e) { System.err.println("Decryption failed: " + e); } return null; } // reads key string from user, returns SecretKeySpec public SecretKeySpec readkey() { SecretKeySpec kp = null; String line; byte [] bin = null; try { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); System.out.print("Give the key or passphrase (" + keyLen/4 + " hex digits or long ascii string) \n : "); line = in.readLine(); // check if input is all hex or not boolean ishex = true; for (int i = 0; i < line.length(); i++) if (Character.digit(line.charAt(i), 16) < 0) { ishex = false; break; } // check hex key length if (ishex && line.length() != keyLen/4) System.err.println("Wrong hex ley lenght (" + line.length() + "/" + keyLen/4 + ")"); // make binary key if (ishex) bin = hextobin(line); else bin = asciitobin(line); // make key for crypto algorithm kp = new SecretKeySpec(bin, calg); System.out.println("Key = |" + bintohex(kp.getEncoded()) + "|"); } catch (Exception e) { System.err.println("Key generation failed" + e); } return kp; } // readkey() // make binary out of hex string public byte[] hextobin(String s) { int len = (s.length()+1)/2; byte[] A = new byte[len]; for (int i = 0; i < len; i++) A[i] = Integer.valueOf(s.substring(i*2, i*2+2), 16).byteValue(); return A; } // returns new 128 bit key using MD5 of the string s public byte[] asciitobin(String s) { byte[] A = null; try { MessageDigest md = MessageDigest.getInstance("MD5"); A = md.digest(s.getBytes()); } catch (Exception e) { System.err.println("Digest failed" + e); } return A; } // returns new hex string representation of A public String bintohex(byte[] A) { int len = A.length; StringBuffer sb = new StringBuffer(len*2); for (int i = 0; i < len; i++) { if ((A[i] & 0xFF) < 0x10) sb.append("0"); sb.append(Integer.toHexString(A[i] & 0xFF)); } return sb.toString(); } } // class
Java加密技术（二）
中源
05-08 191
 接下来我们介绍对称加密算法，最常用的莫过于DES数据加密算法。 DES DES-Data Encryption Standard,即数据加密算法。是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或...
AES加、解密算法工具类
iceloop的博客
02-02 298
package com.lcare.buma.util.taikang; import org.apache.commons.codec.binary.Base64; import org.apache.commons.codec.digest.DigestUtils; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; import ja
java加密解密应用——DES算法
JavaMan_chen的专栏
10-12 5809
应用领域：IC卡，POS机，ATM机，加油站，高速公路收费站。应用场景：信用卡持卡人的PIN的加密传输，IC卡与 POS机之间的双向认证。算法入口参数:KEY，Data，Modekey:DES算法的工作密钥Mode:DES算法的工作模式(加密|解密)Data:需要加密或解密的数据工作方式:如果Mode为加密模式，则用key对数据data进行加密处理，生成data的密码模式如果Mode为解密模式，则用key对数据data进行解密处理，还原data的明码模式这样，在通信网络的两端，双方约定好一致的key，源端用
java加密与解密-非对称加密算法RSA（5）
让天空解释着蔚蓝的博客
03-26 237
非对称加密算法 ​ 非对称加密算法的密钥，一把公开，称为公钥，一把保密，称为私钥。非对称加密算法解决了对称加密算法密钥分配的问题，极大的提高了算法的安全性。非堆成加密算法的代表算法：RSA算法，广泛的被使用到各个方面 RSA算法实现 算法 密钥长度 密钥长度默认值 工作模式 填充模式 备注 RSA 512-65536 1024 ECB NoPaddingPKCS1Pdaaing...
常用加密算法的Java实现总结(二)——对称加密算法DES、3DES和AES.pdf
02-10
常用加密算法的java实现总结，常用加密算法的java实现总结，常用加密算法的java实现总结，常用加密算法的java实现总结，常用加密算法的java实现总结
Java实现的对称加密算法AES定义与用法详解
08-27
"Java实现的对称加密算法AES定义与用法详解" 对称加密算法AES是当前使用最多的加密算法之一，其主要特点是高级的、安全的、快速的和灵活的。下面我们将详细介绍Java实现的对称加密算法AES的定义、特点、用法及使用...
Java对称加密算法DES实例详解
08-25
Java对称加密算法DES实例详解 Java对称加密算法是使用对称密钥进行加密和解密的加密算法，其加密和解密使用相同的密钥。Java中对称加密算法有多种，而DES（Data Encryption Standard）是其中一种古老的对称加密...
python实现对称加密中3DES与AES算法工程文件
07-09
python实现对称加密中3DES与AES算法工程文件 详解博客地址：https://blog.csdn.net/m0_52316372/article/details/125691581
php对称加密算法DES和AES类.zip
07-11
分享一个php对称加密算法DES和AES类，支持密钥：64/128/256 bit（字节长度8/16/32），支持算法：DES/AES（根据密钥长度自动匹配使用：DES:64bit AES:128/256bit），支持模式：CBC/ECB/OFB/CFB，密文编码：base64字符...
JAVA—DES的加密解密
TofuCai的博客
02-15 1326
 JAVA采用DES进行的加密和解密操作 简单介绍： DES是一种对称加密算法，所谓对称加密算法即：加密和解密使用相同密钥的算法。DES加密算法出自IBM的研究， 后来被美国政府正式采用，之后开始广泛流传，但是近些年使用越来越少，因为DES使用56位密钥，以现代计算能力， 24小时内即可被破解。 理论： DES是一个分组加密算法，它以64位为分组对数据加密。同时DES也是一个对称算法：加密...
DES Wrong Key Size错误
gbstack08的专栏
12-09 1648
对接方将3DES密钥用文本给出，我将其base64解码后的bytes来创建SecretKeySpec，报错 java.security.InvalidKeyException: Wrong key size debug发现base64解码的bytes只有18个字节。。 后来我想是不是他将每个文本字符作为一个字节？统计了以下字符长度，确实是24。真是个奇葩的对接方 ...
java使用des加密
huangshikai
11-15 529
DES加密算法是jdk自带的一种采用8位密钥字符加密的对称算法，它既可以正向加密也可以反向解密。 DES算法的入口参数有三个：Key、Data、Mode。其中Key为8个字符共56位，每个字符由7个字节外加1字节的奇偶校验组成，是DES算法的工作密钥；Data为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式,有两种:加密（值为1）或解密（值为2）。 注意：加密密钥与解密密...
对称加密
原此航的博客
08-10 105
 本示例包含了DES， DESede和AES算法。 其中AES算法的密钥长度可以为128, 192 或者 256， 但是要想正常使用192和256位的密钥长度， 需要替换JRE默认的两个策略文件local_policy.jar和US_export_policy.jar。该策略文件下载地址： https://cds.sun.com/is-bin/INTERSHOP.enfinity/WFS/CDS...
Java加密技术（十一）——双向认证
热门推荐
匚⒈0 牸潞扣 _ 』銄佐鯐 銄佑鯐『
04-24 1万+
对于双向认证，做一个简单的描述。  服务器端下发证书，客户端接受证书。证书带有公钥信息，用于验证服务器端、对数据加密/解密，起到OSI五类服务的认证（鉴别）服务和保密性服务。  这只是单向认证，为什么？因为客户端可以验证服务器端，但服务器端不能验证客户端！  如果客户端也有这样一个证书，服务器端也就能够验证客户端，这就是双向认证了！  换言之，当你用银行的“U盾”之类的U盘与银行账
Java实现DES加密解密算法完整示例
Des（Data Encryption Standard）是对称加密算法，使用相同的密钥进行加密和解密。Des加密算法是一种块加密算法，每个块的长度为64位，密钥的长度也为64位。Des加密算法的安全性取决于密钥的安全性，因此，密钥的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值