DES 加密算法

àì夳堔傛蜴生んèń 2022-07-28 04:15 254阅读 0赞

在项目中，会经常用到数据的加密处理，对敏感的数据处理。我在项目中用到了记录用户名和密码的功能。在做远程登陆时使用。

DES 加密，现在还没有使用加密机。 直接上代码了。

DES 加密接口

**\[java\]**  [view plain][]  [copy][view plain]

1.  **package** com.hkrt.des;  
2.    
3.  **public** **interface** Encrypt \{  
4.      /\*\* 
5.       \* DES加密 
6.       \* @param key 是十六进制 
7.       \* @param src ASCII值 
8.       \* @return ASCII 值 会有不可见字符 通常把加密后的数据转成十六进制 
9.       \* @throws Exception 
10.      \*/  
11.     **public** **byte**\[\] DesEncryptByte2(String key, **byte** \[\] src)**throws** Exception;//  
12.     /\*\* 
13.      \* DES解密 
14.      \* @param key 是十六进制 
15.      \* @param src 是十六进制 
16.      \* @return  
17.      \* @throws Exception 
18.      \*/  
19.     **public** String DesDecrypt(String key, String src)**throws** Exception;//  
20. \}

DES 加密接口实现

**\[java\]**  [view plain][]  [copy][view plain]

1.  **package** com.hkrt.des;  
2.    
3.  **import** javax.crypto.Cipher;  
4.  **import** javax.crypto.SecretKey;  
5.  **import** javax.crypto.spec.SecretKeySpec;  
6.    
7.    
8.  **public** **class** Des **implements** Encrypt \{  
9.      **private** **static** **final** String DES = "DES"; // 定义 加密算法  
10.     **private** **static** **final** String CFB = "DES/ECB/NoPadding"; //   
11.   
12.     // DES解密  
13.     **public** String DesDecrypt(String key, String szSrc) **throws** Exception \{  
14.         String str = "";  
15.   
16.         **if** (key.length() != 16) \{  
17.             **throw** **new** Exception("DES密钥长度必须为十六进制的16字节");  
18.         \}  
19.         **byte**\[\] srcBytes = DESdecryptMode(hexStr2ByteArr(key), hexStr2ByteArr(szSrc));  
20.           
21.         **byte**\[\] srcBytesEnd = srcBytes;  
22.         str = **new** String(srcBytesEnd);  
23.         **return** str;  
24.     \}  
25.   
26.       
27.     // DES解密方法  
28.     **public** **static** **byte**\[\] DESdecryptMode(**byte**\[\] keybyte, **byte**\[\] src) \{  
29.         **try** \{  
30.             // 生成密钥  
31.             SecretKey deskey = **new** SecretKeySpec(keybyte, DES);  
32.   
33.             // 解密  
34.             Cipher c1 = Cipher.getInstance(CFB);  
35.             c1.init(Cipher.DECRYPT\_MODE, deskey);  
36.             **return** c1.doFinal(src);  
37.         \} **catch** (java.security.NoSuchAlgorithmException e1) \{  
38.             e1.printStackTrace();  
39.         \} **catch** (javax.crypto.NoSuchPaddingException e2) \{  
40.             e2.printStackTrace();  
41.         \} **catch** (java.lang.Exception e3) \{  
42.             e3.printStackTrace();  
43.         \}  
44.         **return** **null**;  
45.     \}  
46.       
47.     //将十六进制字符串转换成原始字节数组  
48.     **public** **static** **byte**\[\] hexStr2ByteArr(String strIn) **throws** Exception \{  
49.         System.out.println("---"\+strIn);  
50.            **byte**\[\] arrB = strIn.getBytes();  
51.            **int** iLen = arrB.length;  
52.   
53.            **byte**\[\] arrOut = **new** **byte**\[iLen / 2\];  
54.            **for** (**int** i = 0; i < iLen; i = i + 2) \{  
55.             String strTmp = **new** String(arrB, i, 2);  
56.             arrOut\[i / 2\] = (**byte**) Integer.parseInt(strTmp, 16);  
57.            // System.out.println(arrOut\[i/2\]);  
58.            \}  
59.            **return** arrOut;  
60.              
61.     \}  
62.       
63.     // DES加密 返回byte\[\]  
64.     **public** **byte**\[\] DesEncryptByte2(String key, **byte** \[\] szSrc) **throws** Exception \{  
65.         **if**(szSrc.length %8 != 0)\{  
66.             **throw** **new** Exception("数据体的长度必须为8的倍数");  
67.         \}  
68.         **if** (key.length() != 16) \{  
69.             **throw** **new** Exception("DES密钥长度必须为十六进制的16字节");  
70.         \}  
71.         **byte**\[\] encoded = DESencryptMode(hexStr2ByteArr(key), szSrc);  
72.           
73.         **return** encoded;  
74.   
75.     \}  
76.     // DES加密方法  
77.     **public** **byte**\[\] DESencryptMode(**byte**\[\] keybyte, **byte**\[\] src) \{  
78.         **try** \{  
79.   
80.             // 生成密钥  
81.             SecretKey deskey = **new** SecretKeySpec(keybyte, DES);  
82.               
83.   
84.             // 加密  
85.             Cipher c1 = Cipher.getInstance(CFB);  
86.             c1.init(Cipher.ENCRYPT\_MODE, deskey);  
87.             **return** c1.doFinal(src);  
88.         \} **catch** (java.security.NoSuchAlgorithmException e1) \{  
89.             e1.printStackTrace();  
90.         \} **catch** (javax.crypto.NoSuchPaddingException e2) \{  
91.             e2.printStackTrace();  
92.         \} **catch** (java.lang.Exception e3) \{  
93.             e3.printStackTrace();  
94.         \}  
95.         **return** **null**;  
96.     \}  
97.       
98.   
99.       
100.       
101. \}

