test_src/main-sha2-test.c

   1 /* main-sha512-test.c */
   2 /*
   3     This file is part of the ARM-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-512 test-suit
  21  *
  22 */
  23
  24 #include "main-test-common.h"
  25 #include <avr/pgmspace.h>
  26 #include "shavs.h"
  27 #include "nessie_hash_test.h"
  28 #include "performance_test.h"
  29 #include "hfal-nessie.h"
  30 #include "hfal-performance.h"
  31 #include "hfal-test.h"
  32
  33
  34 #include "sha224.h"
  35 #include "hfal_sha224.h"
  36 #include "sha256.h"
  37 #include "hfal_sha256.h"
  38 #include "sha384.h"
  39 #include "hfal_sha384.h"
  40 #include "sha512.h"
  41 #include "hfal_sha512.h"
  42
  43 const char *algo_name = "SHA-2";
  44
  45 const hfdesc_t *const algolist[] PROGMEM = {
  46         (hfdesc_t*)&sha224_desc,
  47         (hfdesc_t*)&sha256_desc,
  48         (hfdesc_t*)&sha384_desc,
  49         (hfdesc_t*)&sha512_desc,
  50         NULL
  51 };
  52
  53 /*****************************************************************************
  54  *  additional validation-functions                                                                                      *
  55  *****************************************************************************/
  56
  57 void testrun_nessie_sha2(void){
  58         hfal_nessie_multiple(algolist);
  59 }
  60
  61 void testrun_performance_sha2(void){
  62         hfal_performance_multiple(algolist);
  63 }
  64
  65 void simple_test(void){
  66         const char *msg = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
  67                                   "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu";
  68
  69         uint8_t hash[64];
  70         sha512_ctx_t ctx;
  71         cli_putstr_P(PSTR("\r\nDBG: init ..."));
  72         sha512_init(&ctx);
  73         cli_putstr_P(PSTR("\r\nDBG: init done"));
  74         sha512_lastBlock(&ctx, msg, 3*8);
  75         cli_putstr_P(PSTR("\r\nDBG: lastBlock done"));
  76         sha512_ctx2hash(hash, &ctx);
  77         cli_putstr_P(PSTR("\r\n hash = "));
  78         cli_hexdump(hash, 64);
  79
  80
  81         cli_putstr_P(PSTR("\r\nDBG: init ..."));
  82         sha512_init(&ctx);
  83         cli_putstr_P(PSTR("\r\nDBG: init done"));
  84         sha512_lastBlock(&ctx, msg, 896);
  85         cli_putstr_P(PSTR("\r\nDBG: lastBlock done"));
  86         sha512_ctx2hash(hash, &ctx);
  87         cli_putstr_P(PSTR("\r\n hash = "));
  88         cli_hexdump(hash, 64);
  89
  90         uint32_t c=0;
  91         uint8_t buffer[128];
  92         memset(buffer, 'a', 128);
  93         cli_putstr_P(PSTR("\r\nDBG: init ..."));
  94         sha512_init(&ctx);
  95         cli_putstr_P(PSTR("\r\nDBG: init done"));
  96         do{
  97                 sha512_nextBlock(&ctx, buffer);
  98                 c += 128;
  99         }while(c+128<1000000L);
 100         sha512_lastBlock(&ctx, buffer, (1000000-c)*8);
 101         cli_putstr_P(PSTR("\r\nDBG: lastBlock done"));
 102         sha512_ctx2hash(hash, &ctx);
 103         cli_putstr_P(PSTR("\r\n hash = "));
 104         cli_hexdump(hash, 64);
 105
 106
 107 }
 108
 109 /*
 110 void test_monte(void){
 111         uint8_t data1[] = {
 112      0xF4, 0x1E, 0xCE, 0x26, 0x13, 0xE4, 0x57, 0x39,
 113      0x15, 0x69, 0x6B, 0x5A, 0xDC, 0xD5, 0x1C, 0xA3,
 114          0x28, 0xBE, 0x3B, 0xF5, 0x66, 0xA9, 0xCA, 0x99,
 115          0xC9, 0xCE, 0xB0, 0x27, 0x9C, 0x1C, 0xB0, 0xA7,
 116      0xF4, 0x1E, 0xCE, 0x26, 0x13, 0xE4, 0x57, 0x39,
 117      0x15, 0x69, 0x6B, 0x5A, 0xDC, 0xD5, 0x1C, 0xA3,
 118          0x28, 0xBE, 0x3B, 0xF5, 0x66, 0xA9, 0xCA, 0x99,
 119          0xC9, 0xCE, 0xB0, 0x27, 0x9C, 0x1C, 0xB0, 0xA7,
 120      0xF4, 0x1E, 0xCE, 0x26, 0x13, 0xE4, 0x57, 0x39,
 121      0x15, 0x69, 0x6B, 0x5A, 0xDC, 0xD5, 0x1C, 0xA3,
 122          0x28, 0xBE, 0x3B, 0xF5, 0x66, 0xA9, 0xCA, 0x99,
 123          0xC9, 0xCE, 0xB0, 0x27, 0x9C, 0x1C, 0xB0, 0xA7 };
 124
 125    uint8_t data2[] = {
 126      0xF4, 0x1E, 0xCE, 0x26, 0x13, 0xE4, 0x57, 0x39,
 127      0x15, 0x69, 0x6B, 0x5A, 0xDC, 0xD5, 0x1C, 0xA3,
 128          0x28, 0xBE, 0x3B, 0xF5, 0x66, 0xA9, 0xCA, 0x99,
 129          0xC9, 0xCE, 0xB0, 0x27, 0x9C, 0x1C, 0xB0, 0xA7,
 130      0xF4, 0x1E, 0xCE, 0x26, 0x13, 0xE4, 0x57, 0x39,
 131      0x15, 0x69, 0x6B, 0x5A, 0xDC, 0xD5, 0x1C, 0xA3,
 132          0x28, 0xBE, 0x3B, 0xF5, 0x66, 0xA9, 0xCA, 0x99,
 133          0xC9, 0xCE, 0xB0, 0x27, 0x9C, 0x1C, 0xB0, 0xA7,
 134      0xFD, 0xDF, 0x1B, 0x37, 0xDD, 0x34, 0xB3, 0xB2,
 135      0x01, 0xD4, 0x3C, 0x57, 0xBC, 0xDE, 0x11, 0x58,
 136      0x38, 0xF0, 0xDF, 0x70, 0x1D, 0xA9, 0x3C, 0x3B,
 137      0xF2, 0xC9, 0xC8, 0x68, 0x96, 0xE7, 0xE6, 0xC7 };
 138    uint8_t hash[SHA256_HASH_BYTES];
 139    sha256((sha256_hash_t*)hash, data1, 3*32*8);
 140    cli_putstr_P(PSTR("\r\n hash(data1) = "));
 141    cli_hexdump(hash, 32);
 142    sha256((sha256_hash_t*)hash, data2, 3*32*8);
 143    cli_putstr_P(PSTR("\r\n hash(data2) = "));
 144    cli_hexdump(hash, 32);
 145 }
 146
 147 void test_monte2(void){
 148         uint8_t data[] = {
 149         0x6c, 0xd4, 0xc0, 0xc5, 0xcb, 0x2c, 0xa2, 0xa0,
 150         0xf1, 0xd1, 0xae, 0xce, 0xba, 0xc0, 0x3b, 0x52,
 151         0xe6, 0x4e, 0xa0, 0x3d, 0x1a, 0x16, 0x54, 0x37,
 152         0x29, 0x36, 0x54, 0x5b, 0x92, 0xbb, 0xc5, 0x48,
 153         0x4a, 0x59, 0xdb, 0x74, 0xbb, 0x60, 0xf9, 0xc4,
 154         0x0c, 0xeb, 0x1a, 0x5a, 0xa3, 0x5a, 0x6f, 0xaf,
 155         0xe8, 0x03, 0x49, 0xe1, 0x4c, 0x25, 0x3a, 0x4e,
 156         0x8b, 0x1d, 0x77, 0x61, 0x2d, 0xdd, 0x81, 0xac,
 157         0xe9, 0x26, 0xae, 0x8b, 0x0a, 0xf6, 0xe5, 0x31,
 158         0x76, 0xdb, 0xff, 0xcc, 0x2a, 0x6b, 0x88, 0xc6,
 159         0xbd, 0x76, 0x5f, 0x93, 0x9d, 0x3d, 0x17, 0x8a,
 160         0x9b, 0xde, 0x9e, 0xf3, 0xaa, 0x13, 0x1c, 0x61,
 161         0xe3, 0x1c, 0x1e, 0x42, 0xcd, 0xfa, 0xf4, 0xb4,
 162         0xdc, 0xde, 0x57, 0x9a, 0x37, 0xe1, 0x50, 0xef,
 163         0xbe, 0xf5, 0x55, 0x5b, 0x4c, 0x1c, 0xb4, 0x04,
 164         0x39, 0xd8, 0x35, 0xa7, 0x24, 0xe2, 0xfa, 0xe7 };
 165
 166    uint8_t hash[SHA256_HASH_BYTES];
 167    sha256((sha256_hash_t*)hash, data, 1024);
 168    cli_putstr_P(PSTR("\r\n hash(data) = "));
 169    cli_hexdump(hash, 32);
 170 }
 171 */
 172 /*****************************************************************************
 173  *  main                                                                                                                                         *
 174  *****************************************************************************/
 175
 176 const char nessie_str[]      PROGMEM = "nessie";
 177 const char test_str[]        PROGMEM = "test";
 178 //const char monte_str[]     PROGMEM   = "monte";
 179 //const char monte2_str[]    PROGMEM   = "monte2";
 180 const char performance_str[] PROGMEM = "performance";
 181 const char echo_str[]        PROGMEM = "echo";
 182 const char shavs_list_str[]  PROGMEM = "shavs_list";
 183 const char shavs_set_str[]   PROGMEM = "shavs_set";
 184 const char shavs_test1_str[] PROGMEM = "shavs_test1";
 185 const char shavs_test2_str[] PROGMEM = "shavs_test2";
 186 const char shavs_test3_str[] PROGMEM = "shavs_test3";
 187
 188 const cmdlist_entry_t cmdlist[] PROGMEM = {
 189         { nessie_str,          NULL, testrun_nessie_sha2          },
 190         { test_str,            NULL, simple_test                    },
 191 //      { monte_str,           NULL, test_monte                     },
 192 //      { monte2_str,          NULL, test_monte2                    },
 193         { performance_str,     NULL, testrun_performance_sha2     },
 194         { echo_str,        (void*)1, (void_fpt)echo_ctrl            },
 195         { shavs_list_str,      NULL, shavs_listalgos                },
 196         { shavs_set_str,   (void*)1, (void_fpt)shavs_setalgo        },
 197         { shavs_test1_str,     NULL, shavs_test1                    },
 198         { shavs_test2_str,     NULL, shavs_test2                    },
 199         { shavs_test3_str,     NULL, shavs_test3                    },
 200         { NULL,                NULL, NULL                           }
 201 };
 202
 203 int main(void) {
 204         main_setup();
 205
 206         shavs_algolist=(hfdesc_t**)algolist;
 207         shavs_algo=(hfdesc_t*)&sha256_desc;
 208
 209         for(;;){
 210                 welcome_msg(algo_name);
 211                 cmd_interface(cmdlist);
 212     }
 213
 214 }