test_sha256.c (20459B)
1 /* 2 This file is part of libmicrohttpd 3 Copyright (C) 2019-2023 Evgeny Grin (Karlson2k) 4 5 This test tool is free software; you can redistribute it and/or 6 modify it under the terms of the GNU General Public License as 7 published by the Free Software Foundation; either version 2, or 8 (at your option) any later version. 9 10 This test tool is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public 16 License along with this library; if not, write to the Free Software 17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 18 */ 19 20 /** 21 * @file microhttpd/test_sha256.h 22 * @brief Unit tests for SHA-256 functions 23 * @author Karlson2k (Evgeny Grin) 24 */ 25 26 #include "mhd_options.h" 27 #include "mhd_sha256_wrap.h" 28 #include "test_helpers.h" 29 #include <stdio.h> 30 #include <stdlib.h> 31 32 #if defined(MHD_SHA256_TLSLIB) && defined(MHD_HTTPS_REQUIRE_GCRYPT) 33 #define NEED_GCRYP_INIT 1 34 #include <gcrypt.h> 35 #endif /* MHD_SHA256_TLSLIB && MHD_HTTPS_REQUIRE_GCRYPT */ 36 37 static int verbose = 0; /* verbose level (0-1)*/ 38 39 40 struct str_with_len 41 { 42 const char *const str; 43 const size_t len; 44 }; 45 46 #define D_STR_W_LEN(s) {(s), (sizeof((s)) / sizeof(char)) - 1} 47 48 struct data_unit1 49 { 50 const struct str_with_len str_l; 51 const uint8_t digest[SHA256_DIGEST_SIZE]; 52 }; 53 54 static const struct data_unit1 data_units1[] = { 55 {D_STR_W_LEN ("abc"), 56 {0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde, 57 0x5d, 0xae, 0x22, 0x23, 58 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61, 59 0xf2, 0x00, 0x15, 0xad}}, 60 {D_STR_W_LEN ("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"), 61 {0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8, 0xe5, 0xc0, 0x26, 0x93, 62 0x0c, 0x3e, 0x60, 0x39, 63 0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67, 0xf6, 0xec, 0xed, 0xd4, 64 0x19, 0xdb, 0x06, 0xc1}}, 65 {D_STR_W_LEN (""), 66 {0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 67 0x99, 0x6f, 0xb9, 0x24, 68 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 69 0x78, 0x52, 0xb8, 0x55}}, 70 {D_STR_W_LEN ("1234567890!@~%&$@#{}[]\\/!?`."), 71 {0x2f, 0xad, 0x7a, 0xff, 0x7d, 0xfe, 0xcd, 0x78, 0xe4, 0xa6, 0xf3, 0x85, 72 0x97, 0x9d, 0xdc, 0x39, 73 0x55, 0x24, 0x35, 0x4a, 0x00, 0x6f, 0x42, 0x72, 0x41, 0xc1, 0x52, 0xa7, 74 0x01, 0x0b, 0x2c, 0x41}}, 75 {D_STR_W_LEN ("Simple string."), 76 {0x01, 0x73, 0x17, 0xc4, 0x0a, 0x9a, 0x0e, 0x81, 0xb3, 0xa4, 0xb1, 0x8e, 77 0xe9, 0xd6, 0xc2, 0xdf, 78 0xfa, 0x7d, 0x53, 0x4e, 0xa1, 0xda, 0xb2, 0x5a, 0x75, 0xbb, 0x2c, 0x30, 79 0x2f, 0x5f, 0x7a, 0xf4}}, 80 {D_STR_W_LEN ("abcdefghijklmnopqrstuvwxyz"), 81 {0x71, 0xc4, 0x80, 0xdf, 0x93, 0xd6, 0xae, 0x2f, 0x1e, 0xfa, 0xd1, 0x44, 82 0x7c, 0x66, 0xc9, 0x52, 83 0x5e, 0x31, 0x62, 0x18, 0xcf, 0x51, 0xfc, 0x8d, 0x9e, 0xd8, 0x32, 0xf2, 84 0xda, 0xf1, 0x8b, 0x73}}, 85 {D_STR_W_LEN ("zyxwvutsrqponMLKJIHGFEDCBA"), 86 {0xce, 0x7d, 0xde, 0xb6, 0x1f, 0x7c, 0x1d, 0x83, 0x7c, 0x60, 0xd8, 0x36, 87 0x73, 0x82, 0xac, 0x92, 88 0xca, 0x37, 0xfd, 0x72, 0x8b, 0x0c, 0xd1, 0x6c, 0x55, 0xd5, 0x88, 0x98, 89 0x24, 0xfa, 0x16, 0xf2}}, 90 {D_STR_W_LEN ("abcdefghijklmnopqrstuvwxyzzyxwvutsrqponMLKJIHGFEDCBA" \ 91 "abcdefghijklmnopqrstuvwxyzzyxwvutsrqponMLKJIHGFEDCBA"), 92 {0x27, 0xd1, 0xe8, 0xbc, 0x6a, 0x79, 0x16, 0x83, 0x61, 0x73, 0xa9, 0xa8, 93 0x9b, 0xaf, 0xaf, 0xcf, 94 0x47, 0x4d, 0x09, 0xef, 0x6d, 0x50, 0x35, 0x12, 0x25, 0x72, 0xd8, 0x68, 95 0xdc, 0x1f, 0xd2, 0xf4}}, 96 {D_STR_W_LEN ("/long/long/long/long/long/long/long/long/long/long/long" \ 97 "/long/long/long/long/long/long/long/long/long/long/long" \ 98 "/long/long/long/long/long/long/long/long/long/long/long" \ 99 "/long/long/long/long/long/long/long/long/long/long/long" \ 100 "/long/long/long/long/long/long/long/long/long/long/long" \ 101 "/long/long/long/long/long/long/long/long/long/long/long" \ 102 "/long/long/long/long/path?with%20some=parameters"), 103 {0x73, 0x85, 0xc5, 0xb9, 0x8f, 0xaf, 0x7d, 0x5e, 0xad, 0xd8, 0x0b, 0x8e, 104 0x12, 0xdb, 0x28, 0x60, 0xc7, 0xc7, 0x55, 0x05, 0x2f, 0x7c, 0x6f, 0xfa, 105 0xd1, 0xe3, 0xe1, 0x7b, 0x04, 0xd4, 0xb0, 0x21}} 106 }; 107 108 static const size_t units1_num = sizeof(data_units1) / sizeof(data_units1[0]); 109 110 struct bin_with_len 111 { 112 const uint8_t bin[512]; 113 const size_t len; 114 }; 115 116 struct data_unit2 117 { 118 const struct bin_with_len bin_l; 119 const uint8_t digest[SHA256_DIGEST_SIZE]; 120 }; 121 122 /* Size must be less than 512 bytes! */ 123 static const struct data_unit2 data_units2[] = { 124 { { {97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 125 112, 113, 114, 115, 116, 126 117, 118, 119, 120, 121, 122}, 26}, /* a..z ASCII sequence */ 127 {0x71, 0xc4, 0x80, 0xdf, 0x93, 0xd6, 0xae, 0x2f, 0x1e, 0xfa, 0xd1, 0x44, 128 0x7c, 0x66, 0xc9, 0x52, 129 0x5e, 0x31, 0x62, 0x18, 0xcf, 0x51, 0xfc, 0x8d, 0x9e, 0xd8, 0x32, 0xf2, 130 0xda, 0xf1, 0x8b, 0x73}}, 131 { { {65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 132 65, 65, 65, 65, 65, 65, 133 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 134 65, 65, 65, 65, 65, 65, 135 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 136 65, 65, 65, 65, 65, 65}, 72 },/* 'A' x 72 times */ 137 {0x6a, 0x6d, 0x69, 0x1a, 0xc9, 0xba, 0x70, 0x95, 0x50, 0x46, 0x75, 0x7c, 138 0xd6, 0x85, 0xb6, 0x25, 139 0x77, 0x73, 0xff, 0x3a, 0xd9, 0x3f, 0x43, 0xd4, 0xd4, 0x81, 0x2c, 0x5b, 140 0x10, 0x6f, 0x4b, 0x5b}}, 141 { { {19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 142 37, 38, 39, 40, 41, 42, 143 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 144 61, 62, 63, 64, 65, 66, 67, 145 68, 69, 70, 71, 72, 73}, 55}, /* 19..73 sequence */ 146 {0x06, 0xe4, 0xb3, 0x9e, 0xf1, 0xfb, 0x6c, 0xcf, 0xd7, 0x3f, 0x50, 0x9e, 147 0xf4, 0x16, 0x17, 0xd4, 148 0x63, 0x7c, 0x39, 0x1e, 0xa8, 0x0f, 0xa9, 0x88, 0x03, 0x44, 0x98, 0x0e, 149 0x95, 0x81, 0xf0, 0x2a}}, 150 { { {7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 151 26, 27, 28, 29, 30, 31, 152 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 153 50, 51, 52, 53, 54, 55, 56, 154 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69}, 63}, /* 7..69 sequence */ 155 {0x4a, 0xd3, 0xc6, 0x87, 0x1f, 0xd1, 0xc5, 0xe2, 0x3e, 0x52, 0xdc, 0x22, 156 0xd1, 0x10, 0xd2, 0x05, 157 0x15, 0x23, 0xcd, 0x15, 0xac, 0x24, 0x88, 0x26, 0x02, 0x00, 0x70, 0x78, 158 0x9f, 0x17, 0xf8, 0xd9}}, 159 { { {38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 160 56, 57, 58, 59, 60, 61, 161 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 162 80, 81, 82, 83, 84, 85, 86, 163 87, 88, 89, 90, 91, 92}, 55}, /* 38..92 sequence */ 164 {0xe6, 0x03, 0x0f, 0xc9, 0x0d, 0xca, 0x0c, 0x26, 0x41, 0xcf, 0x43, 0x27, 165 0xec, 0xd6, 0x28, 0x2a, 166 0x98, 0x24, 0x55, 0xd3, 0x5a, 0xed, 0x8b, 0x32, 0x19, 0x78, 0xeb, 0x83, 167 0x1d, 0x19, 0x92, 0x79}}, 168 { { {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 169 21, 22, 23, 24, 25, 26, 27, 170 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 171 46, 47, 48, 49, 50, 51, 52, 172 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 173 71, 72}, 174 72},/* 1..72 sequence */ 175 {0x87, 0xa2, 0xfa, 0x2e, 0xec, 0x53, 0x05, 0x3c, 0xb1, 0xee, 0x07, 0xd7, 176 0x59, 0x70, 0xf6, 0x50, 177 0xcd, 0x9d, 0xc5, 0x8b, 0xdc, 0xb8, 0x65, 0x30, 0x4f, 0x70, 0x82, 0x9e, 178 0xbd, 0xe2, 0x7d, 0xac}}, 179 { { {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 180 21, 22, 23, 24, 25, 26, 181 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 182 45, 46, 47, 48, 49, 50, 51, 183 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 184 70, 71, 72, 73, 74, 75, 76, 185 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 186 95, 96, 97, 98, 99, 100, 187 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 188 115, 116, 117, 118, 119, 120, 189 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 190 135, 136, 137, 138, 139, 140, 191 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 192 155, 156, 157, 158, 159, 160, 193 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 194 175, 176, 177, 178, 179, 180, 195 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 196 195, 196, 197, 198, 199, 200, 197 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 198 215, 216, 217, 218, 219, 220, 199 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 200 235, 236, 237, 238, 239, 240, 201 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 202 255}, 256}, /* 0..255 sequence */ 203 {0x40, 0xaf, 0xf2, 0xe9, 0xd2, 0xd8, 0x92, 0x2e, 0x47, 0xaf, 0xd4, 0x64, 204 0x8e, 0x69, 0x67, 0x49, 205 0x71, 0x58, 0x78, 0x5f, 0xbd, 0x1d, 0xa8, 0x70, 0xe7, 0x11, 0x02, 0x66, 206 0xbf, 0x94, 0x48, 0x80}}, 207 { { {199, 198, 197, 196, 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, 208 185, 184, 183, 182, 181, 180, 209 179, 178, 177, 176, 175, 174, 173, 172, 171, 170, 169, 168, 167, 166, 210 165, 164, 163, 162, 161, 160, 211 159, 158, 157, 156, 155, 154, 153, 152, 151, 150, 149, 148, 147, 146, 212 145, 144, 143, 142, 141, 140, 213 139}, 61}, /* 199..139 sequence */ 214 {0x85, 0xf8, 0xa2, 0x83, 0xd6, 0x3c, 0x76, 0x8e, 0xea, 0x8f, 0x1c, 0x57, 215 0x2d, 0x85, 0xb6, 0xff, 216 0xd8, 0x33, 0x57, 0x62, 0x1d, 0x37, 0xae, 0x0e, 0xfc, 0x22, 0xd3, 0xd5, 217 0x8f, 0x53, 0x21, 0xb7}}, 218 { { {255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 219 241, 240, 239, 238, 237, 236, 220 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 224, 223, 222, 221 221, 220, 219, 218, 217, 216, 222 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, 223 201, 200, 199, 198, 197, 196, 224 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, 183, 182, 225 181, 180, 179, 178, 177, 176, 226 175, 174, 173, 172, 171, 170, 169, 168, 167, 166, 165, 164, 163, 162, 227 161, 160, 159, 158, 157, 156, 228 155, 154, 153, 152, 151, 150, 149, 148, 147, 146, 145, 144, 143, 142, 229 141, 140, 139, 138, 137, 136, 230 135, 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 231 121, 120, 119, 118, 117, 116, 232 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 102, 233 101, 100, 99, 98, 97, 96, 95, 234 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 235 76, 75, 74, 73, 72, 71, 70, 236 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 237 51, 50, 49, 48, 47, 46, 45, 238 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 239 26, 25, 24, 23, 22, 21, 20, 240 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}, 255}, /* 255..1 sequence */ 241 {0x61, 0x86, 0x96, 0xab, 0x3e, 0xaa, 0x0e, 0x64, 0xb2, 0xf7, 0x2d, 0x75, 242 0x47, 0x5a, 0x14, 0x97, 243 0xa3, 0x3d, 0x59, 0xa4, 0x08, 0xd9, 0x9e, 0x73, 0xf2, 0x78, 0x00, 0x5b, 244 0x4b, 0x55, 0xca, 0x43}}, 245 { { {41, 35, 190, 132, 225, 108, 214, 174, 82, 144, 73, 241, 241, 187, 233, 246 235, 179, 166, 219, 60, 135, 247 12, 62, 153, 36, 94, 13, 28, 6, 183, 71, 222, 179, 18, 77, 200, 67, 187, 248 139, 166, 31, 3, 90, 125, 9, 249 56, 37, 31, 93, 212, 203, 252, 150, 245, 69, 59, 19, 13, 137, 10, 28, 250 219, 174, 50, 32, 154, 80, 238, 251 64, 120, 54, 253, 18, 73, 50, 246, 158, 125, 73, 220, 173, 79, 20, 242, 252 68, 64, 102, 208, 107, 196, 253 48, 183, 50, 59, 161, 34, 246, 34, 145, 157, 225, 139, 31, 218, 176, 202, 254 153, 2, 185, 114, 157, 73, 255 44, 128, 126, 197, 153, 213, 233, 128, 178, 234, 201, 204, 83, 191, 103, 256 214, 191, 20, 214, 126, 45, 257 220, 142, 102, 131, 239, 87, 73, 97, 255, 105, 143, 97, 205, 209, 30, 258 157, 156, 22, 114, 114, 230, 259 29, 240, 132, 79, 74, 119, 2, 215, 232, 57, 44, 83, 203, 201, 18, 30, 51, 260 116, 158, 12, 244, 213, 261 212, 159, 212, 164, 89, 126, 53, 207, 50, 34, 244, 204, 207, 211, 144, 262 45, 72, 211, 143, 117, 230, 263 217, 29, 42, 229, 192, 247, 43, 120, 129, 135, 68, 14, 95, 80, 0, 212, 264 97, 141, 190, 123, 5, 21, 7, 265 59, 51, 130, 31, 24, 112, 146, 218, 100, 84, 206, 177, 133, 62, 105, 21, 266 248, 70, 106, 4, 150, 115, 267 14, 217, 22, 47, 103, 104, 212, 247, 74, 74, 208, 87, 104}, 255}, /* pseudo-random data */ 268 {0x08, 0x7f, 0x86, 0xac, 0xe2, 0x2e, 0x28, 0x56, 0x74, 0x53, 0x4f, 0xc0, 269 0xfb, 0xb8, 0x79, 0x57, 270 0xc5, 0xc8, 0xd1, 0xb7, 0x47, 0xb7, 0xd9, 0xea, 0x97, 0xa8, 0x67, 0xe9, 271 0x26, 0x93, 0xee, 0xa3}} 272 }; 273 274 static const size_t units2_num = sizeof(data_units2) / sizeof(data_units2[0]); 275 276 277 /* 278 * Helper functions 279 */ 280 281 /** 282 * Print bin as hex 283 * 284 * @param bin binary data 285 * @param len number of bytes in bin 286 * @param hex pointer to len*2+1 bytes buffer 287 */ 288 static void 289 bin2hex (const uint8_t *bin, 290 size_t len, 291 char *hex) 292 { 293 while (len-- > 0) 294 { 295 unsigned int b1, b2; 296 b1 = (*bin >> 4) & 0xf; 297 *hex++ = (char) ((b1 > 9) ? (b1 + 'A' - 10) : (b1 + '0')); 298 b2 = *bin++ & 0xf; 299 *hex++ = (char) ((b2 > 9) ? (b2 + 'A' - 10) : (b2 + '0')); 300 } 301 *hex = 0; 302 } 303 304 305 static int 306 check_result (const char *test_name, 307 unsigned int check_num, 308 const uint8_t calculated[SHA256_DIGEST_SIZE], 309 const uint8_t expected[SHA256_DIGEST_SIZE]) 310 { 311 int failed = memcmp (calculated, expected, SHA256_DIGEST_SIZE); 312 check_num++; /* Print 1-based numbers */ 313 if (failed) 314 { 315 char calc_str[SHA256_DIGEST_STRING_SIZE]; 316 char expc_str[SHA256_DIGEST_STRING_SIZE]; 317 bin2hex (calculated, SHA256_DIGEST_SIZE, calc_str); 318 bin2hex (expected, SHA256_DIGEST_SIZE, expc_str); 319 fprintf (stderr, 320 "FAILED: %s check %u: calculated digest %s, expected digest %s.\n", 321 test_name, check_num, calc_str, expc_str); 322 fflush (stderr); 323 } 324 else if (verbose) 325 { 326 char calc_str[SHA256_DIGEST_STRING_SIZE]; 327 bin2hex (calculated, SHA256_DIGEST_SIZE, calc_str); 328 printf ("PASSED: %s check %u: calculated digest %s " 329 "matches expected digest.\n", 330 test_name, check_num, calc_str); 331 fflush (stdout); 332 } 333 return failed ? 1 : 0; 334 } 335 336 337 /* 338 * Tests 339 */ 340 341 /* Calculated SHA-256 as one pass for whole data */ 342 static int 343 test1_str (void) 344 { 345 int num_failed = 0; 346 unsigned int i; 347 struct Sha256CtxWr ctx; 348 349 MHD_SHA256_init_one_time (&ctx); 350 for (i = 0; i < units1_num; i++) 351 { 352 uint8_t digest[SHA256_DIGEST_SIZE]; 353 354 MHD_SHA256_update (&ctx, (const uint8_t *) data_units1[i].str_l.str, 355 data_units1[i].str_l.len); 356 MHD_SHA256_finish_reset (&ctx, digest); 357 #ifdef MHD_SHA256_HAS_EXT_ERROR 358 if (0 != ctx.ext_error) 359 { 360 fprintf (stderr, "External hashing error: %d.\n", ctx.ext_error); 361 exit (99); 362 } 363 #endif /* MHD_SHA256_HAS_EXT_ERROR */ 364 num_failed += check_result (MHD_FUNC_, i, digest, 365 data_units1[i].digest); 366 } 367 MHD_SHA256_deinit (&ctx); 368 return num_failed; 369 } 370 371 372 static int 373 test1_bin (void) 374 { 375 int num_failed = 0; 376 unsigned int i; 377 struct Sha256CtxWr ctx; 378 379 MHD_SHA256_init_one_time (&ctx); 380 for (i = 0; i < units2_num; i++) 381 { 382 uint8_t digest[SHA256_DIGEST_SIZE]; 383 384 MHD_SHA256_update (&ctx, data_units2[i].bin_l.bin, 385 data_units2[i].bin_l.len); 386 MHD_SHA256_finish_reset (&ctx, digest); 387 #ifdef MHD_SHA256_HAS_EXT_ERROR 388 if (0 != ctx.ext_error) 389 { 390 fprintf (stderr, "External hashing error: %d.\n", ctx.ext_error); 391 exit (99); 392 } 393 #endif /* MHD_SHA256_HAS_EXT_ERROR */ 394 num_failed += check_result (MHD_FUNC_, i, digest, 395 data_units2[i].digest); 396 } 397 MHD_SHA256_deinit (&ctx); 398 return num_failed; 399 } 400 401 402 /* Calculated SHA-256 as two iterations for whole data */ 403 static int 404 test2_str (void) 405 { 406 int num_failed = 0; 407 unsigned int i; 408 struct Sha256CtxWr ctx; 409 410 MHD_SHA256_init_one_time (&ctx); 411 for (i = 0; i < units1_num; i++) 412 { 413 uint8_t digest[SHA256_DIGEST_SIZE]; 414 size_t part_s = data_units1[i].str_l.len / 4; 415 416 MHD_SHA256_update (&ctx, (const uint8_t *) "", 0); 417 MHD_SHA256_update (&ctx, (const uint8_t *) data_units1[i].str_l.str, 418 part_s); 419 MHD_SHA256_update (&ctx, (const uint8_t *) "", 0); 420 MHD_SHA256_update (&ctx, (const uint8_t *) data_units1[i].str_l.str 421 + part_s, 422 data_units1[i].str_l.len - part_s); 423 MHD_SHA256_update (&ctx, (const uint8_t *) "", 0); 424 MHD_SHA256_finish_reset (&ctx, digest); 425 #ifdef MHD_SHA256_HAS_EXT_ERROR 426 if (0 != ctx.ext_error) 427 { 428 fprintf (stderr, "External hashing error: %d.\n", ctx.ext_error); 429 exit (99); 430 } 431 #endif /* MHD_SHA256_HAS_EXT_ERROR */ 432 num_failed += check_result (MHD_FUNC_, i, digest, 433 data_units1[i].digest); 434 } 435 MHD_SHA256_deinit (&ctx); 436 return num_failed; 437 } 438 439 440 static int 441 test2_bin (void) 442 { 443 int num_failed = 0; 444 unsigned int i; 445 struct Sha256CtxWr ctx; 446 447 MHD_SHA256_init_one_time (&ctx); 448 for (i = 0; i < units2_num; i++) 449 { 450 uint8_t digest[SHA256_DIGEST_SIZE]; 451 size_t part_s = data_units2[i].bin_l.len * 2 / 3; 452 453 MHD_SHA256_update (&ctx, data_units2[i].bin_l.bin, part_s); 454 MHD_SHA256_update (&ctx, (const uint8_t *) "", 0); 455 MHD_SHA256_update (&ctx, data_units2[i].bin_l.bin + part_s, 456 data_units2[i].bin_l.len - part_s); 457 MHD_SHA256_finish_reset (&ctx, digest); 458 #ifdef MHD_SHA256_HAS_EXT_ERROR 459 if (0 != ctx.ext_error) 460 { 461 fprintf (stderr, "External hashing error: %d.\n", ctx.ext_error); 462 exit (99); 463 } 464 #endif /* MHD_SHA256_HAS_EXT_ERROR */ 465 num_failed += check_result (MHD_FUNC_, i, digest, 466 data_units2[i].digest); 467 } 468 MHD_SHA256_deinit (&ctx); 469 return num_failed; 470 } 471 472 473 /* Use data set number 7 as it has the longest sequence */ 474 #define DATA_POS 6 475 #define MAX_OFFSET 31 476 477 static int 478 test_unaligned (void) 479 { 480 int num_failed = 0; 481 unsigned int offset; 482 uint8_t *buf; 483 uint8_t *digest_buf; 484 struct Sha256CtxWr ctx; 485 486 const struct data_unit2 *const tdata = data_units2 + DATA_POS; 487 488 MHD_SHA256_init_one_time (&ctx); 489 buf = malloc (tdata->bin_l.len + MAX_OFFSET); 490 digest_buf = malloc (SHA256_DIGEST_SIZE + MAX_OFFSET); 491 if ((NULL == buf) || (NULL == digest_buf)) 492 exit (99); 493 494 for (offset = MAX_OFFSET; offset >= 1; --offset) 495 { 496 uint8_t *unaligned_digest; 497 uint8_t *unaligned_buf; 498 499 unaligned_buf = buf + offset; 500 memcpy (unaligned_buf, tdata->bin_l.bin, tdata->bin_l.len); 501 unaligned_digest = digest_buf + MAX_OFFSET - offset; 502 memset (unaligned_digest, 0, SHA256_DIGEST_SIZE); 503 504 MHD_SHA256_update (&ctx, unaligned_buf, tdata->bin_l.len); 505 MHD_SHA256_finish_reset (&ctx, unaligned_digest); 506 #ifdef MHD_SHA256_HAS_EXT_ERROR 507 if (0 != ctx.ext_error) 508 { 509 fprintf (stderr, "External hashing error: %d.\n", ctx.ext_error); 510 exit (99); 511 } 512 #endif /* MHD_SHA256_HAS_EXT_ERROR */ 513 num_failed += check_result (MHD_FUNC_, MAX_OFFSET - offset, 514 unaligned_digest, tdata->digest); 515 } 516 free (digest_buf); 517 free (buf); 518 MHD_SHA256_deinit (&ctx); 519 return num_failed; 520 } 521 522 523 int 524 main (int argc, char *argv[]) 525 { 526 int num_failed = 0; 527 (void) has_in_name; /* Mute compiler warning. */ 528 if (has_param (argc, argv, "-v") || has_param (argc, argv, "--verbose")) 529 verbose = 1; 530 531 #ifdef NEED_GCRYP_INIT 532 gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0); 533 #ifdef GCRYCTL_INITIALIZATION_FINISHED 534 gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0); 535 #endif /* GCRYCTL_INITIALIZATION_FINISHED */ 536 #endif /* NEED_GCRYP_INIT */ 537 538 num_failed += test1_str (); 539 num_failed += test1_bin (); 540 541 num_failed += test2_str (); 542 num_failed += test2_bin (); 543 544 num_failed += test_unaligned (); 545 546 return num_failed ? 1 : 0; 547 }