test_src/main-rabbit-test.c

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