test_src/main-sha1-test.c

   1 /* main-sha1-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  * SHA-1 test-suit
  21  *
  22 */
  23
  24 #include "config.h"
  25
  26 #include "uart_i.h"
  27 #include "debug.h"
  28
  29 #include "sha1.h"
  30 #include "nessie_hash_test.h"
  31 #include "hfal/hfal_sha1.h"
  32 #include "hfal/hfal-performance.h"
  33
  34 #include <stdint.h>
  35 #include <string.h>
  36 #include <stdlib.h>
  37 #include "cli.h"
  38 #include "shavs.h"
  39 #include "hfal/hfal_sha1.h"
  40 #include "dump.h"
  41
  42 char* algo_name = "SHA-1";
  43
  44 const hfdesc_t* algolist[] PROGMEM = {
  45         (hfdesc_t*)&sha1_desc,
  46         NULL
  47 };
  48 /*****************************************************************************
  49  *  additional validation-functions                                                                                      *
  50  *****************************************************************************/
  51
  52 void testrun_nessie_sha1(void){
  53         nessie_hash_ctx.hashsize_b  = 160;
  54         nessie_hash_ctx.blocksize_B = 512/8;
  55         nessie_hash_ctx.ctx_size_B  = sizeof(sha1_ctx_t);
  56         nessie_hash_ctx.name = algo_name;
  57         nessie_hash_ctx.hash_init = (nessie_hash_init_fpt)sha1_init;
  58         nessie_hash_ctx.hash_next = (nessie_hash_next_fpt)sha1_nextBlock;
  59         nessie_hash_ctx.hash_last = (nessie_hash_last_fpt)sha1_lastBlock;
  60         nessie_hash_ctx.hash_conv = (nessie_hash_conv_fpt)sha1_ctx2hash;
  61
  62         nessie_hash_run();
  63 }
  64
  65 /*****************************************************************************
  66  *  self tests                                                                                                                           *
  67  *****************************************************************************/
  68
  69 void sha1_ctx_dump(sha1_ctx_t *s){
  70         uint8_t i;
  71         cli_putstr("\r\n==== sha1_ctx_dump ====");
  72         for(i=0;i<5;++i){
  73                 cli_putstr("\r\na["); cli_hexdump(&i, 1); cli_putstr("]: ");
  74                 cli_hexdump(&(s->h[i]), 4);
  75         }
  76         cli_putstr("\r\nlength"); cli_hexdump(&i, 8);
  77 }
  78
  79 void testrun_sha1(void){
  80         sha1_hash_t hash;
  81         sha1(&hash,"abc",3*8);
  82         cli_putstr_P(PSTR("\r\nsha1(\"abc\") = \r\n\t"));
  83         cli_hexdump(hash,SHA1_HASH_BITS/8);
  84
  85         sha1(&hash,"\0\0\0\0\0\0\0\0", 8*8);
  86         cli_putstr_P(PSTR("\r\nsha1(8 x 0x00) = \r\n\t"));
  87         cli_hexdump(hash,SHA1_HASH_BITS/8);
  88 /*
  89    Len = 496
  90    Msg = 46fe5ed326c8fe376fcc92dc9e2714e2240d3253b105ad
  91          fbb256ff7a19bc40975c604ad7c0071c4fd78a7cb64786
  92          e1bece548fa4833c04065fe593f6fb10
  93    MD  = f220a7457f4588d639dc21407c942e9843f8e26b
  94 */
  95         sha1(&hash,"\x46\xfe\x5e\xd3\x26\xc8\xfe\x37"
  96                    "\x6f\xcc\x92\xdc\x9e\x27\x14\xe2"
  97                    "\x24\x0d\x32\x53\xb1\x05\xad\xfb"
  98                    "\xb2\x56\xff\x7a\x19\xbc\x40\x97"
  99                    "\x5c\x60\x4a\xd7\xc0\x07\x1c\x4f"
 100                    "\xd7\x8a\x7c\xb6\x47\x86\xe1\xbe"
 101                    "\xce\x54\x8f\xa4\x83\x3c\x04\x06"
 102                    "\x5f\xe5\x93\xf6\xfb\x10", 496);
 103         cli_putstr_P(PSTR("\r\nsha1(tv_496) = \r\n\t"));
 104         cli_hexdump(hash,SHA1_HASH_BITS/8);
 105
 106         sha1(&hash,"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",448);
 107 //      cli_putstr_P(PSTR("\r\nsha1(\"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\") = \r\n\t"));
 108         cli_hexdump(hash,SHA1_HASH_BITS/8);
 109         cli_putstr("\r\nsha1(1,000,000 * 'a') = \r\n\t");
 110         {
 111                 uint8_t block[SHA1_BLOCK_BITS/8];
 112                 uint16_t i;
 113                 sha1_ctx_t s;
 114                 memset(block,'a',SHA1_BLOCK_BITS/8);
 115                 sha1_init(&s);
 116                 for(i=0;i<15625; ++i){ /* (1000000/(SHA1_BLOCK_BITS/8)) */
 117                         sha1_nextBlock(&s, block);
 118                 }
 119                 sha1_lastBlock(&s,block,0);
 120                 sha1_ctx2hash(&hash, &s);
 121         }
 122         cli_hexdump(hash,SHA1_HASH_BITS/8);
 123
 124 }
 125
 126
 127 void testrun_sha1_2(void){
 128         sha1_ctx_t ctx;
 129         sha1_hash_t hash;
 130         sha1(&hash,"",0);
 131         cli_putstr_P(PSTR("\r\nsha1(NULL) = \r\n\t"));
 132         cli_hexdump(hash,SHA1_HASH_BYTES);
 133
 134         memset(hash, 0, SHA1_HASH_BYTES);
 135
 136         sha1_init(&ctx);
 137         sha1_lastBlock(&ctx, "", 0);
 138         sha1_ctx2hash(&hash, &ctx);
 139         cli_putstr_P(PSTR("\r\nsha1(NULL) = \r\n\t"));
 140         cli_hexdump(hash,SHA1_HASH_BYTES);
 141 }
 142
 143 /*
 144 Msg = a38b899cae4edb191d88d861c842b6e32b9b67db66bdbdde8911d2b30fafa765a8190b963c28bf162c46d7b5dbde63556d114f43ceab88c7f65560f96c0c34c0
 145 MD = 722246b014af03ef3ba31364fc732a4ab8f38587
 146 */
 147
 148 void testrun_sha1_506(void){
 149         uint8_t data[] = {
 150                 0xa3, 0x8b, 0x89, 0x9c, 0xae, 0x4e, 0xdb, 0x19,
 151                 0x1d, 0x88, 0xd8, 0x61, 0xc8, 0x42, 0xb6, 0xe3,
 152                 0x2b, 0x9b, 0x67, 0xdb, 0x66, 0xbd, 0xbd, 0xde,
 153                 0x89, 0x11, 0xd2, 0xb3, 0x0f, 0xaf, 0xa7, 0x65,
 154                 0xa8, 0x19, 0x0b, 0x96, 0x3c, 0x28, 0xbf, 0x16,
 155                 0x2c, 0x46, 0xd7, 0xb5, 0xdb, 0xde, 0x63, 0x55,
 156                 0x6d, 0x11, 0x4f, 0x43, 0xce, 0xab, 0x88, 0xc7,
 157                 0xf6, 0x55, 0x60, 0xf9, 0x6c, 0x0c, 0x34, 0xc0 };
 158         uint8_t ref[] = {
 159                 0x72, 0x22, 0x46, 0xb0, 0x14, 0xaf, 0x03, 0xef,
 160                 0x3b, 0xa3, 0x13, 0x64, 0xfc, 0x73, 0x2a, 0x4a,
 161                 0xb8, 0xf3, 0x85, 0x87 };
 162         sha1_hash_t hash;
 163         sha1(&hash,data,506);
 164         cli_putstr_P(PSTR("\r\nsha1(<tv506>) = \r\n\t"));
 165         cli_hexdump(hash,SHA1_HASH_BYTES);
 166         cli_putstr_P(PSTR("\r\nshould        = \r\n\t"));
 167         cli_hexdump(ref,SHA1_HASH_BYTES);
 168         if(memcmp(ref, hash, SHA1_HASH_BYTES)==0){
 169                 cli_putstr_P(PSTR("\r\n[ok]"));
 170         } else {
 171                 cli_putstr_P(PSTR("\r\n[fail]"));
 172         }
 173 }
 174
 175 void testrun_performance_sha1(void){
 176         hfal_performance_multiple(algolist);
 177 }
 178
 179
 180 /*****************************************************************************
 181  *  main                                                                                                                                         *
 182  *****************************************************************************/
 183
 184 const char nessie_str[]      PROGMEM = "nessie";
 185 const char test_str[]        PROGMEM = "test";
 186 const char test2_str[]       PROGMEM = "test2";
 187 const char test506_str[]     PROGMEM = "test506";
 188 const char performance_str[] PROGMEM = "performance";
 189 const char echo_str[]        PROGMEM = "echo";
 190 const char shavs_list_str[]  PROGMEM = "shavs_list";
 191 const char shavs_set_str[]   PROGMEM = "shavs_set";
 192 const char shavs_test1_str[] PROGMEM = "shavs_test1";
 193 const char shavs_test2_str[] PROGMEM = "shavs_test2";
 194 const char dump_str[]        PROGMEM = "dump";
 195
 196
 197 cmdlist_entry_t cmdlist[] PROGMEM = {
 198         { nessie_str,          NULL, testrun_nessie_sha1},
 199         { test_str,            NULL, testrun_sha1},
 200         { test2_str,           NULL, testrun_sha1_2},
 201         { test506_str,         NULL, testrun_sha1_506},
 202         { performance_str,     NULL, testrun_performance_sha1},
 203         { echo_str,        (void*)1, (void_fpt)echo_ctrl},
 204         { shavs_list_str,      NULL, shavs_listalgos},
 205         { shavs_set_str,   (void*)1, (void_fpt)shavs_setalgo},
 206         { shavs_test1_str,     NULL, shavs_test1},
 207         { shavs_test2_str,     NULL, shavs_test2},
 208         { dump_str,        (void*)1, (void_fpt)dump},
 209         { NULL,                NULL, NULL}
 210 };
 211
 212 int main (void){
 213         DEBUG_INIT();
 214
 215         cli_rx = (cli_rx_fpt)uart0_getc;
 216         cli_tx = (cli_tx_fpt)uart0_putc;
 217         shavs_algolist=(hfdesc_t**)algolist;
 218         shavs_algo=(hfdesc_t*)&sha1_desc;
 219         for(;;){
 220                 cli_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
 221                 cli_putstr(algo_name);
 222                 cli_putstr_P(PSTR(")\r\nloaded and running\r\n"));
 223                 cmd_interface(cmdlist);
 224         }
 225 }