test_src/main-rabbit-test.c

   1 /* main-rabbit-test.c */
   2 /*
   3     This file is part of the AVR-Crypto-Lib.
   4     Copyright (C) 2006-2011 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 #include "main-test-common.h"
  21
  22 #include "rabbit.h"
  23 #include "performance_test.h"
  24
  25 #include "scal_rabbit.h"
  26 #include "scal-basic.h"
  27 #include "scal-nessie.h"
  28
  29 const char *algo_name = "Rabbit";
  30
  31 /*****************************************************************************
  32  *  additional validation-functions                                                                                      *
  33  *****************************************************************************/
  34
  35 void test_vector(void *key, void *iv, const void *ref){
  36         rabbit_ctx_t ctx;
  37         uint8_t fail=0;
  38         cli_putstr_P(PSTR("\r\n testing with\r\n key:  "));
  39         cli_hexdump(key, 16);
  40         cli_putstr_P(PSTR("\r\n iv:   "));
  41         if(iv){
  42                 cli_hexdump(iv, 8);
  43         }else{
  44                 cli_putstr_P(PSTR("[no iv]"));
  45         }
  46         rabbit_init(key, 128, iv, &ctx);
  47         rabbit_gen(&ctx);
  48         if(!ref || (memcmp_P(ctx.buffer, ref, 16))!=0){
  49                 fail = 1;
  50                 cli_putstr_P(PSTR("\r\n S[0]: "));
  51                 cli_hexdump(ctx.buffer, 16);
  52         }
  53         ctx.buffer_idx=16;
  54         rabbit_gen(&ctx);
  55         if(!ref || (memcmp_P(ctx.buffer, ref, 16))!=0){
  56                 fail = 1;
  57                 cli_putstr_P(PSTR("\r\n S[0]: "));
  58                 cli_hexdump(ctx.buffer, 16);
  59         }
  60         ctx.buffer_idx=16;
  61         rabbit_gen(&ctx);
  62         if(!ref || (memcmp_P(ctx.buffer, ref, 16))!=0){
  63                 fail = 1;
  64                 cli_putstr_P(PSTR("\r\n S[0]: "));
  65                 cli_hexdump(ctx.buffer, 16);
  66         }
  67         if(ref){
  68                 cli_putstr_P(fail?PSTR("\r\n [fail]"):PSTR("\r\n [ok]"));
  69         }
  70         cli_putstr_P(PSTR("\r\n"));
  71 }
  72
  73 void nessie_first(void){
  74         uint8_t key[16];
  75     uint8_t iv[8];
  76
  77         memset(iv, 0, 8);
  78         memset(key, 0, 16);
  79         key[0] = 0x80;
  80         test_vector(key, iv, NULL);
  81         key[0] = 0x00;
  82
  83         key[15] = 0x80;
  84         test_vector(key, iv, NULL);
  85
  86 }
  87
  88
  89 const uint8_t spec_key1[] PROGMEM = {
  90         0x91, 0x28, 0x13, 0x29, 0x2E, /* 0xED */ 0x3D, 0x36, 0xFE,
  91         0x3B, 0xFC, 0x62, 0xF1, 0xDC, 0x51, 0xC3, 0xAC
  92 };
  93
  94 const uint8_t spec_key2[] PROGMEM = {
  95         0x83, 0x95, 0x74, 0x15, 0x87, 0xE0, 0xC7, 0x33,
  96         0xE9, 0xE9, 0xAB, 0x01, 0xC0, 0x9B, 0x00, 0x43
  97 };
  98
  99 const uint8_t spec_iv1[] PROGMEM = {
 100         0xC3, 0x73, 0xF5, 0x75, 0xC1, 0x26, 0x7E, 0x59
 101 };
 102
 103 const uint8_t spec_iv2[] PROGMEM = {
 104         0xA6, 0xEB, 0x56, 0x1A, 0xD2, 0xF4, 0x17, 0x27
 105 };
 106
 107 const uint8_t spec_ref[] PROGMEM = {
 108         0xB1, 0x57, 0x54, 0xF0, 0x36, 0xA5, 0xD6, 0xEC, 0xF5, 0x6B, 0x45, 0x26, 0x1C, 0x4A, 0xF7, 0x02,
 109         0x88, 0xE8, 0xD8, 0x15, 0xC5, 0x9C, 0x0C, 0x39, 0x7B, 0x69, 0x6C, 0x47, 0x89, 0xC6, 0x8A, 0xA7,
 110         0xF4, 0x16, 0xA1, 0xC3, 0x70, 0x0C, 0xD4, 0x51, 0xDA, 0x68, 0xD1, 0x88, 0x16, 0x73, 0xD6, 0x96,
 111
 112         0x3D, 0x2D, 0xF3, 0xC8, 0x3E, 0xF6, 0x27, 0xA1, 0xE9, 0x7F, 0xC3, 0x84, 0x87, 0xE2, 0x51, 0x9C,
 113         0xF5, 0x76, 0xCD, 0x61, 0xF4, 0x40, 0x5B, 0x88, 0x96, 0xBF, 0x53, 0xAA, 0x85, 0x54, 0xFC, 0x19,
 114         0xE5, 0x54, 0x74, 0x73, 0xFB, 0xDB, 0x43, 0x50, 0x8A, 0xE5, 0x3B, 0x20, 0x20, 0x4D, 0x4C, 0x5E,
 115
 116         0x0C, 0xB1, 0x0D, 0xCD, 0xA0, 0x41, 0xCD, 0xAC, 0x32, 0xEB, 0x5C, 0xFD, 0x02, 0xD0, 0x60, 0x9B,
 117         0x95, 0xFC, 0x9F, 0xCA, 0x0F, 0x17, 0x01, 0x5A, 0x7B, 0x70, 0x92, 0x11, 0x4C, 0xFF, 0x3E, 0xAD,
 118         0x96, 0x49, 0xE5, 0xDE, 0x8B, 0xFC, 0x7F, 0x3F, 0x92, 0x41, 0x47, 0xAD, 0x3A, 0x94, 0x74, 0x28,
 119
 120         0xC6, 0xA7, 0x27, 0x5E, 0xF8, 0x54, 0x95, 0xD8, 0x7C, 0xCD, 0x5D, 0x37, 0x67, 0x05, 0xB7, 0xED,
 121         0x5F, 0x29, 0xA6, 0xAC, 0x04, 0xF5, 0xEF, 0xD4, 0x7B, 0x8F, 0x29, 0x32, 0x70, 0xDC, 0x4A, 0x8D,
 122         0x2A, 0xDE, 0x82, 0x2B, 0x29, 0xDE, 0x6C, 0x1E, 0xE5, 0x2B, 0xDB, 0x8A, 0x47, 0xBF, 0x8F, 0x66,
 123
 124         0x1F, 0xCD, 0x4E, 0xB9, 0x58, 0x00, 0x12, 0xE2, 0xE0, 0xDC, 0xCC, 0x92, 0x22, 0x01, 0x7D, 0x6D,
 125         0xA7, 0x5F, 0x4E, 0x10, 0xD1, 0x21, 0x25, 0x01, 0x7B, 0x24, 0x99, 0xFF, 0xED, 0x93, 0x6F, 0x2E,
 126         0xEB, 0xC1, 0x12, 0xC3, 0x93, 0xE7, 0x38, 0x39, 0x23, 0x56, 0xBD, 0xD0, 0x12, 0x02, 0x9B, 0xA7,
 127
 128         0x44, 0x5A, 0xD8, 0xC8, 0x05, 0x85, 0x8D, 0xBF, 0x70, 0xB6, 0xAF, 0x23, 0xA1, 0x51, 0x10, 0x4D,
 129         0x96, 0xC8, 0xF2, 0x79, 0x47, 0xF4, 0x2C, 0x5B, 0xAE, 0xAE, 0x67, 0xC6, 0xAC, 0xC3, 0x5B, 0x03,
 130         0x9F, 0xCB, 0xFC, 0x89, 0x5F, 0xA7, 0x1C, 0x17, 0x31, 0x3D, 0xF0, 0x34, 0xF0, 0x15, 0x51, 0xCB
 131 };
 132
 133 void spec_test(void){
 134         uint8_t key[16];
 135     uint8_t iv[8];
 136     const uint8_t *ref;
 137     ref = spec_ref;
 138
 139         memset(key, 0, 16);
 140         test_vector(key, NULL, ref);
 141         memcpy_P(key, spec_key1, 16);
 142         ref += 48;
 143         test_vector(key, NULL, ref);
 144         memcpy_P(key, spec_key2, 16);
 145         ref += 48;
 146         test_vector(key, NULL, ref);
 147
 148
 149         memset(key, 0, 16);
 150         memset(iv, 0, 8);
 151         ref += 48;
 152         test_vector(key, iv, ref);
 153         memcpy_P(iv,  spec_iv1,   8);
 154         ref += 48;
 155         test_vector(key, iv, ref);
 156         memcpy_P(iv,  spec_iv2,   8);
 157         ref += 48;
 158         test_vector(key, iv, ref);
 159 }
 160
 161
 162 void testrun_nessie_rabbit(void){
 163         scal_nessie_set_estream(1);
 164         scal_nessie_run(&rabbit_desc);
 165 }
 166
 167
 168
 169 void testrun_performance_rabbit(void){
 170         uint64_t t;
 171         char str[16];
 172         uint8_t key[16];
 173         rabbit_ctx_t ctx;
 174
 175         calibrateTimer();
 176         print_overhead();
 177
 178         memset(key,  0, 16);
 179
 180         startTimer(1);
 181         rabbit_init(key, 128, NULL, &ctx);
 182         t = stopTimer();
 183         cli_putstr_P(PSTR("\r\n\tctx-gen time: "));
 184         ultoa((unsigned long)t, str, 10);
 185         cli_putstr(str);
 186
 187         startTimer(1);
 188         rabbit_gen(&ctx);
 189         t = stopTimer();
 190         cli_putstr_P(PSTR("\r\n\tencrypt time: "));
 191         ultoa((unsigned long)t, str, 10);
 192         cli_putstr(str);
 193
 194         cli_putstr_P(PSTR("\r\n"));
 195 }
 196
 197
 198 /*****************************************************************************
 199  *  main                                                                                                                                         *
 200  *****************************************************************************/
 201
 202 const char nessie_str[]      PROGMEM = "nessie";
 203 const char first_str[]       PROGMEM = "first";
 204 const char test_str[]        PROGMEM = "test";
 205 const char performance_str[] PROGMEM = "performance";
 206 const char echo_str[]        PROGMEM = "echo";
 207
 208 const cmdlist_entry_t cmdlist[] PROGMEM = {
 209         { nessie_str,      NULL, testrun_nessie_rabbit},
 210         { performance_str, NULL, testrun_performance_rabbit},
 211         { first_str,       NULL, nessie_first},
 212         { test_str,        NULL, spec_test},
 213         { echo_str,    (void*)1, (void_fpt)echo_ctrl},
 214         { NULL,            NULL, NULL}
 215 };
 216
 217 int main (void){
 218     main_setup();
 219
 220     for(;;){
 221         welcome_msg(algo_name);
 222         cmd_interface(cmdlist);
 223         }
 224 }
 225