[efi] Include installed protocol list in unknown handle names
[ipxe.git] / src / tests / hmac_drbg_test.c
1 /*
2 * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of the
7 * License, or any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA.
18 *
19 * You can also choose to distribute this program under the terms of
20 * the Unmodified Binary Distribution Licence (as given in the file
21 * COPYING.UBDL), provided that you have satisfied its requirements.
22 */
23
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25
26 /** @file
27 *
28 * HMAC_DRBG tests
29 *
30 * These test vectors are provided by NIST as part of the
31 * Cryptographic Toolkit Examples, downloadable from:
32 *
33 * http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/HMAC_DRBG.pdf
34 *
35 */
36
37 /* Forcibly enable assertions */
38 #undef NDEBUG
39
40 #include <assert.h>
41 #include <string.h>
42 #include <ipxe/hmac_drbg.h>
43 #include <ipxe/sha1.h>
44 #include <ipxe/sha256.h>
45 #include <ipxe/test.h>
46
47 /** Define inline expected data */
48 #define EXPECT(...) { __VA_ARGS__ }
49
50 /** An HMAC_DRBG instantiation test */
51 struct hmac_drbg_test_instantiate {
52 /** Underlying hash algorithm */
53 struct digest_algorithm *hash;
54 /** Output block length */
55 size_t out_len;
56 /** Entropy */
57 const void *entropy;
58 /** Length of entropy */
59 size_t entropy_len;
60 /** Nonce */
61 const void *nonce;
62 /** Length of nonce */
63 size_t nonce_len;
64 /** Personalisation string */
65 const void *personal;
66 /** Length of personalisation string */
67 size_t personal_len;
68 /** Expected key */
69 const void *expected_key;
70 /** Length of expected key */
71 size_t expected_key_len;
72 /** Expected value */
73 const void *expected_value;
74 /** Length of expected value */
75 size_t expected_value_len;
76 };
77
78 /**
79 * Define an HMAC_DRBG instantiation test
80 *
81 * @v name Test name
82 * @v hmac_drbg HMAC_DRBG algorithm
83 * @v entropy_array Entropy input
84 * @v nonce_array Nonce
85 * @v personal_array Personalisation string
86 * @v key Expected key
87 * @v value Expected value
88 * @ret test Instantiation test
89 */
90 #define HMAC_DRBG_TEST_INSTANTIATE( name, hmac_drbg, entropy_array, \
91 nonce_array, personal_array, \
92 key, value ) \
93 static const uint8_t name ## _key [] = key; \
94 static const uint8_t name ## _value [] = value; \
95 static struct hmac_drbg_test_instantiate name = { \
96 .hash = HMAC_DRBG_HASH ( hmac_drbg ), \
97 .out_len = HMAC_DRBG_OUTLEN_BYTES ( hmac_drbg ), \
98 .entropy = entropy_array, \
99 .entropy_len = sizeof ( entropy_array ), \
100 .nonce = nonce_array, \
101 .nonce_len = sizeof ( nonce_array ), \
102 .personal = personal_array, \
103 .personal_len = sizeof ( personal_array ), \
104 .expected_key = name ## _key, \
105 .expected_key_len = sizeof ( name ## _key ), \
106 .expected_value = name ## _value, \
107 .expected_value_len = sizeof ( name ## _value ), \
108 }
109
110 /**
111 * Report instantiation test result
112 *
113 * @v state HMAC_DRBG internal state
114 * @v test Instantiation test
115 */
116 #define instantiate_ok( state, test ) do { \
117 struct { \
118 uint8_t entropy[(test)->entropy_len]; \
119 uint8_t nonce[(test)->nonce_len]; \
120 } __attribute__ (( packed )) entropy_nonce; \
121 \
122 assert ( (test)->expected_key_len == (test)->out_len ); \
123 assert ( (test)->expected_value_len == (test)->out_len ); \
124 memcpy ( entropy_nonce.entropy, (test)->entropy, \
125 sizeof ( entropy_nonce.entropy ) ); \
126 memcpy ( entropy_nonce.nonce, (test)->nonce, \
127 sizeof ( entropy_nonce.nonce ) ); \
128 hmac_drbg_instantiate ( (test)->hash, (state), &entropy_nonce, \
129 sizeof ( entropy_nonce ), \
130 (test)->personal, \
131 (test)->personal_len ); \
132 ok ( memcmp ( (state)->key, (test)->expected_key, \
133 (test)->expected_key_len ) == 0 ); \
134 ok ( memcmp ( (state)->value, (test)->expected_value, \
135 (test)->expected_value_len ) == 0 ); \
136 } while ( 0 )
137
138 /** An HMAC_DRBG reseed test */
139 struct hmac_drbg_test_reseed {
140 /** Underlying hash algorithm */
141 struct digest_algorithm *hash;
142 /** Output block length */
143 size_t out_len;
144 /** Entropy */
145 const void *entropy;
146 /** Length of entropy */
147 size_t entropy_len;
148 /** Additional input */
149 const void *additional;
150 /** Length of additional_input */
151 size_t additional_len;
152 /** Expected key */
153 const void *expected_key;
154 /** Length of expected key */
155 size_t expected_key_len;
156 /** Expected value */
157 const void *expected_value;
158 /** Length of expected value */
159 size_t expected_value_len;
160 };
161
162 /**
163 * Define an HMAC_DRBG reseed test
164 *
165 * @v name Test name
166 * @v hmac_drbg HMAC_DRBG algorithm
167 * @v entropy_array Entropy input
168 * @v additional_array Additional input
169 * @v key Expected key
170 * @v value Expected value
171 * @ret test Reseed test
172 */
173 #define HMAC_DRBG_TEST_RESEED( name, hmac_drbg, entropy_array, \
174 additional_array, key, value ) \
175 static const uint8_t name ## _key [] = key; \
176 static const uint8_t name ## _value [] = value; \
177 static struct hmac_drbg_test_reseed name = { \
178 .hash = HMAC_DRBG_HASH ( hmac_drbg ), \
179 .out_len = HMAC_DRBG_OUTLEN_BYTES ( hmac_drbg ), \
180 .entropy = entropy_array, \
181 .entropy_len = sizeof ( entropy_array ), \
182 .additional = additional_array, \
183 .additional_len = sizeof ( additional_array ), \
184 .expected_key = name ## _key, \
185 .expected_key_len = sizeof ( name ## _key ), \
186 .expected_value = name ## _value, \
187 .expected_value_len = sizeof ( name ## _value ), \
188 }
189
190 /**
191 * Report reseed test result
192 *
193 * @v state HMAC_DRBG internal state
194 * @v test Reseed test
195 */
196 #define reseed_ok( state, test ) do { \
197 assert ( (test)->expected_key_len == (test)->out_len ); \
198 assert ( (test)->expected_value_len == (test)->out_len ); \
199 hmac_drbg_reseed ( (test)->hash, (state), (test)->entropy, \
200 (test)->entropy_len, (test)->additional, \
201 (test)->additional_len ); \
202 ok ( memcmp ( (state)->key, (test)->expected_key, \
203 (test)->expected_key_len ) == 0 ); \
204 ok ( memcmp ( (state)->value, (test)->expected_value, \
205 (test)->expected_value_len ) == 0 ); \
206 } while ( 0 )
207
208 /** An HMAC_DRBG generation test */
209 struct hmac_drbg_test_generate {
210 /** Underlying hash algorithm */
211 struct digest_algorithm *hash;
212 /** Output block length */
213 size_t out_len;
214 /** Additional input */
215 const void *additional;
216 /** Length of additional_input */
217 size_t additional_len;
218 /** Expected key */
219 const void *expected_key;
220 /** Length of expected key */
221 size_t expected_key_len;
222 /** Expected value */
223 const void *expected_value;
224 /** Length of expected value */
225 size_t expected_value_len;
226 /** Expected pseudorandom data */
227 const void *expected_data;
228 /** Length of data */
229 size_t expected_data_len;
230 };
231
232 /**
233 * Define an HMAC_DRBG generation test
234 *
235 * @v name Test name
236 * @v hmac_drbg HMAC_DRBG algorithm
237 * @v additional_array Additional input
238 * @v key Expected key
239 * @v value Expected value
240 * @v data Expected pseudorandom data
241 * @ret test Generation test
242 */
243 #define HMAC_DRBG_TEST_GENERATE( name, hmac_drbg, additional_array, \
244 key, value, data ) \
245 static const uint8_t name ## _key [] = key; \
246 static const uint8_t name ## _value [] = value; \
247 static const uint8_t name ## _data [] = data; \
248 static struct hmac_drbg_test_generate name = { \
249 .hash = HMAC_DRBG_HASH ( hmac_drbg ), \
250 .out_len = HMAC_DRBG_OUTLEN_BYTES ( hmac_drbg ), \
251 .additional = additional_array, \
252 .additional_len = sizeof ( additional_array ), \
253 .expected_key = name ## _key, \
254 .expected_key_len = sizeof ( name ## _key ), \
255 .expected_value = name ## _value, \
256 .expected_value_len = sizeof ( name ## _value ), \
257 .expected_data = name ## _data, \
258 .expected_data_len = sizeof ( name ## _data ), \
259 }
260
261 /**
262 * Report generation test result
263 *
264 * @v state HMAC_DRBG internal state
265 * @v test Generation test
266 */
267 #define generate_ok( state, test ) do { \
268 uint8_t data[ (test)->expected_data_len ]; \
269 int rc; \
270 \
271 assert ( (test)->expected_key_len == (test)->out_len ); \
272 assert ( (test)->expected_value_len == (test)->out_len ); \
273 rc = hmac_drbg_generate ( (test)->hash, (state), \
274 (test)->additional, \
275 (test)->additional_len, \
276 data, sizeof ( data ) ); \
277 ok ( rc == 0 ); \
278 ok ( memcmp ( (state)->key, (test)->expected_key, \
279 (test)->expected_key_len ) == 0 ); \
280 ok ( memcmp ( (state)->value, (test)->expected_value, \
281 (test)->expected_value_len ) == 0 ); \
282 ok ( memcmp ( data, (test)->expected_data, \
283 (test)->expected_data_len ) == 0 ); \
284 } while ( 0 )
285
286 /** An HMAC_DRBG generation failure test */
287 struct hmac_drbg_test_generate_fail {
288 /** Underlying hash algorithm */
289 struct digest_algorithm *hash;
290 /** Additional input */
291 const void *additional;
292 /** Length of additional_input */
293 size_t additional_len;
294 /** Length of requested data */
295 size_t requested_len;
296 };
297
298 /**
299 * Define an HMAC_DRBG generation failure test
300 *
301 * @v name Test name
302 * @v hmac_drbg HMAC_DRBG algorithm
303 * @v additional_array Additional input
304 * @ret test Generation failure test
305 */
306 #define HMAC_DRBG_TEST_GENERATE_FAIL( name, hmac_drbg, \
307 additional_array, len ) \
308 static struct hmac_drbg_test_generate_fail name = { \
309 .hash = HMAC_DRBG_HASH ( hmac_drbg ), \
310 .additional = additional_array, \
311 .additional_len = sizeof ( additional_array ), \
312 .requested_len = len, \
313 }
314
315 /**
316 * Report generation failure test result
317 *
318 * @v state HMAC_DRBG internal state
319 * @v test Generation failure test
320 */
321 #define generate_fail_ok( state, test ) do { \
322 uint8_t data[ (test)->requested_len ]; \
323 int rc; \
324 \
325 rc = hmac_drbg_generate ( (test)->hash, (state), \
326 (test)->additional, \
327 (test)->additional_len, data, \
328 sizeof ( data ) ); \
329 ok ( rc != 0 ); \
330 } while ( 0 )
331
332 /** "EntropyInput" */
333 static const uint8_t entropy_input[] = {
334 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
335 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
336 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
337 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
338 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36
339 };
340
341 /** "Nonce" for SHA-1 */
342 static const uint8_t nonce_sha1[] = {
343 0x20, 0x21, 0x22, 0x23, 0x24
344 };
345
346 /** "Nonce" for SHA-256 */
347 static const uint8_t nonce_sha256[] = {
348 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27
349 };
350
351 /** "EntropyInput1 (for Reseed1) */
352 static const uint8_t entropy_input_1[] = {
353 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b,
354 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
355 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3,
356 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
357 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6
358 };
359
360 /** "EntropyInput2 (for Reseed2) */
361 static const uint8_t entropy_input_2[] = {
362 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb,
363 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
364 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3,
365 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
366 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6
367 };
368
369 /** "PersonalizationString = <empty>" */
370 static const uint8_t personalisation_string_empty[] = {};
371
372 /** "PersonalizationString" */
373 static const uint8_t personalisation_string[] = {
374 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b,
375 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
376 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
377 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
378 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76
379 };
380
381 /** "AdditionalInput = <empty>" */
382 static const uint8_t additional_input_empty[] = {};
383
384 /** "AdditionalInput1" */
385 static const uint8_t additional_input_1[] = {
386 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
387 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
388 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83,
389 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
390 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96
391 };
392
393 /** "AdditionalInput2" */
394 static const uint8_t additional_input_2[] = {
395 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab,
396 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
397 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3,
398 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
399 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6
400 };
401
402 /** SHA-1 Test 1 : Instantiation */
403 HMAC_DRBG_TEST_INSTANTIATE ( sha1_instantiate_1, HMAC_DRBG_SHA1,
404 entropy_input, nonce_sha1, personalisation_string_empty,
405 EXPECT ( 0xab, 0x16, 0x0d, 0xd2, 0x1c, 0x30, 0x98, 0x0c, 0xa3, 0xca,
406 0x5a, 0x9c, 0x77, 0xb7, 0xbd, 0xf0, 0x50, 0xe6, 0x4e, 0xe9 ),
407 EXPECT ( 0x61, 0x44, 0x99, 0xea, 0x98, 0x0c, 0xfb, 0x3d, 0xaa, 0x2c,
408 0xa8, 0x6d, 0x65, 0xa4, 0x6b, 0xf4, 0x48, 0x8d, 0x8c, 0xc5 ) );
409
410 /** SHA-1 Test 1.1 : First call to Generate */
411 HMAC_DRBG_TEST_GENERATE ( sha1_generate_1_1, HMAC_DRBG_SHA1,
412 additional_input_empty,
413 EXPECT ( 0x7b, 0xb1, 0x80, 0x28, 0xe0, 0x1d, 0x03, 0x42, 0xdf, 0x4f,
414 0x54, 0xda, 0x51, 0x22, 0xfa, 0x5f, 0x2c, 0x3a, 0x05, 0xe4 ),
415 EXPECT ( 0x2f, 0x89, 0x4f, 0x28, 0xcc, 0x2f, 0x53, 0x82, 0x96, 0x40,
416 0x64, 0x3a, 0xd1, 0x7b, 0x84, 0xb0, 0xcd, 0x3c, 0x79, 0x79 ),
417 EXPECT ( 0x5a, 0x7d, 0x3b, 0x44, 0x9f, 0x48, 0x1c, 0xb3, 0x8d, 0xf7,
418 0x9a, 0xd2, 0xb1, 0xfc, 0xc0, 0x1e, 0x57, 0xf8, 0x13, 0x5e,
419 0x8c, 0x0b, 0x22, 0xcd, 0x06, 0x30, 0xbf, 0xb0, 0x12, 0x7f,
420 0xb5, 0x40, 0x8c, 0x8e, 0xfc, 0x17, 0xa9, 0x29, 0x89, 0x6e ) );
421
422 /** SHA-1 Test 1.2 : Second call to Generate */
423 HMAC_DRBG_TEST_GENERATE ( sha1_generate_1_2, HMAC_DRBG_SHA1,
424 additional_input_empty,
425 EXPECT ( 0x3d, 0x4d, 0x73, 0x77, 0xe9, 0x17, 0x2a, 0xaf, 0xa7, 0x76,
426 0xb0, 0xdd, 0xcb, 0x89, 0x42, 0x00, 0x4a, 0x44, 0xb7, 0xfd ),
427 EXPECT ( 0x1a, 0x26, 0xbd, 0x9b, 0xfc, 0x97, 0x44, 0xbd, 0x29, 0xf6,
428 0xae, 0xbe, 0x24, 0x37, 0xe2, 0x09, 0xf1, 0xf7, 0x16, 0x25 ),
429 EXPECT ( 0x82, 0xcf, 0x77, 0x2e, 0xc3, 0xe8, 0x4b, 0x00, 0xfc, 0x74,
430 0xf5, 0xdf, 0x10, 0x4e, 0xfb, 0xfb, 0x24, 0x28, 0x55, 0x4e,
431 0x9c, 0xe3, 0x67, 0xd0, 0x3a, 0xea, 0xde, 0x37, 0x82, 0x7f,
432 0xa8, 0xe9, 0xcb, 0x6a, 0x08, 0x19, 0x61, 0x15, 0xd9, 0x48 ) );
433
434 /** SHA-1 Test 2 : Instantiation */
435 #define sha1_instantiate_2 sha1_instantiate_1
436
437 /** SHA-1 Test 2.1 : First call to Generate */
438 HMAC_DRBG_TEST_GENERATE ( sha1_generate_2_1, HMAC_DRBG_SHA1,
439 additional_input_1,
440 EXPECT ( 0x3a, 0x06, 0x2e, 0x6b, 0x79, 0xfe, 0x70, 0xdb, 0xff, 0xeb,
441 0x3a, 0x2b, 0x6b, 0xe8, 0x03, 0x23, 0xf7, 0xd6, 0x74, 0xc5 ),
442 EXPECT ( 0xbd, 0x36, 0x31, 0x28, 0xbf, 0x58, 0x0d, 0x7a, 0x54, 0x42,
443 0x9d, 0xdd, 0x58, 0xe8, 0x19, 0x3b, 0x98, 0x43, 0xbd, 0x2b ),
444 EXPECT ( 0xc7, 0xaa, 0xac, 0x58, 0x3c, 0x6e, 0xf6, 0x30, 0x07, 0x14,
445 0xc2, 0xcc, 0x5d, 0x06, 0xc1, 0x48, 0xcf, 0xfb, 0x40, 0x44,
446 0x9a, 0xd0, 0xbb, 0x26, 0xfa, 0xc0, 0x49, 0x7b, 0x5c, 0x57,
447 0xe1, 0x61, 0xe3, 0x66, 0x81, 0xbc, 0xc9, 0x30, 0xce, 0x80 ) );
448
449 /** SHA-1 Test 2.2 : Second call to Generate */
450 HMAC_DRBG_TEST_GENERATE ( sha1_generate_2_2, HMAC_DRBG_SHA1,
451 additional_input_2,
452 EXPECT ( 0x8a, 0xd7, 0xe3, 0x47, 0x72, 0xb5, 0xfc, 0x7c, 0x3b, 0x3b,
453 0x27, 0x62, 0x4f, 0x0b, 0x91, 0x77, 0x6a, 0x8a, 0x71, 0x12 ),
454 EXPECT ( 0xd7, 0x13, 0x76, 0xa4, 0x6d, 0x76, 0x4b, 0x17, 0xc3, 0xb7,
455 0x39, 0x34, 0x7b, 0x38, 0x4e, 0x51, 0x51, 0xe8, 0x7e, 0x88 ),
456 EXPECT ( 0x6e, 0xbd, 0x2b, 0x7b, 0x5e, 0x0a, 0x2a, 0xd7, 0xa2, 0x4b,
457 0x1b, 0xf9, 0xa1, 0xdb, 0xa4, 0x7d, 0x43, 0x27, 0x17, 0x19,
458 0xb9, 0xc3, 0x7b, 0x7f, 0xe8, 0x1b, 0xa9, 0x40, 0x45, 0xa1,
459 0x4a, 0x7c, 0xb5, 0x14, 0xb4, 0x46, 0x66, 0x6e, 0xa5, 0xa7 ) );
460
461 /** SHA-1 Test 3 : Instantiation */
462 HMAC_DRBG_TEST_INSTANTIATE ( sha1_instantiate_3, HMAC_DRBG_SHA1,
463 entropy_input, nonce_sha1, personalisation_string,
464 EXPECT ( 0xb7, 0xd9, 0x66, 0xd7, 0x0d, 0x4e, 0x27, 0xa7, 0xfa, 0x83,
465 0x8f, 0x7d, 0x61, 0x12, 0x6c, 0x0e, 0xdc, 0x84, 0x76, 0x1c ),
466 EXPECT ( 0xda, 0xb2, 0xa7, 0x18, 0x83, 0xf1, 0x00, 0x5c, 0x5d, 0xd0,
467 0x39, 0x32, 0x4d, 0x3c, 0x36, 0x4d, 0x6e, 0x18, 0xf9, 0x54 ) );
468
469 /** SHA-1 Test 3.1 : First call to Generate */
470 HMAC_DRBG_TEST_GENERATE ( sha1_generate_3_1, HMAC_DRBG_SHA1,
471 additional_input_empty,
472 EXPECT ( 0x87, 0xd3, 0x82, 0x8b, 0xe0, 0x3a, 0x80, 0x7d, 0xd3, 0x40,
473 0x29, 0x41, 0xbe, 0xd6, 0xde, 0x98, 0x6e, 0xe7, 0xa2, 0x86 ),
474 EXPECT ( 0x6a, 0xe1, 0xd0, 0x08, 0x6f, 0x53, 0xb1, 0xb7, 0x63, 0xa4,
475 0x51, 0x5b, 0x19, 0x06, 0xfe, 0xe4, 0x76, 0x61, 0xfd, 0x47 ),
476 EXPECT ( 0xb3, 0xbd, 0x05, 0x24, 0x6c, 0xba, 0x12, 0xa6, 0x47, 0x35,
477 0xa4, 0xe3, 0xfd, 0xe5, 0x99, 0xbc, 0x1b, 0xe3, 0x0f, 0x43,
478 0x9b, 0xd0, 0x60, 0x20, 0x8e, 0xea, 0x7d, 0x71, 0xf9, 0xd1,
479 0x23, 0xdf, 0x47, 0xb3, 0xce, 0x06, 0x9d, 0x98, 0xed, 0xe6 ) );
480
481 /** SHA-1 Test 3.2 : Second call to Generate */
482 HMAC_DRBG_TEST_GENERATE ( sha1_generate_3_2, HMAC_DRBG_SHA1,
483 additional_input_empty,
484 EXPECT ( 0x26, 0xab, 0xbf, 0x54, 0xb2, 0x8b, 0x93, 0xff, 0x90, 0x08,
485 0x67, 0x0e, 0xbf, 0xee, 0x86, 0xcd, 0xd7, 0x22, 0x8e, 0xd5 ),
486 EXPECT ( 0xe9, 0x25, 0x47, 0x29, 0xe0, 0x02, 0x04, 0xa1, 0xb6, 0xc0,
487 0x21, 0x58, 0xa6, 0xc7, 0x27, 0x86, 0x47, 0x14, 0xf1, 0xf7 ),
488 EXPECT ( 0xb5, 0xda, 0xda, 0x38, 0x0e, 0x28, 0x72, 0xdf, 0x93, 0x5b,
489 0xca, 0x55, 0xb8, 0x82, 0xc8, 0xc9, 0x37, 0x69, 0x02, 0xab,
490 0x63, 0x97, 0x65, 0x47, 0x2b, 0x71, 0xac, 0xeb, 0xe2, 0xea,
491 0x8b, 0x1b, 0x6b, 0x49, 0x62, 0x9c, 0xb6, 0x73, 0x17, 0xe0 ) );
492
493 /** SHA-1 Test 4 : Instantiation */
494 #define sha1_instantiate_4 sha1_instantiate_3
495
496 /** SHA-1 Test 4.1 : First call to Generate */
497 HMAC_DRBG_TEST_GENERATE ( sha1_generate_4_1, HMAC_DRBG_SHA1,
498 additional_input_1,
499 EXPECT ( 0x17, 0xa5, 0xd7, 0x9f, 0x07, 0x67, 0x87, 0x6f, 0x3a, 0x45,
500 0xe0, 0xc9, 0xc3, 0x3e, 0xc8, 0x8b, 0x03, 0xce, 0xea, 0x13 ),
501 EXPECT ( 0x4d, 0x2f, 0x3b, 0xc7, 0x77, 0x50, 0x5c, 0x45, 0xf7, 0xe1,
502 0x7d, 0xcd, 0x3d, 0x86, 0xbf, 0x37, 0x9c, 0xb6, 0x02, 0x5e ),
503 EXPECT ( 0x1f, 0x8f, 0xec, 0x7b, 0xc7, 0xcf, 0xa9, 0xa8, 0x80, 0x34,
504 0x5d, 0x28, 0x0b, 0x13, 0xc6, 0x32, 0xb8, 0x52, 0x77, 0x0a,
505 0x6d, 0xfc, 0x30, 0x2e, 0xad, 0x4c, 0xe3, 0xf5, 0x54, 0xc7,
506 0x9b, 0x0d, 0x44, 0x23, 0x9e, 0xba, 0x56, 0xa7, 0xea, 0x2d ) );
507
508 /** SHA-1 Test 4.2 : Second call to Generate */
509 HMAC_DRBG_TEST_GENERATE ( sha1_generate_4_2, HMAC_DRBG_SHA1,
510 additional_input_2,
511 EXPECT ( 0x07, 0x9b, 0x57, 0xd9, 0x40, 0x6e, 0x11, 0xc2, 0xf8, 0x7c,
512 0x8c, 0x82, 0x8c, 0x8c, 0x6f, 0xa7, 0x6e, 0x40, 0xea, 0x01 ),
513 EXPECT ( 0xa6, 0x54, 0xfe, 0x72, 0xf8, 0xa7, 0x7b, 0xb8, 0xf0, 0x3d,
514 0xff, 0x07, 0xc7, 0x9a, 0x51, 0x53, 0x00, 0x9e, 0xdd, 0xda ),
515 EXPECT ( 0xaf, 0x97, 0xcd, 0xe1, 0xe8, 0xab, 0x32, 0x2a, 0x2e, 0xac,
516 0xa8, 0xe6, 0xf4, 0xe5, 0xbf, 0x78, 0xa1, 0x1b, 0xde, 0xf7,
517 0xdc, 0x91, 0x21, 0x5d, 0x44, 0xb1, 0x07, 0xb4, 0xd5, 0xa7,
518 0x79, 0x01, 0x59, 0x25, 0x09, 0x76, 0x52, 0x80, 0xf9, 0x69 ) );
519
520 /** SHA-1 Test 5 : Instantiation */
521 #define sha1_instantiate_5 sha1_instantiate_1
522
523 /** SHA-1 Test 5.1 : First call to Generate */
524 HMAC_DRBG_TEST_GENERATE_FAIL ( sha1_generate_fail_5_1, HMAC_DRBG_SHA1,
525 additional_input_empty, ( 320 / 8 ) );
526
527 /** SHA-1 Test 5.2 : Reseed */
528 HMAC_DRBG_TEST_RESEED ( sha1_reseed_5_2, HMAC_DRBG_SHA1,
529 entropy_input_1, additional_input_empty,
530 EXPECT ( 0xcd, 0x4c, 0xab, 0x38, 0xc8, 0xad, 0x65, 0x71, 0x22, 0xbf,
531 0x5d, 0x3d, 0x00, 0xd0, 0xac, 0x9b, 0x13, 0xd6, 0x29, 0xbb ),
532 EXPECT ( 0xf6, 0x60, 0xe2, 0x3e, 0x91, 0x00, 0x6b, 0x62, 0xc6, 0x54,
533 0x3a, 0xb1, 0x34, 0x4d, 0x23, 0xa3, 0x1a, 0xb4, 0xcf, 0x2c ) );
534
535 /** SHA-1 Test 5.3 : Retried first call to Generate */
536 HMAC_DRBG_TEST_GENERATE ( sha1_generate_5_3, HMAC_DRBG_SHA1,
537 additional_input_empty,
538 EXPECT ( 0x58, 0x7f, 0xd8, 0x21, 0xef, 0x6c, 0x9d, 0xa4, 0xa8, 0x3c,
539 0x19, 0x21, 0x1f, 0x10, 0x56, 0xca, 0xcd, 0x23, 0xfc, 0x1a ),
540 EXPECT ( 0x84, 0x8f, 0xd1, 0x4c, 0x13, 0xb7, 0xea, 0x93, 0x72, 0x0c,
541 0xcf, 0xde, 0x71, 0xf2, 0xf6, 0x44, 0x39, 0xdb, 0x79, 0x5d ),
542 EXPECT ( 0xfe, 0xc4, 0x59, 0x7f, 0x06, 0xa3, 0xa8, 0xcc, 0x85, 0x29,
543 0xd5, 0x95, 0x57, 0xb9, 0xe6, 0x61, 0x05, 0x38, 0x09, 0xc0,
544 0xbc, 0x0e, 0xfc, 0x28, 0x2a, 0xbd, 0x87, 0x60, 0x5c, 0xc9,
545 0x0c, 0xba, 0x9b, 0x86, 0x33, 0xdc, 0xb1, 0xda, 0xe0, 0x2e ) );
546
547 /** SHA-1 Test 5.4 : Second call to Generate */
548 HMAC_DRBG_TEST_GENERATE_FAIL ( sha1_generate_fail_5_4, HMAC_DRBG_SHA1,
549 additional_input_empty, ( 320 / 8 ) );
550
551 /** SHA-1 Test 5.5 : Reseed */
552 HMAC_DRBG_TEST_RESEED ( sha1_reseed_5_5, HMAC_DRBG_SHA1,
553 entropy_input_2, additional_input_empty,
554 EXPECT ( 0xdb, 0xa1, 0xcf, 0xf4, 0x87, 0x95, 0x46, 0xa0, 0x38, 0xa5,
555 0x59, 0xb2, 0xa2, 0x4d, 0xf2, 0xc0, 0x30, 0x08, 0x9a, 0x41 ),
556 EXPECT ( 0x2f, 0x88, 0x3c, 0x46, 0x48, 0xe1, 0x31, 0xe8, 0x6d, 0xdf,
557 0x9d, 0xca, 0x0d, 0x74, 0xf3, 0x0c, 0xa1, 0xce, 0x6e, 0xfb ) );
558
559 /** SHA-1 Test 5.6 : Retried second call to Generate */
560 HMAC_DRBG_TEST_GENERATE ( sha1_generate_5_6, HMAC_DRBG_SHA1,
561 additional_input_empty,
562 EXPECT ( 0xf9, 0x39, 0xa5, 0xab, 0x08, 0xa3, 0x9f, 0x23, 0x10, 0x70,
563 0xb0, 0xd4, 0xc9, 0x6d, 0xc2, 0x37, 0x90, 0xba, 0x01, 0x53 ),
564 EXPECT ( 0xce, 0x6d, 0x08, 0xb4, 0xae, 0x2c, 0xe3, 0x83, 0xfd, 0xab,
565 0xb0, 0x1e, 0xaa, 0xfc, 0x9c, 0x8e, 0x76, 0xa0, 0xd4, 0x72 ),
566 EXPECT ( 0x84, 0xad, 0xd5, 0xe2, 0xd2, 0x04, 0x1c, 0x01, 0x72, 0x3a,
567 0x4d, 0xe4, 0x33, 0x5b, 0x13, 0xef, 0xdf, 0x16, 0xb0, 0xe5,
568 0x1a, 0x0a, 0xd3, 0x9b, 0xd1, 0x5e, 0x86, 0x2e, 0x64, 0x4f,
569 0x31, 0xe4, 0xa2, 0xd7, 0xd8, 0x43, 0xe5, 0x7c, 0x59, 0x68 ) );
570
571 /** SHA-1 Test 6 : Instantiate */
572 #define sha1_instantiate_6 sha1_instantiate_1
573
574 /** SHA-1 Test 6.1 : First call to Generate */
575 HMAC_DRBG_TEST_GENERATE_FAIL ( sha1_generate_fail_6_1, HMAC_DRBG_SHA1,
576 additional_input_1, ( 320 / 8 ) );
577
578 /** SHA-1 Test 6.2 : Reseed */
579 HMAC_DRBG_TEST_RESEED ( sha1_reseed_6_2, HMAC_DRBG_SHA1,
580 entropy_input_1, additional_input_1,
581 EXPECT ( 0x52, 0x28, 0xa4, 0xb6, 0xa4, 0x46, 0x92, 0x90, 0x5e, 0xc0,
582 0x44, 0xbf, 0xf0, 0xbb, 0x4e, 0x25, 0xa3, 0x87, 0xca, 0xc1 ),
583 EXPECT ( 0x24, 0x77, 0x32, 0xd0, 0x4c, 0xb8, 0x4e, 0xd4, 0x1a, 0xdd,
584 0x95, 0xa4, 0xb7, 0x8b, 0x50, 0xcd, 0x9b, 0x3d, 0x3f, 0x32 ) );
585
586 /** SHA-1 Test 6.3 : Retried first call to Generate */
587 HMAC_DRBG_TEST_GENERATE ( sha1_generate_6_3, HMAC_DRBG_SHA1,
588 additional_input_empty,
589 EXPECT ( 0xab, 0x3d, 0xd4, 0x89, 0x5b, 0xc8, 0xcd, 0x22, 0x71, 0xde,
590 0xba, 0x5f, 0x3c, 0x13, 0x63, 0x52, 0x6b, 0x8b, 0x74, 0x52 ),
591 EXPECT ( 0xa8, 0x66, 0xc5, 0xef, 0xf2, 0xaf, 0x04, 0x2b, 0x11, 0x86,
592 0x44, 0x94, 0x45, 0x23, 0x7f, 0x9c, 0x02, 0x44, 0x98, 0x64 ),
593 EXPECT ( 0xa1, 0xba, 0x8f, 0xa5, 0x8b, 0xb5, 0x01, 0x3f, 0x43, 0xf7,
594 0xb6, 0xed, 0x52, 0xb4, 0x53, 0x9f, 0xa1, 0x6d, 0xc7, 0x79,
595 0x57, 0xae, 0xe8, 0x15, 0xb9, 0xc0, 0x70, 0x04, 0xc7, 0xe9,
596 0x92, 0xeb, 0x8c, 0x7e, 0x59, 0x19, 0x64, 0xaf, 0xee, 0xa2 ) );
597
598 /** SHA-1 Test 6.4 : Second call to Generate */
599 HMAC_DRBG_TEST_GENERATE_FAIL ( sha1_generate_fail_6_4, HMAC_DRBG_SHA1,
600 additional_input_2, ( 320 / 8 ) );
601
602 /** SHA-1 Test 6.5 : Reseed */
603 HMAC_DRBG_TEST_RESEED ( sha1_reseed_6_5, HMAC_DRBG_SHA1,
604 entropy_input_2, additional_input_2,
605 EXPECT ( 0xe5, 0x73, 0x9f, 0x9c, 0xf7, 0xff, 0x43, 0x84, 0xd1, 0x27,
606 0x3e, 0x02, 0x6b, 0x45, 0x31, 0x21, 0x36, 0x49, 0x4f, 0x41 ),
607 EXPECT ( 0x30, 0xc3, 0x43, 0x05, 0xc2, 0xc6, 0x48, 0xb0, 0x57, 0xa6,
608 0x40, 0x22, 0x1b, 0x5c, 0x56, 0x57, 0x26, 0xcd, 0x32, 0xb2 ) );
609
610 /** SHA-1 Test 6.6 : Retried second call to Generate */
611 HMAC_DRBG_TEST_GENERATE ( sha1_generate_6_6, HMAC_DRBG_SHA1,
612 additional_input_empty,
613 EXPECT ( 0x61, 0x91, 0xca, 0x9b, 0xf0, 0x00, 0xd1, 0x0a, 0x71, 0x69,
614 0x0a, 0xc1, 0x0e, 0x09, 0xff, 0xc8, 0x92, 0xab, 0xde, 0x9a ),
615 EXPECT ( 0x1e, 0xc0, 0x49, 0x0f, 0xa0, 0xb7, 0x65, 0x52, 0x7e, 0x5e,
616 0xa1, 0x8b, 0x53, 0x22, 0xb2, 0x8b, 0xdd, 0x0e, 0x7b, 0xc0 ),
617 EXPECT ( 0x84, 0x26, 0x4a, 0x73, 0xa8, 0x18, 0xc9, 0x5c, 0x2f, 0x42,
618 0x4b, 0x37, 0xd3, 0xcc, 0x99, 0x0b, 0x04, 0x6f, 0xb5, 0x0c,
619 0x2d, 0xc6, 0x4a, 0x16, 0x42, 0x11, 0x88, 0x9a, 0x01, 0x0f,
620 0x24, 0x71, 0xa0, 0x91, 0x2f, 0xfe, 0xa1, 0xbf, 0x01, 0x95 ) );
621
622 /** SHA-1 Test 7 : Instantiation */
623 #define sha1_instantiate_7 sha1_instantiate_3
624
625 /** SHA-1 Test 7.1 : First call to Generate */
626 HMAC_DRBG_TEST_GENERATE_FAIL ( sha1_generate_fail_7_1, HMAC_DRBG_SHA1,
627 additional_input_empty, ( 320 / 8 ) );
628
629 /** SHA-1 Test 7.2 : Reseed */
630 HMAC_DRBG_TEST_RESEED ( sha1_reseed_7_2, HMAC_DRBG_SHA1,
631 entropy_input_1, additional_input_empty,
632 EXPECT ( 0xb9, 0x25, 0x4d, 0x8a, 0xac, 0xba, 0x43, 0xfb, 0xda, 0xe6,
633 0x39, 0x4f, 0x2b, 0x3a, 0xfc, 0x5d, 0x58, 0x08, 0x00, 0xbf ),
634 EXPECT ( 0x28, 0x40, 0x3b, 0x60, 0x36, 0x38, 0xd0, 0x7d, 0x79, 0x66,
635 0x66, 0x1e, 0xf6, 0x7b, 0x9d, 0x39, 0x05, 0xf4, 0x6d, 0xb9 ) );
636
637 /** SHA-1 Test 7.3 : Retried first call to Generate */
638 HMAC_DRBG_TEST_GENERATE ( sha1_generate_7_3, HMAC_DRBG_SHA1,
639 additional_input_empty,
640 EXPECT ( 0x64, 0xfe, 0x07, 0x4a, 0x6e, 0x77, 0x97, 0xd1, 0xa4, 0x35,
641 0xda, 0x89, 0x64, 0x48, 0x4d, 0x6c, 0xf8, 0xbd, 0xc0, 0x1b ),
642 EXPECT ( 0x43, 0xe0, 0xc0, 0x52, 0x15, 0x86, 0xe9, 0x47, 0x3b, 0x06,
643 0x0d, 0x87, 0xd0, 0x8a, 0x23, 0x25, 0xfa, 0xe1, 0x49, 0xd1 ),
644 EXPECT ( 0x6c, 0x37, 0xfd, 0xd7, 0x29, 0xaa, 0x40, 0xf8, 0x0b, 0xc6,
645 0xab, 0x08, 0xca, 0x7c, 0xc6, 0x49, 0x79, 0x4f, 0x69, 0x98,
646 0xb5, 0x70, 0x81, 0xe4, 0x22, 0x0f, 0x22, 0xc5, 0xc2, 0x83,
647 0xe2, 0xc9, 0x1b, 0x8e, 0x30, 0x5a, 0xb8, 0x69, 0xc6, 0x25 ) );
648
649 /** SHA-1 Test 7.4 : Second call to Generate */
650 HMAC_DRBG_TEST_GENERATE_FAIL ( sha1_generate_fail_7_4, HMAC_DRBG_SHA1,
651 additional_input_empty, ( 320 / 8 ) );
652
653 /** SHA-1 Test 7.5 : Reseed */
654 HMAC_DRBG_TEST_RESEED ( sha1_reseed_7_5, HMAC_DRBG_SHA1,
655 entropy_input_2, additional_input_empty,
656 EXPECT ( 0x02, 0xbc, 0x57, 0x7f, 0xd1, 0x0e, 0xf7, 0x19, 0x3c, 0x1d,
657 0xb0, 0x98, 0xbd, 0x5b, 0x75, 0xc7, 0xc4, 0xb6, 0x79, 0x59 ),
658 EXPECT ( 0xbc, 0xbd, 0xf0, 0x52, 0xe0, 0xe0, 0x2a, 0xe8, 0x9a, 0x77,
659 0x67, 0x94, 0x3f, 0x98, 0x65, 0xb8, 0xb7, 0x22, 0x90, 0x2d ) );
660
661 /** SHA-1 Test 7.6 : Retried second call to Generate */
662 HMAC_DRBG_TEST_GENERATE ( sha1_generate_7_6, HMAC_DRBG_SHA1,
663 additional_input_empty,
664 EXPECT ( 0x1a, 0xa4, 0x24, 0x1c, 0x69, 0x5e, 0x29, 0xc0, 0xa5, 0x9a,
665 0xd1, 0x8a, 0x60, 0x70, 0xe3, 0x38, 0xa5, 0x48, 0xbe, 0x92 ),
666 EXPECT ( 0x03, 0x47, 0x35, 0x9b, 0xc9, 0xc7, 0xf8, 0x8c, 0xc8, 0x33,
667 0x0d, 0x4f, 0x59, 0xfb, 0xc7, 0x70, 0xb0, 0xb7, 0x7b, 0x03 ),
668 EXPECT ( 0xca, 0xf5, 0x7d, 0xcf, 0xea, 0x39, 0x3b, 0x92, 0x36, 0xbf,
669 0x69, 0x1f, 0xa4, 0x56, 0xfe, 0xa7, 0xfd, 0xf1, 0xdf, 0x83,
670 0x61, 0x48, 0x2c, 0xa5, 0x4d, 0x5f, 0xa7, 0x23, 0xf4, 0xc8,
671 0x8b, 0x4f, 0xa5, 0x04, 0xbf, 0x03, 0x27, 0x7f, 0xa7, 0x83 ) );
672
673 /** SHA-1 Test 8 : Instantiate */
674 #define sha1_instantiate_8 sha1_instantiate_3
675
676 /** SHA-1 Test 8.1 : First call to Generate */
677 HMAC_DRBG_TEST_GENERATE_FAIL ( sha1_generate_fail_8_1, HMAC_DRBG_SHA1,
678 additional_input_1, ( 320 / 8 ) );
679
680 /** SHA-1 Test 8.2 : Reseed */
681 HMAC_DRBG_TEST_RESEED ( sha1_reseed_8_2, HMAC_DRBG_SHA1,
682 entropy_input_1, additional_input_1,
683 EXPECT ( 0xc0, 0x95, 0x48, 0xc0, 0xd3, 0xc8, 0x61, 0xd7, 0x40, 0xf2,
684 0x83, 0x7d, 0x72, 0xb5, 0x07, 0x23, 0x5c, 0x26, 0xdb, 0x82 ),
685 EXPECT ( 0x17, 0x4b, 0x3f, 0x84, 0xc3, 0x53, 0x1f, 0x7c, 0x0a, 0x2e,
686 0x54, 0x21, 0x23, 0x4e, 0xa1, 0x6b, 0x70, 0x8d, 0xdf, 0x0d ) );
687
688 /** SHA-1 Test 8.3 : Retried first call to Generate */
689 HMAC_DRBG_TEST_GENERATE ( sha1_generate_8_3, HMAC_DRBG_SHA1,
690 additional_input_empty,
691 EXPECT ( 0x60, 0x3f, 0x09, 0x49, 0x27, 0x9c, 0x70, 0xe8, 0xc6, 0x6c,
692 0x0f, 0x56, 0x37, 0xc0, 0xf3, 0x75, 0x60, 0x07, 0xe5, 0xac ),
693 EXPECT ( 0xf2, 0xb3, 0x3b, 0x21, 0x15, 0x1f, 0xaf, 0x61, 0x20, 0x01,
694 0x83, 0x10, 0xf4, 0x4e, 0x4c, 0xd0, 0xbf, 0xe3, 0x68, 0xea ),
695 EXPECT ( 0xbd, 0x07, 0xc2, 0x5c, 0xfd, 0x7c, 0x5e, 0x3a, 0x4e, 0xaa,
696 0x6e, 0x2e, 0xdc, 0x5a, 0xb7, 0xea, 0x49, 0x42, 0xa0, 0x91,
697 0x34, 0x71, 0xfd, 0xa5, 0x5c, 0x6d, 0xdd, 0x2c, 0x03, 0xef,
698 0xa3, 0xb9, 0x64, 0x3a, 0xb3, 0xbb, 0x22, 0xf6, 0xc9, 0xf2 ) );
699
700 /** SHA-1 Test 8.4 : Second call to Generate */
701 HMAC_DRBG_TEST_GENERATE_FAIL ( sha1_generate_fail_8_4, HMAC_DRBG_SHA1,
702 additional_input_2, ( 320 / 8 ) );
703
704 /** SHA-1 Test 8.5 : Reseed */
705 HMAC_DRBG_TEST_RESEED ( sha1_reseed_8_5, HMAC_DRBG_SHA1,
706 entropy_input_2, additional_input_2,
707 EXPECT ( 0x89, 0x42, 0xa5, 0x4f, 0x34, 0x9e, 0x28, 0x1b, 0x84, 0xaa,
708 0x46, 0x95, 0x87, 0xfb, 0xdd, 0xaf, 0x9d, 0x11, 0x40, 0x82 ),
709 EXPECT ( 0x07, 0x73, 0x0e, 0x3c, 0xbf, 0xfd, 0x3c, 0xaf, 0xd7, 0xa8,
710 0xaa, 0xe2, 0xbf, 0x01, 0xd6, 0x01, 0x43, 0x01, 0xe2, 0x4d ) );
711
712 /** SHA-1 Test 8.6 : Retried second call to Generate */
713 HMAC_DRBG_TEST_GENERATE ( sha1_generate_8_6, HMAC_DRBG_SHA1,
714 additional_input_empty,
715 EXPECT ( 0xbd, 0xe1, 0xb4, 0x6c, 0xdc, 0x54, 0x13, 0xb3, 0xd9, 0xf7,
716 0x35, 0xac, 0xdb, 0x80, 0xb1, 0x3c, 0x57, 0xbf, 0xe4, 0x73 ),
717 EXPECT ( 0x72, 0x5a, 0x3c, 0x78, 0x20, 0xde, 0x1a, 0x06, 0xd0, 0x95,
718 0x81, 0x9c, 0xcf, 0x6f, 0x2c, 0x9b, 0x3a, 0x67, 0xf2, 0xce ),
719 EXPECT ( 0xd1, 0xa9, 0xc1, 0xa2, 0x2c, 0x84, 0xfc, 0x23, 0xff, 0x22,
720 0x27, 0xef, 0x98, 0xec, 0x8b, 0xa9, 0xdf, 0x2a, 0x20, 0x9b,
721 0xa1, 0xdb, 0x09, 0x80, 0x9f, 0x57, 0xbf, 0xea, 0xe5, 0xb3,
722 0xe5, 0xf1, 0x46, 0xc7, 0x5f, 0x2d, 0x8d, 0xbb, 0x5e, 0x4a ) );
723
724 /** SHA-256 Test 1 : Instantiation */
725 HMAC_DRBG_TEST_INSTANTIATE ( sha256_instantiate_1, HMAC_DRBG_SHA256,
726 entropy_input, nonce_sha256, personalisation_string_empty,
727 EXPECT ( 0x3d, 0xda, 0x54, 0x3e, 0x7e, 0xef, 0x14, 0xf9, 0x36, 0x23,
728 0x7b, 0xe6, 0x5d, 0x09, 0x4b, 0x4d, 0xdc, 0x96, 0x9c, 0x0b,
729 0x2b, 0x5e, 0xaf, 0xb5, 0xd8, 0x05, 0xe8, 0x6c, 0xfa, 0x64,
730 0xd7, 0x41 ),
731 EXPECT ( 0x2d, 0x02, 0xc2, 0xf8, 0x22, 0x51, 0x7d, 0x54, 0xb8, 0x17,
732 0x27, 0x9a, 0x59, 0x49, 0x1c, 0x41, 0xa1, 0x98, 0x9b, 0x3e,
733 0x38, 0x2d, 0xeb, 0xe8, 0x0d, 0x2c, 0x7f, 0x66, 0x0f, 0x44,
734 0x76, 0xc4 ) );
735
736 /** SHA-256 Test 1.1 : First call to Generate */
737 HMAC_DRBG_TEST_GENERATE ( sha256_generate_1_1, HMAC_DRBG_SHA256,
738 additional_input_empty,
739 EXPECT ( 0xdd, 0x30, 0x95, 0x79, 0x35, 0x38, 0x02, 0xcc, 0xdd, 0x43,
740 0x99, 0xc3, 0x69, 0x1c, 0x9d, 0xd9, 0x09, 0xdd, 0x3b, 0x2d,
741 0xd0, 0x03, 0xcc, 0xd5, 0x9d, 0x6f, 0x08, 0xd8, 0x5f, 0x2e,
742 0x35, 0x09 ),
743 EXPECT ( 0xa1, 0xc2, 0x0f, 0xf2, 0x70, 0xa3, 0x9d, 0x2b, 0x8d, 0x03,
744 0xd6, 0x59, 0xb9, 0xdd, 0xd0, 0x11, 0xc2, 0xcc, 0xdf, 0x24,
745 0x48, 0x55, 0x7e, 0xf6, 0xa1, 0xa9, 0x15, 0xd1, 0x89, 0x40,
746 0xa6, 0x88 ),
747 EXPECT ( 0xd6, 0x7b, 0x8c, 0x17, 0x34, 0xf4, 0x6f, 0xa3, 0xf7, 0x63,
748 0xcf, 0x57, 0xc6, 0xf9, 0xf4, 0xf2, 0xdc, 0x10, 0x89, 0xbd,
749 0x8b, 0xc1, 0xf6, 0xf0, 0x23, 0x95, 0x0b, 0xfc, 0x56, 0x17,
750 0x63, 0x52, 0x08, 0xc8, 0x50, 0x12, 0x38, 0xad, 0x7a, 0x44,
751 0x00, 0xde, 0xfe, 0xe4, 0x6c, 0x64, 0x0b, 0x61, 0xaf, 0x77,
752 0xc2, 0xd1, 0xa3, 0xbf, 0xaa, 0x90, 0xed, 0xe5, 0xd2, 0x07,
753 0x40, 0x6e, 0x54, 0x03 ) );
754
755 /** SHA-256 Test 1.2 : Second call to Generate */
756 HMAC_DRBG_TEST_GENERATE ( sha256_generate_1_2, HMAC_DRBG_SHA256,
757 additional_input_empty,
758 EXPECT ( 0x5c, 0xd5, 0xe5, 0x0a, 0x3e, 0x44, 0x8a, 0x07, 0xc3, 0xd2,
759 0xf2, 0xa3, 0xf9, 0xde, 0xbc, 0xc0, 0x46, 0x5f, 0x9c, 0xf1,
760 0x1c, 0xa1, 0x36, 0xe9, 0xb5, 0x04, 0xb4, 0xd3, 0x1c, 0x7f,
761 0xf1, 0xb8 ),
762 EXPECT ( 0x33, 0xb3, 0x09, 0xf2, 0xff, 0x01, 0xce, 0x10, 0x4b, 0x44,
763 0x29, 0xb6, 0x75, 0xfa, 0xfa, 0x19, 0x01, 0x1e, 0x34, 0x8b,
764 0x28, 0x12, 0x71, 0x5a, 0x76, 0x37, 0xf6, 0xa6, 0xe6, 0x3b,
765 0x5d, 0x57 ),
766 EXPECT ( 0x8f, 0xda, 0xec, 0x20, 0xf8, 0xb4, 0x21, 0x40, 0x70, 0x59,
767 0xe3, 0x58, 0x89, 0x20, 0xda, 0x7e, 0xda, 0x9d, 0xce, 0x3c,
768 0xf8, 0x27, 0x4d, 0xfa, 0x1c, 0x59, 0xc1, 0x08, 0xc1, 0xd0,
769 0xaa, 0x9b, 0x0f, 0xa3, 0x8d, 0xa5, 0xc7, 0x92, 0x03, 0x7c,
770 0x4d, 0x33, 0xcd, 0x07, 0x0c, 0xa7, 0xcd, 0x0c, 0x56, 0x08,
771 0xdb, 0xa8, 0xb8, 0x85, 0x65, 0x46, 0x39, 0xde, 0x21, 0x87,
772 0xb7, 0x4c, 0xb2, 0x63 ) );
773
774 /** SHA-256 Test 2 : Instantiation */
775 #define sha256_instantiate_2 sha256_instantiate_1
776
777 /** SHA-256 Test 2.1 : First call to Generate */
778 HMAC_DRBG_TEST_GENERATE ( sha256_generate_2_1, HMAC_DRBG_SHA256,
779 additional_input_1,
780 EXPECT ( 0x79, 0x1d, 0x31, 0x44, 0xb3, 0x02, 0xad, 0x6c, 0xe4, 0x32,
781 0x41, 0x34, 0x42, 0x10, 0xaa, 0xd0, 0xd3, 0x99, 0xed, 0xb7,
782 0xb5, 0x90, 0x6f, 0xb2, 0x51, 0xdb, 0x1c, 0xb6, 0x00, 0x04,
783 0xea, 0x51 ),
784 EXPECT ( 0x58, 0xfd, 0x96, 0x5f, 0x4f, 0x99, 0x89, 0x3c, 0x17, 0xe6,
785 0xa3, 0x3c, 0xb8, 0xe9, 0x04, 0x15, 0xb5, 0x16, 0xd0, 0x06,
786 0x14, 0xa4, 0x49, 0xd4, 0x06, 0xe0, 0x3c, 0x68, 0x5b, 0xd8,
787 0x59, 0xbd ),
788 EXPECT ( 0x41, 0x87, 0x87, 0x35, 0x81, 0x35, 0x41, 0x9b, 0x93, 0x81,
789 0x33, 0x53, 0x53, 0x06, 0x17, 0x6a, 0xfb, 0x25, 0x1c, 0xdd,
790 0x2b, 0xa3, 0x79, 0x88, 0x59, 0xb5, 0x66, 0xa0, 0x5c, 0xfb,
791 0x1d, 0x68, 0x0e, 0xa9, 0x25, 0x85, 0x6d, 0x5b, 0x84, 0xd5,
792 0x6a, 0xda, 0xe8, 0x70, 0x45, 0xa6, 0xba, 0x28, 0xd2, 0xc9,
793 0x08, 0xab, 0x75, 0xb7, 0xcc, 0x41, 0x43, 0x1f, 0xac, 0x59,
794 0xf3, 0x89, 0x18, 0xa3 ) );
795
796 /** SHA-256 Test 2.2 : Second call to Generate */
797 HMAC_DRBG_TEST_GENERATE ( sha256_generate_2_2, HMAC_DRBG_SHA256,
798 additional_input_2,
799 EXPECT ( 0xe7, 0x45, 0x8f, 0xb4, 0x4a, 0x36, 0x9a, 0x65, 0x3f, 0x2f,
800 0x8f, 0x57, 0x7b, 0xf9, 0x75, 0xc4, 0xb3, 0x62, 0xc4, 0xfe,
801 0x61, 0x8b, 0x2f, 0x1f, 0xf6, 0x76, 0x9b, 0x13, 0xc9, 0x4d,
802 0xec, 0xf4 ),
803 EXPECT ( 0x19, 0x33, 0x4b, 0x8c, 0x31, 0xb7, 0x49, 0x32, 0xdd, 0xd7,
804 0xb2, 0xa4, 0x68, 0xf6, 0x43, 0x6d, 0xf9, 0x2e, 0x10, 0x0d,
805 0x39, 0xd3, 0xac, 0xb3, 0x68, 0xc7, 0x02, 0x9c, 0xb8, 0x83,
806 0xec, 0x89 ),
807 EXPECT ( 0x7c, 0x06, 0x7b, 0xdd, 0xca, 0x81, 0x72, 0x48, 0x23, 0xd6,
808 0x4c, 0x69, 0x82, 0x92, 0x85, 0xbd, 0xbf, 0xf5, 0x37, 0x71,
809 0x61, 0x02, 0xc1, 0x88, 0x2e, 0x20, 0x22, 0x50, 0xe0, 0xfa,
810 0x5e, 0xf3, 0xa3, 0x84, 0xcd, 0x34, 0xa2, 0x0f, 0xfd, 0x1f,
811 0xbc, 0x91, 0xe0, 0xc5, 0x32, 0xa8, 0xa4, 0x21, 0xbc, 0x4a,
812 0xfe, 0x3c, 0xd4, 0x7f, 0x22, 0x32, 0x3e, 0xb4, 0xba, 0xe1,
813 0xa0, 0x07, 0x89, 0x81 ) );
814
815 /** SHA-256 Test 3 : Instantiation */
816 HMAC_DRBG_TEST_INSTANTIATE ( sha256_instantiate_3, HMAC_DRBG_SHA256,
817 entropy_input, nonce_sha256, personalisation_string,
818 EXPECT ( 0x65, 0x67, 0x3c, 0x34, 0x8e, 0x51, 0xcf, 0xac, 0xc4, 0x10,
819 0xbd, 0x20, 0x02, 0x49, 0xa5, 0x9a, 0x9d, 0x6b, 0xae, 0x77,
820 0x69, 0x04, 0x27, 0x1b, 0xb1, 0xf7, 0x18, 0xda, 0x1d, 0x18,
821 0x20, 0x42 ),
822 EXPECT ( 0xe0, 0xf9, 0x1a, 0xc9, 0x96, 0x30, 0xee, 0xe6, 0x7c, 0xf8,
823 0x30, 0xcf, 0xd5, 0x04, 0x4f, 0xeb, 0xf5, 0x5c, 0x0c, 0x11,
824 0x50, 0x07, 0x99, 0x7a, 0xda, 0x11, 0x29, 0x6f, 0xc4, 0x16,
825 0x4a, 0x9a ) );
826
827 /** SHA-256 Test 3.1 : First call to Generate */
828 HMAC_DRBG_TEST_GENERATE ( sha256_generate_3_1, HMAC_DRBG_SHA256,
829 additional_input_empty,
830 EXPECT ( 0xf0, 0xb2, 0xf2, 0x42, 0xca, 0xd9, 0x92, 0xa7, 0x24, 0xf7,
831 0xe5, 0x59, 0x1d, 0x2f, 0x3b, 0x0c, 0x21, 0x57, 0xae, 0x70,
832 0xd5, 0x32, 0x78, 0x99, 0x40, 0xf1, 0x64, 0x45, 0x9b, 0x00,
833 0xc7, 0x49 ),
834 EXPECT ( 0x1a, 0x03, 0xf9, 0x1c, 0x51, 0x20, 0xba, 0xca, 0x2b, 0xf6,
835 0xc6, 0x4d, 0xd7, 0x3a, 0xb1, 0x1d, 0xf6, 0xfd, 0x3f, 0xf1,
836 0xac, 0x3b, 0x57, 0x20, 0xa3, 0xf7, 0xfb, 0xe3, 0x9e, 0x7e,
837 0x7f, 0xe9 ),
838 EXPECT ( 0x0d, 0xd9, 0xc8, 0x55, 0x89, 0xf3, 0x57, 0xc3, 0x89, 0xd6,
839 0xaf, 0x8d, 0xe9, 0xd7, 0x34, 0xa9, 0x17, 0xc7, 0x71, 0xef,
840 0x2d, 0x88, 0x16, 0xb9, 0x82, 0x59, 0x6e, 0xd1, 0x2d, 0xb4,
841 0x5d, 0x73, 0x4a, 0x62, 0x68, 0x08, 0x35, 0xc0, 0x2f, 0xda,
842 0x66, 0xb0, 0x8e, 0x1a, 0x36, 0x9a, 0xe2, 0x18, 0xf2, 0x6d,
843 0x52, 0x10, 0xad, 0x56, 0x42, 0x48, 0x87, 0x2d, 0x7a, 0x28,
844 0x78, 0x41, 0x59, 0xc3 ) );
845
846 /** SHA-256 Test 3.2 : Second call to Generate */
847 HMAC_DRBG_TEST_GENERATE ( sha256_generate_3_2, HMAC_DRBG_SHA256,
848 additional_input_empty,
849 EXPECT ( 0x5c, 0x0d, 0xec, 0x09, 0x37, 0x08, 0xc1, 0x7c, 0xa7, 0x6b,
850 0x57, 0xc0, 0xcb, 0x60, 0xcf, 0x88, 0x9d, 0xcc, 0x47, 0xad,
851 0x10, 0xbd, 0x64, 0xbc, 0x6a, 0x14, 0xb2, 0x3f, 0x20, 0x26,
852 0x07, 0x8a ),
853 EXPECT ( 0x45, 0x67, 0x52, 0xa5, 0x11, 0xb8, 0x48, 0xbd, 0x05, 0xf1,
854 0x81, 0x9b, 0x9f, 0x6b, 0x15, 0x42, 0xc7, 0xd5, 0xec, 0xf9,
855 0x32, 0x73, 0x39, 0x26, 0x7a, 0x0c, 0x77, 0x23, 0x5b, 0x87,
856 0xdc, 0x5a ),
857 EXPECT ( 0x46, 0xb4, 0xf4, 0x75, 0x6a, 0xe7, 0x15, 0xe0, 0xe5, 0x16,
858 0x81, 0xab, 0x29, 0x32, 0xde, 0x15, 0x23, 0xbe, 0x5d, 0x13,
859 0xba, 0xf0, 0xf4, 0x58, 0x8b, 0x11, 0xfe, 0x37, 0x2f, 0xda,
860 0x37, 0xab, 0xe3, 0x68, 0x31, 0x73, 0x41, 0xbc, 0x8b, 0xa9,
861 0x1f, 0xc5, 0xd8, 0x5b, 0x7f, 0xb8, 0xca, 0x8f, 0xbc, 0x30,
862 0x9a, 0x75, 0x8f, 0xd6, 0xfc, 0xa9, 0xdf, 0x43, 0xc7, 0x66,
863 0x0b, 0x22, 0x13, 0x22 ) );
864
865 /** SHA-256 Test 4 : Instantiation */
866 #define sha256_instantiate_4 sha256_instantiate_3
867
868 /** SHA-256 Test 4.1 : First call to Generate */
869 HMAC_DRBG_TEST_GENERATE ( sha256_generate_4_1, HMAC_DRBG_SHA256,
870 additional_input_1,
871 EXPECT ( 0x57, 0x2c, 0x03, 0x74, 0xc1, 0xa1, 0x01, 0x25, 0xbf, 0xa6,
872 0xae, 0xcd, 0x7c, 0xeb, 0xfe, 0x32, 0xf7, 0x52, 0xc3, 0xfb,
873 0x31, 0x67, 0x31, 0xb7, 0xcf, 0xdb, 0xde, 0xc2, 0x63, 0x56,
874 0x93, 0x2b ),
875 EXPECT ( 0xd6, 0x8b, 0xf0, 0x41, 0xf3, 0xeb, 0x50, 0x88, 0x08, 0x8d,
876 0x8b, 0x8e, 0x71, 0x2c, 0x36, 0xae, 0x95, 0x83, 0xbb, 0x08,
877 0xfd, 0x1f, 0x90, 0x34, 0xa4, 0xe9, 0x42, 0xe9, 0xa6, 0x74,
878 0x7c, 0xe7 ),
879 EXPECT ( 0x14, 0x78, 0xf2, 0x9e, 0x94, 0xb0, 0x2c, 0xb4, 0x0d, 0x3a,
880 0xab, 0x86, 0x24, 0x55, 0x57, 0xce, 0x13, 0xa8, 0xca, 0x2f,
881 0xdb, 0x65, 0x7d, 0x98, 0xef, 0xc1, 0x92, 0x34, 0x6b, 0x9f,
882 0xac, 0x33, 0xea, 0x58, 0xad, 0xa2, 0xcc, 0xa4, 0x32, 0xcc,
883 0xde, 0xfb, 0xcd, 0xaa, 0x8b, 0x82, 0xf5, 0x53, 0xef, 0x96,
884 0x61, 0x34, 0xe2, 0xcd, 0x13, 0x9f, 0x15, 0xf0, 0x1c, 0xad,
885 0x56, 0x85, 0x65, 0xa8 ) );
886
887 /** SHA-256 Test 4.2 : Second call to Generate */
888 HMAC_DRBG_TEST_GENERATE ( sha256_generate_4_2, HMAC_DRBG_SHA256,
889 additional_input_2,
890 EXPECT ( 0x28, 0x2e, 0x07, 0x34, 0x80, 0x80, 0x93, 0x75, 0x58, 0xb1,
891 0x39, 0x2e, 0x95, 0xab, 0x91, 0xe7, 0xc1, 0xf6, 0x22, 0xb2,
892 0x4f, 0xfb, 0x87, 0x20, 0xa5, 0xf0, 0xa5, 0xe0, 0x75, 0x50,
893 0xc7, 0xc2 ),
894 EXPECT ( 0xdf, 0xc3, 0xbd, 0xb5, 0xf3, 0xbc, 0xf1, 0xaa, 0x68, 0x29,
895 0x8e, 0x79, 0x0d, 0x72, 0x0a, 0x67, 0xa7, 0x6e, 0x31, 0xb9,
896 0x2b, 0x9b, 0x35, 0xa8, 0xe5, 0x47, 0x1b, 0xb1, 0x7e, 0x30,
897 0x3c, 0x6b ),
898 EXPECT ( 0x49, 0x7c, 0x7a, 0x16, 0xe8, 0x8a, 0x64, 0x11, 0xf8, 0xfc,
899 0xe1, 0x0e, 0xf5, 0x67, 0x63, 0xc6, 0x10, 0x25, 0x80, 0x1d,
900 0x8f, 0x51, 0xa7, 0x43, 0x52, 0xd6, 0x82, 0xcc, 0x23, 0xa0,
901 0xa8, 0xe6, 0x73, 0xca, 0xe0, 0x32, 0x28, 0x93, 0x90, 0x64,
902 0x7d, 0xc6, 0x83, 0xb7, 0x34, 0x28, 0x85, 0xd6, 0xb7, 0x6a,
903 0xb1, 0xda, 0x69, 0x6d, 0x3e, 0x97, 0xe2, 0x2d, 0xff, 0xdd,
904 0xff, 0xfd, 0x8d, 0xf0 ) );
905
906 /** SHA-256 Test 5 : Instantiation */
907 #define sha256_instantiate_5 sha256_instantiate_1
908
909 /** SHA-256 Test 5.1 : First call to Generate */
910 HMAC_DRBG_TEST_GENERATE_FAIL ( sha256_generate_fail_5_1, HMAC_DRBG_SHA256,
911 additional_input_empty, ( 512 / 8 ) );
912
913 /** SHA-256 Test 5.2 : Reseed */
914 HMAC_DRBG_TEST_RESEED ( sha256_reseed_5_2, HMAC_DRBG_SHA256,
915 entropy_input_1, additional_input_empty,
916 EXPECT ( 0xb8, 0x40, 0x07, 0xe3, 0xe2, 0x7f, 0x34, 0xf9, 0xa7, 0x82,
917 0x0b, 0x7a, 0xb5, 0x9b, 0xbe, 0xfc, 0xd0, 0xc4, 0xac, 0xae,
918 0xde, 0x4b, 0x0b, 0x36, 0xb1, 0x47, 0xb8, 0x97, 0x79, 0xfd,
919 0x74, 0x9d ),
920 EXPECT ( 0xa7, 0x2b, 0x8f, 0xee, 0x92, 0x39, 0x2f, 0x0a, 0x9d, 0x2d,
921 0x61, 0xbf, 0x09, 0xa4, 0xdf, 0xcc, 0x9d, 0xe6, 0x9a, 0x16,
922 0xa5, 0xf1, 0x50, 0x22, 0x4c, 0x3e, 0xf6, 0x04, 0x2d, 0x15,
923 0x21, 0xfc ) );
924
925 /** SHA-256 Test 5.3 : Retried first call to Generate */
926 HMAC_DRBG_TEST_GENERATE ( sha256_generate_5_3, HMAC_DRBG_SHA256,
927 additional_input_empty,
928 EXPECT ( 0x43, 0x48, 0xaf, 0x84, 0x20, 0x84, 0x2f, 0xa0, 0x77, 0xb9,
929 0xd3, 0xdb, 0xa8, 0xdc, 0xe9, 0xb3, 0xe1, 0xdf, 0x73, 0x4f,
930 0xfc, 0xe1, 0xbe, 0xa5, 0xb9, 0xe2, 0xb1, 0x54, 0xdc, 0x5e,
931 0xc6, 0x15 ),
932 EXPECT ( 0xd2, 0xc1, 0xac, 0x27, 0x88, 0x5d, 0x43, 0x32, 0x76, 0x71,
933 0x31, 0x46, 0x32, 0xea, 0x60, 0x43, 0x3c, 0xca, 0x72, 0x73,
934 0x04, 0x56, 0x9e, 0xa7, 0xd4, 0x71, 0xfe, 0xa7, 0xdb, 0x7d,
935 0x31, 0x5d ),
936 EXPECT ( 0xfa, 0xbd, 0x0a, 0xe2, 0x5c, 0x69, 0xdc, 0x2e, 0xfd, 0xef,
937 0xb7, 0xf2, 0x0c, 0x5a, 0x31, 0xb5, 0x7a, 0xc9, 0x38, 0xab,
938 0x77, 0x1a, 0xa1, 0x9b, 0xf8, 0xf5, 0xf1, 0x46, 0x8f, 0x66,
939 0x5c, 0x93, 0x8c, 0x9a, 0x1a, 0x5d, 0xf0, 0x62, 0x8a, 0x56,
940 0x90, 0xf1, 0x5a, 0x1a, 0xd8, 0xa6, 0x13, 0xf3, 0x1b, 0xbd,
941 0x65, 0xee, 0xad, 0x54, 0x57, 0xd5, 0xd2, 0x69, 0x47, 0xf2,
942 0x9f, 0xe9, 0x1a, 0xa7 ) );
943
944 /** SHA-256 Test 5.4 : Second call to Generate */
945 HMAC_DRBG_TEST_GENERATE_FAIL ( sha256_generate_fail_5_4, HMAC_DRBG_SHA256,
946 additional_input_empty, ( 512 / 8 ) );
947
948 /** SHA-256 Test 5.5 : Reseed */
949 HMAC_DRBG_TEST_RESEED ( sha256_reseed_5_5, HMAC_DRBG_SHA256,
950 entropy_input_2, additional_input_empty,
951 EXPECT ( 0xbf, 0xa0, 0x2c, 0xe7, 0xe9, 0x2d, 0xe9, 0x2b, 0x18, 0x24,
952 0x28, 0x86, 0x89, 0x0e, 0x58, 0x6f, 0x83, 0x69, 0x06, 0xac,
953 0xe9, 0xe5, 0x54, 0xf1, 0xb0, 0xed, 0x63, 0x57, 0x3c, 0xb8,
954 0xb5, 0x03 ),
955 EXPECT ( 0xd3, 0x24, 0x03, 0xee, 0xa9, 0xdc, 0xe1, 0x61, 0x6e, 0x4e,
956 0x11, 0x55, 0xb9, 0x23, 0xd8, 0x84, 0x2c, 0xc6, 0xe7, 0x84,
957 0xc6, 0x7a, 0x93, 0x85, 0xb2, 0xa6, 0x37, 0xf1, 0x02, 0xfa,
958 0x45, 0xd5 ) );
959
960 /** SHA-256 Test 5.6 : Retried second call to Generate */
961 HMAC_DRBG_TEST_GENERATE ( sha256_generate_5_6, HMAC_DRBG_SHA256,
962 additional_input_empty,
963 EXPECT ( 0x81, 0x21, 0xf7, 0x76, 0x4c, 0x08, 0x1e, 0xe9, 0xd1, 0x17,
964 0x1e, 0xd1, 0x87, 0xba, 0xe0, 0x88, 0x95, 0xca, 0xe2, 0x30,
965 0xd0, 0xa2, 0x5e, 0x37, 0x39, 0xc5, 0x7d, 0x54, 0x16, 0x10,
966 0x9b, 0x82 ),
967 EXPECT ( 0x37, 0x84, 0x97, 0x7c, 0xc0, 0xe5, 0x9f, 0xbc, 0x9c, 0xda,
968 0x4e, 0x11, 0x92, 0x47, 0x5c, 0x6e, 0xfa, 0xf8, 0x07, 0x20,
969 0x19, 0x86, 0x21, 0x22, 0xcb, 0x6b, 0xce, 0xaa, 0xcc, 0x4a,
970 0x17, 0x5e ),
971 EXPECT ( 0x6b, 0xd9, 0x25, 0xb0, 0xe1, 0xc2, 0x32, 0xef, 0xd6, 0x7c,
972 0xcd, 0x84, 0xf7, 0x22, 0xe9, 0x27, 0xec, 0xb4, 0x6a, 0xb2,
973 0xb7, 0x40, 0x01, 0x47, 0x77, 0xaf, 0x14, 0xba, 0x0b, 0xbf,
974 0x53, 0xa4, 0x5b, 0xdb, 0xb6, 0x2b, 0x3f, 0x7d, 0x0b, 0x9c,
975 0x8e, 0xea, 0xd0, 0x57, 0xc0, 0xec, 0x75, 0x4e, 0xf8, 0xb5,
976 0x3e, 0x60, 0xa1, 0xf4, 0x34, 0xf0, 0x59, 0x46, 0xa8, 0xb6,
977 0x86, 0xaf, 0xbc, 0x7a ) );
978
979 /** SHA-256 Test 6 : Instantiate */
980 #define sha256_instantiate_6 sha256_instantiate_1
981
982 /** SHA-256 Test 6.1 : First call to Generate */
983 HMAC_DRBG_TEST_GENERATE_FAIL ( sha256_generate_fail_6_1, HMAC_DRBG_SHA256,
984 additional_input_1, ( 512 / 8 ) );
985
986 /** SHA-256 Test 6.2 : Reseed */
987 HMAC_DRBG_TEST_RESEED ( sha256_reseed_6_2, HMAC_DRBG_SHA256,
988 entropy_input_1, additional_input_1,
989 EXPECT ( 0xc1, 0x25, 0xea, 0x99, 0x75, 0x8e, 0xbb, 0x9a, 0x6f, 0x69,
990 0xae, 0x31, 0x2a, 0xc2, 0x04, 0xb5, 0x94, 0xc0, 0x0a, 0xb6,
991 0x8b, 0x81, 0x6e, 0x3a, 0x52, 0x12, 0x8e, 0x02, 0x78, 0xa5,
992 0x84, 0xac ),
993 EXPECT ( 0xb2, 0xcb, 0x2b, 0x89, 0x12, 0x3f, 0x5b, 0x4a, 0xf5, 0x87,
994 0xb8, 0xf6, 0xbd, 0xc5, 0x42, 0x7a, 0x99, 0x14, 0x19, 0xd3,
995 0x53, 0x07, 0x7c, 0x68, 0x5e, 0x70, 0x7a, 0xcd, 0xf8, 0xe9,
996 0xfd, 0xa9 ) );
997
998 /** SHA-256 Test 6.3 : Retried first call to Generate */
999 HMAC_DRBG_TEST_GENERATE ( sha256_generate_6_3, HMAC_DRBG_SHA256,
1000 additional_input_empty,
1001 EXPECT ( 0xc6, 0xed, 0x8f, 0xed, 0x71, 0x57, 0xa4, 0xd0, 0x9e, 0xa1,
1002 0xdd, 0xe8, 0x94, 0x6b, 0x54, 0x43, 0x3e, 0xcc, 0x54, 0x49,
1003 0xa4, 0xa3, 0x52, 0xaf, 0x45, 0x76, 0x4e, 0xe6, 0x73, 0x4b,
1004 0xbb, 0x04 ),
1005 EXPECT ( 0xeb, 0xc7, 0x75, 0x25, 0x6b, 0xb7, 0x81, 0x24, 0x1e, 0x9c,
1006 0x70, 0xbb, 0xcf, 0x73, 0x2b, 0xdc, 0x90, 0xad, 0x10, 0xd9,
1007 0xdd, 0x3a, 0x89, 0x6e, 0xcc, 0x12, 0xb9, 0x2f, 0xfb, 0x63,
1008 0x45, 0xab ),
1009 EXPECT ( 0x08, 0x5d, 0x57, 0xaf, 0x6b, 0xab, 0xcf, 0x2b, 0x9a, 0xee,
1010 0xf3, 0x87, 0xd5, 0x31, 0x65, 0x0e, 0x6a, 0x50, 0x5c, 0x54,
1011 0x40, 0x6a, 0xb3, 0x7a, 0x52, 0x89, 0x9e, 0x0e, 0xca, 0xb3,
1012 0x63, 0x2b, 0x7a, 0x06, 0x8a, 0x28, 0x14, 0xc6, 0xdf, 0x6a,
1013 0xe5, 0x32, 0xb6, 0x58, 0xd0, 0xd9, 0x74, 0x1c, 0x84, 0x77,
1014 0x5f, 0xee, 0x45, 0xb6, 0x84, 0xcd, 0xbd, 0xc2, 0x5f, 0xbc,
1015 0xb4, 0xd8, 0xf3, 0x10 ) );
1016
1017 /** SHA-256 Test 6.4 : Second call to Generate */
1018 HMAC_DRBG_TEST_GENERATE_FAIL ( sha256_generate_fail_6_4, HMAC_DRBG_SHA256,
1019 additional_input_2, ( 512 / 8 ) );
1020
1021 /** SHA-256 Test 6.5 : Reseed */
1022 HMAC_DRBG_TEST_RESEED ( sha256_reseed_6_5, HMAC_DRBG_SHA256,
1023 entropy_input_2, additional_input_2,
1024 EXPECT ( 0xfc, 0x51, 0xda, 0x84, 0xf9, 0x69, 0x6b, 0xcc, 0x84, 0xc8,
1025 0xf2, 0xac, 0xb9, 0x24, 0xbc, 0xdf, 0x72, 0xf8, 0x2e, 0xa2,
1026 0xca, 0x64, 0x3f, 0x08, 0x3b, 0x0c, 0x16, 0xc3, 0x63, 0x4e,
1027 0xfc, 0x62 ),
1028 EXPECT ( 0xb9, 0x74, 0xe4, 0x37, 0x0a, 0xd5, 0x76, 0xbb, 0x99, 0xc4,
1029 0xe4, 0x9e, 0xa6, 0x80, 0xbf, 0xf9, 0x8d, 0xe9, 0xe1, 0x2f,
1030 0xec, 0xd0, 0x13, 0xde, 0xd4, 0x3c, 0x80, 0xf6, 0x9a, 0x7a,
1031 0xde, 0x8a ) );
1032
1033 /** SHA-256 Test 6.6 : Retried second call to Generate */
1034 HMAC_DRBG_TEST_GENERATE ( sha256_generate_6_6, HMAC_DRBG_SHA256,
1035 additional_input_empty,
1036 EXPECT ( 0x56, 0xa2, 0xb4, 0x46, 0x32, 0xcb, 0x8f, 0xc3, 0xa6, 0x40,
1037 0x09, 0xbf, 0xd6, 0xec, 0x95, 0xe5, 0x6c, 0xef, 0x8e, 0x7c,
1038 0x91, 0x2a, 0xa8, 0x2b, 0x16, 0xf6, 0x14, 0x91, 0x5d, 0x9c,
1039 0xd6, 0xe3 ),
1040 EXPECT ( 0xb5, 0xb3, 0x96, 0xa0, 0x15, 0x76, 0xb0, 0xfe, 0x42, 0xf4,
1041 0x08, 0x44, 0x55, 0x6c, 0x4c, 0xf4, 0xb6, 0x80, 0x4c, 0x94,
1042 0xde, 0x9d, 0x62, 0x38, 0xf1, 0xf7, 0xe7, 0xaf, 0x5c, 0x72,
1043 0x57, 0xf3 ),
1044 EXPECT ( 0x9b, 0x21, 0x9f, 0xd9, 0x0d, 0xe2, 0xa0, 0x8e, 0x49, 0x34,
1045 0x05, 0xcf, 0x87, 0x44, 0x17, 0xb5, 0x82, 0x67, 0x70, 0xf3,
1046 0x94, 0x48, 0x15, 0x55, 0xdc, 0x66, 0x8a, 0xcd, 0x96, 0xb9,
1047 0xa3, 0xe5, 0x6f, 0x9d, 0x2c, 0x32, 0x5e, 0x26, 0xd4, 0x7c,
1048 0x1d, 0xfc, 0xfc, 0x8f, 0xbf, 0x86, 0x12, 0x6f, 0x40, 0xa1,
1049 0xe6, 0x39, 0x60, 0xf6, 0x27, 0x49, 0x34, 0x2e, 0xcd, 0xb7,
1050 0x1b, 0x24, 0x0d, 0xc6 ) );
1051
1052 /** SHA-256 Test 7 : Instantiation */
1053 #define sha256_instantiate_7 sha256_instantiate_3
1054
1055 /** SHA-256 Test 7.1 : First call to Generate */
1056 HMAC_DRBG_TEST_GENERATE_FAIL ( sha256_generate_fail_7_1, HMAC_DRBG_SHA256,
1057 additional_input_empty, ( 512 / 8 ) );
1058
1059 /** SHA-256 Test 7.2 : Reseed */
1060 HMAC_DRBG_TEST_RESEED ( sha256_reseed_7_2, HMAC_DRBG_SHA256,
1061 entropy_input_1, additional_input_empty,
1062 EXPECT ( 0x44, 0x76, 0xc6, 0xd1, 0x1f, 0xc3, 0x5d, 0x44, 0x09, 0xd9,
1063 0x03, 0x2e, 0x45, 0x3b, 0x0f, 0x0d, 0xc3, 0x31, 0x4d, 0xb8,
1064 0x62, 0xcb, 0xdb, 0x60, 0x9c, 0x56, 0x02, 0x20, 0x8d, 0x4c,
1065 0x88, 0xd8 ),
1066 EXPECT ( 0x95, 0xef, 0x78, 0x5a, 0x61, 0xc2, 0xf7, 0xb3, 0x6b, 0xc5,
1067 0x96, 0xba, 0x4b, 0xa2, 0x08, 0xa5, 0x2c, 0x6d, 0xc2, 0x03,
1068 0x63, 0x6d, 0x8f, 0x17, 0x87, 0x45, 0x3b, 0x85, 0x2b, 0x7e,
1069 0x49, 0xec ) );
1070
1071 /** SHA-256 Test 7.3 : Retried first call to Generate */
1072 HMAC_DRBG_TEST_GENERATE ( sha256_generate_7_3, HMAC_DRBG_SHA256,
1073 additional_input_empty,
1074 EXPECT ( 0x0d, 0xf9, 0x11, 0x0e, 0x2f, 0x22, 0x58, 0x98, 0x24, 0xa9,
1075 0x47, 0x6c, 0x8e, 0x32, 0x08, 0x8e, 0x51, 0xa0, 0xda, 0x36,
1076 0x63, 0x3f, 0x8c, 0xd1, 0xf7, 0x54, 0x7d, 0xff, 0x69, 0x6e,
1077 0x4b, 0x29 ),
1078 EXPECT ( 0xc0, 0xe3, 0xc8, 0xed, 0x5a, 0x8b, 0x57, 0x9e, 0x3f, 0xef,
1079 0x9d, 0xf3, 0xb7, 0xc2, 0xc2, 0x12, 0x98, 0x07, 0x17, 0xcc,
1080 0x91, 0xae, 0x18, 0x66, 0x45, 0xfa, 0xbb, 0x2c, 0xc7, 0x84,
1081 0xd5, 0xd7 ),
1082 EXPECT ( 0xd8, 0xb6, 0x71, 0x30, 0x71, 0x41, 0x94, 0xff, 0xe5, 0xb2,
1083 0xa3, 0x5d, 0xbc, 0xd5, 0xe1, 0xa2, 0x99, 0x42, 0xad, 0x5c,
1084 0x68, 0xf3, 0xde, 0xb9, 0x4a, 0xdd, 0x9e, 0x9e, 0xba, 0xd8,
1085 0x60, 0x67, 0xed, 0xf0, 0x49, 0x15, 0xfb, 0x40, 0xc3, 0x91,
1086 0xea, 0xe7, 0x0c, 0x65, 0x9e, 0xaa, 0xe7, 0xef, 0x11, 0xa3,
1087 0xd4, 0x6a, 0x5b, 0x08, 0x5e, 0xdd, 0x90, 0xcc, 0x72, 0xce,
1088 0xa9, 0x89, 0x21, 0x0b ) );
1089
1090 /** SHA-256 Test 7.4 : Second call to Generate */
1091 HMAC_DRBG_TEST_GENERATE_FAIL ( sha256_generate_fail_7_4, HMAC_DRBG_SHA256,
1092 additional_input_empty, ( 512 / 8 ) );
1093
1094 /** SHA-256 Test 7.5 : Reseed */
1095 HMAC_DRBG_TEST_RESEED ( sha256_reseed_7_5, HMAC_DRBG_SHA256,
1096 entropy_input_2, additional_input_empty,
1097 EXPECT ( 0x3d, 0x77, 0x63, 0xe5, 0x30, 0x3d, 0xb5, 0x4b, 0xe2, 0x05,
1098 0x44, 0xa8, 0x1e, 0x9f, 0x00, 0xca, 0xdc, 0xfc, 0x1c, 0xb2,
1099 0x8d, 0xec, 0xb9, 0xcf, 0xc6, 0x99, 0xf6, 0x1d, 0xba, 0xf8,
1100 0x80, 0x21 ),
1101 EXPECT ( 0xfe, 0xbc, 0x02, 0x79, 0xb7, 0x71, 0x0d, 0xec, 0x5c, 0x06,
1102 0x7e, 0xbe, 0xfa, 0x06, 0x8e, 0x4b, 0x59, 0x67, 0x49, 0x1b,
1103 0x7e, 0xef, 0x94, 0x75, 0x83, 0x50, 0x6d, 0x04, 0x97, 0xce,
1104 0x67, 0xba ) );
1105
1106 /** SHA-256 Test 7.6 : Retried second call to Generate */
1107 HMAC_DRBG_TEST_GENERATE ( sha256_generate_7_6, HMAC_DRBG_SHA256,
1108 additional_input_empty,
1109 EXPECT ( 0x2d, 0x21, 0xac, 0x94, 0x99, 0x2f, 0xd8, 0x2b, 0x09, 0x80,
1110 0xd3, 0xd5, 0x95, 0x51, 0xb9, 0xd0, 0x7c, 0x8d, 0x54, 0xb2,
1111 0x52, 0xb6, 0x16, 0x28, 0x93, 0x44, 0xf8, 0xac, 0x86, 0x9e,
1112 0xd3, 0x5b ),
1113 EXPECT ( 0x61, 0x0c, 0x34, 0xcd, 0xbf, 0x6f, 0x75, 0x33, 0x54, 0x7f,
1114 0x23, 0x32, 0xea, 0xc5, 0x7e, 0xe3, 0x1e, 0x72, 0x4f, 0xb2,
1115 0x92, 0x55, 0x56, 0x6b, 0x59, 0x78, 0x33, 0x16, 0x6c, 0xd0,
1116 0x39, 0x9f ),
1117 EXPECT ( 0x8b, 0xba, 0x71, 0xc2, 0x58, 0x3f, 0x25, 0x30, 0xc2, 0x59,
1118 0xc9, 0x07, 0x84, 0xa5, 0x9a, 0xc4, 0x4d, 0x1c, 0x80, 0x56,
1119 0x91, 0x7c, 0xcf, 0x38, 0x87, 0x88, 0x10, 0x2d, 0x73, 0x82,
1120 0x4c, 0x6c, 0x11, 0xd5, 0xd6, 0x3b, 0xe1, 0xf0, 0x10, 0x17,
1121 0xd8, 0x84, 0xcd, 0x69, 0xd9, 0x33, 0x4b, 0x9e, 0xbc, 0x01,
1122 0xe7, 0xbd, 0x8f, 0xdf, 0x2a, 0x8e, 0x52, 0x57, 0x22, 0x93,
1123 0xdc, 0x21, 0xc0, 0xe1 ) );
1124
1125 /** SHA-256 Test 8 : Instantiate */
1126 #define sha256_instantiate_8 sha256_instantiate_3
1127
1128 /** SHA-256 Test 8.1 : First call to Generate */
1129 HMAC_DRBG_TEST_GENERATE_FAIL ( sha256_generate_fail_8_1, HMAC_DRBG_SHA256,
1130 additional_input_1, ( 512 / 8 ) );
1131
1132 /** SHA-256 Test 8.2 : Reseed */
1133 HMAC_DRBG_TEST_RESEED ( sha256_reseed_8_2, HMAC_DRBG_SHA256,
1134 entropy_input_1, additional_input_1,
1135 EXPECT ( 0xb3, 0x81, 0x38, 0x8c, 0x1d, 0x7c, 0xfd, 0x56, 0x59, 0x30,
1136 0x99, 0x3b, 0xd9, 0x26, 0x90, 0x66, 0x50, 0x88, 0xd9, 0xb8,
1137 0x39, 0x96, 0x9b, 0x87, 0xf1, 0x6d, 0xb6, 0xdf, 0x4e, 0x43,
1138 0x00, 0xd7 ),
1139 EXPECT ( 0xfa, 0x04, 0x25, 0x64, 0x00, 0xe3, 0x42, 0xe6, 0x55, 0xf4,
1140 0x33, 0x26, 0x94, 0xe3, 0xb2, 0x4c, 0x04, 0xfb, 0x85, 0xbf,
1141 0x87, 0x80, 0x21, 0xe4, 0x52, 0xe7, 0x3b, 0x8f, 0x46, 0xd4,
1142 0xbd, 0xc6 ) );
1143
1144 /** SHA-256 Test 8.3 : Retried first call to Generate */
1145 HMAC_DRBG_TEST_GENERATE ( sha256_generate_8_3, HMAC_DRBG_SHA256,
1146 additional_input_empty,
1147 EXPECT ( 0xd4, 0x1f, 0x6f, 0x33, 0x65, 0x82, 0x21, 0x70, 0x50, 0xb1,
1148 0xf6, 0x59, 0x28, 0xfd, 0x6e, 0x94, 0xcb, 0xc9, 0x45, 0x68,
1149 0xfe, 0x3b, 0x6b, 0x53, 0x38, 0x9e, 0x1e, 0x3a, 0x5b, 0x49,
1150 0xe1, 0x01 ),
1151 EXPECT ( 0xa6, 0x55, 0xc9, 0xe7, 0xd1, 0x33, 0xf1, 0xcd, 0x8b, 0x11,
1152 0x61, 0xf2, 0x7d, 0x54, 0xe7, 0x5a, 0x7e, 0x7c, 0x80, 0x42,
1153 0xbf, 0x74, 0xd4, 0x7f, 0x9f, 0xfd, 0x60, 0xe2, 0x45, 0xeb,
1154 0xa5, 0x7e ),
1155 EXPECT ( 0x44, 0xd7, 0x8b, 0xbc, 0x3e, 0xb6, 0x7c, 0x59, 0xc2, 0x2f,
1156 0x6c, 0x31, 0x00, 0x3d, 0x21, 0x2a, 0x78, 0x37, 0xcc, 0xd8,
1157 0x4c, 0x43, 0x8b, 0x55, 0x15, 0x0f, 0xd0, 0x13, 0xa8, 0xa7,
1158 0x8f, 0xe8, 0xed, 0xea, 0x81, 0xc6, 0x72, 0xe4, 0xb8, 0xdd,
1159 0xc8, 0x18, 0x38, 0x86, 0xe6, 0x9c, 0x2e, 0x17, 0x7d, 0xf5,
1160 0x74, 0xc1, 0xf1, 0x90, 0xdf, 0x27, 0x18, 0x50, 0xf8, 0xce,
1161 0x55, 0xef, 0x20, 0xb8 ) );
1162
1163 /** SHA-256 Test 8.4 : Second call to Generate */
1164 HMAC_DRBG_TEST_GENERATE_FAIL ( sha256_generate_fail_8_4, HMAC_DRBG_SHA256,
1165 additional_input_2, ( 512 / 8 ) );
1166
1167 /** SHA-256 Test 8.5 : Reseed */
1168 HMAC_DRBG_TEST_RESEED ( sha256_reseed_8_5, HMAC_DRBG_SHA256,
1169 entropy_input_2, additional_input_2,
1170 EXPECT ( 0xfb, 0xa8, 0x05, 0x45, 0x3e, 0x3c, 0x9a, 0x73, 0x64, 0x58,
1171 0x5c, 0xed, 0xbc, 0xd2, 0x92, 0x30, 0xfb, 0xc9, 0x3d, 0x6f,
1172 0x12, 0x9d, 0x21, 0xed, 0xdd, 0xf6, 0x61, 0x3b, 0x3a, 0x8f,
1173 0xf2, 0x83 ),
1174 EXPECT ( 0x83, 0x64, 0x7a, 0x33, 0x8c, 0x15, 0x3c, 0xba, 0xf0, 0xe4,
1175 0x9a, 0x54, 0xa4, 0x4f, 0xea, 0x66, 0x70, 0xcf, 0xd7, 0xc1,
1176 0x71, 0x4d, 0x4a, 0xb3, 0x5f, 0x11, 0x12, 0x3d, 0xf2, 0x7b,
1177 0x69, 0xcf ) );
1178
1179 /** SHA-256 Test 8.6 : Retried second call to Generate */
1180 HMAC_DRBG_TEST_GENERATE ( sha256_generate_8_6, HMAC_DRBG_SHA256,
1181 additional_input_empty,
1182 EXPECT ( 0xae, 0x59, 0xc7, 0x0a, 0x7c, 0x60, 0xed, 0x49, 0x83, 0x78,
1183 0xea, 0x84, 0x5b, 0xe9, 0x7d, 0x8f, 0xf8, 0x81, 0xe0, 0xea,
1184 0x37, 0x2e, 0x26, 0x5f, 0xa6, 0x72, 0x84, 0x29, 0x3e, 0x1a,
1185 0x46, 0xac ),
1186 EXPECT ( 0xe2, 0xf0, 0x4d, 0xe3, 0xce, 0x21, 0x79, 0x61, 0xae, 0x2b,
1187 0x2d, 0x20, 0xa7, 0xba, 0x7c, 0x6c, 0x82, 0x0b, 0x5b, 0x14,
1188 0x92, 0x6e, 0x59, 0x56, 0xae, 0x6d, 0xfa, 0x2e, 0xd1, 0xd6,
1189 0x39, 0x93 ),
1190 EXPECT ( 0x91, 0x77, 0x80, 0xdc, 0x0c, 0xe9, 0x98, 0x9f, 0xee, 0x6c,
1191 0x08, 0x06, 0xd6, 0xda, 0x12, 0x3a, 0x18, 0x25, 0x29, 0x47,
1192 0x58, 0xd4, 0xe1, 0xb5, 0x82, 0x68, 0x72, 0x31, 0x78, 0x0a,
1193 0x2a, 0x9c, 0x33, 0xf1, 0xd1, 0x56, 0xcc, 0xad, 0x32, 0x77,
1194 0x64, 0xb2, 0x9a, 0x4c, 0xb2, 0x69, 0x01, 0x77, 0xae, 0x96,
1195 0xef, 0x9e, 0xe9, 0x2a, 0xd0, 0xc3, 0x40, 0xba, 0x0f, 0xd1,
1196 0x20, 0x3c, 0x02, 0xc6 ) );
1197
1198 /**
1199 * Force a "reseed required" state
1200 *
1201 * @v state HMAC_DRBG internal state
1202 */
1203 static inline void force_reseed_required ( struct hmac_drbg_state *state ) {
1204 state->reseed_counter = ( HMAC_DRBG_RESEED_INTERVAL + 1 );
1205 }
1206
1207 /**
1208 * Perform HMAC_DRBG self-test
1209 *
1210 */
1211 static void hmac_drbg_test_exec ( void ) {
1212 struct hmac_drbg_state state;
1213
1214 /*
1215 * IMPORTANT NOTE
1216 *
1217 * The NIST test vector set includes several calls to
1218 * HMAC_DRBG_Generate() that are expected to fail with a
1219 * status of "Reseed required". The pattern seems to be that
1220 * when prediction resistance is requested, any call to
1221 * HMAC_DRBG_Generate() is at first expected to fail. After
1222 * an explicit reseeding, the call to HMAC_DRBG_Generate() is
1223 * retried, and on this second time it is expected to succeed.
1224 *
1225 * This pattern does not match the specifications for
1226 * HMAC_DRBG_Generate(): neither HMAC_DRBG_Generate_algorithm
1227 * (defined in ANS X9.82 Part 3-2007 Section 10.2.2.2.5 (NIST
1228 * SP 800-90 Section 10.1.2.5)) nor the higher-level wrapper
1229 * Generate_function defined in ANS X9.82 Part 3-2007 Section
1230 * 9.4 (NIST SP 800-90 Section 9.3)) can possibly exhibit this
1231 * behaviour:
1232 *
1233 * a) HMAC_DRBG_Generate_algorithm can return a "reseed
1234 * required" status only as a result of the test
1235 *
1236 * "1. If reseed_counter > reseed_interval, then return
1237 * an indication that a reseed is required."
1238 *
1239 * Since the reseed interval is independent of any request
1240 * for prediction resistance, and since the reseed interval
1241 * is not specified as part of the NIST test vector set,
1242 * then this cannot be the source of the "Reseed required"
1243 * failure expected by the NIST test vector set.
1244 *
1245 * b) Generate_function cannot return a "reseed required"
1246 * status under any circumstances. If the underlying
1247 * HMAC_DRBG_Generate_algorithm call returns "reseed
1248 * required", then Generate_function will automatically
1249 * reseed and try again.
1250 *
1251 * To produce the behaviour expected by the NIST test vector
1252 * set, we therefore contrive to produce a "reseed required"
1253 * state where necessary by setting the reseed_counter to
1254 * greater than the reseed_interval.
1255 */
1256
1257 /* SHA-1 Test 1 */
1258 instantiate_ok ( &state, &sha1_instantiate_1 );
1259 generate_ok ( &state, &sha1_generate_1_1 );
1260 generate_ok ( &state, &sha1_generate_1_2 );
1261
1262 /* SHA-1 Test 2 */
1263 instantiate_ok ( &state, &sha1_instantiate_2 );
1264 generate_ok ( &state, &sha1_generate_2_1 );
1265 generate_ok ( &state, &sha1_generate_2_2 );
1266
1267 /* SHA-1 Test 3 */
1268 instantiate_ok ( &state, &sha1_instantiate_3 );
1269 generate_ok ( &state, &sha1_generate_3_1 );
1270 generate_ok ( &state, &sha1_generate_3_2 );
1271
1272 /* SHA-1 Test 4 */
1273 instantiate_ok ( &state, &sha1_instantiate_4 );
1274 generate_ok ( &state, &sha1_generate_4_1 );
1275 generate_ok ( &state, &sha1_generate_4_2 );
1276
1277 /* SHA-1 Test 5 */
1278 instantiate_ok ( &state, &sha1_instantiate_5 );
1279 force_reseed_required ( &state ); /* See above comments */
1280 generate_fail_ok ( &state, &sha1_generate_fail_5_1 );
1281 reseed_ok ( &state, &sha1_reseed_5_2 );
1282 generate_ok ( &state, &sha1_generate_5_3 );
1283 force_reseed_required ( &state ); /* See above comments */
1284 generate_fail_ok ( &state, &sha1_generate_fail_5_4 );
1285 reseed_ok ( &state, &sha1_reseed_5_5 );
1286 generate_ok ( &state, &sha1_generate_5_6 );
1287
1288 /* SHA-1 Test 6 */
1289 instantiate_ok ( &state, &sha1_instantiate_6 );
1290 force_reseed_required ( &state ); /* See above comments */
1291 generate_fail_ok ( &state, &sha1_generate_fail_6_1 );
1292 reseed_ok ( &state, &sha1_reseed_6_2 );
1293 generate_ok ( &state, &sha1_generate_6_3 );
1294 force_reseed_required ( &state ); /* See above comments */
1295 generate_fail_ok ( &state, &sha1_generate_fail_6_4 );
1296 reseed_ok ( &state, &sha1_reseed_6_5 );
1297 generate_ok ( &state, &sha1_generate_6_6 );
1298
1299 /* SHA-1 Test 7 */
1300 instantiate_ok ( &state, &sha1_instantiate_7 );
1301 force_reseed_required ( &state ); /* See above comments */
1302 generate_fail_ok ( &state, &sha1_generate_fail_7_1 );
1303 reseed_ok ( &state, &sha1_reseed_7_2 );
1304 generate_ok ( &state, &sha1_generate_7_3 );
1305 force_reseed_required ( &state ); /* See above comments */
1306 generate_fail_ok ( &state, &sha1_generate_fail_7_4 );
1307 reseed_ok ( &state, &sha1_reseed_7_5 );
1308 generate_ok ( &state, &sha1_generate_7_6 );
1309
1310 /* SHA-1 Test 8 */
1311 instantiate_ok ( &state, &sha1_instantiate_8 );
1312 force_reseed_required ( &state ); /* See above comments */
1313 generate_fail_ok ( &state, &sha1_generate_fail_8_1 );
1314 reseed_ok ( &state, &sha1_reseed_8_2 );
1315 generate_ok ( &state, &sha1_generate_8_3 );
1316 force_reseed_required ( &state ); /* See above comments */
1317 generate_fail_ok ( &state, &sha1_generate_fail_8_4 );
1318 reseed_ok ( &state, &sha1_reseed_8_5 );
1319 generate_ok ( &state, &sha1_generate_8_6 );
1320
1321 /* SHA-256 Test 1 */
1322 instantiate_ok ( &state, &sha256_instantiate_1 );
1323 generate_ok ( &state, &sha256_generate_1_1 );
1324 generate_ok ( &state, &sha256_generate_1_2 );
1325
1326 /* SHA-256 Test 2 */
1327 instantiate_ok ( &state, &sha256_instantiate_2 );
1328 generate_ok ( &state, &sha256_generate_2_1 );
1329 generate_ok ( &state, &sha256_generate_2_2 );
1330
1331 /* SHA-256 Test 3 */
1332 instantiate_ok ( &state, &sha256_instantiate_3 );
1333 generate_ok ( &state, &sha256_generate_3_1 );
1334 generate_ok ( &state, &sha256_generate_3_2 );
1335
1336 /* SHA-256 Test 4 */
1337 instantiate_ok ( &state, &sha256_instantiate_4 );
1338 generate_ok ( &state, &sha256_generate_4_1 );
1339 generate_ok ( &state, &sha256_generate_4_2 );
1340
1341 /* SHA-256 Test 5 */
1342 instantiate_ok ( &state, &sha256_instantiate_5 );
1343 force_reseed_required ( &state ); /* See above comments */
1344 generate_fail_ok ( &state, &sha256_generate_fail_5_1 );
1345 reseed_ok ( &state, &sha256_reseed_5_2 );
1346 generate_ok ( &state, &sha256_generate_5_3 );
1347 force_reseed_required ( &state ); /* See above comments */
1348 generate_fail_ok ( &state, &sha256_generate_fail_5_4 );
1349 reseed_ok ( &state, &sha256_reseed_5_5 );
1350 generate_ok ( &state, &sha256_generate_5_6 );
1351
1352 /* SHA-256 Test 6 */
1353 instantiate_ok ( &state, &sha256_instantiate_6 );
1354 force_reseed_required ( &state ); /* See above comments */
1355 generate_fail_ok ( &state, &sha256_generate_fail_6_1 );
1356 reseed_ok ( &state, &sha256_reseed_6_2 );
1357 generate_ok ( &state, &sha256_generate_6_3 );
1358 force_reseed_required ( &state ); /* See above comments */
1359 generate_fail_ok ( &state, &sha256_generate_fail_6_4 );
1360 reseed_ok ( &state, &sha256_reseed_6_5 );
1361 generate_ok ( &state, &sha256_generate_6_6 );
1362
1363 /* SHA-256 Test 7 */
1364 instantiate_ok ( &state, &sha256_instantiate_7 );
1365 force_reseed_required ( &state ); /* See above comments */
1366 generate_fail_ok ( &state, &sha256_generate_fail_7_1 );
1367 reseed_ok ( &state, &sha256_reseed_7_2 );
1368 generate_ok ( &state, &sha256_generate_7_3 );
1369 force_reseed_required ( &state ); /* See above comments */
1370 generate_fail_ok ( &state, &sha256_generate_fail_7_4 );
1371 reseed_ok ( &state, &sha256_reseed_7_5 );
1372 generate_ok ( &state, &sha256_generate_7_6 );
1373
1374 /* SHA-256 Test 8 */
1375 instantiate_ok ( &state, &sha256_instantiate_8 );
1376 force_reseed_required ( &state ); /* See above comments */
1377 generate_fail_ok ( &state, &sha256_generate_fail_8_1 );
1378 reseed_ok ( &state, &sha256_reseed_8_2 );
1379 generate_ok ( &state, &sha256_generate_8_3 );
1380 force_reseed_required ( &state ); /* See above comments */
1381 generate_fail_ok ( &state, &sha256_generate_fail_8_4 );
1382 reseed_ok ( &state, &sha256_reseed_8_5 );
1383 generate_ok ( &state, &sha256_generate_8_6 );
1384 }
1385
1386 /** HMAC_DRBG self-test */
1387 struct self_test hmac_drbg_test __self_test = {
1388 .name = "hmac_drbg",
1389 .exec = hmac_drbg_test_exec,
1390 };