One-Way
爱一人,攀一山,追一梦
posts - 113,  comments - 13,  trackbacks - 0

3DES(或称为Triple DES),它相当于是对每个数据块应用三次DES加密算法。3*8字节密钥。

设Ek()和Dk()代表DES算法的加密和解密过程,K代表DES算法使用的密钥,P代表明文,C代表密文;

  3DES加密过程为:C=Ek3(Dk2(Ek1(P)))

  3DES解密过程为:P=Dk1((EK2(Dk3(C)))

补齐方式PKCS7

             k=8,l=数据长度

                      01 -- if l mod k = k-1
       02 02 -- if l mod k = k-2
                                .
                                .
                                .
             k k ... k k -- if l mod k = 0

 

想在数据库中直接对数据进行加密,考虑使用udf函数对数据加密,考虑效率使用c语言更好一些,创建c语言的udf。

将openssl源码中的3DES加解密的源代码摘出来,在linux下编译测试。测试成功,然后按照udf的规则重新组织就可以使用了。

$gcc -Wall -O2 -o des3_func des3_func.c  
  1 #include <stdio.h>
  2 #include <string.h>
  3 #include <stdlib.h>
  4 
  5 #define DES_LONG unsigned long
  6 #define LEN_OF_KEY 24
  7  
  8 #define ITERATIONS 16
  9 
 10 #define c2l(c,l)        (l =((DES_LONG)(*((c)++)))    , \
 11                          l|=((DES_LONG)(*((c)++)))<< 8L, \
 12                          l|=((DES_LONG)(*((c)++)))<<16L, \
 13                          l|=((DES_LONG)(*((c)++)))<<24L)
 14 
 15 
 16 #define l2c(l,c)        (*((c)++)=(unsigned char)(((l)     )&0xff), \
 17                          *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \
 18                          *((c)++)=(unsigned char)(((l)>>16L)&0xff), \
 19                          *((c)++)=(unsigned char)(((l)>>24L)&0xff))
 20 
 21 #define ROTATE(a,n)     (((a)>>(n))+((a)<<(32-(n))))
 22 
 23 #define LOAD_DATA_tmp(a,b,c,d,e,f) LOAD_DATA(a,b,c,d,e,f,g)
 24 #define LOAD_DATA(R,S,u,t,E0,E1,tmp) \
 25         u=R^s[S  ]; \
 26         t=R^s[S+1]
 27         
 28 #define D_ENCRYPT(LL,R,S) {\
 29         LOAD_DATA_tmp(R,S,u,t,E0,E1); \
 30         t=ROTATE(t,4); \
 31         LL^=\
 32                 DES_SPtrans[0][(u>> 2L)&0x3f]^ \
 33                 DES_SPtrans[2][(u>>10L)&0x3f]^ \
 34                 DES_SPtrans[4][(u>>18L)&0x3f]^ \
 35                 DES_SPtrans[6][(u>>26L)&0x3f]^ \
 36                 DES_SPtrans[1][(t>> 2L)&0x3f]^ \
 37                 DES_SPtrans[3][(t>>10L)&0x3f]^ \
 38                 DES_SPtrans[5][(t>>18L)&0x3f]^ \
 39                 DES_SPtrans[7][(t>>26L)&0x3f]; }
 40 
 41 #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
 42         (b)^=(t),\
 43         (a)^=((t)<<(n)))
 44 
 45 #define IP(l,r) \
 46         { \
 47         register DES_LONG tt; \
 48         PERM_OP(r,l,tt, 4,0x0f0f0f0fL); \
 49         PERM_OP(l,r,tt,16,0x0000ffffL); \
 50         PERM_OP(r,l,tt, 2,0x33333333L); \
 51         PERM_OP(l,r,tt, 8,0x00ff00ffL); \
 52         PERM_OP(r,l,tt, 1,0x55555555L); \
 53         }
 54 
 55 #define FP(l,r) \
 56         { \
 57         register DES_LONG tt; \
 58         PERM_OP(l,r,tt, 1,0x55555555L); \
 59         PERM_OP(r,l,tt, 8,0x00ff00ffL); \
 60         PERM_OP(l,r,tt, 2,0x33333333L); \
 61         PERM_OP(r,l,tt,16,0x0000ffffL); \
 62         PERM_OP(l,r,tt, 4,0x0f0f0f0fL); \
 63         }
 64 
 65 extern const DES_LONG DES_SPtrans[8][64];         
 66 
 67 
 68 #define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
 69         (a)=(a)^(t)^(t>>(16-(n))))
 70 
 71 static const DES_LONG des_skb[8][64] = {
 72     {
 73      /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
 74      0x00000000L, 0x00000010L, 0x20000000L, 0x20000010L,
 75      0x00010000L, 0x00010010L, 0x20010000L, 0x20010010L,
 76      0x00000800L, 0x00000810L, 0x20000800L, 0x20000810L,
 77      0x00010800L, 0x00010810L, 0x20010800L, 0x20010810L,
 78      0x00000020L, 0x00000030L, 0x20000020L, 0x20000030L,
 79      0x00010020L, 0x00010030L, 0x20010020L, 0x20010030L,
 80      0x00000820L, 0x00000830L, 0x20000820L, 0x20000830L,
 81      0x00010820L, 0x00010830L, 0x20010820L, 0x20010830L,
 82      0x00080000L, 0x00080010L, 0x20080000L, 0x20080010L,
 83      0x00090000L, 0x00090010L, 0x20090000L, 0x20090010L,
 84      0x00080800L, 0x00080810L, 0x20080800L, 0x20080810L,
 85      0x00090800L, 0x00090810L, 0x20090800L, 0x20090810L,
 86      0x00080020L, 0x00080030L, 0x20080020L, 0x20080030L,
 87      0x00090020L, 0x00090030L, 0x20090020L, 0x20090030L,
 88      0x00080820L, 0x00080830L, 0x20080820L, 0x20080830L,
 89      0x00090820L, 0x00090830L, 0x20090820L, 0x20090830L,
 90      },
 91     {
 92      /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
 93      0x00000000L, 0x02000000L, 0x00002000L, 0x02002000L,
 94      0x00200000L, 0x02200000L, 0x00202000L, 0x02202000L,
 95      0x00000004L, 0x02000004L, 0x00002004L, 0x02002004L,
 96      0x00200004L, 0x02200004L, 0x00202004L, 0x02202004L,
 97      0x00000400L, 0x02000400L, 0x00002400L, 0x02002400L,
 98      0x00200400L, 0x02200400L, 0x00202400L, 0x02202400L,
 99      0x00000404L, 0x02000404L, 0x00002404L, 0x02002404L,
100      0x00200404L, 0x02200404L, 0x00202404L, 0x02202404L,
101      0x10000000L, 0x12000000L, 0x10002000L, 0x12002000L,
102      0x10200000L, 0x12200000L, 0x10202000L, 0x12202000L,
103      0x10000004L, 0x12000004L, 0x10002004L, 0x12002004L,
104      0x10200004L, 0x12200004L, 0x10202004L, 0x12202004L,
105      0x10000400L, 0x12000400L, 0x10002400L, 0x12002400L,
106      0x10200400L, 0x12200400L, 0x10202400L, 0x12202400L,
107      0x10000404L, 0x12000404L, 0x10002404L, 0x12002404L,
108      0x10200404L, 0x12200404L, 0x10202404L, 0x12202404L,
109      },
110     {
111      /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
112      0x00000000L, 0x00000001L, 0x00040000L, 0x00040001L,
113      0x01000000L, 0x01000001L, 0x01040000L, 0x01040001L,
114      0x00000002L, 0x00000003L, 0x00040002L, 0x00040003L,
115      0x01000002L, 0x01000003L, 0x01040002L, 0x01040003L,
116      0x00000200L, 0x00000201L, 0x00040200L, 0x00040201L,
117      0x01000200L, 0x01000201L, 0x01040200L, 0x01040201L,
118      0x00000202L, 0x00000203L, 0x00040202L, 0x00040203L,
119      0x01000202L, 0x01000203L, 0x01040202L, 0x01040203L,
120      0x08000000L, 0x08000001L, 0x08040000L, 0x08040001L,
121      0x09000000L, 0x09000001L, 0x09040000L, 0x09040001L,
122      0x08000002L, 0x08000003L, 0x08040002L, 0x08040003L,
123      0x09000002L, 0x09000003L, 0x09040002L, 0x09040003L,
124      0x08000200L, 0x08000201L, 0x08040200L, 0x08040201L,
125      0x09000200L, 0x09000201L, 0x09040200L, 0x09040201L,
126      0x08000202L, 0x08000203L, 0x08040202L, 0x08040203L,
127      0x09000202L, 0x09000203L, 0x09040202L, 0x09040203L,
128      },
129     {
130      /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
131      0x00000000L, 0x00100000L, 0x00000100L, 0x00100100L,
132      0x00000008L, 0x00100008L, 0x00000108L, 0x00100108L,
133      0x00001000L, 0x00101000L, 0x00001100L, 0x00101100L,
134      0x00001008L, 0x00101008L, 0x00001108L, 0x00101108L,
135      0x04000000L, 0x04100000L, 0x04000100L, 0x04100100L,
136      0x04000008L, 0x04100008L, 0x04000108L, 0x04100108L,
137      0x04001000L, 0x04101000L, 0x04001100L, 0x04101100L,
138      0x04001008L, 0x04101008L, 0x04001108L, 0x04101108L,
139      0x00020000L, 0x00120000L, 0x00020100L, 0x00120100L,
140      0x00020008L, 0x00120008L, 0x00020108L, 0x00120108L,
141      0x00021000L, 0x00121000L, 0x00021100L, 0x00121100L,
142      0x00021008L, 0x00121008L, 0x00021108L, 0x00121108L,
143      0x04020000L, 0x04120000L, 0x04020100L, 0x04120100L,
144      0x04020008L, 0x04120008L, 0x04020108L, 0x04120108L,
145      0x04021000L, 0x04121000L, 0x04021100L, 0x04121100L,
146      0x04021008L, 0x04121008L, 0x04021108L, 0x04121108L,
147      },
148     {
149      /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
150      0x00000000L, 0x10000000L, 0x00010000L, 0x10010000L,
151      0x00000004L, 0x10000004L, 0x00010004L, 0x10010004L,
152      0x20000000L, 0x30000000L, 0x20010000L, 0x30010000L,
153      0x20000004L, 0x30000004L, 0x20010004L, 0x30010004L,
154      0x00100000L, 0x10100000L, 0x00110000L, 0x10110000L,
155      0x00100004L, 0x10100004L, 0x00110004L, 0x10110004L,
156      0x20100000L, 0x30100000L, 0x20110000L, 0x30110000L,
157      0x20100004L, 0x30100004L, 0x20110004L, 0x30110004L,
158      0x00001000L, 0x10001000L, 0x00011000L, 0x10011000L,
159      0x00001004L, 0x10001004L, 0x00011004L, 0x10011004L,
160      0x20001000L, 0x30001000L, 0x20011000L, 0x30011000L,
161      0x20001004L, 0x30001004L, 0x20011004L, 0x30011004L,
162      0x00101000L, 0x10101000L, 0x00111000L, 0x10111000L,
163      0x00101004L, 0x10101004L, 0x00111004L, 0x10111004L,
164      0x20101000L, 0x30101000L, 0x20111000L, 0x30111000L,
165      0x20101004L, 0x30101004L, 0x20111004L, 0x30111004L,
166      },
167     {
168      /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
169      0x00000000L, 0x08000000L, 0x00000008L, 0x08000008L,
170      0x00000400L, 0x08000400L, 0x00000408L, 0x08000408L,
171      0x00020000L, 0x08020000L, 0x00020008L, 0x08020008L,
172      0x00020400L, 0x08020400L, 0x00020408L, 0x08020408L,
173      0x00000001L, 0x08000001L, 0x00000009L, 0x08000009L,
174      0x00000401L, 0x08000401L, 0x00000409L, 0x08000409L,
175      0x00020001L, 0x08020001L, 0x00020009L, 0x08020009L,
176      0x00020401L, 0x08020401L, 0x00020409L, 0x08020409L,
177      0x02000000L, 0x0A000000L, 0x02000008L, 0x0A000008L,
178      0x02000400L, 0x0A000400L, 0x02000408L, 0x0A000408L,
179      0x02020000L, 0x0A020000L, 0x02020008L, 0x0A020008L,
180      0x02020400L, 0x0A020400L, 0x02020408L, 0x0A020408L,
181      0x02000001L, 0x0A000001L, 0x02000009L, 0x0A000009L,
182      0x02000401L, 0x0A000401L, 0x02000409L, 0x0A000409L,
183      0x02020001L, 0x0A020001L, 0x02020009L, 0x0A020009L,
184      0x02020401L, 0x0A020401L, 0x02020409L, 0x0A020409L,
185      },
186     {
187      /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
188      0x00000000L, 0x00000100L, 0x00080000L, 0x00080100L,
189      0x01000000L, 0x01000100L, 0x01080000L, 0x01080100L,
190      0x00000010L, 0x00000110L, 0x00080010L, 0x00080110L,
191      0x01000010L, 0x01000110L, 0x01080010L, 0x01080110L,
192      0x00200000L, 0x00200100L, 0x00280000L, 0x00280100L,
193      0x01200000L, 0x01200100L, 0x01280000L, 0x01280100L,
194      0x00200010L, 0x00200110L, 0x00280010L, 0x00280110L,
195      0x01200010L, 0x01200110L, 0x01280010L, 0x01280110L,
196      0x00000200L, 0x00000300L, 0x00080200L, 0x00080300L,
197      0x01000200L, 0x01000300L, 0x01080200L, 0x01080300L,
198      0x00000210L, 0x00000310L, 0x00080210L, 0x00080310L,
199      0x01000210L, 0x01000310L, 0x01080210L, 0x01080310L,
200      0x00200200L, 0x00200300L, 0x00280200L, 0x00280300L,
201      0x01200200L, 0x01200300L, 0x01280200L, 0x01280300L,
202      0x00200210L, 0x00200310L, 0x00280210L, 0x00280310L,
203      0x01200210L, 0x01200310L, 0x01280210L, 0x01280310L,
204      },
205     {
206      /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
207      0x00000000L, 0x04000000L, 0x00040000L, 0x04040000L,
208      0x00000002L, 0x04000002L, 0x00040002L, 0x04040002L,
209      0x00002000L, 0x04002000L, 0x00042000L, 0x04042000L,
210      0x00002002L, 0x04002002L, 0x00042002L, 0x04042002L,
211      0x00000020L, 0x04000020L, 0x00040020L, 0x04040020L,
212      0x00000022L, 0x04000022L, 0x00040022L, 0x04040022L,
213      0x00002020L, 0x04002020L, 0x00042020L, 0x04042020L,
214      0x00002022L, 0x04002022L, 0x00042022L, 0x04042022L,
215      0x00000800L, 0x04000800L, 0x00040800L, 0x04040800L,
216      0x00000802L, 0x04000802L, 0x00040802L, 0x04040802L,
217      0x00002800L, 0x04002800L, 0x00042800L, 0x04042800L,
218      0x00002802L, 0x04002802L, 0x00042802L, 0x04042802L,
219      0x00000820L, 0x04000820L, 0x00040820L, 0x04040820L,
220      0x00000822L, 0x04000822L, 0x00040822L, 0x04040822L,
221      0x00002820L, 0x04002820L, 0x00042820L, 0x04042820L,
222      0x00002822L, 0x04002822L, 0x00042822L, 0x04042822L,
223      }
224 };
225        
226 const DES_LONG DES_SPtrans[8][64] = {
227     {
228         /* nibble 0 */
229         0x02080800L, 0x00080000L, 0x02000002L, 0x02080802L,
230         0x02000000L, 0x00080802L, 0x00080002L, 0x02000002L,
231         0x00080802L, 0x02080800L, 0x02080000L, 0x00000802L,
232         0x02000802L, 0x02000000L, 0x00000000L, 0x00080002L,
233         0x00080000L, 0x00000002L, 0x02000800L, 0x00080800L,
234         0x02080802L, 0x02080000L, 0x00000802L, 0x02000800L,
235         0x00000002L, 0x00000800L, 0x00080800L, 0x02080002L,
236         0x00000800L, 0x02000802L, 0x02080002L, 0x00000000L,
237         0x00000000L, 0x02080802L, 0x02000800L, 0x00080002L,
238         0x02080800L, 0x00080000L, 0x00000802L, 0x02000800L,
239         0x02080002L, 0x00000800L, 0x00080800L, 0x02000002L,
240         0x00080802L, 0x00000002L, 0x02000002L, 0x02080000L,
241         0x02080802L, 0x00080800L, 0x02080000L, 0x02000802L,
242         0x02000000L, 0x00000802L, 0x00080002L, 0x00000000L,
243         0x00080000L, 0x02000000L, 0x02000802L, 0x02080800L,
244         0x00000002L, 0x02080002L, 0x00000800L, 0x00080802L,
245     },
246     {
247         /* nibble 1 */
248         0x40108010L, 0x00000000L, 0x00108000L, 0x40100000L,
249         0x40000010L, 0x00008010L, 0x40008000L, 0x00108000L,
250         0x00008000L, 0x40100010L, 0x00000010L, 0x40008000L,
251         0x00100010L, 0x40108000L, 0x40100000L, 0x00000010L,
252         0x00100000L, 0x40008010L, 0x40100010L, 0x00008000L,
253         0x00108010L, 0x40000000L, 0x00000000L, 0x00100010L,
254         0x40008010L, 0x00108010L, 0x40108000L, 0x40000010L,
255         0x40000000L, 0x00100000L, 0x00008010L, 0x40108010L,
256         0x00100010L, 0x40108000L, 0x40008000L, 0x00108010L,
257         0x40108010L, 0x00100010L, 0x40000010L, 0x00000000L,
258         0x40000000L, 0x00008010L, 0x00100000L, 0x40100010L,
259         0x00008000L, 0x40000000L, 0x00108010L, 0x40008010L,
260         0x40108000L, 0x00008000L, 0x00000000L, 0x40000010L,
261         0x00000010L, 0x40108010L, 0x00108000L, 0x40100000L,
262         0x40100010L, 0x00100000L, 0x00008010L, 0x40008000L,
263         0x40008010L, 0x00000010L, 0x40100000L, 0x00108000L,
264     },
265     {
266         /* nibble 2 */
267         0x04000001L, 0x04040100L, 0x00000100L, 0x04000101L,
268         0x00040001L, 0x04000000L, 0x04000101L, 0x00040100L,
269         0x04000100L, 0x00040000L, 0x04040000L, 0x00000001L,
270         0x04040101L, 0x00000101L, 0x00000001L, 0x04040001L,
271         0x00000000L, 0x00040001L, 0x04040100L, 0x00000100L,
272         0x00000101L, 0x04040101L, 0x00040000L, 0x04000001L,
273         0x04040001L, 0x04000100L, 0x00040101L, 0x04040000L,
274         0x00040100L, 0x00000000L, 0x04000000L, 0x00040101L,
275         0x04040100L, 0x00000100L, 0x00000001L, 0x00040000L,
276         0x00000101L, 0x00040001L, 0x04040000L, 0x04000101L,
277         0x00000000L, 0x04040100L, 0x00040100L, 0x04040001L,
278         0x00040001L, 0x04000000L, 0x04040101L, 0x00000001L,
279         0x00040101L, 0x04000001L, 0x04000000L, 0x04040101L,
280         0x00040000L, 0x04000100L, 0x04000101L, 0x00040100L,
281         0x04000100L, 0x00000000L, 0x04040001L, 0x00000101L,
282         0x04000001L, 0x00040101L, 0x00000100L, 0x04040000L,
283     },
284     {
285         /* nibble 3 */
286         0x00401008L, 0x10001000L, 0x00000008L, 0x10401008L,
287         0x00000000L, 0x10400000L, 0x10001008L, 0x00400008L,
288         0x10401000L, 0x10000008L, 0x10000000L, 0x00001008L,
289         0x10000008L, 0x00401008L, 0x00400000L, 0x10000000L,
290         0x10400008L, 0x00401000L, 0x00001000L, 0x00000008L,
291         0x00401000L, 0x10001008L, 0x10400000L, 0x00001000L,
292         0x00001008L, 0x00000000L, 0x00400008L, 0x10401000L,
293         0x10001000L, 0x10400008L, 0x10401008L, 0x00400000L,
294         0x10400008L, 0x00001008L, 0x00400000L, 0x10000008L,
295         0x00401000L, 0x10001000L, 0x00000008L, 0x10400000L,
296         0x10001008L, 0x00000000L, 0x00001000L, 0x00400008L,
297         0x00000000L, 0x10400008L, 0x10401000L, 0x00001000L,
298         0x10000000L, 0x10401008L, 0x00401008L, 0x00400000L,
299         0x10401008L, 0x00000008L, 0x10001000L, 0x00401008L,
300         0x00400008L, 0x00401000L, 0x10400000L, 0x10001008L,
301         0x00001008L, 0x10000000L, 0x10000008L, 0x10401000L,
302     },
303     {
304         /* nibble 4 */
305         0x08000000L, 0x00010000L, 0x00000400L, 0x08010420L,
306         0x08010020L, 0x08000400L, 0x00010420L, 0x08010000L,
307         0x00010000L, 0x00000020L, 0x08000020L, 0x00010400L,
308         0x08000420L, 0x08010020L, 0x08010400L, 0x00000000L,
309         0x00010400L, 0x08000000L, 0x00010020L, 0x00000420L,
310         0x08000400L, 0x00010420L, 0x00000000L, 0x08000020L,
311         0x00000020L, 0x08000420L, 0x08010420L, 0x00010020L,
312         0x08010000L, 0x00000400L, 0x00000420L, 0x08010400L,
313         0x08010400L, 0x08000420L, 0x00010020L, 0x08010000L,
314         0x00010000L, 0x00000020L, 0x08000020L, 0x08000400L,
315         0x08000000L, 0x00010400L, 0x08010420L, 0x00000000L,
316         0x00010420L, 0x08000000L, 0x00000400L, 0x00010020L,
317         0x08000420L, 0x00000400L, 0x00000000L, 0x08010420L,
318         0x08010020L, 0x08010400L, 0x00000420L, 0x00010000L,
319         0x00010400L, 0x08010020L, 0x08000400L, 0x00000420L,
320         0x00000020L, 0x00010420L, 0x08010000L, 0x08000020L,
321     },
322     {
323         /* nibble 5 */
324         0x80000040L, 0x00200040L, 0x00000000L, 0x80202000L,
325         0x00200040L, 0x00002000L, 0x80002040L, 0x00200000L,
326         0x00002040L, 0x80202040L, 0x00202000L, 0x80000000L,
327         0x80002000L, 0x80000040L, 0x80200000L, 0x00202040L,
328         0x00200000L, 0x80002040L, 0x80200040L, 0x00000000L,
329         0x00002000L, 0x00000040L, 0x80202000L, 0x80200040L,
330         0x80202040L, 0x80200000L, 0x80000000L, 0x00002040L,
331         0x00000040L, 0x00202000L, 0x00202040L, 0x80002000L,
332         0x00002040L, 0x80000000L, 0x80002000L, 0x00202040L,
333         0x80202000L, 0x00200040L, 0x00000000L, 0x80002000L,
334         0x80000000L, 0x00002000L, 0x80200040L, 0x00200000L,
335         0x00200040L, 0x80202040L, 0x00202000L, 0x00000040L,
336         0x80202040L, 0x00202000L, 0x00200000L, 0x80002040L,
337         0x80000040L, 0x80200000L, 0x00202040L, 0x00000000L,
338         0x00002000L, 0x80000040L, 0x80002040L, 0x80202000L,
339         0x80200000L, 0x00002040L, 0x00000040L, 0x80200040L,
340     },
341     {
342         /* nibble 6 */
343         0x00004000L, 0x00000200L, 0x01000200L, 0x01000004L,
344         0x01004204L, 0x00004004L, 0x00004200L, 0x00000000L,
345         0x01000000L, 0x01000204L, 0x00000204L, 0x01004000L,
346         0x00000004L, 0x01004200L, 0x01004000L, 0x00000204L,
347         0x01000204L, 0x00004000L, 0x00004004L, 0x01004204L,
348         0x00000000L, 0x01000200L, 0x01000004L, 0x00004200L,
349         0x01004004L, 0x00004204L, 0x01004200L, 0x00000004L,
350         0x00004204L, 0x01004004L, 0x00000200L, 0x01000000L,
351         0x00004204L, 0x01004000L, 0x01004004L, 0x00000204L,
352         0x00004000L, 0x00000200L, 0x01000000L, 0x01004004L,
353         0x01000204L, 0x00004204L, 0x00004200L, 0x00000000L,
354         0x00000200L, 0x01000004L, 0x00000004L, 0x01000200L,
355         0x00000000L, 0x01000204L, 0x01000200L, 0x00004200L,
356         0x00000204L, 0x00004000L, 0x01004204L, 0x01000000L,
357         0x01004200L, 0x00000004L, 0x00004004L, 0x01004204L,
358         0x01000004L, 0x01004200L, 0x01004000L, 0x00004004L,
359     },
360     {
361         /* nibble 7 */
362         0x20800080L, 0x20820000L, 0x00020080L, 0x00000000L,
363         0x20020000L, 0x00800080L, 0x20800000L, 0x20820080L,
364         0x00000080L, 0x20000000L, 0x00820000L, 0x00020080L,
365         0x00820080L, 0x20020080L, 0x20000080L, 0x20800000L,
366         0x00020000L, 0x00820080L, 0x00800080L, 0x20020000L,
367         0x20820080L, 0x20000080L, 0x00000000L, 0x00820000L,
368         0x20000000L, 0x00800000L, 0x20020080L, 0x20800080L,
369         0x00800000L, 0x00020000L, 0x20820000L, 0x00000080L,
370         0x00800000L, 0x00020000L, 0x20000080L, 0x20820080L,
371         0x00020080L, 0x20000000L, 0x00000000L, 0x00820000L,
372         0x20800080L, 0x20020080L, 0x20020000L, 0x00800080L,
373         0x20820000L, 0x00000080L, 0x00800080L, 0x20020000L,
374         0x20820080L, 0x00800000L, 0x20800000L, 0x20000080L,
375         0x00820000L, 0x00020080L, 0x20020080L, 0x20800000L,
376         0x00000080L, 0x20820000L, 0x00820080L, 0x00000000L,
377         0x20000000L, 0x20800080L, 0x00020000L, 0x00820080L,
378     }
379 };
380                 
381 
382 typedef unsigned char DES_cblock[8];
383 typedef /* const */ unsigned char const_DES_cblock[8];
384 
385 
386 typedef struct DES_ks {
387     union {
388         DES_cblock cblock;
389         /*
390          * make sure things are correct size on machines with 8 byte longs
391          */
392         DES_LONG deslong[2];
393     } ks[16];
394 } DES_key_schedule;
395 
396 
397 # define DES_ENCRYPT     1
398 # define DES_DECRYPT     0
399 
400 
401 
402 void DES_ecb3_encrypt(const_DES_cblock *input, DES_cblock *output,
403                       DES_key_schedule *ks1, DES_key_schedule *ks2,
404                       DES_key_schedule *ks3, int enc);
405 
406 
407 void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc);
408 
409 void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc);
410 
411 void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1,
412                   DES_key_schedule *ks2, DES_key_schedule *ks3);
413 void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1,
414                   DES_key_schedule *ks2, DES_key_schedule *ks3);
415                   
416 void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule);
417 
418 
419 
420 /************************************************************************
421  * 3DES-ECB加密方式
422  * 8字节密钥,加密内容8位补齐,补齐方式为:PKCS7。
423  *
424  * file: des3_func.c.c
425  * gcc -Wall -O2 -o des3_func des3_func.c 
426  *
427  * @author  Edward
428  *
429  ************************************************************************/
430 int main(int argc, char *argv[])
431 {
432     int i = 0;
433     int len = 0;
434     int nlen = 0;
435     int klen = 0;
436  
437     char ch = '\0';
438     char *k = "ABCDEFGHABCDEFGHABCDEFGH";
439     
440     char *data = "123456789ABCDEFG";  /* 原始明文 */
441     
442     unsigned char key[LEN_OF_KEY];
443     unsigned char src[64] = {0};
444     unsigned char out[64] = {0};
445     unsigned char tmp[64] = {0};
446  
447     unsigned char block[8] = {0};
448     DES_key_schedule ks1, ks2, ks3;
449  
450     /* 设置密码表 */
451     klen = strlen(k);
452     memcpy(key, k, klen);
453     memset(key + klen, 0x00, LEN_OF_KEY - klen); 
454     
455     
456     memcpy(block, key, sizeof(block));
457     DES_set_key_unchecked((const_DES_cblock *)block, &ks1);
458     
459     memcpy(block, key + 8, sizeof(block));
460     DES_set_key_unchecked((const_DES_cblock *)block, &ks2);
461  
462     memcpy(block, key + 16, sizeof(block));
463     DES_set_key_unchecked((const_DES_cblock *)block, &ks3);
464  
465     nlen = strlen(data);
466     memcpy(src, data, nlen);
467  
468     //len = (nlen / 8 + (nlen % 8 ? 1: 0)) * 8;
469     len = (nlen / 8 + 1) * 8;
470  
471     ch = 8 - nlen % 8;
472     //memset(src + nlen, ch, (8 - nlen % 8) % 8);
473      memset(src + nlen, ch, (8 - nlen % 8));
474  
475     for (i = 0; i < len; i += 8) {
476         DES_ecb3_encrypt((const_DES_cblock *)(src + i), (DES_cblock *)(out + i), &ks1, &ks2, &ks3, DES_ENCRYPT);
477     }
478  
479     printf("encrypted Hex:");
480     for (i = 0; i < len; i++) {
481         printf("%02X" , *(out + i));
482     }
483     printf("\n");
484  
485     for (i = 0; i < len; i += 8) {
486         DES_ecb3_encrypt((const_DES_cblock *)(out + i), (DES_cblock *)(tmp + i), &ks1, &ks2, &ks3, DES_DECRYPT);
487     }
488  
489     printf("decrypted Hex:");
490     for (i = 0; i < len; i++) {
491         printf("%02X", *(tmp + i));
492     }
493     printf("\n");
494     printf("decrypted Bin:");
495     for (i = 0; i < len; i++) {
496         printf("%c", *(tmp + i));
497     }
498     printf("\n");
499  
500     return 0;
501 }
502 
503 
504 void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule)
505 {
506     static const int shifts2[16] =
507         { 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0 };
508     register DES_LONG c, d, t, s, t2;
509     register const unsigned char *in;
510     register DES_LONG *k;
511     register int i;
512 
513 
514     k = &schedule->ks->deslong[0];
515     in = &(*key)[0];
516 
517     c2l(in, c);
518     c2l(in, d);
519 
520     /*
521      * do PC1 in 47 simple operations :-) Thanks to John Fletcher
522      * (john_fletcher@lccmail.ocf.llnl.gov) for the inspiration. :-)
523      */
524     PERM_OP(d, c, t, 4, 0x0f0f0f0fL);
525     HPERM_OP(c, t, -2, 0xcccc0000L);
526     HPERM_OP(d, t, -2, 0xcccc0000L);
527     PERM_OP(d, c, t, 1, 0x55555555L);
528     PERM_OP(c, d, t, 8, 0x00ff00ffL);
529     PERM_OP(d, c, t, 1, 0x55555555L);
530     d = (((d & 0x000000ffL) << 16L) | (d & 0x0000ff00L) |
531          ((d & 0x00ff0000L) >> 16L) | ((c & 0xf0000000L) >> 4L));
532     c &= 0x0fffffffL;
533 
534     for (i = 0; i < ITERATIONS; i++) {
535         if (shifts2[i]) {
536             c = ((c >> 2L) | (c << 26L));
537             d = ((d >> 2L) | (d << 26L));
538         } else {
539             c = ((c >> 1L) | (c << 27L));
540             d = ((d >> 1L) | (d << 27L));
541         }
542         c &= 0x0fffffffL;
543         d &= 0x0fffffffL;
544         /*
545          * could be a few less shifts but I am to lazy at this point in time
546          * to investigate
547          */
548         s = des_skb[0][(c) & 0x3f] |
549             des_skb[1][((c >> 6L) & 0x03) | ((c >> 7L) & 0x3c)] |
550             des_skb[2][((c >> 13L) & 0x0f) | ((c >> 14L) & 0x30)] |
551             des_skb[3][((c >> 20L) & 0x01) | ((c >> 21L) & 0x06) |
552                        ((c >> 22L) & 0x38)];
553         t = des_skb[4][(d) & 0x3f] |
554             des_skb[5][((d >> 7L) & 0x03) | ((d >> 8L) & 0x3c)] |
555             des_skb[6][(d >> 15L) & 0x3f] |
556             des_skb[7][((d >> 21L) & 0x0f) | ((d >> 22L) & 0x30)];
557 
558         /* table contained 0213 4657 */
559         t2 = ((t << 16L) | (s & 0x0000ffffL)) & 0xffffffffL;
560         *(k++) = ROTATE(t2, 30) & 0xffffffffL;
561 
562         t2 = ((s >> 16L) | (t & 0xffff0000L));
563         *(k++) = ROTATE(t2, 26) & 0xffffffffL;
564     }
565 }
566 
567 
568 void DES_ecb3_encrypt(const_DES_cblock *input, DES_cblock *output,
569                       DES_key_schedule *ks1, DES_key_schedule *ks2,
570                       DES_key_schedule *ks3, int enc)
571 {
572     register DES_LONG l0, l1;
573     DES_LONG ll[2];
574     const unsigned char *in = &(*input)[0];
575     unsigned char *out = &(*output)[0];
576 
577     c2l(in, l0);
578     c2l(in, l1);
579     ll[0] = l0;
580     ll[1] = l1;
581     
582     if (enc)
583         DES_encrypt3(ll, ks1, ks2, ks3);
584     else
585         DES_decrypt3(ll, ks1, ks2, ks3);
586     l0 = ll[0];
587     l1 = ll[1];
588     l2c(l0, out);
589     l2c(l1, out);
590 }
591 
592 
593 void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc)
594 {
595     register DES_LONG l, r, t, u;
596     /*
597 #ifdef DES_PTR
598     register const unsigned char *des_SP = (const unsigned char *)DES_SPtrans;
599 #endif
600 #ifndef DES_UNROLL
601     
602 #endif*/
603     register int i;
604     register DES_LONG *s;
605 
606     r = data[0];
607     l = data[1];
608 
609     IP(r, l);
610     /*
611      * Things have been modified so that the initial rotate is done outside
612      * the loop.  This required the DES_SPtrans values in sp.h to be rotated
613      * 1 bit to the right. One perl script later and things have a 5% speed
614      * up on a sparc2. Thanks to Richard Outerbridge
615      * <71755.204@CompuServe.COM> for pointing this out.
616      */
617     /* clear the top bits on machines with 8byte longs */
618     /* shift left by 2 */
619     r = ROTATE(r, 29) & 0xffffffffL;
620     l = ROTATE(l, 29) & 0xffffffffL;
621 
622     s = ks->ks->deslong;
623     /*
624      * I don't know if it is worth the effort of loop unrolling the inner
625      * loop
626      */
627     if (enc) {
628 
629         for (i = 0; i < 32; i += 4) {
630             D_ENCRYPT(l, r, i + 0); /* 1 */
631             D_ENCRYPT(r, l, i + 2); /* 2 */
632         }
633     } else {
634 
635         for (i = 30; i > 0; i -= 4) {
636             D_ENCRYPT(l, r, i - 0); /* 16 */
637             D_ENCRYPT(r, l, i - 2); /* 15 */
638         }
639     }
640 
641     /* rotate and clear the top bits on machines with 8byte longs */
642     l = ROTATE(l, 3) & 0xffffffffL;
643     r = ROTATE(r, 3) & 0xffffffffL;
644 
645     FP(r, l);
646     data[0] = l;
647     data[1] = r;
648     l = r = t = u = 0;
649 }
650 
651 void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc)
652 {
653     register DES_LONG l, r, t, u;
654     /*
655 #ifdef DES_PTR
656     register const unsigned char *des_SP = (const unsigned char *)DES_SPtrans;
657 #endif
658 #ifndef DES_UNROLL
659     register int i;
660 #endif*/
661     register int i;
662     register DES_LONG *s;
663 
664     r = data[0];
665     l = data[1];
666 
667     /*
668      * Things have been modified so that the initial rotate is done outside
669      * the loop.  This required the DES_SPtrans values in sp.h to be rotated
670      * 1 bit to the right. One perl script later and things have a 5% speed
671      * up on a sparc2. Thanks to Richard Outerbridge
672      * <71755.204@CompuServe.COM> for pointing this out.
673      */
674     /* clear the top bits on machines with 8byte longs */
675     r = ROTATE(r, 29) & 0xffffffffL;
676     l = ROTATE(l, 29) & 0xffffffffL;
677 
678     s = ks->ks->deslong;
679     /*
680      * I don't know if it is worth the effort of loop unrolling the inner
681      * loop
682      */
683     if (enc) {
684 
685         for (i = 0; i < 32; i += 4) {
686             D_ENCRYPT(l, r, i + 0); /* 1 */
687             D_ENCRYPT(r, l, i + 2); /* 2 */
688         }
689         
690     } else {
691 
692         for (i = 30; i > 0; i -= 4) {
693             D_ENCRYPT(l, r, i - 0); /* 16 */
694             D_ENCRYPT(r, l, i - 2); /* 15 */
695         }
696 
697     }
698     /* rotate and clear the top bits on machines with 8byte longs */
699     data[0] = ROTATE(l, 3) & 0xffffffffL;
700     data[1] = ROTATE(r, 3) & 0xffffffffL;
701     l = r = t = u = 0;
702 }
703 
704 void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1,
705                   DES_key_schedule *ks2, DES_key_schedule *ks3)
706 {
707     register DES_LONG l, r;
708 
709     l = data[0];
710     r = data[1];
711     IP(l, r);
712     data[0] = l;
713     data[1] = r;
714     DES_encrypt2((DES_LONG *)data, ks1, DES_ENCRYPT);
715     DES_encrypt2((DES_LONG *)data, ks2, DES_DECRYPT);
716     DES_encrypt2((DES_LONG *)data, ks3, DES_ENCRYPT);
717     l = data[0];
718     r = data[1];
719     FP(r, l);
720     data[0] = l;
721     data[1] = r;
722 }
723 
724 void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1,
725                   DES_key_schedule *ks2, DES_key_schedule *ks3)
726 {
727     register DES_LONG l, r;
728 
729     l = data[0];
730     r = data[1];
731     IP(l, r);
732     data[0] = l;
733     data[1] = r;
734     DES_encrypt2((DES_LONG *)data, ks3, DES_DECRYPT);
735     DES_encrypt2((DES_LONG *)data, ks2, DES_ENCRYPT);
736     DES_encrypt2((DES_LONG *)data, ks1, DES_DECRYPT);
737     l = data[0];
738     r = data[1];
739     FP(r, l);
740     data[0] = l;
741     data[1] = r;
742 }

 

posted on 2016-07-05 15:21  单行道|  阅读(7151)  评论(1编辑  收藏