kdf: make function naming consistent.
[openssl.git] / providers / fips / self_test_kats.c
1 /*
2  * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <string.h>
11 #include <openssl/evp.h>
12 #include <openssl/kdf.h>
13 #include <openssl/rand_drbg.h>
14 #include <openssl/core_names.h>
15 #include <openssl/param_build.h>
16 #include "internal/cryptlib.h"
17 #include "internal/nelem.h"
18 #include "self_test.h"
19 #include "self_test_data.inc"
20 #include "../../crypto/rand/rand_local.h"
21
22 #define DRBG_PARAM_ENTROPY "DRBG-ENTROPY"
23 #define DRBG_PARAM_NONCE   "DRBG-NONCE"
24
25 static int self_test_digest(const ST_KAT_DIGEST *t, OSSL_SELF_TEST *st,
26                             OPENSSL_CTX *libctx)
27 {
28     int ok = 0;
29     unsigned char out[EVP_MAX_MD_SIZE];
30     unsigned int out_len = 0;
31     EVP_MD_CTX *ctx = EVP_MD_CTX_new();
32     EVP_MD *md = EVP_MD_fetch(libctx, t->algorithm, NULL);
33
34     OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_KAT_DIGEST, t->desc);
35
36     if (ctx == NULL
37             || md == NULL
38             || !EVP_DigestInit_ex(ctx, md, NULL)
39             || !EVP_DigestUpdate(ctx, t->pt, t->pt_len)
40             || !EVP_DigestFinal(ctx, out, &out_len))
41         goto err;
42
43     /* Optional corruption */
44     OSSL_SELF_TEST_oncorrupt_byte(st, out);
45
46     if (out_len != t->expected_len
47             || memcmp(out, t->expected, out_len) != 0)
48         goto err;
49     ok = 1;
50 err:
51     EVP_MD_free(md);
52     EVP_MD_CTX_free(ctx);
53     OSSL_SELF_TEST_onend(st, ok);
54     return ok;
55 }
56
57 /*
58  * Helper function to setup a EVP_CipherInit
59  * Used to hide the complexity of Authenticated ciphers.
60  */
61 static int cipher_init(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
62                        const ST_KAT_CIPHER *t, int enc)
63 {
64     unsigned char *in_tag = NULL;
65     int pad = 0, tmp;
66
67     /* Flag required for Key wrapping */
68     EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
69     if (t->tag == NULL) {
70         /* Use a normal cipher init */
71         return EVP_CipherInit_ex(ctx, cipher, NULL, t->key, t->iv, enc)
72                && EVP_CIPHER_CTX_set_padding(ctx, pad);
73     }
74
75     /* The authenticated cipher init */
76     if (!enc)
77         in_tag = (unsigned char *)t->tag;
78
79     return EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc)
80            && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, t->iv_len, NULL)
81            && (in_tag == NULL
82                || EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, t->tag_len,
83                                       in_tag))
84            && EVP_CipherInit_ex(ctx, NULL, NULL, t->key, t->iv, enc)
85            && EVP_CIPHER_CTX_set_padding(ctx, pad)
86            && EVP_CipherUpdate(ctx, NULL, &tmp, t->aad, t->aad_len);
87 }
88
89 /* Test a single KAT for encrypt/decrypt */
90 static int self_test_cipher(const ST_KAT_CIPHER *t, OSSL_SELF_TEST *st,
91                             OPENSSL_CTX *libctx)
92 {
93     int ret = 0, encrypt = 1, len, ct_len = 0, pt_len = 0;
94     EVP_CIPHER_CTX *ctx = NULL;
95     EVP_CIPHER *cipher = NULL;
96     unsigned char ct_buf[256] = { 0 };
97     unsigned char pt_buf[256] = { 0 };
98
99     OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_KAT_CIPHER, t->base.desc);
100
101     ctx = EVP_CIPHER_CTX_new();
102     if (ctx == NULL)
103         goto err;
104     cipher = EVP_CIPHER_fetch(libctx, t->base.algorithm, "");
105     if (cipher == NULL)
106         goto err;
107
108     /* Encrypt plain text message */
109     if (!cipher_init(ctx, cipher, t, encrypt)
110             || !EVP_CipherUpdate(ctx, ct_buf, &len, t->base.pt, t->base.pt_len)
111             || !EVP_CipherFinal_ex(ctx, ct_buf + len, &ct_len))
112         goto err;
113
114     OSSL_SELF_TEST_oncorrupt_byte(st, ct_buf);
115     ct_len += len;
116     if (ct_len != (int)t->base.expected_len
117         || memcmp(t->base.expected, ct_buf, ct_len) != 0)
118         goto err;
119
120     if (t->tag != NULL) {
121         unsigned char tag[16] = { 0 };
122
123         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, t->tag_len, tag)
124             || memcmp(tag, t->tag, t->tag_len) != 0)
125             goto err;
126     }
127
128     if (!(cipher_init(ctx, cipher, t, !encrypt)
129           && EVP_CipherUpdate(ctx, pt_buf, &len, ct_buf, ct_len)
130           && EVP_CipherFinal_ex(ctx, pt_buf + len, &pt_len)))
131         goto err;
132     pt_len += len;
133
134     if (pt_len != (int)t->base.pt_len
135             || memcmp(pt_buf, t->base.pt, pt_len) != 0)
136         goto err;
137
138     ret = 1;
139 err:
140     EVP_CIPHER_free(cipher);
141     EVP_CIPHER_CTX_free(ctx);
142     OSSL_SELF_TEST_onend(st, ret);
143     return ret;
144 }
145
146 static int add_params(OSSL_PARAM_BLD *bld, const ST_KAT_PARAM *params,
147                       BN_CTX *ctx)
148 {
149     int ret = 0;
150     const ST_KAT_PARAM *p;
151
152     if (params == NULL)
153         return 1;
154     for (p = params; p->data != NULL; ++p)
155     {
156         switch (p->type) {
157         case OSSL_PARAM_UNSIGNED_INTEGER: {
158             BIGNUM *bn = BN_CTX_get(ctx);
159
160             if (bn == NULL
161                 || (BN_bin2bn(p->data, p->data_len, bn) == NULL)
162                 || !OSSL_PARAM_BLD_push_BN(bld, p->name, bn))
163                 goto err;
164             break;
165         }
166         case OSSL_PARAM_UTF8_STRING: {
167             if (!OSSL_PARAM_BLD_push_utf8_string(bld, p->name, p->data, 0))
168                 goto err;
169             break;
170         }
171         case OSSL_PARAM_OCTET_STRING: {
172             if (!OSSL_PARAM_BLD_push_octet_string(bld, p->name, p->data,
173                                                   p->data_len))
174                 goto err;
175             break;
176         }
177         default:
178             break;
179         }
180     }
181     ret = 1;
182 err:
183     return ret;
184 }
185
186 static int self_test_kdf(const ST_KAT_KDF *t, OSSL_SELF_TEST *st,
187                          OPENSSL_CTX *libctx)
188 {
189     int ret = 0;
190     unsigned char out[64];
191     EVP_KDF *kdf = NULL;
192     EVP_KDF_CTX *ctx = NULL;
193     BN_CTX *bnctx = NULL;
194     OSSL_PARAM *params  = NULL;
195     OSSL_PARAM_BLD *bld = NULL;
196
197     OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_KAT_KDF, t->desc);
198
199     bld = OSSL_PARAM_BLD_new();
200     if (bld == NULL)
201         goto err;
202
203     kdf = EVP_KDF_fetch(libctx, t->algorithm, "");
204     if (kdf == NULL)
205         goto err;
206
207     ctx = EVP_KDF_new_ctx(kdf);
208     if (ctx == NULL)
209         goto err;
210
211     bnctx = BN_CTX_new_ex(libctx);
212     if (bnctx == NULL)
213         goto err;
214     if (!add_params(bld, t->params, bnctx))
215         goto err;
216     params = OSSL_PARAM_BLD_to_param(bld);
217     if (params == NULL)
218         goto err;
219     if (!EVP_KDF_set_ctx_params(ctx, params))
220         goto err;
221
222     if (t->expected_len > sizeof(out))
223         goto err;
224     if (EVP_KDF_derive(ctx, out, t->expected_len) <= 0)
225         goto err;
226
227     OSSL_SELF_TEST_oncorrupt_byte(st, out);
228
229     if (memcmp(out, t->expected,  t->expected_len) != 0)
230         goto err;
231
232     ret = 1;
233 err:
234     EVP_KDF_free(kdf);
235     EVP_KDF_free_ctx(ctx);
236     BN_CTX_free(bnctx);
237     OSSL_PARAM_BLD_free_params(params);
238     OSSL_PARAM_BLD_free(bld);
239     OSSL_SELF_TEST_onend(st, ret);
240     return ret;
241 }
242
243 static size_t drbg_kat_entropy_cb(RAND_DRBG *drbg, unsigned char **pout,
244                                   int entropy, size_t min_len, size_t max_len,
245                                   int prediction_resistance)
246 {
247     OSSL_PARAM *drbg_params = RAND_DRBG_get_callback_data(drbg);
248     OSSL_PARAM *p = OSSL_PARAM_locate(drbg_params, DRBG_PARAM_ENTROPY);
249
250     if (p == NULL || p->data_type != OSSL_PARAM_OCTET_STRING)
251         return 0;
252     *pout = (unsigned char *)p->data;
253     return p->data_size;
254 }
255
256 static size_t drbg_kat_nonce_cb(RAND_DRBG *drbg, unsigned char **pout,
257                                 int entropy, size_t min_len, size_t max_len)
258 {
259     OSSL_PARAM *drbg_params = RAND_DRBG_get_callback_data(drbg);
260     OSSL_PARAM *p = OSSL_PARAM_locate(drbg_params, DRBG_PARAM_NONCE);
261
262     if (p == NULL || p->data_type != OSSL_PARAM_OCTET_STRING)
263         return 0;
264     *pout = (unsigned char *)p->data;
265     return p->data_size;
266 }
267
268 static int self_test_drbg(const ST_KAT_DRBG *t, OSSL_SELF_TEST *st,
269                           OPENSSL_CTX *libctx)
270 {
271     int ret = 0;
272     unsigned char out[256];
273     RAND_DRBG *drbg = NULL;
274     unsigned int flags = 0;
275     int prediction_resistance = 1; /* Causes a reseed */
276     OSSL_PARAM drbg_params[3] = {
277         OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END
278     };
279     static const unsigned char zero[sizeof(drbg->data)] = { 0 };
280
281     OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_DRBG, t->desc);
282
283     if (strcmp(t->desc, OSSL_SELF_TEST_DESC_DRBG_HMAC) == 0)
284         flags |= RAND_DRBG_FLAG_HMAC;
285
286     drbg = RAND_DRBG_new_ex(libctx, t->nid, flags, NULL);
287     if (drbg == NULL)
288         goto err;
289
290     if (!RAND_DRBG_set_callback_data(drbg, drbg_params))
291         goto err;
292
293     if (!RAND_DRBG_set_callbacks(drbg, drbg_kat_entropy_cb, NULL,
294                                  drbg_kat_nonce_cb, NULL))
295         goto err;
296
297     drbg_params[0] =
298         OSSL_PARAM_construct_octet_string(DRBG_PARAM_ENTROPY,
299                                           (void *)t->entropyin, t->entropyinlen);
300     drbg_params[1] =
301         OSSL_PARAM_construct_octet_string(DRBG_PARAM_NONCE,
302                                           (void *)t->nonce, t->noncelen);
303
304     if (!RAND_DRBG_instantiate(drbg, t->persstr, t->persstrlen))
305         goto err;
306
307     drbg_params[0] =
308         OSSL_PARAM_construct_octet_string(DRBG_PARAM_ENTROPY,
309                                           (void *)t->entropyinpr1,
310                                           t->entropyinpr1len);
311
312     if (!RAND_DRBG_generate(drbg, out, t->expectedlen, prediction_resistance,
313                             t->entropyaddin1, t->entropyaddin1len))
314         goto err;
315
316     drbg_params[0] =
317         OSSL_PARAM_construct_octet_string(DRBG_PARAM_ENTROPY,
318                                          (void *)t->entropyinpr2,
319                                          t->entropyinpr2len);
320     /* This calls RAND_DRBG_reseed() internally when prediction_resistance = 1 */
321     if (!RAND_DRBG_generate(drbg, out,  t->expectedlen, prediction_resistance,
322                             t->entropyaddin2, t->entropyaddin2len))
323         goto err;
324
325     OSSL_SELF_TEST_oncorrupt_byte(st, out);
326
327     if (memcmp(out, t->expected, t->expectedlen) != 0)
328         goto err;
329
330     if (!RAND_DRBG_uninstantiate(drbg))
331         goto err;
332     /*
333      * Check that the DRBG data has been zeroized after RAND_DRBG_uninstantiate.
334      */
335     if (memcmp((unsigned char *)&drbg->data, zero, sizeof(drbg->data)) != 0)
336         goto err;
337
338     ret = 1;
339 err:
340     RAND_DRBG_free(drbg);
341     OSSL_SELF_TEST_onend(st, ret);
342     return ret;
343 }
344
345
346
347 static int self_test_ka(const ST_KAT_KAS *t,
348                         OSSL_SELF_TEST *st, OPENSSL_CTX *libctx)
349 {
350     int ret = 0;
351     EVP_PKEY_CTX *kactx = NULL, *dctx = NULL;
352     EVP_PKEY *pkey = NULL, *peerkey = NULL;
353     OSSL_PARAM *params = NULL;
354     OSSL_PARAM *params_peer = NULL;
355     unsigned char secret[256];
356     size_t secret_len;
357     OSSL_PARAM_BLD *bld = NULL;
358     BN_CTX *bnctx = NULL;
359
360     OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_KAT_KA, t->desc);
361
362     bnctx = BN_CTX_new_ex(libctx);
363     if (bnctx == NULL)
364         goto err;
365
366     bld = OSSL_PARAM_BLD_new();
367     if (bld == NULL)
368         goto err;
369
370     if (!add_params(bld, t->key_group, bnctx)
371         || !add_params(bld, t->key_host_data, bnctx))
372         goto err;
373     params = OSSL_PARAM_BLD_to_param(bld);
374
375     if (!add_params(bld, t->key_group, bnctx)
376         || !add_params(bld, t->key_peer_data, bnctx))
377         goto err;
378
379     params_peer = OSSL_PARAM_BLD_to_param(bld);
380     if (params == NULL || params_peer == NULL)
381         goto err;
382
383     /* Create a EVP_PKEY_CTX to load the DH keys into */
384     kactx = EVP_PKEY_CTX_new_from_name(libctx, t->algorithm, "");
385     if (kactx == NULL)
386         goto err;
387     if (EVP_PKEY_key_fromdata_init(kactx) <= 0
388         || EVP_PKEY_fromdata(kactx, &pkey, params) <= 0)
389         goto err;
390     if (EVP_PKEY_key_fromdata_init(kactx) <= 0
391         || EVP_PKEY_fromdata(kactx, &peerkey, params_peer) <= 0)
392         goto err;
393
394     /* Create a EVP_PKEY_CTX to perform key derivation */
395     dctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, NULL);
396     if (dctx == NULL)
397         goto err;
398
399     if (EVP_PKEY_derive_init(dctx) <= 0
400         || EVP_PKEY_derive_set_peer(dctx, peerkey) <= 0
401         || EVP_PKEY_derive(dctx, secret, &secret_len) <= 0)
402         goto err;
403
404     OSSL_SELF_TEST_oncorrupt_byte(st, secret);
405
406     if (secret_len != t->expected_len
407         || memcmp(secret, t->expected, t->expected_len) != 0)
408         goto err;
409     ret = 1;
410 err:
411     BN_CTX_free(bnctx);
412     EVP_PKEY_free(pkey);
413     EVP_PKEY_free(peerkey);
414     EVP_PKEY_CTX_free(kactx);
415     EVP_PKEY_CTX_free(dctx);
416     OSSL_PARAM_BLD_free_params(params_peer);
417     OSSL_PARAM_BLD_free_params(params);
418     OSSL_PARAM_BLD_free(bld);
419     OSSL_SELF_TEST_onend(st, ret);
420     return ret;
421 }
422
423 static int self_test_sign(const ST_KAT_SIGN *t,
424                          OSSL_SELF_TEST *st, OPENSSL_CTX *libctx)
425 {
426     int ret = 0;
427     OSSL_PARAM *params = NULL, *params_sig = NULL;
428     OSSL_PARAM_BLD *bld = NULL;
429     EVP_PKEY_CTX *sctx = NULL, *kctx = NULL;
430     EVP_PKEY *pkey = NULL;
431     unsigned char sig[256];
432     BN_CTX *bnctx = NULL;
433     size_t siglen = 0;
434     static const unsigned char dgst[] = {
435         0x7f, 0x83, 0xb1, 0x65, 0x7f, 0xf1, 0xfc, 0x53, 0xb9, 0x2d, 0xc1, 0x81,
436         0x48, 0xa1, 0xd6, 0x5d, 0xfc, 0x2d, 0x4b, 0x1f, 0xa3, 0xd6, 0x77, 0x28,
437         0x4a, 0xdd, 0xd2, 0x00, 0x12, 0x6d, 0x90, 0x69
438     };
439
440     OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_KAT_SIGNATURE, t->desc);
441
442     bnctx = BN_CTX_new_ex(libctx);
443     if (bnctx == NULL)
444         goto err;
445
446     bld = OSSL_PARAM_BLD_new();
447     if (bld == NULL)
448         goto err;
449
450     if (!add_params(bld, t->key, bnctx))
451         goto err;
452     params = OSSL_PARAM_BLD_to_param(bld);
453
454     /* Create a EVP_PKEY_CTX to load the DSA key into */
455     kctx = EVP_PKEY_CTX_new_from_name(libctx, t->algorithm, "");
456     if (kctx == NULL || params == NULL)
457         goto err;
458     if (EVP_PKEY_key_fromdata_init(kctx) <= 0
459         || EVP_PKEY_fromdata(kctx, &pkey, params) <= 0)
460         goto err;
461
462     /* Create a EVP_PKEY_CTX to use for the signing operation */
463     sctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, NULL);
464     if (sctx == NULL
465         || EVP_PKEY_sign_init(sctx) <= 0)
466         goto err;
467
468     /* set signature parameters */
469     if (!OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_SIGNATURE_PARAM_DIGEST,
470                                          t->mdalgorithm,
471                                          strlen(t->mdalgorithm) + 1))
472         goto err;
473     params_sig = OSSL_PARAM_BLD_to_param(bld);
474     if (EVP_PKEY_CTX_set_params(sctx, params_sig) <= 0)
475         goto err;
476
477     if (EVP_PKEY_sign(sctx, sig, &siglen, dgst, sizeof(dgst)) <= 0
478         || EVP_PKEY_verify_init(sctx) <= 0
479         || EVP_PKEY_CTX_set_params(sctx, params_sig) <= 0)
480         goto err;
481
482     /*
483      * Used by RSA, for other key types where the signature changes, we
484      * can only use the verify.
485      */
486     if (t->sig_expected != NULL
487         && (siglen != t->sig_expected_len
488             || memcmp(sig, t->sig_expected, t->sig_expected_len) != 0))
489         goto err;
490
491     OSSL_SELF_TEST_oncorrupt_byte(st, sig);
492     if (EVP_PKEY_verify(sctx, sig, siglen, dgst, sizeof(dgst)) <= 0)
493         goto err;
494     ret = 1;
495 err:
496     BN_CTX_free(bnctx);
497     EVP_PKEY_free(pkey);
498     EVP_PKEY_CTX_free(kctx);
499     EVP_PKEY_CTX_free(sctx);
500     OSSL_PARAM_BLD_free_params(params);
501     OSSL_PARAM_BLD_free_params(params_sig);
502     OSSL_PARAM_BLD_free(bld);
503     OSSL_SELF_TEST_onend(st, ret);
504     return ret;
505 }
506
507 /*
508  * Test a data driven list of KAT's for digest algorithms.
509  * All tests are run regardless of if they fail or not.
510  * Return 0 if any test fails.
511  */
512 static int self_test_digests(OSSL_SELF_TEST *st, OPENSSL_CTX *libctx)
513 {
514     int i, ret = 1;
515
516     for (i = 0; i < (int)OSSL_NELEM(st_kat_digest_tests); ++i) {
517         if (!self_test_digest(&st_kat_digest_tests[i], st, libctx))
518             ret = 0;
519     }
520     return ret;
521 }
522
523 static int self_test_ciphers(OSSL_SELF_TEST *st, OPENSSL_CTX *libctx)
524 {
525     int i, ret = 1;
526
527     for (i = 0; i < (int)OSSL_NELEM(st_kat_cipher_tests); ++i) {
528         if (!self_test_cipher(&st_kat_cipher_tests[i], st, libctx))
529             ret = 0;
530     }
531     return ret;
532 }
533
534 static int self_test_kdfs(OSSL_SELF_TEST *st, OPENSSL_CTX *libctx)
535 {
536     int i, ret = 1;
537
538     for (i = 0; i < (int)OSSL_NELEM(st_kat_kdf_tests); ++i) {
539         if (!self_test_kdf(&st_kat_kdf_tests[i], st, libctx))
540             ret = 0;
541     }
542     return ret;
543 }
544
545 static int self_test_drbgs(OSSL_SELF_TEST *st, OPENSSL_CTX *libctx)
546 {
547     int i, ret = 1;
548
549     for (i = 0; i < (int)OSSL_NELEM(st_kat_drbg_tests); ++i) {
550         if (!self_test_drbg(&st_kat_drbg_tests[i], st, libctx))
551             ret = 0;
552     }
553     return ret;
554 }
555
556 static int self_test_kas(OSSL_SELF_TEST *st, OPENSSL_CTX *libctx)
557 {
558     int i, ret = 1;
559
560     for (i = 0; i < (int)OSSL_NELEM(st_kat_kas_tests); ++i) {
561         if (!self_test_ka(&st_kat_kas_tests[i], st, libctx))
562             ret = 0;
563     }
564     return ret;
565 }
566
567 static int self_test_signatures(OSSL_SELF_TEST *st, OPENSSL_CTX *libctx)
568 {
569     int i, ret = 1;
570
571     for (i = 0; i < (int)OSSL_NELEM(st_kat_sign_tests); ++i) {
572         if (!self_test_sign(&st_kat_sign_tests[i], st, libctx))
573             ret = 0;
574     }
575     return ret;
576 }
577
578 /*
579  * Run the algorithm KAT's.
580  * Return 1 is successful, otherwise return 0.
581  * This runs all the tests regardless of if any fail.
582  */
583 int SELF_TEST_kats(OSSL_SELF_TEST *st, OPENSSL_CTX *libctx)
584 {
585     int ret = 1;
586
587     if (!self_test_digests(st, libctx))
588         ret = 0;
589     if (!self_test_ciphers(st, libctx))
590         ret = 0;
591     if (!self_test_signatures(st, libctx))
592         ret = 0;
593     if (!self_test_kdfs(st, libctx))
594         ret = 0;
595     if (!self_test_drbgs(st, libctx))
596         ret = 0;
597     if (!self_test_kas(st, libctx))
598         ret = 0;
599
600     return ret;
601 }