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)
51 static void polarssl_zeroize(
void *v,
size_t n ) {
52 volatile unsigned char *p = v;
while( n-- ) *p++ = 0;
59 #define GET_UINT32_BE(n,b,i) \
61 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
62 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
63 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
64 | ( (uint32_t) (b)[(i) + 3] ); \
69 #define PUT_UINT32_BE(n,b,i) \
71 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
72 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
73 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
74 (b)[(i) + 3] = (unsigned char) ( (n) ); \
81 static const uint32_t SB1[64] =
83 0x01010400, 0x00000000, 0x00010000, 0x01010404,
84 0x01010004, 0x00010404, 0x00000004, 0x00010000,
85 0x00000400, 0x01010400, 0x01010404, 0x00000400,
86 0x01000404, 0x01010004, 0x01000000, 0x00000004,
87 0x00000404, 0x01000400, 0x01000400, 0x00010400,
88 0x00010400, 0x01010000, 0x01010000, 0x01000404,
89 0x00010004, 0x01000004, 0x01000004, 0x00010004,
90 0x00000000, 0x00000404, 0x00010404, 0x01000000,
91 0x00010000, 0x01010404, 0x00000004, 0x01010000,
92 0x01010400, 0x01000000, 0x01000000, 0x00000400,
93 0x01010004, 0x00010000, 0x00010400, 0x01000004,
94 0x00000400, 0x00000004, 0x01000404, 0x00010404,
95 0x01010404, 0x00010004, 0x01010000, 0x01000404,
96 0x01000004, 0x00000404, 0x00010404, 0x01010400,
97 0x00000404, 0x01000400, 0x01000400, 0x00000000,
98 0x00010004, 0x00010400, 0x00000000, 0x01010004
101 static const uint32_t SB2[64] =
103 0x80108020, 0x80008000, 0x00008000, 0x00108020,
104 0x00100000, 0x00000020, 0x80100020, 0x80008020,
105 0x80000020, 0x80108020, 0x80108000, 0x80000000,
106 0x80008000, 0x00100000, 0x00000020, 0x80100020,
107 0x00108000, 0x00100020, 0x80008020, 0x00000000,
108 0x80000000, 0x00008000, 0x00108020, 0x80100000,
109 0x00100020, 0x80000020, 0x00000000, 0x00108000,
110 0x00008020, 0x80108000, 0x80100000, 0x00008020,
111 0x00000000, 0x00108020, 0x80100020, 0x00100000,
112 0x80008020, 0x80100000, 0x80108000, 0x00008000,
113 0x80100000, 0x80008000, 0x00000020, 0x80108020,
114 0x00108020, 0x00000020, 0x00008000, 0x80000000,
115 0x00008020, 0x80108000, 0x00100000, 0x80000020,
116 0x00100020, 0x80008020, 0x80000020, 0x00100020,
117 0x00108000, 0x00000000, 0x80008000, 0x00008020,
118 0x80000000, 0x80100020, 0x80108020, 0x00108000
121 static const uint32_t SB3[64] =
123 0x00000208, 0x08020200, 0x00000000, 0x08020008,
124 0x08000200, 0x00000000, 0x00020208, 0x08000200,
125 0x00020008, 0x08000008, 0x08000008, 0x00020000,
126 0x08020208, 0x00020008, 0x08020000, 0x00000208,
127 0x08000000, 0x00000008, 0x08020200, 0x00000200,
128 0x00020200, 0x08020000, 0x08020008, 0x00020208,
129 0x08000208, 0x00020200, 0x00020000, 0x08000208,
130 0x00000008, 0x08020208, 0x00000200, 0x08000000,
131 0x08020200, 0x08000000, 0x00020008, 0x00000208,
132 0x00020000, 0x08020200, 0x08000200, 0x00000000,
133 0x00000200, 0x00020008, 0x08020208, 0x08000200,
134 0x08000008, 0x00000200, 0x00000000, 0x08020008,
135 0x08000208, 0x00020000, 0x08000000, 0x08020208,
136 0x00000008, 0x00020208, 0x00020200, 0x08000008,
137 0x08020000, 0x08000208, 0x00000208, 0x08020000,
138 0x00020208, 0x00000008, 0x08020008, 0x00020200
141 static const uint32_t SB4[64] =
143 0x00802001, 0x00002081, 0x00002081, 0x00000080,
144 0x00802080, 0x00800081, 0x00800001, 0x00002001,
145 0x00000000, 0x00802000, 0x00802000, 0x00802081,
146 0x00000081, 0x00000000, 0x00800080, 0x00800001,
147 0x00000001, 0x00002000, 0x00800000, 0x00802001,
148 0x00000080, 0x00800000, 0x00002001, 0x00002080,
149 0x00800081, 0x00000001, 0x00002080, 0x00800080,
150 0x00002000, 0x00802080, 0x00802081, 0x00000081,
151 0x00800080, 0x00800001, 0x00802000, 0x00802081,
152 0x00000081, 0x00000000, 0x00000000, 0x00802000,
153 0x00002080, 0x00800080, 0x00800081, 0x00000001,
154 0x00802001, 0x00002081, 0x00002081, 0x00000080,
155 0x00802081, 0x00000081, 0x00000001, 0x00002000,
156 0x00800001, 0x00002001, 0x00802080, 0x00800081,
157 0x00002001, 0x00002080, 0x00800000, 0x00802001,
158 0x00000080, 0x00800000, 0x00002000, 0x00802080
161 static const uint32_t SB5[64] =
163 0x00000100, 0x02080100, 0x02080000, 0x42000100,
164 0x00080000, 0x00000100, 0x40000000, 0x02080000,
165 0x40080100, 0x00080000, 0x02000100, 0x40080100,
166 0x42000100, 0x42080000, 0x00080100, 0x40000000,
167 0x02000000, 0x40080000, 0x40080000, 0x00000000,
168 0x40000100, 0x42080100, 0x42080100, 0x02000100,
169 0x42080000, 0x40000100, 0x00000000, 0x42000000,
170 0x02080100, 0x02000000, 0x42000000, 0x00080100,
171 0x00080000, 0x42000100, 0x00000100, 0x02000000,
172 0x40000000, 0x02080000, 0x42000100, 0x40080100,
173 0x02000100, 0x40000000, 0x42080000, 0x02080100,
174 0x40080100, 0x00000100, 0x02000000, 0x42080000,
175 0x42080100, 0x00080100, 0x42000000, 0x42080100,
176 0x02080000, 0x00000000, 0x40080000, 0x42000000,
177 0x00080100, 0x02000100, 0x40000100, 0x00080000,
178 0x00000000, 0x40080000, 0x02080100, 0x40000100
181 static const uint32_t SB6[64] =
183 0x20000010, 0x20400000, 0x00004000, 0x20404010,
184 0x20400000, 0x00000010, 0x20404010, 0x00400000,
185 0x20004000, 0x00404010, 0x00400000, 0x20000010,
186 0x00400010, 0x20004000, 0x20000000, 0x00004010,
187 0x00000000, 0x00400010, 0x20004010, 0x00004000,
188 0x00404000, 0x20004010, 0x00000010, 0x20400010,
189 0x20400010, 0x00000000, 0x00404010, 0x20404000,
190 0x00004010, 0x00404000, 0x20404000, 0x20000000,
191 0x20004000, 0x00000010, 0x20400010, 0x00404000,
192 0x20404010, 0x00400000, 0x00004010, 0x20000010,
193 0x00400000, 0x20004000, 0x20000000, 0x00004010,
194 0x20000010, 0x20404010, 0x00404000, 0x20400000,
195 0x00404010, 0x20404000, 0x00000000, 0x20400010,
196 0x00000010, 0x00004000, 0x20400000, 0x00404010,
197 0x00004000, 0x00400010, 0x20004010, 0x00000000,
198 0x20404000, 0x20000000, 0x00400010, 0x20004010
201 static const uint32_t SB7[64] =
203 0x00200000, 0x04200002, 0x04000802, 0x00000000,
204 0x00000800, 0x04000802, 0x00200802, 0x04200800,
205 0x04200802, 0x00200000, 0x00000000, 0x04000002,
206 0x00000002, 0x04000000, 0x04200002, 0x00000802,
207 0x04000800, 0x00200802, 0x00200002, 0x04000800,
208 0x04000002, 0x04200000, 0x04200800, 0x00200002,
209 0x04200000, 0x00000800, 0x00000802, 0x04200802,
210 0x00200800, 0x00000002, 0x04000000, 0x00200800,
211 0x04000000, 0x00200800, 0x00200000, 0x04000802,
212 0x04000802, 0x04200002, 0x04200002, 0x00000002,
213 0x00200002, 0x04000000, 0x04000800, 0x00200000,
214 0x04200800, 0x00000802, 0x00200802, 0x04200800,
215 0x00000802, 0x04000002, 0x04200802, 0x04200000,
216 0x00200800, 0x00000000, 0x00000002, 0x04200802,
217 0x00000000, 0x00200802, 0x04200000, 0x00000800,
218 0x04000002, 0x04000800, 0x00000800, 0x00200002
221 static const uint32_t SB8[64] =
223 0x10001040, 0x00001000, 0x00040000, 0x10041040,
224 0x10000000, 0x10001040, 0x00000040, 0x10000000,
225 0x00040040, 0x10040000, 0x10041040, 0x00041000,
226 0x10041000, 0x00041040, 0x00001000, 0x00000040,
227 0x10040000, 0x10000040, 0x10001000, 0x00001040,
228 0x00041000, 0x00040040, 0x10040040, 0x10041000,
229 0x00001040, 0x00000000, 0x00000000, 0x10040040,
230 0x10000040, 0x10001000, 0x00041040, 0x00040000,
231 0x00041040, 0x00040000, 0x10041000, 0x00001000,
232 0x00000040, 0x10040040, 0x00001000, 0x00041040,
233 0x10001000, 0x00000040, 0x10000040, 0x10040000,
234 0x10040040, 0x10000000, 0x00040000, 0x10001040,
235 0x00000000, 0x10041040, 0x00040040, 0x10000040,
236 0x10040000, 0x10001000, 0x10001040, 0x00000000,
237 0x10041040, 0x00041000, 0x00041000, 0x00001040,
238 0x00001040, 0x00040040, 0x10000000, 0x10041000
244 static const uint32_t LHs[16] =
246 0x00000000, 0x00000001, 0x00000100, 0x00000101,
247 0x00010000, 0x00010001, 0x00010100, 0x00010101,
248 0x01000000, 0x01000001, 0x01000100, 0x01000101,
249 0x01010000, 0x01010001, 0x01010100, 0x01010101
252 static const uint32_t RHs[16] =
254 0x00000000, 0x01000000, 0x00010000, 0x01010000,
255 0x00000100, 0x01000100, 0x00010100, 0x01010100,
256 0x00000001, 0x01000001, 0x00010001, 0x01010001,
257 0x00000101, 0x01000101, 0x00010101, 0x01010101,
263 #define DES_IP(X,Y) \
265 T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \
266 T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \
267 T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \
268 T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \
269 Y = ((Y << 1) | (Y >> 31)) & 0xFFFFFFFF; \
270 T = (X ^ Y) & 0xAAAAAAAA; Y ^= T; X ^= T; \
271 X = ((X << 1) | (X >> 31)) & 0xFFFFFFFF; \
277 #define DES_FP(X,Y) \
279 X = ((X << 31) | (X >> 1)) & 0xFFFFFFFF; \
280 T = (X ^ Y) & 0xAAAAAAAA; X ^= T; Y ^= T; \
281 Y = ((Y << 31) | (Y >> 1)) & 0xFFFFFFFF; \
282 T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \
283 T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \
284 T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \
285 T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \
291 #define DES_ROUND(X,Y) \
294 Y ^= SB8[ (T ) & 0x3F ] ^ \
295 SB6[ (T >> 8) & 0x3F ] ^ \
296 SB4[ (T >> 16) & 0x3F ] ^ \
297 SB2[ (T >> 24) & 0x3F ]; \
299 T = *SK++ ^ ((X << 28) | (X >> 4)); \
300 Y ^= SB7[ (T ) & 0x3F ] ^ \
301 SB5[ (T >> 8) & 0x3F ] ^ \
302 SB3[ (T >> 16) & 0x3F ] ^ \
303 SB1[ (T >> 24) & 0x3F ]; \
306 #define SWAP(a,b) { uint32_t t = a; a = b; b = t; t = 0; }
334 static const unsigned char odd_parity_table[128] = { 1, 2, 4, 7, 8,
335 11, 13, 14, 16, 19, 21, 22, 25, 26, 28, 31, 32, 35, 37, 38, 41, 42, 44,
336 47, 49, 50, 52, 55, 56, 59, 61, 62, 64, 67, 69, 70, 73, 74, 76, 79, 81,
337 82, 84, 87, 88, 91, 93, 94, 97, 98, 100, 103, 104, 107, 109, 110, 112,
338 115, 117, 118, 121, 122, 124, 127, 128, 131, 133, 134, 137, 138, 140,
339 143, 145, 146, 148, 151, 152, 155, 157, 158, 161, 162, 164, 167, 168,
340 171, 173, 174, 176, 179, 181, 182, 185, 186, 188, 191, 193, 194, 196,
341 199, 200, 203, 205, 206, 208, 211, 213, 214, 217, 218, 220, 223, 224,
342 227, 229, 230, 233, 234, 236, 239, 241, 242, 244, 247, 248, 251, 253,
350 key[i] = odd_parity_table[key[i] / 2];
361 if( key[i] != odd_parity_table[key[i] / 2] )
388 #define WEAK_KEY_COUNT 16
390 static const unsigned char weak_key_table[WEAK_KEY_COUNT][
DES_KEY_SIZE] =
392 { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
393 { 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE },
394 { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E },
395 { 0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1 },
397 { 0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E },
398 { 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01 },
399 { 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1 },
400 { 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01 },
401 { 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE },
402 { 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01 },
403 { 0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1 },
404 { 0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E },
405 { 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE },
406 { 0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E },
407 { 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE },
408 { 0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1 }
415 for( i = 0; i < WEAK_KEY_COUNT; i++ )
416 if( memcmp( weak_key_table[i], key, DES_KEY_SIZE) == 0 )
422 static void des_setkey( uint32_t SK[32],
const unsigned char key[DES_KEY_SIZE] )
427 GET_UINT32_BE( X, key, 0 );
428 GET_UINT32_BE( Y, key, 4 );
433 T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4);
434 T = ((Y ) ^ X) & 0x10101010; X ^= T; Y ^= (T );
436 X = (LHs[ (X ) & 0xF] << 3) | (LHs[ (X >> 8) & 0xF ] << 2)
437 | (LHs[ (X >> 16) & 0xF] << 1) | (LHs[ (X >> 24) & 0xF ] )
438 | (LHs[ (X >> 5) & 0xF] << 7) | (LHs[ (X >> 13) & 0xF ] << 6)
439 | (LHs[ (X >> 21) & 0xF] << 5) | (LHs[ (X >> 29) & 0xF ] << 4);
441 Y = (RHs[ (Y >> 1) & 0xF] << 3) | (RHs[ (Y >> 9) & 0xF ] << 2)
442 | (RHs[ (Y >> 17) & 0xF] << 1) | (RHs[ (Y >> 25) & 0xF ] )
443 | (RHs[ (Y >> 4) & 0xF] << 7) | (RHs[ (Y >> 12) & 0xF ] << 6)
444 | (RHs[ (Y >> 20) & 0xF] << 5) | (RHs[ (Y >> 28) & 0xF ] << 4);
452 for( i = 0; i < 16; i++ )
454 if( i < 2 || i == 8 || i == 15 )
456 X = ((X << 1) | (X >> 27)) & 0x0FFFFFFF;
457 Y = ((Y << 1) | (Y >> 27)) & 0x0FFFFFFF;
461 X = ((X << 2) | (X >> 26)) & 0x0FFFFFFF;
462 Y = ((Y << 2) | (Y >> 26)) & 0x0FFFFFFF;
465 *SK++ = ((X << 4) & 0x24000000) | ((X << 28) & 0x10000000)
466 | ((X << 14) & 0x08000000) | ((X << 18) & 0x02080000)
467 | ((X << 6) & 0x01000000) | ((X << 9) & 0x00200000)
468 | ((X >> 1) & 0x00100000) | ((X << 10) & 0x00040000)
469 | ((X << 2) & 0x00020000) | ((X >> 10) & 0x00010000)
470 | ((Y >> 13) & 0x00002000) | ((Y >> 4) & 0x00001000)
471 | ((Y << 6) & 0x00000800) | ((Y >> 1) & 0x00000400)
472 | ((Y >> 14) & 0x00000200) | ((Y ) & 0x00000100)
473 | ((Y >> 5) & 0x00000020) | ((Y >> 10) & 0x00000010)
474 | ((Y >> 3) & 0x00000008) | ((Y >> 18) & 0x00000004)
475 | ((Y >> 26) & 0x00000002) | ((Y >> 24) & 0x00000001);
477 *SK++ = ((X << 15) & 0x20000000) | ((X << 17) & 0x10000000)
478 | ((X << 10) & 0x08000000) | ((X << 22) & 0x04000000)
479 | ((X >> 2) & 0x02000000) | ((X << 1) & 0x01000000)
480 | ((X << 16) & 0x00200000) | ((X << 11) & 0x00100000)
481 | ((X << 3) & 0x00080000) | ((X >> 6) & 0x00040000)
482 | ((X << 15) & 0x00020000) | ((X >> 4) & 0x00010000)
483 | ((Y >> 2) & 0x00002000) | ((Y << 8) & 0x00001000)
484 | ((Y >> 14) & 0x00000808) | ((Y >> 9) & 0x00000400)
485 | ((Y ) & 0x00000200) | ((Y << 7) & 0x00000100)
486 | ((Y >> 7) & 0x00000020) | ((Y >> 3) & 0x00000011)
487 | ((Y << 2) & 0x00000004) | ((Y >> 21) & 0x00000002);
496 des_setkey( ctx->
sk, key );
508 des_setkey( ctx->
sk, key );
510 for( i = 0; i < 16; i += 2 )
512 SWAP( ctx->
sk[i ], ctx->
sk[30 - i] );
513 SWAP( ctx->
sk[i + 1], ctx->
sk[31 - i] );
519 static void des3_set2key( uint32_t esk[96],
521 const unsigned char key[DES_KEY_SIZE*2] )
525 des_setkey( esk, key );
526 des_setkey( dsk + 32, key + 8 );
528 for( i = 0; i < 32; i += 2 )
530 dsk[i ] = esk[30 - i];
531 dsk[i + 1] = esk[31 - i];
533 esk[i + 32] = dsk[62 - i];
534 esk[i + 33] = dsk[63 - i];
536 esk[i + 64] = esk[i ];
537 esk[i + 65] = esk[i + 1];
539 dsk[i + 64] = dsk[i ];
540 dsk[i + 65] = dsk[i + 1];
548 const unsigned char key[DES_KEY_SIZE * 2] )
552 des3_set2key( ctx->
sk, sk, key );
553 polarssl_zeroize( sk,
sizeof( sk ) );
562 const unsigned char key[DES_KEY_SIZE * 2] )
566 des3_set2key( sk, ctx->
sk, key );
567 polarssl_zeroize( sk,
sizeof( sk ) );
572 static void des3_set3key( uint32_t esk[96],
574 const unsigned char key[24] )
578 des_setkey( esk, key );
579 des_setkey( dsk + 32, key + 8 );
580 des_setkey( esk + 64, key + 16 );
582 for( i = 0; i < 32; i += 2 )
584 dsk[i ] = esk[94 - i];
585 dsk[i + 1] = esk[95 - i];
587 esk[i + 32] = dsk[62 - i];
588 esk[i + 33] = dsk[63 - i];
590 dsk[i + 64] = esk[30 - i];
591 dsk[i + 65] = esk[31 - i];
599 const unsigned char key[DES_KEY_SIZE * 3] )
603 des3_set3key( ctx->
sk, sk, key );
604 polarssl_zeroize( sk,
sizeof( sk ) );
613 const unsigned char key[DES_KEY_SIZE * 3] )
617 des3_set3key( sk, ctx->
sk, key );
618 polarssl_zeroize( sk,
sizeof( sk ) );
627 const unsigned char input[8],
628 unsigned char output[8] )
631 uint32_t X, Y, T, *SK;
635 GET_UINT32_BE( X, input, 0 );
636 GET_UINT32_BE( Y, input, 4 );
640 for( i = 0; i < 8; i++ )
648 PUT_UINT32_BE( Y, output, 0 );
649 PUT_UINT32_BE( X, output, 4 );
654 #if defined(POLARSSL_CIPHER_MODE_CBC)
662 const unsigned char *input,
663 unsigned char *output )
666 unsigned char temp[8];
675 for( i = 0; i < 8; i++ )
676 output[i] = (
unsigned char)( input[i] ^ iv[i] );
679 memcpy( iv, output, 8 );
690 memcpy( temp, input, 8 );
693 for( i = 0; i < 8; i++ )
694 output[i] = (
unsigned char)( output[i] ^ iv[i] );
696 memcpy( iv, temp, 8 );
712 const unsigned char input[8],
713 unsigned char output[8] )
716 uint32_t X, Y, T, *SK;
720 GET_UINT32_BE( X, input, 0 );
721 GET_UINT32_BE( Y, input, 4 );
725 for( i = 0; i < 8; i++ )
731 for( i = 0; i < 8; i++ )
737 for( i = 0; i < 8; i++ )
745 PUT_UINT32_BE( Y, output, 0 );
746 PUT_UINT32_BE( X, output, 4 );
751 #if defined(POLARSSL_CIPHER_MODE_CBC)
759 const unsigned char *input,
760 unsigned char *output )
763 unsigned char temp[8];
772 for( i = 0; i < 8; i++ )
773 output[i] = (
unsigned char)( input[i] ^ iv[i] );
776 memcpy( iv, output, 8 );
787 memcpy( temp, input, 8 );
790 for( i = 0; i < 8; i++ )
791 output[i] = (
unsigned char)( output[i] ^ iv[i] );
793 memcpy( iv, temp, 8 );
807 #if defined(POLARSSL_SELF_TEST)
816 static const unsigned char des3_test_keys[24] =
818 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
819 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01,
820 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23
823 static const unsigned char des3_test_buf[8] =
825 0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74
828 static const unsigned char des3_test_ecb_dec[3][8] =
830 { 0xCD, 0xD6, 0x4F, 0x2F, 0x94, 0x27, 0xC1, 0x5D },
831 { 0x69, 0x96, 0xC8, 0xFA, 0x47, 0xA2, 0xAB, 0xEB },
832 { 0x83, 0x25, 0x39, 0x76, 0x44, 0x09, 0x1A, 0x0A }
835 static const unsigned char des3_test_ecb_enc[3][8] =
837 { 0x6A, 0x2A, 0x19, 0xF4, 0x1E, 0xCA, 0x85, 0x4B },
838 { 0x03, 0xE6, 0x9F, 0x5B, 0xFA, 0x58, 0xEB, 0x42 },
839 { 0xDD, 0x17, 0xE8, 0xB8, 0xB4, 0x37, 0xD2, 0x32 }
842 #if defined(POLARSSL_CIPHER_MODE_CBC)
843 static const unsigned char des3_test_iv[8] =
845 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF,
848 static const unsigned char des3_test_cbc_dec[3][8] =
850 { 0x12, 0x9F, 0x40, 0xB9, 0xD2, 0x00, 0x56, 0xB3 },
851 { 0x47, 0x0E, 0xFC, 0x9A, 0x6B, 0x8E, 0xE3, 0x93 },
852 { 0xC5, 0xCE, 0xCF, 0x63, 0xEC, 0xEC, 0x51, 0x4C }
855 static const unsigned char des3_test_cbc_enc[3][8] =
857 { 0x54, 0xF1, 0x5A, 0xF6, 0xEB, 0xE3, 0xA4, 0xB4 },
858 { 0x35, 0x76, 0x11, 0x56, 0x5F, 0xA1, 0x8E, 0x4D },
859 { 0xCB, 0x19, 0x1F, 0x85, 0xD1, 0xED, 0x84, 0x39 }
868 int i, j, u, v, ret = 0;
871 unsigned char buf[8];
872 #if defined(POLARSSL_CIPHER_MODE_CBC)
873 unsigned char prv[8];
882 for( i = 0; i < 6; i++ )
889 ( u == 0 ) ?
' ' :
'3', 56 + u * 56,
892 memcpy( buf, des3_test_buf, 8 );
924 for( j = 0; j < 10000; j++ )
933 memcmp( buf, des3_test_ecb_dec[u], 8 ) != 0 ) ||
935 memcmp( buf, des3_test_ecb_enc[u], 8 ) != 0 ) )
951 #if defined(POLARSSL_CIPHER_MODE_CBC)
955 for( i = 0; i < 6; i++ )
962 ( u == 0 ) ?
' ' :
'3', 56 + u * 56,
965 memcpy( iv, des3_test_iv, 8 );
966 memcpy( prv, des3_test_iv, 8 );
967 memcpy( buf, des3_test_buf, 8 );
1001 for( j = 0; j < 10000; j++ )
1011 for( j = 0; j < 10000; j++ )
1013 unsigned char tmp[8];
1020 memcpy( tmp, prv, 8 );
1021 memcpy( prv, buf, 8 );
1022 memcpy( buf, tmp, 8 );
1025 memcpy( buf, prv, 8 );
1029 memcmp( buf, des3_test_cbc_dec[u], 8 ) != 0 ) ||
1031 memcmp( buf, des3_test_cbc_enc[u], 8 ) != 0 ) )
void des3_init(des3_context *ctx)
Initialize Triple-DES context.
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)
void des3_free(des3_context *ctx)
Clear Triple-DES context.
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_init(des_context *ctx)
Initialize DES context.
void des_key_set_parity(unsigned char key[DES_KEY_SIZE])
Set key parity on the given key to odd.
void des_free(des_context *ctx)
Clear DES context.
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