32 #if !defined(POLARSSL_CONFIG_FILE)
35 #include POLARSSL_CONFIG_FILE
38 #if defined(POLARSSL_DES_C)
42 #if defined(POLARSSL_PLATFORM_C)
45 #define polarssl_printf printf
48 #if !defined(POLARSSL_DES_ALT)
54 #define GET_UINT32_BE(n,b,i) \
56 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
57 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
58 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
59 | ( (uint32_t) (b)[(i) + 3] ); \
64 #define PUT_UINT32_BE(n,b,i) \
66 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
67 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
68 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
69 (b)[(i) + 3] = (unsigned char) ( (n) ); \
76 static const uint32_t SB1[64] =
78 0x01010400, 0x00000000, 0x00010000, 0x01010404,
79 0x01010004, 0x00010404, 0x00000004, 0x00010000,
80 0x00000400, 0x01010400, 0x01010404, 0x00000400,
81 0x01000404, 0x01010004, 0x01000000, 0x00000004,
82 0x00000404, 0x01000400, 0x01000400, 0x00010400,
83 0x00010400, 0x01010000, 0x01010000, 0x01000404,
84 0x00010004, 0x01000004, 0x01000004, 0x00010004,
85 0x00000000, 0x00000404, 0x00010404, 0x01000000,
86 0x00010000, 0x01010404, 0x00000004, 0x01010000,
87 0x01010400, 0x01000000, 0x01000000, 0x00000400,
88 0x01010004, 0x00010000, 0x00010400, 0x01000004,
89 0x00000400, 0x00000004, 0x01000404, 0x00010404,
90 0x01010404, 0x00010004, 0x01010000, 0x01000404,
91 0x01000004, 0x00000404, 0x00010404, 0x01010400,
92 0x00000404, 0x01000400, 0x01000400, 0x00000000,
93 0x00010004, 0x00010400, 0x00000000, 0x01010004
96 static const uint32_t SB2[64] =
98 0x80108020, 0x80008000, 0x00008000, 0x00108020,
99 0x00100000, 0x00000020, 0x80100020, 0x80008020,
100 0x80000020, 0x80108020, 0x80108000, 0x80000000,
101 0x80008000, 0x00100000, 0x00000020, 0x80100020,
102 0x00108000, 0x00100020, 0x80008020, 0x00000000,
103 0x80000000, 0x00008000, 0x00108020, 0x80100000,
104 0x00100020, 0x80000020, 0x00000000, 0x00108000,
105 0x00008020, 0x80108000, 0x80100000, 0x00008020,
106 0x00000000, 0x00108020, 0x80100020, 0x00100000,
107 0x80008020, 0x80100000, 0x80108000, 0x00008000,
108 0x80100000, 0x80008000, 0x00000020, 0x80108020,
109 0x00108020, 0x00000020, 0x00008000, 0x80000000,
110 0x00008020, 0x80108000, 0x00100000, 0x80000020,
111 0x00100020, 0x80008020, 0x80000020, 0x00100020,
112 0x00108000, 0x00000000, 0x80008000, 0x00008020,
113 0x80000000, 0x80100020, 0x80108020, 0x00108000
116 static const uint32_t SB3[64] =
118 0x00000208, 0x08020200, 0x00000000, 0x08020008,
119 0x08000200, 0x00000000, 0x00020208, 0x08000200,
120 0x00020008, 0x08000008, 0x08000008, 0x00020000,
121 0x08020208, 0x00020008, 0x08020000, 0x00000208,
122 0x08000000, 0x00000008, 0x08020200, 0x00000200,
123 0x00020200, 0x08020000, 0x08020008, 0x00020208,
124 0x08000208, 0x00020200, 0x00020000, 0x08000208,
125 0x00000008, 0x08020208, 0x00000200, 0x08000000,
126 0x08020200, 0x08000000, 0x00020008, 0x00000208,
127 0x00020000, 0x08020200, 0x08000200, 0x00000000,
128 0x00000200, 0x00020008, 0x08020208, 0x08000200,
129 0x08000008, 0x00000200, 0x00000000, 0x08020008,
130 0x08000208, 0x00020000, 0x08000000, 0x08020208,
131 0x00000008, 0x00020208, 0x00020200, 0x08000008,
132 0x08020000, 0x08000208, 0x00000208, 0x08020000,
133 0x00020208, 0x00000008, 0x08020008, 0x00020200
136 static const uint32_t SB4[64] =
138 0x00802001, 0x00002081, 0x00002081, 0x00000080,
139 0x00802080, 0x00800081, 0x00800001, 0x00002001,
140 0x00000000, 0x00802000, 0x00802000, 0x00802081,
141 0x00000081, 0x00000000, 0x00800080, 0x00800001,
142 0x00000001, 0x00002000, 0x00800000, 0x00802001,
143 0x00000080, 0x00800000, 0x00002001, 0x00002080,
144 0x00800081, 0x00000001, 0x00002080, 0x00800080,
145 0x00002000, 0x00802080, 0x00802081, 0x00000081,
146 0x00800080, 0x00800001, 0x00802000, 0x00802081,
147 0x00000081, 0x00000000, 0x00000000, 0x00802000,
148 0x00002080, 0x00800080, 0x00800081, 0x00000001,
149 0x00802001, 0x00002081, 0x00002081, 0x00000080,
150 0x00802081, 0x00000081, 0x00000001, 0x00002000,
151 0x00800001, 0x00002001, 0x00802080, 0x00800081,
152 0x00002001, 0x00002080, 0x00800000, 0x00802001,
153 0x00000080, 0x00800000, 0x00002000, 0x00802080
156 static const uint32_t SB5[64] =
158 0x00000100, 0x02080100, 0x02080000, 0x42000100,
159 0x00080000, 0x00000100, 0x40000000, 0x02080000,
160 0x40080100, 0x00080000, 0x02000100, 0x40080100,
161 0x42000100, 0x42080000, 0x00080100, 0x40000000,
162 0x02000000, 0x40080000, 0x40080000, 0x00000000,
163 0x40000100, 0x42080100, 0x42080100, 0x02000100,
164 0x42080000, 0x40000100, 0x00000000, 0x42000000,
165 0x02080100, 0x02000000, 0x42000000, 0x00080100,
166 0x00080000, 0x42000100, 0x00000100, 0x02000000,
167 0x40000000, 0x02080000, 0x42000100, 0x40080100,
168 0x02000100, 0x40000000, 0x42080000, 0x02080100,
169 0x40080100, 0x00000100, 0x02000000, 0x42080000,
170 0x42080100, 0x00080100, 0x42000000, 0x42080100,
171 0x02080000, 0x00000000, 0x40080000, 0x42000000,
172 0x00080100, 0x02000100, 0x40000100, 0x00080000,
173 0x00000000, 0x40080000, 0x02080100, 0x40000100
176 static const uint32_t SB6[64] =
178 0x20000010, 0x20400000, 0x00004000, 0x20404010,
179 0x20400000, 0x00000010, 0x20404010, 0x00400000,
180 0x20004000, 0x00404010, 0x00400000, 0x20000010,
181 0x00400010, 0x20004000, 0x20000000, 0x00004010,
182 0x00000000, 0x00400010, 0x20004010, 0x00004000,
183 0x00404000, 0x20004010, 0x00000010, 0x20400010,
184 0x20400010, 0x00000000, 0x00404010, 0x20404000,
185 0x00004010, 0x00404000, 0x20404000, 0x20000000,
186 0x20004000, 0x00000010, 0x20400010, 0x00404000,
187 0x20404010, 0x00400000, 0x00004010, 0x20000010,
188 0x00400000, 0x20004000, 0x20000000, 0x00004010,
189 0x20000010, 0x20404010, 0x00404000, 0x20400000,
190 0x00404010, 0x20404000, 0x00000000, 0x20400010,
191 0x00000010, 0x00004000, 0x20400000, 0x00404010,
192 0x00004000, 0x00400010, 0x20004010, 0x00000000,
193 0x20404000, 0x20000000, 0x00400010, 0x20004010
196 static const uint32_t SB7[64] =
198 0x00200000, 0x04200002, 0x04000802, 0x00000000,
199 0x00000800, 0x04000802, 0x00200802, 0x04200800,
200 0x04200802, 0x00200000, 0x00000000, 0x04000002,
201 0x00000002, 0x04000000, 0x04200002, 0x00000802,
202 0x04000800, 0x00200802, 0x00200002, 0x04000800,
203 0x04000002, 0x04200000, 0x04200800, 0x00200002,
204 0x04200000, 0x00000800, 0x00000802, 0x04200802,
205 0x00200800, 0x00000002, 0x04000000, 0x00200800,
206 0x04000000, 0x00200800, 0x00200000, 0x04000802,
207 0x04000802, 0x04200002, 0x04200002, 0x00000002,
208 0x00200002, 0x04000000, 0x04000800, 0x00200000,
209 0x04200800, 0x00000802, 0x00200802, 0x04200800,
210 0x00000802, 0x04000002, 0x04200802, 0x04200000,
211 0x00200800, 0x00000000, 0x00000002, 0x04200802,
212 0x00000000, 0x00200802, 0x04200000, 0x00000800,
213 0x04000002, 0x04000800, 0x00000800, 0x00200002
216 static const uint32_t SB8[64] =
218 0x10001040, 0x00001000, 0x00040000, 0x10041040,
219 0x10000000, 0x10001040, 0x00000040, 0x10000000,
220 0x00040040, 0x10040000, 0x10041040, 0x00041000,
221 0x10041000, 0x00041040, 0x00001000, 0x00000040,
222 0x10040000, 0x10000040, 0x10001000, 0x00001040,
223 0x00041000, 0x00040040, 0x10040040, 0x10041000,
224 0x00001040, 0x00000000, 0x00000000, 0x10040040,
225 0x10000040, 0x10001000, 0x00041040, 0x00040000,
226 0x00041040, 0x00040000, 0x10041000, 0x00001000,
227 0x00000040, 0x10040040, 0x00001000, 0x00041040,
228 0x10001000, 0x00000040, 0x10000040, 0x10040000,
229 0x10040040, 0x10000000, 0x00040000, 0x10001040,
230 0x00000000, 0x10041040, 0x00040040, 0x10000040,
231 0x10040000, 0x10001000, 0x10001040, 0x00000000,
232 0x10041040, 0x00041000, 0x00041000, 0x00001040,
233 0x00001040, 0x00040040, 0x10000000, 0x10041000
239 static const uint32_t LHs[16] =
241 0x00000000, 0x00000001, 0x00000100, 0x00000101,
242 0x00010000, 0x00010001, 0x00010100, 0x00010101,
243 0x01000000, 0x01000001, 0x01000100, 0x01000101,
244 0x01010000, 0x01010001, 0x01010100, 0x01010101
247 static const uint32_t RHs[16] =
249 0x00000000, 0x01000000, 0x00010000, 0x01010000,
250 0x00000100, 0x01000100, 0x00010100, 0x01010100,
251 0x00000001, 0x01000001, 0x00010001, 0x01010001,
252 0x00000101, 0x01000101, 0x00010101, 0x01010101,
258 #define DES_IP(X,Y) \
260 T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \
261 T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \
262 T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \
263 T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \
264 Y = ((Y << 1) | (Y >> 31)) & 0xFFFFFFFF; \
265 T = (X ^ Y) & 0xAAAAAAAA; Y ^= T; X ^= T; \
266 X = ((X << 1) | (X >> 31)) & 0xFFFFFFFF; \
272 #define DES_FP(X,Y) \
274 X = ((X << 31) | (X >> 1)) & 0xFFFFFFFF; \
275 T = (X ^ Y) & 0xAAAAAAAA; X ^= T; Y ^= T; \
276 Y = ((Y << 31) | (Y >> 1)) & 0xFFFFFFFF; \
277 T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \
278 T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \
279 T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \
280 T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \
286 #define DES_ROUND(X,Y) \
289 Y ^= SB8[ (T ) & 0x3F ] ^ \
290 SB6[ (T >> 8) & 0x3F ] ^ \
291 SB4[ (T >> 16) & 0x3F ] ^ \
292 SB2[ (T >> 24) & 0x3F ]; \
294 T = *SK++ ^ ((X << 28) | (X >> 4)); \
295 Y ^= SB7[ (T ) & 0x3F ] ^ \
296 SB5[ (T >> 8) & 0x3F ] ^ \
297 SB3[ (T >> 16) & 0x3F ] ^ \
298 SB1[ (T >> 24) & 0x3F ]; \
301 #define SWAP(a,b) { uint32_t t = a; a = b; b = t; t = 0; }
303 static const unsigned char odd_parity_table[128] = { 1, 2, 4, 7, 8,
304 11, 13, 14, 16, 19, 21, 22, 25, 26, 28, 31, 32, 35, 37, 38, 41, 42, 44,
305 47, 49, 50, 52, 55, 56, 59, 61, 62, 64, 67, 69, 70, 73, 74, 76, 79, 81,
306 82, 84, 87, 88, 91, 93, 94, 97, 98, 100, 103, 104, 107, 109, 110, 112,
307 115, 117, 118, 121, 122, 124, 127, 128, 131, 133, 134, 137, 138, 140,
308 143, 145, 146, 148, 151, 152, 155, 157, 158, 161, 162, 164, 167, 168,
309 171, 173, 174, 176, 179, 181, 182, 185, 186, 188, 191, 193, 194, 196,
310 199, 200, 203, 205, 206, 208, 211, 213, 214, 217, 218, 220, 223, 224,
311 227, 229, 230, 233, 234, 236, 239, 241, 242, 244, 247, 248, 251, 253,
319 key[i] = odd_parity_table[key[i] / 2];
330 if ( key[i] != odd_parity_table[key[i] / 2] )
357 #define WEAK_KEY_COUNT 16
359 static const unsigned char weak_key_table[WEAK_KEY_COUNT][
DES_KEY_SIZE] =
361 { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
362 { 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE },
363 { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E },
364 { 0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1 },
366 { 0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E },
367 { 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01 },
368 { 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1 },
369 { 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01 },
370 { 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE },
371 { 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01 },
372 { 0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1 },
373 { 0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E },
374 { 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE },
375 { 0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E },
376 { 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE },
377 { 0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1 }
384 for( i = 0; i < WEAK_KEY_COUNT; i++ )
385 if( memcmp( weak_key_table[i], key, DES_KEY_SIZE) == 0)
391 static void des_setkey( uint32_t SK[32],
const unsigned char key[DES_KEY_SIZE] )
396 GET_UINT32_BE( X, key, 0 );
397 GET_UINT32_BE( Y, key, 4 );
402 T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4);
403 T = ((Y ) ^ X) & 0x10101010; X ^= T; Y ^= (T );
405 X = (LHs[ (X ) & 0xF] << 3) | (LHs[ (X >> 8) & 0xF ] << 2)
406 | (LHs[ (X >> 16) & 0xF] << 1) | (LHs[ (X >> 24) & 0xF ] )
407 | (LHs[ (X >> 5) & 0xF] << 7) | (LHs[ (X >> 13) & 0xF ] << 6)
408 | (LHs[ (X >> 21) & 0xF] << 5) | (LHs[ (X >> 29) & 0xF ] << 4);
410 Y = (RHs[ (Y >> 1) & 0xF] << 3) | (RHs[ (Y >> 9) & 0xF ] << 2)
411 | (RHs[ (Y >> 17) & 0xF] << 1) | (RHs[ (Y >> 25) & 0xF ] )
412 | (RHs[ (Y >> 4) & 0xF] << 7) | (RHs[ (Y >> 12) & 0xF ] << 6)
413 | (RHs[ (Y >> 20) & 0xF] << 5) | (RHs[ (Y >> 28) & 0xF ] << 4);
421 for( i = 0; i < 16; i++ )
423 if( i < 2 || i == 8 || i == 15 )
425 X = ((X << 1) | (X >> 27)) & 0x0FFFFFFF;
426 Y = ((Y << 1) | (Y >> 27)) & 0x0FFFFFFF;
430 X = ((X << 2) | (X >> 26)) & 0x0FFFFFFF;
431 Y = ((Y << 2) | (Y >> 26)) & 0x0FFFFFFF;
434 *SK++ = ((X << 4) & 0x24000000) | ((X << 28) & 0x10000000)
435 | ((X << 14) & 0x08000000) | ((X << 18) & 0x02080000)
436 | ((X << 6) & 0x01000000) | ((X << 9) & 0x00200000)
437 | ((X >> 1) & 0x00100000) | ((X << 10) & 0x00040000)
438 | ((X << 2) & 0x00020000) | ((X >> 10) & 0x00010000)
439 | ((Y >> 13) & 0x00002000) | ((Y >> 4) & 0x00001000)
440 | ((Y << 6) & 0x00000800) | ((Y >> 1) & 0x00000400)
441 | ((Y >> 14) & 0x00000200) | ((Y ) & 0x00000100)
442 | ((Y >> 5) & 0x00000020) | ((Y >> 10) & 0x00000010)
443 | ((Y >> 3) & 0x00000008) | ((Y >> 18) & 0x00000004)
444 | ((Y >> 26) & 0x00000002) | ((Y >> 24) & 0x00000001);
446 *SK++ = ((X << 15) & 0x20000000) | ((X << 17) & 0x10000000)
447 | ((X << 10) & 0x08000000) | ((X << 22) & 0x04000000)
448 | ((X >> 2) & 0x02000000) | ((X << 1) & 0x01000000)
449 | ((X << 16) & 0x00200000) | ((X << 11) & 0x00100000)
450 | ((X << 3) & 0x00080000) | ((X >> 6) & 0x00040000)
451 | ((X << 15) & 0x00020000) | ((X >> 4) & 0x00010000)
452 | ((Y >> 2) & 0x00002000) | ((Y << 8) & 0x00001000)
453 | ((Y >> 14) & 0x00000808) | ((Y >> 9) & 0x00000400)
454 | ((Y ) & 0x00000200) | ((Y << 7) & 0x00000100)
455 | ((Y >> 7) & 0x00000020) | ((Y >> 3) & 0x00000011)
456 | ((Y << 2) & 0x00000004) | ((Y >> 21) & 0x00000002);
465 des_setkey( ctx->
sk, key );
477 des_setkey( ctx->
sk, key );
479 for( i = 0; i < 16; i += 2 )
481 SWAP( ctx->
sk[i ], ctx->
sk[30 - i] );
482 SWAP( ctx->
sk[i + 1], ctx->
sk[31 - i] );
488 static void des3_set2key( uint32_t esk[96],
490 const unsigned char key[DES_KEY_SIZE*2] )
494 des_setkey( esk, key );
495 des_setkey( dsk + 32, key + 8 );
497 for( i = 0; i < 32; i += 2 )
499 dsk[i ] = esk[30 - i];
500 dsk[i + 1] = esk[31 - i];
502 esk[i + 32] = dsk[62 - i];
503 esk[i + 33] = dsk[63 - i];
505 esk[i + 64] = esk[i ];
506 esk[i + 65] = esk[i + 1];
508 dsk[i + 64] = dsk[i ];
509 dsk[i + 65] = dsk[i + 1];
517 const unsigned char key[DES_KEY_SIZE * 2] )
521 des3_set2key( ctx->
sk, sk, key );
522 memset( sk, 0,
sizeof( sk ) );
531 const unsigned char key[DES_KEY_SIZE * 2] )
535 des3_set2key( sk, ctx->
sk, key );
536 memset( sk, 0,
sizeof( sk ) );
541 static void des3_set3key( uint32_t esk[96],
543 const unsigned char key[24] )
547 des_setkey( esk, key );
548 des_setkey( dsk + 32, key + 8 );
549 des_setkey( esk + 64, key + 16 );
551 for( i = 0; i < 32; i += 2 )
553 dsk[i ] = esk[94 - i];
554 dsk[i + 1] = esk[95 - i];
556 esk[i + 32] = dsk[62 - i];
557 esk[i + 33] = dsk[63 - i];
559 dsk[i + 64] = esk[30 - i];
560 dsk[i + 65] = esk[31 - i];
568 const unsigned char key[DES_KEY_SIZE * 3] )
572 des3_set3key( ctx->
sk, sk, key );
573 memset( sk, 0,
sizeof( sk ) );
582 const unsigned char key[DES_KEY_SIZE * 3] )
586 des3_set3key( sk, ctx->
sk, key );
587 memset( sk, 0,
sizeof( sk ) );
596 const unsigned char input[8],
597 unsigned char output[8] )
600 uint32_t X, Y, T, *SK;
604 GET_UINT32_BE( X, input, 0 );
605 GET_UINT32_BE( Y, input, 4 );
609 for( i = 0; i < 8; i++ )
617 PUT_UINT32_BE( Y, output, 0 );
618 PUT_UINT32_BE( X, output, 4 );
623 #if defined(POLARSSL_CIPHER_MODE_CBC)
631 const unsigned char *input,
632 unsigned char *output )
635 unsigned char temp[8];
644 for( i = 0; i < 8; i++ )
645 output[i] = (
unsigned char)( input[i] ^ iv[i] );
648 memcpy( iv, output, 8 );
659 memcpy( temp, input, 8 );
662 for( i = 0; i < 8; i++ )
663 output[i] = (
unsigned char)( output[i] ^ iv[i] );
665 memcpy( iv, temp, 8 );
681 const unsigned char input[8],
682 unsigned char output[8] )
685 uint32_t X, Y, T, *SK;
689 GET_UINT32_BE( X, input, 0 );
690 GET_UINT32_BE( Y, input, 4 );
694 for( i = 0; i < 8; i++ )
700 for( i = 0; i < 8; i++ )
706 for( i = 0; i < 8; i++ )
714 PUT_UINT32_BE( Y, output, 0 );
715 PUT_UINT32_BE( X, output, 4 );
720 #if defined(POLARSSL_CIPHER_MODE_CBC)
728 const unsigned char *input,
729 unsigned char *output )
732 unsigned char temp[8];
741 for( i = 0; i < 8; i++ )
742 output[i] = (
unsigned char)( input[i] ^ iv[i] );
745 memcpy( iv, output, 8 );
756 memcpy( temp, input, 8 );
759 for( i = 0; i < 8; i++ )
760 output[i] = (
unsigned char)( output[i] ^ iv[i] );
762 memcpy( iv, temp, 8 );
776 #if defined(POLARSSL_SELF_TEST)
785 static const unsigned char des3_test_keys[24] =
787 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
788 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01,
789 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23
792 static const unsigned char des3_test_buf[8] =
794 0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74
797 static const unsigned char des3_test_ecb_dec[3][8] =
799 { 0xCD, 0xD6, 0x4F, 0x2F, 0x94, 0x27, 0xC1, 0x5D },
800 { 0x69, 0x96, 0xC8, 0xFA, 0x47, 0xA2, 0xAB, 0xEB },
801 { 0x83, 0x25, 0x39, 0x76, 0x44, 0x09, 0x1A, 0x0A }
804 static const unsigned char des3_test_ecb_enc[3][8] =
806 { 0x6A, 0x2A, 0x19, 0xF4, 0x1E, 0xCA, 0x85, 0x4B },
807 { 0x03, 0xE6, 0x9F, 0x5B, 0xFA, 0x58, 0xEB, 0x42 },
808 { 0xDD, 0x17, 0xE8, 0xB8, 0xB4, 0x37, 0xD2, 0x32 }
811 #if defined(POLARSSL_CIPHER_MODE_CBC)
812 static const unsigned char des3_test_iv[8] =
814 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF,
817 static const unsigned char des3_test_cbc_dec[3][8] =
819 { 0x12, 0x9F, 0x40, 0xB9, 0xD2, 0x00, 0x56, 0xB3 },
820 { 0x47, 0x0E, 0xFC, 0x9A, 0x6B, 0x8E, 0xE3, 0x93 },
821 { 0xC5, 0xCE, 0xCF, 0x63, 0xEC, 0xEC, 0x51, 0x4C }
824 static const unsigned char des3_test_cbc_enc[3][8] =
826 { 0x54, 0xF1, 0x5A, 0xF6, 0xEB, 0xE3, 0xA4, 0xB4 },
827 { 0x35, 0x76, 0x11, 0x56, 0x5F, 0xA1, 0x8E, 0x4D },
828 { 0xCB, 0x19, 0x1F, 0x85, 0xD1, 0xED, 0x84, 0x39 }
840 unsigned char key[24];
841 unsigned char buf[8];
842 #if defined(POLARSSL_CIPHER_MODE_CBC)
843 unsigned char prv[8];
847 memset( key, 0, 24 );
852 for( i = 0; i < 6; i++ )
859 ( u == 0 ) ?
' ' :
'3', 56 + u * 56,
862 memcpy( buf, des3_test_buf, 8 );
894 for( j = 0; j < 10000; j++ )
903 memcmp( buf, des3_test_ecb_dec[u], 8 ) != 0 ) ||
905 memcmp( buf, des3_test_ecb_enc[u], 8 ) != 0 ) )
920 #if defined(POLARSSL_CIPHER_MODE_CBC)
924 for( i = 0; i < 6; i++ )
931 ( u == 0 ) ?
' ' :
'3', 56 + u * 56,
934 memcpy( iv, des3_test_iv, 8 );
935 memcpy( prv, des3_test_iv, 8 );
936 memcpy( buf, des3_test_buf, 8 );
970 for( j = 0; j < 10000; j++ )
980 for( j = 0; j < 10000; j++ )
982 unsigned char tmp[8];
989 memcpy( tmp, prv, 8 );
990 memcpy( prv, buf, 8 );
991 memcpy( buf, tmp, 8 );
994 memcpy( buf, prv, 8 );
998 memcmp( buf, des3_test_cbc_dec[u], 8 ) != 0 ) ||
1000 memcmp( buf, des3_test_cbc_enc[u], 8 ) != 0 ) )
int des_self_test(int verbose)
Checkup routine.
int des_crypt_ecb(des_context *ctx, const unsigned char input[8], unsigned char output[8])
DES-ECB block encryption/decryption.
Configuration options (set of defines)
int des3_set3key_enc(des3_context *ctx, const unsigned char key[DES_KEY_SIZE *3])
Triple-DES key schedule (168-bit, encryption)
int des3_set3key_dec(des3_context *ctx, const unsigned char key[DES_KEY_SIZE *3])
Triple-DES key schedule (168-bit, decryption)
Triple-DES context structure.
int des3_set2key_enc(des3_context *ctx, const unsigned char key[DES_KEY_SIZE *2])
Triple-DES key schedule (112-bit, encryption)
void des_key_set_parity(unsigned char key[DES_KEY_SIZE])
Set key parity on the given key to odd.
int des_crypt_cbc(des_context *ctx, int mode, size_t length, unsigned char iv[8], const unsigned char *input, unsigned char *output)
DES-CBC buffer encryption/decryption.
int des_setkey_enc(des_context *ctx, const unsigned char key[DES_KEY_SIZE])
DES key schedule (56-bit, encryption)
int des_setkey_dec(des_context *ctx, const unsigned char key[DES_KEY_SIZE])
DES key schedule (56-bit, decryption)
int des3_crypt_ecb(des3_context *ctx, const unsigned char input[8], unsigned char output[8])
3DES-ECB block encryption/decryption
int des_key_check_weak(const unsigned char key[DES_KEY_SIZE])
Check that key is not a weak or semi-weak DES key.
int des_key_check_key_parity(const unsigned char key[DES_KEY_SIZE])
Check that key parity on the given key is odd.
#define POLARSSL_ERR_DES_INVALID_INPUT_LENGTH
The data input has an invalid length.
int des3_set2key_dec(des3_context *ctx, const unsigned char key[DES_KEY_SIZE *2])
Triple-DES key schedule (112-bit, decryption)
int des3_crypt_cbc(des3_context *ctx, int mode, size_t length, unsigned char iv[8], const unsigned char *input, unsigned char *output)
3DES-CBC buffer encryption/decryption