DesUtil 工具类

**\[java\]**  [view plain][]  [copy][view plain]

1.  **package** com.hkrt.des;  
2.    
3.  **import** java.util.ArrayList;  
4.    
5.  **public** **class** DesUtil \{  
6.      /\*\* 右补null \*/  
7.      **public** **static** **byte**\[\] fillByte(**byte**\[\] bRecv) \{  
8.          **int** iLen;  
9.          iLen = (bRecv.length) % 8;  
10.         **byte**\[\] bSend;  
11.         **if** (iLen != 0) \{  
12.             iLen = 8 - iLen;  
13.             **byte**\[\] bSpace = **new** **byte**\[iLen\];  
14.             bSend = **new** **byte**\[bRecv.length + iLen\];  
15.             System.arraycopy(bRecv, 0, bSend, 0, bRecv.length);  
16.             **for** (**int** i = 0; i < iLen; i++) \{  
17.                 // 不足位数补空格  
18.                 bSpace\[i\] = (**byte**) 0;  
19.             \}  
20.             System.arraycopy(bSpace, 0, bSend, bRecv.length, bSpace.length);  
21.         \} **else** \{  
22.             bSend = **new** **byte**\[bRecv.length\];  
23.             System.arraycopy(bRecv, 0, bSend, 0, bRecv.length);  
24.         \}  
25.   
26.         **return** bSend;  
27.     \}  
28.   
29.     /\*\* 把ASCII 转成十六进制 \*/  
30.     **public** **static** String printHexString(**byte**\[\] b) \{  
31.         String result = "";  
32.         **for** (**int** i = 0; i < b.length; i++) \{  
33.             String hex = Integer.toHexString(b\[i\] & 0xFF);  
34.             **if** (hex.length() == 1) \{  
35.                 hex = '0' + hex;  
36.             \}  
37.             result = result + hex.toUpperCase();  
38.         \}  
39.         **return** result;  
40.     \}  
41.   
42.     /\*\* 将十六进制字符串转换成原始字节数组 \*/  
43.     **public** **static** **byte**\[\] hexStr2ByteArr(String strIn) **throws** Exception \{  
44.         **byte**\[\] arrB = strIn.getBytes();  
45.         **int** iLen = arrB.length;  
46.   
47.         **byte**\[\] arrOut = **new** **byte**\[iLen / 2\];  
48.         **for** (**int** i = 0; i < iLen; i = i + 2) \{  
49.             String strTmp = **new** String(arrB, i, 2);  
50.             arrOut\[i / 2\] = (**byte**) Integer.parseInt(strTmp, 16);  
51.         \}  
52.         **return** arrOut;  
53.   
54.     \}  
55.   
56.     /\*\*\* 去除不可见字符( byte 是0的不可见字符) \*/  
57.     **public** **static** **byte**\[\] removeNoSeeChar(**byte**\[\] srcBytes) \{  
58.         ArrayList<Byte> listArr = **new** ArrayList<Byte>();  
59.         **for** (**int** i = 0; i < srcBytes.length; i++) \{  
60.             listArr.add(srcBytes\[i\]);  
61.         \}  
62.         lableB: **for** (**int** j = listArr.size() - 1; j >= 0; j--) \{  
63.             **if** (listArr.get(j) == 0) \{  
64.                 listArr.remove(listArr.get(j));  
65.             \} **else** \{  
66.                 // break;  
67.                 **break** lableB;  
68.             \}  
69.         \}  
70.         **byte**\[\] bs = **new** **byte**\[listArr.size()\];  
71.         **for** (**int** k = 0; k < listArr.size(); k++) \{  
72.             bs\[k\] = listArr.get(k).byteValue();  
73.         \}  
74.         **return** bs;  
75.     \}  
76.   
77. \}

