| 1 |
/************************** shatest.c **************************/ |
| 2 |
/***************** See RFC 6234 for details. *******************/ |
| 3 |
/* Copyright (c) 2011 IETF Trust and the persons identified as */ |
| 4 |
/* authors of the code. All rights reserved. */ |
| 5 |
/* See sha.h for terms of use and redistribution. */ |
| 6 |
/* */ |
| 7 |
/* SPDX-License-Identifier: BSD-3-Clause */ |
| 8 |
|
| 9 |
/* |
| 10 |
* Description: |
| 11 |
* This file will exercise the SHA code performing |
| 12 |
* the three tests documented in FIPS PUB 180-3 |
| 13 |
* (http://csrc.nist.gov/publications/fips/ |
| 14 |
* fips180-2/fips180-2withchangenotice.pdf) |
| 15 |
* one that calls SHAInput with an exact multiple of 512 bits |
| 16 |
* the seven tests documented for each algorithm in |
| 17 |
* "The Secure Hash Algorithm Validation System (SHAVS)" |
| 18 |
* (http://csrc.nist.gov/cryptval/shs/SHAVS.pdf), |
| 19 |
* three of which are bit-level tests |
| 20 |
* |
| 21 |
* These tests have subsequently been moved to pages linked from |
| 22 |
* http://csrc.nist.gov/groups/ST/toolkit/examples.html |
| 23 |
* |
| 24 |
* This file will exercise the HMAC SHA1 code performing |
| 25 |
* the seven tests documented in RFCs [RFC 2202] and [RFC 4231]. |
| 26 |
* |
| 27 |
* This file will exercise the HKDF code performing |
| 28 |
* the seven tests documented in RFC 4869. |
| 29 |
* |
| 30 |
* To run the tests and just see PASSED/FAILED, use the -p option. |
| 31 |
* |
| 32 |
* Other options exercise: |
| 33 |
* hashing an arbitrary string |
| 34 |
* hashing a file's contents |
| 35 |
* a few error test checks |
| 36 |
* printing the results in raw format |
| 37 |
* |
| 38 |
* Portability Issues: |
| 39 |
* None. |
| 40 |
* |
| 41 |
*/ |
| 42 |
|
| 43 |
#include <stdint.h> |
| 44 |
#include <stdio.h> |
| 45 |
#include <stdlib.h> |
| 46 |
#include <string.h> |
| 47 |
#include <ctype.h> |
| 48 |
#include <unistd.h> /* defines getopt() and optarg */ |
| 49 |
#include "sha.h" |
| 50 |
|
| 51 |
static int scasecmp(const char *s1, const char *s2); |
| 52 |
|
| 53 |
/* |
| 54 |
* Define patterns for testing |
| 55 |
*/ |
| 56 |
#define TEST1 "abc" |
| 57 |
#define TEST2_1 \ |
| 58 |
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" |
| 59 |
#define TEST2_2a \ |
| 60 |
"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn" |
| 61 |
#define TEST2_2b \ |
| 62 |
"hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu" |
| 63 |
#define TEST2_2 TEST2_2a TEST2_2b |
| 64 |
#define TEST3 "a" /* times 1000000 */ |
| 65 |
#define TEST4a "01234567012345670123456701234567" |
| 66 |
#define TEST4b "01234567012345670123456701234567" |
| 67 |
/* an exact multiple of 512 bits */ |
| 68 |
#define TEST4 TEST4a TEST4b /* times 10 */ |
| 69 |
#define TEST7_1 \ |
| 70 |
"\x49\xb2\xae\xc2\x59\x4b\xbe\x3a\x3b\x11\x75\x42\xd9\x4a\xc8" |
| 71 |
#define TEST8_1 \ |
| 72 |
"\x9a\x7d\xfd\xf1\xec\xea\xd0\x6e\xd6\x46\xaa\x55\xfe\x75\x71\x46" |
| 73 |
#define TEST9_1 \ |
| 74 |
"\x65\xf9\x32\x99\x5b\xa4\xce\x2c\xb1\xb4\xa2\xe7\x1a\xe7\x02\x20" \ |
| 75 |
"\xaa\xce\xc8\x96\x2d\xd4\x49\x9c\xbd\x7c\x88\x7a\x94\xea\xaa\x10" \ |
| 76 |
"\x1e\xa5\xaa\xbc\x52\x9b\x4e\x7e\x43\x66\x5a\x5a\xf2\xcd\x03\xfe" \ |
| 77 |
"\x67\x8e\xa6\xa5\x00\x5b\xba\x3b\x08\x22\x04\xc2\x8b\x91\x09\xf4" \ |
| 78 |
"\x69\xda\xc9\x2a\xaa\xb3\xaa\x7c\x11\xa1\xb3\x2a" |
| 79 |
#define TEST10_1 \ |
| 80 |
"\xf7\x8f\x92\x14\x1b\xcd\x17\x0a\xe8\x9b\x4f\xba\x15\xa1\xd5\x9f" \ |
| 81 |
"\x3f\xd8\x4d\x22\x3c\x92\x51\xbd\xac\xbb\xae\x61\xd0\x5e\xd1\x15" \ |
| 82 |
"\xa0\x6a\x7c\xe1\x17\xb7\xbe\xea\xd2\x44\x21\xde\xd9\xc3\x25\x92" \ |
| 83 |
"\xbd\x57\xed\xea\xe3\x9c\x39\xfa\x1f\xe8\x94\x6a\x84\xd0\xcf\x1f" \ |
| 84 |
"\x7b\xee\xad\x17\x13\xe2\xe0\x95\x98\x97\x34\x7f\x67\xc8\x0b\x04" \ |
| 85 |
"\x00\xc2\x09\x81\x5d\x6b\x10\xa6\x83\x83\x6f\xd5\x56\x2a\x56\xca" \ |
| 86 |
"\xb1\xa2\x8e\x81\xb6\x57\x66\x54\x63\x1c\xf1\x65\x66\xb8\x6e\x3b" \ |
| 87 |
"\x33\xa1\x08\xb0\x53\x07\xc0\x0a\xff\x14\xa7\x68\xed\x73\x50\x60" \ |
| 88 |
"\x6a\x0f\x85\xe6\xa9\x1d\x39\x6f\x5b\x5c\xbe\x57\x7f\x9b\x38\x80" \ |
| 89 |
"\x7c\x7d\x52\x3d\x6d\x79\x2f\x6e\xbc\x24\xa4\xec\xf2\xb3\xa4\x27" \ |
| 90 |
"\xcd\xbb\xfb" |
| 91 |
#define TEST7_224 \ |
| 92 |
"\xf0\x70\x06\xf2\x5a\x0b\xea\x68\xcd\x76\xa2\x95\x87\xc2\x8d" |
| 93 |
#define TEST8_224 \ |
| 94 |
"\x18\x80\x40\x05\xdd\x4f\xbd\x15\x56\x29\x9d\x6f\x9d\x93\xdf\x62" |
| 95 |
#define TEST9_224 \ |
| 96 |
"\xa2\xbe\x6e\x46\x32\x81\x09\x02\x94\xd9\xce\x94\x82\x65\x69\x42" \ |
| 97 |
"\x3a\x3a\x30\x5e\xd5\xe2\x11\x6c\xd4\xa4\xc9\x87\xfc\x06\x57\x00" \ |
| 98 |
"\x64\x91\xb1\x49\xcc\xd4\xb5\x11\x30\xac\x62\xb1\x9d\xc2\x48\xc7" \ |
| 99 |
"\x44\x54\x3d\x20\xcd\x39\x52\xdc\xed\x1f\x06\xcc\x3b\x18\xb9\x1f" \ |
| 100 |
"\x3f\x55\x63\x3e\xcc\x30\x85\xf4\x90\x70\x60\xd2" |
| 101 |
#define TEST10_224 \ |
| 102 |
"\x55\xb2\x10\x07\x9c\x61\xb5\x3a\xdd\x52\x06\x22\xd1\xac\x97\xd5" \ |
| 103 |
"\xcd\xbe\x8c\xb3\x3a\xa0\xae\x34\x45\x17\xbe\xe4\xd7\xba\x09\xab" \ |
| 104 |
"\xc8\x53\x3c\x52\x50\x88\x7a\x43\xbe\xbb\xac\x90\x6c\x2e\x18\x37" \ |
| 105 |
"\xf2\x6b\x36\xa5\x9a\xe3\xbe\x78\x14\xd5\x06\x89\x6b\x71\x8b\x2a" \ |
| 106 |
"\x38\x3e\xcd\xac\x16\xb9\x61\x25\x55\x3f\x41\x6f\xf3\x2c\x66\x74" \ |
| 107 |
"\xc7\x45\x99\xa9\x00\x53\x86\xd9\xce\x11\x12\x24\x5f\x48\xee\x47" \ |
| 108 |
"\x0d\x39\x6c\x1e\xd6\x3b\x92\x67\x0c\xa5\x6e\xc8\x4d\xee\xa8\x14" \ |
| 109 |
"\xb6\x13\x5e\xca\x54\x39\x2b\xde\xdb\x94\x89\xbc\x9b\x87\x5a\x8b" \ |
| 110 |
"\xaf\x0d\xc1\xae\x78\x57\x36\x91\x4a\xb7\xda\xa2\x64\xbc\x07\x9d" \ |
| 111 |
"\x26\x9f\x2c\x0d\x7e\xdd\xd8\x10\xa4\x26\x14\x5a\x07\x76\xf6\x7c" \ |
| 112 |
"\x87\x82\x73" |
| 113 |
#define TEST7_256 \ |
| 114 |
"\xbe\x27\x46\xc6\xdb\x52\x76\x5f\xdb\x2f\x88\x70\x0f\x9a\x73" |
| 115 |
#define TEST8_256 \ |
| 116 |
"\xe3\xd7\x25\x70\xdc\xdd\x78\x7c\xe3\x88\x7a\xb2\xcd\x68\x46\x52" |
| 117 |
#define TEST9_256 \ |
| 118 |
"\x3e\x74\x03\x71\xc8\x10\xc2\xb9\x9f\xc0\x4e\x80\x49\x07\xef\x7c" \ |
| 119 |
"\xf2\x6b\xe2\x8b\x57\xcb\x58\xa3\xe2\xf3\xc0\x07\x16\x6e\x49\xc1" \ |
| 120 |
"\x2e\x9b\xa3\x4c\x01\x04\x06\x91\x29\xea\x76\x15\x64\x25\x45\x70" \ |
| 121 |
"\x3a\x2b\xd9\x01\xe1\x6e\xb0\xe0\x5d\xeb\xa0\x14\xeb\xff\x64\x06" \ |
| 122 |
"\xa0\x7d\x54\x36\x4e\xff\x74\x2d\xa7\x79\xb0\xb3" |
| 123 |
#define TEST10_256 \ |
| 124 |
"\x83\x26\x75\x4e\x22\x77\x37\x2f\x4f\xc1\x2b\x20\x52\x7a\xfe\xf0" \ |
| 125 |
"\x4d\x8a\x05\x69\x71\xb1\x1a\xd5\x71\x23\xa7\xc1\x37\x76\x00\x00" \ |
| 126 |
"\xd7\xbe\xf6\xf3\xc1\xf7\xa9\x08\x3a\xa3\x9d\x81\x0d\xb3\x10\x77" \ |
| 127 |
"\x7d\xab\x8b\x1e\x7f\x02\xb8\x4a\x26\xc7\x73\x32\x5f\x8b\x23\x74" \ |
| 128 |
"\xde\x7a\x4b\x5a\x58\xcb\x5c\x5c\xf3\x5b\xce\xe6\xfb\x94\x6e\x5b" \ |
| 129 |
"\xd6\x94\xfa\x59\x3a\x8b\xeb\x3f\x9d\x65\x92\xec\xed\xaa\x66\xca" \ |
| 130 |
"\x82\xa2\x9d\x0c\x51\xbc\xf9\x33\x62\x30\xe5\xd7\x84\xe4\xc0\xa4" \ |
| 131 |
"\x3f\x8d\x79\xa3\x0a\x16\x5c\xba\xbe\x45\x2b\x77\x4b\x9c\x71\x09" \ |
| 132 |
"\xa9\x7d\x13\x8f\x12\x92\x28\x96\x6f\x6c\x0a\xdc\x10\x6a\xad\x5a" \ |
| 133 |
"\x9f\xdd\x30\x82\x57\x69\xb2\xc6\x71\xaf\x67\x59\xdf\x28\xeb\x39" \ |
| 134 |
"\x3d\x54\xd6" |
| 135 |
#define TEST7_384 \ |
| 136 |
"\x8b\xc5\x00\xc7\x7c\xee\xd9\x87\x9d\xa9\x89\x10\x7c\xe0\xaa" |
| 137 |
#define TEST8_384 \ |
| 138 |
"\xa4\x1c\x49\x77\x79\xc0\x37\x5f\xf1\x0a\x7f\x4e\x08\x59\x17\x39" |
| 139 |
#define TEST9_384 \ |
| 140 |
"\x68\xf5\x01\x79\x2d\xea\x97\x96\x76\x70\x22\xd9\x3d\xa7\x16\x79" \ |
| 141 |
"\x30\x99\x20\xfa\x10\x12\xae\xa3\x57\xb2\xb1\x33\x1d\x40\xa1\xd0" \ |
| 142 |
"\x3c\x41\xc2\x40\xb3\xc9\xa7\x5b\x48\x92\xf4\xc0\x72\x4b\x68\xc8" \ |
| 143 |
"\x75\x32\x1a\xb8\xcf\xe5\x02\x3b\xd3\x75\xbc\x0f\x94\xbd\x89\xfe" \ |
| 144 |
"\x04\xf2\x97\x10\x5d\x7b\x82\xff\xc0\x02\x1a\xeb\x1c\xcb\x67\x4f" \ |
| 145 |
"\x52\x44\xea\x34\x97\xde\x26\xa4\x19\x1c\x5f\x62\xe5\xe9\xa2\xd8" \ |
| 146 |
"\x08\x2f\x05\x51\xf4\xa5\x30\x68\x26\xe9\x1c\xc0\x06\xce\x1b\xf6" \ |
| 147 |
"\x0f\xf7\x19\xd4\x2f\xa5\x21\xc8\x71\xcd\x23\x94\xd9\x6e\xf4\x46" \ |
| 148 |
"\x8f\x21\x96\x6b\x41\xf2\xba\x80\xc2\x6e\x83\xa9" |
| 149 |
#define TEST10_384 \ |
| 150 |
"\x39\x96\x69\xe2\x8f\x6b\x9c\x6d\xbc\xbb\x69\x12\xec\x10\xff\xcf" \ |
| 151 |
"\x74\x79\x03\x49\xb7\xdc\x8f\xbe\x4a\x8e\x7b\x3b\x56\x21\xdb\x0f" \ |
| 152 |
"\x3e\x7d\xc8\x7f\x82\x32\x64\xbb\xe4\x0d\x18\x11\xc9\xea\x20\x61" \ |
| 153 |
"\xe1\xc8\x4a\xd1\x0a\x23\xfa\xc1\x72\x7e\x72\x02\xfc\x3f\x50\x42" \ |
| 154 |
"\xe6\xbf\x58\xcb\xa8\xa2\x74\x6e\x1f\x64\xf9\xb9\xea\x35\x2c\x71" \ |
| 155 |
"\x15\x07\x05\x3c\xf4\xe5\x33\x9d\x52\x86\x5f\x25\xcc\x22\xb5\xe8" \ |
| 156 |
"\x77\x84\xa1\x2f\xc9\x61\xd6\x6c\xb6\xe8\x95\x73\x19\x9a\x2c\xe6" \ |
| 157 |
"\x56\x5c\xbd\xf1\x3d\xca\x40\x38\x32\xcf\xcb\x0e\x8b\x72\x11\xe8" \ |
| 158 |
"\x3a\xf3\x2a\x11\xac\x17\x92\x9f\xf1\xc0\x73\xa5\x1c\xc0\x27\xaa" \ |
| 159 |
"\xed\xef\xf8\x5a\xad\x7c\x2b\x7c\x5a\x80\x3e\x24\x04\xd9\x6d\x2a" \ |
| 160 |
"\x77\x35\x7b\xda\x1a\x6d\xae\xed\x17\x15\x1c\xb9\xbc\x51\x25\xa4" \ |
| 161 |
"\x22\xe9\x41\xde\x0c\xa0\xfc\x50\x11\xc2\x3e\xcf\xfe\xfd\xd0\x96" \ |
| 162 |
"\x76\x71\x1c\xf3\xdb\x0a\x34\x40\x72\x0e\x16\x15\xc1\xf2\x2f\xbc" \ |
| 163 |
"\x3c\x72\x1d\xe5\x21\xe1\xb9\x9b\xa1\xbd\x55\x77\x40\x86\x42\x14" \ |
| 164 |
"\x7e\xd0\x96" |
| 165 |
#define TEST7_512 \ |
| 166 |
"\x08\xec\xb5\x2e\xba\xe1\xf7\x42\x2d\xb6\x2b\xcd\x54\x26\x70" |
| 167 |
#define TEST8_512 \ |
| 168 |
"\x8d\x4e\x3c\x0e\x38\x89\x19\x14\x91\x81\x6e\x9d\x98\xbf\xf0\xa0" |
| 169 |
#define TEST9_512 \ |
| 170 |
"\x3a\xdd\xec\x85\x59\x32\x16\xd1\x61\x9a\xa0\x2d\x97\x56\x97\x0b" \ |
| 171 |
"\xfc\x70\xac\xe2\x74\x4f\x7c\x6b\x27\x88\x15\x10\x28\xf7\xb6\xa2" \ |
| 172 |
"\x55\x0f\xd7\x4a\x7e\x6e\x69\xc2\xc9\xb4\x5f\xc4\x54\x96\x6d\xc3" \ |
| 173 |
"\x1d\x2e\x10\xda\x1f\x95\xce\x02\xbe\xb4\xbf\x87\x65\x57\x4c\xbd" \ |
| 174 |
"\x6e\x83\x37\xef\x42\x0a\xdc\x98\xc1\x5c\xb6\xd5\xe4\xa0\x24\x1b" \ |
| 175 |
"\xa0\x04\x6d\x25\x0e\x51\x02\x31\xca\xc2\x04\x6c\x99\x16\x06\xab" \ |
| 176 |
"\x4e\xe4\x14\x5b\xee\x2f\xf4\xbb\x12\x3a\xab\x49\x8d\x9d\x44\x79" \ |
| 177 |
"\x4f\x99\xcc\xad\x89\xa9\xa1\x62\x12\x59\xed\xa7\x0a\x5b\x6d\xd4" \ |
| 178 |
"\xbd\xd8\x77\x78\xc9\x04\x3b\x93\x84\xf5\x49\x06" |
| 179 |
#define TEST10_512 \ |
| 180 |
"\xa5\x5f\x20\xc4\x11\xaa\xd1\x32\x80\x7a\x50\x2d\x65\x82\x4e\x31" \ |
| 181 |
"\xa2\x30\x54\x32\xaa\x3d\x06\xd3\xe2\x82\xa8\xd8\x4e\x0d\xe1\xde" \ |
| 182 |
"\x69\x74\xbf\x49\x54\x69\xfc\x7f\x33\x8f\x80\x54\xd5\x8c\x26\xc4" \ |
| 183 |
"\x93\x60\xc3\xe8\x7a\xf5\x65\x23\xac\xf6\xd8\x9d\x03\xe5\x6f\xf2" \ |
| 184 |
"\xf8\x68\x00\x2b\xc3\xe4\x31\xed\xc4\x4d\xf2\xf0\x22\x3d\x4b\xb3" \ |
| 185 |
"\xb2\x43\x58\x6e\x1a\x7d\x92\x49\x36\x69\x4f\xcb\xba\xf8\x8d\x95" \ |
| 186 |
"\x19\xe4\xeb\x50\xa6\x44\xf8\xe4\xf9\x5e\xb0\xea\x95\xbc\x44\x65" \ |
| 187 |
"\xc8\x82\x1a\xac\xd2\xfe\x15\xab\x49\x81\x16\x4b\xbb\x6d\xc3\x2f" \ |
| 188 |
"\x96\x90\x87\xa1\x45\xb0\xd9\xcc\x9c\x67\xc2\x2b\x76\x32\x99\x41" \ |
| 189 |
"\x9c\xc4\x12\x8b\xe9\xa0\x77\xb3\xac\xe6\x34\x06\x4e\x6d\x99\x28" \ |
| 190 |
"\x35\x13\xdc\x06\xe7\x51\x5d\x0d\x73\x13\x2e\x9a\x0d\xc6\xd3\xb1" \ |
| 191 |
"\xf8\xb2\x46\xf1\xa9\x8a\x3f\xc7\x29\x41\xb1\xe3\xbb\x20\x98\xe8" \ |
| 192 |
"\xbf\x16\xf2\x68\xd6\x4f\x0b\x0f\x47\x07\xfe\x1e\xa1\xa1\x79\x1b" \ |
| 193 |
"\xa2\xf3\xc0\xc7\x58\xe5\xf5\x51\x86\x3a\x96\xc9\x49\xad\x47\xd7" \ |
| 194 |
"\xfb\x40\xd2" |
| 195 |
#define SHA1_SEED "\xd0\x56\x9c\xb3\x66\x5a\x8a\x43\xeb\x6e\xa2\x3d" \ |
| 196 |
"\x75\xa3\xc4\xd2\x05\x4a\x0d\x7d" |
| 197 |
#define SHA224_SEED "\xd0\x56\x9c\xb3\x66\x5a\x8a\x43\xeb\x6e\xa2" \ |
| 198 |
"\x3d\x75\xa3\xc4\xd2\x05\x4a\x0d\x7d\x66\xa9\xca\x99\xc9\xce\xb0" \ |
| 199 |
"\x27" |
| 200 |
#define SHA256_SEED "\xf4\x1e\xce\x26\x13\xe4\x57\x39\x15\x69\x6b" \ |
| 201 |
"\x5a\xdc\xd5\x1c\xa3\x28\xbe\x3b\xf5\x66\xa9\xca\x99\xc9\xce\xb0" \ |
| 202 |
"\x27\x9c\x1c\xb0\xa7" |
| 203 |
#define SHA384_SEED "\x82\x40\xbc\x51\xe4\xec\x7e\xf7\x6d\x18\xe3" \ |
| 204 |
"\x52\x04\xa1\x9f\x51\xa5\x21\x3a\x73\xa8\x1d\x6f\x94\x46\x80\xd3" \ |
| 205 |
"\x07\x59\x48\xb7\xe4\x63\x80\x4e\xa3\xd2\x6e\x13\xea\x82\x0d\x65" \ |
| 206 |
"\xa4\x84\xbe\x74\x53" |
| 207 |
#define SHA512_SEED "\x47\x3f\xf1\xb9\xb3\xff\xdf\xa1\x26\x69\x9a" \ |
| 208 |
"\xc7\xef\x9e\x8e\x78\x77\x73\x09\x58\x24\xc6\x42\x55\x7c\x13\x99" \ |
| 209 |
"\xd9\x8e\x42\x20\x44\x8d\xc3\x5b\x99\xbf\xdd\x44\x77\x95\x43\x92" \ |
| 210 |
"\x4c\x1c\xe9\x3b\xc5\x94\x15\x38\x89\x5d\xb9\x88\x26\x1b\x00\x77" \ |
| 211 |
"\x4b\x12\x27\x20\x39" |
| 212 |
|
| 213 |
#define TESTCOUNT 10 |
| 214 |
#define HASHCOUNT 5 |
| 215 |
#define RANDOMCOUNT 4 |
| 216 |
#define HMACTESTCOUNT 7 |
| 217 |
#define HKDFTESTCOUNT 7 |
| 218 |
|
| 219 |
#define PRINTNONE 0 |
| 220 |
#define PRINTTEXT 1 |
| 221 |
#define PRINTRAW 2 |
| 222 |
#define PRINTHEX 3 |
| 223 |
#define PRINTBASE64 4 |
| 224 |
|
| 225 |
#define PRINTPASSFAIL 1 |
| 226 |
#define PRINTFAIL 2 |
| 227 |
|
| 228 |
#define length(x) (sizeof(x)-1) |
| 229 |
|
| 230 |
/* Test arrays for hashes. */ |
| 231 |
static struct hash { |
| 232 |
const char *name; |
| 233 |
SHAversion whichSha; |
| 234 |
int hashsize; |
| 235 |
struct { |
| 236 |
const char *testarray; |
| 237 |
int length; |
| 238 |
long repeatcount; |
| 239 |
int extrabits; |
| 240 |
int numberExtrabits; |
| 241 |
const char *resultarray; |
| 242 |
} tests[TESTCOUNT]; |
| 243 |
const char *randomtest; |
| 244 |
const char *randomresults[RANDOMCOUNT]; |
| 245 |
} hashes[HASHCOUNT] = { |
| 246 |
{ "SHA1", SHA1, SHA1HashSize, |
| 247 |
{ |
| 248 |
/* 1 */ { TEST1, length(TEST1), 1, 0, 0, |
| 249 |
"A9993E364706816ABA3E25717850C26C9CD0D89D" }, |
| 250 |
/* 2 */ { TEST2_1, length(TEST2_1), 1, 0, 0, |
| 251 |
"84983E441C3BD26EBAAE4AA1F95129E5E54670F1" }, |
| 252 |
/* 3 */ { TEST3, length(TEST3), 1000000, 0, 0, |
| 253 |
"34AA973CD4C4DAA4F61EEB2BDBAD27316534016F" }, |
| 254 |
/* 4 */ { TEST4, length(TEST4), 10, 0, 0, |
| 255 |
"DEA356A2CDDD90C7A7ECEDC5EBB563934F460452" }, |
| 256 |
/* 5 */ { "", 0, 0, 0x98, 5, |
| 257 |
"29826B003B906E660EFF4027CE98AF3531AC75BA" }, |
| 258 |
/* 6 */ { "\x5e", 1, 1, 0, 0, |
| 259 |
"5E6F80A34A9798CAFC6A5DB96CC57BA4C4DB59C2" }, |
| 260 |
/* 7 */ { TEST7_1, length(TEST7_1), 1, 0x80, 3, |
| 261 |
"6239781E03729919C01955B3FFA8ACB60B988340" }, |
| 262 |
/* 8 */ { TEST8_1, length(TEST8_1), 1, 0, 0, |
| 263 |
"82ABFF6605DBE1C17DEF12A394FA22A82B544A35" }, |
| 264 |
/* 9 */ { TEST9_1, length(TEST9_1), 1, 0xE0, 3, |
| 265 |
"8C5B2A5DDAE5A97FC7F9D85661C672ADBF7933D4" }, |
| 266 |
/* 10 */ { TEST10_1, length(TEST10_1), 1, 0, 0, |
| 267 |
"CB0082C8F197D260991BA6A460E76E202BAD27B3" } |
| 268 |
}, SHA1_SEED, { "E216836819477C7F78E0D843FE4FF1B6D6C14CD4", |
| 269 |
"A2DBC7A5B1C6C0A8BCB7AAA41252A6A7D0690DBC", |
| 270 |
"DB1F9050BB863DFEF4CE37186044E2EEB17EE013", |
| 271 |
"127FDEDF43D372A51D5747C48FBFFE38EF6CDF7B" |
| 272 |
} }, |
| 273 |
{ "SHA224", SHA224, SHA224HashSize, |
| 274 |
{ |
| 275 |
/* 1 */ { TEST1, length(TEST1), 1, 0, 0, |
| 276 |
"23097D223405D8228642A477BDA255B32AADBCE4BDA0B3F7E36C9DA7" }, |
| 277 |
/* 2 */ { TEST2_1, length(TEST2_1), 1, 0, 0, |
| 278 |
"75388B16512776CC5DBA5DA1FD890150B0C6455CB4F58B1952522525" }, |
| 279 |
/* 3 */ { TEST3, length(TEST3), 1000000, 0, 0, |
| 280 |
"20794655980C91D8BBB4C1EA97618A4BF03F42581948B2EE4EE7AD67" }, |
| 281 |
/* 4 */ { TEST4, length(TEST4), 10, 0, 0, |
| 282 |
"567F69F168CD7844E65259CE658FE7AADFA25216E68ECA0EB7AB8262" }, |
| 283 |
/* 5 */ { "", 0, 0, 0x68, 5, |
| 284 |
"E3B048552C3C387BCAB37F6EB06BB79B96A4AEE5FF27F51531A9551C" }, |
| 285 |
/* 6 */ { "\x07", 1, 1, 0, 0, |
| 286 |
"00ECD5F138422B8AD74C9799FD826C531BAD2FCABC7450BEE2AA8C2A" }, |
| 287 |
/* 7 */ { TEST7_224, length(TEST7_224), 1, 0xA0, 3, |
| 288 |
"1B01DB6CB4A9E43DED1516BEB3DB0B87B6D1EA43187462C608137150" }, |
| 289 |
/* 8 */ { TEST8_224, length(TEST8_224), 1, 0, 0, |
| 290 |
"DF90D78AA78821C99B40BA4C966921ACCD8FFB1E98AC388E56191DB1" }, |
| 291 |
/* 9 */ { TEST9_224, length(TEST9_224), 1, 0xE0, 3, |
| 292 |
"54BEA6EAB8195A2EB0A7906A4B4A876666300EEFBD1F3B8474F9CD57" }, |
| 293 |
/* 10 */ { TEST10_224, length(TEST10_224), 1, 0, 0, |
| 294 |
"0B31894EC8937AD9B91BDFBCBA294D9ADEFAA18E09305E9F20D5C3A4" } |
| 295 |
}, SHA224_SEED, { "100966A5B4FDE0B42E2A6C5953D4D7F41BA7CF79FD" |
| 296 |
"2DF431416734BE", "1DCA396B0C417715DEFAAE9641E10A2E99D55A" |
| 297 |
"BCB8A00061EB3BE8BD", "1864E627BDB2319973CD5ED7D68DA71D8B" |
| 298 |
"F0F983D8D9AB32C34ADB34", "A2406481FC1BCAF24DD08E6752E844" |
| 299 |
"709563FB916227FED598EB621F" |
| 300 |
} }, |
| 301 |
{ "SHA256", SHA256, SHA256HashSize, |
| 302 |
{ |
| 303 |
/* 1 */ { TEST1, length(TEST1), 1, 0, 0, "BA7816BF8F01CFEA4141" |
| 304 |
"40DE5DAE2223B00361A396177A9CB410FF61F20015AD" }, |
| 305 |
/* 2 */ { TEST2_1, length(TEST2_1), 1, 0, 0, "248D6A61D20638B8" |
| 306 |
"E5C026930C3E6039A33CE45964FF2167F6ECEDD419DB06C1" }, |
| 307 |
/* 3 */ { TEST3, length(TEST3), 1000000, 0, 0, "CDC76E5C9914FB92" |
| 308 |
"81A1C7E284D73E67F1809A48A497200E046D39CCC7112CD0" }, |
| 309 |
/* 4 */ { TEST4, length(TEST4), 10, 0, 0, "594847328451BDFA" |
| 310 |
"85056225462CC1D867D877FB388DF0CE35F25AB5562BFBB5" }, |
| 311 |
/* 5 */ { "", 0, 0, 0x68, 5, "D6D3E02A31A84A8CAA9718ED6C2057BE" |
| 312 |
"09DB45E7823EB5079CE7A573A3760F95" }, |
| 313 |
/* 6 */ { "\x19", 1, 1, 0, 0, "68AA2E2EE5DFF96E3355E6C7EE373E3D" |
| 314 |
"6A4E17F75F9518D843709C0C9BC3E3D4" }, |
| 315 |
/* 7 */ { TEST7_256, length(TEST7_256), 1, 0x60, 3, "77EC1DC8" |
| 316 |
"9C821FF2A1279089FA091B35B8CD960BCAF7DE01C6A7680756BEB972" }, |
| 317 |
/* 8 */ { TEST8_256, length(TEST8_256), 1, 0, 0, "175EE69B02BA" |
| 318 |
"9B58E2B0A5FD13819CEA573F3940A94F825128CF4209BEABB4E8" }, |
| 319 |
/* 9 */ { TEST9_256, length(TEST9_256), 1, 0xA0, 3, "3E9AD646" |
| 320 |
"8BBBAD2AC3C2CDC292E018BA5FD70B960CF1679777FCE708FDB066E9" }, |
| 321 |
/* 10 */ { TEST10_256, length(TEST10_256), 1, 0, 0, "97DBCA7D" |
| 322 |
"F46D62C8A422C941DD7E835B8AD3361763F7E9B2D95F4F0DA6E1CCBC" }, |
| 323 |
}, SHA256_SEED, { "83D28614D49C3ADC1D6FC05DB5F48037C056F8D2A4CE44" |
| 324 |
"EC6457DEA5DD797CD1", "99DBE3127EF2E93DD9322D6A07909EB33B6399" |
| 325 |
"5E529B3F954B8581621BB74D39", "8D4BE295BB64661CA3C7EFD129A2F7" |
| 326 |
"25B33072DBDDE32385B9A87B9AF88EA76F", "40AF5D3F9716B040DF9408" |
| 327 |
"E31536B70FF906EC51B00447CA97D7DD97C12411F4" |
| 328 |
} }, |
| 329 |
{ "SHA384", SHA384, SHA384HashSize, |
| 330 |
{ |
| 331 |
/* 1 */ { TEST1, length(TEST1), 1, 0, 0, |
| 332 |
"CB00753F45A35E8BB5A03D699AC65007272C32AB0EDED163" |
| 333 |
"1A8B605A43FF5BED8086072BA1E7CC2358BAECA134C825A7" }, |
| 334 |
/* 2 */ { TEST2_2, length(TEST2_2), 1, 0, 0, |
| 335 |
"09330C33F71147E83D192FC782CD1B4753111B173B3B05D2" |
| 336 |
"2FA08086E3B0F712FCC7C71A557E2DB966C3E9FA91746039" }, |
| 337 |
/* 3 */ { TEST3, length(TEST3), 1000000, 0, 0, |
| 338 |
"9D0E1809716474CB086E834E310A4A1CED149E9C00F24852" |
| 339 |
"7972CEC5704C2A5B07B8B3DC38ECC4EBAE97DDD87F3D8985" }, |
| 340 |
/* 4 */ { TEST4, length(TEST4), 10, 0, 0, |
| 341 |
"2FC64A4F500DDB6828F6A3430B8DD72A368EB7F3A8322A70" |
| 342 |
"BC84275B9C0B3AB00D27A5CC3C2D224AA6B61A0D79FB4596" }, |
| 343 |
/* 5 */ { "", 0, 0, 0x10, 5, |
| 344 |
"8D17BE79E32B6718E07D8A603EB84BA0478F7FCFD1BB9399" |
| 345 |
"5F7D1149E09143AC1FFCFC56820E469F3878D957A15A3FE4" }, |
| 346 |
/* 6 */ { "\xb9", 1, 1, 0, 0, |
| 347 |
"BC8089A19007C0B14195F4ECC74094FEC64F01F90929282C" |
| 348 |
"2FB392881578208AD466828B1C6C283D2722CF0AD1AB6938" }, |
| 349 |
/* 7 */ { TEST7_384, length(TEST7_384), 1, 0xA0, 3, |
| 350 |
"D8C43B38E12E7C42A7C9B810299FD6A770BEF30920F17532" |
| 351 |
"A898DE62C7A07E4293449C0B5FA70109F0783211CFC4BCE3" }, |
| 352 |
/* 8 */ { TEST8_384, length(TEST8_384), 1, 0, 0, |
| 353 |
"C9A68443A005812256B8EC76B00516F0DBB74FAB26D66591" |
| 354 |
"3F194B6FFB0E91EA9967566B58109CBC675CC208E4C823F7" }, |
| 355 |
/* 9 */ { TEST9_384, length(TEST9_384), 1, 0xE0, 3, |
| 356 |
"5860E8DE91C21578BB4174D227898A98E0B45C4C760F0095" |
| 357 |
"49495614DAEDC0775D92D11D9F8CE9B064EEAC8DAFC3A297" }, |
| 358 |
/* 10 */ { TEST10_384, length(TEST10_384), 1, 0, 0, |
| 359 |
"4F440DB1E6EDD2899FA335F09515AA025EE177A79F4B4AAF" |
| 360 |
"38E42B5C4DE660F5DE8FB2A5B2FBD2A3CBFFD20CFF1288C0" } |
| 361 |
}, SHA384_SEED, { "CE44D7D63AE0C91482998CF662A51EC80BF6FC68661A3C" |
| 362 |
"57F87566112BD635A743EA904DEB7D7A42AC808CABE697F38F", "F9C6D2" |
| 363 |
"61881FEE41ACD39E67AA8D0BAD507C7363EB67E2B81F45759F9C0FD7B503" |
| 364 |
"DF1A0B9E80BDE7BC333D75B804197D", "D96512D8C9F4A7A4967A366C01" |
| 365 |
"C6FD97384225B58343A88264847C18E4EF8AB7AEE4765FFBC3E30BD485D3" |
| 366 |
"638A01418F", "0CA76BD0813AF1509E170907A96005938BC985628290B2" |
| 367 |
"5FEF73CF6FAD68DDBA0AC8920C94E0541607B0915A7B4457F7" |
| 368 |
} }, |
| 369 |
{ "SHA512", SHA512, SHA512HashSize, |
| 370 |
{ |
| 371 |
/* 1 */ { TEST1, length(TEST1), 1, 0, 0, |
| 372 |
"DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA2" |
| 373 |
"0A9EEEE64B55D39A2192992A274FC1A836BA3C23A3FEEBBD" |
| 374 |
"454D4423643CE80E2A9AC94FA54CA49F" }, |
| 375 |
/* 2 */ { TEST2_2, length(TEST2_2), 1, 0, 0, |
| 376 |
"8E959B75DAE313DA8CF4F72814FC143F8F7779C6EB9F7FA1" |
| 377 |
"7299AEADB6889018501D289E4900F7E4331B99DEC4B5433A" |
| 378 |
"C7D329EEB6DD26545E96E55B874BE909" }, |
| 379 |
/* 3 */ { TEST3, length(TEST3), 1000000, 0, 0, |
| 380 |
"E718483D0CE769644E2E42C7BC15B4638E1F98B13B204428" |
| 381 |
"5632A803AFA973EBDE0FF244877EA60A4CB0432CE577C31B" |
| 382 |
"EB009C5C2C49AA2E4EADB217AD8CC09B" }, |
| 383 |
/* 4 */ { TEST4, length(TEST4), 10, 0, 0, |
| 384 |
"89D05BA632C699C31231DED4FFC127D5A894DAD412C0E024" |
| 385 |
"DB872D1ABD2BA8141A0F85072A9BE1E2AA04CF33C765CB51" |
| 386 |
"0813A39CD5A84C4ACAA64D3F3FB7BAE9" }, |
| 387 |
/* 5 */ { "", 0, 0, 0xB0, 5, |
| 388 |
"D4EE29A9E90985446B913CF1D1376C836F4BE2C1CF3CADA0" |
| 389 |
"720A6BF4857D886A7ECB3C4E4C0FA8C7F95214E41DC1B0D2" |
| 390 |
"1B22A84CC03BF8CE4845F34DD5BDBAD4" }, |
| 391 |
/* 6 */ { "\xD0", 1, 1, 0, 0, |
| 392 |
"9992202938E882E73E20F6B69E68A0A7149090423D93C81B" |
| 393 |
"AB3F21678D4ACEEEE50E4E8CAFADA4C85A54EA8306826C4A" |
| 394 |
"D6E74CECE9631BFA8A549B4AB3FBBA15" }, |
| 395 |
/* 7 */ { TEST7_512, length(TEST7_512), 1, 0x80, 3, |
| 396 |
"ED8DC78E8B01B69750053DBB7A0A9EDA0FB9E9D292B1ED71" |
| 397 |
"5E80A7FE290A4E16664FD913E85854400C5AF05E6DAD316B" |
| 398 |
"7359B43E64F8BEC3C1F237119986BBB6" }, |
| 399 |
/* 8 */ { TEST8_512, length(TEST8_512), 1, 0, 0, |
| 400 |
"CB0B67A4B8712CD73C9AABC0B199E9269B20844AFB75ACBD" |
| 401 |
"D1C153C9828924C3DDEDAAFE669C5FDD0BC66F630F677398" |
| 402 |
"8213EB1B16F517AD0DE4B2F0C95C90F8" }, |
| 403 |
/* 9 */ { TEST9_512, length(TEST9_512), 1, 0x80, 3, |
| 404 |
"32BA76FC30EAA0208AEB50FFB5AF1864FDBF17902A4DC0A6" |
| 405 |
"82C61FCEA6D92B783267B21080301837F59DE79C6B337DB2" |
| 406 |
"526F8A0A510E5E53CAFED4355FE7C2F1" }, |
| 407 |
/* 10 */ { TEST10_512, length(TEST10_512), 1, 0, 0, |
| 408 |
"C665BEFB36DA189D78822D10528CBF3B12B3EEF726039909" |
| 409 |
"C1A16A270D48719377966B957A878E720584779A62825C18" |
| 410 |
"DA26415E49A7176A894E7510FD1451F5" } |
| 411 |
}, SHA512_SEED, { "2FBB1E7E00F746BA514FBC8C421F36792EC0E11FF5EFC3" |
| 412 |
"78E1AB0C079AA5F0F66A1E3EDBAEB4F9984BE14437123038A452004A5576" |
| 413 |
"8C1FD8EED49E4A21BEDCD0", "25CBE5A4F2C7B1D7EF07011705D50C62C5" |
| 414 |
"000594243EAFD1241FC9F3D22B58184AE2FEE38E171CF8129E29459C9BC2" |
| 415 |
"EF461AF5708887315F15419D8D17FE7949", "5B8B1F2687555CE2D7182B" |
| 416 |
"92E5C3F6C36547DA1C13DBB9EA4F73EA4CBBAF89411527906D35B1B06C1B" |
| 417 |
"6A8007D05EC66DF0A406066829EAB618BDE3976515AAFC", "46E36B007D" |
| 418 |
"19876CDB0B29AD074FE3C08CDD174D42169D6ABE5A1414B6E79707DF5877" |
| 419 |
"6A98091CF431854147BB6D3C66D43BFBC108FD715BDE6AA127C2B0E79F" |
| 420 |
} |
| 421 |
} |
| 422 |
}; |
| 423 |
|
| 424 |
/* Test arrays for HMAC. */ |
| 425 |
static struct hmachash { |
| 426 |
const char *keyarray[5]; |
| 427 |
int keylength[5]; |
| 428 |
const char *dataarray[5]; |
| 429 |
int datalength[5]; |
| 430 |
const char *resultarray[5]; |
| 431 |
int resultlength[5]; |
| 432 |
} hmachashes[HMACTESTCOUNT] = { |
| 433 |
{ /* 1 */ { |
| 434 |
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b" |
| 435 |
"\x0b\x0b\x0b\x0b\x0b" |
| 436 |
}, { 20 }, { |
| 437 |
"\x48\x69\x20\x54\x68\x65\x72\x65" /* "Hi There" */ |
| 438 |
}, { 8 }, { |
| 439 |
/* HMAC-SHA-1 */ |
| 440 |
"B617318655057264E28BC0B6FB378C8EF146BE00", |
| 441 |
/* HMAC-SHA-224 */ |
| 442 |
"896FB1128ABBDF196832107CD49DF33F47B4B1169912BA4F53684B22", |
| 443 |
/* HMAC-SHA-256 */ |
| 444 |
"B0344C61D8DB38535CA8AFCEAF0BF12B881DC200C9833DA726E9376C2E32" |
| 445 |
"CFF7", |
| 446 |
/* HMAC-SHA-384 */ |
| 447 |
"AFD03944D84895626B0825F4AB46907F15F9DADBE4101EC682AA034C7CEB" |
| 448 |
"C59CFAEA9EA9076EDE7F4AF152E8B2FA9CB6", |
| 449 |
/* HMAC-SHA-512 */ |
| 450 |
"87AA7CDEA5EF619D4FF0B4241A1D6CB02379F4E2CE4EC2787AD0B30545E1" |
| 451 |
"7CDEDAA833B7D6B8A702038B274EAEA3F4E4BE9D914EEB61F1702E696C20" |
| 452 |
"3A126854" |
| 453 |
}, { SHA1HashSize, SHA224HashSize, SHA256HashSize, |
| 454 |
SHA384HashSize, SHA512HashSize } |
| 455 |
}, |
| 456 |
{ /* 2 */ { |
| 457 |
"\x4a\x65\x66\x65" /* "Jefe" */ |
| 458 |
}, { 4 }, { |
| 459 |
"\x77\x68\x61\x74\x20\x64\x6f\x20\x79\x61\x20\x77\x61\x6e\x74" |
| 460 |
"\x20\x66\x6f\x72\x20\x6e\x6f\x74\x68\x69\x6e\x67\x3f" |
| 461 |
/* "what do ya want for nothing?" */ |
| 462 |
}, { 28 }, { |
| 463 |
/* HMAC-SHA-1 */ |
| 464 |
"EFFCDF6AE5EB2FA2D27416D5F184DF9C259A7C79", |
| 465 |
/* HMAC-SHA-224 */ |
| 466 |
"A30E01098BC6DBBF45690F3A7E9E6D0F8BBEA2A39E6148008FD05E44", |
| 467 |
/* HMAC-SHA-256 */ |
| 468 |
"5BDCC146BF60754E6A042426089575C75A003F089D2739839DEC58B964EC" |
| 469 |
"3843", |
| 470 |
/* HMAC-SHA-384 */ |
| 471 |
"AF45D2E376484031617F78D2B58A6B1B9C7EF464F5A01B47E42EC3736322" |
| 472 |
"445E8E2240CA5E69E2C78B3239ECFAB21649", |
| 473 |
/* HMAC-SHA-512 */ |
| 474 |
"164B7A7BFCF819E2E395FBE73B56E0A387BD64222E831FD610270CD7EA25" |
| 475 |
"05549758BF75C05A994A6D034F65F8F0E6FDCAEAB1A34D4A6B4B636E070A" |
| 476 |
"38BCE737" |
| 477 |
}, { SHA1HashSize, SHA224HashSize, SHA256HashSize, |
| 478 |
SHA384HashSize, SHA512HashSize } |
| 479 |
}, |
| 480 |
{ /* 3 */ |
| 481 |
{ |
| 482 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 483 |
"\xaa\xaa\xaa\xaa\xaa" |
| 484 |
}, { 20 }, { |
| 485 |
"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd" |
| 486 |
"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd" |
| 487 |
"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd" |
| 488 |
"\xdd\xdd\xdd\xdd\xdd" |
| 489 |
}, { 50 }, { |
| 490 |
/* HMAC-SHA-1 */ |
| 491 |
"125D7342B9AC11CD91A39AF48AA17B4F63F175D3", |
| 492 |
/* HMAC-SHA-224 */ |
| 493 |
"7FB3CB3588C6C1F6FFA9694D7D6AD2649365B0C1F65D69D1EC8333EA", |
| 494 |
/* HMAC-SHA-256 */ |
| 495 |
"773EA91E36800E46854DB8EBD09181A72959098B3EF8C122D9635514CED5" |
| 496 |
"65FE", |
| 497 |
/* HMAC-SHA-384 */ |
| 498 |
"88062608D3E6AD8A0AA2ACE014C8A86F0AA635D947AC9FEBE83EF4E55966" |
| 499 |
"144B2A5AB39DC13814B94E3AB6E101A34F27", |
| 500 |
/* HMAC-SHA-512 */ |
| 501 |
"FA73B0089D56A284EFB0F0756C890BE9B1B5DBDD8EE81A3655F83E33B227" |
| 502 |
"9D39BF3E848279A722C806B485A47E67C807B946A337BEE8942674278859" |
| 503 |
"E13292FB" |
| 504 |
}, { SHA1HashSize, SHA224HashSize, SHA256HashSize, |
| 505 |
SHA384HashSize, SHA512HashSize } |
| 506 |
}, |
| 507 |
{ /* 4 */ { |
| 508 |
"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" |
| 509 |
"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19" |
| 510 |
}, { 25 }, { |
| 511 |
"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd" |
| 512 |
"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd" |
| 513 |
"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd" |
| 514 |
"\xcd\xcd\xcd\xcd\xcd" |
| 515 |
}, { 50 }, { |
| 516 |
/* HMAC-SHA-1 */ |
| 517 |
"4C9007F4026250C6BC8414F9BF50C86C2D7235DA", |
| 518 |
/* HMAC-SHA-224 */ |
| 519 |
"6C11506874013CAC6A2ABC1BB382627CEC6A90D86EFC012DE7AFEC5A", |
| 520 |
/* HMAC-SHA-256 */ |
| 521 |
"82558A389A443C0EA4CC819899F2083A85F0FAA3E578F8077A2E3FF46729" |
| 522 |
"665B", |
| 523 |
/* HMAC-SHA-384 */ |
| 524 |
"3E8A69B7783C25851933AB6290AF6CA77A9981480850009CC5577C6E1F57" |
| 525 |
"3B4E6801DD23C4A7D679CCF8A386C674CFFB", |
| 526 |
/* HMAC-SHA-512 */ |
| 527 |
"B0BA465637458C6990E5A8C5F61D4AF7E576D97FF94B872DE76F8050361E" |
| 528 |
"E3DBA91CA5C11AA25EB4D679275CC5788063A5F19741120C4F2DE2ADEBEB" |
| 529 |
"10A298DD" |
| 530 |
}, { SHA1HashSize, SHA224HashSize, SHA256HashSize, |
| 531 |
SHA384HashSize, SHA512HashSize } |
| 532 |
}, |
| 533 |
{ /* 5 */ { |
| 534 |
"\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c" |
| 535 |
"\x0c\x0c\x0c\x0c\x0c" |
| 536 |
}, { 20 }, { |
| 537 |
"Test With Truncation" |
| 538 |
}, { 20 }, { |
| 539 |
/* HMAC-SHA-1 */ |
| 540 |
"4C1A03424B55E07FE7F27BE1", |
| 541 |
/* HMAC-SHA-224 */ |
| 542 |
"0E2AEA68A90C8D37C988BCDB9FCA6FA8", |
| 543 |
/* HMAC-SHA-256 */ |
| 544 |
"A3B6167473100EE06E0C796C2955552B", |
| 545 |
/* HMAC-SHA-384 */ |
| 546 |
"3ABF34C3503B2A23A46EFC619BAEF897", |
| 547 |
/* HMAC-SHA-512 */ |
| 548 |
"415FAD6271580A531D4179BC891D87A6" |
| 549 |
}, { 12, 16, 16, 16, 16 } |
| 550 |
}, |
| 551 |
{ /* 6 */ { |
| 552 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 553 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 554 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 555 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 556 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 557 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 558 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 559 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 560 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 561 |
}, { 80, 131 }, { |
| 562 |
"Test Using Larger Than Block-Size Key - Hash Key First" |
| 563 |
}, { 54 }, { |
| 564 |
/* HMAC-SHA-1 */ |
| 565 |
"AA4AE5E15272D00E95705637CE8A3B55ED402112", |
| 566 |
/* HMAC-SHA-224 */ |
| 567 |
"95E9A0DB962095ADAEBE9B2D6F0DBCE2D499F112F2D2B7273FA6870E", |
| 568 |
/* HMAC-SHA-256 */ |
| 569 |
"60E431591EE0B67F0D8A26AACBF5B77F8E0BC6213728C5140546040F0EE3" |
| 570 |
"7F54", |
| 571 |
/* HMAC-SHA-384 */ |
| 572 |
"4ECE084485813E9088D2C63A041BC5B44F9EF1012A2B588F3CD11F05033A" |
| 573 |
"C4C60C2EF6AB4030FE8296248DF163F44952", |
| 574 |
/* HMAC-SHA-512 */ |
| 575 |
"80B24263C7C1A3EBB71493C1DD7BE8B49B46D1F41B4AEEC1121B013783F8" |
| 576 |
"F3526B56D037E05F2598BD0FD2215D6A1E5295E64F73F63F0AEC8B915A98" |
| 577 |
"5D786598" |
| 578 |
}, { SHA1HashSize, SHA224HashSize, SHA256HashSize, |
| 579 |
SHA384HashSize, SHA512HashSize } |
| 580 |
}, |
| 581 |
{ /* 7 */ { |
| 582 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 583 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 584 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 585 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 586 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 587 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 588 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 589 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 590 |
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" |
| 591 |
}, { 80, 131 }, { |
| 592 |
"Test Using Larger Than Block-Size Key and " |
| 593 |
"Larger Than One Block-Size Data", |
| 594 |
"\x54\x68\x69\x73\x20\x69\x73\x20\x61\x20\x74\x65\x73\x74\x20" |
| 595 |
"\x75\x73\x69\x6e\x67\x20\x61\x20\x6c\x61\x72\x67\x65\x72\x20" |
| 596 |
"\x74\x68\x61\x6e\x20\x62\x6c\x6f\x63\x6b\x2d\x73\x69\x7a\x65" |
| 597 |
"\x20\x6b\x65\x79\x20\x61\x6e\x64\x20\x61\x20\x6c\x61\x72\x67" |
| 598 |
"\x65\x72\x20\x74\x68\x61\x6e\x20\x62\x6c\x6f\x63\x6b\x2d\x73" |
| 599 |
"\x69\x7a\x65\x20\x64\x61\x74\x61\x2e\x20\x54\x68\x65\x20\x6b" |
| 600 |
"\x65\x79\x20\x6e\x65\x65\x64\x73\x20\x74\x6f\x20\x62\x65\x20" |
| 601 |
"\x68\x61\x73\x68\x65\x64\x20\x62\x65\x66\x6f\x72\x65\x20\x62" |
| 602 |
"\x65\x69\x6e\x67\x20\x75\x73\x65\x64\x20\x62\x79\x20\x74\x68" |
| 603 |
"\x65\x20\x48\x4d\x41\x43\x20\x61\x6c\x67\x6f\x72\x69\x74\x68" |
| 604 |
"\x6d\x2e" |
| 605 |
/* "This is a test using a larger than block-size key and a " |
| 606 |
"larger than block-size data. The key needs to be hashed " |
| 607 |
"before being used by the HMAC algorithm." */ |
| 608 |
}, { 73, 152 }, { |
| 609 |
/* HMAC-SHA-1 */ |
| 610 |
"E8E99D0F45237D786D6BBAA7965C7808BBFF1A91", |
| 611 |
/* HMAC-SHA-224 */ |
| 612 |
"3A854166AC5D9F023F54D517D0B39DBD946770DB9C2B95C9F6F565D1", |
| 613 |
/* HMAC-SHA-256 */ |
| 614 |
"9B09FFA71B942FCB27635FBCD5B0E944BFDC63644F0713938A7F51535C3A" |
| 615 |
"35E2", |
| 616 |
/* HMAC-SHA-384 */ |
| 617 |
"6617178E941F020D351E2F254E8FD32C602420FEB0B8FB9ADCCEBB82461E" |
| 618 |
"99C5A678CC31E799176D3860E6110C46523E", |
| 619 |
/* HMAC-SHA-512 */ |
| 620 |
"E37B6A775DC87DBAA4DFA9F96E5E3FFDDEBD71F8867289865DF5A32D20CD" |
| 621 |
"C944B6022CAC3C4982B10D5EEB55C3E4DE15134676FB6DE0446065C97440" |
| 622 |
"FA8C6A58" |
| 623 |
}, { SHA1HashSize, SHA224HashSize, SHA256HashSize, |
| 624 |
SHA384HashSize, SHA512HashSize } |
| 625 |
} |
| 626 |
}; |
| 627 |
|
| 628 |
/* Test arrays for HKDF. */ |
| 629 |
static struct hkdfhash { |
| 630 |
SHAversion whichSha; |
| 631 |
int ikmlength; |
| 632 |
const char *ikmarray; |
| 633 |
int saltlength; |
| 634 |
const char *saltarray; |
| 635 |
int infolength; |
| 636 |
const char *infoarray; |
| 637 |
int prklength; |
| 638 |
const char *prkarray; |
| 639 |
int okmlength; |
| 640 |
const char *okmarray; |
| 641 |
} hkdfhashes[HKDFTESTCOUNT] = { |
| 642 |
{ /* RFC 5869 A.1. Test Case 1 */ |
| 643 |
SHA256, |
| 644 |
22, "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b" |
| 645 |
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b", |
| 646 |
13, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c", |
| 647 |
10, "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9", |
| 648 |
32, "077709362C2E32DF0DDC3F0DC47BBA6390B6C73BB50F9C3122EC844A" |
| 649 |
"D7C2B3E5", |
| 650 |
42, "3CB25F25FAACD57A90434F64D0362F2A2D2D0A90CF1A5A4C5DB02D56" |
| 651 |
"ECC4C5BF34007208D5B887185865" |
| 652 |
}, |
| 653 |
{ /* RFC 5869 A.2. Test Case 2 */ |
| 654 |
SHA256, |
| 655 |
80, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d" |
| 656 |
"\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b" |
| 657 |
"\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29" |
| 658 |
"\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37" |
| 659 |
"\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45" |
| 660 |
"\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f", |
| 661 |
80, "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d" |
| 662 |
"\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b" |
| 663 |
"\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89" |
| 664 |
"\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97" |
| 665 |
"\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5" |
| 666 |
"\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf", |
| 667 |
80, "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd" |
| 668 |
"\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb" |
| 669 |
"\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9" |
| 670 |
"\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7" |
| 671 |
"\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5" |
| 672 |
"\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff", |
| 673 |
32, "06A6B88C5853361A06104C9CEB35B45C" |
| 674 |
"EF760014904671014A193F40C15FC244", |
| 675 |
82, "B11E398DC80327A1C8E7F78C596A4934" |
| 676 |
"4F012EDA2D4EFAD8A050CC4C19AFA97C" |
| 677 |
"59045A99CAC7827271CB41C65E590E09" |
| 678 |
"DA3275600C2F09B8367793A9ACA3DB71" |
| 679 |
"CC30C58179EC3E87C14C01D5C1F3434F" |
| 680 |
"1D87" |
| 681 |
}, |
| 682 |
{ /* RFC 5869 A.3. Test Case 3 */ |
| 683 |
SHA256, |
| 684 |
22, "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b" |
| 685 |
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b", |
| 686 |
0, "", |
| 687 |
0, "", |
| 688 |
32, "19EF24A32C717B167F33A91D6F648BDF" |
| 689 |
"96596776AFDB6377AC434C1C293CCB04", |
| 690 |
42, "8DA4E775A563C18F715F802A063C5A31" |
| 691 |
"B8A11F5C5EE1879EC3454E5F3C738D2D" |
| 692 |
"9D201395FAA4B61A96C8" |
| 693 |
}, |
| 694 |
{ /* RFC 5869 A.4. Test Case 4 */ |
| 695 |
SHA1, |
| 696 |
11, "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b", |
| 697 |
13, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c", |
| 698 |
10, "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9", |
| 699 |
20, "9B6C18C432A7BF8F0E71C8EB88F4B30BAA2BA243", |
| 700 |
42, "085A01EA1B10F36933068B56EFA5AD81" |
| 701 |
"A4F14B822F5B091568A9CDD4F155FDA2" |
| 702 |
"C22E422478D305F3F896" |
| 703 |
}, |
| 704 |
{ /* RFC 5869 A.5. Test Case 5 */ |
| 705 |
SHA1, |
| 706 |
80, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d" |
| 707 |
"\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b" |
| 708 |
"\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29" |
| 709 |
"\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37" |
| 710 |
"\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45" |
| 711 |
"\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f", |
| 712 |
80, "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6A\x6B\x6C\x6D" |
| 713 |
"\x6E\x6F\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7A\x7B" |
| 714 |
"\x7C\x7D\x7E\x7F\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89" |
| 715 |
"\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97" |
| 716 |
"\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5" |
| 717 |
"\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF", |
| 718 |
80, "\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD" |
| 719 |
"\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB" |
| 720 |
"\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9" |
| 721 |
"\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7" |
| 722 |
"\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5" |
| 723 |
"\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF", |
| 724 |
20, "8ADAE09A2A307059478D309B26C4115A224CFAF6", |
| 725 |
82, "0BD770A74D1160F7C9F12CD5912A06EB" |
| 726 |
"FF6ADCAE899D92191FE4305673BA2FFE" |
| 727 |
"8FA3F1A4E5AD79F3F334B3B202B2173C" |
| 728 |
"486EA37CE3D397ED034C7F9DFEB15C5E" |
| 729 |
"927336D0441F4C4300E2CFF0D0900B52" |
| 730 |
"D3B4" |
| 731 |
}, |
| 732 |
{ /* RFC 5869 A.6. Test Case 6 */ |
| 733 |
SHA1, |
| 734 |
22, "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b" |
| 735 |
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b", |
| 736 |
0, "", |
| 737 |
0, "", |
| 738 |
20, "DA8C8A73C7FA77288EC6F5E7C297786AA0D32D01", |
| 739 |
42, "0AC1AF7002B3D761D1E55298DA9D0506" |
| 740 |
"B9AE52057220A306E07B6B87E8DF21D0" |
| 741 |
"EA00033DE03984D34918" |
| 742 |
}, |
| 743 |
{ /* RFC 5869 A.7. Test Case 7. */ |
| 744 |
SHA1, |
| 745 |
22, "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c" |
| 746 |
"\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c", |
| 747 |
0, 0, |
| 748 |
0, "", |
| 749 |
20, "2ADCCADA18779E7C2077AD2EB19D3F3E731385DD", |
| 750 |
42, "2C91117204D745F3500D636A62F64F0A" |
| 751 |
"B3BAE548AA53D423B0D1F27EBBA6F5E5" |
| 752 |
"673A081D70CCE7ACFC48" |
| 753 |
} |
| 754 |
}; |
| 755 |
|
| 756 |
/* |
| 757 |
* Check the hash value against the expected string, expressed in hex |
| 758 |
*/ |
| 759 |
static const char hexdigits[ ] = "0123456789ABCDEF"; |
| 760 |
static int checkmatch(const unsigned char *hashvalue, |
| 761 |
const char *hexstr, int hashsize) |
| 762 |
{ |
| 763 |
int i; |
| 764 |
for (i = 0; i < hashsize; ++i) { |
| 765 |
if (*hexstr++ != hexdigits[(hashvalue[i] >> 4) & 0xF]) |
| 766 |
return 0; |
| 767 |
if (*hexstr++ != hexdigits[hashvalue[i] & 0xF]) return 0; |
| 768 |
} |
| 769 |
return 1; |
| 770 |
} |
| 771 |
|
| 772 |
/* |
| 773 |
* Print the string, converting non-printable characters to "." |
| 774 |
*/ |
| 775 |
static void printstr(const char *str, int len) |
| 776 |
{ |
| 777 |
for ( ; len-- > 0; str++) |
| 778 |
putchar(isprint((unsigned char)*str) ? *str : '.'); |
| 779 |
} |
| 780 |
|
| 781 |
/* |
| 782 |
* Print the string, converting all characters to hex "## ". |
| 783 |
*/ |
| 784 |
static void printxstr(const char *str, int len) |
| 785 |
{ |
| 786 |
char *sep = ""; |
| 787 |
for ( ; len-- > 0; str++) { |
| 788 |
printf("%s%c%c", sep, hexdigits[(*str >> 4) & 0xF], |
| 789 |
hexdigits[*str & 0xF]); |
| 790 |
sep = " "; |
| 791 |
} |
| 792 |
} |
| 793 |
|
| 794 |
/* |
| 795 |
* Print a usage message. |
| 796 |
*/ |
| 797 |
static void usage(const char *argv0) |
| 798 |
{ |
| 799 |
fprintf(stderr, |
| 800 |
"Usage:\n" |
| 801 |
"Common options: [-h hash] [-w|-x|-6] [-H]\n" |
| 802 |
"Hash a string:\n" |
| 803 |
"\t%s [-S expectedresult] -s hashstr [-k key] " |
| 804 |
"[-i info -L okm-len]\n" |
| 805 |
"Hash a file:\n" |
| 806 |
"\t%s [-S expectedresult] -f file [-k key] " |
| 807 |
"[-i info -L okm-len]\n" |
| 808 |
"Hash a file, ignoring whitespace:\n" |
| 809 |
"\t%s [-S expectedresult] -F file [-k key] " |
| 810 |
"[-i info -L okm-len]\n" |
| 811 |
"Additional bits to add in: [-B bitcount -b bits]\n" |
| 812 |
"(If -k,-i&-L are used, run HKDF-SHA###.\n" |
| 813 |
" If -k is used, but not -i&-L, run HMAC-SHA###.\n" |
| 814 |
" Otherwise, run SHA###.)\n" |
| 815 |
"Standard tests:\n" |
| 816 |
"\t%s [-m | -d] [-l loopcount] [-t test#] [-e]\n" |
| 817 |
"\t\t[-r randomseed] [-R randomloop-count] " |
| 818 |
"[-p] [-P|-X]\n" |
| 819 |
"-h\thash to test: " |
| 820 |
"0|SHA1, 1|SHA224, 2|SHA256, 3|SHA384, 4|SHA512\n" |
| 821 |
"-m\tperform hmac standard tests\n" |
| 822 |
"-k\tkey for hmac test\n" |
| 823 |
"-d\tperform hkdf standard tests\n" |
| 824 |
"-t\ttest case to run, 1-10\n" |
| 825 |
"-l\thow many times to run the test\n" |
| 826 |
"-e\ttest error returns\n" |
| 827 |
"-p\tdo not print results\n" |
| 828 |
"-P\tdo not print PASSED/FAILED\n" |
| 829 |
"-X\tprint FAILED, but not PASSED\n" |
| 830 |
"-r\tseed for random test\n" |
| 831 |
"-R\thow many times to run random test\n" |
| 832 |
"-s\tstring to hash\n" |
| 833 |
"-S\texpected result of hashed string, in hex\n" |
| 834 |
"-w\toutput hash in raw format\n" |
| 835 |
"-x\toutput hash in hex format\n" |
| 836 |
"-6\toutput hash in base64 format\n" |
| 837 |
"-B\t# extra bits to add in after string or file input\n" |
| 838 |
"-b\textra bits to add (high order bits of #, 0# or 0x#)\n" |
| 839 |
"-H\tinput hashstr or randomseed is in hex\n" |
| 840 |
, argv0, argv0, argv0, argv0); |
| 841 |
exit(1); |
| 842 |
} |
| 843 |
|
| 844 |
/* |
| 845 |
* Print the results and PASS/FAIL. |
| 846 |
*/ |
| 847 |
static void printResult(uint8_t *Message_Digest, int hashsize, |
| 848 |
const char *hashname, const char *testtype, const char *testname, |
| 849 |
const char *resultarray, int printResults, int printPassFail) |
| 850 |
{ |
| 851 |
int i, k; |
| 852 |
if (printResults == PRINTTEXT) { |
| 853 |
printf("\nhashsize=%d\n", hashsize); |
| 854 |
putchar('\t'); |
| 855 |
for (i = 0; i < hashsize; ++i) { |
| 856 |
putchar(hexdigits[(Message_Digest[i] >> 4) & 0xF]); |
| 857 |
putchar(hexdigits[Message_Digest[i] & 0xF]); |
| 858 |
putchar(' '); |
| 859 |
} |
| 860 |
putchar('\n'); |
| 861 |
} else if (printResults == PRINTRAW) { |
| 862 |
fwrite(Message_Digest, 1, hashsize, stdout); |
| 863 |
} else if (printResults == PRINTHEX) { |
| 864 |
for (i = 0; i < hashsize; ++i) { |
| 865 |
putchar(hexdigits[(Message_Digest[i] >> 4) & 0xF]); |
| 866 |
putchar(hexdigits[Message_Digest[i] & 0xF]); |
| 867 |
} |
| 868 |
putchar('\n'); |
| 869 |
} else if (printResults == PRINTBASE64) { |
| 870 |
unsigned char b; |
| 871 |
char *sm = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" |
| 872 |
"0123456789+/"; |
| 873 |
for (i = 0; i < hashsize; i += 3) { |
| 874 |
putchar(sm[Message_Digest[i] >> 2]); |
| 875 |
b = (Message_Digest[i] & 0x03) << 4; |
| 876 |
if (i+1 < hashsize) b |= Message_Digest[i+1] >> 4; |
| 877 |
putchar(sm[b]); |
| 878 |
if (i+1 < hashsize) { |
| 879 |
b = (Message_Digest[i+1] & 0x0f) << 2; |
| 880 |
if (i+2 < hashsize) b |= Message_Digest[i+2] >> 6; |
| 881 |
putchar(sm[b]); |
| 882 |
} else putchar('='); |
| 883 |
if (i+2 < hashsize) putchar(sm[Message_Digest[i+2] & 0x3f]); |
| 884 |
else putchar('='); |
| 885 |
} |
| 886 |
putchar('\n'); |
| 887 |
} |
| 888 |
|
| 889 |
if (printResults && resultarray) { |
| 890 |
printf(" Should match:\n\t"); |
| 891 |
for (i = 0, k = 0; i < hashsize; i++, k += 2) { |
| 892 |
putchar(resultarray[k]); |
| 893 |
putchar(resultarray[k+1]); |
| 894 |
putchar(' '); |
| 895 |
} |
| 896 |
putchar('\n'); |
| 897 |
} |
| 898 |
|
| 899 |
if (printPassFail && resultarray) { |
| 900 |
int ret = checkmatch(Message_Digest, resultarray, hashsize); |
| 901 |
if ((printPassFail == PRINTPASSFAIL) || !ret) |
| 902 |
printf("%s %s %s: %s\n", hashname, testtype, testname, |
| 903 |
ret ? "PASSED" : "FAILED"); |
| 904 |
} |
| 905 |
} |
| 906 |
|
| 907 |
/* |
| 908 |
* Exercise a hash series of functions. The input is the testarray, |
| 909 |
* repeated repeatcount times, followed by the extrabits. If the |
| 910 |
* result is known, it is in resultarray in uppercase hex. |
| 911 |
*/ |
| 912 |
static int hash(int testno, int loopno, int hashno, |
| 913 |
const char *testarray, int length, long repeatcount, |
| 914 |
int numberExtrabits, int extrabits, const unsigned char *keyarray, |
| 915 |
int keylen, const unsigned char *info, int infolen, int okmlen, |
| 916 |
const char *resultarray, int hashsize, int printResults, |
| 917 |
int printPassFail) |
| 918 |
{ |
| 919 |
USHAContext sha; |
| 920 |
HMACContext hmac; |
| 921 |
HKDFContext hkdf; |
| 922 |
int err, i; |
| 923 |
uint8_t Message_Digest_Buf[USHAMaxHashSize]; |
| 924 |
uint8_t *Message_Digest = Message_Digest_Buf; |
| 925 |
char buf[128]; |
| 926 |
|
| 927 |
if (printResults == PRINTTEXT) { |
| 928 |
printf("\nTest %d: Iteration %d, Repeat %ld\n\t'", testno+1, |
| 929 |
loopno, repeatcount); |
| 930 |
printstr(testarray, length); |
| 931 |
printf("'\n\t'"); |
| 932 |
printxstr(testarray, length); |
| 933 |
printf("'\n"); |
| 934 |
printf(" Length=%d bytes (%d bits), ", length, length * 8); |
| 935 |
printf("ExtraBits %d: %2.2x\n", numberExtrabits, extrabits); |
| 936 |
} |
| 937 |
|
| 938 |
if (info) Message_Digest = (uint8_t *) malloc(okmlen); |
| 939 |
memset(&sha, '\343', sizeof(sha)); /* force bad data into struct */ |
| 940 |
memset(&hmac, '\343', sizeof(hmac)); |
| 941 |
memset(&hkdf, '\343', sizeof(hkdf)); |
| 942 |
|
| 943 |
err = info ? RFC5869HkdfReset(&hkdf, hashes[hashno].whichSha, |
| 944 |
keyarray, keylen) : |
| 945 |
keyarray ? RFC2104HmacReset(&hmac, hashes[hashno].whichSha, |
| 946 |
keyarray, keylen) : |
| 947 |
USHAReset(&sha, hashes[hashno].whichSha); |
| 948 |
if (err != shaSuccess) { |
| 949 |
fprintf(stderr, "hash(): %sReset Error %d.\n", |
| 950 |
info ? "hkdf" : keyarray ? "hmac" : "sha", err); |
| 951 |
if (info) free((void *) Message_Digest); |
| 952 |
return err; |
| 953 |
} |
| 954 |
|
| 955 |
for (i = 0; i < repeatcount; ++i) { |
| 956 |
err = info ? RFC5869HkdfInput(&hkdf, (const uint8_t *)testarray, length) : |
| 957 |
keyarray ? RFC2104HmacInput(&hmac, (const uint8_t *) testarray, |
| 958 |
length) : |
| 959 |
USHAInput(&sha, (const uint8_t *) testarray, |
| 960 |
length); |
| 961 |
if (err != shaSuccess) { |
| 962 |
fprintf(stderr, "hash(): %sInput Error %d.\n", |
| 963 |
info ? "hkdf" : keyarray ? "hmac" : "sha", err); |
| 964 |
if (info) free((void *) Message_Digest); |
| 965 |
return err; |
| 966 |
} |
| 967 |
} |
| 968 |
|
| 969 |
if (numberExtrabits > 0) { |
| 970 |
err = info ? RFC5869HkdfFinalBits(&hkdf, extrabits, numberExtrabits) : |
| 971 |
keyarray ? RFC2104HmacFinalBits(&hmac, (uint8_t) extrabits, |
| 972 |
numberExtrabits) : |
| 973 |
USHAFinalBits(&sha, (uint8_t) extrabits, |
| 974 |
numberExtrabits); |
| 975 |
if (err != shaSuccess) { |
| 976 |
fprintf(stderr, "hash(): %sFinalBits Error %d.\n", |
| 977 |
info ? "hkdf" : keyarray ? "hmac" : "sha", err); |
| 978 |
if (info) free((void *) Message_Digest); |
| 979 |
return err; |
| 980 |
} |
| 981 |
} |
| 982 |
|
| 983 |
err = info ? RFC5869HkdfResult(&hkdf, 0, info, infolen, |
| 984 |
Message_Digest, okmlen) : |
| 985 |
keyarray ? RFC2104HmacResult(&hmac, Message_Digest) : |
| 986 |
USHAResult(&sha, Message_Digest); |
| 987 |
if (err != shaSuccess) { |
| 988 |
fprintf(stderr, "hash(): %s Result Error %d, could not compute " |
| 989 |
"message digest.\n", |
| 990 |
info ? "hkdf" : keyarray ? "hmac" : "sha", err); |
| 991 |
if (info) free((void *) Message_Digest); |
| 992 |
return err; |
| 993 |
} |
| 994 |
|
| 995 |
snprintf(buf, (size_t) 128, "%d", testno+1); |
| 996 |
printResult(Message_Digest, info ? okmlen : hashsize, |
| 997 |
hashes[hashno].name, info ? "hkdf standard test" : |
| 998 |
keyarray ? "hmac standard test" : "sha standard test", buf, |
| 999 |
resultarray, printResults, printPassFail); |
| 1000 |
|
| 1001 |
if (info) free((void *) Message_Digest); |
| 1002 |
|
| 1003 |
return err; |
| 1004 |
} |
| 1005 |
|
| 1006 |
/* |
| 1007 |
* Exercise an HKDF series. The input is the testarray, |
| 1008 |
* repeated repeatcount times, followed by the extrabits. If the |
| 1009 |
* result is known, it is in resultarray in uppercase hex. |
| 1010 |
*/ |
| 1011 |
static int hashHkdf(int testno, int loopno, int hashno, |
| 1012 |
int printResults, int printPassFail) |
| 1013 |
{ |
| 1014 |
int err; |
| 1015 |
unsigned char prk[USHAMaxHashSize+1]; |
| 1016 |
uint8_t okm[255 * USHAMaxHashSize+1]; |
| 1017 |
char buf[128]; |
| 1018 |
|
| 1019 |
(void) hashno; /* Silence 'unused parameter' warning */ |
| 1020 |
|
| 1021 |
if (printResults == PRINTTEXT) { |
| 1022 |
printf("\nTest %d: Iteration %d\n\tSALT\t'", testno+1, loopno); |
| 1023 |
printxstr(hkdfhashes[testno].saltarray, |
| 1024 |
hkdfhashes[testno].saltlength); |
| 1025 |
printf("'\n\tIKM\t'"); |
| 1026 |
printxstr(hkdfhashes[testno].ikmarray, |
| 1027 |
hkdfhashes[testno].ikmlength); |
| 1028 |
printf("'\n\tINFO\t'"); |
| 1029 |
printxstr(hkdfhashes[testno].infoarray, |
| 1030 |
hkdfhashes[testno].infolength); |
| 1031 |
printf("'\n"); |
| 1032 |
printf(" L=%d bytes\n", hkdfhashes[testno].okmlength); |
| 1033 |
} |
| 1034 |
|
| 1035 |
/* Run RFC5869Hkdf() against the test vectors */ |
| 1036 |
err = RFC5869Hkdf(hkdfhashes[testno].whichSha, |
| 1037 |
(const uint8_t *) hkdfhashes[testno].saltarray, |
| 1038 |
hkdfhashes[testno].saltlength, |
| 1039 |
(const uint8_t *) hkdfhashes[testno].ikmarray, |
| 1040 |
hkdfhashes[testno].ikmlength, |
| 1041 |
(const uint8_t *) hkdfhashes[testno].infoarray, |
| 1042 |
hkdfhashes[testno].infolength, okm, |
| 1043 |
hkdfhashes[testno].okmlength); |
| 1044 |
if (err != shaSuccess) { |
| 1045 |
fprintf(stderr, "hashHkdf(): hkdf Error %d.\n", err); |
| 1046 |
return err; |
| 1047 |
} |
| 1048 |
snprintf(buf, (size_t) 128, "hkdf %d", testno+1); |
| 1049 |
printResult(okm, hkdfhashes[testno].okmlength, |
| 1050 |
USHAHashName(hkdfhashes[testno].whichSha), "hkdf standard test", |
| 1051 |
buf, hkdfhashes[testno].okmarray, printResults, printPassFail); |
| 1052 |
|
| 1053 |
/* Now run RFC5869HkdfExtract() by itself against the test vectors */ |
| 1054 |
/* to verify the intermediate results. */ |
| 1055 |
err = RFC5869HkdfExtract(hkdfhashes[testno].whichSha, |
| 1056 |
(const uint8_t *) hkdfhashes[testno].saltarray, |
| 1057 |
hkdfhashes[testno].saltlength, |
| 1058 |
(const uint8_t *) hkdfhashes[testno].ikmarray, |
| 1059 |
hkdfhashes[testno].ikmlength, prk); |
| 1060 |
if (err != shaSuccess) { |
| 1061 |
fprintf(stderr, "hashHkdf(): RFC5869HkdfExtract Error %d.\n", err); |
| 1062 |
return err; |
| 1063 |
} |
| 1064 |
snprintf(buf, (size_t) 128, "hkdfExtract %d", testno+1); |
| 1065 |
printResult(prk, USHAHashSize(hkdfhashes[testno].whichSha), |
| 1066 |
USHAHashName(hkdfhashes[testno].whichSha), "hkdf standard test", |
| 1067 |
buf, hkdfhashes[testno].prkarray, printResults, printPassFail); |
| 1068 |
|
| 1069 |
/* Now run RFC5869HkdfExpand() by itself against the test vectors */ |
| 1070 |
/* using the intermediate results from RFC5869HkdfExtract. */ |
| 1071 |
err = RFC5869HkdfExpand(hkdfhashes[testno].whichSha, prk, |
| 1072 |
USHAHashSize(hkdfhashes[testno].whichSha), |
| 1073 |
(const uint8_t *)hkdfhashes[testno].infoarray, |
| 1074 |
hkdfhashes[testno].infolength, okm, |
| 1075 |
hkdfhashes[testno].okmlength); |
| 1076 |
if (err != shaSuccess) { |
| 1077 |
fprintf(stderr, "hashHkdf(): RFC5869HkdfExpand Error %d.\n", err); |
| 1078 |
return err; |
| 1079 |
} |
| 1080 |
snprintf(buf, (size_t) 128, "hkdfExpand %d", testno+1); |
| 1081 |
printResult(okm, hkdfhashes[testno].okmlength, |
| 1082 |
USHAHashName(hkdfhashes[testno].whichSha), "hkdf standard test", |
| 1083 |
buf, hkdfhashes[testno].okmarray, printResults, printPassFail); |
| 1084 |
|
| 1085 |
return err; |
| 1086 |
} |
| 1087 |
|
| 1088 |
/* |
| 1089 |
* Exercise a hash series of functions. The input is a filename. |
| 1090 |
* If the result is known, it is in resultarray in uppercase hex. |
| 1091 |
*/ |
| 1092 |
static int hashfile(int hashno, const char *hashfilename, int bits, |
| 1093 |
int bitcount, int skipSpaces, const unsigned char *keyarray, |
| 1094 |
int keylen, const unsigned char *info, int infolen, int okmlen, |
| 1095 |
const char *resultarray, int hashsize, |
| 1096 |
int printResults, int printPassFail) |
| 1097 |
{ |
| 1098 |
USHAContext sha; |
| 1099 |
HMACContext hmac; |
| 1100 |
HKDFContext hkdf; |
| 1101 |
int err, nread, c; |
| 1102 |
unsigned char buf[4096]; |
| 1103 |
uint8_t Message_Digest_Buf[USHAMaxHashSize]; |
| 1104 |
uint8_t *Message_Digest = Message_Digest_Buf; |
| 1105 |
unsigned char cc; |
| 1106 |
FILE *hashfp = (strcmp(hashfilename, "-") == 0) ? stdin : |
| 1107 |
fopen(hashfilename, "r"); |
| 1108 |
|
| 1109 |
if (!hashfp) { |
| 1110 |
fprintf(stderr, "cannot open file '%s'\n", hashfilename); |
| 1111 |
return shaStateError; |
| 1112 |
} |
| 1113 |
|
| 1114 |
if (info) Message_Digest = (uint8_t *) malloc(okmlen); |
| 1115 |
memset(&sha, '\343', sizeof(sha)); /* force bad data into struct */ |
| 1116 |
memset(&hmac, '\343', sizeof(hmac)); |
| 1117 |
memset(&hkdf, '\343', sizeof(hkdf)); |
| 1118 |
err = info ? RFC5869HkdfReset(&hkdf, hashes[hashno].whichSha, |
| 1119 |
keyarray, keylen) : |
| 1120 |
keyarray ? RFC2104HmacReset(&hmac, hashes[hashno].whichSha, |
| 1121 |
keyarray, keylen) : |
| 1122 |
USHAReset(&sha, hashes[hashno].whichSha); |
| 1123 |
if (err != shaSuccess) { |
| 1124 |
fprintf(stderr, "hashfile(): %sReset Error %d.\n", |
| 1125 |
info ? "hkdf" : keyarray ? "hmac" : "sha", err); |
| 1126 |
if (hashfp != stdin) fclose(hashfp); |
| 1127 |
if (info) free((void *) Message_Digest); |
| 1128 |
return err; |
| 1129 |
} |
| 1130 |
|
| 1131 |
if (skipSpaces) |
| 1132 |
while ((c = getc(hashfp)) != EOF) { |
| 1133 |
if (!isspace(c)) { |
| 1134 |
cc = (unsigned char)c; |
| 1135 |
err = info ? RFC5869HkdfInput(&hkdf, &cc, 1) : |
| 1136 |
keyarray ? RFC2104HmacInput(&hmac, &cc, 1) : |
| 1137 |
USHAInput(&sha, &cc, 1); |
| 1138 |
if (err != shaSuccess) { |
| 1139 |
fprintf(stderr, "hashfile(): %sInput Error %d.\n", |
| 1140 |
info ? "hkdf" : keyarray ? "hmac" : "sha", err); |
| 1141 |
if (hashfp != stdin) fclose(hashfp); |
| 1142 |
if (info) free((void *) Message_Digest); |
| 1143 |
return err; |
| 1144 |
} |
| 1145 |
} |
| 1146 |
} |
| 1147 |
else |
| 1148 |
while ((nread = fread(buf, 1, sizeof(buf), hashfp)) > 0) { |
| 1149 |
err = info ? RFC5869HkdfInput(&hkdf, buf, nread) : |
| 1150 |
keyarray ? RFC2104HmacInput(&hmac, buf, nread) : |
| 1151 |
USHAInput(&sha, buf, nread); |
| 1152 |
if (err != shaSuccess) { |
| 1153 |
fprintf(stderr, "hashfile(): %s Error %d.\n", |
| 1154 |
info ? "hkdf" : keyarray ? "hmacInput" : |
| 1155 |
"shaInput", err); |
| 1156 |
if (hashfp != stdin) fclose(hashfp); |
| 1157 |
if (info) free((void *) Message_Digest); |
| 1158 |
return err; |
| 1159 |
} |
| 1160 |
} |
| 1161 |
|
| 1162 |
if (bitcount > 0) |
| 1163 |
err = info ? RFC5869HkdfFinalBits(&hkdf, bits, bitcount) : |
| 1164 |
keyarray ? RFC2104HmacFinalBits(&hmac, bits, bitcount) : |
| 1165 |
USHAFinalBits(&sha, bits, bitcount); |
| 1166 |
if (err != shaSuccess) { |
| 1167 |
fprintf(stderr, "hashfile(): %s Error %d.\n", |
| 1168 |
info ? "hkdf" : keyarray ? "hmacFinalBits" : |
| 1169 |
"shaFinalBits", err); |
| 1170 |
if (hashfp != stdin) fclose(hashfp); |
| 1171 |
if (info) free((void *) Message_Digest); |
| 1172 |
return err; |
| 1173 |
} |
| 1174 |
|
| 1175 |
err = info ? RFC5869HkdfResult(&hkdf, 0, info, infolen, |
| 1176 |
Message_Digest, okmlen) : |
| 1177 |
keyarray ? RFC2104HmacResult(&hmac, Message_Digest) : |
| 1178 |
USHAResult(&sha, Message_Digest); |
| 1179 |
if (err != shaSuccess) { |
| 1180 |
fprintf(stderr, "hashfile(): %s Error %d.\n", |
| 1181 |
info ? "hkdf" : keyarray ? "hmacResult" : |
| 1182 |
"shaResult", err); |
| 1183 |
if (hashfp != stdin) fclose(hashfp); |
| 1184 |
if (info) free((void *) Message_Digest); |
| 1185 |
return err; |
| 1186 |
} |
| 1187 |
|
| 1188 |
printResult(Message_Digest, info ? okmlen : hashsize, |
| 1189 |
hashes[hashno].name, "file", hashfilename, resultarray, |
| 1190 |
printResults, printPassFail); |
| 1191 |
|
| 1192 |
if (hashfp != stdin) fclose(hashfp); |
| 1193 |
if (info) free((void *) Message_Digest); |
| 1194 |
return err; |
| 1195 |
} |
| 1196 |
|
| 1197 |
/* |
| 1198 |
* Exercise a hash series of functions through multiple permutations. |
| 1199 |
* The input is an initial seed. That seed is replicated 3 times. |
| 1200 |
* For 1000 rounds, the previous three results are used as the input. |
| 1201 |
* This result is then checked, and used to seed the next cycle. |
| 1202 |
* If the result is known, it is in resultarrays in uppercase hex. |
| 1203 |
*/ |
| 1204 |
static void randomtest(int hashno, const char *seed, int hashsize, |
| 1205 |
const char **resultarrays, int randomcount, |
| 1206 |
int printResults, int printPassFail) |
| 1207 |
{ |
| 1208 |
int i, j; |
| 1209 |
char buf[128]; |
| 1210 |
unsigned char SEED[USHAMaxHashSize], MD[1003][USHAMaxHashSize]; |
| 1211 |
|
| 1212 |
/* INPUT: Seed - A random seed n bits long */ |
| 1213 |
memcpy(SEED, seed, hashsize); |
| 1214 |
if (printResults == PRINTTEXT) { |
| 1215 |
printf("%s random test seed= '", hashes[hashno].name); |
| 1216 |
printxstr(seed, hashsize); |
| 1217 |
printf("'\n"); |
| 1218 |
} |
| 1219 |
|
| 1220 |
for (j = 0; j < randomcount; j++) { |
| 1221 |
/* MD0 = MD1 = MD2 = Seed; */ |
| 1222 |
memcpy(MD[0], SEED, hashsize); |
| 1223 |
memcpy(MD[1], SEED, hashsize); |
| 1224 |
memcpy(MD[2], SEED, hashsize); |
| 1225 |
for (i=3; i<1003; i++) { |
| 1226 |
/* Mi = MDi-3 || MDi-2 || MDi-1; */ |
| 1227 |
USHAContext Mi; |
| 1228 |
memset(&Mi, '\343', sizeof(Mi)); /* force bad data into struct */ |
| 1229 |
USHAReset(&Mi, hashes[hashno].whichSha); |
| 1230 |
USHAInput(&Mi, MD[i-3], hashsize); |
| 1231 |
USHAInput(&Mi, MD[i-2], hashsize); |
| 1232 |
USHAInput(&Mi, MD[i-1], hashsize); |
| 1233 |
/* MDi = SHA(Mi); */ |
| 1234 |
USHAResult(&Mi, MD[i]); |
| 1235 |
} |
| 1236 |
|
| 1237 |
/* MDj = Seed = MDi; */ |
| 1238 |
memcpy(SEED, MD[i-1], hashsize); |
| 1239 |
|
| 1240 |
/* OUTPUT: MDj */ |
| 1241 |
snprintf(buf, (size_t) 128, "%d", j); |
| 1242 |
printResult(SEED, hashsize, hashes[hashno].name, "random test", |
| 1243 |
buf, resultarrays ? resultarrays[j] : 0, printResults, |
| 1244 |
(j < RANDOMCOUNT) ? printPassFail : 0); |
| 1245 |
} |
| 1246 |
} |
| 1247 |
|
| 1248 |
/* |
| 1249 |
* Look up a hash name. |
| 1250 |
*/ |
| 1251 |
static int findhash(const char *argv0, const char *opt) |
| 1252 |
{ |
| 1253 |
int i; |
| 1254 |
const char *names[HASHCOUNT][2] = { |
| 1255 |
{ "0", "sha1" }, { "1", "sha224" }, { "2", "sha256" }, |
| 1256 |
{ "3", "sha384" }, { "4", "sha512" } |
| 1257 |
}; |
| 1258 |
for (i = 0; i < HASHCOUNT; i++) |
| 1259 |
if ((strcmp(opt, names[i][0]) == 0) || |
| 1260 |
(scasecmp(opt, names[i][1]) == 0)) |
| 1261 |
return i; |
| 1262 |
|
| 1263 |
fprintf(stderr, "%s: Unknown hash name: '%s'\n", argv0, opt); |
| 1264 |
usage(argv0); |
| 1265 |
return 0; |
| 1266 |
} |
| 1267 |
|
| 1268 |
/* |
| 1269 |
* Run some tests that should invoke errors. |
| 1270 |
*/ |
| 1271 |
static void testErrors(int hashnolow, int hashnohigh, int printResults, |
| 1272 |
int printPassFail) |
| 1273 |
{ |
| 1274 |
USHAContext usha; |
| 1275 |
uint8_t Message_Digest[USHAMaxHashSize]; |
| 1276 |
int hashno, err; |
| 1277 |
|
| 1278 |
for (hashno = hashnolow; hashno <= hashnohigh; hashno++) { |
| 1279 |
memset(&usha, '\343', sizeof(usha)); /* force bad data */ |
| 1280 |
USHAReset(&usha, hashno); |
| 1281 |
USHAResult(&usha, Message_Digest); |
| 1282 |
err = USHAInput(&usha, (const unsigned char *)"foo", 3); |
| 1283 |
if (printResults == PRINTTEXT) |
| 1284 |
printf ("\nError %d. Should be %d.\n", err, shaStateError); |
| 1285 |
|
| 1286 |
if ((printPassFail == PRINTPASSFAIL) || |
| 1287 |
((printPassFail == PRINTFAIL) && (err != shaStateError))) |
| 1288 |
printf("%s se: %s\n", hashes[hashno].name, |
| 1289 |
(err == shaStateError) ? "PASSED" : "FAILED"); |
| 1290 |
|
| 1291 |
err = USHAFinalBits(&usha, 0x80, 3); |
| 1292 |
if (printResults == PRINTTEXT) |
| 1293 |
printf ("\nError %d. Should be %d.\n", err, shaStateError); |
| 1294 |
if ((printPassFail == PRINTPASSFAIL) || |
| 1295 |
((printPassFail == PRINTFAIL) && (err != shaStateError))) |
| 1296 |
printf("%s se: %s\n", hashes[hashno].name, |
| 1297 |
(err == shaStateError) ? "PASSED" : "FAILED"); |
| 1298 |
|
| 1299 |
err = USHAReset(0, hashes[hashno].whichSha); |
| 1300 |
if (printResults == PRINTTEXT) |
| 1301 |
printf("\nError %d. Should be %d.\n", err, shaNull); |
| 1302 |
if ((printPassFail == PRINTPASSFAIL) || |
| 1303 |
((printPassFail == PRINTFAIL) && (err != shaNull))) |
| 1304 |
printf("%s usha null: %s\n", hashes[hashno].name, |
| 1305 |
(err == shaNull) ? "PASSED" : "FAILED"); |
| 1306 |
|
| 1307 |
switch (hashno) { |
| 1308 |
case SHA1: err = SHA1Reset(0); break; |
| 1309 |
case SHA224: err = SHA224Reset(0); break; |
| 1310 |
case SHA256: err = SHA256Reset(0); break; |
| 1311 |
case SHA384: err = SHA384Reset(0); break; |
| 1312 |
case SHA512: err = SHA512Reset(0); break; |
| 1313 |
} |
| 1314 |
if (printResults == PRINTTEXT) |
| 1315 |
printf("\nError %d. Should be %d.\n", err, shaNull); |
| 1316 |
if ((printPassFail == PRINTPASSFAIL) || |
| 1317 |
((printPassFail == PRINTFAIL) && (err != shaNull))) |
| 1318 |
printf("%s sha null: %s\n", hashes[hashno].name, |
| 1319 |
(err == shaNull) ? "PASSED" : "FAILED"); |
| 1320 |
} |
| 1321 |
} |
| 1322 |
|
| 1323 |
/* replace a hex string in place with its value */ |
| 1324 |
static int unhexStr(char *hexstr) |
| 1325 |
{ |
| 1326 |
char *o = hexstr; |
| 1327 |
int len = 0, nibble1 = 0, nibble2 = 0; |
| 1328 |
if (!hexstr) return 0; |
| 1329 |
for ( ; *hexstr; hexstr++) { |
| 1330 |
if (isalpha((int)(unsigned char)(*hexstr))) { |
| 1331 |
nibble1 = tolower((int)(unsigned char)(*hexstr)) - 'a' + 10; |
| 1332 |
} else if (isdigit((int)(unsigned char)(*hexstr))) { |
| 1333 |
nibble1 = *hexstr - '0'; |
| 1334 |
} else { |
| 1335 |
printf("\nError: bad hex character '%c'\n", *hexstr); |
| 1336 |
} |
| 1337 |
if (!*++hexstr) break; |
| 1338 |
if (isalpha((int)(unsigned char)(*hexstr))) { |
| 1339 |
nibble2 = tolower((int)(unsigned char)(*hexstr)) - 'a' + 10; |
| 1340 |
} else if (isdigit((int)(unsigned char)(*hexstr))) { |
| 1341 |
nibble2 = *hexstr - '0'; |
| 1342 |
} else { |
| 1343 |
printf("\nError: bad hex character '%c'\n", *hexstr); |
| 1344 |
} |
| 1345 |
*o++ = (char)((nibble1 << 4) | nibble2); |
| 1346 |
len++; |
| 1347 |
} |
| 1348 |
return len; |
| 1349 |
} |
| 1350 |
|
| 1351 |
int main(int argc, char **argv) |
| 1352 |
{ |
| 1353 |
int i, err; |
| 1354 |
int loopno, loopnohigh = 1; |
| 1355 |
int hashno, hashnolow = 0, hashnohigh = HASHCOUNT - 1; |
| 1356 |
int testno, testnolow = 0, testnohigh; |
| 1357 |
int ntestnohigh = 0; |
| 1358 |
int printResults = PRINTTEXT; |
| 1359 |
int printPassFail = 1; |
| 1360 |
int checkErrors = 0; |
| 1361 |
char *hashstr = 0; |
| 1362 |
int hashlen = 0; |
| 1363 |
const char *resultstr = 0; |
| 1364 |
char *randomseedstr = 0; |
| 1365 |
int runHmacTests = 0; |
| 1366 |
int runHkdfTests = 0; |
| 1367 |
char *hmacKey = 0; |
| 1368 |
int hmaclen = 0; |
| 1369 |
char *info = 0; |
| 1370 |
int infolen = 0, okmlen = 0; |
| 1371 |
int randomcount = RANDOMCOUNT; |
| 1372 |
const char *hashfilename = 0; |
| 1373 |
const char *hashFilename = 0; |
| 1374 |
int extrabits = 0, numberExtrabits = 0; |
| 1375 |
int strIsHex = 0; |
| 1376 |
|
| 1377 |
if ('A' != 0x41) { |
| 1378 |
fprintf(stderr, "%s: these tests require ASCII\n", argv[0]); |
| 1379 |
} |
| 1380 |
|
| 1381 |
while ((i = getopt(argc, argv, |
| 1382 |
"6b:B:def:F:h:i:Hk:l:L:mpPr:R:s:S:t:wxX")) != -1) |
| 1383 |
switch (i) { |
| 1384 |
case 'b': extrabits = strtol(optarg, 0, 0); break; |
| 1385 |
case 'B': numberExtrabits = atoi(optarg); break; |
| 1386 |
case 'd': runHkdfTests = 1; break; |
| 1387 |
case 'e': checkErrors = 1; break; |
| 1388 |
case 'f': hashfilename = optarg; break; |
| 1389 |
case 'F': hashFilename = optarg; break; |
| 1390 |
case 'h': hashnolow = hashnohigh = findhash(argv[0], optarg); |
| 1391 |
break; |
| 1392 |
case 'H': strIsHex = 1; break; |
| 1393 |
case 'i': info = optarg; infolen = strlen(optarg); break; |
| 1394 |
case 'k': hmacKey = optarg; hmaclen = strlen(optarg); break; |
| 1395 |
case 'l': loopnohigh = atoi(optarg); break; |
| 1396 |
case 'L': okmlen = strtol(optarg, 0, 0); break; |
| 1397 |
case 'm': runHmacTests = 1; break; |
| 1398 |
case 'P': printPassFail = 0; break; |
| 1399 |
case 'p': printResults = PRINTNONE; break; |
| 1400 |
case 'R': randomcount = atoi(optarg); break; |
| 1401 |
case 'r': randomseedstr = optarg; break; |
| 1402 |
case 's': hashstr = optarg; hashlen = strlen(hashstr); break; |
| 1403 |
case 'S': resultstr = optarg; break; |
| 1404 |
case 't': testnolow = ntestnohigh = atoi(optarg) - 1; break; |
| 1405 |
case 'w': printResults = PRINTRAW; break; |
| 1406 |
case 'x': printResults = PRINTHEX; break; |
| 1407 |
case 'X': printPassFail = 2; break; |
| 1408 |
case '6': printResults = PRINTBASE64; break; |
| 1409 |
default: usage(argv[0]); |
| 1410 |
} |
| 1411 |
|
| 1412 |
if (strIsHex) { |
| 1413 |
hashlen = unhexStr(hashstr); |
| 1414 |
unhexStr(randomseedstr); |
| 1415 |
hmaclen = unhexStr(hmacKey); |
| 1416 |
infolen = unhexStr(info); |
| 1417 |
} |
| 1418 |
testnohigh = (ntestnohigh != 0) ? ntestnohigh: |
| 1419 |
runHmacTests ? (HMACTESTCOUNT-1) : |
| 1420 |
runHkdfTests ? (HKDFTESTCOUNT-1) : |
| 1421 |
(TESTCOUNT-1); |
| 1422 |
if ((testnolow < 0) || |
| 1423 |
(testnohigh >= (runHmacTests ? HMACTESTCOUNT : TESTCOUNT)) || |
| 1424 |
(hashnolow < 0) || (hashnohigh >= HASHCOUNT) || |
| 1425 |
(hashstr && (testnolow == testnohigh)) || |
| 1426 |
(randomcount < 0) || |
| 1427 |
(resultstr && (!hashstr && !hashfilename && !hashFilename)) || |
| 1428 |
((runHmacTests || hmacKey) && randomseedstr) || |
| 1429 |
(hashfilename && hashFilename) || |
| 1430 |
(info && ((infolen <= 0) || (okmlen <= 0))) || |
| 1431 |
(info && !hmacKey)) |
| 1432 |
usage(argv[0]); |
| 1433 |
|
| 1434 |
/* |
| 1435 |
* Perform SHA/HMAC tests |
| 1436 |
*/ |
| 1437 |
for (hashno = hashnolow; hashno <= hashnohigh; ++hashno) { |
| 1438 |
if (printResults == PRINTTEXT) |
| 1439 |
printf("Hash %s\n", hashes[hashno].name); |
| 1440 |
err = shaSuccess; |
| 1441 |
|
| 1442 |
for (loopno = 1; (loopno <= loopnohigh) && (err == shaSuccess); |
| 1443 |
++loopno) { |
| 1444 |
if (hashstr) |
| 1445 |
err = hash(0, loopno, hashno, hashstr, hashlen, 1, |
| 1446 |
numberExtrabits, extrabits, (const unsigned char *)hmacKey, |
| 1447 |
hmaclen, (const uint8_t *) info, infolen, okmlen, resultstr, |
| 1448 |
hashes[hashno].hashsize, printResults, printPassFail); |
| 1449 |
|
| 1450 |
else if (randomseedstr) |
| 1451 |
randomtest(hashno, randomseedstr, hashes[hashno].hashsize, 0, |
| 1452 |
randomcount, printResults, printPassFail); |
| 1453 |
|
| 1454 |
else if (hashfilename) |
| 1455 |
err = hashfile(hashno, hashfilename, extrabits, |
| 1456 |
numberExtrabits, 0, |
| 1457 |
(const unsigned char *)hmacKey, hmaclen, |
| 1458 |
(const uint8_t *) info, infolen, okmlen, |
| 1459 |
resultstr, hashes[hashno].hashsize, |
| 1460 |
printResults, printPassFail); |
| 1461 |
|
| 1462 |
else if (hashFilename) |
| 1463 |
err = hashfile(hashno, hashFilename, extrabits, |
| 1464 |
numberExtrabits, 1, |
| 1465 |
(const unsigned char *)hmacKey, hmaclen, |
| 1466 |
(const uint8_t *) info, infolen, okmlen, |
| 1467 |
resultstr, hashes[hashno].hashsize, |
| 1468 |
printResults, printPassFail); |
| 1469 |
|
| 1470 |
else /* standard tests */ { |
| 1471 |
for (testno = testnolow; |
| 1472 |
(testno <= testnohigh) && (err == shaSuccess); ++testno) { |
| 1473 |
if (runHmacTests) { |
| 1474 |
err = hash(testno, loopno, hashno, |
| 1475 |
hmachashes[testno].dataarray[hashno] ? |
| 1476 |
hmachashes[testno].dataarray[hashno] : |
| 1477 |
hmachashes[testno].dataarray[1] ? |
| 1478 |
hmachashes[testno].dataarray[1] : |
| 1479 |
hmachashes[testno].dataarray[0], |
| 1480 |
hmachashes[testno].datalength[hashno] ? |
| 1481 |
hmachashes[testno].datalength[hashno] : |
| 1482 |
hmachashes[testno].datalength[1] ? |
| 1483 |
hmachashes[testno].datalength[1] : |
| 1484 |
hmachashes[testno].datalength[0], |
| 1485 |
1, 0, 0, |
| 1486 |
(const unsigned char *)( |
| 1487 |
hmachashes[testno].keyarray[hashno] ? |
| 1488 |
hmachashes[testno].keyarray[hashno] : |
| 1489 |
hmachashes[testno].keyarray[1] ? |
| 1490 |
hmachashes[testno].keyarray[1] : |
| 1491 |
hmachashes[testno].keyarray[0]), |
| 1492 |
hmachashes[testno].keylength[hashno] ? |
| 1493 |
hmachashes[testno].keylength[hashno] : |
| 1494 |
hmachashes[testno].keylength[1] ? |
| 1495 |
hmachashes[testno].keylength[1] : |
| 1496 |
hmachashes[testno].keylength[0], |
| 1497 |
0, 0, 0, |
| 1498 |
hmachashes[testno].resultarray[hashno], |
| 1499 |
hmachashes[testno].resultlength[hashno], |
| 1500 |
printResults, printPassFail); |
| 1501 |
} else if (runHkdfTests) { |
| 1502 |
err = hashHkdf(testno, loopno, hashno, |
| 1503 |
printResults, printPassFail); |
| 1504 |
} else { /* sha tests */ |
| 1505 |
err = hash(testno, loopno, hashno, |
| 1506 |
hashes[hashno].tests[testno].testarray, |
| 1507 |
hashes[hashno].tests[testno].length, |
| 1508 |
hashes[hashno].tests[testno].repeatcount, |
| 1509 |
hashes[hashno].tests[testno].numberExtrabits, |
| 1510 |
hashes[hashno].tests[testno].extrabits, |
| 1511 |
0, 0, 0, 0, 0, |
| 1512 |
hashes[hashno].tests[testno].resultarray, |
| 1513 |
hashes[hashno].hashsize, |
| 1514 |
printResults, printPassFail); |
| 1515 |
} |
| 1516 |
} |
| 1517 |
if (!runHmacTests && !runHkdfTests) { |
| 1518 |
randomtest(hashno, hashes[hashno].randomtest, |
| 1519 |
hashes[hashno].hashsize, hashes[hashno].randomresults, |
| 1520 |
RANDOMCOUNT, printResults, printPassFail); |
| 1521 |
} |
| 1522 |
} |
| 1523 |
} |
| 1524 |
} |
| 1525 |
|
| 1526 |
/* Test some error returns */ |
| 1527 |
if (checkErrors) { |
| 1528 |
testErrors(hashnolow, hashnohigh, printResults, printPassFail); |
| 1529 |
} |
| 1530 |
|
| 1531 |
return 0; |
| 1532 |
} |
| 1533 |
|
| 1534 |
/* |
| 1535 |
* Compare two strings, case independently. |
| 1536 |
* Equivalent to strcasecmp() found on some systems. |
| 1537 |
*/ |
| 1538 |
int scasecmp(const char *s1, const char *s2) |
| 1539 |
{ |
| 1540 |
for (;;) { |
| 1541 |
char u1 = tolower((int)(unsigned char)(*s1++)); |
| 1542 |
char u2 = tolower((int)(unsigned char)(*s2++)); |
| 1543 |
if (u1 != u2) |
| 1544 |
return u1 - u2; |
| 1545 |
if (u1 == '\0') |
| 1546 |
return 0; |
| 1547 |
} |
| 1548 |
} |