python实现的DES加密算法和3DES加密算法实例

这篇文章主要介绍了python实现的DES加密算法和3DES加密算法,以实例形式较为详细的分析了DES加密算法和3DES加密算法的原理与实现技巧,需要的朋友可以参考下

本文实例讲述了python实现的DES加密算法和3DES加密算法。分享给大家供大家参考。具体实现方法如下：

1. ############################################################################# 
2. # Documentation # 
3. ############################################################################# 
4. # Author: Todd Whiteman 
5. # Date: 16th March, 2009 
6. # Verion: 2.0.0 
7. # License: Public Domain - free to do as you wish 
8. # Homepage: http://twhiteman.netfirms.com/des.html 
9. # 
10. # This is a pure python implementation of the DES encryption algorithm. 
11. # It's pure python to avoid portability issues, since most DES  
12. # implementations are programmed in C (for performance reasons). 
13. # 
14. # Triple DES class is also implemented, utilising the DES base. Triple DES 
15. # is either DES-EDE3 with a 24 byte key, or DES-EDE2 with a 16 byte key. 
16. # 
17. # See the README.txt that should come with this python module for the 
18. # implementation methods used. 
19. # 
20. # Thanks to: 
21. # * David Broadwell for ideas, comments and suggestions. 
22. # * Mario Wolff for pointing out and debugging some triple des CBC errors. 
23. # * Santiago Palladino for providing the PKCS5 padding technique. 
24. # * Shaya for correcting the PAD_PKCS5 triple des CBC errors. 
25. # 
26. """A pure python implementation of the DES and TRIPLE DES encryption algorithms. 
27. Class initialization 
28. -------------------- 
29. pyDes.des(key, [mode], [IV], [pad], [padmode]) 
30. pyDes.triple_des(key, [mode], [IV], [pad], [padmode]) 
31. key -> Bytes containing the encryption key. 8 bytes for DES, 16 or 24 bytes 
32. for Triple DES 
33. mode -> Optional argument for encryption type, can be either 
34. pyDes.ECB (Electronic Code Book) or pyDes.CBC (Cypher Block Chaining) 
35. IV -> Optional Initial Value bytes, must be supplied if using CBC mode. 
36. Length must be 8 bytes. 
37. pad -> Optional argument, set the pad character (PAD_NORMAL) to use during 
38. all encrypt/decrpt operations done with this instance. 
39. padmode -> Optional argument, set the padding mode (PAD_NORMAL or PAD_PKCS5) 
40. to use during all encrypt/decrpt operations done with this instance. 
41. I recommend to use PAD_PKCS5 padding, as then you never need to worry about any 
42. padding issues, as the padding can be removed unambiguously upon decrypting 
43. data that was encrypted using PAD_PKCS5 padmode. 
44. Common methods 
45. -------------- 
46. encrypt(data, [pad], [padmode]) 
47. decrypt(data, [pad], [padmode]) 
48. data -> Bytes to be encrypted/decrypted 
49. pad -> Optional argument. Only when using padmode of PAD_NORMAL. For 
50. encryption, adds this characters to the end of the data block when 
51. data is not a multiple of 8 bytes. For decryption, will remove the 
52. trailing characters that match this pad character from the last 8 
53. bytes of the unencrypted data block. 
54. padmode -> Optional argument, set the padding mode, must be one of PAD_NORMAL 
55. or PAD_PKCS5). Defaults to PAD_NORMAL. 
56.  
57. Example 
58. ------- 
59. from pyDes import * 
60. data = "Please encrypt my data" 
61. k = des("DESCRYPT", CBC, "/0/0/0/0/0/0/0/0", pad=None, padmode=PAD_PKCS5) 
62. # For Python3, you'll need to use bytes, i.e.: 
63. # data = b"Please encrypt my data" 
64. # k = des(b"DESCRYPT", CBC, b"/0/0/0/0/0/0/0/0", pad=None, padmode=PAD_PKCS5) 
65. d = k.encrypt(data) 
66. print "Encrypted: %r" % d 
67. print "Decrypted: %r" % k.decrypt(d) 
68. assert k.decrypt(d, padmode=PAD_PKCS5) == data 
69.  
70. See the module source (pyDes.py) for more examples of use. 
71. You can also run the pyDes.py file without and arguments to see a simple test. 
72. Note: This code was not written for high-end systems needing a fast 
73. implementation, but rather a handy portable solution with small usage. 
74. """ 
75. import sys 
76. # _pythonMajorVersion is used to handle Python2 and Python3 differences. 
77. _pythonMajorVersion = sys.version_info[0] 
78. # Modes of crypting / cyphering 
79. ECB = 0 
80. CBC = 1 
81. # Modes of padding 
82. PAD_NORMAL = 1 
83. PAD_PKCS5 = 2 
84. # PAD_PKCS5: is a method that will unambiguously remove all padding 
85. # characters after decryption, when originally encrypted with 
86. # this padding mode. 
87. # For a good description of the PKCS5 padding technique, see: 
88. # http://www.faqs.org/rfcs/rfc1423.html 
89. # The base class shared by des and triple des. 
90. class _baseDes(object): 
91. def __init__(self, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL): 
92. if IV: 
93. IV = self._guardAgainstUnicode(IV) 
94. if pad: 
95. pad = self._guardAgainstUnicode(pad) 
96. self.block_size = 8 
97. # Sanity checking of arguments. 
98. if pad and padmode == PAD_PKCS5: 
99. raise ValueError("Cannot use a pad character with PAD_PKCS5") 
100. if IV and len(IV) != self.block_size: 
101. raise ValueError("Invalid Initial Value (IV), must be a multiple of " + str(self.block_size) + " bytes") 
102. # Set the passed in variables 
103. self._mode = mode 
104. self._iv = IV 
105. self._padding = pad 
106. self._padmode = padmode 
107. def getKey(self): 
108. """getKey() -> bytes""" 
109. return self.__key 
110. def setKey(self, key): 
111. """Will set the crypting key for this object.""" 
112. key = self._guardAgainstUnicode(key) 
113. self.__key = key 
114. def getMode(self): 
115. """getMode() -> pyDes.ECB or pyDes.CBC""" 
116. return self._mode 
117. def setMode(self, mode): 
118. """Sets the type of crypting mode, pyDes.ECB or pyDes.CBC""" 
119. self._mode = mode 
120. def getPadding(self): 
121. """getPadding() -> bytes of length 1. Padding character.""" 
122. return self._padding 
123. def setPadding(self, pad): 
124. """setPadding() -> bytes of length 1. Padding character.""" 
125. if pad is not None: 
126. pad = self._guardAgainstUnicode(pad) 
127. self._padding = pad 
128. def getPadMode(self): 
129. """getPadMode() -> pyDes.PAD_NORMAL or pyDes.PAD_PKCS5""" 
130. return self._padmode 
131. def setPadMode(self, mode): 
132. """Sets the type of padding mode, pyDes.PAD_NORMAL or pyDes.PAD_PKCS5""" 
133. self._padmode = mode 
134. def getIV(self): 
135. """getIV() -> bytes""" 
136. return self._iv 
137. def setIV(self, IV): 
138. """Will set the Initial Value, used in conjunction with CBC mode""" 
139. if not IV or len(IV) != self.block_size: 
140. raise ValueError("Invalid Initial Value (IV), must be a multiple of " + str(self.block_size) + " bytes") 
141. IV = self._guardAgainstUnicode(IV) 
142. self._iv = IV 
143. def _padData(self, data, pad, padmode): 
144. # Pad data depending on the mode 
145. if padmode is None: 
146. # Get the default padding mode. 
147. padmode = self.getPadMode() 
148. if pad and padmode == PAD_PKCS5: 
149. raise ValueError("Cannot use a pad character with PAD_PKCS5") 
150. if padmode == PAD_NORMAL: 
151. if len(data) % self.block_size == 0: 
152. # No padding required. 
153. return data 
154. if not pad: 
155. # Get the default padding. 
156. pad = self.getPadding() 
157. if not pad: 
158. raise ValueError("Data must be a multiple of " + str(self.block_size) + " bytes in length. Use padmode=PAD_PKCS5 or set the pad character.") 
159. data += (self.block_size - (len(data) % self.block_size)) * pad 
160. elif padmode == PAD_PKCS5: 
161. pad_len = 8 - (len(data) % self.block_size) 
162. if _pythonMajorVersion < 3: 
163. data += pad_len * chr(pad_len) 
164. else: 
165. data += bytes([pad_len] * pad_len) 
166. return data 
167. def _unpadData(self, data, pad, padmode): 
168. # Unpad data depending on the mode. 
169. if not data: 
170. return data 
171. if pad and padmode == PAD_PKCS5: 
172. raise ValueError("Cannot use a pad character with PAD_PKCS5") 
173. if padmode is None: 
174. # Get the default padding mode. 
175. padmode = self.getPadMode() 
176. if padmode == PAD_NORMAL: 
177. if not pad: 
178. # Get the default padding. 
179. pad = self.getPadding() 
180. if pad: 
181. data = data[:-self.block_size] + / 
182. data[-self.block_size:].rstrip(pad) 
183. elif padmode == PAD_PKCS5: 
184. if _pythonMajorVersion < 3: 
185. pad_len = ord(data[-1]) 
186. else: 
187. pad_len = data[-1] 
188. data = data[:-pad_len] 
189. return data 
190. def _guardAgainstUnicode(self, data): 
191. # Only accept byte strings or ascii unicode values, otherwise 
192. # there is no way to correctly decode the data into bytes. 
193. if _pythonMajorVersion < 3: 
194. if isinstance(data, unicode): 
195. raise ValueError("pyDes can only work with bytes, not Unicode strings.") 
196. else: 
197. if isinstance(data, str): 
198. # Only accept ascii unicode values. 
199. try: 
200. return data.encode('ascii') 
201. except UnicodeEncodeError: 
202. pass 
203. raise ValueError("pyDes can only work with encoded strings, not Unicode.") 
204. return data 
205. ############################################################################# 
206. # DES # 
207. ############################################################################# 
208. class des(_baseDes): 
209. """DES encryption/decrytpion class 
210. Supports ECB (Electronic Code Book) and CBC (Cypher Block Chaining) modes. 
211. pyDes.des(key,[mode], [IV]) 
212. key -> Bytes containing the encryption key, must be exactly 8 bytes 
213. mode -> Optional argument for encryption type, can be either pyDes.ECB 
214. (Electronic Code Book), pyDes.CBC (Cypher Block Chaining) 
215. IV -> Optional Initial Value bytes, must be supplied if using CBC mode. 
216. Must be 8 bytes in length. 
217. pad -> Optional argument, set the pad character (PAD_NORMAL) to use 
218. during all encrypt/decrpt operations done with this instance. 
219. padmode -> Optional argument, set the padding mode (PAD_NORMAL or 
220. PAD_PKCS5) to use during all encrypt/decrpt operations done 
221. with this instance. 
222. """ 
223.  
224. # Permutation and translation tables for DES 
225. __pc1 = [56, 48, 40, 32, 24, 16, 8, 
226. , 57, 49, 41, 33, 25, 17, 
227. , 1, 58, 50, 42, 34, 26, 
228. , 10, 2, 59, 51, 43, 35, 
229. , 54, 46, 38, 30, 22, 14, 
230. , 61, 53, 45, 37, 29, 21, 
231. , 5, 60, 52, 44, 36, 28, 
232. , 12, 4, 27, 19, 11, 3 
233. ] 
234. # number left rotations of pc1 
235. __left_rotations = [ 
236. , 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 
237. ] 
238. # permuted choice key (table 2) 
239. __pc2 = [ 
240. , 16, 10, 23, 0, 4, 
241. , 27, 14, 5, 20, 9, 
242. , 18, 11, 3, 25, 7, 
243. , 6, 26, 19, 12, 1, 
244. , 51, 30, 36, 46, 54, 
245. , 39, 50, 44, 32, 47, 
246. , 48, 38, 55, 33, 52, 
247. , 41, 49, 35, 28, 31 
248. ] 
249. # initial permutation IP 
250. __ip = [57, 49, 41, 33, 25, 17, 9, 1, 
251. , 51, 43, 35, 27, 19, 11, 3, 
252. , 53, 45, 37, 29, 21, 13, 5, 
253. , 55, 47, 39, 31, 23, 15, 7, 
254. , 48, 40, 32, 24, 16, 8, 0, 
255. , 50, 42, 34, 26, 18, 10, 2, 
256. , 52, 44, 36, 28, 20, 12, 4, 
257. , 54, 46, 38, 30, 22, 14, 6 
258. ] 
259. # Expansion table for turning 32 bit blocks into 48 bits 
260. __expansion_table = [ 
261. , 0, 1, 2, 3, 4, 
262. , 4, 5, 6, 7, 8, 
263. , 8, 9, 10, 11, 12, 
264. , 12, 13, 14, 15, 16, 
265. , 16, 17, 18, 19, 20, 
266. , 20, 21, 22, 23, 24, 
267. , 24, 25, 26, 27, 28, 
268. , 28, 29, 30, 31, 0 
269. ] 
270. # The (in)famous S-boxes 
271. __sbox = [ 
272. # S1 
273. [14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7, 
274. , 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8, 
275. , 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0, 
276. , 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13], 
277. # S2 
278. [15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10, 
279. , 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5, 
280. , 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15, 
281. , 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9], 
282. # S3 
283. [10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8, 
284. , 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1, 
285. , 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7, 
286. , 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12], 
287. # S4 
288. [7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15, 
289. , 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9, 
290. , 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4, 
291. , 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14], 
292. # S5 
293. [2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9, 
294. , 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6, 
295. , 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14, 
296. , 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3], 
297. # S6 
298. [12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11, 
299. , 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8, 
300. , 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6, 
301. , 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13], 
302. # S7 
303. [4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1, 
304. , 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6, 
305. , 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2, 
306. , 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12], 
307. # S8 
308. [13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7, 
309. , 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2, 
310. , 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8, 
311. , 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11], 
312. ] 
313.  
314. # 32-bit permutation function P used on the output of the S-boxes 
315. __p = [ 
316. , 6, 19, 20, 28, 11, 
317. , 16, 0, 14, 22, 25, 
318. , 17, 30, 9, 1, 7, 
319. ,13, 31, 26, 2, 8, 
320. , 12, 29, 5, 21, 10, 
321. , 24 
322. ] 
323. # final permutation IP^-1 
324. __fp = [ 
325. , 7, 47, 15, 55, 23, 63, 31, 
326. , 6, 46, 14, 54, 22, 62, 30, 
327. , 5, 45, 13, 53, 21, 61, 29, 
328. , 4, 44, 12, 52, 20, 60, 28, 
329. , 3, 43, 11, 51, 19, 59, 27, 
330. , 2, 42, 10, 50, 18, 58, 26, 
331. , 1, 41, 9, 49, 17, 57, 25, 
332. , 0, 40, 8, 48, 16, 56, 24 
333. ] 
334. # Type of crypting being done 
335. ENCRYPT = 0x00 
336. DECRYPT = 0x01 
337. # Initialisation 
338. def __init__(self, key, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL): 
339. # Sanity checking of arguments. 
340. if len(key) != 8: 
341. raise ValueError("Invalid DES key size. Key must be exactly 8 bytes long.") 
342. _baseDes.__init__(self, mode, IV, pad, padmode) 
343. self.key_size = 8 
344. self.L = [] 
345. self.R = [] 
346. self.Kn = [ [0] * 48 ] * 16 # 16 48-bit keys (K1 - K16) 
347. self.final = [] 
348. self.setKey(key) 
349. def setKey(self, key): 
350. """Will set the crypting key for this object. Must be 8 bytes.""" 
351. _baseDes.setKey(self, key) 
352. self.__create_sub_keys() 
353. def __String_to_BitList(self, data): 
354. """Turn the string data, into a list of bits (1, 0)'s""" 
355. if _pythonMajorVersion < 3: 
356. # Turn the strings into integers. Python 3 uses a bytes 
357. # class, which already has this behaviour. 
358. data = [ord(c) for c in data] 
359. l = len(data) * 8 
360. result = [0] * l 
361. pos = 0 
362. for ch in data: 
363. i = 7 
364. while i >= 0: 
365. if ch & (1 << i) != 0: 
366. result[pos] = 1 
367. else: 
368. result[pos] = 0 
369. pos += 1 
370. i -= 1 
371. return result 
372. def __BitList_to_String(self, data): 
373. """Turn the list of bits -> data, into a string""" 
374. result = [] 
375. pos = 0 
376. c = 0 
377. while pos < len(data): 
378. c += data[pos] << (7 - (pos % 8)) 
379. if (pos % 8) == 7: 
380. result.append(c) 
381. c = 0 
382. pos += 1 
383. if _pythonMajorVersion < 3: 
384. return ''.join([ chr(c) for c in result ]) 
385. else: 
386. return bytes(result) 
387. def __permutate(self, table, block): 
388. """Permutate this block with the specified table""" 
389. return list(map(lambda x: block[x], table)) 
390. # Transform the secret key, so that it is ready for data processing 
391. # Create the 16 subkeys, K[1] - K[16] 
392. def __create_sub_keys(self): 
393. """Create the 16 subkeys K[1] to K[16] from the given key""" 
394. key = self.__permutate(des.__pc1, self.__String_to_BitList(self.getKey())) 
395. i = 0 
396. # Split into Left and Right sections 
397. self.L = key[:28] 
398. self.R = key[28:] 
399. while i < 16: 
400. j = 0 
401. # Perform circular left shifts 
402. while j < des.__left_rotations[i]: 
403. self.L.append(self.L[0]) 
404. del self.L[0] 
405. self.R.append(self.R[0]) 
406. del self.R[0] 
407. j += 1 
408. # Create one of the 16 subkeys through pc2 permutation 
409. self.Kn[i] = self.__permutate(des.__pc2, self.L + self.R) 
410. i += 1 
411. # Main part of the encryption algorithm, the number cruncher :) 
412. def __des_crypt(self, block, crypt_type): 
413. """Crypt the block of data through DES bit-manipulation""" 
414. block = self.__permutate(des.__ip, block) 
415. self.L = block[:32] 
416. self.R = block[32:] 
417. # Encryption starts from Kn[1] through to Kn[16] 
418. if crypt_type == des.ENCRYPT: 
419. iteration = 0 
420. iteration_adjustment = 1 
421. # Decryption starts from Kn[16] down to Kn[1] 
422. else: 
423. iteration = 15 
424. iteration_adjustment = -1 
425. i = 0 
426. while i < 16: 
427. # Make a copy of R[i-1], this will later become L[i] 
428. tempR = self.R[:] 
429. # Permutate R[i - 1] to start creating R[i] 
430. self.R = self.__permutate(des.__expansion_table, self.R) 
431. # Exclusive or R[i - 1] with K[i], create B[1] to B[8] whilst here 
432. self.R = list(map(lambda x, y: x ^ y, self.R, self.Kn[iteration])) 
433. B = [self.R[:6], self.R[6:12], self.R[12:18], self.R[18:24], self.R[24:30], self.R[30:36], self.R[36:42], self.R[42:]] 
434. # Optimization: Replaced below commented code with above 
435. #j = 0 
436. #B = [] 
437. #while j < len(self.R): 
438. # self.R[j] = self.R[j] ^ self.Kn[iteration][j] 
439. # j += 1 
440. # if j % 6 == 0: 
441. # B.append(self.R[j-6:j]) 
442. # Permutate B[1] to B[8] using the S-Boxes 
443. j = 0 
444. Bn = [0] * 32 
445. pos = 0 
446. while j < 8: 
447. # Work out the offsets 
448. m = (B[j][0] << 1) + B[j][5] 
449. n = (B[j][1] << 3) + (B[j][2] << 2) + (B[j][3] << 1) + B[j][4] 
450. # Find the permutation value 
451. v = des.__sbox[j][(m << 4) + n] 
452. # Turn value into bits, add it to result: Bn 
453. Bn[pos] = (v & 8) >> 3 
454. Bn[pos + 1] = (v & 4) >> 2 
455. Bn[pos + 2] = (v & 2) >> 1 
456. Bn[pos + 3] = v & 1 
457. pos += 4 
458. j += 1 
459. # Permutate the concatination of B[1] to B[8] (Bn) 
460. self.R = self.__permutate(des.__p, Bn) 
461. # Xor with L[i - 1] 
462. self.R = list(map(lambda x, y: x ^ y, self.R, self.L)) 
463. # Optimization: This now replaces the below commented code 
464. #j = 0 
465. #while j < len(self.R): 
466. # self.R[j] = self.R[j] ^ self.L[j] 
467. # j += 1 
468. # L[i] becomes R[i - 1] 
469. self.L = tempR 
470. i += 1 
471. iteration += iteration_adjustment 
472. # Final permutation of R[16]L[16] 
473. self.final = self.__permutate(des.__fp, self.R + self.L) 
474. return self.final 
475.  
476. # Data to be encrypted/decrypted 
477. def crypt(self, data, crypt_type): 
478. """Crypt the data in blocks, running it through des_crypt()""" 
479. # Error check the data 
480. if not data: 
481. return '' 
482. if len(data) % self.block_size != 0: 
483. if crypt_type == des.DECRYPT: # Decryption must work on 8 byte blocks 
484. raise ValueError("Invalid data length, data must be a multiple of " + str(self.block_size) + " bytes/n.") 
485. if not self.getPadding(): 
486. raise ValueError("Invalid data length, data must be a multiple of " + str(self.block_size) + " bytes/n. Try setting the optional padding character") 
487. else: 
488. data += (self.block_size - (len(data) % self.block_size)) * self.getPadding() 
489. # print "Len of data: %f" % (len(data) / self.block_size) 
490. if self.getMode() == CBC: 
491. if self.getIV(): 
492. iv = self.__String_to_BitList(self.getIV()) 
493. else: 
494. raise ValueError("For CBC mode, you must supply the Initial Value (IV) for ciphering") 
495. # Split the data into blocks, crypting each one seperately 
496. i = 0 
497. dict = {} 
498. result = [] 
499. #cached = 0 
500. #lines = 0 
501. while i < len(data): 
502. # Test code for caching encryption results 
503. #lines += 1 
504. #if dict.has_key(data[i:i+8]): 
505. #print "Cached result for: %s" % data[i:i+8] 
506. # cached += 1 
507. # result.append(dict[data[i:i+8]]) 
508. # i += 8 
509. # continue 
510. block = self.__String_to_BitList(data[i:i+8]) 
511. # Xor with IV if using CBC mode 
512. if self.getMode() == CBC: 
513. if crypt_type == des.ENCRYPT: 
514. block = list(map(lambda x, y: x ^ y, block, iv)) 
515. #j = 0 
516. #while j < len(block): 
517. # block[j] = block[j] ^ iv[j] 
518. # j += 1 
519. processed_block = self.__des_crypt(block, crypt_type) 
520. if crypt_type == des.DECRYPT: 
521. processed_block = list(map(lambda x, y: x ^ y, processed_block, iv)) 
522. #j = 0 
523. #while j < len(processed_block): 
524. # processed_block[j] = processed_block[j] ^ iv[j] 
525. # j += 1 
526. iv = block 
527. else: 
528. iv = processed_block 
529. else: 
530. processed_block = self.__des_crypt(block, crypt_type) 
531.  
532. # Add the resulting crypted block to our list 
533. #d = self.__BitList_to_String(processed_block) 
534. #result.append(d) 
535. result.append(self.__BitList_to_String(processed_block)) 
536. #dict[data[i:i+8]] = d 
537. i += 8 
538. # print "Lines: %d, cached: %d" % (lines, cached) 
539. # Return the full crypted string 
540. if _pythonMajorVersion < 3: 
541. return ''.join(result) 
542. else: 
543. return bytes.fromhex('').join(result) 
544. def encrypt(self, data, pad=None, padmode=None): 
545. """encrypt(data, [pad], [padmode]) -> bytes 
546. data : Bytes to be encrypted 
547. pad : Optional argument for encryption padding. Must only be one byte 
548. padmode : Optional argument for overriding the padding mode. 
549. The data must be a multiple of 8 bytes and will be encrypted 
550. with the already specified key. Data does not have to be a 
551. multiple of 8 bytes if the padding character is supplied, or 
552. the padmode is set to PAD_PKCS5, as bytes will then added to 
553. ensure the be padded data is a multiple of 8 bytes. 
554. """ 
555. data = self._guardAgainstUnicode(data) 
556. if pad is not None: 
557. pad = self._guardAgainstUnicode(pad) 
558. data = self._padData(data, pad, padmode) 
559. return self.crypt(data, des.ENCRYPT) 
560. def decrypt(self, data, pad=None, padmode=None): 
561. """decrypt(data, [pad], [padmode]) -> bytes 
562. data : Bytes to be encrypted 
563. pad : Optional argument for decryption padding. Must only be one byte 
564. padmode : Optional argument for overriding the padding mode. 
565. The data must be a multiple of 8 bytes and will be decrypted 
566. with the already specified key. In PAD_NORMAL mode, if the 
567. optional padding character is supplied, then the un-encrypted 
568. data will have the padding characters removed from the end of 
569. the bytes. This pad removal only occurs on the last 8 bytes of 
570. the data (last data block). In PAD_PKCS5 mode, the special 
571. padding end markers will be removed from the data after decrypting. 
572. """ 
573. data = self._guardAgainstUnicode(data) 
574. if pad is not None: 
575. pad = self._guardAgainstUnicode(pad) 
576. data = self.crypt(data, des.DECRYPT) 
577. return self._unpadData(data, pad, padmode) 
578.  
579. ############################################################################# 
580. # Triple DES # 
581. ############################################################################# 
582. class triple_des(_baseDes): 
583. """Triple DES encryption/decrytpion class 
584. This algorithm uses the DES-EDE3 (when a 24 byte key is supplied) or 
585. the DES-EDE2 (when a 16 byte key is supplied) encryption methods. 
586. Supports ECB (Electronic Code Book) and CBC (Cypher Block Chaining) modes. 
587. pyDes.des(key, [mode], [IV]) 
588. key -> Bytes containing the encryption key, must be either 16 or 
589. bytes long 
590. mode -> Optional argument for encryption type, can be either pyDes.ECB 
591. (Electronic Code Book), pyDes.CBC (Cypher Block Chaining) 
592. IV -> Optional Initial Value bytes, must be supplied if using CBC mode. 
593. Must be 8 bytes in length. 
594. pad -> Optional argument, set the pad character (PAD_NORMAL) to use 
595. during all encrypt/decrpt operations done with this instance. 
596. padmode -> Optional argument, set the padding mode (PAD_NORMAL or 
597. PAD_PKCS5) to use during all encrypt/decrpt operations done 
598. with this instance. 
599. """ 
600. def __init__(self, key, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL): 
601. _baseDes.__init__(self, mode, IV, pad, padmode) 
602. self.setKey(key) 
603. def setKey(self, key): 
604. """Will set the crypting key for this object. Either 16 or 24 bytes long.""" 
605. self.key_size = 24 # Use DES-EDE3 mode 
606. if len(key) != self.key_size: 
607. if len(key) == 16: # Use DES-EDE2 mode 
608. self.key_size = 16 
609. else: 
610. raise ValueError("Invalid triple DES key size. Key must be either 16 or 24 bytes long") 
611. if self.getMode() == CBC: 
612. if not self.getIV(): 
613. # Use the first 8 bytes of the key 
614. self._iv = key[:self.block_size] 
615. if len(self.getIV()) != self.block_size: 
616. raise ValueError("Invalid IV, must be 8 bytes in length") 
617. self.__key1 = des(key[:8], self._mode, self._iv, 
618. self._padding, self._padmode) 
619. self.__key2 = des(key[8:16], self._mode, self._iv, 
620. self._padding, self._padmode) 
621. if self.key_size == 16: 
622. self.__key3 = self.__key1 
623. else: 
624. self.__key3 = des(key[16:], self._mode, self._iv, 
625. self._padding, self._padmode) 
626. _baseDes.setKey(self, key) 
627. # Override setter methods to work on all 3 keys. 
628. def setMode(self, mode): 
629. """Sets the type of crypting mode, pyDes.ECB or pyDes.CBC""" 
630. _baseDes.setMode(self, mode) 
631. for key in (self.__key1, self.__key2, self.__key3): 
632. key.setMode(mode) 
633. def setPadding(self, pad): 
634. """setPadding() -> bytes of length 1. Padding character.""" 
635. _baseDes.setPadding(self, pad) 
636. for key in (self.__key1, self.__key2, self.__key3): 
637. key.setPadding(pad) 
638. def setPadMode(self, mode): 
639. """Sets the type of padding mode, pyDes.PAD_NORMAL or pyDes.PAD_PKCS5""" 
640. _baseDes.setPadMode(self, mode) 
641. for key in (self.__key1, self.__key2, self.__key3): 
642. key.setPadMode(mode) 
643. def setIV(self, IV): 
644. """Will set the Initial Value, used in conjunction with CBC mode""" 
645. _baseDes.setIV(self, IV) 
646. for key in (self.__key1, self.__key2, self.__key3): 
647. key.setIV(IV) 
648. def encrypt(self, data, pad=None, padmode=None): 
649. """encrypt(data, [pad], [padmode]) -> bytes 
650. data : bytes to be encrypted 
651. pad : Optional argument for encryption padding. Must only be one byte 
652. padmode : Optional argument for overriding the padding mode. 
653. The data must be a multiple of 8 bytes and will be encrypted 
654. with the already specified key. Data does not have to be a 
655. multiple of 8 bytes if the padding character is supplied, or 
656. the padmode is set to PAD_PKCS5, as bytes will then added to 
657. ensure the be padded data is a multiple of 8 bytes. 
658. """ 
659. ENCRYPT = des.ENCRYPT 
660. DECRYPT = des.DECRYPT 
661. data = self._guardAgainstUnicode(data) 
662. if pad is not None: 
663. pad = self._guardAgainstUnicode(pad) 
664. # Pad the data accordingly. 
665. data = self._padData(data, pad, padmode) 
666. if self.getMode() == CBC: 
667. self.__key1.setIV(self.getIV()) 
668. self.__key2.setIV(self.getIV()) 
669. self.__key3.setIV(self.getIV()) 
670. i = 0 
671. result = [] 
672. while i < len(data): 
673. block = self.__key1.crypt(data[i:i+8], ENCRYPT) 
674. block = self.__key2.crypt(block, DECRYPT) 
675. block = self.__key3.crypt(block, ENCRYPT) 
676. self.__key1.setIV(block) 
677. self.__key2.setIV(block) 
678. self.__key3.setIV(block) 
679. result.append(block) 
680. i += 8 
681. if _pythonMajorVersion < 3: 
682. return ''.join(result) 
683. else: 
684. return bytes.fromhex('').join(result) 
685. else: 
686. data = self.__key1.crypt(data, ENCRYPT) 
687. data = self.__key2.crypt(data, DECRYPT) 
688. return self.__key3.crypt(data, ENCRYPT) 
689. def decrypt(self, data, pad=None, padmode=None): 
690. """decrypt(data, [pad], [padmode]) -> bytes 
691. data : bytes to be encrypted 
692. pad : Optional argument for decryption padding. Must only be one byte 
693. padmode : Optional argument for overriding the padding mode. 
694. The data must be a multiple of 8 bytes and will be decrypted 
695. with the already specified key. In PAD_NORMAL mode, if the 
696. optional padding character is supplied, then the un-encrypted 
697. data will have the padding characters removed from the end of 
698. the bytes. This pad removal only occurs on the last 8 bytes of 
699. the data (last data block). In PAD_PKCS5 mode, the special 
700. padding end markers will be removed from the data after 
701. decrypting, no pad character is required for PAD_PKCS5. 
702. """ 
703. ENCRYPT = des.ENCRYPT 
704. DECRYPT = des.DECRYPT 
705. data = self._guardAgainstUnicode(data) 
706. if pad is not None: 
707. pad = self._guardAgainstUnicode(pad) 
708. if self.getMode() == CBC: 
709. self.__key1.setIV(self.getIV()) 
710. self.__key2.setIV(self.getIV()) 
711. self.__key3.setIV(self.getIV()) 
712. i = 0 
713. result = [] 
714. while i < len(data): 
715. iv = data[i:i+8] 
716. block = self.__key3.crypt(iv, DECRYPT) 
717. block = self.__key2.crypt(block, ENCRYPT) 
718. block = self.__key1.crypt(block, DECRYPT) 
719. self.__key1.setIV(iv) 
720. self.__key2.setIV(iv) 
721. self.__key3.setIV(iv) 
722. result.append(block) 
723. i += 8 
724. if _pythonMajorVersion < 3: 
725. data = ''.join(result) 
726. else: 
727. data = bytes.fromhex('').join(result) 
728. else: 
729. data = self.__key3.crypt(data, DECRYPT) 
730. data = self.__key2.crypt(data, ENCRYPT) 
731. data = self.__key1.crypt(data, DECRYPT) 
732. return self._unpadData(data, pad, padmode) 

希望本文所述对大家的Python程序设计有所帮助。