DES/3DES原理 + PBOC实现（C/C++）

原文：http://blog.csdn.net/ishow99/article/details/4841718

1、3des.cpp

 

[cpp] view plaincopy

1. /************************************************************************ 
2. * DES/3DES原理： 
3. *  1-1、变换密钥 
4. *  1-1-1、取得64位的密钥，每个第8位作为奇偶校验位。程序上无需任何操作 
5. * 
6. *  1-2、变换密钥 
7. *  1-2-1、舍弃64位密钥中的奇偶校验位，根据下表（PC-1）进行密钥变换（换位）得到56位的密钥，在变换中，奇偶校验位被舍弃 
8. * 
9. *  Permuted Choice 1 (PC-1)，本表表示的数组下标从1开始，因此转换时需要：PC1_Table[i]-1 
10. *    57, 49, 41, 33, 25, 17,  9, 
11. *    1, 58, 50, 42, 34, 26, 18, 
12. *    10,  2, 59, 51, 43, 35, 27, 
13. *    19, 11,  3, 60, 52, 44, 36, 
14. *    63, 55, 47, 39, 31, 23, 15, 
15. *    7, 62, 54, 46, 38, 30, 22, 
16. *    14,  6, 61, 53, 45, 37, 29, 
17. *    21, 13,  5, 28, 20, 12,  4 
18. * 
19. *  1-2-2、将变换后的密钥分为两个部分，开始的28位称为C[0]，最后的28位称为D[0] 
20. *  1-2-3、生成16个子密钥, I = 1。<这里假设I为生成密钥的轮数，它的基数是从1开始，即I取值为 1 – 16 > 
21. *  1-2-3-1、同时将C[I]、D[I]左移1位或2位，根据I值决定左移的位数。见下表： 
22. *           I： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 
23. *           左移位数： 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 
24. *           <每轮移位输出的C[I] D[I]作为下一轮移位时输入的C[I] D[I] 
25. *            这里有个关键点，进行解密时这里是向右移，而且在I = 1时无需移位。即： 
26. *            右移位数： 0, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 
27. *            解密时也只有这里也有区别，其它的地方和加密是一样的，DES算法的很多换位表是互反的，即可能你用 
28. *            表1换位完后，用表2再换一遍就又和原始值一样了> 
29. *  1-2-3-2、将C[I]D[I]作为一个整体按下表（PC-2）变换，得到48位的K[I] 
30. * 
31. *  Permuted Choice 2 (PC-2)，本表表示的数组下标从1开始，因此转换时需要：PC2_Table[i]-1 
32. *    14, 17, 11, 24,  1,  5, 
33. *    3, 28, 15,  6, 21, 10, 
34. *    23, 19, 12,  4, 26,  8, 
35. *    16,  7, 27, 20, 13,  2, 
36. *    41, 52, 31, 37, 47, 55, 
37. *    30, 40, 51, 45, 33, 48, 
38. *    44, 49, 39, 56, 34, 53, 
39. *    46, 42, 50, 36, 29, 32 
40. * 
41. *  1-2-3-3、从1-2-3-1处循环执行，直到K[16]被计算完成 
42. * 
43. *  2、处理64位的数据 
44. *  2-1、取得64位的数据，如果数据长度不足64位，应该将其扩展为64位（例如补零） 
45. *       <补什么要看具体数据，只能补数据取值范围外的字符，如果数据取值范围是0x00 – 0XFF而且还不是64位整倍数，那就要另想办法，比如在数据前面加上长度什么的> 
46. *  2-2、将64位数据按下表变换（IP） 
47. * 
48. *  Initial Permutation (IP)，本表表示的数组下标从1开始，因此转换时需要：IP_Table[i]-1 
49. *    58, 50, 42, 34, 26, 18, 10, 2, 
50. *    60, 52, 44, 36, 28, 20, 12, 4, 
51. *    62, 54, 46, 38, 30, 22, 14, 6, 
52. *    64, 56, 48, 40, 32, 24, 16, 8, 
53. *    57, 49, 41, 33, 25, 17,  9, 1, 
54. *    59, 51, 43, 35, 27, 19, 11, 3, 
55. *    61, 53, 45, 37, 29, 21, 13, 5, 
56. *    63, 55, 47, 39, 31, 23, 15, 7 
57. * 
58. *  2-3、将变换后的数据分为两部分，开始的32位称为L[0]，最后的32位称为R[0] 
59. *  2-4、用16个子密钥加密数据，初始I=1 
60. *  2-4-1、将32位的R[I-1]按下表（E）扩展为48位的E[I-1] 
61. *  Expansion (E)，本表表示的数组下标从1开始，因此转换时需要：E_Table[i]-1 
62. *    32,  1,  2,  3,  4,  5, 
63. *    4,  5,  6,  7,  8,  9, 
64. *    8,  9, 10, 11, 12, 13, 
65. *    12, 13, 14, 15, 16, 17, 
66. *    16, 17, 18, 19, 20, 21, 
67. *    20, 21, 22, 23, 24, 25, 
68. *    24, 25, 26, 27, 28, 29, 
69. *    28, 29, 30, 31, 32,  1 
70. * 
71. *  2-4-2、异或E[I-1]和K[I]，即E[I-1] XOR K[I] <上面生成的16组子密钥就是在这里用到的> 
72. *  2-4-3、将异或后的结果分为8个6位长的部分，第1位到第6位称为B[1]，第7位到第12位称为B[2]，依此类推，第43位到第48位称为B[8] 
73. *  2-4-4、按S表变换所有的B[J]，初始J=1。所有在S表的值都被当作4位长度处理 
74. *  2-4-4-1、将B[J]的第1位和第6位组合为一个2位长度的变量M，M作为在S[J]中的行号 
75. *  2-4-4-2、将B[J]的第2位到第5位组合，作为一个4位长度的变量N，N作为在S[J]中的列号 
76. *  2-4-4-3、用S[J][M][N]来取代B[J] 
77. * 
78. *  Substitution Box 
79. *    S[1] 
80. *    14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7 
81. *    0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8 
82. *    4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0 
83. *    15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13 
84. * 
85. *    S[2] 
86. *    15 1 8 14 6 11 3 4 9 7 2 13 12 0 5 10 
87. *    3 13 4 7 15 2 8 14 12 0 1 10 6 9 11 5 
88. *    0 14 7 11 10 4 13 1 5 8 12 6 9 3 2 15 
89. *    13 8 10 1 3 15 4 2 11 6 7 12 0 5 14 9 
90. * 
91. *    S[3] 
92. *    10 0 9 14 6 3 15 5 1 13 12 7 11 4 2 8 
93. *    13 7 0 9 3 4 6 10 2 8 5 14 12 11 15 1 
94. *    13 6 4 9 8 15 3 0 11 1 2 12 5 10 14 7 
95. *    1 10 13 0 6 9 8 7 4 15 14 3 11 5 2 12 
96. * 
97. *    S[4] 
98. *    7 13 14 3 0 6 9 10 1 2 8 5 11 12 4 15 
99. *    13 8 11 5 6 15 0 3 4 7 2 12 1 10 14 9 
100. *    10 6 9 0 12 11 7 13 15 1 3 14 5 2 8 4 
101. *    3 15 0 6 10 1 13 8 9 4 5 11 12 7 2 14 
102. * 
103. *    S[5] 
104. *    2 12 4 1 7 10 11 6 8 5 3 15 13 0 14 9 
105. *    14 11 2 12 4 7 13 1 5 0 15 10 3 9 8 6 
106. *    4 2 1 11 10 13 7 8 15 9 12 5 6 3 0 14 
107. *    11 8 12 7 1 14 2 13 6 15 0 9 10 4 5 3 
108. * 
109. *    S[6] 
110. *    12 1 10 15 9 2 6 8 0 13 3 4 14 7 5 11 
111. *    10 15 4 2 7 12 9 5 6 1 13 14 0 11 3 8 
112. *    9 14 15 5 2 8 12 3 7 0 4 10 1 13 11 6 
113. *    4 3 2 12 9 5 15 10 11 14 1 7 6 0 8 13 
114. * 
115. *    S[7] 
116. *    4 11 2 14 15 0 8 13 3 12 9 7 5 10 6 1 
117. *    13 0 11 7 4 9 1 10 14 3 5 12 2 15 8 6 
118. *    1 4 11 13 12 3 7 14 10 15 6 8 0 5 9 2 
119. *    6 11 13 8 1 4 10 7 9 5 0 15 14 2 3 12 
120. * 
121. *    S[8] 
122. *    13 2 8 4 6 15 11 1 10 9 3 14 5 0 12 7 
123. *    1 15 13 8 10 3 7 4 12 5 6 11 0 14 9 2 
124. *    7 11 4 1 9 12 14 2 0 6 10 13 15 3 5 8 
125. *    2 1 14 7 4 10 8 13 15 12 9 0 3 5 6 11 
126. * 
127. *  2-4-4-4、从2-4-4-1处循环执行，直到B[8]被替代完成 
128. *  2-4-4-5、将B[1]到B[8]组合，按下表（P）变换，得到P <B[1]到B[8]组成一个32位的数据> 
129. * 
130. *  Permutation P 
131. *    16, 7, 20, 21, 
132. *    29, 12, 28, 17, 
133. *    1,  15, 23, 26, 
134. *    5,  18, 31, 10, 
135. *    2,  8, 24, 14, 
136. *    32, 27, 3,  9, 
137. *    19, 13, 30, 6, 
138. *    22, 11, 4,  25 
139. * 
140. *  2-4-6、异或P和L[I-1]结果放在R[I]，即R[I] = P XOR L[I - 1] 
141. *  2-4-7、L[I] = R[I - 1] 
142. *  2-4-8、从2-4-1处开始循环执行，直到K[16]被变换完成 
143. *  2-4-5、组合变换后的R[16]L[16]（注意：R作为开始的32位），按下表（IP-1）变换得到最后的结果 
144. *         <这里要注意了，是对R[16]L[16]，而不是L[16]R[16] 即，需要进行左32位和右32位调换一下位置, 这里下标里的16是指轮数，不是位数> 
145. * 
146. *  Final Permutation (IP**-1) 
147. *    40, 8, 48, 16, 56, 24, 64, 32, 
148. *    39, 7, 47, 15, 55, 23, 63, 31, 
149. *    38, 6, 46, 14, 54, 22, 62, 30, 
150. *    37, 5, 45, 13, 53, 21, 61, 29, 
151. *    36, 4, 44, 12, 52, 20, 60, 28, 
152. *    35, 3, 43, 11, 51, 19, 59, 27, 
153. *    34, 2, 42, 10, 50, 18, 58, 26, 
154. *    33, 1, 41,  9, 49, 17, 57, 25 
155. * 
156. *  3DES计算方法如下： 
157. *    3DES(加密) = DES(key1, 加密) DES(key2, 解密)  DES(key3, 加密) 
158. *    3DES(解密) = DES(key3, 解密) DES(key2, 加密)  DES(key1, 解密) 
159. *    每个KEY为64位，总共可以有192位的KEY, 但一般都只使用128位的key 
160. *    如果只用128位密钥，则key3 = key1 
161. * 
162. *************************************************************************/  
163.   
164. #include "3des.h"  
165. #include <stdlib.h>  
166. #include <stdio.h>  
167. #include <memory.h>  
168. #include <string.h>  
169. #include <ctype.h>  
170.   
171. const char IP_Table[64] =  
172. {  
173.     58, 50, 42, 34, 26, 18, 10, 2,  
174.     60, 52, 44, 36, 28, 20, 12, 4,  
175.     62, 54, 46, 38, 30, 22, 14, 6,  
176.     64, 56, 48, 40, 32, 24, 16, 8,  
177.     57, 49, 41, 33, 25, 17,  9, 1,  
178.     59, 51, 43, 35, 27, 19, 11, 3,  
179.     61, 53, 45, 37, 29, 21, 13, 5,  
180.     63, 55, 47, 39, 31, 23, 15, 7  
181. };  
182.   
183. const char IPR_Table[64] =  
184. {  
185.     40, 8, 48, 16, 56, 24, 64, 32,  
186.     39, 7, 47, 15, 55, 23, 63, 31,  
187.     38, 6, 46, 14, 54, 22, 62, 30,  
188.     37, 5, 45, 13, 53, 21, 61, 29,  
189.     36, 4, 44, 12, 52, 20, 60, 28,  
190.     35, 3, 43, 11, 51, 19, 59, 27,  
191.     34, 2, 42, 10, 50, 18, 58, 26,  
192.     33, 1, 41,  9, 49, 17, 57, 25  
193. };  
194.   
195. const char E_Table[48] =  
196. {  
197.     32,  1,  2,  3,  4,  5,  
198.     4,  5,  6,  7,  8,  9,  
199.     8,  9, 10, 11, 12, 13,  
200.     12, 13, 14, 15, 16, 17,  
201.     16, 17, 18, 19, 20, 21,  
202.     20, 21, 22, 23, 24, 25,  
203.     24, 25, 26, 27, 28, 29,  
204.     28, 29, 30, 31, 32,  1  
205. };  
206.   
207. const char P_Table[32] =  
208. {  
209.     16, 7, 20, 21,  
210.     29, 12, 28, 17,  
211.     1,  15, 23, 26,  
212.     5,  18, 31, 10,  
213.     2,  8, 24, 14,  
214.     32, 27, 3,  9,  
215.     19, 13, 30, 6,  
216.     22, 11, 4,  25  
217. };  
218.   
219. const char PC1_Table[56] =  
220. {  
221.     57, 49, 41, 33, 25, 17,  9,  
222.     1, 58, 50, 42, 34, 26, 18,  
223.     10,  2, 59, 51, 43, 35, 27,  
224.     19, 11,  3, 60, 52, 44, 36,  
225.     63, 55, 47, 39, 31, 23, 15,  
226.     7, 62, 54, 46, 38, 30, 22,  
227.     14,  6, 61, 53, 45, 37, 29,  
228.     21, 13,  5, 28, 20, 12,  4  
229. };  
230.   
231. const char PC2_Table[48] =  
232. {  
233.     14, 17, 11, 24,  1,  5,  
234.     3, 28, 15,  6, 21, 10,  
235.     23, 19, 12,  4, 26,  8,  
236.     16,  7, 27, 20, 13,  2,  
237.     41, 52, 31, 37, 47, 55,  
238.     30, 40, 51, 45, 33, 48,  
239.     44, 49, 39, 56, 34, 53,  
240.     46, 42, 50, 36, 29, 32  
241. };  
242.   
243. const char LOOP_Table[16] =  
244. {  
245.     1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1  
246. };  
247.   
248. const char S_Box[8][4][16] =  
249. {  
250.     {  
251.         {14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7},  
252.         { 0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8},  
253.         { 4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0},  
254.         {15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13}  
255.     },  
256.   
257.     {  
258.         {15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10},  
259.         { 3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5},  
260.         { 0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15},  
261.         {13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9}  
262.     },  
263.   
264.     {  
265.         {10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8},  
266.         {13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1},  
267.         {13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7},  
268.         { 1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12}  
269.     },  
270.   
271.     {  
272.         { 7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15},  
273.         {13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9},  
274.         {10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4},  
275.         { 3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14}  
276.     },  
277.   
278.     {  
279.         { 2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9},  
280.         {14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6},  
281.         { 4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14},  
282.         {11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3}  
283.     },  
284.   
285.     {  
286.         {12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11},  
287.         {10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8},  
288.         { 9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6},  
289.         { 4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13}  
290.     },  
291.   
292.     {  
293.         { 4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1},  
294.         {13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6},  
295.         { 1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2},  
296.         { 6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12}  
297.     },  
298.   
299.     {  
300.         {13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7},  
301.         { 1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2},  
302.         { 7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8},  
303.         { 2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11}  
304.     }  
305. };  
306.   
307. char*  ch64="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";  
308.   
309.   
310.   
311. static void ByteToBit(char *Out, const char *In, int bits);  
312. static void BitToByte(char *Out, const char *In, int bits);  
313. static void RotateL(char *In, int len, int loop);  
314. static void Xor(char *InA, const char *InB, int len);  
315. static void Transform(char *Out, const char *In, const char *Table, int len);  
316. static void S_func(char Out[32], const char In[48]);  
317. static void F_func(char In[32], const char Ki[48]);  
318. static void SetSubKey(PSubKey pSubKey, const char Key[8]);  
319. static void DES(char Out[8], const char In[8], const PSubKey pSubKey, int Type);  
320.   
321.   
322.   
323. /******************************************************************* 
324.   函 数 名 称:  ByteToBit 
325.   功 能 描 述：  把BYTE转化为Bit流 
326.   参 数 说 明：  Out:    输出的Bit流[in][out] 
327.                 In:     输入的BYTE流[in] 
328.                 bits:   Bit流的长度[in] 
329.  
330.   返回值 说明：   void 
331. *******************************************************************/  
332. static void ByteToBit(char *Out, const char *In, int bits)  
333. {  
334.     int i;  
335.     for (i=0; i<bits; ++i)  
336.         Out[i] = (In[i>>3]>>(7 - i&7)) & 1;  
337. }  
338.   
339. /******************************************************************* 
340.   函 数 名 称:  BitToByte 
341.   功 能 描 述：  把Bit转化为Byte流 
342.   参 数 说 明：  Out:    输出的BYTE流[in][out] 
343.                 In:     输入的Bit流[in] 
344.                 bits:   Bit流的长度[in] 
345.  
346.   返回值 说明：   void 
347.   作       者:    huangjf 
348.   更 新 日 期：  2009.6.17 
349. *******************************************************************/  
350. static void BitToByte(char *Out, const char *In, int bits)  
351. {  
352.     int i;  
353.     memset(Out, 0, bits>>3);  
354.     for (i=0; i<bits; ++i) Out[i>>3] |= In[i]<<(7 - i&7);  
355. }  
356.   
357. /******************************************************************* 
358.   函 数 名 称:  RotateL 
359.   功 能 描 述：  把BIT流按位向左迭代 
360.   参 数 说 明：  In:     输入的Bit流[in][out] 
361.                 len:    Bit流的长度[in] 
362.                 loop:   向左迭代的长度 
363.  
364.   返回值 说明：   void 
365.   作       者:    huangjf 
366.   更 新 日 期：  2009.6.17 
367. *******************************************************************/  
368. static void RotateL(char *In, int len, int loop)  
369. {  
370.     char szTmp[256] = {0};  
371.   
372.     if (len >= 256) return;  
373.     if (loop==0 || loop>=256) return;  
374.   
375.     memset(szTmp, 0x00, sizeof(szTmp));  
376.   
377.     memcpy(szTmp, In, loop);  
378.     memmove(In, In+loop, len-loop);  
379.     memcpy(In+len-loop, szTmp, loop);  
380. }  
381.   
382. /******************************************************************* 
383.   函 数 名 称:  Xor 
384.   功 能 描 述：  把两个Bit流进行异或 
385.   参 数 说 明：  InA:    输入的Bit流[in][out] 
386.                 InB:    输入的Bit流[in] 
387.                 loop:   Bit流的长度 
388.  
389.   返回值 说明：   void 
390.   作       者:    huangjf 
391.   更 新 日 期：  2009.6.17 
392. *******************************************************************/  
393. static void Xor(char *InA, const char *InB, int len)  
394. {  
395.     int i;  
396.     for (i=0; i<len; ++i) InA[i] ^= InB[i];  
397. }  
398.   
399. /******************************************************************* 
400.   函 数 名 称:  Transform 
401.   功 能 描 述：  把两个Bit流按表进行位转化 
402.   参 数 说 明：  Out:    输出的Bit流[out] 
403.                 In:     输入的Bit流[in] 
404.                 Table:  转化需要的表指针 
405.                 len:    转化表的长度 
406.  
407.   返回值 说明：   void 
408.   作       者:    huangjf 
409.   更 新 日 期：  2009.6.17 
410. *******************************************************************/  
411. static void Transform(char *Out, const char *In, const char *Table, int len)  
412. {  
413.     char szTmp[256] = {0};  
414.     int i;  
415.   
416.     if (!Out || !In || !Table) return;  
417.     if (len >= 256) return;  
418.   
419.     memset(szTmp, 0x00, sizeof(szTmp));  
420.     for (i=0; i<len; ++i) szTmp[i] = In[Table[i]-1];  
421.   
422.     memcpy(Out, szTmp, len);  
423. }  
424.   
425. /******************************************************************* 
426.   函 数 名 称:  S_func 
427.   功 能 描 述：  实现数据加密S BOX模块 
428.   参 数 说 明：  Out:    输出的32Bit[out] 
429.                 In:     输入的48Bit[in] 
430.  
431.   返回值 说明：   void 
432.   作       者:    huangjf 
433.   更 新 日 期：  2009.6.17 
434. *******************************************************************/  
435. static void S_func(char Out[32], const char In[48])  
436. {  
437.     int i,j,k,l;  
438.     for (i=0,j=0,k=0; i<8; ++i,In+=6,Out+=4)  
439.     {  
440.         j = (In[0]<<1) + In[5];  
441.         k = (In[1]<<3) + (In[2]<<2) + (In[3]<<1) + In[4];  
442.   
443.         for ( l=0; l<4; ++l)  
444.             Out[l] = (S_Box[i][j][k]>>(3 - l)) & 1;  
445.     }  
446. }  
447.   
448. /******************************************************************* 
449.   函 数 名 称:  F_func 
450.   功 能 描 述：  实现数据加密到输出P 
451.   参 数 说 明：  Out:    输出的32Bit[out] 
452.                 In:     输入的48Bit[in] 
453.  
454.   返回值 说明：   void 
455.   作       者:    huangjf 
456.   更 新 日 期：  2009.6.17 
457. *******************************************************************/  
458. static void F_func(char In[32], const char Ki[48])  
459. {  
460.     char MR[48] = {0};  
461.     memset(MR, 0x00, sizeof(MR));  
462.   
463.     Transform(MR, In, E_Table, 48);  
464.     Xor(MR, Ki, 48);  
465.     S_func(In, MR);  
466.     Transform(In, In, P_Table, 32);  
467. }  
468.   
469. /******************************************************************* 
470.   函 数 名 称:  SetSubKey 
471.   功 能 描 述：  变换（换位）8字节密钥，生成16个子密钥 
472.   参 数 说 明：  pSubKey:    转换生成的16个子密钥[out] 
473.                 Key:        输入的8字节64Bit密钥[in] 
474.  
475.   返回值 说明：   void 
476.   作       者:    huangjf 
477.   更 新 日 期：  2009.6.17 
478. *******************************************************************/  
479. static void SetSubKey(PSubKey pSubKey, const char Key[8])  
480. {  
481.     int i;  
482.     char K[64] = {0}, *KL=&K[0], *KR=&K[28];  
483.   
484.     ByteToBit(K, Key, 64);  
485.   
486.     Transform(K, K, PC1_Table, 56);  
487.   
488.     for ( i=0; i<16; ++i)  
489.     {  
490.         RotateL(KL, 28, LOOP_Table[i]);  
491.         RotateL(KR, 28, LOOP_Table[i]);  
492.         Transform((*pSubKey)[i], K, PC2_Table, 48);  
493.     }  
494. }  
495.   
496. /******************************************************************* 
497. 函 数 名 称:    DES 
498. 功 能 描 述：    处理8字节64位的数据 
499. 参 数 说 明：    Out:        输出的8字节[out] 
500.                 In:         输入的8字节待加密[in] 
501.                 pSubKey:    转换后的16个48位子密钥 
502.                 Type:       类型：加密ENCRYPT，解密DECRYPT 
503.  
504. 返回值 说明： void 
505. 作       者:  huangjf 
506. 更 新 日 期：    2009.6.17 
507. *******************************************************************/  
508. static void DES(char Out[8], const char In[8], const PSubKey pSubKey, int Type)  
509. {  
510.     int i;  
511.     char M[64] = {0}, *ML=&M[0], *MR=&M[32], szTmp[32] = {0};  
512.   
513.     ByteToBit(M, In, 64);  
514.     Transform(M, M, IP_Table, 64);  
515.   
516.     if (Type == ENCRYPT)  
517.     {  
518.         for (i=0; i<16; ++i)  
519.         {  
520.             memcpy(szTmp, MR, 32);  
521.             F_func(MR, (*pSubKey)[i]);  
522.             Xor(MR, ML, 32);  
523.             memcpy(ML, szTmp, 32);  
524.         }  
525.     }  
526.     else  
527.     {  
528.         for (i=15; i>=0; --i)  
529.         {  
530.             memcpy(szTmp, MR, 32);  
531.             F_func(MR, (*pSubKey)[i]);  
532.             Xor(MR, ML, 32);  
533.             memcpy(ML, szTmp, 32);  
534.         }  
535.     }  
536.     RotateL(M, 64, 32);  
537.     Transform(M, M, IPR_Table, 64);  
538.     BitToByte(Out, M, 64);  
539. }  
540.   
541. /************************************************************************************************************************************************/  
542. /************************************************************************************************************************************************/  
543.   
544. /******************************************************************* 
545. 函 数 名 称:    Run1Des 
546. 功 能 描 述：    执行单DES算法对文本加解密 
547. 参 数 说 明：    bType   :类型：加密ENCRYPT，解密DECRYPT 
548.                 bMode   :模式：ECB,CBC 
549.                 In      :待加密串指针 
550.                 in_len  :待加密串的长度，同时Out的缓冲区大小应大于或者等于in_len 
551.                 Key     :密钥(可为8位,16位,24位)支持3密钥 
552.                 key_len :密钥长度，多出24位部分将被自动裁减 
553.                 Out     :待输出串指针 
554.                 out_len :输出缓存大小 
555.                 cvecstr :8字节随即字符串 
556.  
557. 作       者:  huangjf 
558. 更 新 日 期：    2009.6.17 
559.  
560. 返回值 说明： int     :是否加密成功，1：成功，0：失败 
561. *******************************************************************/  
562. int Run1Des(int bType, int bMode, const char *In, unsigned int in_len, const char *Key, unsigned int key_len, char* Out, unsigned int out_len, const char cvecstr[8])  
563. {  
564.     int i,j,k;  
565.     char m_SubKey[16][48] = {0};  
566.   
567.     /*参数不合法*/  
568.     if (!In || !Key || !Out) return 0;  
569.   
570.     /*密钥长度，单DES只支持8字节（64位的密钥，每个第8位作为奇偶校验位），多于8字节的自动裁剪*/  
571.     if (key_len & 0x00000007) return 0;  
572.   
573.     /*被加密数据长度，必需为8字节的倍数，如果非8的倍数，调用RunPad()函数补位*/  
574.     if (in_len & 0x00000007) return 0;  
575.   
576.     /*输出缓存大小判断*/  
577.     if (out_len < in_len) return 0;  
578.   
579.     /*生成16个子密钥*/  
580.     memset(m_SubKey, 0x00, sizeof(m_SubKey));  
581.     SetSubKey(&m_SubKey, Key);  
582.   
583.     if (bMode == ECB)  
584.     {  
585.         /*每8字节加密*/  
586.         for (i=0,j=in_len>>3; i<j; ++i,Out+=8,In+=8)  
587.         {  
588.             DES(Out, In, &m_SubKey, bType);  
589.         }  
590.     }  
591.     else if (bMode == CBC)  
592.     {  
593.         if (cvecstr == NULL) return 0;  
594.   
595.         char cvec[8] = {0};  
596.         char cvin[8] = {0};  
597.   
598.         memcpy(cvec, cvecstr, 8);  
599.   
600.         for (i=0,j=in_len>>3; i<j; ++i,Out+=8,In+=8)  
601.         {  
602.             if (bType == ENCRYPT)  
603.             {  
604.                 for ( k=0; k<8; ++k)  
605.                 {  
606.                     cvin[k] = In[k] ^ cvec[k];  
607.                 }  
608.             }  
609.             else  
610.             {  
611.                 memcpy(cvin, In, 8);  
612.             }  
613.   
614.             DES(Out, cvin, &m_SubKey, bType);  
615.   
616.             if (bType == ENCRYPT)  
617.             {  
618.                 memcpy(cvec, Out, 8);  
619.             }  
620.             else  
621.             {  
622.                 for (k=0; k<8; ++k)  
623.                 {  
624.                     Out[k] = Out[k] ^ cvec[k];  
625.                 }  
626.                 memcpy(cvec, cvin, 8);  
627.             }  
628.         }  
629.     }  
630.     else  
631.     {  
632.         return 0;  
633.     }  
634.   
635.     return 1;  
636. }  
637.   
638. /******************************************************************* 
639.   函 数 名 称:  Run3Des 
640.   功 能 描 述：  执行3DES算法对文本加解密 
641.   参 数 说 明：  bType   :类型：加密ENCRYPT，解密DECRYPT 
642.                 bMode   :模式：ECB,CBC 
643.                 In      :待加密串指针 
644.                 in_len  :待加密串的长度，同时Out的缓冲区大小应大于或者等于in_len 
645.                 Key     :密钥(可为8位,16位,24位)支持3密钥 
646.                 key_len :密钥长度，多出24位部分将被自动裁减 
647.                 Out     :待输出串指针 
648.                 out_len :输出缓存大小 
649.                 cvecstr :8字节随即字符串 
650.  
651.   返回值 说明：   int     :是否加密成功，1：成功，0：失败 
652.  
653.   作       者:    huangjf 
654.   更 新 日 期：  2009.6.17 
655.  
656.   3DES(加密) = DES(key1, 加密) DES(key2, 解密) DES(key3, 加密) 
657.   3DES(解密) = DES(key3, 解密) DES(key2, 加密) DES(key1, 解密) 
658.   每个KEY为64位，总共可以有192位的KEY, 但一般都只使用128位的key 
659.   如果只用128位密钥，则key3 = key1 
660.  
661. *******************************************************************/  
662. int Run3Des(int bType, int bMode, const char *In, unsigned int in_len, const char *Key, unsigned int key_len, char* Out, unsigned int out_len, const char cvecstr[8])  
663. {  
664.     int i,j,k;  
665.     char m_SubKey[3][16][48] = {0};  
666.     unsigned char nKey;  
667.   
668.     /*参数不合法*/  
669.     if (!In || !Key || !Out) return 0;  
670.   
671.     /*被加密数据长度，必需为8字节的倍数，如果非8的倍数，调用RunPad()函数补位*/  
672.     if (in_len & 0x00000007) return 0;  
673.   
674.     /*密钥长度，3DES只支持8、16、24字节（192位的密钥，实际使用128位，每个第8位作为奇偶校验位），多于24字节的自动裁剪*/  
675.     if (key_len & 0x00000007) return 0;  
676.   
677.     /*输出缓存大小判断*/  
678.     if (out_len < in_len) return 0;  
679.   
680.     /*生成16个子密钥*/  
681.     nKey = (key_len>>3)>3 ? 3 : (key_len>>3);  
682.     memset(m_SubKey, 0x00, sizeof(m_SubKey));  
683.     for ( i=0; i<nKey; i++)  
684.     {  
685.         SetSubKey(&m_SubKey[i], &Key[i<<3]);  
686.     }  
687.   
688.     if (bMode == ECB)  
689.     {  
690.         if (nKey == 1)  
691.         {  
692.             /*每8字节加密*/  
693.             for (i=0,j=in_len>>3; i<j; ++i,Out+=8,In+=8)  
694.             {  
695.                 DES(Out, In, &m_SubKey[0], bType);  
696.             }  
697.         }  
698.         else if (nKey == 2)  
699.         {  
700.             for (i=0,j=in_len>>3; i<j; ++i,Out+=8,In+=8)  
701.             {  
702.                 DES(Out, In,  &m_SubKey[0], bType);  
703.                 DES(Out, Out, &m_SubKey[1], bType==ENCRYPT?DECRYPT:ENCRYPT);  
704.                 DES(Out, Out, &m_SubKey[0], bType);  
705.             }  
706.         }  
707.         else if (nKey == 3)  
708.         {  
709.             for (i=0,j=in_len>>3; i<j; ++i,Out+=8,In+=8)  
710.             {  
711.                 DES(Out, In,  &m_SubKey[bType?2:0], bType);  
712.                 DES(Out, Out, &m_SubKey[1],         bType==ENCRYPT?DECRYPT:ENCRYPT);  
713.                 DES(Out, Out, &m_SubKey[bType?0:2], bType);  
714.             }  
715.         }  
716.         else  
717.         {  
718.             /*密钥长度不对*/  
719.             return 0;  
720.         }  
721.     }  
722.     else if (bMode == CBC)  
723.     {  
724.         if (cvecstr == NULL) return 0;  
725.   
726.         char cvec[8] = {0};  
727.         char cvin[8] = {0};  
728.   
729.         memcpy(cvec, cvecstr, 8);  
730.   
731.         if (nKey == 1)  
732.         {  
733.             for (i=0,j=in_len>>3; i<j; ++i,Out+=8,In+=8)  
734.             {  
735.                 if (bType == ENCRYPT)  
736.                 {  
737.                     for (k=0; k<8; ++k)  
738.                     {  
739.                         cvin[k] = In[k] ^ cvec[k];  
740.                     }  
741.                 }  
742.                 else  
743.                 {  
744.                     memcpy(cvin, In, 8);  
745.                 }  
746.   
747.                 DES(Out, cvin, &m_SubKey[0], bType);  
748.   
749.                 if (bType == ENCRYPT)  
750.                 {  
751.                     memcpy(cvec, Out, 8);  
752.                 }  
753.                 else  
754.                 {  
755.                     for (k=0; k<8; ++k)  
756.                     {  
757.                         Out[k] = Out[k] ^ cvec[k];  
758.                     }  
759.                     memcpy(cvec, cvin, 8);  
760.                 }  
761.             }  
762.         }  
763.         else if (nKey == 2)  
764.         {  
765.             for (i=0,j=in_len>>3; i<j; ++i,Out+=8,In+=8)  
766.             {  
767.                 if (bType == ENCRYPT)  
768.                 {  
769.                     for ( k=0; k<8; ++k)  
770.                     {  
771.                         cvin[k] = In[k] ^ cvec[k];  
772.                     }  
773.                 }  
774.                 else  
775.                 {  
776.                     memcpy(cvin, In, 8);  
777.                 }  
778.   
779.                 DES(Out, cvin, &m_SubKey[0], bType);  
780.                 DES(Out, Out,  &m_SubKey[1], bType==ENCRYPT?DECRYPT:ENCRYPT);  
781.                 DES(Out, Out,  &m_SubKey[0], bType);  
782.   
783.                 if (bType == ENCRYPT)  
784.                 {  
785.                     memcpy(cvec, Out, 8);  
786.                 }  
787.                 else  
788.                 {  
789.                     for (k=0; k<8; ++k)  
790.                     {  
791.                         Out[k] = Out[k] ^ cvec[k];  
792.                     }  
793.                     memcpy(cvec, cvin, 8);  
794.                 }  
795.             }  
796.         }  
797.         else if (nKey == 3)  
798.         {  
799.   
800.             for (i=0,j=in_len>>3; i<j; ++i,Out+=8,In+=8)  
801.             {  
802.                 if (bType == ENCRYPT)  
803.                 {  
804.                     for (k=0; k<8; ++k)  
805.                     {  
806.                         cvin[k] = In[k] ^ cvec[k];  
807.                     }  
808.                 }  
809.                 else  
810.                 {  
811.                     memcpy(cvin, In, 8);  
812.                 }  
813.   
814.                 DES(Out, cvin, &m_SubKey[bType?2:0], bType);  
815.                 DES(Out, Out,  &m_SubKey[1],         bType==ENCRYPT?DECRYPT:ENCRYPT);  
816.                 DES(Out, Out,  &m_SubKey[bType?0:2], bType);  
817.   
818.                 if (bType == ENCRYPT)  
819.                 {  
820.                     memcpy(cvec, Out, 8);  
821.                 }  
822.                 else  
823.                 {  
824.                     for (k=0; k<8; ++k)  
825.                     {  
826.                         Out[k] = Out[k] ^ cvec[k];  
827.                     }  
828.                     memcpy(cvec, cvin, 8);  
829.                 }  
830.             }  
831.         }  
832.         else  
833.         {  
834.             /*密钥长度不对*/  
835.             return 0;  
836.         }  
837.     }  
838.     else  
839.     {  
840.         return 0;  
841.     }  
842.   
843.     return 1;  
844. }  
845.   
846. /******************************************************************* 
847.   函 数 名 称:  RunPad 
848.   功 能 描 述：  根据协议对加密前的数据进行填充 
849.   参 数 说 明：  bType   :类型：PAD类型 
850.                 In      :数据串指针 
851.                 Out     :填充输出串指针 
852.                 in_len  :数据的长度 
853.                 padlen  :(in,out)输出buffer的长度，填充后的长度 
854.  
855.   返回值 说明：   char    :是否填充成功 
856.   作       者:    huangjf 
857.   修 改 历 史： 
858.  
859.   更 新 日 期：  2009.6.17 
860. *******************************************************************/  
861. int RunPad(int nType,const char* In,unsigned in_len,char* Out,int* padlen)  
862. {  
863.     int res = (in_len & 0x00000007);  
864.   
865.     /* 
866.         if(*padlen< ((int)in_len+8-res)) 
867.         { 
868.             return 0; 
869.         } 
870.         else 
871.         { 
872.             *padlen =   ((int)in_len+8-res); 
873.             memcpy(Out,In,in_len); 
874.         } 
875.     */  
876.     *padlen =   ((int)in_len+8-res);  
877.     memcpy(Out,In,in_len);  
878.   
879.     if (nType   ==  PAD_ISO_1)  
880.     {  
881.         memset(Out+in_len,0x00,8-res);  
882.     }  
883.     else if (nType  ==  PAD_ISO_2)  
884.     {  
885.         memset(Out+in_len,0x80,1);  
886.         memset(Out+in_len,0x00,7-res);  
887.     }  
888.     else if (nType  ==  PAD_PKCS_7)  
889.     {  
890.         memset(Out+in_len,8-res,8-res);  
891.     }  
892.     else  
893.     {  
894.         return 0;  
895.     }  
896.   
897.     return 1;  
898. }  
899.   
900. /*解密后,将填充的字符去掉*/  
901. void RunRsm(char *Text)  
902. {  
903.     int len,tmpint;  
904.   
905.     len=strlen(Text);  
906.     tmpint=*(Text+len-1);  
907.     *(Text+len-tmpint)=0x00;  
908. }  
909.   
910. /*将48位的明文密钥转换成24的字符串密钥*/  
911. int CovertKey(char *iKey, char *oKey)  
912. {  
913.     char in[64],out[64];  
914.     int  inlen,i,j;  
915.     unsigned char p,q,t,m,n;  
916.   
917.     memset(in,0,sizeof(in));  
918.     memset(out,0,sizeof(out));  
919.   
920.     inlen=strlen(iKey);  
921.     /*检查长度合法性*/  
922.     if (inlen!=48)  
923.         return 0;  
924.     strcpy(in,iKey);  
925.     /*检查字符合法性*/  
926.     for (i=0; i<inlen; i++)  
927.     {  
928.         if (!isxdigit(in[i]))  
929.             return 0;  
930.     }  
931.     for (i=0,j=0; i<inlen; i+=2,j++)  
932.     {  
933.         p=toupper(in[i]);  
934.         q=toupper(in[i+1]);  
935.   
936.         if (isdigit(p))  
937.             m=p-48;  
938.         else  
939.             m=p-55;  
940.   
941.         if (isdigit(q))  
942.             n=q-48;  
943.         else  
944.             n=q-55;  
945.   
946.         p=(char)((m<<4)&0xf0);  
947.         q=n&0x0f;  
948.         t=p|q;  
949.         out[j]=t;  
950.     }  
951.     memcpy(oKey,out,j+1);  
952.   
953.     return 1;  
954. }  
955.   
956. char *Base64Encode(char *src,int srclen)  
957. {  
958.     int n,buflen,i,j;  
959.     int pading=0;  
960.     char *buf;  
961.     static char *dst;  
962.   
963.     buf=src;  
964.     buflen=n=srclen;  
965.     if (n%3!=0) /* pad with 0x00 by using a temp buffer */  
966.     {  
967.         pading=1;  
968.         buflen=n+3-n%3;  
969.         buf=(char*)malloc(buflen+1);  
970.         memset(buf,0,buflen+1);  
971.         memcpy(buf,src,n);  
972.         for (i=0; i<3-n%3; i++)  
973.             buf[n+i]=0x00;  
974.     }  
975.   
976.     dst=(char*)malloc(buflen*4/3+1);  
977.     memset(dst,0,buflen*4/3+1);  
978.     for (i=0,j=0; i<buflen; i+=3,j+=4)  
979.     {  
980.         dst[j]=(buf[i]&0xFC)>>2;  
981.         dst[j+1]=((buf[i]&0x03)<<4) + ((buf[i+1]&0xF0)>>4);  
982.         dst[j+2]=((buf[i+1]&0x0F)<<2) + ((buf[i+2]&0xC0)>>6);  
983.         dst[j+3]=buf[i+2]&0x3F;  
984.     }  
985.   
986.     for (i=0; i<buflen*4/3; i++) /* map 6 bit value to base64 ASCII character */  
987.     {  
988.         dst[i]=ch64[dst[i]];  
989.     }  
990.     for (i=0; i<3-n%3; i++)/*补'='*/  
991.         dst[j-i-1]='=';  
992.   
993.     if (pading)  
994.         free(buf);  
995.     return dst;  
996. }  
997.   
998. char *Base64Decode(char *src)  
999. {  
1000.     int m,n,i,j,len;  
1001.     char *p;  
1002.     static char *dst;  
1003.     char strbuf[256];  
1004.   
1005.     if (src == 0 || src[0] == 0)  
1006.         return NULL;  
1007.     len = strlen(src);  
1008.     if (len % 4)  
1009.         return NULL;  
1010.   
1011.     for (i = 0; i < len-2; i++)  
1012.         if (src[i] == '=')  
1013.             return NULL;  
1014.   
1015.     memset(strbuf,0,sizeof(strbuf));  
1016.     strcpy(strbuf,src);  
1017.     n=strlen(src);  
1018.     for (i=0; i<n; i++) /* map base64 ASCII character to 6 bit value */  
1019.     {  
1020.         p=strchr(ch64,src[i]);  
1021.         if (!p)  
1022.             break;  
1023.         src[i]=p-ch64;  
1024.     }  
1025.     dst=(char*)malloc(n*3/4+1);  
1026.     memset(dst,0,n*3/4+1);  
1027.     for (i=0,j=0; i<n; i+=4,j+=3)  
1028.     {  
1029.         dst[j]=(src[i]<<2) + ((src[i+1]&0x30)>>4);  
1030.         dst[j+1]=((src[i+1]&0x0F)<<4) + ((src[i+2]&0x3C)>>2);  
1031.         dst[j+2]=((src[i+2]&0x03)<<6) + src[i+3];  
1032.     }  
1033.     m=strcspn(strbuf,"=");  
1034.     for (i=0; i<n-m; i++)  
1035.         dst[j-i-1]=0x00;  
1036.   
1037.     return dst;  
1038. }  
1039.   
1040. void MyDesInit(int* cryptmode,int* padmode,char* cvec)  
1041. {  
1042.     char buf[10];  
1043.   
1044.     memset(buf,0,sizeof(buf));  
1045.     *cryptmode=CBC;  
1046.     *padmode=PAD_PKCS_7;  
1047.     buf[0]=0x01;  
1048.     buf[1]=0x02;  
1049.     buf[2]=0x03;  
1050.     buf[3]=0x04;  
1051.     buf[4]=0x05;  
1052.     buf[5]=0x06;  
1053.     buf[6]=0x07;  
1054.     buf[7]=0x08;  
1055.     memcpy(cvec,buf,8);  
1056. }  
1057.   
1058. /******************************************************************* 
1059.   函 数 名 称:  Crypt3Des 
1060.   功 能 描 述：  实现3DES的加解密 
1061.   参 数 说 明：  type    :类型：加密ENCRYPT，解密DECRYPT 
1062.                 in      :待加密串指针或者待解密的密码字符串指针 
1063.                 Out     :加密后的密码或者解密后的明文 
1064.                 Key     :密钥(48位的ASCII字符串) 
1065.  
1066.   返回值 说明： 
1067.                  0:成功 
1068.                 -1:非法的密钥长度 
1069.                 -2:密钥含有非16进制字符 
1070.                 -3:明文填充失败 
1071.                 -4:加解密失败 
1072.                 -5:非法的操作类型 
1073.  
1074. *******************************************************************/  
1075. int Crypt3Des(int type,char* in,char* key,char* out)  
1076. {  
1077.   
1078.     int cryptmode,padmode,inlen,outlength,keylen,i;  
1079.     char cvec[10],instr[256],keystr[256],outstr[256],tmpstr[256];  
1080.     char* p,*q;  
1081.   
1082.     memset(cvec,0,sizeof(cvec));  
1083.     memset(instr,0,sizeof(instr));  
1084.     memset(outstr,0,sizeof(outstr));  
1085.     memset(keystr,0,sizeof(keystr));  
1086.     memset(tmpstr,0,sizeof(tmpstr));  
1087.   
1088.     MyDesInit(&cryptmode,&padmode,cvec);/*设置环境变量*/  
1089.     inlen=strlen(in);  
1090.   
1091.     if (in == 0 || in[0] == 0)  
1092.         return -7;  
1093.   
1094.     inlen = strlen(in);  
1095.   
1096.   
1097.     if (inlen % 8)  
1098.         return -8;  
1099.   
1100.     if (key == 0) return -9;  
1101.   
1102.     keylen=strlen(key);  
1103.     if (keylen!=48)  
1104.         return -1;  
1105.     for (i = 0; i < keylen; i++)  
1106.     {  
1107.         if ((key[i] >= '0' && key[i] <= '9') || (key[i] >= 'a' && key[i] <= 'f') || (key[i] >= 'A' && key[i] <= 'F'))  
1108.             continue;  
1109.         else  
1110.             return -10;  
1111.     }  
1112.     if (inlen>256)  
1113.         return 0;  
1114.     if (!CovertKey(key,keystr))  
1115.         return -2;  
1116.   
1117.     keylen=strlen(keystr);  
1118.   
1119.     if (type==ENCRYPT)  
1120.     {  
1121.   
1122.         if (!RunPad(padmode,in,strlen(in),instr,&inlen))  
1123.             return -3;  
1124.         if (!Run3Des(0,cryptmode,instr,inlen,keystr,(unsigned char)keylen,outstr,sizeof(outstr),cvec))  
1125.             return -4;  
1126.         outlength=strlen(outstr);  
1127.   
1128.         p=Base64Encode(outstr,outlength);  
1129.         if (p==NULL)  
1130.             return -6;  
1131.         strcpy(out,p);  
1132.         free(p);  
1133.         return 1;  
1134.     }  
1135.     else if (type==DECRYPT)  
1136.     {  
1137.         strcpy(tmpstr,in);  
1138.         q=Base64Decode(tmpstr);  
1139.         if (q==NULL)  
1140.             return -6;  
1141.         strcpy(instr,q);  
1142.         inlen=strlen(q);  
1143.         free(q);  
1144.   
1145.         if (!Run3Des(1,cryptmode,instr,inlen,keystr,(unsigned char)keylen,outstr,sizeof(outstr),cvec))  
1146.             return -4;  
1147.         RunRsm(outstr);  
1148.         strcpy(out,outstr);  
1149.     }  
1150.     else  
1151.         return -5;  
1152.   
1153.     return 1;  
1154. }  
1155.   
1156. unsigned char GetByte(char *s)  
1157. {  
1158.     int                v1;  
1159.     int                v2;  
1160.   
1161.     if (s[0] >= '0' && s[0] <= '9')  
1162.         v1 = s[0] - '0';  
1163.     else if (s[0] >= 'a' && s[0] <= 'f')  
1164.         v1 = s[0] - 'a' + 10;  
1165.     else  
1166.         v1 = s[0] - 'A' + 10;  
1167.   
1168.     if (s[1] >= '0' && s[1] <= '9')  
1169.         v2 = s[1] - '0';  
1170.     else if (s[1] >= 'a' && s[1] <= 'f')  
1171.         v2 = s[1] - 'a' + 10;  
1172.     else  
1173.         v2 = s[1] - 'A' + 10;  
1174.   
1175.     return (v1*16+v2);  
1176. }  
1177.   
1178. /************************************************************************ 
1179. //3DES 
1180. char FVin[16] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x38}; 
1181. char FVout[16] = {0}; 
1182. char FCvec[8] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37}; 
1183. unsigned char * p; 
1184. size_t iLen; 
1185.  
1186. //ECB加密 
1187. if (Run3Des(ENCRYPT, ECB, FVin, 16, Km[0], KEY_LEN_16, FVout, sizeof(FVout), NULL) == 1) { 
1188. RunRsm(FVout); 
1189. } 
1190.  
1191. //DES 
1192. if (Run1Des(ENCRYPT, ECB, FVin, 16, Km[0], KEY_LEN_8, FVout, sizeof(FVout), NULL) == 1) { 
1193. RunRsm(FVout); 
1194. } 
1195. ************************************************************************/  

 

