android加密DESede/CBC/PKCS5Padding

工作中需要和ＨＰＨ对接，接口一些敏感信息，讨论后用３ＤＥＳ加密，由于我做的android邮件客户端是依附于php系统，所以我写加密算法对接HPH的加密，然后遇到一个棘手的问题，我的加密解密过程顺利，但是同样的密钥，同样的明文，java和php加密不一样，后来发现双方理解有误我理解的密钥是byte[]类型的，对方的密钥是通过类似String.getBytes()的方法出来的

9.jpg (3.22 KB, 下载次数: 0)

下载附件  保存到相册

5 小时前 上传

引此为戒

1. import java.security.SecureRandom;
   
2. import java.security.Security;
   
3. import java.util.Random;
   
4. 
   
5. import javax.crypto.Cipher;
   
6. import javax.crypto.KeyGenerator;
   
7. import javax.crypto.SecretKey;
   
8. import javax.crypto.SecretKeyFactory;
   
9. import javax.crypto.spec.DESedeKeySpec;
   
10. import javax.crypto.spec.IvParameterSpec;
    
11. import javax.crypto.spec.SecretKeySpec;
    
12. 
    
13. /*字符串 DESede(3DES) 加密*/
    
14. 
    
15. public class ThreeDes {
    
16. 
    
17.     /**
    
18.      * 3DS加密
    
19.      *
    
20.      * @author [e-mail]
    
21.      */
    
22. 
    
23.     private static final String Algorithm = "DESede/CBC/PKCS5Padding"; // 定义加密算法,可用
    
24.                                                                         // DES,DESede,Blowfish，DESede/CBC/PKCS5Padding
    
25. 
    
26.     // keybyte为加密密钥，长度为24字节
    
27. 
    
28.     // src为被加密的数据缓冲区（源）
    
29.     /*
    
30.      * private static SecretKey deskey = null;
    
31.      *
    
32.      * public static void getKey(byte[] strKey) { try { KeyGenerator _generator
    
33.      * = KeyGenerator.getInstance("DES"); _generator.init(new
    
34.      * SecureRandom(strKey)); deskey = _generator.generateKey(); _generator =
    
35.      * null; } catch (Exception e) { e.printStackTrace(); } }
    
36.      */
    
37.     public static byte[] encryptMode(String iv, String key, String src) {
    
38. 
    
39.         try {
    
40.             byte[] keybyte = key.getBytes();
    
41.             byte[] rand = new byte[8];
    
42.             rand = iv.getBytes();
    
43.             // 用随即数生成初始向量
    
44. 
    
45.             /*
    
46.              * Random r=new Random(); r.nextBytes(rand);
    
47.              */
    
48.             IvParameterSpec ivp = new IvParameterSpec(rand);
    
49. 
    
50.             // 生成密钥
    
51. 
    
52.            // SecureRandom sr = new SecureRandom();
    
53.             DESedeKeySpec dks = new DESedeKeySpec(keybyte);
    
54.             SecretKeyFactory keyFactory = SecretKeyFactory
    
55.                     .getInstance("DESede");
    
56.             SecretKey securekey = keyFactory.generateSecret(dks);
    
57.             // IvParameterSpec iv = new IvParameterSpec(PASSWORD_IV.getBytes());
    
58.             /*
    
59.              * Cipher cipher = Cipher.getInstance("DESede");
    
60.              * cipher.init(Cipher.ENCRYPT_MODE, securekey, ivp, sr); return new
    
61.              * String(Hex.encodeHex(cipher.doFinal(str.getBytes())));
    
62.              */
    
63. 
    
64.             // 加密
    
65. 
    
66.             Cipher c1 = Cipher.getInstance(Algorithm);
    
67. 
    
68.             c1.init(Cipher.ENCRYPT_MODE, securekey, ivp);
    
69. 
    
70.             return c1.doFinal(src.getBytes());// 在单一方面的加密或解密
    
71. 
    
72.         } catch (java.security.NoSuchAlgorithmException e1) {
    
73. 
    
74.             // TODO: handle exception
    
75. 
    
76.             e1.printStackTrace();
    
77. 
    
78.         } catch (javax.crypto.NoSuchPaddingException e2) {
    
79. 
    
80.             e2.printStackTrace();
    
81. 
    
82.         } catch (java.lang.Exception e3) {
    
83. 
    
84.             e3.printStackTrace();
    
85. 
    
86.         }
    
87. 
    
88.         return null;
    
89. 
    
90.     }
    
91. 
    
92.     // keybyte为加密密钥，长度为24字节
    
93. 
    
94.     // src为加密后的缓冲区
    
95. 
    
96.     public static byte[] decryptMode(String iv, String key, byte[] src) {
    
97. 
    
98.         try {
    
99.             byte[] srcbytes = src;
    
100.             byte[] keybyte = key.getBytes();
     
101.             byte[] rand = new byte[8];
     
102.             rand = iv.getBytes();
     
103.             // 用随即数生成初始向量
     
104. 
     
105.             /*
     
106.              * Random r=new Random(); r.nextBytes(rand);
     
107.              */
     
108.             IvParameterSpec ivp = new IvParameterSpec(rand);
     
109. 
     
110.             // 生成密钥
     
111. 
     
112.             SecureRandom sr = new SecureRandom();
     
113.             DESedeKeySpec dks = new DESedeKeySpec(keybyte);
     
114.             SecretKeyFactory keyFactory = SecretKeyFactory
     
115.                     .getInstance("DESede");
     
116.             SecretKey securekey = keyFactory.generateSecret(dks);
     
117. 
     
118.             // 解密
     
119. 
     
120.             Cipher c1 = Cipher.getInstance(Algorithm);
     
121. 
     
122.             c1.init(Cipher.DECRYPT_MODE, securekey, ivp);
     
123. 
     
124.             /*
     
125.              * int len = src.getBytes().length; byte[] zero = { 0x00, 0x00,
     
126.              * 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; if (len < 8) { srcbytes =
     
127.              * new byte[8]; System.arraycopy(src.getBytes(), 0, srcbytes, 0,
     
128.              * len); System.arraycopy(zero, len, srcbytes, len, 8 - len); } else
     
129.              * { srcbytes = src.getBytes(); }
     
130.              */
     
131. 
     
132.             return c1.doFinal(srcbytes);
     
133. 
     
134.         } catch (java.security.NoSuchAlgorithmException e1) {
     
135. 
     
136.             // TODO: handle exception
     
137. 
     
138.             e1.printStackTrace();
     
139. 
     
140.         } catch (javax.crypto.NoSuchPaddingException e2) {
     
141. 
     
142.             e2.printStackTrace();
     
143. 
     
144.         } catch (java.lang.Exception e3) {
     
145. 
     
146.             e3.printStackTrace();
     
147. 
     
148.         }
     
149. 
     
150.         return null;
     
151. 
     
152.     }
     
153. 
     
154.     // 转换成十六进制字符串
     
155. 
     
156.     public static String byte2Hex(byte[] b) {
     
157. 
     
158.         String hs = "";
     
159. 
     
160.         String stmp = "";
     
161. 
     
162.         for (int n = 0; n < b.length; n++) {
     
163. 
     
164.             stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
     
165. 
     
166.             if (stmp.length() == 1) {
     
167. 
     
168.                 hs = hs + "0" + stmp;
     
169. 
     
170.             } else {
     
171. 
     
172.                 hs = hs + stmp;
     
173. 
     
174.             }
     
175. 
     
176.             if (n < b.length - 1)
     
177.                 hs = hs + ":";
     
178. 
     
179.         }
     
180. 
     
181.         return hs.toUpperCase();
     
182. 
     
183.     }
     
184. 
     
185.     public static final String encodeHex(byte bytes[]) {
     
186.         StringBuffer buf = new StringBuffer(bytes.length * 2);
     
187.         for (int i = 0; i < bytes.length; i++) {
     
188.             if ((bytes[i] & 0xff) < 16)
     
189.                 buf.append("0");
     
190.             buf.append(Long.toString(bytes[i] & 0xff, 16));
     
191.         }
     
192.         return buf.toString();
     
193.     }
     
194. 
     
195.     public static final byte[] decodeHex(String hex) {
     
196.         char chars[] = hex.toCharArray();
     
197.         byte bytes[] = new byte[chars.length / 2];
     
198.         int byteCount = 0;
     
199.         for (int i = 0; i < chars.length; i += 2) {
     
200.             int newByte = 0;
     
201.             newByte |= hexCharToByte(chars[i]);
     
202.             newByte <<= 4;
     
203.             newByte |= hexCharToByte(chars[i + 1]);
     
204.             bytes[byteCount] = (byte) newByte;
     
205.             byteCount++;
     
206.         }
     
207.         return bytes;
     
208.     }
     
209. 
     
210.     private static final byte hexCharToByte(char ch) {
     
211.         switch (ch) {
     
212.         case 48: // '0'
     
213.             return 0;
     
214. 
     
215.         case 49: // '1'
     
216.             return 1;
     
217. 
     
218.         case 50: // '2'
     
219.             return 2;
     
220. 
     
221.         case 51: // '3'
     
222.             return 3;
     
223. 
     
224.         case 52: // '4'
     
225.             return 4;
     
226. 
     
227.         case 53: // '5'
     
228.             return 5;
     
229. 
     
230.         case 54: // '6'
     
231.             return 6;
     
232. 
     
233.         case 55: // '7'
     
234.             return 7;
     
235. 
     
236.         case 56: // '8'
     
237.             return 8;
     
238. 
     
239.         case 57: // '9'
     
240.             return 9;
     
241. 
     
242.         case 97: // 'a'
     
243.             return 10;
     
244. 
     
245.         case 98: // 'b'
     
246.             return 11;
     
247. 
     
248.         case 99: // 'c'
     
249.             return 12;
     
250. 
     
251.         case 100: // 'd'
     
252.             return 13;
     
253. 
     
254.         case 101: // 'e'
     
255.             return 14;
     
256. 
     
257.         case 102: // 'f'
     
258.             return 15;
     
259. 
     
260.         case 58: // ':'
     
261.         case 59: // ';'
     
262.         case 60: // '<'
     
263.         case 61: // '='
     
264.         case 62: // '>'
     
265.         case 63: // '?'
     
266.         case 64: // '@'
     
267.         case 65: // 'A'
     
268.         case 66: // 'B'
     
269.         case 67: // 'C'
     
270.         case 68: // 'D'
     
271.         case 69: // 'E'
     
272.         case 70: // 'F'
     
273.         case 71: // 'G'
     
274.         case 72: // 'H'
     
275.         case 73: // 'I'
     
276.         case 74: // 'J'
     
277.         case 75: // 'K'
     
278.         case 76: // 'L'
     
279.         case 77: // 'M'
     
280.         case 78: // 'N'
     
281.         case 79: // 'O'
     
282.         case 80: // 'P'
     
283.         case 81: // 'Q'
     
284.         case 82: // 'R'
     
285.         case 83: // 'S'
     
286.         case 84: // 'T'
     
287.         case 85: // 'U'
     
288.         case 86: // 'V'
     
289.         case 87: // 'W'
     
290.         case 88: // 'X'
     
291.         case 89: // 'Y'
     
292.         case 90: // 'Z'
     
293.         case 91: // '['
     
294.         case 92: // '\\'
     
295.         case 93: // ']'
     
296.         case 94: // '^'
     
297.         case 95: // '_'
     
298.         case 96: // '`'
     
299.         default:
     
300.             return 0;
     
301.         }
     
302.     }
     
303. 
     
304.     public static void main(String[] args) {
     
305. 
     
306.         // TODO Auto-generated method stub
     
307. 
     
308.         // 添加新安全算法,如果用JCE就要把它添加进去
     
309. 
     
310.         // Security.addProvider(new com.sun.crypto.provider.SunJCE());
     
311. 
     
312.         /*
     
313.          * final byte[] keyBytes = { 0x01, 0x02, 0x03, 0x04,
     
314.          *
     
315.          * (byte) 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x01, 0x02,
     
316.          *
     
317.          * (byte) 0x03,
     
318.          *
     
319.          * (byte) 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
     
320.          *
     
321.          * (byte) 0x00, 0x01, 0x02, 0x03,
     
322.          *
     
323.          * (byte) 0x04
     
324.          *
     
325.          * }; // 24字节的密钥
     
326.          */
     
327.         String szSrc = "1";
     
328. 
     
329.         System.out.println("加密前的字符串:" + szSrc);
     
330. 
     
331.         byte[] encoded = encryptMode("12345678", "123456789012345678943210",
     
332.                 szSrc);
     
333. 
     
334.         System.out.println("加密后的字符串:" + encodeHex(encoded));
     
335. 
     
336.         byte[] srcBytes = decryptMode("12345678", "123456789012345678943210",
     
337.                 "c5e8faaf1a0e52ae".getBytes());
     
338. 
     
339.         System.out.println("解密后的字符串:" + (new String(srcBytes)));
     
340. 
     
341.     }
     
342. 
     
343. }