test_src/main-aes-test.c

   1 /* main-aes-test.c */
   2 /*
   3     This file is part of the ARM-Crypto-Lib.
   4     Copyright (C) 2006-2010  Daniel Otte (daniel.otte@rub.de)
   5
   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.
  10
  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.
  15
  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/>.
  18 */
  19 /*
  20  * AES test-suit
  21  *
  22 */
  23 #include <stdint.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include "config.h"
  27 #include "cli.h"
  28 #include "dump.h"
  29 #include "uart_lowlevel.h"
  30 #include "sysclock.h"
  31 #include "hw_gptm.h"
  32
  33 #include "aes.h"
  34
  35 #include "nessie_bc_test.h"
  36 #include "performance_test.h"
  37
  38 #include "bcal_aes128.h"
  39 #include "bcal_aes192.h"
  40 #include "bcal_aes256.h"
  41 #include "bcal-cbc.h"
  42 #include "bcal-cfb_byte.h"
  43 #include "bcal-cfb_bit.h"
  44 #include "bcal-ofb.h"
  45 #include "bcal-ctr.h"
  46 #include "bcal-cmac.h"
  47 #include "bcal-eax.h"
  48 #include "cmacvs.h"
  49 #include "bcal-performance.h"
  50
  51
  52 char* algo_name = "AES";
  53
  54 void uart0_putc(char byte){
  55         uart_putc(UART_0, byte);
  56 }
  57
  58 char uart0_getc(void){
  59         return uart_getc(UART_0);
  60 }
  61
  62 const bcdesc_t* algolist[] = {
  63         (bcdesc_t*)&aes128_desc,
  64         (bcdesc_t*)&aes192_desc,
  65         (bcdesc_t*)&aes256_desc,
  66         NULL
  67 };
  68
  69 /*****************************************************************************
  70  *  additional validation-functions                                                                                      *
  71  *****************************************************************************/
  72
  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;
  81         nessie_bc_run();
  82
  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;
  87         nessie_bc_run();
  88
  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;
  93         nessie_bc_run();
  94 }
  95
  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 };
 105         aes128_ctx_t ctx;
 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;
 119         uint8_t r;
 120         r = bcal_cipher_init(&aes128_desc, key, 128, &bcal_ctx);
 121         cli_putstr("\r\n init = 0x");
 122         cli_hexdump(&r, 1);
 123
 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);
 131 }
 132
 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};
 138         aes128_ctx_t ctx;
 139         uint8_t i;
 140         aes128_init(key, &ctx);
 141         cli_putstr("\r\n\r\n keyschedule test (FIPS 197):\r\n key:   ");
 142         cli_hexdump(key, 16);
 143         for(i=0; i<11; ++i){
 144                 cli_putstr("\r\n index: ");
 145                 cli_putc('0'+i/10);
 146                 cli_putc('0'+i%10);
 147                 cli_putstr(" roundkey ");
 148                 cli_hexdump(ctx.key[i].ks, 16);
 149         }
 150 }
 151
 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};
 159         aes192_ctx_t ctx;
 160         uint8_t i;
 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);
 165         for(i=0; i<13; ++i){
 166                 cli_putstr("\r\n index: ");
 167                 cli_putc('0'+i/10);
 168                 cli_putc('0'+i%10);
 169                 cli_putstr(" roundkey ");
 170                 cli_hexdump(ctx.key[i].ks, 16);
 171         }
 172 }
 173
 174
 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};
 184         aes256_ctx_t ctx;
 185         uint8_t i;
 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);
 190         for(i=0; i<15; ++i){
 191                 cli_putstr("\r\n index: ");
 192                 cli_putc('0'+i/10);
 193                 cli_putc('0'+i%10);
 194                 cli_putstr(" roundkey ");
 195                 cli_hexdump(ctx.key[i].ks, 16);
 196         }
 197 }
 198
 199 void crypto_test(void){
 200         uint8_t test_data[16], test_key[32];
 201         aes256_ctx_t ctx;
 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);
 208 }
 209
 210
 211 void testrun_testkey_aes(void){
 212         testrun_testkey_aes128();
 213         testrun_testkey_aes192();
 214         testrun_testkey_aes256();
 215 }
 216
 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
 222         };
 223 const uint8_t modes_iv[] = {
 224                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 225                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
 226     };
 227
 228 const uint8_t modes_ctriv[] = {
 229                 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 230                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 231         };
 232
 233 const uint8_t modes_plain[] = {
 234                 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
 235                 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
 236                 /* --- */
 237                 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
 238                 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
 239                 /* --- */
 240                 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
 241                 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
 242                 /* --- */
 243                 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
 244                 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
 245     };
 246
 247
 248 void testrun_aes128_cbc(void){
 249         uint8_t key[16];
 250         uint8_t iv[16];
 251         uint8_t plain[64];
 252
 253         bcal_cbc_ctx_t ctx;
 254         uint8_t r;
 255
 256         memcpy(key,   modes_key,   16);
 257         memcpy(iv,    modes_iv,    16);
 258         memcpy(plain, modes_plain, 64);
 259
 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");
 263         cli_hexdump(&r, 1);
 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);
 270         if(r)
 271                 return;
 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);
 278         bcal_cbc_free(&ctx);
 279 }
 280
 281 void testrun_aes128_cfb8(void){
 282         uint8_t key[16];
 283         uint8_t iv[16];
 284         uint8_t plain[64];
 285
 286         bcal_cfb_B_ctx_t ctx;
 287         uint8_t r;
 288
 289         memcpy(key,   modes_key,   16);
 290         memcpy(iv,    modes_iv,    16);
 291         memcpy(plain, modes_plain, 64);
 292
 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");
 296         cli_hexdump(&r, 1);
 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);
 303         if(r)
 304                 return;
 305         bcal_cfb_B_encMsg(iv, plain, 64, &ctx);
 306         cli_putstr("\r\n  ciphertext:  ");
 307         cli_hexdump_block(plain, 64, 4, 16);
 308
 309         bcal_cfb_B_decMsg(iv, plain, 64, &ctx);
 310         cli_putstr("\r\n  plaintext:   ");
 311         cli_hexdump_block(plain, 64, 4, 16);
 312
 313         bcal_cfb_B_free(&ctx);
 314
 315 }
 316
 317 void testrun_aes128_cfb1(void){
 318         uint8_t key[16];
 319         uint8_t iv[16];
 320         uint8_t plain[64];
 321
 322         bcal_cfb_b_ctx_t ctx;
 323         uint8_t r;
 324
 325         memcpy(key,   modes_key,   16);
 326         memcpy(iv,    modes_iv,    16);
 327         memcpy(plain, modes_plain, 64);
 328
 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");
 332         cli_hexdump(&r, 1);
 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);
 339         if(r)
 340                 return;
 341         uint8_t i, bit_offset, byte_offset;
 342         bcal_cfb_b_loadIV(iv, &ctx);
 343         for(i=0; i<16; ++i){
 344                 byte_offset = i/8;
 345                 bit_offset = i&7;
 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');
 351         }
 352         cli_putstr("\r\n  ciphertext:  ");
 353         cli_hexdump_block(plain, 2, 4, 16);
 354
 355         bcal_cfb_b_loadIV(iv, &ctx);
 356         for(i=0; i<16; ++i){
 357                 byte_offset = i/8;
 358                 bit_offset = i&7;
 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');
 364         }
 365         cli_putstr("\r\n  plaintext:   ");
 366         cli_hexdump_block(plain, 2, 4, 16);
 367
 368
 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);
 372
 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);
 376
 377         bcal_cfb_b_free(&ctx);
 378 }
 379
 380 void testrun_aes128_ofb(void){
 381         uint8_t key[16];
 382         uint8_t iv[16];
 383         uint8_t plain[64];
 384
 385         bcal_ofb_ctx_t ctx;
 386         uint8_t r;
 387
 388         memcpy(key,   modes_key,   16);
 389         memcpy(iv,    modes_iv,    16);
 390         memcpy(plain, modes_plain, 64);
 391
 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");
 395         cli_hexdump(&r, 1);
 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);
 402         if(r)
 403                 return;
 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);
 410         bcal_ofb_free(&ctx);
 411 }
 412
 413 void testrun_aes128_ctr(void){
 414         uint8_t key[16];
 415         uint8_t iv[16];
 416         uint8_t plain[64];
 417
 418         bcal_ctr_ctx_t ctx;
 419         uint8_t r;
 420
 421         memcpy(key,   modes_key,   16);
 422         memcpy(iv,    modes_ctriv, 16);
 423         memcpy(plain, modes_plain, 64);
 424
 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");
 428         cli_hexdump(&r, 1);
 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);
 435         if(r)
 436                 return;
 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);
 443         bcal_ctr_free(&ctx);
 444 }
 445
 446 void testrun_aes128_cmac(void){
 447         uint8_t key[16];
 448         uint8_t tag[16];
 449         uint8_t plain[64];
 450         uint16_t length[] = { 0, 128, 320, 512 };
 451         bcal_cmac_ctx_t ctx;
 452         uint8_t r,i;
 453
 454         memcpy(key,   modes_key,   16);
 455         memcpy(plain, modes_plain, 64);
 456
 457         cli_putstr("\r\n** AES128-CMAC-TEST **");
 458
 459         cli_putstr("\r\n  key:   ");
 460         cli_hexdump(key, 128/8);
 461         for(i=0; i<4; ++i){
 462                 r = bcal_cmac_init(&aes128_desc, key, 128, &ctx);
 463                 cli_putstr("\r\n  init = 0x");
 464                 cli_hexdump(&r, 1);
 465                 cli_putstr("\r\n  message: ");
 466                 cli_hexdump_block(plain, length[i]/8, 4, 16);
 467                 if(r)
 468                         return;
 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);
 473         }
 474 }
 475 /*
 476 Klen = 16
 477 Mlen = 18
 478 Tlen = 2
 479 Key = 3250974e306b4b678f914b514d1e90f6
 480 Msg = cf132fd4ebc25fd3866f1a95a6193a1a9cdf
 481 */
 482 void testrun_aes128_cmac72(void){
 483         uint8_t key[16]= {
 484                         0x32, 0x50, 0x97, 0x4e, 0x30, 0x6b, 0x4b, 0x67,
 485                         0x8f, 0x91, 0x4b, 0x51, 0x4d, 0x1e, 0x90, 0xf6
 486         };
 487         uint8_t tag[2];
 488         uint8_t plain[18] = {
 489                         0xcf, 0x13, 0x2f, 0xd4, 0xeb, 0xc2, 0x5f, 0xd3,
 490                         0x86, 0x6f, 0x1a, 0x95, 0xa6, 0x19, 0x3a, 0x1a,
 491                         0x9c, 0xdf,
 492         };
 493         bcal_cmac_ctx_t ctx;
 494         uint8_t r;
 495
 496
 497         cli_putstr("\r\n** AES128-CMAC-72-TEST **");
 498
 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");
 503         cli_hexdump(&r, 1);
 504         cli_putstr("\r\n  message: ");
 505         cli_hexdump_block(plain, 18, 4, 16);
 506         if(r)
 507                 return;
 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);
 512 }
 513 /*
 514 Count = 0
 515 Klen = 24
 516 Mlen = 0
 517 Tlen = 2
 518 Key = 2b2aaa666be161ed16648e862ac9bd1e317f71bc69e268b5
 519 Msg = 00
 520 */
 521 void testrun_aes192_cmac0(void){
 522         uint8_t key[24]= {
 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
 526         };
 527         uint8_t tag[2];
 528         uint8_t plain[1] = {
 529                         0x00
 530         };
 531         bcal_cmac_ctx_t ctx;
 532         uint8_t r;
 533
 534
 535         cli_putstr("\r\n** AES192-CMAC-0-TEST **");
 536
 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");
 541         cli_hexdump(&r, 1);
 542         if(r)
 543                 return;
 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);
 548 }
 549
 550 const uint8_t eax_msg[] = {
 551     0xF7, 0xFB,
 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
 560 };
 561
 562 const uint8_t eax_msg_len[] =  {0, 2, 5, 5, 6, 12, 17, 18, 18, 21};
 563
 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
 575 };
 576
 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
 588 };
 589
 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
 601 };
 602
 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
 614 };
 615
 616 void testrun_aes128_eax(void){
 617         uint8_t key[16];
 618         uint8_t nonce[16];
 619         uint8_t header[8];
 620         uint8_t tag[16];
 621         uint8_t msg[21];
 622         uint8_t msg_len;
 623         const void* msg_p;
 624         const void* cipher_p;
 625         uint8_t i, r;
 626
 627         bcal_eax_ctx_t ctx;
 628
 629         msg_p = eax_msg;
 630         cipher_p = eax_cipher;
 631         for(i=0; i<10; ++i){
 632                 cli_putstr("\r\n\r\n** AES128-EAX-TEST #");
 633                 cli_putc('0'+i);
 634                 cli_putstr(" **");
 635
 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;
 642
 643                 cli_putstr("\r\n  key:     ");
 644                 cli_hexdump(key, 16);
 645                 cli_putstr("\r\n  msg:     ");
 646                 if(msg_len){
 647                         cli_hexdump(msg, msg_len);
 648                 }
 649                 cli_putstr("\r\n  nonce:   ");
 650                 cli_hexdump(nonce, 16);
 651                 cli_putstr("\r\n  header:  ");
 652                 cli_hexdump(header, 8);
 653
 654                 r = bcal_eax_init(&aes128_desc, key, 128, &ctx);
 655                 cli_putstr("\r\n  init = 0x");
 656                 cli_hexdump(&r, 1);
 657                 if(r)
 658                         return;
 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);
 663
 664                 cli_putstr("\r\n  cipher:  ");
 665                 cli_hexdump_block(msg, msg_len, 4, 16);
 666
 667                 cli_putstr("\r\n  tag:     ");
 668                 cli_hexdump_block(tag, 16, 4, 16);
 669
 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);
 674                 }else{
 675                         cli_putstr("\r\n cipher:  [pass]");
 676                 }
 677                 cipher_p = ((uint8_t*)cipher_p)+msg_len;
 678                 // *
 679                 if(memcmp(tag, cipher_p, 16)){
 680                         cli_putstr("\r\n tag:     [fail]");
 681                 }else{
 682                         cli_putstr("\r\n tag:     [pass]");
 683                 }
 684
 685                 cipher_p = ((uint8_t*)cipher_p)+16;
 686                 bcal_eax_free(&ctx);
 687         }
 688 }
 689
 690 /*****************************************************************************/
 691
 692 void testrun_performance_aes(void){
 693         bcal_performance_multiple(algolist);
 694 }
 695
 696 /*****************************************************************************
 697  *  main                                                                                                                                         *
 698  *****************************************************************************/
 699
 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             },
 721         { NULL,                NULL, NULL                            }
 722 };
 723
 724
 725 int main (void){
 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);
 730
 731         cli_rx = uart0_getc;
 732     cli_tx = uart0_putc;
 733
 734         cmacvs_algolist=(bcdesc_t**)algolist;
 735         cmacvs_algo=(bcdesc_t*)&aes128_desc;
 736
 737         for(;;){
 738                 cli_putstr("\r\n\r\nARM-Crypto-Lib VS (");
 739                 cli_putstr(algo_name);
 740                 cli_putstr("; ");
 741                 cli_putstr(__DATE__);
 742                 cli_putc(' ');
 743                 cli_putstr(__TIME__);
 744                 cli_putstr(")\r\nloaded and running\r\n");
 745         cmd_interface(cmdlist);
 746     }
 747 }
 748