32 #if !defined(POLARSSL_CONFIG_FILE)
35 #include POLARSSL_CONFIG_FILE
38 #if defined(POLARSSL_CAMELLIA_C)
42 #if defined(POLARSSL_PLATFORM_C)
45 #define polarssl_printf printf
48 #if !defined(POLARSSL_CAMELLIA_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) ); \
78 static const unsigned char SIGMA_CHARS[6][8] =
80 { 0xa0, 0x9e, 0x66, 0x7f, 0x3b, 0xcc, 0x90, 0x8b },
81 { 0xb6, 0x7a, 0xe8, 0x58, 0x4c, 0xaa, 0x73, 0xb2 },
82 { 0xc6, 0xef, 0x37, 0x2f, 0xe9, 0x4f, 0x82, 0xbe },
83 { 0x54, 0xff, 0x53, 0xa5, 0xf1, 0xd3, 0x6f, 0x1c },
84 { 0x10, 0xe5, 0x27, 0xfa, 0xde, 0x68, 0x2d, 0x1d },
85 { 0xb0, 0x56, 0x88, 0xc2, 0xb3, 0xe6, 0xc1, 0xfd }
88 #if defined(POLARSSL_CAMELLIA_SMALL_MEMORY)
90 static const unsigned char FSb[256] =
92 112,130, 44,236,179, 39,192,229,228,133, 87, 53,234, 12,174, 65,
93 35,239,107,147, 69, 25,165, 33,237, 14, 79, 78, 29,101,146,189,
94 134,184,175,143,124,235, 31,206, 62, 48,220, 95, 94,197, 11, 26,
95 166,225, 57,202,213, 71, 93, 61,217, 1, 90,214, 81, 86,108, 77,
96 139, 13,154,102,251,204,176, 45,116, 18, 43, 32,240,177,132,153,
97 223, 76,203,194, 52,126,118, 5,109,183,169, 49,209, 23, 4,215,
98 20, 88, 58, 97,222, 27, 17, 28, 50, 15,156, 22, 83, 24,242, 34,
99 254, 68,207,178,195,181,122,145, 36, 8,232,168, 96,252,105, 80,
100 170,208,160,125,161,137, 98,151, 84, 91, 30,149,224,255,100,210,
101 16,196, 0, 72,163,247,117,219,138, 3,230,218, 9, 63,221,148,
102 135, 92,131, 2,205, 74,144, 51,115,103,246,243,157,127,191,226,
103 82,155,216, 38,200, 55,198, 59,129,150,111, 75, 19,190, 99, 46,
104 233,121,167,140,159,110,188,142, 41,245,249,182, 47,253,180, 89,
105 120,152, 6,106,231, 70,113,186,212, 37,171, 66,136,162,141,250,
106 114, 7,185, 85,248,238,172, 10, 54, 73, 42,104, 60, 56,241,164,
107 64, 40,211,123,187,201, 67,193, 21,227,173,244,119,199,128,158
110 #define SBOX1(n) FSb[(n)]
111 #define SBOX2(n) (unsigned char)((FSb[(n)] >> 7 ^ FSb[(n)] << 1) & 0xff)
112 #define SBOX3(n) (unsigned char)((FSb[(n)] >> 1 ^ FSb[(n)] << 7) & 0xff)
113 #define SBOX4(n) FSb[((n) << 1 ^ (n) >> 7) &0xff]
117 static const unsigned char FSb[256] =
119 112, 130, 44, 236, 179, 39, 192, 229, 228, 133, 87, 53, 234, 12, 174, 65,
120 35, 239, 107, 147, 69, 25, 165, 33, 237, 14, 79, 78, 29, 101, 146, 189,
121 134, 184, 175, 143, 124, 235, 31, 206, 62, 48, 220, 95, 94, 197, 11, 26,
122 166, 225, 57, 202, 213, 71, 93, 61, 217, 1, 90, 214, 81, 86, 108, 77,
123 139, 13, 154, 102, 251, 204, 176, 45, 116, 18, 43, 32, 240, 177, 132, 153,
124 223, 76, 203, 194, 52, 126, 118, 5, 109, 183, 169, 49, 209, 23, 4, 215,
125 20, 88, 58, 97, 222, 27, 17, 28, 50, 15, 156, 22, 83, 24, 242, 34,
126 254, 68, 207, 178, 195, 181, 122, 145, 36, 8, 232, 168, 96, 252, 105, 80,
127 170, 208, 160, 125, 161, 137, 98, 151, 84, 91, 30, 149, 224, 255, 100, 210,
128 16, 196, 0, 72, 163, 247, 117, 219, 138, 3, 230, 218, 9, 63, 221, 148,
129 135, 92, 131, 2, 205, 74, 144, 51, 115, 103, 246, 243, 157, 127, 191, 226,
130 82, 155, 216, 38, 200, 55, 198, 59, 129, 150, 111, 75, 19, 190, 99, 46,
131 233, 121, 167, 140, 159, 110, 188, 142, 41, 245, 249, 182, 47, 253, 180, 89,
132 120, 152, 6, 106, 231, 70, 113, 186, 212, 37, 171, 66, 136, 162, 141, 250,
133 114, 7, 185, 85, 248, 238, 172, 10, 54, 73, 42, 104, 60, 56, 241, 164,
134 64, 40, 211, 123, 187, 201, 67, 193, 21, 227, 173, 244, 119, 199, 128, 158
137 static const unsigned char FSb2[256] =
139 224, 5, 88, 217, 103, 78, 129, 203, 201, 11, 174, 106, 213, 24, 93, 130,
140 70, 223, 214, 39, 138, 50, 75, 66, 219, 28, 158, 156, 58, 202, 37, 123,
141 13, 113, 95, 31, 248, 215, 62, 157, 124, 96, 185, 190, 188, 139, 22, 52,
142 77, 195, 114, 149, 171, 142, 186, 122, 179, 2, 180, 173, 162, 172, 216, 154,
143 23, 26, 53, 204, 247, 153, 97, 90, 232, 36, 86, 64, 225, 99, 9, 51,
144 191, 152, 151, 133, 104, 252, 236, 10, 218, 111, 83, 98, 163, 46, 8, 175,
145 40, 176, 116, 194, 189, 54, 34, 56, 100, 30, 57, 44, 166, 48, 229, 68,
146 253, 136, 159, 101, 135, 107, 244, 35, 72, 16, 209, 81, 192, 249, 210, 160,
147 85, 161, 65, 250, 67, 19, 196, 47, 168, 182, 60, 43, 193, 255, 200, 165,
148 32, 137, 0, 144, 71, 239, 234, 183, 21, 6, 205, 181, 18, 126, 187, 41,
149 15, 184, 7, 4, 155, 148, 33, 102, 230, 206, 237, 231, 59, 254, 127, 197,
150 164, 55, 177, 76, 145, 110, 141, 118, 3, 45, 222, 150, 38, 125, 198, 92,
151 211, 242, 79, 25, 63, 220, 121, 29, 82, 235, 243, 109, 94, 251, 105, 178,
152 240, 49, 12, 212, 207, 140, 226, 117, 169, 74, 87, 132, 17, 69, 27, 245,
153 228, 14, 115, 170, 241, 221, 89, 20, 108, 146, 84, 208, 120, 112, 227, 73,
154 128, 80, 167, 246, 119, 147, 134, 131, 42, 199, 91, 233, 238, 143, 1, 61
157 static const unsigned char FSb3[256] =
159 56, 65, 22, 118, 217, 147, 96, 242, 114, 194, 171, 154, 117, 6, 87, 160,
160 145, 247, 181, 201, 162, 140, 210, 144, 246, 7, 167, 39, 142, 178, 73, 222,
161 67, 92, 215, 199, 62, 245, 143, 103, 31, 24, 110, 175, 47, 226, 133, 13,
162 83, 240, 156, 101, 234, 163, 174, 158, 236, 128, 45, 107, 168, 43, 54, 166,
163 197, 134, 77, 51, 253, 102, 88, 150, 58, 9, 149, 16, 120, 216, 66, 204,
164 239, 38, 229, 97, 26, 63, 59, 130, 182, 219, 212, 152, 232, 139, 2, 235,
165 10, 44, 29, 176, 111, 141, 136, 14, 25, 135, 78, 11, 169, 12, 121, 17,
166 127, 34, 231, 89, 225, 218, 61, 200, 18, 4, 116, 84, 48, 126, 180, 40,
167 85, 104, 80, 190, 208, 196, 49, 203, 42, 173, 15, 202, 112, 255, 50, 105,
168 8, 98, 0, 36, 209, 251, 186, 237, 69, 129, 115, 109, 132, 159, 238, 74,
169 195, 46, 193, 1, 230, 37, 72, 153, 185, 179, 123, 249, 206, 191, 223, 113,
170 41, 205, 108, 19, 100, 155, 99, 157, 192, 75, 183, 165, 137, 95, 177, 23,
171 244, 188, 211, 70, 207, 55, 94, 71, 148, 250, 252, 91, 151, 254, 90, 172,
172 60, 76, 3, 53, 243, 35, 184, 93, 106, 146, 213, 33, 68, 81, 198, 125,
173 57, 131, 220, 170, 124, 119, 86, 5, 27, 164, 21, 52, 30, 28, 248, 82,
174 32, 20, 233, 189, 221, 228, 161, 224, 138, 241, 214, 122, 187, 227, 64, 79
177 static const unsigned char FSb4[256] =
179 112, 44, 179, 192, 228, 87, 234, 174, 35, 107, 69, 165, 237, 79, 29, 146,
180 134, 175, 124, 31, 62, 220, 94, 11, 166, 57, 213, 93, 217, 90, 81, 108,
181 139, 154, 251, 176, 116, 43, 240, 132, 223, 203, 52, 118, 109, 169, 209, 4,
182 20, 58, 222, 17, 50, 156, 83, 242, 254, 207, 195, 122, 36, 232, 96, 105,
183 170, 160, 161, 98, 84, 30, 224, 100, 16, 0, 163, 117, 138, 230, 9, 221,
184 135, 131, 205, 144, 115, 246, 157, 191, 82, 216, 200, 198, 129, 111, 19, 99,
185 233, 167, 159, 188, 41, 249, 47, 180, 120, 6, 231, 113, 212, 171, 136, 141,
186 114, 185, 248, 172, 54, 42, 60, 241, 64, 211, 187, 67, 21, 173, 119, 128,
187 130, 236, 39, 229, 133, 53, 12, 65, 239, 147, 25, 33, 14, 78, 101, 189,
188 184, 143, 235, 206, 48, 95, 197, 26, 225, 202, 71, 61, 1, 214, 86, 77,
189 13, 102, 204, 45, 18, 32, 177, 153, 76, 194, 126, 5, 183, 49, 23, 215,
190 88, 97, 27, 28, 15, 22, 24, 34, 68, 178, 181, 145, 8, 168, 252, 80,
191 208, 125, 137, 151, 91, 149, 255, 210, 196, 72, 247, 219, 3, 218, 63, 148,
192 92, 2, 74, 51, 103, 243, 127, 226, 155, 38, 55, 59, 150, 75, 190, 46,
193 121, 140, 110, 142, 245, 182, 253, 89, 152, 106, 70, 186, 37, 66, 162, 250,
194 7, 85, 238, 10, 73, 104, 56, 164, 40, 123, 201, 193, 227, 244, 199, 158
197 #define SBOX1(n) FSb[(n)]
198 #define SBOX2(n) FSb2[(n)]
199 #define SBOX3(n) FSb3[(n)]
200 #define SBOX4(n) FSb4[(n)]
204 static const unsigned char shifts[2][4][4] =
220 static const signed char indexes[2][4][20] =
223 { 0, 1, 2, 3, 8, 9, 10, 11, 38, 39,
224 36, 37, 23, 20, 21, 22, 27, -1, -1, 26 },
225 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
226 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
227 { 4, 5, 6, 7, 12, 13, 14, 15, 16, 17,
228 18, 19, -1, 24, 25, -1, 31, 28, 29, 30 },
229 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
230 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }
233 { 0, 1, 2, 3, 61, 62, 63, 60, -1, -1,
234 -1, -1, 27, 24, 25, 26, 35, 32, 33, 34 },
235 { -1, -1, -1, -1, 8, 9, 10, 11, 16, 17,
236 18, 19, -1, -1, -1, -1, 39, 36, 37, 38 },
237 { -1, -1, -1, -1, 12, 13, 14, 15, 58, 59,
238 56, 57, 31, 28, 29, 30, -1, -1, -1, -1 },
239 { 4, 5, 6, 7, 65, 66, 67, 64, 20, 21,
240 22, 23, -1, -1, -1, -1, 43, 40, 41, 42 }
244 static const signed char transposes[2][20] =
263 #define ROTL(DEST, SRC, SHIFT) \
265 (DEST)[0] = (SRC)[0] << (SHIFT) ^ (SRC)[1] >> (32 - (SHIFT)); \
266 (DEST)[1] = (SRC)[1] << (SHIFT) ^ (SRC)[2] >> (32 - (SHIFT)); \
267 (DEST)[2] = (SRC)[2] << (SHIFT) ^ (SRC)[3] >> (32 - (SHIFT)); \
268 (DEST)[3] = (SRC)[3] << (SHIFT) ^ (SRC)[0] >> (32 - (SHIFT)); \
271 #define FL(XL, XR, KL, KR) \
273 (XR) = ((((XL) & (KL)) << 1) | (((XL) & (KL)) >> 31)) ^ (XR); \
274 (XL) = ((XR) | (KR)) ^ (XL); \
277 #define FLInv(YL, YR, KL, KR) \
279 (YL) = ((YR) | (KR)) ^ (YL); \
280 (YR) = ((((YL) & (KL)) << 1) | (((YL) & (KL)) >> 31)) ^ (YR); \
283 #define SHIFT_AND_PLACE(INDEX, OFFSET) \
285 TK[0] = KC[(OFFSET) * 4 + 0]; \
286 TK[1] = KC[(OFFSET) * 4 + 1]; \
287 TK[2] = KC[(OFFSET) * 4 + 2]; \
288 TK[3] = KC[(OFFSET) * 4 + 3]; \
290 for( i = 1; i <= 4; i++ ) \
291 if( shifts[(INDEX)][(OFFSET)][i -1] ) \
292 ROTL(TK + i * 4, TK, ( 15 * i ) % 32); \
294 for( i = 0; i < 20; i++ ) \
295 if( indexes[(INDEX)][(OFFSET)][i] != -1 ) { \
296 RK[indexes[(INDEX)][(OFFSET)][i]] = TK[ i ]; \
300 static void camellia_feistel(
const uint32_t x[2],
const uint32_t k[2],
307 I0 = (SBOX1((I0 >> 24) & 0xFF) << 24) |
308 (SBOX2((I0 >> 16) & 0xFF) << 16) |
309 (SBOX3((I0 >> 8) & 0xFF) << 8) |
310 (SBOX4((I0 ) & 0xFF) );
311 I1 = (SBOX2((I1 >> 24) & 0xFF) << 24) |
312 (SBOX3((I1 >> 16) & 0xFF) << 16) |
313 (SBOX4((I1 >> 8) & 0xFF) << 8) |
314 (SBOX1((I1 ) & 0xFF) );
316 I0 ^= (I1 << 8) | (I1 >> 24);
317 I1 ^= (I0 << 16) | (I0 >> 16);
318 I0 ^= (I1 >> 8) | (I1 << 24);
319 I1 ^= (I0 >> 8) | (I0 << 24);
342 unsigned int keysize )
348 uint32_t SIGMA[6][2];
355 memset( RK, 0,
sizeof(ctx->
rk) );
359 case 128: ctx->
nr = 3; idx = 0;
break;
361 case 256: ctx->
nr = 4; idx = 1;
break;
365 for( i = 0; i < keysize / 8; ++i )
368 if( keysize == 192 ) {
369 for( i = 0; i < 8; i++ )
370 t[24 + i] = ~t[16 + i];
376 for( i = 0; i < 6; i++ ) {
385 memset( KC, 0,
sizeof(KC) );
388 for( i = 0; i < 8; i++ )
392 for( i = 0; i < 4; ++i )
393 KC[8 + i] = KC[i] ^ KC[4 + i];
395 camellia_feistel( KC + 8, SIGMA[0], KC + 10 );
396 camellia_feistel( KC + 10, SIGMA[1], KC + 8 );
398 for( i = 0; i < 4; ++i )
401 camellia_feistel( KC + 8, SIGMA[2], KC + 10 );
402 camellia_feistel( KC + 10, SIGMA[3], KC + 8 );
404 if( keysize > 128 ) {
406 for( i = 0; i < 4; ++i )
407 KC[12 + i] = KC[4 + i] ^ KC[8 + i];
409 camellia_feistel( KC + 12, SIGMA[4], KC + 14 );
410 camellia_feistel( KC + 14, SIGMA[5], KC + 12 );
418 SHIFT_AND_PLACE( idx, 0 );
421 if( keysize > 128 ) {
422 SHIFT_AND_PLACE( idx, 1 );
426 SHIFT_AND_PLACE( idx, 2 );
429 if( keysize > 128 ) {
430 SHIFT_AND_PLACE( idx, 3 );
434 for( i = 0; i < 20; i++ ) {
435 if( transposes[idx][i] != -1 ) {
436 RK[32 + 12 * idx + i] = RK[transposes[idx][i]];
447 unsigned int keysize )
462 idx = ( ctx->
nr == 4 );
465 SK = cty.
rk + 24 * 2 + 8 * idx * 2;
472 for( i = 22 + 8 * idx, SK -= 6; i > 0; i--, SK -= 4 )
496 const unsigned char input[16],
497 unsigned char output[16] )
519 camellia_feistel( X, RK, X + 2 );
521 camellia_feistel( X + 2, RK, X );
523 camellia_feistel( X, RK, X + 2 );
525 camellia_feistel( X + 2, RK, X );
527 camellia_feistel( X, RK, X + 2 );
529 camellia_feistel( X + 2, RK, X );
533 FL(X[0], X[1], RK[0], RK[1]);
535 FLInv(X[2], X[3], RK[0], RK[1]);
553 #if defined(POLARSSL_CIPHER_MODE_CBC)
560 unsigned char iv[16],
561 const unsigned char *input,
562 unsigned char *output )
565 unsigned char temp[16];
574 memcpy( temp, input, 16 );
577 for( i = 0; i < 16; i++ )
578 output[i] = (
unsigned char)( output[i] ^ iv[i] );
580 memcpy( iv, temp, 16 );
591 for( i = 0; i < 16; i++ )
592 output[i] = (
unsigned char)( input[i] ^ iv[i] );
595 memcpy( iv, output, 16 );
607 #if defined(POLARSSL_CIPHER_MODE_CFB)
615 unsigned char iv[16],
616 const unsigned char *input,
617 unsigned char *output )
630 *output++ = (
unsigned char)( c ^ iv[n] );
631 iv[n] = (
unsigned char) c;
633 n = ( n + 1 ) & 0x0F;
643 iv[n] = *output++ = (
unsigned char)( iv[n] ^ *input++ );
645 n = ( n + 1 ) & 0x0F;
655 #if defined(POLARSSL_CIPHER_MODE_CTR)
662 unsigned char nonce_counter[16],
663 unsigned char stream_block[16],
664 const unsigned char *input,
665 unsigned char *output )
676 for( i = 16; i > 0; i-- )
677 if( ++nonce_counter[i - 1] != 0 )
681 *output++ = (
unsigned char)( c ^ stream_block[n] );
683 n = ( n + 1 ) & 0x0F;
693 #if defined(POLARSSL_SELF_TEST)
705 #define CAMELLIA_TESTS_ECB 2
707 static const unsigned char camellia_test_ecb_key[3][CAMELLIA_TESTS_ECB][32] =
710 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
711 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
712 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
713 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
716 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
717 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
718 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 },
719 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
720 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
721 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
724 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
725 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
726 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
727 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
728 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
729 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
730 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
731 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
735 static const unsigned char camellia_test_ecb_plain[CAMELLIA_TESTS_ECB][16] =
737 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
738 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
739 { 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
740 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
743 static const unsigned char camellia_test_ecb_cipher[3][CAMELLIA_TESTS_ECB][16] =
746 { 0x67, 0x67, 0x31, 0x38, 0x54, 0x96, 0x69, 0x73,
747 0x08, 0x57, 0x06, 0x56, 0x48, 0xea, 0xbe, 0x43 },
748 { 0x38, 0x3C, 0x6C, 0x2A, 0xAB, 0xEF, 0x7F, 0xDE,
749 0x25, 0xCD, 0x47, 0x0B, 0xF7, 0x74, 0xA3, 0x31 }
752 { 0xb4, 0x99, 0x34, 0x01, 0xb3, 0xe9, 0x96, 0xf8,
753 0x4e, 0xe5, 0xce, 0xe7, 0xd7, 0x9b, 0x09, 0xb9 },
754 { 0xD1, 0x76, 0x3F, 0xC0, 0x19, 0xD7, 0x7C, 0xC9,
755 0x30, 0xBF, 0xF2, 0xA5, 0x6F, 0x7C, 0x93, 0x64 }
758 { 0x9a, 0xcc, 0x23, 0x7d, 0xff, 0x16, 0xd7, 0x6c,
759 0x20, 0xef, 0x7c, 0x91, 0x9e, 0x3a, 0x75, 0x09 },
760 { 0x05, 0x03, 0xFB, 0x10, 0xAB, 0x24, 0x1E, 0x7C,
761 0xF4, 0x5D, 0x8C, 0xDE, 0xEE, 0x47, 0x43, 0x35 }
765 #if defined(POLARSSL_CIPHER_MODE_CBC)
766 #define CAMELLIA_TESTS_CBC 3
768 static const unsigned char camellia_test_cbc_key[3][32] =
770 { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
771 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C }
773 { 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,
774 0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,
775 0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B }
777 { 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
778 0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
779 0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
780 0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4 }
783 static const unsigned char camellia_test_cbc_iv[16] =
785 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
786 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }
789 static const unsigned char camellia_test_cbc_plain[CAMELLIA_TESTS_CBC][16] =
791 { 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
792 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A },
793 { 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
794 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51 },
795 { 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11,
796 0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF }
800 static const unsigned char camellia_test_cbc_cipher[3][CAMELLIA_TESTS_CBC][16] =
803 { 0x16, 0x07, 0xCF, 0x49, 0x4B, 0x36, 0xBB, 0xF0,
804 0x0D, 0xAE, 0xB0, 0xB5, 0x03, 0xC8, 0x31, 0xAB },
805 { 0xA2, 0xF2, 0xCF, 0x67, 0x16, 0x29, 0xEF, 0x78,
806 0x40, 0xC5, 0xA5, 0xDF, 0xB5, 0x07, 0x48, 0x87 },
807 { 0x0F, 0x06, 0x16, 0x50, 0x08, 0xCF, 0x8B, 0x8B,
808 0x5A, 0x63, 0x58, 0x63, 0x62, 0x54, 0x3E, 0x54 }
811 { 0x2A, 0x48, 0x30, 0xAB, 0x5A, 0xC4, 0xA1, 0xA2,
812 0x40, 0x59, 0x55, 0xFD, 0x21, 0x95, 0xCF, 0x93 },
813 { 0x5D, 0x5A, 0x86, 0x9B, 0xD1, 0x4C, 0xE5, 0x42,
814 0x64, 0xF8, 0x92, 0xA6, 0xDD, 0x2E, 0xC3, 0xD5 },
815 { 0x37, 0xD3, 0x59, 0xC3, 0x34, 0x98, 0x36, 0xD8,
816 0x84, 0xE3, 0x10, 0xAD, 0xDF, 0x68, 0xC4, 0x49 }
819 { 0xE6, 0xCF, 0xA3, 0x5F, 0xC0, 0x2B, 0x13, 0x4A,
820 0x4D, 0x2C, 0x0B, 0x67, 0x37, 0xAC, 0x3E, 0xDA },
821 { 0x36, 0xCB, 0xEB, 0x73, 0xBD, 0x50, 0x4B, 0x40,
822 0x70, 0xB1, 0xB7, 0xDE, 0x2B, 0x21, 0xEB, 0x50 },
823 { 0xE3, 0x1A, 0x60, 0x55, 0x29, 0x7D, 0x96, 0xCA,
824 0x33, 0x30, 0xCD, 0xF1, 0xB1, 0x86, 0x0A, 0x83 }
829 #if defined(POLARSSL_CIPHER_MODE_CTR)
836 static const unsigned char camellia_test_ctr_key[3][16] =
838 { 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
839 0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E },
840 { 0x7E, 0x24, 0x06, 0x78, 0x17, 0xFA, 0xE0, 0xD7,
841 0x43, 0xD6, 0xCE, 0x1F, 0x32, 0x53, 0x91, 0x63 },
842 { 0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8,
843 0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC }
846 static const unsigned char camellia_test_ctr_nonce_counter[3][16] =
848 { 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
849 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
850 { 0x00, 0x6C, 0xB6, 0xDB, 0xC0, 0x54, 0x3B, 0x59,
851 0xDA, 0x48, 0xD9, 0x0B, 0x00, 0x00, 0x00, 0x01 },
852 { 0x00, 0xE0, 0x01, 0x7B, 0x27, 0x77, 0x7F, 0x3F,
853 0x4A, 0x17, 0x86, 0xF0, 0x00, 0x00, 0x00, 0x01 }
856 static const unsigned char camellia_test_ctr_pt[3][48] =
858 { 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62,
859 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6D, 0x73, 0x67 },
861 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
862 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
863 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
864 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F },
866 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
867 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
868 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
869 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
870 0x20, 0x21, 0x22, 0x23 }
873 static const unsigned char camellia_test_ctr_ct[3][48] =
875 { 0xD0, 0x9D, 0xC2, 0x9A, 0x82, 0x14, 0x61, 0x9A,
876 0x20, 0x87, 0x7C, 0x76, 0xDB, 0x1F, 0x0B, 0x3F },
877 { 0xDB, 0xF3, 0xC7, 0x8D, 0xC0, 0x83, 0x96, 0xD4,
878 0xDA, 0x7C, 0x90, 0x77, 0x65, 0xBB, 0xCB, 0x44,
879 0x2B, 0x8E, 0x8E, 0x0F, 0x31, 0xF0, 0xDC, 0xA7,
880 0x2C, 0x74, 0x17, 0xE3, 0x53, 0x60, 0xE0, 0x48 },
881 { 0xB1, 0x9D, 0x1F, 0xCD, 0xCB, 0x75, 0xEB, 0x88,
882 0x2F, 0x84, 0x9C, 0xE2, 0x4D, 0x85, 0xCF, 0x73,
883 0x9C, 0xE6, 0x4B, 0x2B, 0x5C, 0x9D, 0x73, 0xF1,
884 0x4F, 0x2D, 0x5D, 0x9D, 0xCE, 0x98, 0x89, 0xCD,
885 0xDF, 0x50, 0x86, 0x96 }
888 static const int camellia_test_ctr_len[3] =
898 unsigned char key[32];
899 unsigned char buf[64];
900 unsigned char src[16];
901 unsigned char dst[16];
902 #if defined(POLARSSL_CIPHER_MODE_CBC)
903 unsigned char iv[16];
905 #if defined(POLARSSL_CIPHER_MODE_CTR)
907 unsigned char nonce_counter[16];
908 unsigned char stream_block[16];
913 memset( key, 0, 32 );
915 for( j = 0; j < 6; j++ ) {
923 for( i = 0; i < CAMELLIA_TESTS_ECB; i++ ) {
924 memcpy( key, camellia_test_ecb_key[u][i], 16 + 8 * u );
928 memcpy( src, camellia_test_ecb_cipher[u][i], 16 );
929 memcpy( dst, camellia_test_ecb_plain[i], 16 );
932 memcpy( src, camellia_test_ecb_plain[i], 16 );
933 memcpy( dst, camellia_test_ecb_cipher[u][i], 16 );
938 if( memcmp( buf, dst, 16 ) != 0 )
954 #if defined(POLARSSL_CIPHER_MODE_CBC)
958 for( j = 0; j < 6; j++ )
967 memcpy( src, camellia_test_cbc_iv, 16 );
968 memcpy( dst, camellia_test_cbc_iv, 16 );
969 memcpy( key, camellia_test_cbc_key[u], 16 + 8 * u );
977 for( i = 0; i < CAMELLIA_TESTS_CBC; i++ ) {
980 memcpy( iv , src, 16 );
981 memcpy( src, camellia_test_cbc_cipher[u][i], 16 );
982 memcpy( dst, camellia_test_cbc_plain[i], 16 );
984 memcpy( iv , dst, 16 );
985 memcpy( src, camellia_test_cbc_plain[i], 16 );
986 memcpy( dst, camellia_test_cbc_cipher[u][i], 16 );
991 if( memcmp( buf, dst, 16 ) != 0 )
1008 #if defined(POLARSSL_CIPHER_MODE_CTR)
1012 for( i = 0; i < 6; i++ )
1021 memcpy( nonce_counter, camellia_test_ctr_nonce_counter[u], 16 );
1022 memcpy( key, camellia_test_ctr_key[u], 16 );
1029 len = camellia_test_ctr_len[u];
1030 memcpy( buf, camellia_test_ctr_ct[u], len );
1035 if( memcmp( buf, camellia_test_ctr_pt[u], len ) != 0 )
1045 len = camellia_test_ctr_len[u];
1046 memcpy( buf, camellia_test_ctr_pt[u], len );
1051 if( memcmp( buf, camellia_test_ctr_ct[u], len ) != 0 )
int camellia_crypt_cbc(camellia_context *ctx, int mode, size_t length, unsigned char iv[16], const unsigned char *input, unsigned char *output)
CAMELLIA-CBC buffer encryption/decryption Length should be a multiple of the block size (16 bytes) ...
Configuration options (set of defines)
int camellia_setkey_enc(camellia_context *ctx, const unsigned char *key, unsigned int keysize)
CAMELLIA key schedule (encryption)
int camellia_crypt_ctr(camellia_context *ctx, size_t length, size_t *nc_off, unsigned char nonce_counter[16], unsigned char stream_block[16], const unsigned char *input, unsigned char *output)
CAMELLIA-CTR buffer encryption/decryption.
int camellia_self_test(int verbose)
Checkup routine.
int camellia_crypt_cfb128(camellia_context *ctx, int mode, size_t length, size_t *iv_off, unsigned char iv[16], const unsigned char *input, unsigned char *output)
CAMELLIA-CFB128 buffer encryption/decryption.
void camellia_init(camellia_context *ctx)
Initialize CAMELLIA context.
#define PUT_UINT32_BE(n, b, i)
#define POLARSSL_ERR_CAMELLIA_INVALID_INPUT_LENGTH
Invalid data input length.
CAMELLIA context structure.
void camellia_free(camellia_context *ctx)
Clear CAMELLIA context.
int camellia_crypt_ecb(camellia_context *ctx, int mode, const unsigned char input[16], unsigned char output[16])
CAMELLIA-ECB block encryption/decryption.
int camellia_setkey_dec(camellia_context *ctx, const unsigned char *key, unsigned int keysize)
CAMELLIA key schedule (decryption)
#define GET_UINT32_BE(n, b, i)
#define POLARSSL_ERR_CAMELLIA_INVALID_KEY_LENGTH
Invalid key length.