3 This file is part of the ARM-Crypto-Lib.
4 Copyright (C) 2006-2010 Daniel Otte (daniel.otte@rub.de)
6 This program is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
29 #include "uart_lowlevel.h"
35 #include "nessie_bc_test.h"
36 #include "performance_test.h"
38 #include "bcal_aes128.h"
39 #include "bcal_aes192.h"
40 #include "bcal_aes256.h"
42 #include "bcal-cfb_byte.h"
43 #include "bcal-cfb_bit.h"
46 #include "bcal-cmac.h"
49 #include "bcal-performance.h"
52 char* algo_name = "AES";
54 void uart0_putc(char byte){
55 uart_putc(UART_0, byte);
58 char uart0_getc(void){
59 return uart_getc(UART_0);
62 const bcdesc_t* algolist[] = {
63 (bcdesc_t*)&aes128_desc,
64 (bcdesc_t*)&aes192_desc,
65 (bcdesc_t*)&aes256_desc,
69 /*****************************************************************************
70 * additional validation-functions *
71 *****************************************************************************/
73 void testrun_nessie_aes(void){
74 nessie_bc_ctx.blocksize_B = 16;
75 nessie_bc_ctx.keysize_b = 128;
76 nessie_bc_ctx.name = algo_name;
77 nessie_bc_ctx.ctx_size_B = sizeof(aes128_ctx_t);
78 nessie_bc_ctx.cipher_enc = (nessie_bc_enc_fpt)aes128_enc;
79 nessie_bc_ctx.cipher_dec = (nessie_bc_dec_fpt)aes128_dec;
80 nessie_bc_ctx.cipher_genctx = (nessie_bc_gen_fpt)aes_init;
83 nessie_bc_ctx.keysize_b = 192;
84 nessie_bc_ctx.ctx_size_B = sizeof(aes192_ctx_t);
85 nessie_bc_ctx.cipher_enc = (nessie_bc_enc_fpt)aes192_enc;
86 nessie_bc_ctx.cipher_dec = (nessie_bc_dec_fpt)aes192_dec;
89 nessie_bc_ctx.keysize_b = 256;
90 nessie_bc_ctx.ctx_size_B = sizeof(aes256_ctx_t);
91 nessie_bc_ctx.cipher_enc = (nessie_bc_enc_fpt)aes256_enc;
92 nessie_bc_ctx.cipher_dec = (nessie_bc_dec_fpt)aes256_dec;
96 void testrun_test_aes(void){
97 uint8_t key[16] = { 0x2b, 0x7e, 0x15, 0x16,
98 0x28, 0xae, 0xd2, 0xa6,
99 0xab, 0xf7, 0x15, 0x88,
100 0x09, 0xcf, 0x4f, 0x3c };
101 uint8_t data[16] = { 0x32, 0x43, 0xf6, 0xa8,
102 0x88, 0x5a, 0x30, 0x8d,
103 0x31, 0x31, 0x98, 0xa2,
104 0xe0, 0x37, 0x07, 0x34 };
106 aes128_init(key, &ctx);
107 cli_putstr("\r\n\r\n cipher test (FIPS 197):\r\n key: ");
108 cli_hexdump(key, 16);
109 cli_putstr("\r\n plaintext: ");
110 cli_hexdump(data, 16);
111 aes128_enc(data, &ctx);
112 cli_putstr("\r\n ciphertext: ");
113 cli_hexdump(data, 16);
114 aes128_dec(data, &ctx);
115 cli_putstr("\r\n plaintext: ");
116 cli_hexdump(data, 16);
117 cli_putstr("\r\n testing bcal:");
118 bcgen_ctx_t bcal_ctx;
120 r = bcal_cipher_init(&aes128_desc, key, 128, &bcal_ctx);
121 cli_putstr("\r\n init = 0x");
124 bcal_cipher_enc(data, &bcal_ctx);
125 cli_putstr("\r\n ciphertext: ");
126 cli_hexdump(data, 16);
127 bcal_cipher_dec(data, &bcal_ctx);
128 cli_putstr("\r\n plaintext: ");
129 cli_hexdump(data, 16);
130 bcal_cipher_free(&bcal_ctx);
133 void testrun_testkey_aes128(void){
134 uint8_t key[16] = { 0x2b, 0x7e, 0x15, 0x16,
135 0x28, 0xae, 0xd2, 0xa6,
136 0xab, 0xf7, 0x15, 0x88,
137 0x09, 0xcf, 0x4f, 0x3c};
140 aes128_init(key, &ctx);
141 cli_putstr("\r\n\r\n keyschedule test (FIPS 197):\r\n key: ");
142 cli_hexdump(key, 16);
144 cli_putstr("\r\n index: ");
147 cli_putstr(" roundkey ");
148 cli_hexdump(ctx.key[i].ks, 16);
152 void testrun_testkey_aes192(void){
153 uint8_t key[24] = { 0x8e, 0x73, 0xb0, 0xf7,
154 0xda, 0x0e, 0x64, 0x52,
155 0xc8, 0x10, 0xf3, 0x2b,
156 0x80, 0x90, 0x79, 0xe5,
157 0x62, 0xf8, 0xea, 0xd2,
158 0x52, 0x2c, 0x6b, 0x7b};
161 memset(&ctx, 0, sizeof(aes192_ctx_t));
162 aes192_init(key, &ctx);
163 cli_putstr("\r\n\r\n keyschedule test (FIPS 197):\r\n key: ");
164 cli_hexdump(key, 24);
166 cli_putstr("\r\n index: ");
169 cli_putstr(" roundkey ");
170 cli_hexdump(ctx.key[i].ks, 16);
175 void testrun_testkey_aes256(void){
176 uint8_t key[32] = { 0x60, 0x3d, 0xeb, 0x10,
177 0x15, 0xca, 0x71, 0xbe,
178 0x2b, 0x73, 0xae, 0xf0,
179 0x85, 0x7d, 0x77, 0x81,
180 0x1f, 0x35, 0x2c, 0x07,
181 0x3b, 0x61, 0x08, 0xd7,
182 0x2d, 0x98, 0x10, 0xa3,
183 0x09, 0x14, 0xdf, 0xf4};
186 memset(&ctx, 0, sizeof(aes256_ctx_t));
187 aes256_init(key, &ctx);
188 cli_putstr("\r\n\r\n keyschedule test (FIPS 197):\r\n key: ");
189 cli_hexdump(key, 32);
191 cli_putstr("\r\n index: ");
194 cli_putstr(" roundkey ");
195 cli_hexdump(ctx.key[i].ks, 16);
199 void crypto_test(void){
200 uint8_t test_data[16], test_key[32];
202 memset(test_key, 0xA5, 32);
203 memset(test_data, 0, 16);
204 aes256_init(test_key, &ctx);
205 aes256_enc(test_data, &ctx);
206 cli_putstr("\r\ncrypto test data:\r\n");
207 cli_hexdump_block(test_data, 16, 4, 8);
211 void testrun_testkey_aes(void){
212 testrun_testkey_aes128();
213 testrun_testkey_aes192();
214 testrun_testkey_aes256();
217 const uint8_t modes_key[] = {
218 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
219 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
220 0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
221 0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4
223 const uint8_t modes_iv[] = {
224 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
225 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
228 const uint8_t modes_ctriv[] = {
229 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
230 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
233 const uint8_t modes_plain[] = {
234 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
235 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
237 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
238 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
240 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
241 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
243 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
244 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
248 void testrun_aes128_cbc(void){
256 memcpy(key, modes_key, 16);
257 memcpy(iv, modes_iv, 16);
258 memcpy(plain, modes_plain, 64);
260 cli_putstr("\r\n** AES128-CBC-TEST **");
261 r = bcal_cbc_init(&aes128_desc, key, 128, &ctx);
262 cli_putstr("\r\n init = 0x");
264 cli_putstr("\r\n key: ");
265 cli_hexdump(key, 128/8);
266 cli_putstr("\r\n IV: ");
267 cli_hexdump(iv, 128/8);
268 cli_putstr("\r\n plaintext:");
269 cli_hexdump_block(plain, 4*128/8, 4, 16);
272 bcal_cbc_encMsg(iv, plain, 4, &ctx);
273 cli_putstr("\r\n ciphertext: ");
274 cli_hexdump_block(plain, 4*128/8, 4, 16);
275 bcal_cbc_decMsg(iv, plain, 4, &ctx);
276 cli_putstr("\r\n plaintext: ");
277 cli_hexdump_block(plain, 4*128/8, 4, 16);
281 void testrun_aes128_cfb8(void){
286 bcal_cfb_B_ctx_t ctx;
289 memcpy(key, modes_key, 16);
290 memcpy(iv, modes_iv, 16);
291 memcpy(plain, modes_plain, 64);
293 cli_putstr("\r\n** AES128-CFB8-TEST **");
294 r = bcal_cfb_B_init(&aes128_desc, key, 128, 8, &ctx);
295 cli_putstr("\r\n init = 0x");
297 cli_putstr("\r\n key: ");
298 cli_hexdump(key, 128/8);
299 cli_putstr("\r\n IV: ");
300 cli_hexdump(iv, 128/8);
301 cli_putstr("\r\n plaintext:");
302 cli_hexdump_block(plain, 4*128/8, 4, 16);
305 bcal_cfb_B_encMsg(iv, plain, 64, &ctx);
306 cli_putstr("\r\n ciphertext: ");
307 cli_hexdump_block(plain, 64, 4, 16);
309 bcal_cfb_B_decMsg(iv, plain, 64, &ctx);
310 cli_putstr("\r\n plaintext: ");
311 cli_hexdump_block(plain, 64, 4, 16);
313 bcal_cfb_B_free(&ctx);
317 void testrun_aes128_cfb1(void){
322 bcal_cfb_b_ctx_t ctx;
325 memcpy(key, modes_key, 16);
326 memcpy(iv, modes_iv, 16);
327 memcpy(plain, modes_plain, 64);
329 cli_putstr("\r\n** AES128-CFB1-TEST **");
330 r = bcal_cfb_b_init(&aes128_desc, key, 128, 1, &ctx);
331 cli_putstr("\r\n init = 0x");
333 cli_putstr("\r\n key: ");
334 cli_hexdump(key, 128/8);
335 cli_putstr("\r\n IV: ");
336 cli_hexdump(iv, 128/8);
337 cli_putstr("\r\n plaintext:");
338 cli_hexdump_block(plain, 2, 4, 16);
341 uint8_t i, bit_offset, byte_offset;
342 bcal_cfb_b_loadIV(iv, &ctx);
346 cli_putstr("\r\n plain bit: ");
347 cli_putc((plain[byte_offset]&(1<<(7-bit_offset)))?'1':'0');
348 bcal_cfb_b_encNext(plain+byte_offset, bit_offset, &ctx);
349 cli_putstr("\r\n cipher bit: ");
350 cli_putc((plain[byte_offset]&(1<<(7-bit_offset)))?'1':'0');
352 cli_putstr("\r\n ciphertext: ");
353 cli_hexdump_block(plain, 2, 4, 16);
355 bcal_cfb_b_loadIV(iv, &ctx);
359 cli_putstr("\r\n plain bit: ");
360 cli_putc((plain[byte_offset]&(1<<(7-bit_offset)))?'1':'0');
361 bcal_cfb_b_decNext(plain+byte_offset, bit_offset, &ctx);
362 cli_putstr("\r\n cipher bit: ");
363 cli_putc((plain[byte_offset]&(1<<(7-bit_offset)))?'1':'0');
365 cli_putstr("\r\n plaintext: ");
366 cli_hexdump_block(plain, 2, 4, 16);
369 bcal_cfb_b_encMsg(iv, plain, 0, 64*8, &ctx);
370 cli_putstr("\r\n ciphertext: ");
371 cli_hexdump_block(plain, 64, 4, 16);
373 bcal_cfb_b_decMsg(iv, plain, 0, 64*8, &ctx);
374 cli_putstr("\r\n plaintext: ");
375 cli_hexdump_block(plain, 64, 4, 16);
377 bcal_cfb_b_free(&ctx);
380 void testrun_aes128_ofb(void){
388 memcpy(key, modes_key, 16);
389 memcpy(iv, modes_iv, 16);
390 memcpy(plain, modes_plain, 64);
392 cli_putstr("\r\n** AES128-OFB-TEST **");
393 r = bcal_ofb_init(&aes128_desc, key, 128, &ctx);
394 cli_putstr("\r\n init = 0x");
396 cli_putstr("\r\n key: ");
397 cli_hexdump(key, 128/8);
398 cli_putstr("\r\n IV: ");
399 cli_hexdump(iv, 128/8);
400 cli_putstr("\r\n plaintext:");
401 cli_hexdump_block(plain, 4*128/8, 4, 16);
404 bcal_ofb_encMsg(iv, plain, 4*128, &ctx);
405 cli_putstr("\r\n ciphertext: ");
406 cli_hexdump_block(plain, 4*128/8, 4, 16);
407 bcal_ofb_decMsg(iv, plain, 4*128, &ctx);
408 cli_putstr("\r\n plaintext: ");
409 cli_hexdump_block(plain, 4*128/8, 4, 16);
413 void testrun_aes128_ctr(void){
421 memcpy(key, modes_key, 16);
422 memcpy(iv, modes_ctriv, 16);
423 memcpy(plain, modes_plain, 64);
425 cli_putstr("\r\n** AES128-CTR-TEST **");
426 r = bcal_ctr_init(&aes128_desc, key, 128, NULL, &ctx);
427 cli_putstr("\r\n init = 0x");
429 cli_putstr("\r\n key: ");
430 cli_hexdump(key, 128/8);
431 cli_putstr("\r\n IV: ");
432 cli_hexdump(iv, 128/8);
433 cli_putstr("\r\n plaintext:");
434 cli_hexdump_block(plain, 4*128/8, 4, 16);
437 bcal_ctr_encMsg(iv, plain, 4*128, &ctx);
438 cli_putstr("\r\n ciphertext: ");
439 cli_hexdump_block(plain, 4*128/8, 4, 16);
440 bcal_ctr_decMsg(iv, plain, 4*128, &ctx);
441 cli_putstr("\r\n plaintext: ");
442 cli_hexdump_block(plain, 4*128/8, 4, 16);
446 void testrun_aes128_cmac(void){
450 uint16_t length[] = { 0, 128, 320, 512 };
454 memcpy(key, modes_key, 16);
455 memcpy(plain, modes_plain, 64);
457 cli_putstr("\r\n** AES128-CMAC-TEST **");
459 cli_putstr("\r\n key: ");
460 cli_hexdump(key, 128/8);
462 r = bcal_cmac_init(&aes128_desc, key, 128, &ctx);
463 cli_putstr("\r\n init = 0x");
465 cli_putstr("\r\n message: ");
466 cli_hexdump_block(plain, length[i]/8, 4, 16);
469 bcal_cmac(tag, 128, plain, length[i], &ctx);
470 cli_putstr("\r\n tag: ");
471 cli_hexdump_block(tag, 128/8, 4, 16);
472 bcal_cmac_free(&ctx);
479 Key = 3250974e306b4b678f914b514d1e90f6
480 Msg = cf132fd4ebc25fd3866f1a95a6193a1a9cdf
482 void testrun_aes128_cmac72(void){
484 0x32, 0x50, 0x97, 0x4e, 0x30, 0x6b, 0x4b, 0x67,
485 0x8f, 0x91, 0x4b, 0x51, 0x4d, 0x1e, 0x90, 0xf6
488 uint8_t plain[18] = {
489 0xcf, 0x13, 0x2f, 0xd4, 0xeb, 0xc2, 0x5f, 0xd3,
490 0x86, 0x6f, 0x1a, 0x95, 0xa6, 0x19, 0x3a, 0x1a,
497 cli_putstr("\r\n** AES128-CMAC-72-TEST **");
499 cli_putstr("\r\n key: ");
500 cli_hexdump(key, 128/8);
501 r = bcal_cmac_init(&aes128_desc, key, 128, &ctx);
502 cli_putstr("\r\n init = 0x");
504 cli_putstr("\r\n message: ");
505 cli_hexdump_block(plain, 18, 4, 16);
508 bcal_cmac(tag, 16, plain, 18*8, &ctx);
509 cli_putstr("\r\n tag: ");
510 cli_hexdump_block(tag, 2, 4, 16);
511 bcal_cmac_free(&ctx);
518 Key = 2b2aaa666be161ed16648e862ac9bd1e317f71bc69e268b5
521 void testrun_aes192_cmac0(void){
523 0x2b, 0x2a, 0xaa, 0x66, 0x6b, 0xe1, 0x61, 0xed,
524 0x16, 0x64, 0x8e, 0x86, 0x2a, 0xc9, 0xbd, 0x1e,
525 0x31, 0x7f, 0x71, 0xbc, 0x69, 0xe2, 0x68, 0xb5
535 cli_putstr("\r\n** AES192-CMAC-0-TEST **");
537 cli_putstr("\r\n key: ");
538 cli_hexdump(key, 192/8);
539 r = bcal_cmac_init(&aes192_desc, key, 192, &ctx);
540 cli_putstr("\r\n init = 0x");
544 bcal_cmac(tag, 16, plain, 0*8, &ctx);
545 cli_putstr("\r\n tag: ");
546 cli_hexdump_block(tag, 2, 4, 16);
547 bcal_cmac_free(&ctx);
550 const uint8_t eax_msg[] = {
552 0x1A, 0x47, 0xCB, 0x49, 0x33,
553 0x48, 0x1C, 0x9E, 0x39, 0xB1,
554 0x40, 0xD0, 0xC0, 0x7D, 0xA5, 0xE4,
555 0x4D, 0xE3, 0xB3, 0x5C, 0x3F, 0xC0, 0x39, 0x24, 0x5B, 0xD1, 0xFB, 0x7D,
556 0x8B, 0x0A, 0x79, 0x30, 0x6C, 0x9C, 0xE7, 0xED, 0x99, 0xDA, 0xE4, 0xF8, 0x7F, 0x8D, 0xD6, 0x16, 0x36,
557 0x1B, 0xDA, 0x12, 0x2B, 0xCE, 0x8A, 0x8D, 0xBA, 0xF1, 0x87, 0x7D, 0x96, 0x2B, 0x85, 0x92, 0xDD, 0x2D, 0x56,
558 0x6C, 0xF3, 0x67, 0x20, 0x87, 0x2B, 0x85, 0x13, 0xF6, 0xEA, 0xB1, 0xA8, 0xA4, 0x44, 0x38, 0xD5, 0xEF, 0x11,
559 0xCA, 0x40, 0xD7, 0x44, 0x6E, 0x54, 0x5F, 0xFA, 0xED, 0x3B, 0xD1, 0x2A, 0x74, 0x0A, 0x65, 0x9F, 0xFB, 0xBB, 0x3C, 0xEA, 0xB7
562 const uint8_t eax_msg_len[] = {0, 2, 5, 5, 6, 12, 17, 18, 18, 21};
564 const uint8_t eax_key[] = {
565 0x23, 0x39, 0x52, 0xDE, 0xE4, 0xD5, 0xED, 0x5F, 0x9B, 0x9C, 0x6D, 0x6F, 0xF8, 0x0F, 0xF4, 0x78,
566 0x91, 0x94, 0x5D, 0x3F, 0x4D, 0xCB, 0xEE, 0x0B, 0xF4, 0x5E, 0xF5, 0x22, 0x55, 0xF0, 0x95, 0xA4,
567 0x01, 0xF7, 0x4A, 0xD6, 0x40, 0x77, 0xF2, 0xE7, 0x04, 0xC0, 0xF6, 0x0A, 0xDA, 0x3D, 0xD5, 0x23,
568 0xD0, 0x7C, 0xF6, 0xCB, 0xB7, 0xF3, 0x13, 0xBD, 0xDE, 0x66, 0xB7, 0x27, 0xAF, 0xD3, 0xC5, 0xE8,
569 0x35, 0xB6, 0xD0, 0x58, 0x00, 0x05, 0xBB, 0xC1, 0x2B, 0x05, 0x87, 0x12, 0x45, 0x57, 0xD2, 0xC2,
570 0xBD, 0x8E, 0x6E, 0x11, 0x47, 0x5E, 0x60, 0xB2, 0x68, 0x78, 0x4C, 0x38, 0xC6, 0x2F, 0xEB, 0x22,
571 0x7C, 0x77, 0xD6, 0xE8, 0x13, 0xBE, 0xD5, 0xAC, 0x98, 0xBA, 0xA4, 0x17, 0x47, 0x7A, 0x2E, 0x7D,
572 0x5F, 0xFF, 0x20, 0xCA, 0xFA, 0xB1, 0x19, 0xCA, 0x2F, 0xC7, 0x35, 0x49, 0xE2, 0x0F, 0x5B, 0x0D,
573 0xA4, 0xA4, 0x78, 0x2B, 0xCF, 0xFD, 0x3E, 0xC5, 0xE7, 0xEF, 0x6D, 0x8C, 0x34, 0xA5, 0x61, 0x23,
574 0x83, 0x95, 0xFC, 0xF1, 0xE9, 0x5B, 0xEB, 0xD6, 0x97, 0xBD, 0x01, 0x0B, 0xC7, 0x66, 0xAA, 0xC3
577 const uint8_t eax_nonce[] = {
578 0x62, 0xEC, 0x67, 0xF9, 0xC3, 0xA4, 0xA4, 0x07, 0xFC, 0xB2, 0xA8, 0xC4, 0x90, 0x31, 0xA8, 0xB3,
579 0xBE, 0xCA, 0xF0, 0x43, 0xB0, 0xA2, 0x3D, 0x84, 0x31, 0x94, 0xBA, 0x97, 0x2C, 0x66, 0xDE, 0xBD,
580 0x70, 0xC3, 0xDB, 0x4F, 0x0D, 0x26, 0x36, 0x84, 0x00, 0xA1, 0x0E, 0xD0, 0x5D, 0x2B, 0xFF, 0x5E,
581 0x84, 0x08, 0xDF, 0xFF, 0x3C, 0x1A, 0x2B, 0x12, 0x92, 0xDC, 0x19, 0x9E, 0x46, 0xB7, 0xD6, 0x17,
582 0xFD, 0xB6, 0xB0, 0x66, 0x76, 0xEE, 0xDC, 0x5C, 0x61, 0xD7, 0x42, 0x76, 0xE1, 0xF8, 0xE8, 0x16,
583 0x6E, 0xAC, 0x5C, 0x93, 0x07, 0x2D, 0x8E, 0x85, 0x13, 0xF7, 0x50, 0x93, 0x5E, 0x46, 0xDA, 0x1B,
584 0x1A, 0x8C, 0x98, 0xDC, 0xD7, 0x3D, 0x38, 0x39, 0x3B, 0x2B, 0xF1, 0x56, 0x9D, 0xEE, 0xFC, 0x19,
585 0xDD, 0xE5, 0x9B, 0x97, 0xD7, 0x22, 0x15, 0x6D, 0x4D, 0x9A, 0xFF, 0x2B, 0xC7, 0x55, 0x98, 0x26,
586 0xB7, 0x81, 0xFC, 0xF2, 0xF7, 0x5F, 0xA5, 0xA8, 0xDE, 0x97, 0xA9, 0xCA, 0x48, 0xE5, 0x22, 0xEC,
587 0x22, 0xE7, 0xAD, 0xD9, 0x3C, 0xFC, 0x63, 0x93, 0xC5, 0x7E, 0xC0, 0xB3, 0xC1, 0x7D, 0x6B, 0x44
590 const uint8_t eax_header[] = {
591 0x6B, 0xFB, 0x91, 0x4F, 0xD0, 0x7E, 0xAE, 0x6B,
592 0xFA, 0x3B, 0xFD, 0x48, 0x06, 0xEB, 0x53, 0xFA,
593 0x23, 0x4A, 0x34, 0x63, 0xC1, 0x26, 0x4A, 0xC6,
594 0x33, 0xCC, 0xE2, 0xEA, 0xBF, 0xF5, 0xA7, 0x9D,
595 0xAE, 0xB9, 0x6E, 0xAE, 0xBE, 0x29, 0x70, 0xE9,
596 0xD4, 0x48, 0x2D, 0x1C, 0xA7, 0x8D, 0xCE, 0x0F,
597 0x65, 0xD2, 0x01, 0x79, 0x90, 0xD6, 0x25, 0x28,
598 0x54, 0xB9, 0xF0, 0x4E, 0x6A, 0x09, 0x18, 0x9A,
599 0x89, 0x9A, 0x17, 0x58, 0x97, 0x56, 0x1D, 0x7E,
600 0x12, 0x67, 0x35, 0xFC, 0xC3, 0x20, 0xD2, 0x5A
603 const uint8_t eax_cipher[] = {
604 0xE0, 0x37, 0x83, 0x0E, 0x83, 0x89, 0xF2, 0x7B, 0x02, 0x5A, 0x2D, 0x65, 0x27, 0xE7, 0x9D, 0x01,
605 0x19, 0xDD, 0x5C, 0x4C, 0x93, 0x31, 0x04, 0x9D, 0x0B, 0xDA, 0xB0, 0x27, 0x74, 0x08, 0xF6, 0x79, 0x67, 0xE5,
606 0xD8, 0x51, 0xD5, 0xBA, 0xE0, 0x3A, 0x59, 0xF2, 0x38, 0xA2, 0x3E, 0x39, 0x19, 0x9D, 0xC9, 0x26, 0x66, 0x26, 0xC4, 0x0F, 0x80,
607 0x63, 0x2A, 0x9D, 0x13, 0x1A, 0xD4, 0xC1, 0x68, 0xA4, 0x22, 0x5D, 0x8E, 0x1F, 0xF7, 0x55, 0x93, 0x99, 0x74, 0xA7, 0xBE, 0xDE,
608 0x07, 0x1D, 0xFE, 0x16, 0xC6, 0x75, 0xCB, 0x06, 0x77, 0xE5, 0x36, 0xF7, 0x3A, 0xFE, 0x6A, 0x14, 0xB7, 0x4E, 0xE4, 0x98, 0x44, 0xDD,
609 0x83, 0x5B, 0xB4, 0xF1, 0x5D, 0x74, 0x3E, 0x35, 0x0E, 0x72, 0x84, 0x14, 0xAB, 0xB8, 0x64, 0x4F, 0xD6, 0xCC, 0xB8, 0x69, 0x47, 0xC5, 0xE1, 0x05, 0x90, 0x21, 0x0A, 0x4F,
610 0x02, 0x08, 0x3E, 0x39, 0x79, 0xDA, 0x01, 0x48, 0x12, 0xF5, 0x9F, 0x11, 0xD5, 0x26, 0x30, 0xDA, 0x30, 0x13, 0x73, 0x27, 0xD1, 0x06, 0x49, 0xB0, 0xAA, 0x6E, 0x1C, 0x18, 0x1D, 0xB6, 0x17, 0xD7, 0xF2,
611 0x2E, 0xC4, 0x7B, 0x2C, 0x49, 0x54, 0xA4, 0x89, 0xAF, 0xC7, 0xBA, 0x48, 0x97, 0xED, 0xCD, 0xAE, 0x8C, 0xC3, 0x3B, 0x60, 0x45, 0x05, 0x99, 0xBD, 0x02, 0xC9, 0x63, 0x82, 0x90, 0x2A, 0xEF, 0x7F, 0x83, 0x2A,
612 0x0D, 0xE1, 0x8F, 0xD0, 0xFD, 0xD9, 0x1E, 0x7A, 0xF1, 0x9F, 0x1D, 0x8E, 0xE8, 0x73, 0x39, 0x38, 0xB1, 0xE8, 0xE7, 0xF6, 0xD2, 0x23, 0x16, 0x18, 0x10, 0x2F, 0xDB, 0x7F, 0xE5, 0x5F, 0xF1, 0x99, 0x17, 0x00,
613 0xCB, 0x89, 0x20, 0xF8, 0x7A, 0x6C, 0x75, 0xCF, 0xF3, 0x96, 0x27, 0xB5, 0x6E, 0x3E, 0xD1, 0x97, 0xC5, 0x52, 0xD2, 0x95, 0xA7, 0xCF, 0xC4, 0x6A, 0xFC, 0x25, 0x3B, 0x46, 0x52, 0xB1, 0xAF, 0x37, 0x95, 0xB1, 0x24, 0xAB, 0x6E
616 void testrun_aes128_eax(void){
624 const void* cipher_p;
630 cipher_p = eax_cipher;
632 cli_putstr("\r\n\r\n** AES128-EAX-TEST #");
636 msg_len = eax_msg_len[i];
637 memcpy(key, eax_key+16*i, 16);
638 memcpy(nonce, eax_nonce+16*i, 16);
639 memcpy(header, eax_header+8*i, 8);
640 memcpy(msg, msg_p, msg_len);
641 msg_p = (uint8_t*)msg_p+msg_len;
643 cli_putstr("\r\n key: ");
644 cli_hexdump(key, 16);
645 cli_putstr("\r\n msg: ");
647 cli_hexdump(msg, msg_len);
649 cli_putstr("\r\n nonce: ");
650 cli_hexdump(nonce, 16);
651 cli_putstr("\r\n header: ");
652 cli_hexdump(header, 8);
654 r = bcal_eax_init(&aes128_desc, key, 128, &ctx);
655 cli_putstr("\r\n init = 0x");
659 bcal_eax_loadNonce(nonce, 16*8, &ctx);
660 bcal_eax_addLastHeader(header, 8*8, &ctx);
661 bcal_eax_encLastBlock(msg, msg_len*8, &ctx);
662 bcal_eax_ctx2tag(tag, 128, &ctx);
664 cli_putstr("\r\n cipher: ");
665 cli_hexdump_block(msg, msg_len, 4, 16);
667 cli_putstr("\r\n tag: ");
668 cli_hexdump_block(tag, 16, 4, 16);
670 if(memcmp(msg, cipher_p, msg_len)){
671 cli_putstr("\r\n cipher: [fail]\r\n should: ");
672 memcpy(msg, cipher_p, msg_len);
673 cli_hexdump_block(msg, msg_len, 4, 16);
675 cli_putstr("\r\n cipher: [pass]");
677 cipher_p = ((uint8_t*)cipher_p)+msg_len;
679 if(memcmp(tag, cipher_p, 16)){
680 cli_putstr("\r\n tag: [fail]");
682 cli_putstr("\r\n tag: [pass]");
685 cipher_p = ((uint8_t*)cipher_p)+16;
690 /*****************************************************************************/
692 void testrun_performance_aes(void){
693 bcal_performance_multiple(algolist);
696 /*****************************************************************************
698 *****************************************************************************/
700 const cmdlist_entry_t cmdlist[] = {
701 { "nessie", NULL, testrun_nessie_aes },
702 { "test", NULL, testrun_test_aes },
703 { "testkey", NULL, testrun_testkey_aes },
704 { "testcbc", NULL, testrun_aes128_cbc },
705 { "testcfb8", NULL, testrun_aes128_cfb8 },
706 { "testcfb1", NULL, testrun_aes128_cfb1 },
707 { "testofb", NULL, testrun_aes128_ofb },
708 { "testctr", NULL, testrun_aes128_ctr },
709 { "testcmac", NULL, testrun_aes128_cmac },
710 { "testcmac72", NULL, testrun_aes128_cmac72 },
711 { "testcmac0", NULL, testrun_aes192_cmac0 },
712 { "testeax", NULL, testrun_aes128_eax },
713 { "quick-test", NULL, crypto_test },
714 { "cmacvs_list", NULL, cmacvs_listalgos },
715 { "cmacvs_set", (void*)1, (void_fpt)cmacvs_setalgo },
716 { "cmacvs_test1", NULL, cmacvs_test1 },
717 { "cmacvs_test2", NULL, cmacvs_test2 },
718 { "performance", NULL, testrun_performance_aes },
719 { "dump", (void*)1, (void_fpt)dump },
720 { "echo", (void*)1, (void_fpt)echo_ctrl },
726 sysclk_set_freq(SYS_FREQ);
727 sysclk_mosc_verify_enable();
728 uart_init(UART_0, 115200, 8, UART_PARATY_NONE, UART_STOPBITS_ONE);
729 gptm_set_timer_32periodic(TIMER0);
734 cmacvs_algolist=(bcdesc_t**)algolist;
735 cmacvs_algo=(bcdesc_t*)&aes128_desc;
738 cli_putstr("\r\n\r\nARM-Crypto-Lib VS (");
739 cli_putstr(algo_name);
741 cli_putstr(__DATE__);
743 cli_putstr(__TIME__);
744 cli_putstr(")\r\nloaded and running\r\n");
745 cmd_interface(cmdlist);