test_src/main-skein-test.c

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