2、3des.h

 

[cpp] view plaincopy

1. #ifndef _3DES__H_  
2. #define _3DES__H_  
3.   
4. #ifdef __cplusplus  
5. extern "C"  
6. {  
7. #endif  
8.   
9. #define ENCRYPT 0  
10. #define DECRYPT 1  
11.   
12. #define ECB 0  
13. #define CBC 1  
14.   
15. #define KEY_LEN_8 8  
16. #define KEY_LEN_16 16  
17. #define KEY_LEN_24 24  
18.   
19. #define PAD_ISO_1   0  
20. #define PAD_ISO_2   1  
21. #define PAD_PKCS_7  2  
22.   
23.     typedef char (*PSubKey)[16][48];  
24.   
25.     /*解密后,将填充的字符去掉*/  
26.     void RunRsm(char* Text);  
27.   
28.     /*将48位的明文密钥转换成24的字符串密钥*/  
29.     int CovertKey(char* iKey, char *oKey);  
30.   
31.     /******************************************************************* 
32.       函 数 名 称:  RunPad 
33.       功 能 描 述：  根据协议对加密前的数据进行填充 
34.       参 数 说 明：  bType   :类型：PAD类型 
35.                     In      :数据串指针 
36.                     Out     :填充输出串指针 
37.                     in_len  :数据的长度 
38.                     padlen  :(in,out)输出buffer的长度，填充后的长度 
39.  
40.       返回值 说明：   char    :是否填充成功 
41.     *******************************************************************/  
42.     int RunPad(int nType,const char* In,unsigned in_len,char* Out,int* padlen);  
43.   
44.     /******************************************************************* 
45.     函 数 名 称:    Run1Des 
46.     功 能 描 述：    执行单DES算法对文本加解密 
47.     参 数 说 明：    bType   :类型：加密ENCRYPT，解密DECRYPT 
48.                     bMode   :模式：ECB,CBC 
49.                     In      :待加密串指针 
50.                     in_len  :待加密串的长度，同时Out的缓冲区大小应大于或者等于in_len 
51.                     Key     :密钥(可为8位,16位,24位)支持3密钥 
52.                     key_len :密钥长度，多出24位部分将被自动裁减 
53.                     Out     :待输出串指针 
54.                     out_len :输出缓存大小 
55.                     cvecstr :8字节随即字符串 
56.  
57.     返回值 说明： int     :是否加密成功，1：成功，0：失败 
58.     *******************************************************************/  
59.     int Run1Des(int bType, int bMode, const char *In, unsigned int in_len, const char *Key, unsigned int key_len, char* Out, unsigned int out_len, const char cvecstr[8]);  
60.   
61.     /******************************************************************* 
62.       函 数 名 称:  Run3Des 
63.       功 能 描 述：  执行3DES算法对文本加解密 
64.       参 数 说 明：  bType   :类型：加密ENCRYPT，解密DECRYPT 
65.                     bMode   :模式：ECB,CBC 
66.                     In      :待加密串指针 
67.                     in_len  :待加密串的长度，同时Out的缓冲区大小应大于或者等于in_len 
68.                     Key     :密钥(可为8位,16位,24位)支持3密钥 
69.                     key_len :密钥长度，多出24位部分将被自动裁减 
70.                     Out     :待输出串指针 
71.                     out_len :输出缓存大小 
72.                     cvecstr :8字节随即字符串 
73.  
74.       返回值 说明：   int     :是否加密成功，1：成功，0：失败 
75.  
76.       作       者:    huangjf 
77.       更 新 日 期：  2009.6.17 
78.  
79.       3DES(加密) = DES(key1, 加密) DES(key2, 解密)  DES(key3, 加密) 
80.       3DES(解密) = DES(key3, 解密) DES(key2, 加密)  DES(key1, 解密) 
81.       每个KEY为64位，总共可以有192位的KEY, 但一般都只使用128位的key 
82.       如果只用128位密钥，则key3 = key1 
83.  
84.     *******************************************************************/  
85.     int Run3Des(int bType, int bMode, const char *In, unsigned int in_len, const char *Key, unsigned int key_len, char* Out, unsigned int out_len, const char cvecstr[8]);  
86.   
87.     /******************************************************************* 
88.     函 数 名 称:    Crypt3Des 
89.     功 能 描 述：    实现3DES的加解密 
90.     参 数 说 明：    type    :类型：加密ENCRYPT，解密DECRYPT 
91.                     in      :待加密串指针或者待解密的密码字符串指针 
92.                     Out     :加密后的密码或者解密后的明文 
93.                     Key     :密钥(48位的ASCII字符串) 
94.  
95.     返回值 说明： 
96.                     0:成功 
97.                     -1:非法的密钥长度 
98.                     -2:密钥含有非16进制字符 
99.                     -3:明文填充失败 
100.                     -4:加解密失败 
101.                     -5:非法的操作类型 
102.     *******************************************************************/  
103.     int Crypt3Des(int type,char* in,char* key,char* out);  
104.   
105.     char *Base64Encode(char *src, int srclen);  
106.     char *Base64Decode(char *src);  
107.     unsigned char GetByte(char *s);  
108.   
109. #ifdef __cplusplus  
110. }  
111. #endif  
112.   
113. #endif  

 

