blob: b429670db105f3ef6b4e889b7551486e5df053aa [file] [log] [blame]
David Brownfecda2d2017-09-07 10:20:34 -06001/* test_ctr_prng.c - TinyCrypt implementation of some CTR-PRNG tests */
2
3/*
4 * Copyright (c) 2016, Chris Morrison, All Rights Reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * * Redistributions of source code must retain the above copyright notice, this
10 * list of conditions and the following disclaimer.
11 *
12 * * Redistributions in binary form must reproduce the above copyright notice,
13 * this list of conditions and the following disclaimer in the documentation
14 * and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/*
30 DESCRIPTION
31 This module tests the CTR-PRNG routines
32*/
33
34#include <tinycrypt/ctr_prng.h>
35#include <tinycrypt/aes.h>
36#include <tinycrypt/constants.h>
37#include <test_utils.h>
38
39
40#include <stdio.h>
41#include <stdlib.h>
42#include <string.h>
43
44/* utility function to convert hex character representation to their nibble (4 bit) values */
45static uint8_t nibbleFromChar(char c)
46{
47 if(c >= '0' && c <= '9') return c - '0';
48 if(c >= 'a' && c <= 'f') return c - 'a' + 10U;
49 if(c >= 'A' && c <= 'F') return c - 'A' + 10U;
50 return 255U;
51}
52
53/*
54 * Convert a string of characters representing a hex buffer into a series of
55 * bytes of that real value
56 */
57uint8_t *hexStringToBytes(char *inhex)
58{
59 uint8_t *retval;
60 uint8_t *p;
61 int len, i;
62
63 len = strlen(inhex) / 2;
64 retval = (uint8_t *)malloc(len+1);
65 for(i=0, p = (uint8_t *) inhex; i<len; i++) {
66 retval[i] = (nibbleFromChar(*p) << 4) | nibbleFromChar(*(p+1));
67 p += 2;
68 }
69 retval[len] = 0;
70 return retval;
71}
72
73typedef struct
74{
75 char * entropyString;
76 char * personalizationString; /* may be null */
77 char * additionalInputString1; /* may be null */
78 char * additionalInputString2; /* may be null */
79 char * expectedString;
80} PRNG_Vector;
81
82/* vectors taken from NIST CAVS 14.3 CTR_DRBG.rsp */
83PRNG_Vector vectors[] = {
84 /*
85 * AES-128 no df, PredictionResistance = False, EntropyInputLen = 256,
86 * NonceLen = 0, PersonalizationStringLen = 0, AdditionalInputLen = 0,
87 * ReturnedBitsLen = 512
88 */
89 { /* Count 0 */
90 "ce50f33da5d4c1d3d4004eb35244b7f2cd7f2e5076fbf6780a7ff634b249a5fc",
91 0,
92 0,
93 0,
94 "6545c0529d372443b392ceb3ae3a99a30f963eaf313280f1d1a1e87f9db373d361e75d18018266499cccd64d9bbb8de0185f213383080faddec46bae1f784e5a",
95 },
96
97 { /* Count 1 */
98 "a385f70a4d450321dfd18d8379ef8e7736fee5fbf0a0aea53b76696094e8aa93",
99 0,
100 0,
101 0,
102 "1a062553ab60457ed1f1c52f5aca5a3be564a27545358c112ed92c6eae2cb7597cfcc2e0a5dd81c5bfecc941da5e8152a9010d4845170734676c8c1b6b3073a5",
103 },
104
105 /*
106 * AES-128 no df, PredictionResistance = False, EntropyInputLen = 256,
107 * NonceLen = 0, PersonalizationStringLen = 0, AdditionalInputLen = 256,
108 * ReturnedBitsLen = 512
109 */
110 { /* Count 0 */
111 "6bd4f2ae649fc99350951ff0c5d460c1a9214154e7384975ee54b34b7cae0704",
112 0,
113 "ecd4893b979ac92db1894ae3724518a2f78cf2dbe2f6bbc6fda596df87c7a4ae",
114 "b23e9188687c88768b26738862c4791fa52f92502e1f94bf66af017c4228a0dc",
115 "5b2bf7a5c60d8ab6591110cbd61cd387b02de19784f496d1a109123d8b3562a5de2dd6d5d1aef957a6c4f371cecd93c15799d82e34d6a0dba7e915a27d8e65f3",
116 },
117
118 { /* Count 1 */
119 "e2addbde2a76e769fc7aa3f45b31402f482b73bbe7067ad6254621f06d3ef68b",
120 0,
121 "ad11643b019e31245e4ea41f18f7680458310580fa6efad275c5833e7f800dae",
122 "b5d849616b3123c9725d188cd0005003220768d1200f9e7cc29ef6d88afb7b9a",
123 "132d0d50c8477a400bb8935be5928f916a85da9ffcf1a8f6e9f9a14cca861036cda14cf66d8953dab456b632cf687cd539b4b807926561d0b3562b9d3334fb61",
124 },
125
126 /*
127 * AES-128 no df, PredictionResistance = False, EntropyInputLen = 256,
128 * NonceLen = 0, PersonalizationStringLen = 256, AdditionalInputLen = 0,
129 * ReturnedBitsLen = 512
130 */
131 { /* Count 0 */
132 "cee23de86a69c7ef57f6e1e12bd16e35e51624226fa19597bf93ec476a44b0f2",
133 "a2ef16f226ea324f23abd59d5e3c660561c25e73638fe21c87566e86a9e04c3e",
134 0,
135 0,
136 "2a76d71b329f449c98dc08fff1d205a2fbd9e4ade120c7611c225c984eac8531288dd3049f3dc3bb3671501ab8fbf9ad49c86cce307653bd8caf29cb0cf07764",
137 },
138
139 { /* Count 1 */
140 "b09eb4a82a39066ec945bb7c6aef6a0682a62c3e674bd900297d4271a5f25b49",
141 "a3b768adcfe76d61c972d900da8dffeeb2a42e740247aa719ed1c924d2d10bd4",
142 0,
143 0,
144 "5a1c26803f3ffd4daf32042fdcc32c3812bb5ef13bc208cef82ea047d2890a6f5dcecf32bcc32a2585775ac5e1ffaa8de00664c54fe00a7674b985619e953c3a",
145 },
146
147 /*
148 * AES-128 no df, PredictionResistance = False, EntropyInputLen = 256,
149 * NonceLen = 0, PersonalizationStringLen = 256, AdditionalInputLen = 256,
150 * ReturnedBitsLen = 512
151 */
152 { /* Count 0 */
153 "50b96542a1f2b8b05074051fe8fb0e45adbbd5560e3594e12d485fe1bfcb741f",
154 "820c3030f97b3ead81a93b88b871937278fd3d711d2085d9280cba394673b17e",
155 "1f1632058806d6d8e231288f3b15a3c324e90ccef4891bd595f09c3e80e27469",
156 "5cadc8bfd86d2a5d44f921f64c7d153001b9bdd7caa6618639b948ebfad5cb8a",
157 "02b76a66f103e98d450e25e09c35337747d987471d2b3d81e03be24c7e985417a32acd72bc0a6eddd9871410dacb921c659249b4e2b368c4ac8580fb5db559bc",
158 },
159
160 { /* Count 1 */
161 "ff5f4b754e8b364f6df0c5effba5f1c036de49c4b38cd8d230ee1f14d7234ef5",
162 "994eb339f64034005d2e18352899e77df446e285c3430631d557498aac4f4280",
163 "e1824832d5fc2a6dea544cac2ab73306d6566bde98cc8f9425d064b860a9b218",
164 "c08b42433a78fd393a34ffc24724d479af08c36882799c134165d98b2866dc0a",
165 "1efa34aed07dd57bde9741b8d1907d28e8c1ac71601df37ef4295e6ffb67f6a1c4c13e5def65d505e2408aeb82948999ca1f9c9113b99a6b59ff7f0cc3dc6e92",
166 },
167
168 /*
169 * AES-128 no df, PredictionResistance = False, EntropyInputLen = 256,
170 * NonceLen = 0, PersonalizationStringLen = 0, AdditionalInputLen = 0,
171 * ReturnedBitsLen = 512
172 */
173 { /* Count 0 */
174 "69a09f6bf5dda15cd4af29e14cf5e0cddd7d07ac39bba587f8bc331104f9c448",
175 0,
176 0,
177 0,
178 "f78a4919a6ec899f7b6c69381febbbe083315f3d289e70346db0e4ec4360473ae0b3d916e9b6b964309f753ed66ae59de48da316cc1944bc8dfd0e2575d0ff6d",
179 },
180
181 { /* Count 1 */
182 "80bfbd340d79888f34f043ed6807a9f28b72b6644d9d9e9d777109482b80788a",
183 0,
184 0,
185 0,
186 "80db048d2f130d864b19bfc547c92503e580cb1a8e1f74f3d97fdda6501fb1aa81fcedac0dd18b6ccfdc183ca28a44fc9f3a08834ba8751a2f4495367c54a185",
187 },
188
189 /*
190 * AES-128 no df, PredictionResistance = False, EntropyInputLen = 256,
191 * NonceLen = 0, PersonalizationStringLen = 0, AdditionalInputLen = 256,
192 * ReturnedBitsLen = 512
193 */
194 { /* Count 0 */
195 "7f40804693552e317523fda6935a5bc814353b1fbb7d334964ac4d1d12ddccce",
196 0,
197 "95c04259f64fcd1fe00c183aa3fb76b8a73b4d1243b800d770e38515bc41143c",
198 "5523102dbd7fe1228436b91a765b165ae6405eb0236e237afad4759cf0888941",
199 "1abf6bccb4c2d64e5187b1e2e34e493eca204ee4eef0d964267e38228f5f20efba376430a266f3832916d0a45b2703f46401dfd145e447a0a1667ebd8b6ee748",
200 },
201
202 { /* Count 1 */
203 "350df677409a1dc297d01d3716a2abdfa6272cd030ab75f76839648582b47113",
204 0,
205 "ba5709a12ae6634a5436b7ea06838b48f7b847a237f6654a0e27c776ebee9511",
206 "f1b2c717c5e3a934127e10471d67accc65f4a45010ca53b35f54c88833dbd8e7",
207 "1ef1ea279812e8abe54f7ffd12d04c80ae40741f4ccfe232a5fba3a78dfd3e2ed419b88ee9188df724160cbb3aea0f276e84a3c0ff01e3b89fe30ebcfa64cb86",
208 },
209
210 /*
211 * AES-128 no df, PredictionResistance = False, EntropyInputLen = 256,
212 * NonceLen = 0, PersonalizationStringLen = 256, AdditionalInputLen = 0,
213 * ReturnedBitsLen = 512
214 */
215 { /* Count 0 */
216 "3fef762f0aa0677f61c65d749eeb10b013ff68ccc6314f150cfee752dcd8f987",
217 "f56db099240c7590dac396372b8737404d418b2864a3df96a8a397967245735f",
218 0,
219 0,
220 "af0afe0837442136fbb1959a1c91a9291c1d8188ede07c67d0e4dd6541303415e7a67999c302ba0df555324c26077514592a9b6db6be2f153fad2250161164e4",
221 },
222
223 { /* Count 1 */
224 "3eebe77db4631862e3eb7e39370515b8baa1cdd71a5b1b0cda79c14d0b5f48ea",
225 "4be56a9b9c21242739c985ef12aa4d98e8c7da07c4c1dc6829f2e06833cfa148",
226 0,
227 0,
228 "be9e18a753df261927473c8bb5fb7c3ea6e821df5ab49adc566a4ebf44f75fa825b1f9d8c154bcd469134c0bb688e07e3c3e45407ca350d540e1528cc2e64068",
229 },
230
231 /*
232 * AES-128 no df, PredictionResistance = False, EntropyInputLen = 256,
233 * NonceLen = 0, PersonalizationStringLen = 256, AdditionalInputLen = 256,
234 * ReturnedBitsLen = 512
235 */
236 { /* Count 0 */
237 "c129c2732003bbf1d1dec244a933cd04cb47199bbce98fe080a1be880afb2155",
238 "64e2b9ac5c20642e3e3ee454b7463861a7e93e0dd1bbf8c4a0c28a6cb3d811ba",
239 "f94f0975760d52f47bd490d1623a9907e4df701f601cf2d573aba803a29d2b51",
240 "6f99720b186e2028a5fcc586b3ea518458e437ff449c7c5a318e6d13f75b5db7",
241 "7b8b3378b9031ab3101cec8af5b8ba5a9ca2a9af41432cd5f2e5e19716140bb219ed7f4ba88fc37b2d7e146037d2cac1128ffe14131c8691e581067a29cacf80",
242 },
243
244 { /* Count 1 */
245 "7667643670254b3530e80a17b16b22406e84efa6a4b5ceef3ebc877495fc6048",
246 "40b92969953acde756747005117e46eff6893d7132a8311ffb1062280367326b",
247 "797a02ffbe8ff2c94ed0e5d39ebdc7847adaa762a88238242ed8f71f5635b194",
248 "d617f0f0e609e90d814192ba2e5214293d485402cdf9f789cc78b05e8c374f18",
249 "e8d6f89dca9825aed8927b43187492a98ca8648db30f0ac709556d401a8ac2b959c81350fc64332c4c0deb559a286a72e65dbb462bd872f9b28c0728f353dc10",
250 }
251};
252
253static uint32_t executePRNG_TestVector(PRNG_Vector vector, uint32_t idx)
254{
255 uint32_t result = TC_PASS;
256 uint8_t * entropy = hexStringToBytes(vector.entropyString);
257 uint32_t entropylen = strlen(vector.entropyString) / 2U;
258
259 uint8_t * expected = hexStringToBytes(vector.expectedString);
260 uint32_t expectedlen = strlen(vector.expectedString) / 2U;
261
262 uint8_t * personalization = 0;
263 uint32_t plen = 0U;
264
265 uint8_t * additional_input1 = 0;
266 uint32_t additionallen1 = 0U;
267
268 uint8_t * additional_input2 = 0;
269 uint32_t additionallen2 = 0U;
270
271 uint8_t * output = (uint8_t *)malloc(expectedlen);
272
273 uint32_t i;
274 TCCtrPrng_t ctx;
275
276 if (0 != vector.personalizationString)
277 {
278 personalization = hexStringToBytes(vector.personalizationString);
279 plen = strlen(vector.personalizationString) / 2U;
280 }
281
282 if (0 != vector.additionalInputString1)
283 {
284 additional_input1 = hexStringToBytes(vector.additionalInputString1);
285 additionallen1 = strlen(vector.additionalInputString1) / 2U;
286 }
287
288 if (0 != vector.additionalInputString2)
289 {
290 additional_input2 = hexStringToBytes(vector.additionalInputString2);
291 additionallen2 = strlen(vector.additionalInputString2) / 2U;
292 }
293
294 (void)tc_ctr_prng_init(&ctx, entropy, entropylen, personalization, plen);
295
296 (void)tc_ctr_prng_generate(&ctx, additional_input1, additionallen1, output, expectedlen);
297 (void)tc_ctr_prng_generate(&ctx, additional_input2, additionallen2, output, expectedlen);
298
299 for (i = 0U; i < expectedlen; i++)
300 {
301 if (output[i] != expected[i])
302 {
303 TC_ERROR("CTR PRNG test #%d failed\n", idx);
304 result = TC_FAIL;
305 break;
306 }
307 }
308
309 free(entropy);
310 free(expected);
311 free(personalization);
312 free(additional_input1);
313 free(additional_input2);
314 free(output);
315
316 return result;
317}
318
319static int32_t test_reseed(void)
320{
321 int32_t result = TC_PASS;
322 uint8_t entropy[32U] = {0U}; /* value not important */
323 uint8_t additional_input[32] = {0U};
324 uint8_t output[32];
325 TCCtrPrng_t ctx;
326 int32_t ret;
327 uint32_t i;
328
329 (void)tc_ctr_prng_init(&ctx, entropy, sizeof entropy, 0, 0U);
330
331 /* force internal state to max allowed count */
332 ctx.reseedCount = 0x1000000000000ULL;
333
334 ret = tc_ctr_prng_generate(&ctx, 0, 0, output, sizeof output);
335 if (1 != ret)
336 {
337 result = TC_FAIL;
338 goto exitTest;
339 }
340
341 /* expect further attempts to fail due to reaching reseed threshold */
342 ret = tc_ctr_prng_generate(&ctx, 0, 0, output, sizeof output);
343 if (-1 != ret)
344 {
345 result = TC_FAIL;
346 goto exitTest;
347 }
348
349 /* reseed and confirm generate works again */
350 /* make entropy different from original value - not really important for the purpose of this test */
351 memset(entropy, 0xFF, sizeof entropy);
352 ret = tc_ctr_prng_reseed(&ctx, entropy, sizeof entropy, additional_input, sizeof additional_input);
353 if (1 != ret)
354 {
355 result = TC_FAIL;
356 goto exitTest;
357 }
358
359 ret = tc_ctr_prng_generate(&ctx, 0, 0, output, sizeof output);
360 if (1 != ret)
361 {
362 result = TC_FAIL;
363 goto exitTest;
364 }
365
366 /* confirm entropy and additional_input are being used correctly */
367 /* first, entropy only */
368 memset(&ctx, 0x0, sizeof ctx);
369 for (i = 0U; i < sizeof entropy; i++)
370 {
371 entropy[i] = i;
372 }
373 ret = tc_ctr_prng_reseed(&ctx, entropy, sizeof entropy, 0, 0U);
374 if (1 != ret)
375 {
376 result = TC_FAIL;
377 goto exitTest;
378 }
379 {
380 uint8_t expectedV[] =
381 {0x7EU, 0xE3U, 0xA0U, 0xCBU, 0x6DU, 0x5CU, 0x4BU, 0xC2U,
382 0x4BU, 0x7EU, 0x3CU, 0x48U, 0x88U, 0xC3U, 0x69U, 0x70U};
383 for (i = 0U; i < sizeof expectedV; i++)
384 {
385 if (ctx.V[i] != expectedV[i])
386 {
387 result = TC_FAIL;
388 goto exitTest;
389 }
390 }
391 }
392
393 /* now, entropy and additional_input */
394 memset(&ctx, 0x0, sizeof ctx);
395 for (i = 0U; i < sizeof additional_input; i++)
396 {
397 additional_input[i] = i * 2U;
398 }
399 ret = tc_ctr_prng_reseed(&ctx, entropy, sizeof entropy, additional_input, sizeof additional_input);
400 if (1 != ret)
401 {
402 result = TC_FAIL;
403 goto exitTest;
404 }
405 {
406 uint8_t expectedV[] =
407 {0x5EU, 0xC1U, 0x84U, 0xEDU, 0x45U, 0x76U, 0x67U, 0xECU,
408 0x7BU, 0x4CU, 0x08U, 0x7EU, 0xB0U, 0xF9U, 0x55U, 0x4EU};
409 for (i = 0U; i < sizeof expectedV; i++)
410 {
411 if (ctx.V[i] != expectedV[i])
412 {
413 result = TC_FAIL;
414 goto exitTest;
415 }
416 }
417 }
418
419 exitTest:
420 if (TC_FAIL == result)
421 {
422 TC_ERROR("CTR PRNG reseed tests failed\n");
423 }
424 return result;
425}
426
427static int32_t test_uninstantiate(void)
428{
429 uint32_t i;
430 int32_t result = TC_PASS;
431 uint8_t entropy[32U] = {0U}; /* value not important */
432 TCCtrPrng_t ctx;
433
434 (void)tc_ctr_prng_init(&ctx, entropy, sizeof entropy, 0, 0U);
435
436 tc_ctr_prng_uninstantiate(&ctx);
437 /* show that state has been zeroised */
438 for (i = 0U; i < sizeof ctx.V; i++)
439 {
440 if (0U != ctx.V[i])
441 {
442 TC_ERROR("CTR PRNG uninstantiate tests failed\n");
443 result = TC_FAIL;
444 break;
445 }
446 }
447
448 for (i = 0U; i < sizeof ctx.key.words / sizeof ctx.key.words[0]; i++)
449 {
450 if (0U != ctx.key.words[i])
451 {
452 TC_ERROR("CTR PRNG uninstantiate tests failed\n");
453 result = TC_FAIL;
454 break;
455 }
456 }
457
458 if (0U != ctx.reseedCount)
459 {
460 TC_ERROR("CTR PRNG uninstantiate tests failed\n");
461 result = TC_FAIL;
462 }
463
464 return result;
465}
466
467static int32_t test_robustness(void)
468{
469 int32_t result = TC_PASS;
470 int32_t ret;
471 uint8_t entropy[32U] = {0U}; /* value not important */
472 uint8_t output[32];
473 TCCtrPrng_t ctx;
474
475
476 /* show that the CTR PRNG is robust to invalid inputs */
477 tc_ctr_prng_uninstantiate(0);
478
479 ret = tc_ctr_prng_generate(&ctx, 0, 0, 0, 0);
480 if (0 != ret)
481 {
482 result = TC_FAIL;
483 goto exitTest;
484 }
485
486 ret = tc_ctr_prng_generate(0, 0, 0, output, sizeof output);
487 if (0 != ret)
488 {
489 result = TC_FAIL;
490 goto exitTest;
491 }
492
493 ret = tc_ctr_prng_generate(0, 0, 0, 0, 0);
494 if (0 != ret)
495 {
496 result = TC_FAIL;
497 goto exitTest;
498 }
499
500 ret = tc_ctr_prng_reseed(&ctx, 0, 0, 0, 0);
501 if (0 != ret)
502 {
503 result = TC_FAIL;
504 goto exitTest;
505 }
506
507 /* too little entropy */
508 ret = tc_ctr_prng_reseed(&ctx, entropy, (sizeof entropy) - 1U, 0, 0);
509 if (0 != ret)
510 {
511 result = TC_FAIL;
512 goto exitTest;
513 }
514
515 ret = tc_ctr_prng_reseed(0, entropy, sizeof entropy, 0, 0);
516 if (0 != ret)
517 {
518 result = TC_FAIL;
519 goto exitTest;
520 }
521
522 ret = tc_ctr_prng_reseed(0, 0, 0, 0, 0);
523 if (0 != ret)
524 {
525 result = TC_FAIL;
526 goto exitTest;
527 }
528
529 ret = tc_ctr_prng_init(&ctx, 0, 0, 0, 0);
530 if (0 != ret)
531 {
532 result = TC_FAIL;
533 goto exitTest;
534 }
535
536 /* too little entropy */
537 ret = tc_ctr_prng_init(&ctx, entropy, (sizeof entropy) - 1U, 0, 0);
538 if (0 != ret)
539 {
540 result = TC_FAIL;
541 goto exitTest;
542 }
543
544 ret = tc_ctr_prng_init(0, entropy, sizeof entropy, 0, 0);
545 if (0 != ret)
546 {
547 result = TC_FAIL;
548 goto exitTest;
549 }
550
551 ret = tc_ctr_prng_init(0, 0, 0, 0, 0);
552 if (0 != ret)
553 {
554 result = TC_FAIL;
555 goto exitTest;
556 }
557
558 exitTest:
559 if (TC_FAIL == result)
560 {
561 TC_ERROR("CTR PRNG reseed tests failed\n");
562 }
563
564
565 return result;
566}
567
568/*
569 * Main task to test CTR PRNG
570 */
571int main(void)
572{
573 int32_t result = TC_PASS;
574 uint32_t i;
575 TC_START("Performing CTR-PRNG tests:");
576 for (i = 0U; i < sizeof vectors / sizeof vectors[0]; i++)
577 {
578 result = executePRNG_TestVector(vectors[i], i);
579 if (TC_PASS != result)
580 {
581 goto exitTest;
582 }
583 }
584
585 if (TC_PASS != test_reseed())
586 {
587 goto exitTest;
588 }
589
590 if (TC_PASS != test_uninstantiate())
591 {
592 goto exitTest;
593 }
594
595 if (TC_PASS != test_robustness())
596 {
597 goto exitTest;
598 }
599
600 TC_PRINT("All CTR PRNG tests succeeded!\n");
601
602 exitTest:
603 TC_END_RESULT(result);
604 TC_END_REPORT(result);
605
606}