test_src/main-skein-test.c

   1 /* main-skein-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  * skein test-suit
  21  *
  22 */
  23
  24 #include "config.h"
  25
  26 #include "uart_i.h"
  27 #include "debug.h"
  28
  29 #include "skein.h"
  30 #include "hfal/hfal_skein256.h"
  31 #include "hfal/hfal_skein512.h"
  32 #include "hfal/hfal_skein1024.h"
  33 #include "cli.h"
  34 #include "shavs.h"
  35 #include "nessie_hash_test.h"
  36 #include "performance_test.h"
  37 #include "hfal/hfal-performance.h"
  38 #include "hfal/hfal-nessie.h"
  39 #include "hfal/hfal-basic.h"
  40
  41
  42 #include <stdint.h>
  43 #include <string.h>
  44 #include <stdlib.h>
  45
  46 char* algo_name = "Skein";
  47
  48 const hfdesc_t* algolist[] PROGMEM = {
  49         (hfdesc_t*)&skein256_128_desc,
  50         (hfdesc_t*)&skein256_160_desc,
  51         (hfdesc_t*)&skein256_224_desc,
  52         (hfdesc_t*)&skein256_256_desc,
  53         (hfdesc_t*)&skein256_384_desc,
  54         (hfdesc_t*)&skein256_512_desc,
  55
  56         (hfdesc_t*)&skein512_128_desc,
  57         (hfdesc_t*)&skein512_160_desc,
  58         (hfdesc_t*)&skein512_224_desc,
  59         (hfdesc_t*)&skein512_256_desc,
  60         (hfdesc_t*)&skein512_384_desc,
  61         (hfdesc_t*)&skein512_512_desc,
  62         (hfdesc_t*)&skein512_1024_desc,
  63
  64         (hfdesc_t*)&skein1024_128_desc,
  65         (hfdesc_t*)&skein1024_160_desc,
  66         (hfdesc_t*)&skein1024_224_desc,
  67         (hfdesc_t*)&skein1024_256_desc,
  68         (hfdesc_t*)&skein1024_384_desc,
  69         (hfdesc_t*)&skein1024_512_desc,
  70         (hfdesc_t*)&skein1024_1024_desc,
  71         NULL
  72 };
  73
  74 /*****************************************************************************
  75  *  additional validation-functions                                                                                      *
  76  *****************************************************************************/
  77 void testrun_stdtest_skein256(uint16_t outsize_b){
  78         uint8_t message[64];
  79         uint8_t hash[(outsize_b+7)/8];
  80         uint8_t i;
  81
  82         cli_putstr_P(PSTR("\r\n\r\nTest vectors for Skein (256 bits):"));
  83         for(i=0; i<64; ++i)
  84                 message[i] = 0xFF-i;
  85
  86         cli_putstr_P(PSTR("\r\nmessage:    "));
  87         cli_hexdump(message, 1);
  88         skein256(hash, outsize_b, message, 8);
  89         cli_putstr_P(PSTR("\r\nhash:"));
  90         cli_hexdump_block(hash, (outsize_b+7)/8, 4, 16);
  91
  92         cli_putstr_P(PSTR("\r\nmessage:"));
  93         cli_hexdump_block(message, 32, 4, 16);
  94         skein256(hash, outsize_b, message, 32*8);
  95         cli_putstr_P(PSTR("\r\nhash:"));
  96         cli_hexdump_block(hash, (outsize_b+7)/8, 4, 16);
  97
  98         cli_putstr_P(PSTR("\r\nmessage:"));
  99         cli_hexdump_block(message, 64, 4, 16);
 100         skein256(hash, outsize_b, message, 64*8);
 101         cli_putstr_P(PSTR("\r\nhash:"));
 102         cli_hexdump_block(hash, (outsize_b+7)/8, 4, 16);
 103 }
 104
 105 void testrun_stdtest_skein512(uint16_t outsize_b){
 106         uint8_t message[128];
 107         uint8_t hash[(outsize_b+7)/8];
 108         uint8_t i;
 109
 110         cli_putstr_P(PSTR("\r\n\r\nTest vectors for Skein (512 bits):"));
 111         for(i=0; i<128; ++i)
 112                 message[i] = 0xFF-i;
 113
 114         cli_putstr_P(PSTR("\r\nmessage:    "));
 115         cli_hexdump(message, 1);
 116         skein512(hash, outsize_b, message, 8);
 117         cli_putstr_P(PSTR("\r\nhash:"));
 118         cli_hexdump_block(hash, (outsize_b+7)/8, 4, 16);
 119
 120         cli_putstr_P(PSTR("\r\nmessage:"));
 121         cli_hexdump_block(message, 64, 4, 16);
 122         skein512(hash, outsize_b, message, 64*8);
 123         cli_putstr_P(PSTR("\r\nhash:"));
 124         cli_hexdump_block(hash, (outsize_b+7)/8, 4, 16);
 125
 126         cli_putstr_P(PSTR("\r\nmessage:"));
 127         cli_hexdump_block(message, 128, 4, 16);
 128         skein512(hash, outsize_b, message, 128*8);
 129         cli_putstr_P(PSTR("\r\nhash:"));
 130         cli_hexdump_block(hash, (outsize_b+7)/8, 4, 16);
 131 }
 132
 133 void testrun_stdtest_skein1024(uint16_t outsize_b){
 134         uint8_t message[256];
 135         uint8_t hash[(outsize_b+7)/8];
 136         uint16_t i;
 137
 138         cli_putstr_P(PSTR("\r\n\r\nTest vectors for Skein (1024 bits):"));
 139         for(i=0; i<256; ++i)
 140                 message[i] = 0xFF-i;
 141
 142         cli_putstr_P(PSTR("\r\nmessage:    "));
 143         cli_hexdump(message, 1);
 144         skein1024(hash, outsize_b, message, 8);
 145         cli_putstr_P(PSTR("\r\nhash:"));
 146         cli_hexdump_block(hash, (outsize_b+7)/8, 4, 16);
 147
 148         cli_putstr_P(PSTR("\r\nmessage:"));
 149         cli_hexdump_block(message, 128, 4, 16);
 150         skein1024(hash, outsize_b, message, 128*8);
 151         cli_putstr_P(PSTR("\r\nhash:"));
 152         cli_hexdump_block(hash, (outsize_b+7)/8, 4, 16);
 153
 154         cli_putstr_P(PSTR("\r\nmessage:"));
 155         cli_hexdump_block(message, 256, 4, 16);
 156         skein1024(hash, outsize_b, message, 256*8);
 157         cli_putstr_P(PSTR("\r\nhash:"));
 158         cli_hexdump_block(hash, (outsize_b+7)/8, 4, 16);
 159 }
 160
 161 void testrun_stdtest_skein(void){
 162         testrun_stdtest_skein256(256);
 163         testrun_stdtest_skein512(512);
 164         testrun_stdtest_skein1024(1024);
 165 }
 166
 167 void zeromsg_test_skein(uint16_t outsize_b){
 168         char str[8];
 169         uint8_t hash[(outsize_b+7)/8];
 170
 171         skein256(hash, outsize_b, NULL, 0);
 172         cli_putstr_P(PSTR("\r\nskein256-"));
 173         utoa(outsize_b, str, 10);
 174         cli_putstr(str);
 175         cli_putstr_P(PSTR(" :"));
 176         cli_hexdump_block(hash, (outsize_b+7)/8, 4, 16);
 177
 178         skein512(hash, outsize_b, NULL, 0);
 179         cli_putstr_P(PSTR("\r\nskein512-"));
 180         utoa(outsize_b, str, 10);
 181         cli_putstr(str);
 182         cli_putstr_P(PSTR(" :"));
 183         cli_hexdump_block(hash, (outsize_b+7)/8, 4, 16);
 184
 185         skein1024(hash, outsize_b, NULL, 0);
 186         cli_putstr_P(PSTR("\r\nskein1024-"));
 187         utoa(outsize_b, str, 10);
 188         cli_putstr(str);
 189         cli_putstr_P(PSTR(" :"));
 190         cli_hexdump_block(hash, (outsize_b+7)/8, 4, 16);
 191 }
 192
 193 void zeromsg_test_common(char* p){
 194         uint8_t i;
 195         uint16_t s=0;
 196         uint16_t sizes[]={128, 160, 224, 256, 384, 512, 1024};
 197         if(p){
 198                 s = strtoul(p, NULL, 0);
 199         }
 200         if(s){
 201                 zeromsg_test_skein(s);
 202         }else{
 203                 for(i=0; i<7; ++i)
 204                         zeromsg_test_skein(sizes[i]);
 205         }
 206 }
 207
 208 void performance_skein(void){
 209         hfal_performance_multiple(algolist);
 210 }
 211
 212 void testrun_nessie_skein(void){
 213         nessie_hash_quick = 1;
 214         hfal_nessie_multiple(algolist);
 215 }
 216
 217 void test_monte2(void){
 218         uint8_t data[] = {
 219         0x6c, 0xd4, 0xc0, 0xc5, 0xcb, 0x2c, 0xa2, 0xa0,
 220         0xf1, 0xd1, 0xae, 0xce, 0xba, 0xc0, 0x3b, 0x52,
 221         0xe6, 0x4e, 0xa0, 0x3d, 0x1a, 0x16, 0x54, 0x37,
 222         0x29, 0x36, 0x54, 0x5b, 0x92, 0xbb, 0xc5, 0x48,
 223         0x4a, 0x59, 0xdb, 0x74, 0xbb, 0x60, 0xf9, 0xc4,
 224         0x0c, 0xeb, 0x1a, 0x5a, 0xa3, 0x5a, 0x6f, 0xaf,
 225         0xe8, 0x03, 0x49, 0xe1, 0x4c, 0x25, 0x3a, 0x4e,
 226         0x8b, 0x1d, 0x77, 0x61, 0x2d, 0xdd, 0x81, 0xac,
 227         0xe9, 0x26, 0xae, 0x8b, 0x0a, 0xf6, 0xe5, 0x31,
 228         0x76, 0xdb, 0xff, 0xcc, 0x2a, 0x6b, 0x88, 0xc6,
 229         0xbd, 0x76, 0x5f, 0x93, 0x9d, 0x3d, 0x17, 0x8a,
 230         0x9b, 0xde, 0x9e, 0xf3, 0xaa, 0x13, 0x1c, 0x61,
 231         0xe3, 0x1c, 0x1e, 0x42, 0xcd, 0xfa, 0xf4, 0xb4,
 232         0xdc, 0xde, 0x57, 0x9a, 0x37, 0xe1, 0x50, 0xef,
 233         0xbe, 0xf5, 0x55, 0x5b, 0x4c, 0x1c, 0xb4, 0x04,
 234         0x39, 0xd8, 0x35, 0xa7, 0x24, 0xe2, 0xfa, 0xe7 };
 235
 236    uint8_t hash[256/8];
 237    skein256(hash, 256, data, 1024);
 238    cli_putstr_P(PSTR("\r\n hash(data) = "));
 239    cli_hexdump(hash, 32);
 240    hfal_hash_mem(&skein256_256_desc,hash, data, 1024);
 241    cli_putstr_P(PSTR("\r\n hash(data) = "));
 242    cli_hexdump(hash, 32);
 243 }
 244
 245 /*****************************************************************************
 246  *  main                                                                                                                                         *
 247  *****************************************************************************/
 248
 249
 250 const char nessie_str[]      PROGMEM = "nessie";
 251 const char test_str[]        PROGMEM = "test";
 252 const char ztest_str[]       PROGMEM = "zerotest";
 253 const char performance_str[] PROGMEM = "performance";
 254 const char echo_str[]        PROGMEM = "echo";
 255 const char monte2_str[]      PROGMEM = "monte2";
 256 const char shavs_list_str[]  PROGMEM = "shavs_list";
 257 const char shavs_set_str[]   PROGMEM = "shavs_set";
 258 const char shavs_test1_str[] PROGMEM = "shavs_test1";
 259 const char shavs_test2_str[] PROGMEM = "shavs_test2";
 260 const char shavs_test3_str[] PROGMEM = "shavs_test3";
 261
 262 cmdlist_entry_t cmdlist[] PROGMEM = {
 263         { nessie_str,          NULL, testrun_nessie_skein            },
 264         { performance_str,     NULL, performance_skein               },
 265         { test_str,            NULL, testrun_stdtest_skein           },
 266         { ztest_str,       (void*)1, (void_fpt)zeromsg_test_common   },
 267         { shavs_list_str,      NULL, shavs_listalgos                 },
 268         { shavs_set_str,   (void*)1, (void_fpt)shavs_setalgo         },
 269         { monte2_str,          NULL, test_monte2                     },
 270         { shavs_test1_str,     NULL, shavs_test1                     },
 271         { shavs_test2_str,     NULL, shavs_test2                     },
 272         { shavs_test3_str,     NULL, shavs_test3                     },
 273         { echo_str,        (void*)1, (void_fpt)echo_ctrl             },
 274         { NULL,                NULL, NULL                            }
 275 };
 276
 277 int main (void){
 278         DEBUG_INIT();
 279
 280         cli_rx = (cli_rx_fpt)uart0_getc;
 281         cli_tx = (cli_tx_fpt)uart0_putc;
 282         shavs_algolist=(hfdesc_t**)algolist;
 283         shavs_algo=(hfdesc_t*)&skein256_256_desc;
 284         for(;;){
 285                 cli_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
 286                 cli_putstr(algo_name);
 287                 cli_putstr_P(PSTR("; "));
 288                 cli_putstr(__DATE__);
 289                 cli_putstr_P(PSTR(" "));
 290                 cli_putstr(__TIME__);
 291                 cli_putstr_P(PSTR(")\r\nloaded and running\r\n"));
 292
 293                 cmd_interface(cmdlist);
 294         }
 295 }