释放双眼，带上耳机，听听看~！
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
2import java.security.SecureRandom;
3import javax.crypto.Cipher;
4import javax.crypto.KeyGenerator;
5import javax.crypto.SecretKey;
6import javax.crypto.SecretKeyFactory;
7import javax.crypto.spec.DESKeySpec;
8import javax.crypto.spec.IvParameterSpec;
9
10
11public class DESUtil
12{
13 private final static String algorithm = "DES";
14
15 /**
16 * @return DES算法密钥
17 */
18 public static byte[] generateKey()
19 {
20 try
21 {
22 // DES算法要求有一个可信任的随机数源
23 SecureRandom sr = new SecureRandom();
24 // 生成一个DES算法的KeyGenerator对象
25 KeyGenerator kg = KeyGenerator.getInstance(algorithm);
26 kg.init(sr);
27 // 生成密钥
28 SecretKey secretKey = kg.generateKey();
29 // 获取密钥数据
30 byte[] key = secretKey.getEncoded();
31 return key;
32 }
33 catch (NoSuchAlgorithmException e)
34 {
35 System.err.println("DESAlgorithmGenerateKeyError");
36 e.printStackTrace();
37 }
38 return null;
39 }
40
41 /**
42 * 加密函数
43 *
44 * @param data
45 * 加密数据
46 * @param key
47 * 密钥
48 * @return 返回加密后的数据
49 */
50 public static byte[] encrypt(byte[] data, byte[] key)
51 {
52 try
53 {
54 // DES算法要求有一个可信任的随机数源
55 SecureRandom sr = new SecureRandom();
56 // 从原始密钥数据创建DESKeySpec对象
57 DESKeySpec dks = new DESKeySpec(key);
58 // 创建一个密匙工厂，然后用它把DESKeySpec转换成
59 // 一个SecretKey对象
60 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(algorithm);
61 SecretKey secretKey = keyFactory.generateSecret(dks);
62 // using DES in ECB mode
63 Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
64 // 用密匙初始化Cipher对象
65 cipher.init(Cipher.ENCRYPT_MODE, secretKey, sr);
66 // 执行加密操作
67 byte encryptedData[] = cipher.doFinal(data);
68 return encryptedData;
69 }
70 catch (Exception e)
71 {
72 System.err.println("DESAlgorithmEncryptError");
73 e.printStackTrace();
74 }
75 return null;
76 }
77
78 /**
79 * 解密函数
80 *
81 * @param data
82 * 解密数据
83 * @param key
84 * 密钥
85 * @return 返回解密后的数据
86 */
87 public static byte[] decrypt(byte[] data, byte[] key) throws Exception
88 {
89 try
90 {
91 // DES算法要求有一个可信任的随机数源
92 SecureRandom sr = new SecureRandom();
93 // byte rawKeyData[] = /* 用某种方法获取原始密匙数据 */;
94 // 从原始密匙数据创建一个DESKeySpec对象
95 DESKeySpec dks = new DESKeySpec(key);
96 // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成
97 // 一个SecretKey对象
98 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(algorithm);
99 SecretKey secretKey = keyFactory.generateSecret(dks);
100 // using DES in ECB mode
101 Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
102 // 用密匙初始化Cipher对象
103 cipher.init(Cipher.DECRYPT_MODE, secretKey, sr);
104 // 正式执行解密操作
105 byte decryptedData[] = cipher.doFinal(data);
106 return decryptedData;
107 }
108 catch (Exception e)
109 {
110 // System.err.println("DESAlgorithmDecryptError");
111 // e.printStackTrace();
112 throw e;
113 }
114 }
115
116 /**
117 * 加密函数--CBC模式
118 *
119 * @param data
120 * 加密数据
121 * @param key
122 * 密钥
123 * @return 返回加密后的数据
124 */
125 public static byte[] CBCEncrypt(byte[] data, byte[] key, byte[] iv)
126 {
127 try
128 {
129 // 从原始密钥数据创建DESKeySpec对象
130 DESKeySpec dks = new DESKeySpec(key);
131 // 创建一个密匙工厂，然后用它把DESKeySpec转换成
132 // 一个SecretKey对象
133 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(algorithm);
134 SecretKey secretKey = keyFactory.generateSecret(dks);
135 // Cipher对象实际完成加密操作
136 Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
137 // 若采用NoPadding模式，data长度必须是8的倍数
138 // Cipher cipher = Cipher.getInstance("DES/CBC/NoPadding");
139 // 用密匙初始化Cipher对象
140 // IvParameterSpec param = new IvParameterSpec(iv);
141 cipher.init(Cipher.ENCRYPT_MODE, secretKey);
142 // 执行加密操作
143 byte encryptedData[] = cipher.doFinal(data);
144 return encryptedData;
145 }
146 catch (Exception e)
147 {
148 System.err.println("DESCBCAlgorithmEncryptError");
149 e.printStackTrace();
150 }
151 return null;
152 }
153
154 /**
155 * 解密函数--CBC模式
156 *
157 * @param data
158 * 解密数据
159 * @param key
160 * 密钥
161 * @return 返回解密后的数据
162 */
163 public static byte[] CBCDecrypt(byte[] data, byte[] key, byte[] iv)
164 {
165 try
166 {
167 // 从原始密匙数据创建一个DESKeySpec对象
168 DESKeySpec dks = new DESKeySpec(key);
169 // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成
170 // 一个SecretKey对象
171 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(algorithm);
172 SecretKey secretKey = keyFactory.generateSecret(dks);
173 // using DES in CBC mode
174 Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
175 // 若采用NoPadding模式，data长度必须是8的倍数
176 // Cipher cipher = Cipher.getInstance("DES/CBC/NoPadding");
177
178 // 用密匙初始化Cipher对象
179 IvParameterSpec param = new IvParameterSpec(iv);
180 cipher.init(Cipher.DECRYPT_MODE, secretKey, param);
181 // cipher.init(Cipher.DECRYPT_MODE, secretKey);
182 // 正式执行解密操作
183 byte decryptedData[] = cipher.doFinal(data);
184 return decryptedData;
185 }
186 catch (Exception e)
187 {
188 System.err.println("DESCBCAlgorithmDecryptError");
189 e.printStackTrace();
190 }
191 return null;
192 }
193
194 public static void main(String[] args) throws Exception
195 {
196 // try {
197 // byte[] key = "11111111".getBytes();
198 // byte[] iv = "22222222".getBytes();
199 // byte[] data = DESUtil.encrypt("ebc mode test 中文".getBytes(), key);
200 // System.out.print("EBC mode:");
201 // System.out.println(new String(DESUtil.decrypt(data, key)));
202 //
203 // System.out.print("CBC mode:");
204 // data = DESUtil.CBCEncrypt("cbc mode test".getBytes(), key, iv);
205 // System.out.println(new String(DESUtil.CBCDecrypt(data, key, iv)));
206 //
207 // } catch (Exception e) {
208 // e.printStackTrace();
209 // }
210 // for(int i=0;i<100;i++){
211 // System.out.println(ByteUtil.bytesToHexstr(DESUtil.generateKey()));
212 // }
213 String s = "";
214 String encryptString = "68d2455f8cf9d10055a532642b2650bfb1204e0e9a6dff146855a95256a8ce63e44380c06288413aa62e43089b1c94db257ea4125cafa9486038df9fbe2e2e02820f15bc155aab97357583a11003ec02b39f39c40c2bc6d04fc23def85e0ae3ea0efb2511add385d2b21aa52795fed816c6a420d4f560d0c";
215 encryptString = "68d2455f8cf9d10055a532642b2650bfb1204e0e9a6dff146855a95256a8ce63e44380c06288413aa62e43089b1c94db257ea4125cafa9486038df9fbe2e2e02820f15bc155aab97357583a11003ec02b39f39c40c2bc6d04fc23def85e0ae3ea0efb2511add385d2b21aa52795fed816c6a420d4f560d0c";
216 String key = "ac1e7a28";
217 byte[] encryptByte = ByteUtil.hexstrTobytes(encryptString);
218 System.out.println();
219 System.out.println(new String(encryptByte));
220 byte[] res = null;
221 long start = System.currentTimeMillis();
222
223 res = DESUtil.decrypt(encryptByte, key.getBytes());
224 long end = System.currentTimeMillis();
225 System.out.println(end - start);
226 System.out.println(new String(res));
227 }
228}
229