工厂类：

**\[java\]**  [view plain][]  [copy][view plain]

1.  **package** com.hkrt.des;  
2.    
3.  **public** **class** DesFactory \{  
4.      **public** **static** Encrypt getInstance()\{  
5.          **return** **new** Des();  
6.      \}  
7.    
8.  \}

测试结果：

**\[java\]**  [view plain][]  [copy][view plain]

1.  **package** com.hkrt.des;  
2.    
3.    
4.  **public** **class** DesTest \{  
5.      **public** **static** **void** main(String\[\] args) \{  
6.          String srcStr="456789你";  
7.          System.out.println("加密结果"\+jiaMi(srcStr));  
8.          System.out.println("解密结果"\+jieMi("DD543BEBCB344F9B"));  
9.      \}  
10.     /\*\* 
11.      \* @param srcStr 原始数据 
12.      \* @return 十六进制数据 
13.      \*/  
14.     **private** **static** String jiaMi(String srcStr)\{  
15.         String keyStr="123456";  
16.         String key = DesUtil.printHexString(DesUtil.fillByte(keyStr.getBytes()));//给key 补位 并转成十六进制  
17.         **byte**\[\] src = DesUtil.fillByte(srcStr.getBytes());//给src 补位  
18.         **byte**\[\]  result=**null**;  
19.         **try** \{  
20.             result = DesFactory.getInstance().DesEncryptByte2(key, src);  
21.         \} **catch** (Exception e) \{  
22.             e.printStackTrace();  
23.         \}  
24.         **return** DesUtil.printHexString(result);  
25.     \}  
26.     /\*\* 
27.      \* @param srcStr 十六进制 
28.      \* @return 真实数据 
29.      \*/  
30.     **private** **static** String jieMi(String srcStr)\{  
31.         String keyStr="123456";  
32.         String key = DesUtil.printHexString(DesUtil.fillByte(keyStr.getBytes()));//给key 补位 并转成十六进制  
33.         String result =**null**;  
34.         **try** \{  
35.             result = DesFactory.getInstance().DesDecrypt(key, srcStr);  
36.         \} **catch** (Exception e) \{  
37.             e.printStackTrace();  
38.         \}  
39.         **return** result;  
40.     \}  
41.   
42. \}

转载地址：[http://blog.csdn.net/liuc0317/article/details/7056636][http_blog.csdn.net_liuc0317_article_details_7056636]

[view plain]: http://blog.csdn.net/liuc0317/article/details/7056636#
[http_blog.csdn.net_liuc0317_article_details_7056636]: http://blog.csdn.net/liuc0317/article/details/7056636