test_src/main-aes-test.c

   1 /* main-aes-test.c */
   2 /*
   3     This file is part of the AVR-Crypto-Lib.
   4     Copyright (C) 2008  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
  24 #include "config.h"
  25
  26 #include "uart_i.h"
  27 #include "debug.h"
  28
  29 #include "aes/aes.h"
  30
  31 #include "nessie_bc_test.h"
  32 #include "cli.h"
  33 #include "performance_test.h"
  34 #include "dump.h"
  35
  36 #include "bcal_aes128.h"
  37 #include "bcal_aes192.h"
  38 #include "bcal_aes256.h"
  39 #include "bcal-cbc.h"
  40 #include "bcal-cfb_byte.h"
  41 #include "bcal-cfb_bit.h"
  42 #include "bcal-ofb.h"
  43 #include "bcal-ctr.h"
  44 #include "bcal-cmac.h"
  45 #include "bcal-eax.h"
  46 #include "cmacvs.h"
  47
  48 #include <stdint.h>
  49 #include <string.h>
  50 #include <stdlib.h>
  51 #include <avr/pgmspace.h>
  52
  53 char* algo_name = "AES";
  54
  55 const bcdesc_t* algolist[] PROGMEM = {
  56         (bcdesc_t*)&aes128_desc,
  57         (bcdesc_t*)&aes192_desc,
  58         (bcdesc_t*)&aes256_desc,
  59         NULL
  60 };
  61
  62 /*****************************************************************************
  63  *  additional validation-functions                                                                                      *
  64  *****************************************************************************/
  65
  66 void testrun_nessie_aes(void){
  67         nessie_bc_ctx.blocksize_B =  16;
  68         nessie_bc_ctx.keysize_b   = 128;
  69         nessie_bc_ctx.name        = algo_name;
  70         nessie_bc_ctx.ctx_size_B  = sizeof(aes128_ctx_t);
  71         nessie_bc_ctx.cipher_enc  = (nessie_bc_enc_fpt)aes128_enc;
  72         nessie_bc_ctx.cipher_dec  = (nessie_bc_dec_fpt)aes128_dec;
  73         nessie_bc_ctx.cipher_genctx  = (nessie_bc_gen_fpt)aes_init;
  74         nessie_bc_run();
  75
  76         nessie_bc_ctx.keysize_b   = 192;
  77         nessie_bc_ctx.ctx_size_B  = sizeof(aes192_ctx_t);
  78         nessie_bc_ctx.cipher_enc  = (nessie_bc_enc_fpt)aes192_enc;
  79         nessie_bc_ctx.cipher_dec  = (nessie_bc_dec_fpt)aes192_dec;
  80         nessie_bc_run();
  81
  82         nessie_bc_ctx.keysize_b   = 256;
  83         nessie_bc_ctx.ctx_size_B  = sizeof(aes256_ctx_t);
  84         nessie_bc_ctx.cipher_enc  = (nessie_bc_enc_fpt)aes256_enc;
  85         nessie_bc_ctx.cipher_dec  = (nessie_bc_dec_fpt)aes256_dec;
  86         nessie_bc_run();
  87 }
  88
  89 void testrun_test_aes(void){
  90         uint8_t key[16] = { 0x2b, 0x7e, 0x15, 0x16,
  91                             0x28, 0xae, 0xd2, 0xa6,
  92                             0xab, 0xf7, 0x15, 0x88,
  93                             0x09, 0xcf, 0x4f, 0x3c };
  94         uint8_t data[16] = { 0x32, 0x43, 0xf6, 0xa8,
  95                              0x88, 0x5a, 0x30, 0x8d,
  96                              0x31, 0x31, 0x98, 0xa2,
  97                              0xe0, 0x37, 0x07, 0x34 };
  98         aes128_ctx_t ctx;
  99         aes128_init(key, &ctx);
 100         cli_putstr_P(PSTR("\r\n\r\n cipher test (FIPS 197):\r\n key:        "));
 101         cli_hexdump(key, 16);
 102         cli_putstr_P(PSTR("\r\n plaintext:  "));
 103         cli_hexdump(data, 16);
 104         aes128_enc(data, &ctx);
 105         cli_putstr_P(PSTR("\r\n ciphertext: "));
 106         cli_hexdump(data, 16);
 107         aes128_dec(data, &ctx);
 108         cli_putstr_P(PSTR("\r\n plaintext:  "));
 109         cli_hexdump(data, 16);
 110         cli_putstr(PSTR("\r\n testing bcal:"));
 111         bcgen_ctx_t bcal_ctx;
 112         uint8_t r;
 113         r = bcal_cipher_init(&aes128_desc, key, 128, &bcal_ctx);
 114         cli_putstr_P(PSTR("\r\n init = 0x"));
 115         cli_hexdump(&r, 1);
 116
 117         bcal_cipher_enc(data, &bcal_ctx);
 118         cli_putstr_P(PSTR("\r\n ciphertext: "));
 119         cli_hexdump(data, 16);
 120         bcal_cipher_dec(data, &bcal_ctx);
 121         cli_putstr_P(PSTR("\r\n plaintext:  "));
 122         cli_hexdump(data, 16);
 123         bcal_cipher_free(&bcal_ctx);
 124 }
 125
 126 void testrun_testkey_aes128(void){
 127         uint8_t key[16] = { 0x2b, 0x7e, 0x15, 0x16,
 128                             0x28, 0xae, 0xd2, 0xa6,
 129                             0xab, 0xf7, 0x15, 0x88,
 130                             0x09, 0xcf, 0x4f, 0x3c};
 131         aes128_ctx_t ctx;
 132         uint8_t i;
 133         aes128_init(key, &ctx);
 134         cli_putstr_P(PSTR("\r\n\r\n keyschedule test (FIPS 197):\r\n key:   "));
 135         cli_hexdump(key, 16);
 136         for(i=0; i<11; ++i){
 137                 cli_putstr_P(PSTR("\r\n index: "));
 138                 cli_putc('0'+i/10);
 139                 cli_putc('0'+i%10);
 140                 cli_putstr_P(PSTR(" roundkey "));
 141                 cli_hexdump(ctx.key[i].ks, 16);
 142         }
 143 }
 144
 145 void testrun_testkey_aes192(void){
 146         uint8_t key[24] = { 0x8e, 0x73, 0xb0, 0xf7,
 147                             0xda, 0x0e, 0x64, 0x52,
 148                             0xc8, 0x10, 0xf3, 0x2b,
 149                             0x80, 0x90, 0x79, 0xe5,
 150                             0x62, 0xf8, 0xea, 0xd2,
 151                             0x52, 0x2c, 0x6b, 0x7b};
 152         aes192_ctx_t ctx;
 153         uint8_t i;
 154         memset(&ctx, 0, sizeof(aes192_ctx_t));
 155         aes192_init(key, &ctx);
 156         cli_putstr_P(PSTR("\r\n\r\n keyschedule test (FIPS 197):\r\n key:   "));
 157         cli_hexdump(key, 24);
 158         for(i=0; i<13; ++i){
 159                 cli_putstr_P(PSTR("\r\n index: "));
 160                 cli_putc('0'+i/10);
 161                 cli_putc('0'+i%10);
 162                 cli_putstr_P(PSTR(" roundkey "));
 163                 cli_hexdump(ctx.key[i].ks, 16);
 164         }
 165 }
 166
 167
 168 void testrun_testkey_aes256(void){
 169         uint8_t key[32] = { 0x60, 0x3d, 0xeb, 0x10,
 170                             0x15, 0xca, 0x71, 0xbe,
 171                             0x2b, 0x73, 0xae, 0xf0,
 172                             0x85, 0x7d, 0x77, 0x81,
 173                             0x1f, 0x35, 0x2c, 0x07,
 174                             0x3b, 0x61, 0x08, 0xd7,
 175                             0x2d, 0x98, 0x10, 0xa3,
 176                             0x09, 0x14, 0xdf, 0xf4};
 177         aes256_ctx_t ctx;
 178         uint8_t i;
 179         memset(&ctx, 0, sizeof(aes256_ctx_t));
 180         aes256_init(key, &ctx);
 181         cli_putstr_P(PSTR("\r\n\r\n keyschedule test (FIPS 197):\r\n key:   "));
 182         cli_hexdump(key, 32);
 183         for(i=0; i<15; ++i){
 184                 cli_putstr_P(PSTR("\r\n index: "));
 185                 cli_putc('0'+i/10);
 186                 cli_putc('0'+i%10);
 187                 cli_putstr_P(PSTR(" roundkey "));
 188                 cli_hexdump(ctx.key[i].ks, 16);
 189         }
 190 }
 191
 192 void testrun_testkey_aes(void){
 193         testrun_testkey_aes128();
 194         testrun_testkey_aes192();
 195         testrun_testkey_aes256();
 196 }
 197
 198 uint8_t modes_key[]   PROGMEM = {
 199                 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
 200                 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
 201                 0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
 202                 0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4
 203         };
 204 uint8_t modes_iv[]    PROGMEM = {
 205                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 206                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
 207     };
 208
 209 uint8_t modes_ctriv[] PROGMEM = {
 210                 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 211                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 212         };
 213
 214 uint8_t modes_plain[] PROGMEM = {
 215                 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
 216                 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
 217                 /* --- */
 218                 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
 219                 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
 220                 /* --- */
 221                 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
 222                 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
 223                 /* --- */
 224                 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
 225                 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
 226     };
 227
 228
 229 void testrun_aes128_cbc(void){
 230         uint8_t key[16];
 231         uint8_t iv[16];
 232         uint8_t plain[64];
 233
 234         bcal_cbc_ctx_t ctx;
 235         uint8_t r;
 236
 237         memcpy_P(key,   modes_key,   16);
 238         memcpy_P(iv,    modes_iv,    16);
 239         memcpy_P(plain, modes_plain, 64);
 240
 241         cli_putstr_P(PSTR("\r\n** AES128-CBC-TEST **"));
 242         r = bcal_cbc_init(&aes128_desc, key, 128, &ctx);
 243         cli_putstr_P(PSTR("\r\n  init = 0x"));
 244         cli_hexdump(&r, 1);
 245         cli_putstr_P(PSTR("\r\n  key:   "));
 246         cli_hexdump(key, 128/8);
 247         cli_putstr_P(PSTR("\r\n  IV:    "));
 248         cli_hexdump(iv, 128/8);
 249         cli_putstr_P(PSTR("\r\n  plaintext:"));
 250         cli_hexdump_block(plain, 4*128/8, 4, 16);
 251         if(r)
 252                 return;
 253         bcal_cbc_encMsg(iv, plain, 4, &ctx);
 254         cli_putstr_P(PSTR("\r\n  ciphertext:  "));
 255         cli_hexdump_block(plain, 4*128/8, 4, 16);
 256         bcal_cbc_decMsg(iv, plain, 4, &ctx);
 257         cli_putstr_P(PSTR("\r\n  plaintext:   "));
 258         cli_hexdump_block(plain, 4*128/8, 4, 16);
 259         bcal_cbc_free(&ctx);
 260 }
 261
 262 void testrun_aes128_cfb8(void){
 263         uint8_t key[16];
 264         uint8_t iv[16];
 265         uint8_t plain[64];
 266
 267         bcal_cfb_B_ctx_t ctx;
 268         uint8_t r;
 269
 270         memcpy_P(key,   modes_key,   16);
 271         memcpy_P(iv,    modes_iv,    16);
 272         memcpy_P(plain, modes_plain, 64);
 273
 274         cli_putstr_P(PSTR("\r\n** AES128-CFB8-TEST **"));
 275         r = bcal_cfb_B_init(&aes128_desc, key, 128, 8, &ctx);
 276         cli_putstr_P(PSTR("\r\n  init = 0x"));
 277         cli_hexdump(&r, 1);
 278         cli_putstr_P(PSTR("\r\n  key:   "));
 279         cli_hexdump(key, 128/8);
 280         cli_putstr_P(PSTR("\r\n  IV:    "));
 281         cli_hexdump(iv, 128/8);
 282         cli_putstr_P(PSTR("\r\n  plaintext:"));
 283         cli_hexdump_block(plain, 4*128/8, 4, 16);
 284         if(r)
 285                 return;
 286         bcal_cfb_B_encMsg(iv, plain, 64, &ctx);
 287         cli_putstr_P(PSTR("\r\n  ciphertext:  "));
 288         cli_hexdump_block(plain, 64, 4, 16);
 289
 290         bcal_cfb_B_decMsg(iv, plain, 64, &ctx);
 291         cli_putstr_P(PSTR("\r\n  plaintext:   "));
 292         cli_hexdump_block(plain, 64, 4, 16);
 293
 294         bcal_cfb_B_free(&ctx);
 295
 296 }
 297
 298 void testrun_aes128_cfb1(void){
 299         uint8_t key[16];
 300         uint8_t iv[16];
 301         uint8_t plain[64];
 302
 303         bcal_cfb_b_ctx_t ctx;
 304         uint8_t r;
 305
 306         memcpy_P(key,   modes_key,   16);
 307         memcpy_P(iv,    modes_iv,    16);
 308         memcpy_P(plain, modes_plain, 64);
 309
 310         cli_putstr_P(PSTR("\r\n** AES128-CFB1-TEST **"));
 311         r = bcal_cfb_b_init(&aes128_desc, key, 128, 1, &ctx);
 312         cli_putstr_P(PSTR("\r\n  init = 0x"));
 313         cli_hexdump(&r, 1);
 314         cli_putstr_P(PSTR("\r\n  key:   "));
 315         cli_hexdump(key, 128/8);
 316         cli_putstr_P(PSTR("\r\n  IV:    "));
 317         cli_hexdump(iv, 128/8);
 318         cli_putstr_P(PSTR("\r\n  plaintext:"));
 319         cli_hexdump_block(plain, 2, 4, 16);
 320         if(r)
 321                 return;
 322         uint8_t i, bit_offset, byte_offset;
 323         bcal_cfb_b_loadIV(iv, &ctx);
 324         for(i=0; i<16; ++i){
 325                 byte_offset = i/8;
 326                 bit_offset = i&7;
 327                 cli_putstr_P(PSTR("\r\n  plain bit:   "));
 328                 cli_putc((plain[byte_offset]&(1<<(7-bit_offset)))?'1':'0');
 329                 bcal_cfb_b_encNext(plain+byte_offset, bit_offset, &ctx);
 330                 cli_putstr_P(PSTR("\r\n  cipher bit:  "));
 331                 cli_putc((plain[byte_offset]&(1<<(7-bit_offset)))?'1':'0');
 332         }
 333         cli_putstr_P(PSTR("\r\n  ciphertext:  "));
 334         cli_hexdump_block(plain, 2, 4, 16);
 335
 336         bcal_cfb_b_loadIV(iv, &ctx);
 337         for(i=0; i<16; ++i){
 338                 byte_offset = i/8;
 339                 bit_offset = i&7;
 340                 cli_putstr_P(PSTR("\r\n  plain bit:   "));
 341                 cli_putc((plain[byte_offset]&(1<<(7-bit_offset)))?'1':'0');
 342                 bcal_cfb_b_decNext(plain+byte_offset, bit_offset, &ctx);
 343                 cli_putstr_P(PSTR("\r\n  cipher bit:  "));
 344                 cli_putc((plain[byte_offset]&(1<<(7-bit_offset)))?'1':'0');
 345         }
 346         cli_putstr_P(PSTR("\r\n  plaintext:   "));
 347         cli_hexdump_block(plain, 2, 4, 16);
 348
 349
 350         bcal_cfb_b_encMsg(iv, plain, 0, 64*8, &ctx);
 351         cli_putstr_P(PSTR("\r\n  ciphertext:  "));
 352         cli_hexdump_block(plain, 64, 4, 16);
 353
 354         bcal_cfb_b_decMsg(iv, plain, 0, 64*8, &ctx);
 355         cli_putstr_P(PSTR("\r\n  plaintext:   "));
 356         cli_hexdump_block(plain, 64, 4, 16);
 357
 358         bcal_cfb_b_free(&ctx);
 359 }
 360
 361 void testrun_aes128_ofb(void){
 362         uint8_t key[16];
 363         uint8_t iv[16];
 364         uint8_t plain[64];
 365
 366         bcal_ofb_ctx_t ctx;
 367         uint8_t r;
 368
 369         memcpy_P(key,   modes_key,   16);
 370         memcpy_P(iv,    modes_iv,    16);
 371         memcpy_P(plain, modes_plain, 64);
 372
 373         cli_putstr_P(PSTR("\r\n** AES128-OFB-TEST **"));
 374         r = bcal_ofb_init(&aes128_desc, key, 128, &ctx);
 375         cli_putstr_P(PSTR("\r\n  init = 0x"));
 376         cli_hexdump(&r, 1);
 377         cli_putstr_P(PSTR("\r\n  key:   "));
 378         cli_hexdump(key, 128/8);
 379         cli_putstr_P(PSTR("\r\n  IV:    "));
 380         cli_hexdump(iv, 128/8);
 381         cli_putstr_P(PSTR("\r\n  plaintext:"));
 382         cli_hexdump_block(plain, 4*128/8, 4, 16);
 383         if(r)
 384                 return;
 385         bcal_ofb_encMsg(iv, plain, 4*128, &ctx);
 386         cli_putstr_P(PSTR("\r\n  ciphertext:  "));
 387         cli_hexdump_block(plain, 4*128/8, 4, 16);
 388         bcal_ofb_decMsg(iv, plain, 4*128, &ctx);
 389         cli_putstr_P(PSTR("\r\n  plaintext:   "));
 390         cli_hexdump_block(plain, 4*128/8, 4, 16);
 391         bcal_ofb_free(&ctx);
 392 }
 393
 394 void testrun_aes128_ctr(void){
 395         uint8_t key[16];
 396         uint8_t iv[16];
 397         uint8_t plain[64];
 398
 399         bcal_ctr_ctx_t ctx;
 400         uint8_t r;
 401
 402         memcpy_P(key,   modes_key,   16);
 403         memcpy_P(iv,    modes_ctriv, 16);
 404         memcpy_P(plain, modes_plain, 64);
 405
 406         cli_putstr_P(PSTR("\r\n** AES128-CTR-TEST **"));
 407         r = bcal_ctr_init(&aes128_desc, key, 128, NULL, &ctx);
 408         cli_putstr_P(PSTR("\r\n  init = 0x"));
 409         cli_hexdump(&r, 1);
 410         cli_putstr_P(PSTR("\r\n  key:   "));
 411         cli_hexdump(key, 128/8);
 412         cli_putstr_P(PSTR("\r\n  IV:    "));
 413         cli_hexdump(iv, 128/8);
 414         cli_putstr_P(PSTR("\r\n  plaintext:"));
 415         cli_hexdump_block(plain, 4*128/8, 4, 16);
 416         if(r)
 417                 return;
 418         bcal_ctr_encMsg(iv, plain, 4*128, &ctx);
 419         cli_putstr_P(PSTR("\r\n  ciphertext:  "));
 420         cli_hexdump_block(plain, 4*128/8, 4, 16);
 421         bcal_ctr_decMsg(iv, plain, 4*128, &ctx);
 422         cli_putstr_P(PSTR("\r\n  plaintext:   "));
 423         cli_hexdump_block(plain, 4*128/8, 4, 16);
 424         bcal_ctr_free(&ctx);
 425 }
 426
 427 void testrun_aes128_cmac(void){
 428         uint8_t key[16];
 429         uint8_t tag[16];
 430         uint8_t plain[64];
 431         uint16_t length[] = { 0, 128, 320, 512 };
 432         bcal_cmac_ctx_t ctx;
 433         uint8_t r,i;
 434
 435         memcpy_P(key,   modes_key,   16);
 436         memcpy_P(plain, modes_plain, 64);
 437
 438         cli_putstr_P(PSTR("\r\n** AES128-CMAC-TEST **"));
 439
 440         cli_putstr_P(PSTR("\r\n  key:   "));
 441         cli_hexdump(key, 128/8);
 442         for(i=0; i<4; ++i){
 443                 r = bcal_cmac_init(&aes128_desc, key, 128, &ctx);
 444                 cli_putstr_P(PSTR("\r\n  init = 0x"));
 445                 cli_hexdump(&r, 1);
 446                 cli_putstr_P(PSTR("\r\n  message: "));
 447                 cli_hexdump_block(plain, length[i]/8, 4, 16);
 448                 if(r)
 449                         return;
 450                 bcal_cmac(tag, 128, plain, length[i], &ctx);
 451                 cli_putstr_P(PSTR("\r\n  tag:     "));
 452                 cli_hexdump_block(tag, 128/8, 4, 16);
 453                 bcal_cmac_free(&ctx);
 454         }
 455 }
 456 /*
 457 Klen = 16
 458 Mlen = 18
 459 Tlen = 2
 460 Key = 3250974e306b4b678f914b514d1e90f6
 461 Msg = cf132fd4ebc25fd3866f1a95a6193a1a9cdf
 462 */
 463 void testrun_aes128_cmac72(void){
 464         uint8_t key[16]= {
 465                         0x32, 0x50, 0x97, 0x4e, 0x30, 0x6b, 0x4b, 0x67,
 466                         0x8f, 0x91, 0x4b, 0x51, 0x4d, 0x1e, 0x90, 0xf6
 467         };
 468         uint8_t tag[2];
 469         uint8_t plain[18] = {
 470                         0xcf, 0x13, 0x2f, 0xd4, 0xeb, 0xc2, 0x5f, 0xd3,
 471                         0x86, 0x6f, 0x1a, 0x95, 0xa6, 0x19, 0x3a, 0x1a,
 472                         0x9c, 0xdf,
 473         };
 474         bcal_cmac_ctx_t ctx;
 475         uint8_t r;
 476
 477
 478         cli_putstr_P(PSTR("\r\n** AES128-CMAC-72-TEST **"));
 479
 480         cli_putstr_P(PSTR("\r\n  key:   "));
 481         cli_hexdump(key, 128/8);
 482         r = bcal_cmac_init(&aes128_desc, key, 128, &ctx);
 483         cli_putstr_P(PSTR("\r\n  init = 0x"));
 484         cli_hexdump(&r, 1);
 485         cli_putstr_P(PSTR("\r\n  message: "));
 486         cli_hexdump_block(plain, 18, 4, 16);
 487         if(r)
 488                 return;
 489         bcal_cmac(tag, 16, plain, 18*8, &ctx);
 490         cli_putstr_P(PSTR("\r\n  tag:     "));
 491         cli_hexdump_block(tag, 2, 4, 16);
 492         bcal_cmac_free(&ctx);
 493 }
 494 /*
 495 Count = 0
 496 Klen = 24
 497 Mlen = 0
 498 Tlen = 2
 499 Key = 2b2aaa666be161ed16648e862ac9bd1e317f71bc69e268b5
 500 Msg = 00
 501 */
 502 void testrun_aes192_cmac0(void){
 503         uint8_t key[24]= {
 504                         0x2b, 0x2a, 0xaa, 0x66, 0x6b, 0xe1, 0x61, 0xed,
 505                         0x16, 0x64, 0x8e, 0x86, 0x2a, 0xc9, 0xbd, 0x1e,
 506                         0x31, 0x7f, 0x71, 0xbc, 0x69, 0xe2, 0x68, 0xb5
 507         };
 508         uint8_t tag[2];
 509         uint8_t plain[1] = {
 510                         0x00
 511         };
 512         bcal_cmac_ctx_t ctx;
 513         uint8_t r;
 514
 515
 516         cli_putstr_P(PSTR("\r\n** AES192-CMAC-0-TEST **"));
 517
 518         cli_putstr_P(PSTR("\r\n  key:   "));
 519         cli_hexdump(key, 192/8);
 520         r = bcal_cmac_init(&aes192_desc, key, 192, &ctx);
 521         cli_putstr_P(PSTR("\r\n  init = 0x"));
 522         cli_hexdump(&r, 1);
 523         if(r)
 524                 return;
 525         bcal_cmac(tag, 16, plain, 0*8, &ctx);
 526         cli_putstr_P(PSTR("\r\n  tag:     "));
 527         cli_hexdump_block(tag, 2, 4, 16);
 528         bcal_cmac_free(&ctx);
 529 }
 530 /*
 531 MSG:
 532 KEY:    233952DEE4D5ED5F9B9C6D6FF80FF478
 533 NONCE:  62EC67F9C3A4A407FCB2A8C49031A8B3
 534 HEADER: 6BFB914FD07EAE6B
 535 CIPHER: E037830E8389F27B025A2D6527E79D01
 536 */
 537
 538 void testrun_aes128_eax(void){
 539         uint8_t key[16]= {
 540                         0x23, 0x39, 0x52, 0xDE, 0xE4, 0xD5, 0xED, 0x5F,
 541                         0x9B, 0x9C, 0x6D, 0x6F, 0xF8, 0x0F, 0xF4, 0x78
 542         };
 543         uint8_t nonce[16] = {
 544                         0x62, 0xEC, 0x67, 0xF9, 0xC3, 0xA4, 0xA4, 0x07,
 545                         0xFC, 0xB2, 0xA8, 0xC4, 0x90, 0x31, 0xA8, 0xB3
 546         };
 547         uint8_t header[8] = {
 548                         0x6B, 0xFB, 0x91, 0x4F, 0xD0, 0x7E, 0xAE, 0x6B
 549         };
 550         uint8_t tag[16];
 551
 552         bcal_eax_ctx_t ctx;
 553         uint8_t r;
 554
 555
 556         cli_putstr_P(PSTR("\r\n** AES128-EAX-TEST **"));
 557
 558         cli_putstr_P(PSTR("\r\n  key:     "));
 559         cli_hexdump(key, 16);
 560         cli_putstr_P(PSTR("\r\n  nonce:   "));
 561         cli_hexdump(nonce, 16);
 562         cli_putstr_P(PSTR("\r\n  header:  "));
 563         cli_hexdump(header, 8);
 564         r = bcal_eax_init(&aes128_desc, key, 128, &ctx);
 565         cli_putstr_P(PSTR("\r\n  init = 0x"));
 566         cli_hexdump(&r, 1);
 567         if(r)
 568                 return;
 569         bcal_eax_loadNonce(nonce, 16*8, &ctx);
 570         bcal_eax_addLastHeader(header, 8*8, &ctx);
 571         bcal_eax_encLastBlock(NULL, 0, &ctx);
 572         bcal_eax_ctx2tag(tag, 128, &ctx);
 573         cli_putstr_P(PSTR("\r\n  tag:     "));
 574         cli_hexdump_block(tag, 16, 4, 16);
 575         bcal_eax_free(&ctx);
 576 }
 577
 578 /*
 579 MSG:    F7FB
 580 KEY:    91945D3F4DCBEE0BF45EF52255F095A4
 581 NONCE:  BECAF043B0A23D843194BA972C66DEBD
 582 HEADER: FA3BFD4806EB53FA
 583 CIPHER:
 584  */
 585 void testrun_aes128_eax2(void){
 586         uint8_t key[16]= {
 587                         0x91, 0x94, 0x5D, 0x3F, 0x4D, 0xCB, 0xEE, 0x0B,
 588                         0xF4, 0x5E, 0xF5, 0x22, 0x55, 0xF0, 0x95, 0xA4,
 589         };
 590         uint8_t msg[2] = { 0xF7, 0xFB };
 591         uint8_t nonce[16] = {
 592                         0xBE, 0xCA, 0xF0, 0x43, 0xB0, 0xA2, 0x3D, 0x84,
 593                         0x31, 0x94, 0xBA, 0x97, 0x2C, 0x66, 0xDE, 0xBD,
 594         };
 595         uint8_t header[8] = {
 596                         0xFA, 0x3B, 0xFD, 0x48, 0x06, 0xEB, 0x53, 0xFA
 597         };
 598         uint8_t tag[16];
 599
 600         bcal_eax_ctx_t ctx;
 601         uint8_t r;
 602
 603
 604         cli_putstr_P(PSTR("\r\n** AES128-EAX2-TEST **"));
 605
 606         cli_putstr_P(PSTR("\r\n  key:     "));
 607         cli_hexdump(key, 16);
 608         cli_putstr_P(PSTR("\r\n  msg:     "));
 609         cli_hexdump(msg, 2);
 610         cli_putstr_P(PSTR("\r\n  nonce:   "));
 611         cli_hexdump(nonce, 16);
 612         cli_putstr_P(PSTR("\r\n  header:  "));
 613         cli_hexdump(header, 8);
 614         r = bcal_eax_init(&aes128_desc, key, 128, &ctx);
 615         cli_putstr_P(PSTR("\r\n  init = 0x"));
 616         cli_hexdump(&r, 1);
 617         if(r)
 618                 return;
 619         bcal_eax_loadNonce(nonce, 16*8, &ctx);
 620         bcal_eax_addLastHeader(header, 8*8, &ctx);
 621         bcal_eax_encLastBlock(msg, 2*8, &ctx);
 622         bcal_eax_ctx2tag(tag, 128, &ctx);
 623         cli_putstr_P(PSTR("\r\n  cipher:  "));
 624         cli_hexdump_block(msg, 2, 4, 16);
 625         cli_putstr_P(PSTR("\r\n  tag:     "));
 626         cli_hexdump_block(tag, 16, 4, 16);
 627         bcal_eax_free(&ctx);
 628 }
 629 /*
 630 MSG:    1A47CB4933
 631 KEY:    01F74AD64077F2E704C0F60ADA3DD523
 632 NONCE:  70C3DB4F0D26368400A10ED05D2BFF5E
 633 HEADER: 234A3463C1264AC6
 634 CIPHER:
 635 */
 636 void testrun_aes128_eax3(void){
 637         uint8_t key[16]= {
 638                         0x01, 0xF7, 0x4A, 0xD6, 0x40, 0x77, 0xF2, 0xE7,
 639                         0x04, 0xC0, 0xF6, 0x0A, 0xDA, 0x3D, 0xD5, 0x23
 640         };
 641         uint8_t msg[5] = {
 642                         0x1A, 0x47, 0xCB, 0x49, 0x33
 643         };
 644         uint8_t nonce[16] = {
 645                         0x70, 0xC3, 0xDB, 0x4F, 0x0D, 0x26, 0x36, 0x84,
 646                         0x00, 0xA1, 0x0E, 0xD0, 0x5D, 0x2B, 0xFF, 0x5E
 647         };
 648         uint8_t header[8] = {
 649                         0x23, 0x4A, 0x34, 0x63, 0xC1, 0x26, 0x4A, 0xC6
 650         };
 651         uint8_t tag[16];
 652
 653         bcal_eax_ctx_t ctx;
 654         uint8_t r;
 655
 656
 657         cli_putstr_P(PSTR("\r\n** AES128-EAX3-TEST **"));
 658
 659         cli_putstr_P(PSTR("\r\n  key:     "));
 660         cli_hexdump(key, 16);
 661         cli_putstr_P(PSTR("\r\n  msg:     "));
 662         cli_hexdump(msg, 5);
 663         cli_putstr_P(PSTR("\r\n  nonce:   "));
 664         cli_hexdump(nonce, 16);
 665         cli_putstr_P(PSTR("\r\n  header:  "));
 666         cli_hexdump(header, 8);
 667         r = bcal_eax_init(&aes128_desc, key, 128, &ctx);
 668         cli_putstr_P(PSTR("\r\n  init = 0x"));
 669         cli_hexdump(&r, 1);
 670         if(r)
 671                 return;
 672         bcal_eax_loadNonce(nonce, 16*8, &ctx);
 673         bcal_eax_addLastHeader(header, 8*8, &ctx);
 674         bcal_eax_encLastBlock(msg, 5*8, &ctx);
 675         bcal_eax_ctx2tag(tag, 128, &ctx);
 676         cli_putstr_P(PSTR("\r\n  cipher:  "));
 677         cli_hexdump_block(msg, 5, 4, 16);
 678         cli_putstr_P(PSTR("\r\n  tag:     "));
 679         cli_hexdump_block(tag, 16, 4, 16);
 680         bcal_eax_free(&ctx);
 681 }
 682
 683 /*****************************************************************************/
 684
 685 void testrun_performance_aes128(void){
 686         uint64_t t;
 687         char str[16];
 688         uint8_t key[32], data[16];
 689         aes128_ctx_t ctx;
 690
 691         calibrateTimer();
 692         print_overhead();
 693
 694         memset(key,  0, 32);
 695         memset(data, 0, 16);
 696
 697         startTimer(1);
 698         aes128_init(key, &ctx);
 699         t = stopTimer();
 700         cli_putstr_P(PSTR("\r\n\tctx-gen time: "));
 701         ultoa((unsigned long)t, str, 10);
 702         cli_putstr(str);
 703
 704
 705         startTimer(1);
 706         aes128_enc(data, &ctx);
 707         t = stopTimer();
 708         cli_putstr_P(PSTR("\r\n\tencrypt time: "));
 709         ultoa((unsigned long)t, str, 10);
 710         cli_putstr(str);
 711
 712
 713         startTimer(1);
 714         aes128_dec(data, &ctx);
 715         t = stopTimer();
 716         cli_putstr_P(PSTR("\r\n\tdecrypt time: "));
 717         ultoa((unsigned long)t, str, 10);
 718         cli_putstr(str);
 719
 720         cli_putstr_P(PSTR("\r\n"));
 721 }
 722
 723
 724 void testrun_performance_aes192(void){
 725         uint64_t t;
 726         char str[16];
 727         uint8_t key[32], data[16];
 728         aes192_ctx_t ctx;
 729
 730         calibrateTimer();
 731         print_overhead();
 732
 733         memset(key,  0, 32);
 734         memset(data, 0, 16);
 735
 736         startTimer(1);
 737         aes192_init(key, &ctx);
 738         t = stopTimer();
 739         cli_putstr_P(PSTR("\r\n\tctx-gen time: "));
 740         ultoa((unsigned long)t, str, 10);
 741         cli_putstr(str);
 742
 743
 744         startTimer(1);
 745         aes192_enc(data, &ctx);
 746         t = stopTimer();
 747         cli_putstr_P(PSTR("\r\n\tencrypt time: "));
 748         ultoa((unsigned long)t, str, 10);
 749         cli_putstr(str);
 750
 751
 752         startTimer(1);
 753         aes192_dec(data, &ctx);
 754         t = stopTimer();
 755         cli_putstr_P(PSTR("\r\n\tdecrypt time: "));
 756         ultoa((unsigned long)t, str, 10);
 757         cli_putstr(str);
 758
 759         cli_putstr_P(PSTR("\r\n"));
 760 }
 761
 762
 763 void testrun_performance_aes256(void){
 764         uint64_t t;
 765         char str[16];
 766         uint8_t key[32], data[16];
 767         aes256_ctx_t ctx;
 768
 769         calibrateTimer();
 770         print_overhead();
 771
 772         memset(key,  0, 32);
 773         memset(data, 0, 16);
 774
 775         startTimer(1);
 776         aes256_init(key, &ctx);
 777         t = stopTimer();
 778         cli_putstr_P(PSTR("\r\n\tctx-gen time: "));
 779         ultoa((unsigned long)t, str, 10);
 780         cli_putstr(str);
 781
 782
 783         startTimer(1);
 784         aes256_enc(data, &ctx);
 785         t = stopTimer();
 786         cli_putstr_P(PSTR("\r\n\tencrypt time: "));
 787         ultoa((unsigned long)t, str, 10);
 788         cli_putstr(str);
 789
 790
 791         startTimer(1);
 792         aes256_dec(data, &ctx);
 793         t = stopTimer();
 794         cli_putstr_P(PSTR("\r\n\tdecrypt time: "));
 795         ultoa((unsigned long)t, str, 10);
 796         cli_putstr(str);
 797
 798         cli_putstr_P(PSTR("\r\n"));
 799 }
 800
 801 void testrun_performance_aes(void){
 802         cli_putstr_P(PSTR("\r\n -=AES Performance Test=-\r\n"));
 803         cli_putstr_P(PSTR("\r\n       AES-128\r\n"));
 804         testrun_performance_aes128();
 805         cli_putstr_P(PSTR("\r\n       AES-192\r\n"));
 806         testrun_performance_aes192();
 807         cli_putstr_P(PSTR("\r\n       AES-256\r\n"));
 808         testrun_performance_aes256();
 809 }
 810 /*****************************************************************************
 811  *  main                                                                                                                                         *
 812  *****************************************************************************/
 813
 814 const char nessie_str[]       PROGMEM = "nessie";
 815 const char test_str[]         PROGMEM = "test";
 816 const char testkey_str[]      PROGMEM = "testkey";
 817 const char testcbc_str[]      PROGMEM = "testcbc";
 818 const char testcfb8_str[]     PROGMEM = "testcfb8";
 819 const char testcfb1_str[]     PROGMEM = "testcfb1";
 820 const char testofb_str[]      PROGMEM = "testofb";
 821 const char testctr_str[]      PROGMEM = "testctr";
 822 const char testcmac_str[]     PROGMEM = "testcmac";
 823 const char testcmac72_str[]   PROGMEM = "testcmac72";
 824 const char testcmac0_str[]    PROGMEM = "testcmac0";
 825 const char testeax_str[]      PROGMEM = "testeax";
 826 const char testeax2_str[]     PROGMEM = "testeax2";
 827 const char testeax3_str[]     PROGMEM = "testeax3";
 828 const char cmacvs_list_str[]  PROGMEM = "cmacvs_list";
 829 const char cmacvs_set_str[]   PROGMEM = "cmacvs_set";
 830 const char cmacvs_test1_str[] PROGMEM = "cmacvs_test1";
 831 const char cmacvs_test2_str[] PROGMEM = "cmacvs_test2";
 832 const char performance_str[]  PROGMEM = "performance";
 833 const char dump_str[]         PROGMEM = "dump";
 834 const char echo_str[]         PROGMEM = "echo";
 835
 836 cmdlist_entry_t cmdlist[] PROGMEM = {
 837         { nessie_str,          NULL, testrun_nessie_aes              },
 838         { test_str,            NULL, testrun_test_aes                },
 839         { testkey_str,         NULL, testrun_testkey_aes             },
 840         { testcbc_str,         NULL, testrun_aes128_cbc              },
 841         { testcfb8_str,        NULL, testrun_aes128_cfb8             },
 842         { testcfb1_str,        NULL, testrun_aes128_cfb1             },
 843         { testofb_str,         NULL, testrun_aes128_ofb              },
 844         { testctr_str,         NULL, testrun_aes128_ctr              },
 845         { testcmac_str,        NULL, testrun_aes128_cmac             },
 846         { testcmac72_str,      NULL, testrun_aes128_cmac72           },
 847         { testcmac0_str,       NULL, testrun_aes192_cmac0            },
 848         { testeax_str,         NULL, testrun_aes128_eax              },
 849         { testeax2_str,        NULL, testrun_aes128_eax2             },
 850         { testeax3_str,        NULL, testrun_aes128_eax3             },
 851         { cmacvs_list_str,     NULL, cmacvs_listalgos                },
 852         { cmacvs_set_str,  (void*)1, (void_fpt)cmacvs_setalgo        },
 853         { cmacvs_test1_str,    NULL, cmacvs_test1                    },
 854         { cmacvs_test2_str,    NULL, cmacvs_test2                    },
 855         { performance_str,     NULL, testrun_performance_aes         },
 856         { dump_str,        (void*)1, (void_fpt)dump                  },
 857         { echo_str,        (void*)1, (void_fpt)echo_ctrl             },
 858         { NULL,                NULL, NULL                            }
 859 };
 860
 861
 862 int main (void){
 863         DEBUG_INIT();
 864
 865         cli_rx = (cli_rx_fpt)uart0_getc;
 866         cli_tx = (cli_tx_fpt)uart0_putc;
 867         cmacvs_algolist=(bcdesc_t**)algolist;
 868         cmacvs_algo=(bcdesc_t*)&aes128_desc;
 869         for(;;){
 870                 cli_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
 871                 cli_putstr(algo_name);
 872                 cli_putstr_P(PSTR(")\r\nloaded and running\r\n"));
 873                 cmd_interface(cmdlist);
 874         }
 875 }
 876