34 #if defined(POLARSSL_DES_C)
38 #if !defined(POLARSSL_DES_ALT)
41 static void polarssl_zeroize(
void *v,
size_t n ) {
42 volatile unsigned char *p = v;
while( n-- ) *p++ = 0;
49 #define GET_UINT32_BE(n,b,i) \
51 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
52 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
53 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
54 | ( (uint32_t) (b)[(i) + 3] ); \
59 #define PUT_UINT32_BE(n,b,i) \
61 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
62 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
63 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
64 (b)[(i) + 3] = (unsigned char) ( (n) ); \
71 static const uint32_t SB1[64] =
73 0x01010400, 0x00000000, 0x00010000, 0x01010404,
74 0x01010004, 0x00010404, 0x00000004, 0x00010000,
75 0x00000400, 0x01010400, 0x01010404, 0x00000400,
76 0x01000404, 0x01010004, 0x01000000, 0x00000004,
77 0x00000404, 0x01000400, 0x01000400, 0x00010400,
78 0x00010400, 0x01010000, 0x01010000, 0x01000404,
79 0x00010004, 0x01000004, 0x01000004, 0x00010004,
80 0x00000000, 0x00000404, 0x00010404, 0x01000000,
81 0x00010000, 0x01010404, 0x00000004, 0x01010000,
82 0x01010400, 0x01000000, 0x01000000, 0x00000400,
83 0x01010004, 0x00010000, 0x00010400, 0x01000004,
84 0x00000400, 0x00000004, 0x01000404, 0x00010404,
85 0x01010404, 0x00010004, 0x01010000, 0x01000404,
86 0x01000004, 0x00000404, 0x00010404, 0x01010400,
87 0x00000404, 0x01000400, 0x01000400, 0x00000000,
88 0x00010004, 0x00010400, 0x00000000, 0x01010004
91 static const uint32_t SB2[64] =
93 0x80108020, 0x80008000, 0x00008000, 0x00108020,
94 0x00100000, 0x00000020, 0x80100020, 0x80008020,
95 0x80000020, 0x80108020, 0x80108000, 0x80000000,
96 0x80008000, 0x00100000, 0x00000020, 0x80100020,
97 0x00108000, 0x00100020, 0x80008020, 0x00000000,
98 0x80000000, 0x00008000, 0x00108020, 0x80100000,
99 0x00100020, 0x80000020, 0x00000000, 0x00108000,
100 0x00008020, 0x80108000, 0x80100000, 0x00008020,
101 0x00000000, 0x00108020, 0x80100020, 0x00100000,
102 0x80008020, 0x80100000, 0x80108000, 0x00008000,
103 0x80100000, 0x80008000, 0x00000020, 0x80108020,
104 0x00108020, 0x00000020, 0x00008000, 0x80000000,
105 0x00008020, 0x80108000, 0x00100000, 0x80000020,
106 0x00100020, 0x80008020, 0x80000020, 0x00100020,
107 0x00108000, 0x00000000, 0x80008000, 0x00008020,
108 0x80000000, 0x80100020, 0x80108020, 0x00108000
111 static const uint32_t SB3[64] =
113 0x00000208, 0x08020200, 0x00000000, 0x08020008,
114 0x08000200, 0x00000000, 0x00020208, 0x08000200,
115 0x00020008, 0x08000008, 0x08000008, 0x00020000,
116 0x08020208, 0x00020008, 0x08020000, 0x00000208,
117 0x08000000, 0x00000008, 0x08020200, 0x00000200,
118 0x00020200, 0x08020000, 0x08020008, 0x00020208,
119 0x08000208, 0x00020200, 0x00020000, 0x08000208,
120 0x00000008, 0x08020208, 0x00000200, 0x08000000,
121 0x08020200, 0x08000000, 0x00020008, 0x00000208,
122 0x00020000, 0x08020200, 0x08000200, 0x00000000,
123 0x00000200, 0x00020008, 0x08020208, 0x08000200,
124 0x08000008, 0x00000200, 0x00000000, 0x08020008,
125 0x08000208, 0x00020000, 0x08000000, 0x08020208,
126 0x00000008, 0x00020208, 0x00020200, 0x08000008,
127 0x08020000, 0x08000208, 0x00000208, 0x08020000,
128 0x00020208, 0x00000008, 0x08020008, 0x00020200
131 static const uint32_t SB4[64] =
133 0x00802001, 0x00002081, 0x00002081, 0x00000080,
134 0x00802080, 0x00800081, 0x00800001, 0x00002001,
135 0x00000000, 0x00802000, 0x00802000, 0x00802081,
136 0x00000081, 0x00000000, 0x00800080, 0x00800001,
137 0x00000001, 0x00002000, 0x00800000, 0x00802001,
138 0x00000080, 0x00800000, 0x00002001, 0x00002080,
139 0x00800081, 0x00000001, 0x00002080, 0x00800080,
140 0x00002000, 0x00802080, 0x00802081, 0x00000081,
141 0x00800080, 0x00800001, 0x00802000, 0x00802081,
142 0x00000081, 0x00000000, 0x00000000, 0x00802000,
143 0x00002080, 0x00800080, 0x00800081, 0x00000001,
144 0x00802001, 0x00002081, 0x00002081, 0x00000080,
145 0x00802081, 0x00000081, 0x00000001, 0x00002000,
146 0x00800001, 0x00002001, 0x00802080, 0x00800081,
147 0x00002001, 0x00002080, 0x00800000, 0x00802001,
148 0x00000080, 0x00800000, 0x00002000, 0x00802080
151 static const uint32_t SB5[64] =
153 0x00000100, 0x02080100, 0x02080000, 0x42000100,
154 0x00080000, 0x00000100, 0x40000000, 0x02080000,
155 0x40080100, 0x00080000, 0x02000100, 0x40080100,
156 0x42000100, 0x42080000, 0x00080100, 0x40000000,
157 0x02000000, 0x40080000, 0x40080000, 0x00000000,
158 0x40000100, 0x42080100, 0x42080100, 0x02000100,
159 0x42080000, 0x40000100, 0x00000000, 0x42000000,
160 0x02080100, 0x02000000, 0x42000000, 0x00080100,
161 0x00080000, 0x42000100, 0x00000100, 0x02000000,
162 0x40000000, 0x02080000, 0x42000100, 0x40080100,
163 0x02000100, 0x40000000, 0x42080000, 0x02080100,
164 0x40080100, 0x00000100, 0x02000000, 0x42080000,
165 0x42080100, 0x00080100, 0x42000000, 0x42080100,
166 0x02080000, 0x00000000, 0x40080000, 0x42000000,
167 0x00080100, 0x02000100, 0x40000100, 0x00080000,
168 0x00000000, 0x40080000, 0x02080100, 0x40000100
171 static const uint32_t SB6[64] =
173 0x20000010, 0x20400000, 0x00004000, 0x20404010,
174 0x20400000, 0x00000010, 0x20404010, 0x00400000,
175 0x20004000, 0x00404010, 0x00400000, 0x20000010,
176 0x00400010, 0x20004000, 0x20000000, 0x00004010,
177 0x00000000, 0x00400010, 0x20004010, 0x00004000,
178 0x00404000, 0x20004010, 0x00000010, 0x20400010,
179 0x20400010, 0x00000000, 0x00404010, 0x20404000,
180 0x00004010, 0x00404000, 0x20404000, 0x20000000,
181 0x20004000, 0x00000010, 0x20400010, 0x00404000,
182 0x20404010, 0x00400000, 0x00004010, 0x20000010,
183 0x00400000, 0x20004000, 0x20000000, 0x00004010,
184 0x20000010, 0x20404010, 0x00404000, 0x20400000,
185 0x00404010, 0x20404000, 0x00000000, 0x20400010,
186 0x00000010, 0x00004000, 0x20400000, 0x00404010,
187 0x00004000, 0x00400010, 0x20004010, 0x00000000,
188 0x20404000, 0x20000000, 0x00400010, 0x20004010
191 static const uint32_t SB7[64] =
193 0x00200000, 0x04200002, 0x04000802, 0x00000000,
194 0x00000800, 0x04000802, 0x00200802, 0x04200800,
195 0x04200802, 0x00200000, 0x00000000, 0x04000002,
196 0x00000002, 0x04000000, 0x04200002, 0x00000802,
197 0x04000800, 0x00200802, 0x00200002, 0x04000800,
198 0x04000002, 0x04200000, 0x04200800, 0x00200002,
199 0x04200000, 0x00000800, 0x00000802, 0x04200802,
200 0x00200800, 0x00000002, 0x04000000, 0x00200800,
201 0x04000000, 0x00200800, 0x00200000, 0x04000802,
202 0x04000802, 0x04200002, 0x04200002, 0x00000002,
203 0x00200002, 0x04000000, 0x04000800, 0x00200000,
204 0x04200800, 0x00000802, 0x00200802, 0x04200800,
205 0x00000802, 0x04000002, 0x04200802, 0x04200000,
206 0x00200800, 0x00000000, 0x00000002, 0x04200802,
207 0x00000000, 0x00200802, 0x04200000, 0x00000800,
208 0x04000002, 0x04000800, 0x00000800, 0x00200002
211 static const uint32_t SB8[64] =
213 0x10001040, 0x00001000, 0x00040000, 0x10041040,
214 0x10000000, 0x10001040, 0x00000040, 0x10000000,
215 0x00040040, 0x10040000, 0x10041040, 0x00041000,
216 0x10041000, 0x00041040, 0x00001000, 0x00000040,
217 0x10040000, 0x10000040, 0x10001000, 0x00001040,
218 0x00041000, 0x00040040, 0x10040040, 0x10041000,
219 0x00001040, 0x00000000, 0x00000000, 0x10040040,
220 0x10000040, 0x10001000, 0x00041040, 0x00040000,
221 0x00041040, 0x00040000, 0x10041000, 0x00001000,
222 0x00000040, 0x10040040, 0x00001000, 0x00041040,
223 0x10001000, 0x00000040, 0x10000040, 0x10040000,
224 0x10040040, 0x10000000, 0x00040000, 0x10001040,
225 0x00000000, 0x10041040, 0x00040040, 0x10000040,
226 0x10040000, 0x10001000, 0x10001040, 0x00000000,
227 0x10041040, 0x00041000, 0x00041000, 0x00001040,
228 0x00001040, 0x00040040, 0x10000000, 0x10041000
234 static const uint32_t LHs[16] =
236 0x00000000, 0x00000001, 0x00000100, 0x00000101,
237 0x00010000, 0x00010001, 0x00010100, 0x00010101,
238 0x01000000, 0x01000001, 0x01000100, 0x01000101,
239 0x01010000, 0x01010001, 0x01010100, 0x01010101
242 static const uint32_t RHs[16] =
244 0x00000000, 0x01000000, 0x00010000, 0x01010000,
245 0x00000100, 0x01000100, 0x00010100, 0x01010100,
246 0x00000001, 0x01000001, 0x00010001, 0x01010001,
247 0x00000101, 0x01000101, 0x00010101, 0x01010101,
253 #define DES_IP(X,Y) \
255 T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \
256 T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \
257 T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \
258 T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \
259 Y = ((Y << 1) | (Y >> 31)) & 0xFFFFFFFF; \
260 T = (X ^ Y) & 0xAAAAAAAA; Y ^= T; X ^= T; \
261 X = ((X << 1) | (X >> 31)) & 0xFFFFFFFF; \
267 #define DES_FP(X,Y) \
269 X = ((X << 31) | (X >> 1)) & 0xFFFFFFFF; \
270 T = (X ^ Y) & 0xAAAAAAAA; X ^= T; Y ^= T; \
271 Y = ((Y << 31) | (Y >> 1)) & 0xFFFFFFFF; \
272 T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \
273 T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \
274 T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \
275 T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \
281 #define DES_ROUND(X,Y) \
284 Y ^= SB8[ (T ) & 0x3F ] ^ \
285 SB6[ (T >> 8) & 0x3F ] ^ \
286 SB4[ (T >> 16) & 0x3F ] ^ \
287 SB2[ (T >> 24) & 0x3F ]; \
289 T = *SK++ ^ ((X << 28) | (X >> 4)); \
290 Y ^= SB7[ (T ) & 0x3F ] ^ \
291 SB5[ (T >> 8) & 0x3F ] ^ \
292 SB3[ (T >> 16) & 0x3F ] ^ \
293 SB1[ (T >> 24) & 0x3F ]; \
296 #define SWAP(a,b) { uint32_t t = a; a = b; b = t; t = 0; }
298 static const unsigned char odd_parity_table[128] = { 1, 2, 4, 7, 8,
299 11, 13, 14, 16, 19, 21, 22, 25, 26, 28, 31, 32, 35, 37, 38, 41, 42, 44,
300 47, 49, 50, 52, 55, 56, 59, 61, 62, 64, 67, 69, 70, 73, 74, 76, 79, 81,
301 82, 84, 87, 88, 91, 93, 94, 97, 98, 100, 103, 104, 107, 109, 110, 112,
302 115, 117, 118, 121, 122, 124, 127, 128, 131, 133, 134, 137, 138, 140,
303 143, 145, 146, 148, 151, 152, 155, 157, 158, 161, 162, 164, 167, 168,
304 171, 173, 174, 176, 179, 181, 182, 185, 186, 188, 191, 193, 194, 196,
305 199, 200, 203, 205, 206, 208, 211, 213, 214, 217, 218, 220, 223, 224,
306 227, 229, 230, 233, 234, 236, 239, 241, 242, 244, 247, 248, 251, 253,
314 key[i] = odd_parity_table[key[i] / 2];
325 if ( key[i] != odd_parity_table[key[i] / 2] )
352 #define WEAK_KEY_COUNT 16
354 static const unsigned char weak_key_table[WEAK_KEY_COUNT][
DES_KEY_SIZE] =
356 { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
357 { 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE },
358 { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E },
359 { 0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1 },
361 { 0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E },
362 { 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01 },
363 { 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1 },
364 { 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01 },
365 { 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE },
366 { 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01 },
367 { 0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1 },
368 { 0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E },
369 { 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE },
370 { 0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E },
371 { 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE },
372 { 0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1 }
379 for( i = 0; i < WEAK_KEY_COUNT; i++ )
380 if( memcmp( weak_key_table[i], key, DES_KEY_SIZE) == 0)
386 static void des_setkey( uint32_t SK[32],
const unsigned char key[DES_KEY_SIZE] )
391 GET_UINT32_BE( X, key, 0 );
392 GET_UINT32_BE( Y, key, 4 );
397 T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4);
398 T = ((Y ) ^ X) & 0x10101010; X ^= T; Y ^= (T );
400 X = (LHs[ (X ) & 0xF] << 3) | (LHs[ (X >> 8) & 0xF ] << 2)
401 | (LHs[ (X >> 16) & 0xF] << 1) | (LHs[ (X >> 24) & 0xF ] )
402 | (LHs[ (X >> 5) & 0xF] << 7) | (LHs[ (X >> 13) & 0xF ] << 6)
403 | (LHs[ (X >> 21) & 0xF] << 5) | (LHs[ (X >> 29) & 0xF ] << 4);
405 Y = (RHs[ (Y >> 1) & 0xF] << 3) | (RHs[ (Y >> 9) & 0xF ] << 2)
406 | (RHs[ (Y >> 17) & 0xF] << 1) | (RHs[ (Y >> 25) & 0xF ] )
407 | (RHs[ (Y >> 4) & 0xF] << 7) | (RHs[ (Y >> 12) & 0xF ] << 6)
408 | (RHs[ (Y >> 20) & 0xF] << 5) | (RHs[ (Y >> 28) & 0xF ] << 4);
416 for( i = 0; i < 16; i++ )
418 if( i < 2 || i == 8 || i == 15 )
420 X = ((X << 1) | (X >> 27)) & 0x0FFFFFFF;
421 Y = ((Y << 1) | (Y >> 27)) & 0x0FFFFFFF;
425 X = ((X << 2) | (X >> 26)) & 0x0FFFFFFF;
426 Y = ((Y << 2) | (Y >> 26)) & 0x0FFFFFFF;
429 *SK++ = ((X << 4) & 0x24000000) | ((X << 28) & 0x10000000)
430 | ((X << 14) & 0x08000000) | ((X << 18) & 0x02080000)
431 | ((X << 6) & 0x01000000) | ((X << 9) & 0x00200000)
432 | ((X >> 1) & 0x00100000) | ((X << 10) & 0x00040000)
433 | ((X << 2) & 0x00020000) | ((X >> 10) & 0x00010000)
434 | ((Y >> 13) & 0x00002000) | ((Y >> 4) & 0x00001000)
435 | ((Y << 6) & 0x00000800) | ((Y >> 1) & 0x00000400)
436 | ((Y >> 14) & 0x00000200) | ((Y ) & 0x00000100)
437 | ((Y >> 5) & 0x00000020) | ((Y >> 10) & 0x00000010)
438 | ((Y >> 3) & 0x00000008) | ((Y >> 18) & 0x00000004)
439 | ((Y >> 26) & 0x00000002) | ((Y >> 24) & 0x00000001);
441 *SK++ = ((X << 15) & 0x20000000) | ((X << 17) & 0x10000000)
442 | ((X << 10) & 0x08000000) | ((X << 22) & 0x04000000)
443 | ((X >> 2) & 0x02000000) | ((X << 1) & 0x01000000)
444 | ((X << 16) & 0x00200000) | ((X << 11) & 0x00100000)
445 | ((X << 3) & 0x00080000) | ((X >> 6) & 0x00040000)
446 | ((X << 15) & 0x00020000) | ((X >> 4) & 0x00010000)
447 | ((Y >> 2) & 0x00002000) | ((Y << 8) & 0x00001000)
448 | ((Y >> 14) & 0x00000808) | ((Y >> 9) & 0x00000400)
449 | ((Y ) & 0x00000200) | ((Y << 7) & 0x00000100)
450 | ((Y >> 7) & 0x00000020) | ((Y >> 3) & 0x00000011)
451 | ((Y << 2) & 0x00000004) | ((Y >> 21) & 0x00000002);
460 des_setkey( ctx->
sk, key );
472 des_setkey( ctx->
sk, key );
474 for( i = 0; i < 16; i += 2 )
476 SWAP( ctx->
sk[i ], ctx->
sk[30 - i] );
477 SWAP( ctx->
sk[i + 1], ctx->
sk[31 - i] );
483 static void des3_set2key( uint32_t esk[96],
485 const unsigned char key[DES_KEY_SIZE*2] )
489 des_setkey( esk, key );
490 des_setkey( dsk + 32, key + 8 );
492 for( i = 0; i < 32; i += 2 )
494 dsk[i ] = esk[30 - i];
495 dsk[i + 1] = esk[31 - i];
497 esk[i + 32] = dsk[62 - i];
498 esk[i + 33] = dsk[63 - i];
500 esk[i + 64] = esk[i ];
501 esk[i + 65] = esk[i + 1];
503 dsk[i + 64] = dsk[i ];
504 dsk[i + 65] = dsk[i + 1];
515 des3_set2key( ctx->
sk, sk, key );
516 polarssl_zeroize( sk,
sizeof( sk ) );
528 des3_set2key( sk, ctx->
sk, key );
529 polarssl_zeroize( sk,
sizeof( sk ) );
534 static void des3_set3key( uint32_t esk[96],
536 const unsigned char key[24] )
540 des_setkey( esk, key );
541 des_setkey( dsk + 32, key + 8 );
542 des_setkey( esk + 64, key + 16 );
544 for( i = 0; i < 32; i += 2 )
546 dsk[i ] = esk[94 - i];
547 dsk[i + 1] = esk[95 - i];
549 esk[i + 32] = dsk[62 - i];
550 esk[i + 33] = dsk[63 - i];
552 dsk[i + 64] = esk[30 - i];
553 dsk[i + 65] = esk[31 - i];
564 des3_set3key( ctx->
sk, sk, key );
565 polarssl_zeroize( sk,
sizeof( sk ) );
577 des3_set3key( sk, ctx->
sk, key );
578 polarssl_zeroize( sk,
sizeof( sk ) );
587 const unsigned char input[8],
588 unsigned char output[8] )
591 uint32_t X, Y, T, *SK;
595 GET_UINT32_BE( X, input, 0 );
596 GET_UINT32_BE( Y, input, 4 );
600 for( i = 0; i < 8; i++ )
608 PUT_UINT32_BE( Y, output, 0 );
609 PUT_UINT32_BE( X, output, 4 );
621 const unsigned char *input,
622 unsigned char *output )
625 unsigned char temp[8];
634 for( i = 0; i < 8; i++ )
635 output[i] = (
unsigned char)( input[i] ^ iv[i] );
638 memcpy( iv, output, 8 );
649 memcpy( temp, input, 8 );
652 for( i = 0; i < 8; i++ )
653 output[i] = (
unsigned char)( output[i] ^ iv[i] );
655 memcpy( iv, temp, 8 );
670 const unsigned char input[8],
671 unsigned char output[8] )
674 uint32_t X, Y, T, *SK;
678 GET_UINT32_BE( X, input, 0 );
679 GET_UINT32_BE( Y, input, 4 );
683 for( i = 0; i < 8; i++ )
689 for( i = 0; i < 8; i++ )
695 for( i = 0; i < 8; i++ )
703 PUT_UINT32_BE( Y, output, 0 );
704 PUT_UINT32_BE( X, output, 4 );
716 const unsigned char *input,
717 unsigned char *output )
720 unsigned char temp[8];
729 for( i = 0; i < 8; i++ )
730 output[i] = (
unsigned char)( input[i] ^ iv[i] );
733 memcpy( iv, output, 8 );
744 memcpy( temp, input, 8 );
747 for( i = 0; i < 8; i++ )
748 output[i] = (
unsigned char)( output[i] ^ iv[i] );
750 memcpy( iv, temp, 8 );
763 #if defined(POLARSSL_SELF_TEST)
772 static const unsigned char des3_test_keys[24] =
774 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
775 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01,
776 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23
779 static const unsigned char des3_test_iv[8] =
781 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF,
784 static const unsigned char des3_test_buf[8] =
786 0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74
789 static const unsigned char des3_test_ecb_dec[3][8] =
791 { 0xCD, 0xD6, 0x4F, 0x2F, 0x94, 0x27, 0xC1, 0x5D },
792 { 0x69, 0x96, 0xC8, 0xFA, 0x47, 0xA2, 0xAB, 0xEB },
793 { 0x83, 0x25, 0x39, 0x76, 0x44, 0x09, 0x1A, 0x0A }
796 static const unsigned char des3_test_ecb_enc[3][8] =
798 { 0x6A, 0x2A, 0x19, 0xF4, 0x1E, 0xCA, 0x85, 0x4B },
799 { 0x03, 0xE6, 0x9F, 0x5B, 0xFA, 0x58, 0xEB, 0x42 },
800 { 0xDD, 0x17, 0xE8, 0xB8, 0xB4, 0x37, 0xD2, 0x32 }
803 static const unsigned char des3_test_cbc_dec[3][8] =
805 { 0x12, 0x9F, 0x40, 0xB9, 0xD2, 0x00, 0x56, 0xB3 },
806 { 0x47, 0x0E, 0xFC, 0x9A, 0x6B, 0x8E, 0xE3, 0x93 },
807 { 0xC5, 0xCE, 0xCF, 0x63, 0xEC, 0xEC, 0x51, 0x4C }
810 static const unsigned char des3_test_cbc_enc[3][8] =
812 { 0x54, 0xF1, 0x5A, 0xF6, 0xEB, 0xE3, 0xA4, 0xB4 },
813 { 0x35, 0x76, 0x11, 0x56, 0x5F, 0xA1, 0x8E, 0x4D },
814 { 0xCB, 0x19, 0x1F, 0x85, 0xD1, 0xED, 0x84, 0x39 }
825 unsigned char key[24];
826 unsigned char buf[8];
827 unsigned char prv[8];
830 memset( key, 0, 24 );
835 for( i = 0; i < 6; i++ )
841 printf(
" DES%c-ECB-%3d (%s): ",
842 ( u == 0 ) ?
' ' :
'3', 56 + u * 56,
845 memcpy( buf, des3_test_buf, 8 );
877 for( j = 0; j < 10000; j++ )
886 memcmp( buf, des3_test_ecb_dec[u], 8 ) != 0 ) ||
888 memcmp( buf, des3_test_ecb_enc[u], 8 ) != 0 ) )
891 printf(
"failed\n" );
897 printf(
"passed\n" );
906 for( i = 0; i < 6; i++ )
912 printf(
" DES%c-CBC-%3d (%s): ",
913 ( u == 0 ) ?
' ' :
'3', 56 + u * 56,
916 memcpy( iv, des3_test_iv, 8 );
917 memcpy( prv, des3_test_iv, 8 );
918 memcpy( buf, des3_test_buf, 8 );
952 for( j = 0; j < 10000; j++ )
962 for( j = 0; j < 10000; j++ )
964 unsigned char tmp[8];
971 memcpy( tmp, prv, 8 );
972 memcpy( prv, buf, 8 );
973 memcpy( buf, tmp, 8 );
976 memcpy( buf, prv, 8 );
980 memcmp( buf, des3_test_cbc_dec[u], 8 ) != 0 ) ||
982 memcmp( buf, des3_test_cbc_enc[u], 8 ) != 0 ) )
985 printf(
"failed\n" );
991 printf(
"passed\n" );