00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030 #include "polarssl/config.h"
00031
00032 #if defined(POLARSSL_DES_C)
00033
00034 #include "polarssl/des.h"
00035
00036 #include <string.h>
00037
00038
00039
00040
00041 #ifndef GET_ULONG_BE
00042 #define GET_ULONG_BE(n,b,i) \
00043 { \
00044 (n) = ( (unsigned long) (b)[(i) ] << 24 ) \
00045 | ( (unsigned long) (b)[(i) + 1] << 16 ) \
00046 | ( (unsigned long) (b)[(i) + 2] << 8 ) \
00047 | ( (unsigned long) (b)[(i) + 3] ); \
00048 }
00049 #endif
00050
00051 #ifndef PUT_ULONG_BE
00052 #define PUT_ULONG_BE(n,b,i) \
00053 { \
00054 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
00055 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
00056 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
00057 (b)[(i) + 3] = (unsigned char) ( (n) ); \
00058 }
00059 #endif
00060
00061
00062
00063
00064 static const unsigned long SB1[64] =
00065 {
00066 0x01010400, 0x00000000, 0x00010000, 0x01010404,
00067 0x01010004, 0x00010404, 0x00000004, 0x00010000,
00068 0x00000400, 0x01010400, 0x01010404, 0x00000400,
00069 0x01000404, 0x01010004, 0x01000000, 0x00000004,
00070 0x00000404, 0x01000400, 0x01000400, 0x00010400,
00071 0x00010400, 0x01010000, 0x01010000, 0x01000404,
00072 0x00010004, 0x01000004, 0x01000004, 0x00010004,
00073 0x00000000, 0x00000404, 0x00010404, 0x01000000,
00074 0x00010000, 0x01010404, 0x00000004, 0x01010000,
00075 0x01010400, 0x01000000, 0x01000000, 0x00000400,
00076 0x01010004, 0x00010000, 0x00010400, 0x01000004,
00077 0x00000400, 0x00000004, 0x01000404, 0x00010404,
00078 0x01010404, 0x00010004, 0x01010000, 0x01000404,
00079 0x01000004, 0x00000404, 0x00010404, 0x01010400,
00080 0x00000404, 0x01000400, 0x01000400, 0x00000000,
00081 0x00010004, 0x00010400, 0x00000000, 0x01010004
00082 };
00083
00084 static const unsigned long SB2[64] =
00085 {
00086 0x80108020, 0x80008000, 0x00008000, 0x00108020,
00087 0x00100000, 0x00000020, 0x80100020, 0x80008020,
00088 0x80000020, 0x80108020, 0x80108000, 0x80000000,
00089 0x80008000, 0x00100000, 0x00000020, 0x80100020,
00090 0x00108000, 0x00100020, 0x80008020, 0x00000000,
00091 0x80000000, 0x00008000, 0x00108020, 0x80100000,
00092 0x00100020, 0x80000020, 0x00000000, 0x00108000,
00093 0x00008020, 0x80108000, 0x80100000, 0x00008020,
00094 0x00000000, 0x00108020, 0x80100020, 0x00100000,
00095 0x80008020, 0x80100000, 0x80108000, 0x00008000,
00096 0x80100000, 0x80008000, 0x00000020, 0x80108020,
00097 0x00108020, 0x00000020, 0x00008000, 0x80000000,
00098 0x00008020, 0x80108000, 0x00100000, 0x80000020,
00099 0x00100020, 0x80008020, 0x80000020, 0x00100020,
00100 0x00108000, 0x00000000, 0x80008000, 0x00008020,
00101 0x80000000, 0x80100020, 0x80108020, 0x00108000
00102 };
00103
00104 static const unsigned long SB3[64] =
00105 {
00106 0x00000208, 0x08020200, 0x00000000, 0x08020008,
00107 0x08000200, 0x00000000, 0x00020208, 0x08000200,
00108 0x00020008, 0x08000008, 0x08000008, 0x00020000,
00109 0x08020208, 0x00020008, 0x08020000, 0x00000208,
00110 0x08000000, 0x00000008, 0x08020200, 0x00000200,
00111 0x00020200, 0x08020000, 0x08020008, 0x00020208,
00112 0x08000208, 0x00020200, 0x00020000, 0x08000208,
00113 0x00000008, 0x08020208, 0x00000200, 0x08000000,
00114 0x08020200, 0x08000000, 0x00020008, 0x00000208,
00115 0x00020000, 0x08020200, 0x08000200, 0x00000000,
00116 0x00000200, 0x00020008, 0x08020208, 0x08000200,
00117 0x08000008, 0x00000200, 0x00000000, 0x08020008,
00118 0x08000208, 0x00020000, 0x08000000, 0x08020208,
00119 0x00000008, 0x00020208, 0x00020200, 0x08000008,
00120 0x08020000, 0x08000208, 0x00000208, 0x08020000,
00121 0x00020208, 0x00000008, 0x08020008, 0x00020200
00122 };
00123
00124 static const unsigned long SB4[64] =
00125 {
00126 0x00802001, 0x00002081, 0x00002081, 0x00000080,
00127 0x00802080, 0x00800081, 0x00800001, 0x00002001,
00128 0x00000000, 0x00802000, 0x00802000, 0x00802081,
00129 0x00000081, 0x00000000, 0x00800080, 0x00800001,
00130 0x00000001, 0x00002000, 0x00800000, 0x00802001,
00131 0x00000080, 0x00800000, 0x00002001, 0x00002080,
00132 0x00800081, 0x00000001, 0x00002080, 0x00800080,
00133 0x00002000, 0x00802080, 0x00802081, 0x00000081,
00134 0x00800080, 0x00800001, 0x00802000, 0x00802081,
00135 0x00000081, 0x00000000, 0x00000000, 0x00802000,
00136 0x00002080, 0x00800080, 0x00800081, 0x00000001,
00137 0x00802001, 0x00002081, 0x00002081, 0x00000080,
00138 0x00802081, 0x00000081, 0x00000001, 0x00002000,
00139 0x00800001, 0x00002001, 0x00802080, 0x00800081,
00140 0x00002001, 0x00002080, 0x00800000, 0x00802001,
00141 0x00000080, 0x00800000, 0x00002000, 0x00802080
00142 };
00143
00144 static const unsigned long SB5[64] =
00145 {
00146 0x00000100, 0x02080100, 0x02080000, 0x42000100,
00147 0x00080000, 0x00000100, 0x40000000, 0x02080000,
00148 0x40080100, 0x00080000, 0x02000100, 0x40080100,
00149 0x42000100, 0x42080000, 0x00080100, 0x40000000,
00150 0x02000000, 0x40080000, 0x40080000, 0x00000000,
00151 0x40000100, 0x42080100, 0x42080100, 0x02000100,
00152 0x42080000, 0x40000100, 0x00000000, 0x42000000,
00153 0x02080100, 0x02000000, 0x42000000, 0x00080100,
00154 0x00080000, 0x42000100, 0x00000100, 0x02000000,
00155 0x40000000, 0x02080000, 0x42000100, 0x40080100,
00156 0x02000100, 0x40000000, 0x42080000, 0x02080100,
00157 0x40080100, 0x00000100, 0x02000000, 0x42080000,
00158 0x42080100, 0x00080100, 0x42000000, 0x42080100,
00159 0x02080000, 0x00000000, 0x40080000, 0x42000000,
00160 0x00080100, 0x02000100, 0x40000100, 0x00080000,
00161 0x00000000, 0x40080000, 0x02080100, 0x40000100
00162 };
00163
00164 static const unsigned long SB6[64] =
00165 {
00166 0x20000010, 0x20400000, 0x00004000, 0x20404010,
00167 0x20400000, 0x00000010, 0x20404010, 0x00400000,
00168 0x20004000, 0x00404010, 0x00400000, 0x20000010,
00169 0x00400010, 0x20004000, 0x20000000, 0x00004010,
00170 0x00000000, 0x00400010, 0x20004010, 0x00004000,
00171 0x00404000, 0x20004010, 0x00000010, 0x20400010,
00172 0x20400010, 0x00000000, 0x00404010, 0x20404000,
00173 0x00004010, 0x00404000, 0x20404000, 0x20000000,
00174 0x20004000, 0x00000010, 0x20400010, 0x00404000,
00175 0x20404010, 0x00400000, 0x00004010, 0x20000010,
00176 0x00400000, 0x20004000, 0x20000000, 0x00004010,
00177 0x20000010, 0x20404010, 0x00404000, 0x20400000,
00178 0x00404010, 0x20404000, 0x00000000, 0x20400010,
00179 0x00000010, 0x00004000, 0x20400000, 0x00404010,
00180 0x00004000, 0x00400010, 0x20004010, 0x00000000,
00181 0x20404000, 0x20000000, 0x00400010, 0x20004010
00182 };
00183
00184 static const unsigned long SB7[64] =
00185 {
00186 0x00200000, 0x04200002, 0x04000802, 0x00000000,
00187 0x00000800, 0x04000802, 0x00200802, 0x04200800,
00188 0x04200802, 0x00200000, 0x00000000, 0x04000002,
00189 0x00000002, 0x04000000, 0x04200002, 0x00000802,
00190 0x04000800, 0x00200802, 0x00200002, 0x04000800,
00191 0x04000002, 0x04200000, 0x04200800, 0x00200002,
00192 0x04200000, 0x00000800, 0x00000802, 0x04200802,
00193 0x00200800, 0x00000002, 0x04000000, 0x00200800,
00194 0x04000000, 0x00200800, 0x00200000, 0x04000802,
00195 0x04000802, 0x04200002, 0x04200002, 0x00000002,
00196 0x00200002, 0x04000000, 0x04000800, 0x00200000,
00197 0x04200800, 0x00000802, 0x00200802, 0x04200800,
00198 0x00000802, 0x04000002, 0x04200802, 0x04200000,
00199 0x00200800, 0x00000000, 0x00000002, 0x04200802,
00200 0x00000000, 0x00200802, 0x04200000, 0x00000800,
00201 0x04000002, 0x04000800, 0x00000800, 0x00200002
00202 };
00203
00204 static const unsigned long SB8[64] =
00205 {
00206 0x10001040, 0x00001000, 0x00040000, 0x10041040,
00207 0x10000000, 0x10001040, 0x00000040, 0x10000000,
00208 0x00040040, 0x10040000, 0x10041040, 0x00041000,
00209 0x10041000, 0x00041040, 0x00001000, 0x00000040,
00210 0x10040000, 0x10000040, 0x10001000, 0x00001040,
00211 0x00041000, 0x00040040, 0x10040040, 0x10041000,
00212 0x00001040, 0x00000000, 0x00000000, 0x10040040,
00213 0x10000040, 0x10001000, 0x00041040, 0x00040000,
00214 0x00041040, 0x00040000, 0x10041000, 0x00001000,
00215 0x00000040, 0x10040040, 0x00001000, 0x00041040,
00216 0x10001000, 0x00000040, 0x10000040, 0x10040000,
00217 0x10040040, 0x10000000, 0x00040000, 0x10001040,
00218 0x00000000, 0x10041040, 0x00040040, 0x10000040,
00219 0x10040000, 0x10001000, 0x10001040, 0x00000000,
00220 0x10041040, 0x00041000, 0x00041000, 0x00001040,
00221 0x00001040, 0x00040040, 0x10000000, 0x10041000
00222 };
00223
00224
00225
00226
00227 static const unsigned long LHs[16] =
00228 {
00229 0x00000000, 0x00000001, 0x00000100, 0x00000101,
00230 0x00010000, 0x00010001, 0x00010100, 0x00010101,
00231 0x01000000, 0x01000001, 0x01000100, 0x01000101,
00232 0x01010000, 0x01010001, 0x01010100, 0x01010101
00233 };
00234
00235 static const unsigned long RHs[16] =
00236 {
00237 0x00000000, 0x01000000, 0x00010000, 0x01010000,
00238 0x00000100, 0x01000100, 0x00010100, 0x01010100,
00239 0x00000001, 0x01000001, 0x00010001, 0x01010001,
00240 0x00000101, 0x01000101, 0x00010101, 0x01010101,
00241 };
00242
00243
00244
00245
00246 #define DES_IP(X,Y) \
00247 { \
00248 T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \
00249 T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \
00250 T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \
00251 T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \
00252 Y = ((Y << 1) | (Y >> 31)) & 0xFFFFFFFF; \
00253 T = (X ^ Y) & 0xAAAAAAAA; Y ^= T; X ^= T; \
00254 X = ((X << 1) | (X >> 31)) & 0xFFFFFFFF; \
00255 }
00256
00257
00258
00259
00260 #define DES_FP(X,Y) \
00261 { \
00262 X = ((X << 31) | (X >> 1)) & 0xFFFFFFFF; \
00263 T = (X ^ Y) & 0xAAAAAAAA; X ^= T; Y ^= T; \
00264 Y = ((Y << 31) | (Y >> 1)) & 0xFFFFFFFF; \
00265 T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \
00266 T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \
00267 T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \
00268 T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \
00269 }
00270
00271
00272
00273
00274 #define DES_ROUND(X,Y) \
00275 { \
00276 T = *SK++ ^ X; \
00277 Y ^= SB8[ (T ) & 0x3F ] ^ \
00278 SB6[ (T >> 8) & 0x3F ] ^ \
00279 SB4[ (T >> 16) & 0x3F ] ^ \
00280 SB2[ (T >> 24) & 0x3F ]; \
00281 \
00282 T = *SK++ ^ ((X << 28) | (X >> 4)); \
00283 Y ^= SB7[ (T ) & 0x3F ] ^ \
00284 SB5[ (T >> 8) & 0x3F ] ^ \
00285 SB3[ (T >> 16) & 0x3F ] ^ \
00286 SB1[ (T >> 24) & 0x3F ]; \
00287 }
00288
00289 #define SWAP(a,b) { unsigned long t = a; a = b; b = t; t = 0; }
00290
00291 static void des_setkey( unsigned long SK[32], unsigned char key[8] )
00292 {
00293 int i;
00294 unsigned long X, Y, T;
00295
00296 GET_ULONG_BE( X, key, 0 );
00297 GET_ULONG_BE( Y, key, 4 );
00298
00299
00300
00301
00302 T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4);
00303 T = ((Y ) ^ X) & 0x10101010; X ^= T; Y ^= (T );
00304
00305 X = (LHs[ (X ) & 0xF] << 3) | (LHs[ (X >> 8) & 0xF ] << 2)
00306 | (LHs[ (X >> 16) & 0xF] << 1) | (LHs[ (X >> 24) & 0xF ] )
00307 | (LHs[ (X >> 5) & 0xF] << 7) | (LHs[ (X >> 13) & 0xF ] << 6)
00308 | (LHs[ (X >> 21) & 0xF] << 5) | (LHs[ (X >> 29) & 0xF ] << 4);
00309
00310 Y = (RHs[ (Y >> 1) & 0xF] << 3) | (RHs[ (Y >> 9) & 0xF ] << 2)
00311 | (RHs[ (Y >> 17) & 0xF] << 1) | (RHs[ (Y >> 25) & 0xF ] )
00312 | (RHs[ (Y >> 4) & 0xF] << 7) | (RHs[ (Y >> 12) & 0xF ] << 6)
00313 | (RHs[ (Y >> 20) & 0xF] << 5) | (RHs[ (Y >> 28) & 0xF ] << 4);
00314
00315 X &= 0x0FFFFFFF;
00316 Y &= 0x0FFFFFFF;
00317
00318
00319
00320
00321 for( i = 0; i < 16; i++ )
00322 {
00323 if( i < 2 || i == 8 || i == 15 )
00324 {
00325 X = ((X << 1) | (X >> 27)) & 0x0FFFFFFF;
00326 Y = ((Y << 1) | (Y >> 27)) & 0x0FFFFFFF;
00327 }
00328 else
00329 {
00330 X = ((X << 2) | (X >> 26)) & 0x0FFFFFFF;
00331 Y = ((Y << 2) | (Y >> 26)) & 0x0FFFFFFF;
00332 }
00333
00334 *SK++ = ((X << 4) & 0x24000000) | ((X << 28) & 0x10000000)
00335 | ((X << 14) & 0x08000000) | ((X << 18) & 0x02080000)
00336 | ((X << 6) & 0x01000000) | ((X << 9) & 0x00200000)
00337 | ((X >> 1) & 0x00100000) | ((X << 10) & 0x00040000)
00338 | ((X << 2) & 0x00020000) | ((X >> 10) & 0x00010000)
00339 | ((Y >> 13) & 0x00002000) | ((Y >> 4) & 0x00001000)
00340 | ((Y << 6) & 0x00000800) | ((Y >> 1) & 0x00000400)
00341 | ((Y >> 14) & 0x00000200) | ((Y ) & 0x00000100)
00342 | ((Y >> 5) & 0x00000020) | ((Y >> 10) & 0x00000010)
00343 | ((Y >> 3) & 0x00000008) | ((Y >> 18) & 0x00000004)
00344 | ((Y >> 26) & 0x00000002) | ((Y >> 24) & 0x00000001);
00345
00346 *SK++ = ((X << 15) & 0x20000000) | ((X << 17) & 0x10000000)
00347 | ((X << 10) & 0x08000000) | ((X << 22) & 0x04000000)
00348 | ((X >> 2) & 0x02000000) | ((X << 1) & 0x01000000)
00349 | ((X << 16) & 0x00200000) | ((X << 11) & 0x00100000)
00350 | ((X << 3) & 0x00080000) | ((X >> 6) & 0x00040000)
00351 | ((X << 15) & 0x00020000) | ((X >> 4) & 0x00010000)
00352 | ((Y >> 2) & 0x00002000) | ((Y << 8) & 0x00001000)
00353 | ((Y >> 14) & 0x00000808) | ((Y >> 9) & 0x00000400)
00354 | ((Y ) & 0x00000200) | ((Y << 7) & 0x00000100)
00355 | ((Y >> 7) & 0x00000020) | ((Y >> 3) & 0x00000011)
00356 | ((Y << 2) & 0x00000004) | ((Y >> 21) & 0x00000002);
00357 }
00358 }
00359
00360
00361
00362
00363 void des_setkey_enc( des_context *ctx, unsigned char key[8] )
00364 {
00365 des_setkey( ctx->sk, key );
00366 }
00367
00368
00369
00370
00371 void des_setkey_dec( des_context *ctx, unsigned char key[8] )
00372 {
00373 int i;
00374
00375 des_setkey( ctx->sk, key );
00376
00377 for( i = 0; i < 16; i += 2 )
00378 {
00379 SWAP( ctx->sk[i ], ctx->sk[30 - i] );
00380 SWAP( ctx->sk[i + 1], ctx->sk[31 - i] );
00381 }
00382 }
00383
00384 static void des3_set2key( unsigned long esk[96],
00385 unsigned long dsk[96],
00386 unsigned char key[16] )
00387 {
00388 int i;
00389
00390 des_setkey( esk, key );
00391 des_setkey( dsk + 32, key + 8 );
00392
00393 for( i = 0; i < 32; i += 2 )
00394 {
00395 dsk[i ] = esk[30 - i];
00396 dsk[i + 1] = esk[31 - i];
00397
00398 esk[i + 32] = dsk[62 - i];
00399 esk[i + 33] = dsk[63 - i];
00400
00401 esk[i + 64] = esk[i ];
00402 esk[i + 65] = esk[i + 1];
00403
00404 dsk[i + 64] = dsk[i ];
00405 dsk[i + 65] = dsk[i + 1];
00406 }
00407 }
00408
00409
00410
00411
00412 void des3_set2key_enc( des3_context *ctx, unsigned char key[16] )
00413 {
00414 unsigned long sk[96];
00415
00416 des3_set2key( ctx->sk, sk, key );
00417 memset( sk, 0, sizeof( sk ) );
00418 }
00419
00420
00421
00422
00423 void des3_set2key_dec( des3_context *ctx, unsigned char key[16] )
00424 {
00425 unsigned long sk[96];
00426
00427 des3_set2key( sk, ctx->sk, key );
00428 memset( sk, 0, sizeof( sk ) );
00429 }
00430
00431 static void des3_set3key( unsigned long esk[96],
00432 unsigned long dsk[96],
00433 unsigned char key[24] )
00434 {
00435 int i;
00436
00437 des_setkey( esk, key );
00438 des_setkey( dsk + 32, key + 8 );
00439 des_setkey( esk + 64, key + 16 );
00440
00441 for( i = 0; i < 32; i += 2 )
00442 {
00443 dsk[i ] = esk[94 - i];
00444 dsk[i + 1] = esk[95 - i];
00445
00446 esk[i + 32] = dsk[62 - i];
00447 esk[i + 33] = dsk[63 - i];
00448
00449 dsk[i + 64] = esk[30 - i];
00450 dsk[i + 65] = esk[31 - i];
00451 }
00452 }
00453
00454
00455
00456
00457 void des3_set3key_enc( des3_context *ctx, unsigned char key[24] )
00458 {
00459 unsigned long sk[96];
00460
00461 des3_set3key( ctx->sk, sk, key );
00462 memset( sk, 0, sizeof( sk ) );
00463 }
00464
00465
00466
00467
00468 void des3_set3key_dec( des3_context *ctx, unsigned char key[24] )
00469 {
00470 unsigned long sk[96];
00471
00472 des3_set3key( sk, ctx->sk, key );
00473 memset( sk, 0, sizeof( sk ) );
00474 }
00475
00476
00477
00478
00479 void des_crypt_ecb( des_context *ctx,
00480 unsigned char input[8],
00481 unsigned char output[8] )
00482 {
00483 int i;
00484 unsigned long X, Y, T, *SK;
00485
00486 SK = ctx->sk;
00487
00488 GET_ULONG_BE( X, input, 0 );
00489 GET_ULONG_BE( Y, input, 4 );
00490
00491 DES_IP( X, Y );
00492
00493 for( i = 0; i < 8; i++ )
00494 {
00495 DES_ROUND( Y, X );
00496 DES_ROUND( X, Y );
00497 }
00498
00499 DES_FP( Y, X );
00500
00501 PUT_ULONG_BE( Y, output, 0 );
00502 PUT_ULONG_BE( X, output, 4 );
00503 }
00504
00505
00506
00507
00508 void des_crypt_cbc( des_context *ctx,
00509 int mode,
00510 int length,
00511 unsigned char iv[8],
00512 unsigned char *input,
00513 unsigned char *output )
00514 {
00515 int i;
00516 unsigned char temp[8];
00517
00518 if( mode == DES_ENCRYPT )
00519 {
00520 while( length > 0 )
00521 {
00522 for( i = 0; i < 8; i++ )
00523 output[i] = (unsigned char)( input[i] ^ iv[i] );
00524
00525 des_crypt_ecb( ctx, output, output );
00526 memcpy( iv, output, 8 );
00527
00528 input += 8;
00529 output += 8;
00530 length -= 8;
00531 }
00532 }
00533 else
00534 {
00535 while( length > 0 )
00536 {
00537 memcpy( temp, input, 8 );
00538 des_crypt_ecb( ctx, input, output );
00539
00540 for( i = 0; i < 8; i++ )
00541 output[i] = (unsigned char)( output[i] ^ iv[i] );
00542
00543 memcpy( iv, temp, 8 );
00544
00545 input += 8;
00546 output += 8;
00547 length -= 8;
00548 }
00549 }
00550 }
00551
00552
00553
00554
00555 void des3_crypt_ecb( des3_context *ctx,
00556 unsigned char input[8],
00557 unsigned char output[8] )
00558 {
00559 int i;
00560 unsigned long X, Y, T, *SK;
00561
00562 SK = ctx->sk;
00563
00564 GET_ULONG_BE( X, input, 0 );
00565 GET_ULONG_BE( Y, input, 4 );
00566
00567 DES_IP( X, Y );
00568
00569 for( i = 0; i < 8; i++ )
00570 {
00571 DES_ROUND( Y, X );
00572 DES_ROUND( X, Y );
00573 }
00574
00575 for( i = 0; i < 8; i++ )
00576 {
00577 DES_ROUND( X, Y );
00578 DES_ROUND( Y, X );
00579 }
00580
00581 for( i = 0; i < 8; i++ )
00582 {
00583 DES_ROUND( Y, X );
00584 DES_ROUND( X, Y );
00585 }
00586
00587 DES_FP( Y, X );
00588
00589 PUT_ULONG_BE( Y, output, 0 );
00590 PUT_ULONG_BE( X, output, 4 );
00591 }
00592
00593
00594
00595
00596 void des3_crypt_cbc( des3_context *ctx,
00597 int mode,
00598 int length,
00599 unsigned char iv[8],
00600 unsigned char *input,
00601 unsigned char *output )
00602 {
00603 int i;
00604 unsigned char temp[8];
00605
00606 if( mode == DES_ENCRYPT )
00607 {
00608 while( length > 0 )
00609 {
00610 for( i = 0; i < 8; i++ )
00611 output[i] = (unsigned char)( input[i] ^ iv[i] );
00612
00613 des3_crypt_ecb( ctx, output, output );
00614 memcpy( iv, output, 8 );
00615
00616 input += 8;
00617 output += 8;
00618 length -= 8;
00619 }
00620 }
00621 else
00622 {
00623 while( length > 0 )
00624 {
00625 memcpy( temp, input, 8 );
00626 des3_crypt_ecb( ctx, input, output );
00627
00628 for( i = 0; i < 8; i++ )
00629 output[i] = (unsigned char)( output[i] ^ iv[i] );
00630
00631 memcpy( iv, temp, 8 );
00632
00633 input += 8;
00634 output += 8;
00635 length -= 8;
00636 }
00637 }
00638 }
00639
00640 #if defined(POLARSSL_SELF_TEST)
00641
00642 #include <stdio.h>
00643
00644
00645
00646
00647
00648
00649 static const unsigned char des3_test_keys[24] =
00650 {
00651 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
00652 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01,
00653 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23
00654 };
00655
00656 static const unsigned char des3_test_iv[8] =
00657 {
00658 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF,
00659 };
00660
00661 static const unsigned char des3_test_buf[8] =
00662 {
00663 0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74
00664 };
00665
00666 static const unsigned char des3_test_ecb_dec[3][8] =
00667 {
00668 { 0xCD, 0xD6, 0x4F, 0x2F, 0x94, 0x27, 0xC1, 0x5D },
00669 { 0x69, 0x96, 0xC8, 0xFA, 0x47, 0xA2, 0xAB, 0xEB },
00670 { 0x83, 0x25, 0x39, 0x76, 0x44, 0x09, 0x1A, 0x0A }
00671 };
00672
00673 static const unsigned char des3_test_ecb_enc[3][8] =
00674 {
00675 { 0x6A, 0x2A, 0x19, 0xF4, 0x1E, 0xCA, 0x85, 0x4B },
00676 { 0x03, 0xE6, 0x9F, 0x5B, 0xFA, 0x58, 0xEB, 0x42 },
00677 { 0xDD, 0x17, 0xE8, 0xB8, 0xB4, 0x37, 0xD2, 0x32 }
00678 };
00679
00680 static const unsigned char des3_test_cbc_dec[3][8] =
00681 {
00682 { 0x12, 0x9F, 0x40, 0xB9, 0xD2, 0x00, 0x56, 0xB3 },
00683 { 0x47, 0x0E, 0xFC, 0x9A, 0x6B, 0x8E, 0xE3, 0x93 },
00684 { 0xC5, 0xCE, 0xCF, 0x63, 0xEC, 0xEC, 0x51, 0x4C }
00685 };
00686
00687 static const unsigned char des3_test_cbc_enc[3][8] =
00688 {
00689 { 0x54, 0xF1, 0x5A, 0xF6, 0xEB, 0xE3, 0xA4, 0xB4 },
00690 { 0x35, 0x76, 0x11, 0x56, 0x5F, 0xA1, 0x8E, 0x4D },
00691 { 0xCB, 0x19, 0x1F, 0x85, 0xD1, 0xED, 0x84, 0x39 }
00692 };
00693
00694
00695
00696
00697 int des_self_test( int verbose )
00698 {
00699 int i, j, u, v;
00700 des_context ctx;
00701 des3_context ctx3;
00702 unsigned char key[24];
00703 unsigned char buf[8];
00704 unsigned char prv[8];
00705 unsigned char iv[8];
00706
00707 memset( key, 0, 24 );
00708
00709
00710
00711
00712 for( i = 0; i < 6; i++ )
00713 {
00714 u = i >> 1;
00715 v = i & 1;
00716
00717 if( verbose != 0 )
00718 printf( " DES%c-ECB-%3d (%s): ",
00719 ( u == 0 ) ? ' ' : '3', 56 + u * 56,
00720 ( v == DES_DECRYPT ) ? "dec" : "enc" );
00721
00722 memcpy( buf, des3_test_buf, 8 );
00723
00724 switch( i )
00725 {
00726 case 0:
00727 des_setkey_dec( &ctx, (unsigned char *) des3_test_keys );
00728 break;
00729
00730 case 1:
00731 des_setkey_enc( &ctx, (unsigned char *) des3_test_keys );
00732 break;
00733
00734 case 2:
00735 des3_set2key_dec( &ctx3, (unsigned char *) des3_test_keys );
00736 break;
00737
00738 case 3:
00739 des3_set2key_enc( &ctx3, (unsigned char *) des3_test_keys );
00740 break;
00741
00742 case 4:
00743 des3_set3key_dec( &ctx3, (unsigned char *) des3_test_keys );
00744 break;
00745
00746 case 5:
00747 des3_set3key_enc( &ctx3, (unsigned char *) des3_test_keys );
00748 break;
00749
00750 default:
00751 return( 1 );
00752 }
00753
00754 for( j = 0; j < 10000; j++ )
00755 {
00756 if( u == 0 )
00757 des_crypt_ecb( &ctx, buf, buf );
00758 else
00759 des3_crypt_ecb( &ctx3, buf, buf );
00760 }
00761
00762 if( ( v == DES_DECRYPT &&
00763 memcmp( buf, des3_test_ecb_dec[u], 8 ) != 0 ) ||
00764 ( v != DES_DECRYPT &&
00765 memcmp( buf, des3_test_ecb_enc[u], 8 ) != 0 ) )
00766 {
00767 if( verbose != 0 )
00768 printf( "failed\n" );
00769
00770 return( 1 );
00771 }
00772
00773 if( verbose != 0 )
00774 printf( "passed\n" );
00775 }
00776
00777 if( verbose != 0 )
00778 printf( "\n" );
00779
00780
00781
00782
00783 for( i = 0; i < 6; i++ )
00784 {
00785 u = i >> 1;
00786 v = i & 1;
00787
00788 if( verbose != 0 )
00789 printf( " DES%c-CBC-%3d (%s): ",
00790 ( u == 0 ) ? ' ' : '3', 56 + u * 56,
00791 ( v == DES_DECRYPT ) ? "dec" : "enc" );
00792
00793 memcpy( iv, des3_test_iv, 8 );
00794 memcpy( prv, des3_test_iv, 8 );
00795 memcpy( buf, des3_test_buf, 8 );
00796
00797 switch( i )
00798 {
00799 case 0:
00800 des_setkey_dec( &ctx, (unsigned char *) des3_test_keys );
00801 break;
00802
00803 case 1:
00804 des_setkey_enc( &ctx, (unsigned char *) des3_test_keys );
00805 break;
00806
00807 case 2:
00808 des3_set2key_dec( &ctx3, (unsigned char *) des3_test_keys );
00809 break;
00810
00811 case 3:
00812 des3_set2key_enc( &ctx3, (unsigned char *) des3_test_keys );
00813 break;
00814
00815 case 4:
00816 des3_set3key_dec( &ctx3, (unsigned char *) des3_test_keys );
00817 break;
00818
00819 case 5:
00820 des3_set3key_enc( &ctx3, (unsigned char *) des3_test_keys );
00821 break;
00822
00823 default:
00824 return( 1 );
00825 }
00826
00827 if( v == DES_DECRYPT )
00828 {
00829 for( j = 0; j < 10000; j++ )
00830 {
00831 if( u == 0 )
00832 des_crypt_cbc( &ctx, v, 8, iv, buf, buf );
00833 else
00834 des3_crypt_cbc( &ctx3, v, 8, iv, buf, buf );
00835 }
00836 }
00837 else
00838 {
00839 for( j = 0; j < 10000; j++ )
00840 {
00841 unsigned char tmp[8];
00842
00843 if( u == 0 )
00844 des_crypt_cbc( &ctx, v, 8, iv, buf, buf );
00845 else
00846 des3_crypt_cbc( &ctx3, v, 8, iv, buf, buf );
00847
00848 memcpy( tmp, prv, 8 );
00849 memcpy( prv, buf, 8 );
00850 memcpy( buf, tmp, 8 );
00851 }
00852
00853 memcpy( buf, prv, 8 );
00854 }
00855
00856 if( ( v == DES_DECRYPT &&
00857 memcmp( buf, des3_test_cbc_dec[u], 8 ) != 0 ) ||
00858 ( v != DES_DECRYPT &&
00859 memcmp( buf, des3_test_cbc_enc[u], 8 ) != 0 ) )
00860 {
00861 if( verbose != 0 )
00862 printf( "failed\n" );
00863
00864 return( 1 );
00865 }
00866
00867 if( verbose != 0 )
00868 printf( "passed\n" );
00869 }
00870
00871 if( verbose != 0 )
00872 printf( "\n" );
00873
00874 return( 0 );
00875 }
00876
00877 #endif
00878
00879 #endif