Params: add argument to the _from_text calls to indicate if the param exists.
[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 OpenSSL license (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 "internal/cryptlib.h"
14 #include "internal/nelem.h"
15 #include "self_test.h"
16 #include "self_test_data.inc"
17
18 static int self_test_digest(const ST_KAT_DIGEST *t, OSSL_ST_EVENT *event,
19                             OPENSSL_CTX *libctx)
20 {
21     int ok = 0;
22     unsigned char out[EVP_MAX_MD_SIZE];
23     unsigned int out_len = 0;
24     EVP_MD_CTX *ctx = EVP_MD_CTX_new();
25     EVP_MD *md = EVP_MD_fetch(libctx, t->algorithm, NULL);
26
27     SELF_TEST_EVENT_onbegin(event, OSSL_SELF_TEST_TYPE_KAT_DIGEST, t->desc);
28
29     if (ctx == NULL
30             || md == NULL
31             || !EVP_DigestInit_ex(ctx, md, NULL)
32             || !EVP_DigestUpdate(ctx, t->pt, t->pt_len)
33             || !EVP_DigestFinal(ctx, out, &out_len))
34         goto err;
35
36     /* Optional corruption */
37     SELF_TEST_EVENT_oncorrupt_byte(event, out);
38
39     if (out_len != t->expected_len
40             || memcmp(out, t->expected, out_len) != 0)
41         goto err;
42     ok = 1;
43 err:
44     SELF_TEST_EVENT_onend(event, ok);
45     EVP_MD_free(md);
46     EVP_MD_CTX_free(ctx);
47
48     return ok;
49 }
50
51 /*
52  * Helper function to setup a EVP_CipherInit
53  * Used to hide the complexity of Authenticated ciphers.
54  */
55 static int cipher_init(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
56                        const ST_KAT_CIPHER *t, int enc)
57 {
58     unsigned char *in_tag = NULL;
59     int pad = 0, tmp;
60
61     /* Flag required for Key wrapping */
62     EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
63     if (t->tag == NULL) {
64         /* Use a normal cipher init */
65         return EVP_CipherInit_ex(ctx, cipher, NULL, t->key, t->iv, enc)
66                && EVP_CIPHER_CTX_set_padding(ctx, pad);
67     }
68
69     /* The authenticated cipher init */
70     if (!enc)
71         in_tag = (unsigned char *)t->tag;
72
73     return EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc)
74            && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, t->iv_len, NULL)
75            && (in_tag == NULL
76                || EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, t->tag_len,
77                                       in_tag))
78            && EVP_CipherInit_ex(ctx, NULL, NULL, t->key, t->iv, enc)
79            && EVP_CIPHER_CTX_set_padding(ctx, pad)
80            && EVP_CipherUpdate(ctx, NULL, &tmp, t->aad, t->aad_len);
81 }
82
83 /* Test a single KAT for encrypt/decrypt */
84 static int self_test_cipher(const ST_KAT_CIPHER *t, OSSL_ST_EVENT *event,
85                             OPENSSL_CTX *libctx)
86 {
87     int ret = 0, encrypt = 1, len, ct_len = 0, pt_len = 0;
88     EVP_CIPHER_CTX *ctx = NULL;
89     EVP_CIPHER *cipher = NULL;
90     unsigned char ct_buf[256] = { 0 };
91     unsigned char pt_buf[256] = { 0 };
92
93     SELF_TEST_EVENT_onbegin(event, OSSL_SELF_TEST_TYPE_KAT_CIPHER, t->base.desc);
94
95     ctx = EVP_CIPHER_CTX_new();
96     if (ctx == NULL)
97         goto end;
98     cipher = EVP_CIPHER_fetch(libctx, t->base.algorithm, "");
99     if (cipher == NULL)
100         goto end;
101
102     /* Encrypt plain text message */
103     if (!cipher_init(ctx, cipher, t, encrypt)
104             || !EVP_CipherUpdate(ctx, ct_buf, &len, t->base.pt, t->base.pt_len)
105             || !EVP_CipherFinal_ex(ctx, ct_buf + len, &ct_len))
106         goto end;
107
108     SELF_TEST_EVENT_oncorrupt_byte(event, ct_buf);
109     ct_len += len;
110     if (ct_len != (int)t->base.expected_len
111         || memcmp(t->base.expected, ct_buf, ct_len) != 0)
112         goto end;
113
114     if (t->tag != NULL) {
115         unsigned char tag[16] = { 0 };
116
117         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, t->tag_len, tag)
118             || memcmp(tag, t->tag, t->tag_len) != 0)
119             goto end;
120     }
121
122     if (!(cipher_init(ctx, cipher, t, !encrypt)
123           && EVP_CipherUpdate(ctx, pt_buf, &len, ct_buf, ct_len)
124           && EVP_CipherFinal_ex(ctx, pt_buf + len, &pt_len)))
125         goto end;
126     pt_len += len;
127
128     if (pt_len != (int)t->base.pt_len
129             || memcmp(pt_buf, t->base.pt, pt_len) != 0)
130         goto end;
131
132     ret = 1;
133 end:
134     EVP_CIPHER_free(cipher);
135     EVP_CIPHER_CTX_free(ctx);
136     SELF_TEST_EVENT_onend(event, ret);
137     return ret;
138 }
139
140 static int self_test_kdf(const ST_KAT_KDF *t, OSSL_ST_EVENT *event,
141                          OPENSSL_CTX *libctx)
142 {
143     int ret = 0;
144     int i, numparams;
145     unsigned char out[64];
146     EVP_KDF *kdf = NULL;
147     EVP_KDF_CTX *ctx = NULL;
148     OSSL_PARAM params[16];
149     const OSSL_PARAM *settables = NULL;
150
151     numparams = OSSL_NELEM(params);
152     SELF_TEST_EVENT_onbegin(event, OSSL_SELF_TEST_TYPE_KAT_KDF, t->desc);
153
154     /* Zeroize the params array to avoid mem leaks on error */
155     for (i = 0; i < numparams; ++i)
156         params[i] = OSSL_PARAM_construct_end();
157
158     kdf = EVP_KDF_fetch(libctx, t->algorithm, "");
159     ctx = EVP_KDF_CTX_new(kdf);
160     if (ctx == NULL)
161         goto end;
162
163     settables = EVP_KDF_settable_ctx_params(kdf);
164     for (i = 0; t->ctrls[i].name != NULL; ++i) {
165         if (!ossl_assert(i < (numparams - 1)))
166             goto end;
167         if (!OSSL_PARAM_allocate_from_text(&params[i], settables,
168                                            t->ctrls[i].name,
169                                            t->ctrls[i].value,
170                                            strlen(t->ctrls[i].value), NULL))
171             goto end;
172     }
173     if (!EVP_KDF_CTX_set_params(ctx, params))
174         goto end;
175
176     if (t->expected_len > sizeof(out))
177         goto end;
178     if (EVP_KDF_derive(ctx, out, t->expected_len) <= 0)
179         goto end;
180
181     SELF_TEST_EVENT_oncorrupt_byte(event, out);
182
183     if (memcmp(out, t->expected,  t->expected_len) != 0)
184         goto end;
185
186     ret = 1;
187 end:
188     for (i = 0; params[i].key != NULL; ++i)
189         OPENSSL_free(params[i].data);
190     EVP_KDF_free(kdf);
191     EVP_KDF_CTX_free(ctx);
192     SELF_TEST_EVENT_onend(event, ret);
193     return ret;
194 }
195
196 /*
197  * Test a data driven list of KAT's for digest algorithms.
198  * All tests are run regardless of if they fail or not.
199  * Return 0 if any test fails.
200  */
201 static int self_test_digests(OSSL_ST_EVENT *event, OPENSSL_CTX *libctx)
202 {
203     int i, ret = 1;
204
205     for (i = 0; i < (int)OSSL_NELEM(st_kat_digest_tests); ++i) {
206         if (!self_test_digest(&st_kat_digest_tests[i], event, libctx))
207             ret = 0;
208     }
209     return ret;
210 }
211
212 static int self_test_ciphers(OSSL_ST_EVENT *event, OPENSSL_CTX *libctx)
213 {
214     int i, ret = 1;
215
216     for (i = 0; i < (int)OSSL_NELEM(st_kat_cipher_tests); ++i) {
217         if (!self_test_cipher(&st_kat_cipher_tests[i], event, libctx))
218             ret = 0;
219     }
220     return ret;
221 }
222
223 static int self_test_kdfs(OSSL_ST_EVENT *event, OPENSSL_CTX *libctx)
224 {
225     int i, ret = 1;
226
227     for (i = 0; i < (int)OSSL_NELEM(st_kat_kdf_tests); ++i) {
228         if (!self_test_kdf(&st_kat_kdf_tests[i], event, libctx))
229             ret = 0;
230     }
231     return ret;
232 }
233
234 /*
235  * Run the algorithm KAT's.
236  * Return 1 is successful, otherwise return 0.
237  * This runs all the tests regardless of if any fail.
238  *
239  * TODO(3.0) Add self tests for KA, DRBG, Sign/Verify when they become available
240  */
241 int SELF_TEST_kats(OSSL_ST_EVENT *event, OPENSSL_CTX *libctx)
242 {
243     int ret = 1;
244
245     if (!self_test_digests(event, libctx))
246         ret = 0;
247     if (!self_test_ciphers(event, libctx))
248         ret = 0;
249     if (!self_test_kdfs(event, libctx))
250         ret = 0;
251
252     return ret;
253 }