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