test_src/main-sha1-test.c

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