3、PBOC算法

 

[cpp] view plaincopy

1. /**************************************************************** 
2. * Subject : 取反 
3. * Input   : In  -- 输入数据 
4. *           in_len  -- 输入数据大小 
5. *           out_len -- 输出缓存大小 
6. *            
7. * OutPut  : Out  -- 输出缓存 
8. * Return  : -1  -- 失败 
9. *           =1  -- 成功 
10. * Remark  : 
11. ****************************************************************/  
12. static int Anti(const char *In, unsigned int in_len, char *Out, unsigned int out_len)  
13. {  
14.     unsigned int i;  
15.   
16.     if (!In || !Out) return -1;  
17.     if (out_len < in_len) return -1;  
18.   
19.     for (i=0; i<in_len; i++)  
20.     {  
21.         Out[i] = ~In[i]&0xFF;  
22.     }  
23.     return 1;  
24. }  
25.   
26.   
27. /**************************************************************** 
28. * Subject : PBOC算法分散会话密钥 
29. * Input   : Km  -- 主密钥 
30. *           km_len  -- 主密钥长度 
31. *           Seed -- 随机数 
32. *           seed_len -- 随机数长度 
33. *           out_len -- 输出缓存大小 
34. *            
35. * OutPut  : Out  -- 输出缓存 
36. * Return  : -1  -- 失败 
37. *           =1  -- 成功 
38. * Remark  : 
39. ****************************************************************/  
40. static int PBOC(const char *Km, unsigned int km_len, const char *Seed, unsigned int seed_len, char *Out, unsigned int out_len)  
41. {  
42.     char DK[16] = {0}, *DKL=&DK[0], *DKR=&DK[8];  
43.     char AntiSeed[8] = {0};  
44.   
45.     if (!Km || !Seed || !Out) return -1;  
46.     if (km_len != KEY_LEN_16) return -1;  
47.     if (seed_len != 8) return -1;  
48.     if (out_len < 16) return -1;  
49.   
50.     if (Anti(Seed, seed_len, AntiSeed, sizeof(AntiSeed)) != 1) return -1;  
51.   
52.     //3DES_ECB加密  
53.     if (Run3Des(ENCRYPT, ECB, Seed, seed_len, Km, km_len, DKL, 8, NULL) != 1) return -1;  
54.     if (Run3Des(ENCRYPT, ECB, AntiSeed, seed_len, Km, km_len, DKR, 8, NULL) != 1) return -1;  
55.   
56.     memcpy(Out, DK, 16);  
57.   
58.     return 1;  
59. }  

 

4、PBOC原理

 

分享到：