self_test_kats.c@ 96441

Last change on this file since 96441 was 94320, checked in by vboxsync, 3 years ago
libs/openssl-3.0.1: Export to OSE and fix copyright headers in Makefiles, bugref:10128
File size: 21.4 KB

Line
1	/*
2	* Copyright 2019-2021 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/core_names.h>
14	#include <openssl/param_build.h>
15	#include "internal/cryptlib.h"
16	#include "internal/nelem.h"
17	#include "self_test.h"
18	#include "self_test_data.inc"
19
20	static int self_test_digest(const ST_KAT_DIGEST t, OSSL_SELF_TEST st,
21	OSSL_LIB_CTX *libctx)
22	{
23	int ok = 0;
24	unsigned char out[EVP_MAX_MD_SIZE];
25	unsigned int out_len = 0;
26	EVP_MD_CTX *ctx = EVP_MD_CTX_new();
27	EVP_MD *md = EVP_MD_fetch(libctx, t->algorithm, NULL);
28
29	OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_KAT_DIGEST, t->desc);
30
31	if (ctx == NULL
32	\|\| md == NULL
33	\|\| !EVP_DigestInit_ex(ctx, md, NULL)
34	\|\| !EVP_DigestUpdate(ctx, t->pt, t->pt_len)
35	\|\| !EVP_DigestFinal(ctx, out, &out_len))
36	goto err;
37
38	/* Optional corruption */
39	OSSL_SELF_TEST_oncorrupt_byte(st, out);
40
41	if (out_len != t->expected_len
42	\|\| memcmp(out, t->expected, out_len) != 0)
43	goto err;
44	ok = 1;
45	err:
46	EVP_MD_free(md);
47	EVP_MD_CTX_free(ctx);
48	OSSL_SELF_TEST_onend(st, ok);
49	return ok;
50	}
51
52	/*
53	* Helper function to setup a EVP_CipherInit
54	* Used to hide the complexity of Authenticated ciphers.
55	*/
56	static int cipher_init(EVP_CIPHER_CTX ctx, const EVP_CIPHER cipher,
57	const ST_KAT_CIPHER *t, int enc)
58	{
59	unsigned char *in_tag = NULL;
60	int pad = 0, tmp;
61
62	/* Flag required for Key wrapping */
63	EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
64	if (t->tag == NULL) {
65	/* Use a normal cipher init */
66	return EVP_CipherInit_ex(ctx, cipher, NULL, t->key, t->iv, enc)
67	&& EVP_CIPHER_CTX_set_padding(ctx, pad);
68	}
69
70	/* The authenticated cipher init */
71	if (!enc)
72	in_tag = (unsigned char *)t->tag;
73
74	return EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc)
75	&& EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, t->iv_len, NULL)
76	&& (in_tag == NULL
77	\|\| EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, t->tag_len,
78	in_tag))
79	&& EVP_CipherInit_ex(ctx, NULL, NULL, t->key, t->iv, enc)
80	&& EVP_CIPHER_CTX_set_padding(ctx, pad)
81	&& EVP_CipherUpdate(ctx, NULL, &tmp, t->aad, t->aad_len);
82	}
83
84	/* Test a single KAT for encrypt/decrypt */
85	static int self_test_cipher(const ST_KAT_CIPHER t, OSSL_SELF_TEST st,
86	OSSL_LIB_CTX *libctx)
87	{
88	int ret = 0, encrypt = 1, len = 0, ct_len = 0, pt_len = 0;
89	EVP_CIPHER_CTX *ctx = NULL;
90	EVP_CIPHER *cipher = NULL;
91	unsigned char ct_buf[256] = { 0 };
92	unsigned char pt_buf[256] = { 0 };
93
94	OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_KAT_CIPHER, t->base.desc);
95
96	ctx = EVP_CIPHER_CTX_new();
97	if (ctx == NULL)
98	goto err;
99	cipher = EVP_CIPHER_fetch(libctx, t->base.algorithm, NULL);
100	if (cipher == NULL)
101	goto err;
102
103	/* Encrypt plain text message */
104	if ((t->mode & CIPHER_MODE_ENCRYPT) != 0) {
105	if (!cipher_init(ctx, cipher, t, encrypt)
106	\|\| !EVP_CipherUpdate(ctx, ct_buf, &len, t->base.pt,
107	t->base.pt_len)
108	\|\| !EVP_CipherFinal_ex(ctx, ct_buf + len, &ct_len))
109	goto err;
110
111	OSSL_SELF_TEST_oncorrupt_byte(st, ct_buf);
112	ct_len += len;
113	if (ct_len != (int)t->base.expected_len
114	\|\| memcmp(t->base.expected, ct_buf, ct_len) != 0)
115	goto err;
116
117	if (t->tag != NULL) {
118	unsigned char tag[16] = { 0 };
119
120	if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, t->tag_len,
121	tag)
122	\|\| memcmp(tag, t->tag, t->tag_len) != 0)
123	goto err;
124	}
125	}
126
127	/* Decrypt cipher text */
128	if ((t->mode & CIPHER_MODE_DECRYPT) != 0) {
129	if (!(cipher_init(ctx, cipher, t, !encrypt)
130	&& EVP_CipherUpdate(ctx, pt_buf, &len,
131	t->base.expected, t->base.expected_len)
132	&& EVP_CipherFinal_ex(ctx, pt_buf + len, &pt_len)))
133	goto err;
134	OSSL_SELF_TEST_oncorrupt_byte(st, pt_buf);
135	pt_len += len;
136	if (pt_len != (int)t->base.pt_len
137	\|\| memcmp(pt_buf, t->base.pt, pt_len) != 0)
138	goto err;
139	}
140
141	ret = 1;
142	err:
143	EVP_CIPHER_free(cipher);
144	EVP_CIPHER_CTX_free(ctx);
145	OSSL_SELF_TEST_onend(st, ret);
146	return ret;
147	}
148
149	static int add_params(OSSL_PARAM_BLD bld, const ST_KAT_PARAM params,
150	BN_CTX *ctx)
151	{
152	int ret = 0;
153	const ST_KAT_PARAM *p;
154
155	if (params == NULL)
156	return 1;
157	for (p = params; p->data != NULL; ++p)
158	{
159	switch (p->type) {
160	case OSSL_PARAM_UNSIGNED_INTEGER: {
161	BIGNUM *bn = BN_CTX_get(ctx);
162
163	if (bn == NULL
164	\|\| (BN_bin2bn(p->data, p->data_len, bn) == NULL)
165	\|\| !OSSL_PARAM_BLD_push_BN(bld, p->name, bn))
166	goto err;
167	break;
168	}
169	case OSSL_PARAM_UTF8_STRING: {
170	if (!OSSL_PARAM_BLD_push_utf8_string(bld, p->name, p->data,
171	p->data_len))
172	goto err;
173	break;
174	}
175	case OSSL_PARAM_OCTET_STRING: {
176	if (!OSSL_PARAM_BLD_push_octet_string(bld, p->name, p->data,
177	p->data_len))
178	goto err;
179	break;
180	}
181	case OSSL_PARAM_INTEGER: {
182	if (!OSSL_PARAM_BLD_push_int(bld, p->name, (int )p->data))
183	goto err;
184	break;
185	}
186	default:
187	break;
188	}
189	}
190	ret = 1;
191	err:
192	return ret;
193	}
194
195	static int self_test_kdf(const ST_KAT_KDF t, OSSL_SELF_TEST st,
196	OSSL_LIB_CTX *libctx)
197	{
198	int ret = 0;
199	unsigned char out[128];
200	EVP_KDF *kdf = NULL;
201	EVP_KDF_CTX *ctx = NULL;
202	BN_CTX *bnctx = NULL;
203	OSSL_PARAM *params = NULL;
204	OSSL_PARAM_BLD *bld = NULL;
205
206	OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_KAT_KDF, t->desc);
207
208	bld = OSSL_PARAM_BLD_new();
209	if (bld == NULL)
210	goto err;
211
212	kdf = EVP_KDF_fetch(libctx, t->algorithm, "");
213	if (kdf == NULL)
214	goto err;
215
216	ctx = EVP_KDF_CTX_new(kdf);
217	if (ctx == NULL)
218	goto err;
219
220	bnctx = BN_CTX_new_ex(libctx);
221	if (bnctx == NULL)
222	goto err;
223	if (!add_params(bld, t->params, bnctx))
224	goto err;
225	params = OSSL_PARAM_BLD_to_param(bld);
226	if (params == NULL)
227	goto err;
228
229	if (t->expected_len > sizeof(out))
230	goto err;
231	if (EVP_KDF_derive(ctx, out, t->expected_len, params) <= 0)
232	goto err;
233
234	OSSL_SELF_TEST_oncorrupt_byte(st, out);
235
236	if (memcmp(out, t->expected, t->expected_len) != 0)
237	goto err;
238
239	ret = 1;
240	err:
241	EVP_KDF_free(kdf);
242	EVP_KDF_CTX_free(ctx);
243	BN_CTX_free(bnctx);
244	OSSL_PARAM_free(params);
245	OSSL_PARAM_BLD_free(bld);
246	OSSL_SELF_TEST_onend(st, ret);
247	return ret;
248	}
249
250	static int self_test_drbg(const ST_KAT_DRBG t, OSSL_SELF_TEST st,
251	OSSL_LIB_CTX *libctx)
252	{
253	int ret = 0;
254	unsigned char out[256];
255	EVP_RAND *rand;
256	EVP_RAND_CTX test = NULL, drbg = NULL;
257	unsigned int strength = 256;
258	int prediction_resistance = 1; /* Causes a reseed */
259	OSSL_PARAM drbg_params[3] = {
260	OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END
261	};
262
263	OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_DRBG, t->desc);
264
265	rand = EVP_RAND_fetch(libctx, "TEST-RAND", NULL);
266	if (rand == NULL)
267	goto err;
268
269	test = EVP_RAND_CTX_new(rand, NULL);
270	EVP_RAND_free(rand);
271	if (test == NULL)
272	goto err;
273
274	drbg_params[0] = OSSL_PARAM_construct_uint(OSSL_RAND_PARAM_STRENGTH,
275	&strength);
276	if (!EVP_RAND_CTX_set_params(test, drbg_params))
277	goto err;
278
279	rand = EVP_RAND_fetch(libctx, t->algorithm, NULL);
280	if (rand == NULL)
281	goto err;
282
283	drbg = EVP_RAND_CTX_new(rand, test);
284	EVP_RAND_free(rand);
285	if (drbg == NULL)
286	goto err;
287
288	strength = EVP_RAND_get_strength(drbg);
289
290	drbg_params[0] = OSSL_PARAM_construct_utf8_string(t->param_name,
291	t->param_value, 0);
292	/* This is only used by HMAC-DRBG but it is ignored by the others */
293	drbg_params[1] =
294	OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_MAC, "HMAC", 0);
295	if (!EVP_RAND_CTX_set_params(drbg, drbg_params))
296	goto err;
297
298	drbg_params[0] =
299	OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY,
300	(void *)t->entropyin,
301	t->entropyinlen);
302	drbg_params[1] =
303	OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_NONCE,
304	(void *)t->nonce, t->noncelen);
305	if (!EVP_RAND_instantiate(test, strength, 0, NULL, 0, drbg_params))
306	goto err;
307	if (!EVP_RAND_instantiate(drbg, strength, 0, t->persstr, t->persstrlen,
308	NULL))
309	goto err;
310
311	drbg_params[0] =
312	OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY,
313	(void *)t->entropyinpr1,
314	t->entropyinpr1len);
315	if (!EVP_RAND_CTX_set_params(test, drbg_params))
316	goto err;
317
318	if (!EVP_RAND_generate(drbg, out, t->expectedlen, strength,
319	prediction_resistance,
320	t->entropyaddin1, t->entropyaddin1len))
321	goto err;
322
323	drbg_params[0] =
324	OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY,
325	(void *)t->entropyinpr2,
326	t->entropyinpr2len);
327	if (!EVP_RAND_CTX_set_params(test, drbg_params))
328	goto err;
329
330	/*
331	* This calls ossl_prov_drbg_reseed() internally when
332	* prediction_resistance = 1
333	*/
334	if (!EVP_RAND_generate(drbg, out, t->expectedlen, strength,
335	prediction_resistance,
336	t->entropyaddin2, t->entropyaddin2len))
337	goto err;
338
339	OSSL_SELF_TEST_oncorrupt_byte(st, out);
340
341	if (memcmp(out, t->expected, t->expectedlen) != 0)
342	goto err;
343
344	if (!EVP_RAND_uninstantiate(drbg))
345	goto err;
346	/*
347	* Check that the DRBG data has been zeroized after
348	* ossl_prov_drbg_uninstantiate.
349	*/
350	if (!EVP_RAND_verify_zeroization(drbg))
351	goto err;
352
353	ret = 1;
354	err:
355	EVP_RAND_CTX_free(drbg);
356	EVP_RAND_CTX_free(test);
357	OSSL_SELF_TEST_onend(st, ret);
358	return ret;
359	}
360
361	#if !defined(OPENSSL_NO_DH) \|\| !defined(OPENSSL_NO_EC)
362	static int self_test_ka(const ST_KAT_KAS *t,
363	OSSL_SELF_TEST st, OSSL_LIB_CTX libctx)
364	{
365	int ret = 0;
366	EVP_PKEY_CTX kactx = NULL, dctx = NULL;
367	EVP_PKEY pkey = NULL, peerkey = NULL;
368	OSSL_PARAM *params = NULL;
369	OSSL_PARAM *params_peer = NULL;
370	unsigned char secret[256];
371	size_t secret_len = sizeof(secret);
372	OSSL_PARAM_BLD *bld = NULL;
373	BN_CTX *bnctx = NULL;
374
375	OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_KAT_KA, t->desc);
376
377	bnctx = BN_CTX_new_ex(libctx);
378	if (bnctx == NULL)
379	goto err;
380
381	bld = OSSL_PARAM_BLD_new();
382	if (bld == NULL)
383	goto err;
384
385	if (!add_params(bld, t->key_group, bnctx)
386	\|\| !add_params(bld, t->key_host_data, bnctx))
387	goto err;
388	params = OSSL_PARAM_BLD_to_param(bld);
389
390	if (!add_params(bld, t->key_group, bnctx)
391	\|\| !add_params(bld, t->key_peer_data, bnctx))
392	goto err;
393
394	params_peer = OSSL_PARAM_BLD_to_param(bld);
395	if (params == NULL \|\| params_peer == NULL)
396	goto err;
397
398	/* Create a EVP_PKEY_CTX to load the DH keys into */
399	kactx = EVP_PKEY_CTX_new_from_name(libctx, t->algorithm, "");
400	if (kactx == NULL)
401	goto err;
402	if (EVP_PKEY_fromdata_init(kactx) <= 0
403	\|\| EVP_PKEY_fromdata(kactx, &pkey, EVP_PKEY_KEYPAIR, params) <= 0)
404	goto err;
405	if (EVP_PKEY_fromdata_init(kactx) <= 0
406	\|\| EVP_PKEY_fromdata(kactx, &peerkey, EVP_PKEY_KEYPAIR, params_peer) <= 0)
407	goto err;
408
409	/* Create a EVP_PKEY_CTX to perform key derivation */
410	dctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, NULL);
411	if (dctx == NULL)
412	goto err;
413
414	if (EVP_PKEY_derive_init(dctx) <= 0
415	\|\| EVP_PKEY_derive_set_peer(dctx, peerkey) <= 0
416	\|\| EVP_PKEY_derive(dctx, secret, &secret_len) <= 0)
417	goto err;
418
419	OSSL_SELF_TEST_oncorrupt_byte(st, secret);
420
421	if (secret_len != t->expected_len
422	\|\| memcmp(secret, t->expected, t->expected_len) != 0)
423	goto err;
424	ret = 1;
425	err:
426	BN_CTX_free(bnctx);
427	EVP_PKEY_free(pkey);
428	EVP_PKEY_free(peerkey);
429	EVP_PKEY_CTX_free(kactx);
430	EVP_PKEY_CTX_free(dctx);
431	OSSL_PARAM_free(params_peer);
432	OSSL_PARAM_free(params);
433	OSSL_PARAM_BLD_free(bld);
434	OSSL_SELF_TEST_onend(st, ret);
435	return ret;
436	}
437	#endif /* !defined(OPENSSL_NO_DH) \|\| !defined(OPENSSL_NO_EC) */
438
439	static int self_test_sign(const ST_KAT_SIGN *t,
440	OSSL_SELF_TEST st, OSSL_LIB_CTX libctx)
441	{
442	int ret = 0;
443	OSSL_PARAM params = NULL, params_sig = NULL;
444	OSSL_PARAM_BLD *bld = NULL;
445	EVP_PKEY_CTX sctx = NULL, kctx = NULL;
446	EVP_PKEY *pkey = NULL;
447	unsigned char sig[256];
448	BN_CTX *bnctx = NULL;
449	size_t siglen = sizeof(sig);
450	static const unsigned char dgst[] = {
451	0x7f, 0x83, 0xb1, 0x65, 0x7f, 0xf1, 0xfc, 0x53, 0xb9, 0x2d, 0xc1, 0x81,
452	0x48, 0xa1, 0xd6, 0x5d, 0xfc, 0x2d, 0x4b, 0x1f, 0xa3, 0xd6, 0x77, 0x28,
453	0x4a, 0xdd, 0xd2, 0x00, 0x12, 0x6d, 0x90, 0x69
454	};
455	const char *typ = OSSL_SELF_TEST_TYPE_KAT_SIGNATURE;
456
457	if (t->sig_expected == NULL)
458	typ = OSSL_SELF_TEST_TYPE_PCT_SIGNATURE;
459
460	OSSL_SELF_TEST_onbegin(st, typ, t->desc);
461
462	bnctx = BN_CTX_new_ex(libctx);
463	if (bnctx == NULL)
464	goto err;
465
466	bld = OSSL_PARAM_BLD_new();
467	if (bld == NULL)
468	goto err;
469
470	if (!add_params(bld, t->key, bnctx))
471	goto err;
472	params = OSSL_PARAM_BLD_to_param(bld);
473
474	/* Create a EVP_PKEY_CTX to load the DSA key into */
475	kctx = EVP_PKEY_CTX_new_from_name(libctx, t->algorithm, "");
476	if (kctx == NULL \|\| params == NULL)
477	goto err;
478	if (EVP_PKEY_fromdata_init(kctx) <= 0
479	\|\| EVP_PKEY_fromdata(kctx, &pkey, EVP_PKEY_KEYPAIR, params) <= 0)
480	goto err;
481
482	/* Create a EVP_PKEY_CTX to use for the signing operation */
483	sctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, NULL);
484	if (sctx == NULL
485	\|\| EVP_PKEY_sign_init(sctx) <= 0)
486	goto err;
487
488	/* set signature parameters */
489	if (!OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_SIGNATURE_PARAM_DIGEST,
490	t->mdalgorithm,
491	strlen(t->mdalgorithm) + 1))
492	goto err;
493	params_sig = OSSL_PARAM_BLD_to_param(bld);
494	if (EVP_PKEY_CTX_set_params(sctx, params_sig) <= 0)
495	goto err;
496
497	if (EVP_PKEY_sign(sctx, sig, &siglen, dgst, sizeof(dgst)) <= 0
498	\|\| EVP_PKEY_verify_init(sctx) <= 0
499	\|\| EVP_PKEY_CTX_set_params(sctx, params_sig) <= 0)
500	goto err;
501
502	/*
503	* Used by RSA, for other key types where the signature changes, we
504	* can only use the verify.
505	*/
506	if (t->sig_expected != NULL
507	&& (siglen != t->sig_expected_len
508	\|\| memcmp(sig, t->sig_expected, t->sig_expected_len) != 0))
509	goto err;
510
511	OSSL_SELF_TEST_oncorrupt_byte(st, sig);
512	if (EVP_PKEY_verify(sctx, sig, siglen, dgst, sizeof(dgst)) <= 0)
513	goto err;
514	ret = 1;
515	err:
516	BN_CTX_free(bnctx);
517	EVP_PKEY_free(pkey);
518	EVP_PKEY_CTX_free(kctx);
519	EVP_PKEY_CTX_free(sctx);
520	OSSL_PARAM_free(params);
521	OSSL_PARAM_free(params_sig);
522	OSSL_PARAM_BLD_free(bld);
523	OSSL_SELF_TEST_onend(st, ret);
524	return ret;
525	}
526
527	/*
528	* Test an encrypt or decrypt KAT..
529	*
530	* FIPS 140-2 IG D.9 states that separate KAT tests are needed for encrypt
531	* and decrypt..
532	*/
533	static int self_test_asym_cipher(const ST_KAT_ASYM_CIPHER t, OSSL_SELF_TEST st,
534	OSSL_LIB_CTX *libctx)
535	{
536	int ret = 0;
537	OSSL_PARAM keyparams = NULL, initparams = NULL;
538	OSSL_PARAM_BLD keybld = NULL, initbld = NULL;
539	EVP_PKEY_CTX encctx = NULL, keyctx = NULL;
540	EVP_PKEY *key = NULL;
541	BN_CTX *bnctx = NULL;
542	unsigned char out[256];
543	size_t outlen = sizeof(out);
544
545	OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_KAT_ASYM_CIPHER, t->desc);
546
547	bnctx = BN_CTX_new_ex(libctx);
548	if (bnctx == NULL)
549	goto err;
550
551	/* Load a public or private key from data */
552	keybld = OSSL_PARAM_BLD_new();
553	if (keybld == NULL
554	\|\| !add_params(keybld, t->key, bnctx))
555	goto err;
556	keyparams = OSSL_PARAM_BLD_to_param(keybld);
557	keyctx = EVP_PKEY_CTX_new_from_name(libctx, t->algorithm, NULL);
558	if (keyctx == NULL \|\| keyparams == NULL)
559	goto err;
560	if (EVP_PKEY_fromdata_init(keyctx) <= 0
561	\|\| EVP_PKEY_fromdata(keyctx, &key, EVP_PKEY_KEYPAIR, keyparams) <= 0)
562	goto err;
563
564	/* Create a EVP_PKEY_CTX to use for the encrypt or decrypt operation */
565	encctx = EVP_PKEY_CTX_new_from_pkey(libctx, key, NULL);
566	if (encctx == NULL
567	\|\| (t->encrypt && EVP_PKEY_encrypt_init(encctx) <= 0)
568	\|\| (!t->encrypt && EVP_PKEY_decrypt_init(encctx) <= 0))
569	goto err;
570
571	/* Add any additional parameters such as padding */
572	if (t->postinit != NULL) {
573	initbld = OSSL_PARAM_BLD_new();
574	if (initbld == NULL)
575	goto err;
576	if (!add_params(initbld, t->postinit, bnctx))
577	goto err;
578	initparams = OSSL_PARAM_BLD_to_param(initbld);
579	if (initparams == NULL)
580	goto err;
581	if (EVP_PKEY_CTX_set_params(encctx, initparams) <= 0)
582	goto err;
583	}
584
585	if (t->encrypt) {
586	if (EVP_PKEY_encrypt(encctx, out, &outlen,
587	t->in, t->in_len) <= 0)
588	goto err;
589	} else {
590	if (EVP_PKEY_decrypt(encctx, out, &outlen,
591	t->in, t->in_len) <= 0)
592	goto err;
593	}
594	/* Check the KAT */
595	OSSL_SELF_TEST_oncorrupt_byte(st, out);
596	if (outlen != t->expected_len
597	\|\| memcmp(out, t->expected, t->expected_len) != 0)
598	goto err;
599
600	ret = 1;
601	err:
602	BN_CTX_free(bnctx);
603	EVP_PKEY_free(key);
604	EVP_PKEY_CTX_free(encctx);
605	EVP_PKEY_CTX_free(keyctx);
606	OSSL_PARAM_free(keyparams);
607	OSSL_PARAM_BLD_free(keybld);
608	OSSL_PARAM_free(initparams);
609	OSSL_PARAM_BLD_free(initbld);
610	OSSL_SELF_TEST_onend(st, ret);
611	return ret;
612	}
613
614	/*
615	* Test a data driven list of KAT's for digest algorithms.
616	* All tests are run regardless of if they fail or not.
617	* Return 0 if any test fails.
618	*/
619	static int self_test_digests(OSSL_SELF_TEST st, OSSL_LIB_CTX libctx)
620	{
621	int i, ret = 1;
622
623	for (i = 0; i < (int)OSSL_NELEM(st_kat_digest_tests); ++i) {
624	if (!self_test_digest(&st_kat_digest_tests[i], st, libctx))
625	ret = 0;
626	}
627	return ret;
628	}
629
630	static int self_test_ciphers(OSSL_SELF_TEST st, OSSL_LIB_CTX libctx)
631	{
632	int i, ret = 1;
633
634	for (i = 0; i < (int)OSSL_NELEM(st_kat_cipher_tests); ++i) {
635	if (!self_test_cipher(&st_kat_cipher_tests[i], st, libctx))
636	ret = 0;
637	}
638	return ret;
639	}
640
641	static int self_test_asym_ciphers(OSSL_SELF_TEST st, OSSL_LIB_CTX libctx)
642	{
643	int i, ret = 1;
644
645	for (i = 0; i < (int)OSSL_NELEM(st_kat_asym_cipher_tests); ++i) {
646	if (!self_test_asym_cipher(&st_kat_asym_cipher_tests[i], st, libctx))
647	ret = 0;
648	}
649	return ret;
650	}
651
652	static int self_test_kdfs(OSSL_SELF_TEST st, OSSL_LIB_CTX libctx)
653	{
654	int i, ret = 1;
655
656	for (i = 0; i < (int)OSSL_NELEM(st_kat_kdf_tests); ++i) {
657	if (!self_test_kdf(&st_kat_kdf_tests[i], st, libctx))
658	ret = 0;
659	}
660	return ret;
661	}
662
663	static int self_test_drbgs(OSSL_SELF_TEST st, OSSL_LIB_CTX libctx)
664	{
665	int i, ret = 1;
666
667	for (i = 0; i < (int)OSSL_NELEM(st_kat_drbg_tests); ++i) {
668	if (!self_test_drbg(&st_kat_drbg_tests[i], st, libctx))
669	ret = 0;
670	}
671	return ret;
672	}
673
674	static int self_test_kas(OSSL_SELF_TEST st, OSSL_LIB_CTX libctx)
675	{
676	int ret = 1;
677	#if !defined(OPENSSL_NO_DH) \|\| !defined(OPENSSL_NO_EC)
678	int i;
679
680	for (i = 0; i < (int)OSSL_NELEM(st_kat_kas_tests); ++i) {
681	if (!self_test_ka(&st_kat_kas_tests[i], st, libctx))
682	ret = 0;
683	}
684	#endif
685
686	return ret;
687	}
688
689	static int self_test_signatures(OSSL_SELF_TEST st, OSSL_LIB_CTX libctx)
690	{
691	int i, ret = 1;
692
693	for (i = 0; i < (int)OSSL_NELEM(st_kat_sign_tests); ++i) {
694	if (!self_test_sign(&st_kat_sign_tests[i], st, libctx))
695	ret = 0;
696	}
697	return ret;
698	}
699
700	/*
701	* Run the algorithm KAT's.
702	* Return 1 is successful, otherwise return 0.
703	* This runs all the tests regardless of if any fail.
704	*/
705	int SELF_TEST_kats(OSSL_SELF_TEST st, OSSL_LIB_CTX libctx)
706	{
707	int ret = 1;
708
709	if (!self_test_digests(st, libctx))
710	ret = 0;
711	if (!self_test_ciphers(st, libctx))
712	ret = 0;
713	if (!self_test_signatures(st, libctx))
714	ret = 0;
715	if (!self_test_kdfs(st, libctx))
716	ret = 0;
717	if (!self_test_drbgs(st, libctx))
718	ret = 0;
719	if (!self_test_kas(st, libctx))
720	ret = 0;
721	if (!self_test_asym_ciphers(st, libctx))
722	ret = 0;
723
724	return ret;
725	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-3.0.3/providers/fips/self_test_kats.c@ 96441

Download in other formats: