Extension of DRBG selftests using new data.
[openssl.git] / fips / rand / fips_drbg_selftest.c
1 /* fips/rand/fips_drbg_selftest.c */
2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3  * project.
4  */
5 /* ====================================================================
6  * Copyright (c) 2011 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer. 
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    licensing@OpenSSL.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  */
53
54 #define OPENSSL_FIPSAPI
55
56 #include <string.h>
57 #include <openssl/crypto.h>
58 #include <openssl/err.h>
59 #include <openssl/fips_rand.h>
60 #include "fips_rand_lcl.h"
61 #include "fips_locl.h"
62
63 #include "fips_drbg_selftest.h"
64
65 typedef struct {
66         int nid;
67         unsigned int flags;
68
69         /* KAT data for no PR */
70         const unsigned char *ent;
71         size_t entlen;
72         const unsigned char *nonce;
73         size_t noncelen;
74         const unsigned char *pers;
75         size_t perslen;
76         const unsigned char *adin;
77         size_t adinlen;
78         const unsigned char *entreseed;
79         size_t entreseedlen;
80         const unsigned char *adinreseed;
81         size_t adinreseedlen;
82         const unsigned char *adin2;
83         size_t adin2len;
84         const unsigned char *kat;
85         size_t katlen;
86         const unsigned char *kat2;
87         size_t kat2len;
88
89         /* KAT data for PR */
90         const unsigned char *ent_pr;
91         size_t entlen_pr;
92         const unsigned char *nonce_pr;
93         size_t noncelen_pr;
94         const unsigned char *pers_pr;
95         size_t perslen_pr;
96         const unsigned char *adin_pr;
97         size_t adinlen_pr;
98         const unsigned char *entpr_pr;
99         size_t entprlen_pr;
100         const unsigned char *ading_pr;
101         size_t adinglen_pr;
102         const unsigned char *entg_pr;
103         size_t entglen_pr;
104         const unsigned char *kat_pr;
105         size_t katlen_pr;
106         const unsigned char *kat2_pr;
107         size_t kat2len_pr;
108
109         } DRBG_SELFTEST_DATA;
110
111 #define make_drbg_test_data(nid, flag, pr) { nid, flag | DRBG_FLAG_TEST, \
112         pr##_entropyinput, sizeof(pr##_entropyinput), \
113         pr##_nonce, sizeof(pr##_nonce), \
114         pr##_personalizationstring, sizeof(pr##_personalizationstring), \
115         pr##_additionalinput, sizeof(pr##_additionalinput), \
116         pr##_entropyinputreseed, sizeof(pr##_entropyinputreseed), \
117         pr##_additionalinputreseed, sizeof(pr##_additionalinputreseed), \
118         pr##_additionalinput2, sizeof(pr##_additionalinput2), \
119         pr##_int_returnedbits, sizeof(pr##_int_returnedbits), \
120         pr##_returnedbits, sizeof(pr##_returnedbits), \
121         pr##_pr_entropyinput, sizeof(pr##_pr_entropyinput), \
122         pr##_pr_nonce, sizeof(pr##_pr_nonce), \
123         pr##_pr_personalizationstring, sizeof(pr##_pr_personalizationstring), \
124         pr##_pr_additionalinput, sizeof(pr##_pr_additionalinput), \
125         pr##_pr_entropyinputpr, sizeof(pr##_pr_entropyinputpr), \
126         pr##_pr_additionalinput2, sizeof(pr##_pr_additionalinput2), \
127         pr##_pr_entropyinputpr2, sizeof(pr##_pr_entropyinputpr2), \
128         pr##_pr_int_returnedbits, sizeof(pr##_pr_int_returnedbits), \
129         pr##_pr_returnedbits, sizeof(pr##_pr_returnedbits), \
130         }
131
132 #define make_drbg_test_data_df(nid, pr) \
133         make_drbg_test_data(nid, DRBG_FLAG_CTR_USE_DF, pr)
134
135 static DRBG_SELFTEST_DATA drbg_test[] = {
136         make_drbg_test_data_df(NID_aes_128_ctr, aes_128_use_df),
137         make_drbg_test_data_df(NID_aes_192_ctr, aes_192_use_df),
138         make_drbg_test_data_df(NID_aes_256_ctr, aes_256_use_df),
139         make_drbg_test_data(NID_aes_128_ctr, 0, aes_128_no_df),
140         make_drbg_test_data(NID_aes_192_ctr, 0, aes_192_no_df),
141         make_drbg_test_data(NID_aes_256_ctr, 0, aes_256_no_df),
142         make_drbg_test_data(NID_sha1, 0, sha1),
143         make_drbg_test_data(NID_sha224, 0, sha224),
144         make_drbg_test_data(NID_sha256, 0, sha256),
145         make_drbg_test_data(NID_sha384, 0, sha384),
146         make_drbg_test_data(NID_sha512, 0, sha512),
147         make_drbg_test_data(NID_hmacWithSHA1, 0, hmac_sha1),
148         make_drbg_test_data(NID_hmacWithSHA224, 0, hmac_sha224),
149         make_drbg_test_data(NID_hmacWithSHA256, 0, hmac_sha256),
150         make_drbg_test_data(NID_hmacWithSHA384, 0, hmac_sha384),
151         make_drbg_test_data(NID_hmacWithSHA512, 0, hmac_sha512),
152         {0,0,0}
153         };
154
155 typedef struct 
156         {
157         const unsigned char *ent;
158         size_t entlen;
159         int entcnt;
160         const unsigned char *nonce;
161         size_t noncelen;
162         int noncecnt;
163         } TEST_ENT;
164
165 static size_t test_entropy(DRBG_CTX *dctx, unsigned char **pout,
166                                 int entropy, size_t min_len, size_t max_len)
167         {
168         TEST_ENT *t = FIPS_drbg_get_app_data(dctx);
169         *pout = (unsigned char *)t->ent;
170         t->entcnt++;
171         return t->entlen;
172         }
173
174 static size_t test_nonce(DRBG_CTX *dctx, unsigned char **pout,
175                                 int entropy, size_t min_len, size_t max_len)
176         {
177         TEST_ENT *t = FIPS_drbg_get_app_data(dctx);
178         *pout = (unsigned char *)t->nonce;
179         t->noncecnt++;
180         return t->noncelen;
181         }
182
183 static int fips_drbg_single_kat(DRBG_CTX *dctx, DRBG_SELFTEST_DATA *td)
184         {
185         TEST_ENT t;
186         int rv = 0;
187         size_t adinlen;
188         unsigned char randout[1024];
189
190         /* Initial test without PR */
191
192         if (!FIPS_drbg_init(dctx, td->nid, td->flags))
193                 return 0;
194         if (!FIPS_drbg_set_callbacks(dctx, test_entropy, 0, 0, test_nonce, 0))
195                 return 0;
196
197         FIPS_drbg_set_app_data(dctx, &t);
198
199         t.ent = td->ent;
200         t.entlen = td->entlen;
201         t.nonce = td->nonce;
202         t.noncelen = td->noncelen;
203         t.entcnt = 0;
204         t.noncecnt = 0;
205
206         if (!FIPS_drbg_instantiate(dctx, td->pers, td->perslen))
207                 goto err;
208
209         /* Note for CTR without DF some additional input values
210          * ignore bytes after the keylength: so reduce adinlen
211          * to half to ensure invalid data is fed in.
212          */
213         if (!fips_post_corrupt(FIPS_TEST_DRBG, dctx->type, &dctx->flags))
214                 adinlen = td->adinlen / 2;
215         else
216                 adinlen = td->adinlen;
217         if (!FIPS_drbg_generate(dctx, randout, td->katlen, 0, 0,
218                                 td->adin, adinlen))
219                 goto err;
220
221         if (memcmp(randout, td->kat, td->katlen))
222                 goto err;
223
224         t.ent = td->entreseed;
225         t.entlen = td->entreseedlen;
226
227         if (!FIPS_drbg_reseed(dctx, td->adinreseed, td->adinreseedlen))
228                 goto err;
229
230         if (!FIPS_drbg_generate(dctx, randout, td->kat2len, 0, 0,
231                                 td->adin2, td->adin2len))
232                 goto err;
233
234         if (memcmp(randout, td->kat2, td->kat2len))
235                 goto err;
236
237         FIPS_drbg_uninstantiate(dctx);
238
239         /* Now test with PR */
240         if (!FIPS_drbg_init(dctx, td->nid, td->flags))
241                 return 0;
242         if (!FIPS_drbg_set_callbacks(dctx, test_entropy, 0, 0, test_nonce, 0))
243                 return 0;
244
245         FIPS_drbg_set_app_data(dctx, &t);
246
247         t.ent = td->ent_pr;
248         t.entlen = td->entlen_pr;
249         t.nonce = td->nonce_pr;
250         t.noncelen = td->noncelen_pr;
251         t.entcnt = 0;
252         t.noncecnt = 0;
253
254         if (!FIPS_drbg_instantiate(dctx, td->pers_pr, td->perslen_pr))
255                 goto err;
256
257         t.ent = td->entpr_pr;
258         t.entlen = td->entprlen_pr;
259
260         /* Note for CTR without DF some additional input values
261          * ignore bytes after the keylength: so reduce adinlen
262          * to half to ensure invalid data is fed in.
263          */
264         if (!fips_post_corrupt(FIPS_TEST_DRBG, dctx->type, &dctx->flags))
265                 adinlen = td->adinlen_pr / 2;
266         else
267                 adinlen = td->adinlen_pr;
268         if (!FIPS_drbg_generate(dctx, randout, td->katlen_pr, 0, 1,
269                                 td->adin_pr, adinlen))
270                 goto err;
271
272         if (memcmp(randout, td->kat_pr, td->katlen_pr))
273                 goto err;
274
275         t.ent = td->entg_pr;
276         t.entlen = td->entglen_pr;
277
278         if (!FIPS_drbg_generate(dctx, randout, td->kat2len_pr, 0, 1,
279                                 td->ading_pr, td->adinglen_pr))
280                 goto err;
281
282         if (memcmp(randout, td->kat2_pr, td->kat2len_pr))
283                 goto err;
284
285         rv = 1;
286
287         err:
288         if (rv == 0)
289                 FIPSerr(FIPS_F_FIPS_DRBG_SINGLE_KAT, FIPS_R_SELFTEST_FAILED);
290         FIPS_drbg_uninstantiate(dctx);
291         
292         return rv;
293
294         }
295
296 /* This is the "health check" function required by SP800-90. Induce several
297  * failure modes and check an error condition is set.
298  */
299
300 static int fips_drbg_health_check(DRBG_CTX *dctx, DRBG_SELFTEST_DATA *td)
301         {
302         unsigned char randout[1024];
303         TEST_ENT t;
304         size_t i;
305         unsigned char *p = (unsigned char *)dctx;
306
307         /* Initialise DRBG */
308
309         if (!FIPS_drbg_init(dctx, td->nid, td->flags))
310                 goto err;
311
312         if (!FIPS_drbg_set_callbacks(dctx, test_entropy, 0, 0, test_nonce, 0))
313                 goto err;
314
315         FIPS_drbg_set_app_data(dctx, &t);
316
317         t.ent = td->ent;
318         t.entlen = td->entlen;
319         t.nonce = td->nonce;
320         t.noncelen = td->noncelen;
321         t.entcnt = 0;
322         t.noncecnt = 0;
323
324         /* Don't report induced errors */
325         dctx->flags |= DRBG_FLAG_NOERR;
326
327         /* Try too large a personalisation length */
328         if (FIPS_drbg_instantiate(dctx, td->pers, dctx->max_pers + 1) > 0)
329                 {
330                 FIPSerr(FIPS_F_FIPS_DRBG_HEALTH_CHECK, FIPS_R_PERSONALISATION_ERROR_UNDETECTED);
331                 goto err;
332                 }
333
334         /* Test entropy source failure detection */
335
336         t.entlen = 0;
337         if (FIPS_drbg_instantiate(dctx, td->pers, td->perslen) > 0)
338                 {
339                 FIPSerr(FIPS_F_FIPS_DRBG_HEALTH_CHECK, FIPS_R_ENTROPY_ERROR_UNDETECTED);
340                 goto err;
341                 }
342
343         /* Try to generate output from uninstantiated DRBG */
344         if (FIPS_drbg_generate(dctx, randout, td->katlen, 0, 0,
345                                 td->adin, td->adinlen))
346                 {
347                 FIPSerr(FIPS_F_FIPS_DRBG_HEALTH_CHECK, FIPS_R_GENERATE_ERROR_UNDETECTED);
348                 goto err;
349                 }
350
351         dctx->flags &= ~DRBG_FLAG_NOERR;
352         if (!FIPS_drbg_uninstantiate(dctx))
353                 {
354                 FIPSerr(FIPS_F_FIPS_DRBG_HEALTH_CHECK, FIPS_R_UNINSTANTIATE_ERROR);
355                 goto err;
356                 }
357
358         /* Instantiate with valid data. NB: errors now reported again */
359         if (!FIPS_drbg_init(dctx, td->nid, td->flags))
360                 goto err;
361         if (!FIPS_drbg_set_callbacks(dctx, test_entropy, 0, 0, test_nonce, 0))
362                 goto err;
363         FIPS_drbg_set_app_data(dctx, &t);
364
365         t.entlen = td->entlen;
366         if (!FIPS_drbg_instantiate(dctx, td->pers, td->perslen))
367                 goto err;
368
369         /* Check generation is now OK */
370         if (!FIPS_drbg_generate(dctx, randout, td->katlen, 0, 0,
371                                 td->adin, td->adinlen))
372                 goto err;
373
374         /* Try to generate with too high a strength.
375          */
376
377         dctx->flags |= DRBG_FLAG_NOERR;
378         if (dctx->strength != 256)
379                 {
380                 if (FIPS_drbg_generate(dctx, randout, td->katlen, 256, 0,
381                                         td->adin, td->adinlen))
382                         {
383                         FIPSerr(FIPS_F_FIPS_DRBG_HEALTH_CHECK, FIPS_R_STRENGTH_ERROR_UNDETECTED);
384
385                         goto err;
386                         }
387                 }
388
389         /* Request too much data for one request */
390         if (FIPS_drbg_generate(dctx, randout, dctx->max_request + 1, 0, 0,
391                                 td->adin, td->adinlen))
392                 {
393                 FIPSerr(FIPS_F_FIPS_DRBG_HEALTH_CHECK, FIPS_R_REQUEST_LENGTH_ERROR_UNDETECTED);
394                 goto err;
395                 }
396
397         /* Check prediction resistance request fails if entropy source
398          * failure.
399          */
400
401         t.entlen = 0;
402
403         if (FIPS_drbg_generate(dctx, randout, td->katlen, 0, 1,
404                                 td->adin, td->adinlen))
405                 {
406                 FIPSerr(FIPS_F_FIPS_DRBG_HEALTH_CHECK, FIPS_R_ENTROPY_ERROR_UNDETECTED);
407                 goto err;
408                 }
409                 
410         dctx->flags &= ~DRBG_FLAG_NOERR;
411
412         if (!FIPS_drbg_uninstantiate(dctx))
413                 {
414                 FIPSerr(FIPS_F_FIPS_DRBG_HEALTH_CHECK, FIPS_R_UNINSTANTIATE_ERROR);
415                 goto err;
416                 }
417
418
419         /* Instantiate again with valid data */
420
421         if (!FIPS_drbg_init(dctx, td->nid, td->flags))
422                 goto err;
423         if (!FIPS_drbg_set_callbacks(dctx, test_entropy, 0, 0, test_nonce, 0))
424                 goto err;
425         FIPS_drbg_set_app_data(dctx, &t);
426
427         t.entlen = td->entlen;
428         /* Test reseeding works */
429         dctx->reseed_interval = 2;
430         if (!FIPS_drbg_instantiate(dctx, td->pers, td->perslen))
431                 goto err;
432
433         /* Check generation is now OK */
434         if (!FIPS_drbg_generate(dctx, randout, td->katlen, 0, 0,
435                                 td->adin, td->adinlen))
436                 goto err;
437         if (!FIPS_drbg_generate(dctx, randout, td->katlen, 0, 0,
438                                 td->adin, td->adinlen))
439                 goto err;
440
441         /* DRBG should now require a reseed */
442         if (dctx->status != DRBG_STATUS_RESEED)
443                 {
444                 FIPSerr(FIPS_F_FIPS_DRBG_HEALTH_CHECK, FIPS_R_RESEED_COUNTER_ERROR);
445                 goto err;
446                 }
447
448
449         /* Generate again and check entropy has been requested for reseed */
450         t.entcnt = 0;
451         if (!FIPS_drbg_generate(dctx, randout, td->katlen, 0, 0,
452                                 td->adin, td->adinlen))
453                 goto err;
454         if (t.entcnt != 1)
455                 {
456                 FIPSerr(FIPS_F_FIPS_DRBG_HEALTH_CHECK, FIPS_R_ENTROPY_NOT_REQUESTED_FOR_RESEED);
457                 goto err;
458                 }
459
460         FIPS_drbg_uninstantiate(dctx);
461         p = (unsigned char *)&dctx->d;
462         /* Standard says we have to check uninstantiate really zeroes
463          * the data...
464          */
465         for (i = 0; i < sizeof(dctx->d); i++)
466                 {
467                 if (*p != 0)
468                         {
469                         FIPSerr(FIPS_F_FIPS_DRBG_HEALTH_CHECK, FIPS_R_UNINSTANTIATE_ZEROISE_ERROR);
470                         goto err;
471                         }
472                 p++;
473                 }
474
475         return 1;
476
477         err:
478         /* A real error as opposed to an induced one: underlying function will
479          * indicate the error.
480          */
481         if (!(dctx->flags & DRBG_FLAG_NOERR))
482                 FIPSerr(FIPS_F_FIPS_DRBG_HEALTH_CHECK, FIPS_R_FUNCTION_ERROR);
483         FIPS_drbg_uninstantiate(dctx);
484         return 0;
485
486         }
487
488
489 int fips_drbg_kat(DRBG_CTX *dctx, int nid, unsigned int flags)
490         {
491         int rv;
492         DRBG_SELFTEST_DATA *td;
493         for (td = drbg_test; td->nid != 0; td++)
494                 {
495                 if (td->nid == nid && td->flags == flags)
496                         {
497                         rv = fips_drbg_single_kat(dctx, td);
498                         if (rv <= 0)
499                                 return rv;
500                         return fips_drbg_health_check(dctx, td);
501                         }
502                 }
503         return 0;
504         }
505
506 int FIPS_selftest_drbg(void)
507         {
508         DRBG_CTX *dctx;
509         DRBG_SELFTEST_DATA *td;
510         int rv = 1;
511         dctx = FIPS_drbg_new(0, 0);
512         if (!dctx)
513                 return 0;
514         for (td = drbg_test; td->nid != 0; td++)
515                 {
516                 if (!fips_post_started(FIPS_TEST_DRBG, td->nid, &td->flags))
517                         return 1;
518                 if (!fips_drbg_single_kat(dctx, td))
519                         {
520                         fips_post_failed(FIPS_TEST_DRBG, td->nid, &td->flags);
521                         rv = 0;
522                         continue;
523                         }
524                 if (!fips_drbg_health_check(dctx, td))
525                         {
526                         fips_post_failed(FIPS_TEST_DRBG, td->nid, &td->flags);
527                         rv = 0;
528                         continue;
529                         }
530                 if (!fips_post_success(FIPS_TEST_DRBG, td->nid, &td->flags))
531                         return 0;
532                 }
533         FIPS_drbg_free(dctx);
534         return rv;
535         }
536
537
538
539