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