1 /*
2 * Copyright 2015-2026 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 #define OPENSSL_SUPPRESS_DEPRECATED /* EVP_PKEY_new_CMAC_key */
11 #include <stdio.h>
12 #include <string.h>
13 #include <stdlib.h>
14 #include <ctype.h>
15 #include <openssl/evp.h>
16 #include <openssl/pem.h>
17 #include <openssl/err.h>
18 #include <openssl/provider.h>
19 #include <openssl/x509v3.h>
20 #include <openssl/pkcs12.h>
21 #include <openssl/kdf.h>
22 #include <openssl/params.h>
23 #include <openssl/param_build.h>
24 #include <openssl/core_names.h>
25 #include <openssl/fips_names.h>
26 #include <openssl/thread.h>
27 #include "internal/numbers.h"
28 #include "internal/nelem.h"
29 #include "internal/sizes.h"
30 #include "crypto/evp.h"
31 #include "testutil.h"
32
33 typedef struct evp_test_buffer_st EVP_TEST_BUFFER;
34 DEFINE_STACK_OF(EVP_TEST_BUFFER)
35
36 #define AAD_NUM 4
37
38 typedef struct evp_test_method_st EVP_TEST_METHOD;
39
40 /* Structure holding test information */
41 typedef struct evp_test_st {
42 STANZA s; /* Common test stanza */
43 char *name;
44 int skip; /* Current test should be skipped */
45 const EVP_TEST_METHOD *meth; /* method for this test */
46 const char *err, *aux_err; /* Error string for test */
47 char *expected_err; /* Expected error value of test */
48 char *reason; /* Expected error reason string */
49 void *data; /* test specific data */
50 int expect_unapproved;
51 int expect_unapproved_callback;
52 } EVP_TEST;
53
54 /* Test method structure */
55 struct evp_test_method_st {
56 /* Name of test as it appears in file */
57 const char *name;
58 /* Initialise test for "alg" */
59 int (*init)(EVP_TEST *t, const char *alg);
60 /* Clean up method */
61 void (*cleanup)(EVP_TEST *t);
62 /* Test specific name value pair processing */
63 int (*parse)(EVP_TEST *t, const char *name, const char *value);
64 /* Run the test itself */
65 int (*run_test)(EVP_TEST *t);
66 };
67
68 /* Linked list of named keys. */
69 typedef struct key_list_st {
70 char *name;
71 EVP_PKEY *key;
72 struct key_list_st *next;
73 } KEY_LIST;
74
75 typedef enum OPTION_choice {
76 OPT_ERR = -1,
77 OPT_EOF = 0,
78 OPT_CONFIG_FILE,
79 OPT_IN_PLACE,
80 OPT_PROVIDER_NAME,
81 OPT_PROV_PROPQUERY,
82 OPT_DATA_CHUNK,
83 OPT_TEST_ENUM
84 } OPTION_CHOICE;
85
86 static OSSL_PROVIDER *prov_null = NULL;
87 static OSSL_PROVIDER *libprov = NULL;
88 static OSSL_LIB_CTX *libctx = NULL;
89 static int fips_indicator_callback_unapproved_count = 0;
90 static int missing_fips_indicator_is_approved = 0;
91 static int extended_tests = 0;
92
93 /* List of public and private keys */
94 static KEY_LIST *private_keys;
95 static KEY_LIST *public_keys;
96
97 static int find_key(EVP_PKEY **ppk, const char *name, KEY_LIST *lst);
98 static int parse_bin(const char *value, unsigned char **buf, size_t *buflen);
99 static int parse_bin_chunk(const char *value, size_t offset, size_t max,
100 unsigned char **buf, size_t *buflen, size_t *out_offset);
101 static int is_digest_disabled(const char *name);
102 static int is_pkey_disabled(const char *name);
103 static int is_mac_disabled(const char *name);
104 static int is_cipher_disabled(const char *name);
105 static int is_kdf_disabled(const char *name);
106
107 /* A callback that is triggered if fips unapproved mode is detected */
fips_indicator_cb(const char * type,const char * desc,const OSSL_PARAM params[])108 static int fips_indicator_cb(const char *type, const char *desc,
109 const OSSL_PARAM params[])
110 {
111 fips_indicator_callback_unapproved_count++;
112 TEST_info("(Indicator Callback received %s : %s is not approved)", type, desc);
113 return 1;
114 }
115
check_fips_approved(EVP_TEST * t,int approved)116 static int check_fips_approved(EVP_TEST *t, int approved)
117 {
118 int callback_received = fips_indicator_callback_unapproved_count > 0;
119
120 if (!OSSL_PROVIDER_available(libctx, "fips")) {
121 if (approved != 0) {
122 TEST_error("A non-FIPS provider reported a FIPS approved operation");
123 return 0;
124 }
125 return 1;
126 }
127
128 /* The callback is checked only when UnapprovedCallback was specified. */
129 if (t->expect_unapproved) {
130 if (approved != 0) {
131 TEST_error("Test is not expected to be FIPS approved");
132 return 0;
133 }
134 } else {
135 if (approved == 0) {
136 TEST_error("Test is expected to be FIPS approved");
137 return 0;
138 }
139 }
140 if (t->expect_unapproved_callback && !callback_received) {
141 TEST_error("Expected an unapproved callback");
142 return 0;
143 }
144 return 1;
145 }
146
mac_check_fips_approved(EVP_MAC_CTX * ctx,EVP_TEST * t)147 static int mac_check_fips_approved(EVP_MAC_CTX *ctx, EVP_TEST *t)
148 {
149 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
150 int approved = missing_fips_indicator_is_approved;
151 const OSSL_PARAM *gettables = EVP_MAC_CTX_gettable_params(ctx);
152
153 if (gettables == NULL
154 || OSSL_PARAM_locate_const(gettables,
155 OSSL_MAC_PARAM_FIPS_APPROVED_INDICATOR)
156 == NULL)
157 return check_fips_approved(t, approved);
158
159 params[0] = OSSL_PARAM_construct_int(OSSL_MAC_PARAM_FIPS_APPROVED_INDICATOR,
160 &approved);
161 if (!EVP_MAC_CTX_get_params(ctx, params)
162 || !OSSL_PARAM_modified(params))
163 return 0;
164 return check_fips_approved(t, approved);
165 }
166
pkey_check_fips_approved(EVP_PKEY_CTX * ctx,EVP_TEST * t)167 static int pkey_check_fips_approved(EVP_PKEY_CTX *ctx, EVP_TEST *t)
168 {
169 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
170 int approved = missing_fips_indicator_is_approved;
171 const OSSL_PARAM *gettables = EVP_PKEY_CTX_gettable_params(ctx);
172
173 if (gettables == NULL
174 || OSSL_PARAM_locate_const(gettables,
175 OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR)
176 == NULL)
177 return check_fips_approved(t, approved);
178
179 params[0] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR,
180 &approved);
181 if (!EVP_PKEY_CTX_get_params(ctx, params)
182 || !OSSL_PARAM_modified(params))
183 return 0;
184 return check_fips_approved(t, approved);
185 }
186
rand_check_fips_approved(EVP_RAND_CTX * ctx,EVP_TEST * t)187 static int rand_check_fips_approved(EVP_RAND_CTX *ctx, EVP_TEST *t)
188 {
189 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
190 int approved = missing_fips_indicator_is_approved;
191 const OSSL_PARAM *gettables = EVP_RAND_CTX_gettable_params(ctx);
192
193 if (gettables == NULL
194 || OSSL_PARAM_locate_const(gettables,
195 OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR)
196 == NULL)
197 return check_fips_approved(t, approved);
198
199 params[0] = OSSL_PARAM_construct_int(OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR,
200 &approved);
201 if (!EVP_RAND_CTX_get_params(ctx, params)
202 || !OSSL_PARAM_modified(params))
203 return 0;
204 return check_fips_approved(t, approved);
205 }
206
digest_check_fips_approved(EVP_MD_CTX * ctx,EVP_TEST * t)207 static int digest_check_fips_approved(EVP_MD_CTX *ctx, EVP_TEST *t)
208 {
209 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
210 int approved = missing_fips_indicator_is_approved;
211 const OSSL_PARAM *gettables = EVP_MD_CTX_gettable_params(ctx);
212
213 if (gettables == NULL
214 || OSSL_PARAM_locate_const(gettables,
215 OSSL_DIGEST_PARAM_FIPS_APPROVED_INDICATOR)
216 == NULL)
217 return check_fips_approved(t, approved);
218
219 params[0] = OSSL_PARAM_construct_int(OSSL_DIGEST_PARAM_FIPS_APPROVED_INDICATOR,
220 &approved);
221 if (!EVP_MD_CTX_get_params(ctx, params)
222 || !OSSL_PARAM_modified(params))
223 return 0;
224 return check_fips_approved(t, approved);
225 }
226
ctrladd(STACK_OF (OPENSSL_STRING)* controls,const char * value)227 static int ctrladd(STACK_OF(OPENSSL_STRING) *controls, const char *value)
228 {
229 char *data = OPENSSL_strdup(value);
230
231 if (data == NULL)
232 return -1;
233
234 if (sk_OPENSSL_STRING_push(controls, data) <= 0) {
235 OPENSSL_free(data);
236 return -1;
237 }
238
239 return 1;
240 }
241
242 /* Because OPENSSL_free is a macro, it can't be passed as a function pointer */
openssl_free(char * m)243 static void openssl_free(char *m)
244 {
245 OPENSSL_free(m);
246 }
247
ctrlfree(STACK_OF (OPENSSL_STRING)* controls)248 static void ctrlfree(STACK_OF(OPENSSL_STRING) *controls)
249 {
250 sk_OPENSSL_STRING_pop_free(controls, openssl_free);
251 }
252
253 /*
254 * This is used if ctrl2params() passes settables as NULL.
255 * A default list of settable OSSL_PARAM that may be set during an operations
256 * init().
257 * Using the algorithms settable list is problematic since it requires that the
258 * init() has already run.
259 */
260 static const OSSL_PARAM settable_ctx_params[] = {
261 OSSL_PARAM_int("key-check", NULL),
262 OSSL_PARAM_int("digest-check", NULL),
263 OSSL_PARAM_int("ems_check", NULL),
264 OSSL_PARAM_int("sign-check", NULL),
265 OSSL_PARAM_int("encrypt-check", NULL),
266 OSSL_PARAM_int("rsa-pss-saltlen-check", NULL),
267 OSSL_PARAM_int("sign-x931-pad-check", NULL),
268 OSSL_PARAM_END
269 };
270
ctrl2params(EVP_TEST * t,STACK_OF (OPENSSL_STRING)* controls,const OSSL_PARAM * settables,OSSL_PARAM params[],size_t params_sz,size_t * params_n)271 static int ctrl2params(EVP_TEST *t, STACK_OF(OPENSSL_STRING) *controls,
272 const OSSL_PARAM *settables,
273 OSSL_PARAM params[], size_t params_sz, size_t *params_n)
274 {
275 int i;
276
277 if (settables == NULL)
278 settables = settable_ctx_params;
279 /* check bounds */
280 if (*params_n + sk_OPENSSL_STRING_num(controls) >= params_sz) {
281 t->err = "ERR_TOO_MANY_PARAMETERS";
282 goto err;
283 }
284 for (i = 0; i < sk_OPENSSL_STRING_num(controls); i++) {
285 char *tmpkey, *tmpval;
286 char *value = sk_OPENSSL_STRING_value(controls, i);
287
288 if (!TEST_ptr(tmpkey = OPENSSL_strdup(value))) {
289 t->err = "ERR_PARAM_ERROR";
290 goto err;
291 }
292 tmpval = strchr(tmpkey, ':');
293 if (tmpval != NULL)
294 *tmpval++ = '\0';
295
296 if (tmpval == NULL
297 || !OSSL_PARAM_allocate_from_text(¶ms[*params_n],
298 settables,
299 tmpkey, tmpval,
300 strlen(tmpval), NULL)) {
301 OPENSSL_free(tmpkey);
302 t->err = "ERR_PARAM_ERROR";
303 goto err;
304 }
305 *params_n += 1;
306 OPENSSL_free(tmpkey);
307 }
308 params[*params_n] = OSSL_PARAM_construct_end();
309 return 1;
310 err:
311 return 0;
312 }
313
ctrl2params_free(OSSL_PARAM params[],size_t params_n,size_t params_n_allocstart)314 static void ctrl2params_free(OSSL_PARAM params[],
315 size_t params_n, size_t params_n_allocstart)
316 {
317 while (params_n-- > params_n_allocstart) {
318 OPENSSL_free(params[params_n].data);
319 }
320 }
321
kdf_check_fips_approved(EVP_KDF_CTX * ctx,EVP_TEST * t)322 static int kdf_check_fips_approved(EVP_KDF_CTX *ctx, EVP_TEST *t)
323 {
324 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
325 int approved = missing_fips_indicator_is_approved;
326 const OSSL_PARAM *gettables = EVP_KDF_CTX_gettable_params(ctx);
327
328 if (gettables == NULL
329 || OSSL_PARAM_locate_const(gettables,
330 OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR)
331 == NULL)
332 return check_fips_approved(t, approved);
333
334 params[0] = OSSL_PARAM_construct_int(OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR,
335 &approved);
336 if (!EVP_KDF_CTX_get_params(ctx, params)
337 || !OSSL_PARAM_modified(params))
338 return 0;
339 return check_fips_approved(t, approved);
340 }
341
cipher_get_fips_approved(EVP_CIPHER_CTX * ctx,int * approved)342 static int cipher_get_fips_approved(EVP_CIPHER_CTX *ctx, int *approved)
343 {
344 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
345 const OSSL_PARAM *gettables = EVP_CIPHER_CTX_gettable_params(ctx);
346
347 *approved = missing_fips_indicator_is_approved;
348 if (gettables == NULL
349 || OSSL_PARAM_locate_const(gettables,
350 OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR)
351 == NULL)
352 return 1;
353
354 params[0] = OSSL_PARAM_construct_int(OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR,
355 approved);
356 if (!EVP_CIPHER_CTX_get_params(ctx, params)
357 || !OSSL_PARAM_modified(params))
358 return 0;
359 return 1;
360 }
361
362 /*
363 * Compare two memory regions for equality, returning zero if they differ.
364 * However, if there is expected to be an error and the actual error
365 * matches then the memory is expected to be different so handle this
366 * case without producing unnecessary test framework output.
367 */
memory_err_compare(EVP_TEST * t,const char * err,const void * expected,size_t expected_len,const void * got,size_t got_len)368 static int memory_err_compare(EVP_TEST *t, const char *err,
369 const void *expected, size_t expected_len,
370 const void *got, size_t got_len)
371 {
372 int r;
373
374 if (t->expected_err != NULL && strcmp(t->expected_err, err) == 0)
375 r = !TEST_mem_ne(expected, expected_len, got, got_len);
376 else
377 r = TEST_mem_eq(expected, expected_len, got, got_len);
378 if (!r)
379 t->err = err;
380 return r;
381 }
382
383 /* Option specific for evp test */
384 static int process_mode_in_place;
385 static const char *propquery = NULL;
386 static int data_chunk_size;
387
evp_test_process_mode(char * mode)388 static int evp_test_process_mode(char *mode)
389 {
390 if (strcmp(mode, "in_place") == 0)
391 return 1;
392 else if (strcmp(mode, "both") == 0)
393 return 0;
394 return -1;
395 }
396
397 /*
398 * Structure used to hold a list of blocks of memory to test
399 * calls to "update" like functions.
400 */
401 struct evp_test_buffer_st {
402 unsigned char *buf;
403 size_t buflen;
404 size_t count;
405 int count_set;
406 };
407
evp_test_buffer_free(EVP_TEST_BUFFER * db)408 static void evp_test_buffer_free(EVP_TEST_BUFFER *db)
409 {
410 if (db != NULL) {
411 OPENSSL_free(db->buf);
412 OPENSSL_free(db);
413 }
414 }
415
416 /* append buffer to a list */
evp_test_buffer_append(const char * value,size_t max_len,STACK_OF (EVP_TEST_BUFFER)** sk)417 static int evp_test_buffer_append(const char *value, size_t max_len,
418 STACK_OF(EVP_TEST_BUFFER) **sk)
419 {
420 EVP_TEST_BUFFER *db = NULL;
421 int rv = 0;
422 size_t offset = 0;
423
424 if (*sk == NULL && !TEST_ptr(*sk = sk_EVP_TEST_BUFFER_new_null()))
425 goto err;
426
427 do {
428 if (!TEST_ptr(db = OPENSSL_zalloc(sizeof(*db))))
429 goto err;
430 if (max_len == 0) {
431 /* parse all in one shot */
432 if ((rv = parse_bin(value, &db->buf, &db->buflen)) != 1)
433 goto err;
434 } else {
435 /* parse in chunks */
436 size_t new_offset = 0;
437
438 if ((rv = parse_bin_chunk(value, offset, max_len, &db->buf,
439 &db->buflen, &new_offset))
440 == -1)
441 goto err;
442 offset = new_offset;
443 }
444
445 db->count = 1;
446 db->count_set = 0;
447
448 if (db->buf == NULL)
449 evp_test_buffer_free(db);
450 else if (db->buf != NULL && !sk_EVP_TEST_BUFFER_push(*sk, db))
451 goto err;
452 /* if processing by chunks, continue until the whole value is parsed */
453 } while (rv == 1 && max_len != 0);
454
455 return 1;
456
457 err:
458 evp_test_buffer_free(db);
459 return 0;
460 }
461
462 /* replace last buffer in list with copies of itself */
evp_test_buffer_ncopy(const char * value,STACK_OF (EVP_TEST_BUFFER)* sk)463 static int evp_test_buffer_ncopy(const char *value,
464 STACK_OF(EVP_TEST_BUFFER) *sk)
465 {
466 EVP_TEST_BUFFER *db;
467 unsigned char *tbuf, *p;
468 size_t tbuflen;
469 int ncopy = atoi(value);
470 int i;
471
472 if (ncopy <= 0)
473 return 0;
474 if (sk == NULL || sk_EVP_TEST_BUFFER_num(sk) == 0)
475 return 0;
476 db = sk_EVP_TEST_BUFFER_value(sk, sk_EVP_TEST_BUFFER_num(sk) - 1);
477
478 tbuflen = db->buflen * ncopy;
479 if (!TEST_ptr(tbuf = OPENSSL_malloc(tbuflen)))
480 return 0;
481 for (i = 0, p = tbuf; i < ncopy; i++, p += db->buflen)
482 memcpy(p, db->buf, db->buflen);
483
484 OPENSSL_free(db->buf);
485 db->buf = tbuf;
486 db->buflen = tbuflen;
487 return 1;
488 }
489
490 /* set repeat count for last buffer in list */
evp_test_buffer_set_count(const char * value,STACK_OF (EVP_TEST_BUFFER)* sk)491 static int evp_test_buffer_set_count(const char *value,
492 STACK_OF(EVP_TEST_BUFFER) *sk)
493 {
494 EVP_TEST_BUFFER *db;
495 int count = atoi(value);
496
497 if (count <= 0)
498 return 0;
499
500 if (sk == NULL || sk_EVP_TEST_BUFFER_num(sk) == 0)
501 return 0;
502
503 db = sk_EVP_TEST_BUFFER_value(sk, sk_EVP_TEST_BUFFER_num(sk) - 1);
504 if (db->count_set != 0)
505 return 0;
506
507 db->count = (size_t)count;
508 db->count_set = 1;
509 return 1;
510 }
511
512 /* call "fn" with each element of the list in turn */
evp_test_buffer_do(STACK_OF (EVP_TEST_BUFFER)* sk,int (* fn)(void * ctx,const unsigned char * buf,size_t buflen),void * ctx)513 static int evp_test_buffer_do(STACK_OF(EVP_TEST_BUFFER) *sk,
514 int (*fn)(void *ctx,
515 const unsigned char *buf,
516 size_t buflen),
517 void *ctx)
518 {
519 int i;
520
521 for (i = 0; i < sk_EVP_TEST_BUFFER_num(sk); i++) {
522 EVP_TEST_BUFFER *tb = sk_EVP_TEST_BUFFER_value(sk, i);
523 size_t j;
524
525 for (j = 0; j < tb->count; j++) {
526 if (fn(ctx, tb->buf, tb->buflen) <= 0)
527 return 0;
528 }
529 }
530 return 1;
531 }
532
533 /*
534 * Unescape some sequences in string literals (only \n for now).
535 * Return an allocated buffer, set |out_len|. If |input_len|
536 * is zero, get an empty buffer but set length to zero.
537 */
unescape(const char * input,size_t input_len,size_t * out_len)538 static unsigned char *unescape(const char *input, size_t input_len,
539 size_t *out_len)
540 {
541 unsigned char *ret, *p;
542 size_t i;
543
544 if (input_len == 0) {
545 *out_len = 0;
546 return OPENSSL_zalloc(1);
547 }
548
549 /* Escaping is non-expanding; over-allocate original size for simplicity. */
550 if (!TEST_ptr(ret = p = OPENSSL_malloc(input_len)))
551 return NULL;
552
553 for (i = 0; i < input_len; i++) {
554 if (*input == '\\') {
555 if (i == input_len - 1 || *++input != 'n') {
556 TEST_error("Bad escape sequence in file");
557 goto err;
558 }
559 *p++ = '\n';
560 i++;
561 input++;
562 } else {
563 *p++ = *input++;
564 }
565 }
566
567 *out_len = p - ret;
568 return ret;
569
570 err:
571 OPENSSL_free(ret);
572 return NULL;
573 }
574
575 /*
576 * For a hex string "value" convert to a binary allocated buffer.
577 * Return 1 on success or 0 on failure.
578 */
parse_bin(const char * value,unsigned char ** buf,size_t * buflen)579 static int parse_bin(const char *value, unsigned char **buf, size_t *buflen)
580 {
581 long len;
582
583 /* Check for NULL literal */
584 if (strcmp(value, "NULL") == 0) {
585 *buf = NULL;
586 *buflen = 0;
587 return 1;
588 }
589
590 /* Check for empty value */
591 if (*value == '\0') {
592 /*
593 * Don't return NULL for zero length buffer. This is needed for
594 * some tests with empty keys: HMAC_Init_ex() expects a non-NULL key
595 * buffer even if the key length is 0, in order to detect key reset.
596 */
597 *buf = OPENSSL_malloc(1);
598 if (*buf == NULL)
599 return 0;
600 **buf = 0;
601 *buflen = 0;
602 return 1;
603 }
604
605 /* Check for string literal */
606 if (value[0] == '"') {
607 size_t vlen = strlen(++value);
608
609 if (vlen == 0 || value[vlen - 1] != '"')
610 return 0;
611 vlen--;
612 *buf = unescape(value, vlen, buflen);
613 return *buf == NULL ? 0 : 1;
614 }
615
616 /* Otherwise assume as hex literal and convert it to binary buffer */
617 if (!TEST_ptr(*buf = OPENSSL_hexstr2buf(value, &len))) {
618 TEST_info("Can't convert %s", value);
619 TEST_openssl_errors();
620 return -1;
621 }
622 /* Size of input buffer means we'll never overflow */
623 *buflen = len;
624 return 1;
625 }
626
627 /*
628 * Convert at maximum "max" bytes to a binary allocated buffer.
629 * Return 1 on success, -1 on failure or 0 for end of value string.
630 */
parse_bin_chunk(const char * value,size_t offset,size_t max,unsigned char ** buf,size_t * buflen,size_t * out_offset)631 static int parse_bin_chunk(const char *value, size_t offset, size_t max,
632 unsigned char **buf, size_t *buflen, size_t *out_offset)
633 {
634 size_t vlen;
635 size_t chunk_len;
636 const char *value_str = value[0] == '"' ? value + offset + 1 : value + offset;
637
638 if (max < 1)
639 return -1;
640
641 if (*value == '\0' || strcmp(value, "\"\"") == 0) {
642 *buf = OPENSSL_malloc(1);
643 if (*buf == NULL)
644 return 0;
645 **buf = 0;
646 *buflen = 0;
647 return 0;
648 }
649
650 if (*value_str == '\0')
651 return 0;
652
653 vlen = strlen(value_str);
654 if (value[0] == '"') {
655 /* Parse string literal */
656 if (vlen == 1 && value_str[0] != '"')
657 /* Missing ending quotation mark */
658 return -1;
659 if (vlen == 1 && value_str[0] == '"')
660 /* End of value */
661 return 0;
662 vlen--;
663 chunk_len = max > vlen ? vlen : max;
664 if ((*buf = unescape(value_str, chunk_len, buflen)) == NULL)
665 return -1;
666 } else {
667 /* Parse hex string chunk */
668 long len;
669 char *chunk = NULL;
670
671 chunk_len = 2 * max > vlen ? vlen : 2 * max;
672 chunk = OPENSSL_strndup(value_str, chunk_len);
673 if (chunk == NULL)
674 return -1;
675 if (!TEST_ptr(*buf = OPENSSL_hexstr2buf(chunk, &len))) {
676 OPENSSL_free(chunk);
677 TEST_openssl_errors();
678 return -1;
679 }
680 OPENSSL_free(chunk);
681 *buflen = len;
682 }
683 *out_offset = value[0] == '"' ? offset + (*buflen) : offset + 2 * (*buflen);
684 return 1;
685 }
686
687 /**
688 ** MESSAGE DIGEST TESTS
689 **/
690
691 typedef struct digest_data_st {
692 /* Digest this test is for */
693 const EVP_MD *digest;
694 EVP_MD *fetched_digest;
695 /* Input to digest */
696 STACK_OF(EVP_TEST_BUFFER) *input;
697 /* Expected output */
698 unsigned char *output;
699 size_t output_len;
700 /* Padding type */
701 int pad_type;
702 /* XOF mode? */
703 int xof;
704 /* Size for variable output length but non-XOF */
705 size_t digest_size;
706 } DIGEST_DATA;
707
digest_test_init(EVP_TEST * t,const char * alg)708 static int digest_test_init(EVP_TEST *t, const char *alg)
709 {
710 DIGEST_DATA *mdat;
711 const EVP_MD *digest;
712 EVP_MD *fetched_digest;
713
714 if (is_digest_disabled(alg)) {
715 TEST_info("skipping, '%s' is disabled", alg);
716 t->skip = 1;
717 return 1;
718 }
719
720 if ((digest = fetched_digest = EVP_MD_fetch(libctx, alg, propquery)) == NULL
721 && (digest = EVP_get_digestbyname(alg)) == NULL)
722 return 0;
723 if (!TEST_ptr(mdat = OPENSSL_zalloc(sizeof(*mdat)))) {
724 EVP_MD_free(fetched_digest);
725 return 0;
726 }
727 t->data = mdat;
728 mdat->digest = digest;
729 mdat->fetched_digest = fetched_digest;
730 mdat->pad_type = 0;
731 mdat->xof = 0;
732 if (fetched_digest != NULL)
733 TEST_info("%s is fetched", alg);
734 return 1;
735 }
736
digest_test_cleanup(EVP_TEST * t)737 static void digest_test_cleanup(EVP_TEST *t)
738 {
739 DIGEST_DATA *mdat = t->data;
740
741 sk_EVP_TEST_BUFFER_pop_free(mdat->input, evp_test_buffer_free);
742 OPENSSL_free(mdat->output);
743 EVP_MD_free(mdat->fetched_digest);
744 }
745
digest_test_parse(EVP_TEST * t,const char * keyword,const char * value)746 static int digest_test_parse(EVP_TEST *t,
747 const char *keyword, const char *value)
748 {
749 DIGEST_DATA *mdata = t->data;
750
751 if (strcmp(keyword, "Input") == 0)
752 return evp_test_buffer_append(value, data_chunk_size, &mdata->input);
753 if (strcmp(keyword, "Output") == 0)
754 return parse_bin(value, &mdata->output, &mdata->output_len);
755 if (strcmp(keyword, "Count") == 0)
756 return evp_test_buffer_set_count(value, mdata->input);
757 if (strcmp(keyword, "Ncopy") == 0)
758 return evp_test_buffer_ncopy(value, mdata->input);
759 if (strcmp(keyword, "Padding") == 0)
760 return (mdata->pad_type = atoi(value)) > 0;
761 if (strcmp(keyword, "XOF") == 0)
762 return (mdata->xof = atoi(value)) > 0;
763 if (strcmp(keyword, "OutputSize") == 0) {
764 int sz;
765
766 sz = atoi(value);
767 if (sz < 0)
768 return -1;
769 mdata->digest_size = sz;
770 return 1;
771 }
772 return 0;
773 }
774
digest_update_fn(void * ctx,const unsigned char * buf,size_t buflen)775 static int digest_update_fn(void *ctx, const unsigned char *buf, size_t buflen)
776 {
777 return EVP_DigestUpdate(ctx, buf, buflen);
778 }
779
test_duplicate_md_ctx(EVP_TEST * t,EVP_MD_CTX * mctx)780 static int test_duplicate_md_ctx(EVP_TEST *t, EVP_MD_CTX *mctx)
781 {
782 char dont[] = "touch";
783
784 if (!TEST_ptr(mctx))
785 return 0;
786 if (!EVP_DigestFinalXOF(mctx, (unsigned char *)dont, 0)) {
787 EVP_MD_CTX_free(mctx);
788 t->err = "DIGESTFINALXOF_ERROR";
789 return 0;
790 }
791 if (!TEST_str_eq(dont, "touch")) {
792 EVP_MD_CTX_free(mctx);
793 t->err = "DIGESTFINALXOF_ERROR";
794 return 0;
795 }
796 EVP_MD_CTX_free(mctx);
797 return 1;
798 }
799
digest_test_run(EVP_TEST * t)800 static int digest_test_run(EVP_TEST *t)
801 {
802 DIGEST_DATA *expected = t->data;
803 EVP_TEST_BUFFER *inbuf;
804 EVP_MD_CTX *mctx;
805 unsigned char *got = NULL;
806 unsigned int got_len;
807 size_t size = 0;
808 int xof = 0;
809 OSSL_PARAM params[4], *p = ¶ms[0];
810
811 t->err = "TEST_FAILURE";
812 if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
813 goto err;
814
815 got = OPENSSL_malloc(expected->output_len > EVP_MAX_MD_SIZE ? expected->output_len : EVP_MAX_MD_SIZE);
816 if (!TEST_ptr(got))
817 goto err;
818
819 if (expected->xof > 0) {
820 xof |= 1;
821 *p++ = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_XOFLEN,
822 &expected->output_len);
823 }
824 if (expected->digest_size > 0) {
825 *p++ = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_SIZE,
826 &expected->digest_size);
827 }
828 if (expected->pad_type > 0)
829 *p++ = OSSL_PARAM_construct_int(OSSL_DIGEST_PARAM_PAD_TYPE,
830 &expected->pad_type);
831 *p++ = OSSL_PARAM_construct_end();
832
833 if (!EVP_DigestInit_ex2(mctx, expected->digest, params)) {
834 t->err = "DIGESTINIT_ERROR";
835 goto err;
836 }
837
838 if (!evp_test_buffer_do(expected->input, digest_update_fn, mctx)) {
839 t->err = "DIGESTUPDATE_ERROR";
840 goto err;
841 }
842
843 xof |= EVP_MD_xof(expected->digest);
844 if (xof) {
845 EVP_MD_CTX *mctx_cpy;
846
847 if (!TEST_ptr(mctx_cpy = EVP_MD_CTX_new())) {
848 goto err;
849 }
850 if (!TEST_true(EVP_MD_CTX_copy(mctx_cpy, mctx))) {
851 EVP_MD_CTX_free(mctx_cpy);
852 goto err;
853 } else if (!test_duplicate_md_ctx(t, mctx_cpy)) {
854 goto err;
855 }
856
857 if (!test_duplicate_md_ctx(t, EVP_MD_CTX_dup(mctx)))
858 goto err;
859
860 got_len = expected->output_len;
861 if (!EVP_DigestFinalXOF(mctx, got, got_len)) {
862 t->err = "DIGESTFINALXOF_ERROR";
863 goto err;
864 }
865 } else {
866 if (!EVP_DigestFinal_ex(mctx, got, &got_len)) {
867 t->err = "DIGESTFINAL_ERROR";
868 goto err;
869 }
870 }
871 if (!TEST_int_eq(expected->output_len, got_len)) {
872 t->err = "DIGEST_LENGTH_MISMATCH";
873 goto err;
874 }
875 if (!memory_err_compare(t, "DIGEST_MISMATCH",
876 expected->output, expected->output_len,
877 got, got_len))
878 goto err;
879 if (!digest_check_fips_approved(mctx, t)) {
880 t->err = "FIPS_INDICATOR_ERROR";
881 goto err;
882 }
883
884 t->err = NULL;
885
886 /* Test the EVP_Q_digest interface as well */
887 if (sk_EVP_TEST_BUFFER_num(expected->input) == 1
888 && !xof
889 /* This should never fail but we need the returned pointer now */
890 && !TEST_ptr(inbuf = sk_EVP_TEST_BUFFER_value(expected->input, 0))
891 && !inbuf->count_set) {
892 OPENSSL_cleanse(got, got_len);
893 if (!TEST_true(EVP_Q_digest(libctx,
894 EVP_MD_get0_name(expected->fetched_digest),
895 NULL, inbuf->buf, inbuf->buflen,
896 got, &size))
897 || !TEST_mem_eq(got, size,
898 expected->output, expected->output_len)) {
899 t->err = "EVP_Q_digest failed";
900 goto err;
901 }
902 }
903
904 err:
905 OPENSSL_free(got);
906 EVP_MD_CTX_free(mctx);
907 return 1;
908 }
909
910 static const EVP_TEST_METHOD digest_test_method = {
911 "Digest",
912 digest_test_init,
913 digest_test_cleanup,
914 digest_test_parse,
915 digest_test_run
916 };
917
918 /**
919 *** CIPHER TESTS
920 **/
921
922 typedef struct cipher_data_st {
923 const EVP_CIPHER *cipher;
924 EVP_CIPHER *fetched_cipher;
925 int enc;
926 /* EVP_CIPH_GCM_MODE, EVP_CIPH_CCM_MODE or EVP_CIPH_OCB_MODE if AEAD */
927 int aead;
928 unsigned char *key;
929 size_t key_len;
930 size_t key_bits; /* Used by RC2 */
931 unsigned char *iv;
932 unsigned char *next_iv; /* Expected IV state after operation */
933 unsigned int rounds;
934 size_t iv_len;
935 unsigned char *plaintext;
936 size_t plaintext_len;
937 unsigned char *ciphertext;
938 size_t ciphertext_len;
939 /* AEAD ciphers only */
940 unsigned char *aad[AAD_NUM];
941 size_t aad_len[AAD_NUM];
942 int tls_aad;
943 int tls_version;
944 unsigned char *tag;
945 const char *cts_mode;
946 size_t tag_len;
947 int tag_late;
948 unsigned char *mac_key;
949 size_t mac_key_len;
950 const char *xts_standard;
951 STACK_OF(OPENSSL_STRING) *init_controls; /* collection of controls */
952 } CIPHER_DATA;
953
954 /*
955 * XTS, SIV, CCM, stitched ciphers and Wrap modes have special
956 * requirements about input lengths so we don't fragment for those
957 */
cipher_test_valid_fragmentation(CIPHER_DATA * cdat)958 static int cipher_test_valid_fragmentation(CIPHER_DATA *cdat)
959 {
960 return (cdat->aead == EVP_CIPH_CCM_MODE
961 || cdat->aead == EVP_CIPH_CBC_MODE
962 || (cdat->aead == -1
963 && EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_STREAM_CIPHER)
964 || ((EVP_CIPHER_get_flags(cdat->cipher) & EVP_CIPH_FLAG_CTS) != 0)
965 || EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_SIV_MODE
966 || EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_GCM_SIV_MODE
967 || EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_XTS_MODE
968 || EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_WRAP_MODE)
969 ? 0
970 : 1;
971 }
972
cipher_test_init(EVP_TEST * t,const char * alg)973 static int cipher_test_init(EVP_TEST *t, const char *alg)
974 {
975 const EVP_CIPHER *cipher;
976 EVP_CIPHER *fetched_cipher;
977 CIPHER_DATA *cdat;
978 int m;
979
980 if (is_cipher_disabled(alg)) {
981 t->skip = 1;
982 TEST_info("skipping, '%s' is disabled", alg);
983 return 1;
984 }
985
986 ERR_set_mark();
987 if ((cipher = fetched_cipher = EVP_CIPHER_fetch(libctx, alg, propquery)) == NULL
988 && (cipher = EVP_get_cipherbyname(alg)) == NULL) {
989 /* a stitched cipher might not be available */
990 if (strstr(alg, "HMAC") != NULL) {
991 ERR_pop_to_mark();
992 t->skip = 1;
993 TEST_info("skipping, '%s' is not available", alg);
994 return 1;
995 }
996 ERR_clear_last_mark();
997 return 0;
998 }
999 ERR_clear_last_mark();
1000
1001 if (!TEST_ptr(cdat = OPENSSL_zalloc(sizeof(*cdat))))
1002 return 0;
1003
1004 cdat->init_controls = sk_OPENSSL_STRING_new_null();
1005 cdat->cipher = cipher;
1006 cdat->fetched_cipher = fetched_cipher;
1007 cdat->enc = -1;
1008 m = EVP_CIPHER_get_mode(cipher);
1009 if (EVP_CIPHER_get_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER)
1010 cdat->aead = m != 0 ? m : -1;
1011 else
1012 cdat->aead = 0;
1013
1014 if (data_chunk_size != 0 && !cipher_test_valid_fragmentation(cdat)) {
1015 ERR_pop_to_mark();
1016 EVP_CIPHER_free(fetched_cipher);
1017 OPENSSL_free(cdat);
1018 t->skip = 1;
1019 TEST_info("skipping, '%s' does not support fragmentation", alg);
1020 return 1;
1021 }
1022
1023 t->data = cdat;
1024 if (fetched_cipher != NULL)
1025 TEST_info("%s is fetched", alg);
1026 return 1;
1027 }
1028
cipher_test_cleanup(EVP_TEST * t)1029 static void cipher_test_cleanup(EVP_TEST *t)
1030 {
1031 int i;
1032 CIPHER_DATA *cdat = t->data;
1033
1034 OPENSSL_free(cdat->key);
1035 OPENSSL_free(cdat->iv);
1036 OPENSSL_free(cdat->next_iv);
1037 OPENSSL_free(cdat->ciphertext);
1038 OPENSSL_free(cdat->plaintext);
1039 for (i = 0; i < AAD_NUM; i++)
1040 OPENSSL_free(cdat->aad[i]);
1041 OPENSSL_free(cdat->tag);
1042 OPENSSL_free(cdat->mac_key);
1043 EVP_CIPHER_free(cdat->fetched_cipher);
1044 ctrlfree(cdat->init_controls);
1045 }
1046
cipher_test_parse(EVP_TEST * t,const char * keyword,const char * value)1047 static int cipher_test_parse(EVP_TEST *t, const char *keyword,
1048 const char *value)
1049 {
1050 CIPHER_DATA *cdat = t->data;
1051 int i;
1052
1053 if (strcmp(keyword, "Key") == 0)
1054 return parse_bin(value, &cdat->key, &cdat->key_len);
1055 if (strcmp(keyword, "Rounds") == 0) {
1056 i = atoi(value);
1057 if (i < 0)
1058 return -1;
1059 cdat->rounds = (unsigned int)i;
1060 return 1;
1061 }
1062 if (strcmp(keyword, "IV") == 0)
1063 return parse_bin(value, &cdat->iv, &cdat->iv_len);
1064 if (strcmp(keyword, "NextIV") == 0)
1065 return parse_bin(value, &cdat->next_iv, &cdat->iv_len);
1066 if (strcmp(keyword, "Plaintext") == 0)
1067 return parse_bin(value, &cdat->plaintext, &cdat->plaintext_len);
1068 if (strcmp(keyword, "Ciphertext") == 0)
1069 return parse_bin(value, &cdat->ciphertext, &cdat->ciphertext_len);
1070 if (strcmp(keyword, "KeyBits") == 0) {
1071 i = atoi(value);
1072 if (i < 0)
1073 return -1;
1074 cdat->key_bits = (size_t)i;
1075 return 1;
1076 }
1077 if (cdat->aead) {
1078 int tls_aad = 0;
1079
1080 if (strcmp(keyword, "TLSAAD") == 0)
1081 cdat->tls_aad = tls_aad = 1;
1082 if (strcmp(keyword, "AAD") == 0 || tls_aad) {
1083 for (i = 0; i < AAD_NUM; i++) {
1084 if (cdat->aad[i] == NULL)
1085 return parse_bin(value, &cdat->aad[i], &cdat->aad_len[i]);
1086 }
1087 return -1;
1088 }
1089 if (strcmp(keyword, "Tag") == 0)
1090 return parse_bin(value, &cdat->tag, &cdat->tag_len);
1091 if (strcmp(keyword, "SetTagLate") == 0) {
1092 if (strcmp(value, "TRUE") == 0)
1093 cdat->tag_late = 1;
1094 else if (strcmp(value, "FALSE") == 0)
1095 cdat->tag_late = 0;
1096 else
1097 return -1;
1098 return 1;
1099 }
1100 if (strcmp(keyword, "MACKey") == 0)
1101 return parse_bin(value, &cdat->mac_key, &cdat->mac_key_len);
1102 if (strcmp(keyword, "TLSVersion") == 0) {
1103 char *endptr;
1104
1105 cdat->tls_version = (int)strtol(value, &endptr, 0);
1106 return value[0] != '\0' && endptr[0] == '\0';
1107 }
1108 }
1109
1110 if (strcmp(keyword, "Operation") == 0) {
1111 if (strcmp(value, "ENCRYPT") == 0)
1112 cdat->enc = 1;
1113 else if (strcmp(value, "DECRYPT") == 0)
1114 cdat->enc = 0;
1115 else
1116 return -1;
1117 return 1;
1118 }
1119 if (strcmp(keyword, "CTSMode") == 0) {
1120 cdat->cts_mode = value;
1121 return 1;
1122 }
1123 if (strcmp(keyword, "XTSStandard") == 0) {
1124 cdat->xts_standard = value;
1125 return 1;
1126 }
1127 if (strcmp(keyword, "CtrlInit") == 0)
1128 return ctrladd(cdat->init_controls, value);
1129 return 0;
1130 }
1131
cipher_test_enc(EVP_TEST * t,int enc,size_t out_misalign,size_t inp_misalign,int frag,int in_place,const OSSL_PARAM initparams[],int * fips_approved)1132 static int cipher_test_enc(EVP_TEST *t, int enc, size_t out_misalign,
1133 size_t inp_misalign, int frag, int in_place,
1134 const OSSL_PARAM initparams[], int *fips_approved)
1135 {
1136 CIPHER_DATA *expected = t->data;
1137 unsigned char *in, *expected_out, *tmp = NULL;
1138 size_t in_len, out_len, donelen = 0;
1139 int ok = 0, tmplen, chunklen, tmpflen, i;
1140 EVP_CIPHER_CTX *ctx_base = NULL;
1141 EVP_CIPHER_CTX *ctx = NULL, *duped;
1142 int fips_dupctx_supported = fips_provider_version_ge(libctx, 3, 2, 0);
1143
1144 t->err = "TEST_FAILURE";
1145 if (!TEST_ptr(ctx_base = EVP_CIPHER_CTX_new()))
1146 goto err;
1147 if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new()))
1148 goto err;
1149 EVP_CIPHER_CTX_set_flags(ctx_base, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
1150 if (enc) {
1151 in = expected->plaintext;
1152 in_len = expected->plaintext_len;
1153 expected_out = expected->ciphertext;
1154 out_len = expected->ciphertext_len;
1155 } else {
1156 in = expected->ciphertext;
1157 in_len = expected->ciphertext_len;
1158 expected_out = expected->plaintext;
1159 out_len = expected->plaintext_len;
1160 }
1161 if (in_place == 1) {
1162 /* Exercise in-place encryption */
1163 tmp = OPENSSL_malloc(out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH);
1164 if (!tmp)
1165 goto err;
1166 in = memcpy(tmp + out_misalign, in, in_len);
1167 } else {
1168 inp_misalign += 16 - ((out_misalign + in_len) & 15);
1169 /*
1170 * 'tmp' will store both output and copy of input. We make the copy
1171 * of input to specifically aligned part of 'tmp'. So we just
1172 * figured out how much padding would ensure the required alignment,
1173 * now we allocate extended buffer and finally copy the input just
1174 * past inp_misalign in expression below. Output will be written
1175 * past out_misalign...
1176 */
1177 tmp = OPENSSL_malloc(out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH + inp_misalign + in_len);
1178 if (!tmp)
1179 goto err;
1180 in = memcpy(tmp + out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH + inp_misalign, in, in_len);
1181 }
1182 if (!EVP_CipherInit_ex2(ctx_base, expected->cipher, NULL, NULL, enc,
1183 initparams)) {
1184 t->err = "CIPHERINIT_ERROR";
1185 goto err;
1186 }
1187 if (expected->cts_mode != NULL) {
1188 OSSL_PARAM params[2];
1189
1190 params[0] = OSSL_PARAM_construct_utf8_string(OSSL_CIPHER_PARAM_CTS_MODE,
1191 (char *)expected->cts_mode,
1192 0);
1193 params[1] = OSSL_PARAM_construct_end();
1194 if (!EVP_CIPHER_CTX_set_params(ctx_base, params)) {
1195 t->err = "INVALID_CTS_MODE";
1196 goto err;
1197 }
1198 }
1199 if (expected->iv) {
1200 if (expected->aead) {
1201 if (EVP_CIPHER_CTX_ctrl(ctx_base, EVP_CTRL_AEAD_SET_IVLEN,
1202 expected->iv_len, 0)
1203 <= 0) {
1204 t->err = "INVALID_IV_LENGTH";
1205 goto err;
1206 }
1207 } else if (expected->iv_len != (size_t)EVP_CIPHER_CTX_get_iv_length(ctx_base)) {
1208 t->err = "INVALID_IV_LENGTH";
1209 goto err;
1210 }
1211 }
1212 if (expected->aead && !expected->tls_aad) {
1213 unsigned char *tag;
1214 /*
1215 * If encrypting or OCB just set tag length initially, otherwise
1216 * set tag length and value.
1217 */
1218 if (enc || expected->aead == EVP_CIPH_OCB_MODE || expected->tag_late) {
1219 t->err = "TAG_LENGTH_SET_ERROR";
1220 tag = NULL;
1221 } else {
1222 t->err = "TAG_SET_ERROR";
1223 tag = expected->tag;
1224 }
1225 if (tag || expected->aead != EVP_CIPH_GCM_MODE) {
1226 if (EVP_CIPHER_CTX_ctrl(ctx_base, EVP_CTRL_AEAD_SET_TAG,
1227 expected->tag_len, tag)
1228 <= 0)
1229 goto err;
1230 }
1231 }
1232
1233 if (expected->rounds > 0) {
1234 int rounds = (int)expected->rounds;
1235
1236 if (EVP_CIPHER_CTX_ctrl(ctx_base, EVP_CTRL_SET_RC5_ROUNDS, rounds, NULL) <= 0) {
1237 t->err = "INVALID_ROUNDS";
1238 goto err;
1239 }
1240 }
1241
1242 if (!EVP_CIPHER_CTX_set_key_length(ctx_base, expected->key_len)) {
1243 t->err = "INVALID_KEY_LENGTH";
1244 goto err;
1245 }
1246 if (expected->key_bits > 0) {
1247 int bits = (int)expected->key_bits;
1248
1249 if (EVP_CIPHER_CTX_ctrl(ctx_base, EVP_CTRL_SET_RC2_KEY_BITS, bits, NULL) <= 0) {
1250 t->err = "INVALID KEY BITS";
1251 goto err;
1252 }
1253 }
1254 if (!EVP_CipherInit_ex(ctx_base, NULL, NULL, expected->key, expected->iv, -1)) {
1255 t->err = "KEY_SET_ERROR";
1256 goto err;
1257 }
1258
1259 /* Check that we get the same IV back */
1260 if (expected->iv != NULL) {
1261 /* Some (e.g., GCM) tests use IVs longer than EVP_MAX_IV_LENGTH. */
1262 unsigned char iv[128];
1263 if (!TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx_base, iv, sizeof(iv)))
1264 || ((EVP_CIPHER_get_flags(expected->cipher) & EVP_CIPH_CUSTOM_IV) == 0
1265 && !TEST_mem_eq(expected->iv, expected->iv_len, iv,
1266 expected->iv_len))) {
1267 t->err = "INVALID_IV";
1268 goto err;
1269 }
1270 }
1271
1272 /* Test that the cipher dup functions correctly if it is supported */
1273 ERR_set_mark();
1274 if (!EVP_CIPHER_CTX_copy(ctx, ctx_base)) {
1275 if (fips_dupctx_supported) {
1276 TEST_info("Doing a copy of Cipher %s Fails!\n",
1277 EVP_CIPHER_get0_name(expected->cipher));
1278 ERR_print_errors_fp(stderr);
1279 goto err;
1280 } else {
1281 TEST_info("Allowing copy fail as an old fips provider is in use.");
1282 }
1283 EVP_CIPHER_CTX_free(ctx);
1284 ctx = ctx_base;
1285 } else {
1286 EVP_CIPHER_CTX_free(ctx_base);
1287 ctx_base = NULL;
1288 }
1289 /* Likewise for dup */
1290 duped = EVP_CIPHER_CTX_dup(ctx);
1291 if (duped != NULL) {
1292 EVP_CIPHER_CTX_free(ctx);
1293 ctx = duped;
1294 } else {
1295 if (fips_dupctx_supported) {
1296 TEST_info("Doing a dup of Cipher %s Fails!\n",
1297 EVP_CIPHER_get0_name(expected->cipher));
1298 ERR_print_errors_fp(stderr);
1299 goto err;
1300 } else {
1301 TEST_info("Allowing dup fail as an old fips provider is in use.");
1302 }
1303 }
1304 ERR_pop_to_mark();
1305
1306 if (expected->mac_key != NULL
1307 && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY,
1308 (int)expected->mac_key_len,
1309 (void *)expected->mac_key)
1310 <= 0) {
1311 t->err = "SET_MAC_KEY_ERROR";
1312 goto err;
1313 }
1314
1315 if (expected->tls_version) {
1316 OSSL_PARAM params[2];
1317
1318 params[0] = OSSL_PARAM_construct_int(OSSL_CIPHER_PARAM_TLS_VERSION,
1319 &expected->tls_version);
1320 params[1] = OSSL_PARAM_construct_end();
1321 if (!EVP_CIPHER_CTX_set_params(ctx, params)) {
1322 t->err = "SET_TLS_VERSION_ERROR";
1323 goto err;
1324 }
1325 }
1326
1327 if (expected->aead == EVP_CIPH_CCM_MODE) {
1328 if (!EVP_CipherUpdate(ctx, NULL, &tmplen, NULL, out_len)) {
1329 t->err = "CCM_PLAINTEXT_LENGTH_SET_ERROR";
1330 goto err;
1331 }
1332 }
1333 if (expected->aad[0] != NULL && !expected->tls_aad) {
1334 t->err = "AAD_SET_ERROR";
1335 if (!frag) {
1336 /* Supply the data all in one go or according to data_chunk_size */
1337 for (i = 0; expected->aad[i] != NULL; i++) {
1338 size_t aad_len = expected->aad_len[i];
1339 donelen = 0;
1340
1341 do {
1342 size_t current_aad_len = (size_t)data_chunk_size;
1343
1344 if (data_chunk_size == 0 || (size_t)data_chunk_size > aad_len)
1345 current_aad_len = aad_len;
1346 if (!EVP_CipherUpdate(ctx, NULL, &chunklen,
1347 expected->aad[i] + donelen,
1348 current_aad_len))
1349 goto err;
1350 donelen += current_aad_len;
1351 aad_len -= current_aad_len;
1352 } while (aad_len > 0);
1353 }
1354 } else {
1355 /* Supply the AAD in chunks less than the block size where possible */
1356 for (i = 0; expected->aad[i] != NULL; i++) {
1357 if (expected->aad_len[i] > 0) {
1358 if (!EVP_CipherUpdate(ctx, NULL, &chunklen, expected->aad[i], 1))
1359 goto err;
1360 donelen++;
1361 }
1362 if (expected->aad_len[i] > 2) {
1363 if (!EVP_CipherUpdate(ctx, NULL, &chunklen,
1364 expected->aad[i] + donelen,
1365 expected->aad_len[i] - 2))
1366 goto err;
1367 donelen += expected->aad_len[i] - 2;
1368 }
1369 if (expected->aad_len[i] > 1
1370 && !EVP_CipherUpdate(ctx, NULL, &chunklen,
1371 expected->aad[i] + donelen, 1))
1372 goto err;
1373 }
1374 }
1375 }
1376
1377 if (expected->tls_aad) {
1378 OSSL_PARAM params[2];
1379 char *tls_aad;
1380
1381 /* duplicate the aad as the implementation might modify it */
1382 if ((tls_aad = OPENSSL_memdup(expected->aad[0],
1383 expected->aad_len[0]))
1384 == NULL)
1385 goto err;
1386 params[0] = OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD,
1387 tls_aad,
1388 expected->aad_len[0]);
1389 params[1] = OSSL_PARAM_construct_end();
1390 if (!EVP_CIPHER_CTX_set_params(ctx, params)) {
1391 OPENSSL_free(tls_aad);
1392 t->err = "TLS1_AAD_ERROR";
1393 goto err;
1394 }
1395 OPENSSL_free(tls_aad);
1396 } else if (!enc && (expected->aead == EVP_CIPH_OCB_MODE || expected->tag_late)) {
1397 if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
1398 expected->tag_len, expected->tag)
1399 <= 0) {
1400 t->err = "TAG_SET_ERROR";
1401 goto err;
1402 }
1403 }
1404 if (expected->xts_standard != NULL) {
1405 OSSL_PARAM params[2];
1406
1407 params[0] = OSSL_PARAM_construct_utf8_string(OSSL_CIPHER_PARAM_XTS_STANDARD,
1408 (char *)expected->xts_standard, 0);
1409 params[1] = OSSL_PARAM_construct_end();
1410 if (!EVP_CIPHER_CTX_set_params(ctx, params)) {
1411 t->err = "SET_XTS_STANDARD_ERROR";
1412 goto err;
1413 }
1414 }
1415 EVP_CIPHER_CTX_set_padding(ctx, 0);
1416 t->err = "CIPHERUPDATE_ERROR";
1417 tmplen = 0;
1418 if (!frag) {
1419 do {
1420 /* Supply the data all in one go or according to data_chunk_size */
1421 size_t current_in_len = (size_t)data_chunk_size;
1422
1423 if (data_chunk_size == 0 || (size_t)data_chunk_size > in_len)
1424 current_in_len = in_len;
1425 if (!EVP_CipherUpdate(ctx, tmp + out_misalign + tmplen, &chunklen,
1426 in, current_in_len))
1427 goto err;
1428 tmplen += chunklen;
1429 in += current_in_len;
1430 in_len -= current_in_len;
1431 } while (in_len > 0);
1432 } else {
1433 /* Supply the data in chunks less than the block size where possible */
1434 if (in_len > 0) {
1435 if (!EVP_CipherUpdate(ctx, tmp + out_misalign, &chunklen, in, 1))
1436 goto err;
1437 tmplen += chunklen;
1438 in++;
1439 in_len--;
1440 }
1441 if (in_len > 1) {
1442 if (!EVP_CipherUpdate(ctx, tmp + out_misalign + tmplen, &chunklen,
1443 in, in_len - 1))
1444 goto err;
1445 tmplen += chunklen;
1446 in += in_len - 1;
1447 in_len = 1;
1448 }
1449 if (in_len > 0) {
1450 if (!EVP_CipherUpdate(ctx, tmp + out_misalign + tmplen, &chunklen,
1451 in, 1))
1452 goto err;
1453 tmplen += chunklen;
1454 }
1455 }
1456 if (!EVP_CipherFinal_ex(ctx, tmp + out_misalign + tmplen, &tmpflen)) {
1457 t->err = "CIPHERFINAL_ERROR";
1458 goto err;
1459 }
1460 if (!cipher_get_fips_approved(ctx, fips_approved)) {
1461 t->err = "FIPSAPPROVED_ERROR";
1462 goto err;
1463 }
1464
1465 if (!enc && expected->tls_aad) {
1466 if (expected->tls_version >= TLS1_1_VERSION
1467 && (EVP_CIPHER_is_a(expected->cipher, "AES-128-CBC-HMAC-SHA1")
1468 || EVP_CIPHER_is_a(expected->cipher, "AES-256-CBC-HMAC-SHA1"))) {
1469 tmplen -= expected->iv_len;
1470 expected_out += expected->iv_len;
1471 out_misalign += expected->iv_len;
1472 }
1473 if ((int)out_len > tmplen + tmpflen)
1474 out_len = tmplen + tmpflen;
1475 }
1476 if (!memory_err_compare(t, "VALUE_MISMATCH", expected_out, out_len,
1477 tmp + out_misalign, tmplen + tmpflen))
1478 goto err;
1479 if (enc && expected->aead && !expected->tls_aad) {
1480 unsigned char rtag[48]; /* longest known for TLS_SHA384_SHA384 */
1481
1482 if (!TEST_size_t_le(expected->tag_len, sizeof(rtag))) {
1483 t->err = "TAG_LENGTH_INTERNAL_ERROR";
1484 goto err;
1485 }
1486 if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
1487 expected->tag_len, rtag)
1488 <= 0) {
1489 t->err = "TAG_RETRIEVE_ERROR";
1490 goto err;
1491 }
1492 if (!memory_err_compare(t, "TAG_VALUE_MISMATCH",
1493 expected->tag, expected->tag_len,
1494 rtag, expected->tag_len))
1495 goto err;
1496 }
1497 /* Check the updated IV */
1498 if (expected->next_iv != NULL) {
1499 /* Some (e.g., GCM) tests use IVs longer than EVP_MAX_IV_LENGTH. */
1500 unsigned char iv[128];
1501 if (!TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, iv, sizeof(iv)))
1502 || ((EVP_CIPHER_get_flags(expected->cipher) & EVP_CIPH_CUSTOM_IV) == 0
1503 && !TEST_mem_eq(expected->next_iv, expected->iv_len, iv,
1504 expected->iv_len))) {
1505 t->err = "INVALID_NEXT_IV";
1506 goto err;
1507 }
1508 }
1509
1510 t->err = NULL;
1511 ok = 1;
1512 err:
1513 OPENSSL_free(tmp);
1514 if (ctx != ctx_base)
1515 EVP_CIPHER_CTX_free(ctx_base);
1516 EVP_CIPHER_CTX_free(ctx);
1517 return ok;
1518 }
1519
cipher_test_run(EVP_TEST * t)1520 static int cipher_test_run(EVP_TEST *t)
1521 {
1522 CIPHER_DATA *cdat = t->data;
1523 int rv = 0, frag, fragmax, in_place;
1524 int enc_approved = 0, dec_approved = 0, approved;
1525 size_t out_misalign, inp_misalign;
1526 OSSL_PARAM initparams[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
1527 size_t params_n = 0;
1528
1529 TEST_info("RUNNING TEST FOR CIPHER %s\n", EVP_CIPHER_get0_name(cdat->cipher));
1530 if (!cdat->key) {
1531 t->err = "NO_KEY";
1532 return 0;
1533 }
1534 if (!cdat->iv && EVP_CIPHER_get_iv_length(cdat->cipher) > 0) {
1535 /* IV is optional and usually omitted in wrap mode */
1536 if (EVP_CIPHER_get_mode(cdat->cipher) != EVP_CIPH_WRAP_MODE) {
1537 t->err = "NO_IV";
1538 return 0;
1539 }
1540 }
1541 if (cdat->aead && cdat->tag == NULL && !cdat->tls_aad) {
1542 t->err = "NO_TAG";
1543 return 0;
1544 }
1545
1546 if (sk_OPENSSL_STRING_num(cdat->init_controls) > 0) {
1547 if (!ctrl2params(t, cdat->init_controls, NULL,
1548 initparams, OSSL_NELEM(initparams), ¶ms_n))
1549 return 0;
1550 }
1551
1552 fragmax = (cipher_test_valid_fragmentation(cdat) == 0) ? 0 : 1;
1553 for (in_place = 1; in_place >= 0; in_place--) {
1554 static char aux_err[64];
1555
1556 t->aux_err = aux_err;
1557 /* Test only in-place data processing */
1558 if (process_mode_in_place == 1 && in_place == 0)
1559 break;
1560
1561 for (frag = 0; frag <= fragmax; frag++) {
1562 if (frag == 1 && data_chunk_size != 0)
1563 break;
1564 for (out_misalign = 0; out_misalign <= 1; out_misalign++) {
1565 for (inp_misalign = 0; inp_misalign <= 1; inp_misalign++) {
1566 /* Skip input misalign tests for in-place processing */
1567 if (inp_misalign == 1 && in_place == 1)
1568 break;
1569 if (in_place == 1) {
1570 BIO_snprintf(aux_err, sizeof(aux_err),
1571 "%s in-place, %sfragmented",
1572 out_misalign ? "misaligned" : "aligned",
1573 frag ? "" : "not ");
1574 } else {
1575 BIO_snprintf(aux_err, sizeof(aux_err),
1576 "%s output and %s input, %sfragmented",
1577 out_misalign ? "misaligned" : "aligned",
1578 inp_misalign ? "misaligned" : "aligned",
1579 frag ? "" : "not ");
1580 }
1581 if (cdat->enc) {
1582 rv = cipher_test_enc(t, 1, out_misalign, inp_misalign,
1583 frag, in_place, initparams, &enc_approved);
1584 if (rv != 1)
1585 goto end;
1586 }
1587 if (cdat->enc != 1) {
1588 rv = cipher_test_enc(t, 0, out_misalign, inp_misalign,
1589 frag, in_place, initparams, &dec_approved);
1590 if (rv != 1)
1591 goto end;
1592 }
1593 if (cdat->enc < 0) {
1594 /*
1595 * A legacy stanza tests both directions. Treat it as
1596 * unapproved if either direction is unapproved; the
1597 * explicit single-operation tests check exact results.
1598 */
1599 approved = enc_approved && dec_approved;
1600 t->expect_unapproved = !approved;
1601 } else {
1602 approved = cdat->enc ? enc_approved : dec_approved;
1603 }
1604 if (!check_fips_approved(t, approved)) {
1605 t->err = "FIPSAPPROVED_ERROR";
1606 goto end;
1607 }
1608 }
1609 }
1610 }
1611 }
1612 ctrl2params_free(initparams, params_n, 0);
1613 t->aux_err = NULL;
1614 return 1;
1615 end:
1616 ctrl2params_free(initparams, params_n, 0);
1617 return (rv < 0 ? 0 : 1);
1618 }
1619
1620 static const EVP_TEST_METHOD cipher_test_method = {
1621 "Cipher",
1622 cipher_test_init,
1623 cipher_test_cleanup,
1624 cipher_test_parse,
1625 cipher_test_run
1626 };
1627
1628 /**
1629 ** MAC TESTS
1630 **/
1631
1632 typedef struct mac_data_st {
1633 /* MAC type in one form or another */
1634 char *mac_name;
1635 EVP_MAC *mac; /* for mac_test_run_mac */
1636 int type; /* for mac_test_run_pkey */
1637 /* Algorithm string for this MAC */
1638 char *alg;
1639 /* MAC key */
1640 unsigned char *key;
1641 size_t key_len;
1642 /* MAC IV (GMAC) */
1643 unsigned char *iv;
1644 size_t iv_len;
1645 /* Input to MAC */
1646 unsigned char *input;
1647 size_t input_len;
1648 /* Expected output */
1649 unsigned char *output;
1650 size_t output_len;
1651 unsigned char *custom;
1652 size_t custom_len;
1653 /* MAC salt (blake2) */
1654 unsigned char *salt;
1655 size_t salt_len;
1656 /* XOF mode? */
1657 int xof;
1658 /* Reinitialization fails */
1659 int no_reinit;
1660 /* Collection of controls */
1661 STACK_OF(OPENSSL_STRING) *controls;
1662 STACK_OF(OPENSSL_STRING) *init_controls;
1663 /* Output size */
1664 int output_size;
1665 /* Block size */
1666 int block_size;
1667 } MAC_DATA;
1668
mac_test_init(EVP_TEST * t,const char * alg)1669 static int mac_test_init(EVP_TEST *t, const char *alg)
1670 {
1671 EVP_MAC *mac = NULL;
1672 int type = NID_undef;
1673 MAC_DATA *mdat;
1674
1675 if (is_mac_disabled(alg)) {
1676 TEST_info("skipping, '%s' is disabled", alg);
1677 t->skip = 1;
1678 return 1;
1679 }
1680 if ((mac = EVP_MAC_fetch(libctx, alg, propquery)) == NULL) {
1681 /*
1682 * Since we didn't find an EVP_MAC, we check for known EVP_PKEY methods
1683 * For debugging purposes, we allow 'NNNN by EVP_PKEY' to force running
1684 * the EVP_PKEY method.
1685 */
1686 size_t sz = strlen(alg);
1687 static const char epilogue[] = " by EVP_PKEY";
1688
1689 if (sz >= sizeof(epilogue)
1690 && strcmp(alg + sz - (sizeof(epilogue) - 1), epilogue) == 0)
1691 sz -= sizeof(epilogue) - 1;
1692
1693 if (strncmp(alg, "HMAC", sz) == 0)
1694 type = EVP_PKEY_HMAC;
1695 else if (strncmp(alg, "CMAC", sz) == 0)
1696 type = EVP_PKEY_CMAC;
1697 else if (strncmp(alg, "Poly1305", sz) == 0)
1698 type = EVP_PKEY_POLY1305;
1699 else if (strncmp(alg, "SipHash", sz) == 0)
1700 type = EVP_PKEY_SIPHASH;
1701 else
1702 return 0;
1703 }
1704
1705 #ifdef OPENSSL_NO_DEPRECATED_3_0
1706 /* The EVP_PKEY CMAC bridge requires the deprecated CMAC key constructor. */
1707 if (type == EVP_PKEY_CMAC) {
1708 TEST_info("skipping, PKEY CMAC is disabled");
1709 t->skip = 1;
1710 return 1;
1711 }
1712 #endif
1713
1714 if (!TEST_ptr(mdat = OPENSSL_zalloc(sizeof(*mdat))))
1715 return 0;
1716
1717 mdat->type = type;
1718 if (!TEST_ptr(mdat->mac_name = OPENSSL_strdup(alg))) {
1719 OPENSSL_free(mdat);
1720 return 0;
1721 }
1722
1723 mdat->mac = mac;
1724 if (!TEST_ptr(mdat->controls = sk_OPENSSL_STRING_new_null())
1725 || !TEST_ptr(mdat->init_controls = sk_OPENSSL_STRING_new_null())) {
1726 sk_OPENSSL_STRING_free(mdat->controls);
1727 OPENSSL_free(mdat->mac_name);
1728 OPENSSL_free(mdat);
1729 return 0;
1730 }
1731
1732 mdat->output_size = mdat->block_size = -1;
1733 t->data = mdat;
1734 return 1;
1735 }
1736
mac_test_cleanup(EVP_TEST * t)1737 static void mac_test_cleanup(EVP_TEST *t)
1738 {
1739 MAC_DATA *mdat = t->data;
1740
1741 EVP_MAC_free(mdat->mac);
1742 OPENSSL_free(mdat->mac_name);
1743 sk_OPENSSL_STRING_pop_free(mdat->controls, openssl_free);
1744 sk_OPENSSL_STRING_pop_free(mdat->init_controls, openssl_free);
1745 OPENSSL_free(mdat->alg);
1746 OPENSSL_free(mdat->key);
1747 OPENSSL_free(mdat->iv);
1748 OPENSSL_free(mdat->custom);
1749 OPENSSL_free(mdat->salt);
1750 OPENSSL_free(mdat->input);
1751 OPENSSL_free(mdat->output);
1752 }
1753
mac_test_parse(EVP_TEST * t,const char * keyword,const char * value)1754 static int mac_test_parse(EVP_TEST *t,
1755 const char *keyword, const char *value)
1756 {
1757 MAC_DATA *mdata = t->data;
1758
1759 if (strcmp(keyword, "Key") == 0)
1760 return parse_bin(value, &mdata->key, &mdata->key_len);
1761 if (strcmp(keyword, "IV") == 0)
1762 return parse_bin(value, &mdata->iv, &mdata->iv_len);
1763 if (strcmp(keyword, "Custom") == 0)
1764 return parse_bin(value, &mdata->custom, &mdata->custom_len);
1765 if (strcmp(keyword, "Salt") == 0)
1766 return parse_bin(value, &mdata->salt, &mdata->salt_len);
1767 if (strcmp(keyword, "Algorithm") == 0) {
1768 mdata->alg = OPENSSL_strdup(value);
1769 if (mdata->alg == NULL)
1770 return -1;
1771 return 1;
1772 }
1773 if (strcmp(keyword, "Input") == 0)
1774 return parse_bin(value, &mdata->input, &mdata->input_len);
1775 if (strcmp(keyword, "Output") == 0)
1776 return parse_bin(value, &mdata->output, &mdata->output_len);
1777 if (strcmp(keyword, "XOF") == 0)
1778 return mdata->xof = 1;
1779 if (strcmp(keyword, "NoReinit") == 0)
1780 return mdata->no_reinit = 1;
1781 if (strcmp(keyword, "Ctrl") == 0)
1782 return ctrladd(mdata->controls, value);
1783 if (strcmp(keyword, "CtrlInit") == 0)
1784 return ctrladd(mdata->init_controls, value);
1785 if (strcmp(keyword, "OutputSize") == 0) {
1786 mdata->output_size = atoi(value);
1787 if (mdata->output_size < 0)
1788 return -1;
1789 return 1;
1790 }
1791 if (strcmp(keyword, "BlockSize") == 0) {
1792 mdata->block_size = atoi(value);
1793 if (mdata->block_size < 0)
1794 return -1;
1795 return 1;
1796 }
1797 return 0;
1798 }
1799
mac_test_ctrl_pkey(EVP_TEST * t,EVP_PKEY_CTX * pctx,const char * value)1800 static int mac_test_ctrl_pkey(EVP_TEST *t, EVP_PKEY_CTX *pctx,
1801 const char *value)
1802 {
1803 int rv = 0;
1804 char *p, *tmpval;
1805
1806 if (!TEST_ptr(tmpval = OPENSSL_strdup(value)))
1807 return 0;
1808 p = strchr(tmpval, ':');
1809 if (p != NULL) {
1810 *p++ = '\0';
1811 rv = EVP_PKEY_CTX_ctrl_str(pctx, tmpval, p);
1812 }
1813 if (rv == -2)
1814 t->err = "PKEY_CTRL_INVALID";
1815 else if (rv <= 0)
1816 t->err = "PKEY_CTRL_ERROR";
1817 else
1818 rv = 1;
1819 OPENSSL_free(tmpval);
1820 return rv > 0;
1821 }
1822
mac_test_run_pkey(EVP_TEST * t)1823 static int mac_test_run_pkey(EVP_TEST *t)
1824 {
1825 MAC_DATA *expected = t->data;
1826 EVP_MD_CTX *mctx = NULL;
1827 EVP_PKEY_CTX *pctx = NULL, *genctx = NULL;
1828 EVP_PKEY *key = NULL;
1829 const char *mdname = NULL;
1830 EVP_CIPHER *cipher = NULL;
1831 unsigned char *got = NULL;
1832 size_t got_len;
1833 int i;
1834 size_t input_len, donelen;
1835 OSSL_PARAM params[5];
1836 OSSL_PARAM *p = NULL;
1837 size_t params_n = 0;
1838
1839 /* We don't do XOF mode via PKEY */
1840 if (expected->xof)
1841 return 1;
1842
1843 if (expected->alg == NULL)
1844 TEST_info("Trying the EVP_PKEY %s test", OBJ_nid2sn(expected->type));
1845 else
1846 TEST_info("Trying the EVP_PKEY %s test with %s",
1847 OBJ_nid2sn(expected->type), expected->alg);
1848
1849 if (expected->type == EVP_PKEY_CMAC) {
1850 #ifdef OPENSSL_NO_DEPRECATED_3_0
1851 TEST_info("skipping, PKEY CMAC '%s' is disabled", expected->alg);
1852 t->skip = 1;
1853 t->err = NULL;
1854 goto err;
1855 #else
1856 OSSL_LIB_CTX *tmpctx;
1857
1858 if (expected->alg != NULL && is_cipher_disabled(expected->alg)) {
1859 TEST_info("skipping, PKEY CMAC '%s' is disabled", expected->alg);
1860 t->skip = 1;
1861 t->err = NULL;
1862 goto err;
1863 }
1864 if (!TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, expected->alg, propquery))) {
1865 t->err = "MAC_KEY_CREATE_ERROR";
1866 goto err;
1867 }
1868 tmpctx = OSSL_LIB_CTX_set0_default(libctx);
1869 key = EVP_PKEY_new_CMAC_key(NULL, expected->key, expected->key_len,
1870 cipher);
1871 OSSL_LIB_CTX_set0_default(tmpctx);
1872 #endif
1873 } else {
1874 key = EVP_PKEY_new_raw_private_key_ex(libctx,
1875 OBJ_nid2sn(expected->type), NULL,
1876 expected->key, expected->key_len);
1877 }
1878 if (key == NULL) {
1879 t->err = "MAC_KEY_CREATE_ERROR";
1880 goto err;
1881 }
1882
1883 if (expected->type == EVP_PKEY_HMAC && expected->alg != NULL) {
1884 if (is_digest_disabled(expected->alg)) {
1885 TEST_info("skipping, HMAC '%s' is disabled", expected->alg);
1886 t->skip = 1;
1887 t->err = NULL;
1888 goto err;
1889 }
1890 mdname = expected->alg;
1891 }
1892 if (!TEST_ptr(mctx = EVP_MD_CTX_new())) {
1893 t->err = "INTERNAL_ERROR";
1894 goto err;
1895 }
1896 if (sk_OPENSSL_STRING_num(expected->init_controls) > 0) {
1897 if (!ctrl2params(t, expected->init_controls, NULL,
1898 params, OSSL_NELEM(params), ¶ms_n))
1899 goto err;
1900 p = params;
1901 }
1902 if (!EVP_DigestSignInit_ex(mctx, &pctx, mdname, libctx, NULL, key, p)) {
1903 t->err = "DIGESTSIGNINIT_ERROR";
1904 goto err;
1905 }
1906 for (i = 0; i < sk_OPENSSL_STRING_num(expected->controls); i++)
1907 if (!mac_test_ctrl_pkey(t, pctx,
1908 sk_OPENSSL_STRING_value(expected->controls,
1909 i))) {
1910 t->err = "EVPPKEYCTXCTRL_ERROR";
1911 goto err;
1912 }
1913 input_len = expected->input_len;
1914 donelen = 0;
1915 do {
1916 size_t current_len = (size_t)data_chunk_size;
1917
1918 if (data_chunk_size == 0 || (size_t)data_chunk_size > input_len)
1919 current_len = input_len;
1920 if (!EVP_DigestSignUpdate(mctx, expected->input + donelen, current_len)) {
1921 t->err = "DIGESTSIGNUPDATE_ERROR";
1922 goto err;
1923 }
1924 donelen += current_len;
1925 input_len -= current_len;
1926 } while (input_len > 0);
1927
1928 if (!EVP_DigestSignFinal(mctx, NULL, &got_len)) {
1929 t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";
1930 goto err;
1931 }
1932 if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
1933 t->err = "TEST_FAILURE";
1934 goto err;
1935 }
1936 if (!EVP_DigestSignFinal(mctx, got, &got_len)
1937 || !memory_err_compare(t, "TEST_MAC_ERR",
1938 expected->output, expected->output_len,
1939 got, got_len)) {
1940 t->err = "TEST_MAC_ERR";
1941 goto err;
1942 }
1943 if (!pkey_check_fips_approved(pctx, t)) {
1944 t->err = "FIPS_INDICATOR_ERROR";
1945 goto err;
1946 }
1947 t->err = NULL;
1948 err:
1949 ctrl2params_free(params, params_n, 0);
1950 EVP_CIPHER_free(cipher);
1951 EVP_MD_CTX_free(mctx);
1952 OPENSSL_free(got);
1953 EVP_PKEY_CTX_free(genctx);
1954 EVP_PKEY_free(key);
1955 return 1;
1956 }
1957
mac_test_run_mac(EVP_TEST * t)1958 static int mac_test_run_mac(EVP_TEST *t)
1959 {
1960 MAC_DATA *expected = t->data;
1961 EVP_MAC_CTX *ctx = NULL;
1962 unsigned char *got = NULL;
1963 size_t got_len = 0, size = 0;
1964 size_t size_before_init = 0, size_after_init, size_val = 0;
1965 int block_size = -1, output_size = -1;
1966 OSSL_PARAM params[21], sizes[3], *psizes = sizes, *p;
1967 size_t params_n = 0;
1968 size_t params_n_allocstart = 0;
1969 const OSSL_PARAM *defined_params = EVP_MAC_settable_ctx_params(expected->mac);
1970 int xof;
1971 int reinit = 1;
1972 size_t input_len, donelen;
1973
1974 if (expected->alg == NULL)
1975 TEST_info("Trying the EVP_MAC %s test", expected->mac_name);
1976 else
1977 TEST_info("Trying the EVP_MAC %s test with %s",
1978 expected->mac_name, expected->alg);
1979
1980 if (expected->alg != NULL) {
1981 int skip = 0;
1982
1983 /*
1984 * The underlying algorithm may be a cipher or a digest.
1985 * We don't know which it is, but we can ask the MAC what it
1986 * should be and bet on that.
1987 */
1988 if (OSSL_PARAM_locate_const(defined_params,
1989 OSSL_MAC_PARAM_CIPHER)
1990 != NULL) {
1991 if (is_cipher_disabled(expected->alg))
1992 skip = 1;
1993 else
1994 params[params_n++] = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_CIPHER,
1995 expected->alg, 0);
1996 } else if (OSSL_PARAM_locate_const(defined_params,
1997 OSSL_MAC_PARAM_DIGEST)
1998 != NULL) {
1999 if (is_digest_disabled(expected->alg))
2000 skip = 1;
2001 else
2002 params[params_n++] = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
2003 expected->alg, 0);
2004 } else {
2005 t->err = "MAC_BAD_PARAMS";
2006 goto err;
2007 }
2008 if (skip) {
2009 TEST_info("skipping, algorithm '%s' is disabled", expected->alg);
2010 t->skip = 1;
2011 t->err = NULL;
2012 goto err;
2013 }
2014 }
2015 if (expected->custom != NULL)
2016 params[params_n++] = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_CUSTOM,
2017 expected->custom,
2018 expected->custom_len);
2019 if (expected->salt != NULL)
2020 params[params_n++] = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_SALT,
2021 expected->salt,
2022 expected->salt_len);
2023 if (expected->iv != NULL)
2024 params[params_n++] = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_IV,
2025 expected->iv,
2026 expected->iv_len);
2027
2028 params_n_allocstart = params_n;
2029 if (!ctrl2params(t, expected->controls, defined_params,
2030 params, OSSL_NELEM(params), ¶ms_n))
2031 goto err;
2032
2033 p = OSSL_PARAM_locate(params + params_n_allocstart, "size");
2034 if (p != NULL) {
2035 if (!OSSL_PARAM_get_size_t(p, &size_val))
2036 goto err;
2037 }
2038
2039 if ((ctx = EVP_MAC_CTX_new(expected->mac)) == NULL) {
2040 t->err = "MAC_CREATE_ERROR";
2041 goto err;
2042 }
2043 if (fips_provider_version_gt(libctx, 3, 2, 0)) {
2044 /* HMAC will put an error on the stack here (digest is not set yet) */
2045 ERR_set_mark();
2046 size_before_init = EVP_MAC_CTX_get_mac_size(ctx);
2047 ERR_pop_to_mark();
2048 }
2049 if (!EVP_MAC_init(ctx, expected->key, expected->key_len, params)) {
2050 t->err = "MAC_INIT_ERROR";
2051 goto err;
2052 }
2053 size_after_init = EVP_MAC_CTX_get_mac_size(ctx);
2054 if (!TEST_false(size_before_init == 0 && size_after_init == 0)) {
2055 t->err = "MAC SIZE not set";
2056 goto err;
2057 }
2058 if (size_before_init != 0) {
2059 /* mac-size not modified by init params */
2060 if (size_val == 0 && !TEST_size_t_eq(size_before_init, size_after_init)) {
2061 t->err = "MAC SIZE check failed";
2062 goto err;
2063 }
2064 /* mac-size modified by init params */
2065 if (size_val != 0 && !TEST_size_t_eq(size_val, size_after_init)) {
2066 t->err = "MAC SIZE check failed";
2067 goto err;
2068 }
2069 }
2070 if (expected->output_size >= 0)
2071 *psizes++ = OSSL_PARAM_construct_int(OSSL_MAC_PARAM_SIZE,
2072 &output_size);
2073 if (expected->block_size >= 0)
2074 *psizes++ = OSSL_PARAM_construct_int(OSSL_MAC_PARAM_BLOCK_SIZE,
2075 &block_size);
2076 if (psizes != sizes) {
2077 *psizes = OSSL_PARAM_construct_end();
2078 if (!TEST_true(EVP_MAC_CTX_get_params(ctx, sizes))) {
2079 t->err = "INTERNAL_ERROR";
2080 goto err;
2081 }
2082 if (expected->output_size >= 0
2083 && !TEST_int_eq(output_size, expected->output_size)) {
2084 t->err = "TEST_FAILURE";
2085 goto err;
2086 }
2087 if (expected->block_size >= 0
2088 && !TEST_int_eq(block_size, expected->block_size)) {
2089 t->err = "TEST_FAILURE";
2090 goto err;
2091 }
2092 }
2093 retry:
2094 input_len = expected->input_len;
2095 donelen = 0;
2096 do {
2097 size_t current_len = (size_t)data_chunk_size;
2098
2099 if (data_chunk_size == 0 || (size_t)data_chunk_size > input_len)
2100 current_len = input_len;
2101 if (!EVP_MAC_update(ctx, expected->input + donelen, current_len)) {
2102 t->err = "MAC_UPDATE_ERROR";
2103 goto err;
2104 }
2105 donelen += current_len;
2106 input_len -= current_len;
2107 } while (input_len > 0);
2108
2109 xof = expected->xof;
2110 if (xof) {
2111 if (!TEST_ptr(got = OPENSSL_malloc(expected->output_len))) {
2112 t->err = "TEST_FAILURE";
2113 goto err;
2114 }
2115 if (!EVP_MAC_finalXOF(ctx, got, expected->output_len)
2116 || !memory_err_compare(t, "TEST_MAC_ERR",
2117 expected->output, expected->output_len,
2118 got, expected->output_len)) {
2119 t->err = "MAC_FINAL_ERROR";
2120 goto err;
2121 }
2122 } else {
2123 if (!EVP_MAC_final(ctx, NULL, &got_len, 0)) {
2124 t->err = "MAC_FINAL_LENGTH_ERROR";
2125 goto err;
2126 }
2127 if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
2128 t->err = "TEST_FAILURE";
2129 goto err;
2130 }
2131 if (!EVP_MAC_final(ctx, got, &got_len, got_len)
2132 || !memory_err_compare(t, "TEST_MAC_ERR",
2133 expected->output, expected->output_len,
2134 got, got_len)) {
2135 t->err = "TEST_MAC_ERR";
2136 goto err;
2137 }
2138 if (!mac_check_fips_approved(ctx, t))
2139 goto err;
2140 }
2141 /* FIPS(3.0.0): can't reinitialise MAC contexts #18100 */
2142 if (reinit-- && fips_provider_version_gt(libctx, 3, 0, 0)) {
2143 OSSL_PARAM ivparams[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
2144 int ret;
2145
2146 /* If the MAC uses IV, we have to set it again */
2147 if (expected->iv != NULL) {
2148 ivparams[0] = OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_IV,
2149 expected->iv,
2150 expected->iv_len);
2151 ivparams[1] = OSSL_PARAM_construct_end();
2152 }
2153 ERR_set_mark();
2154 ret = EVP_MAC_init(ctx, NULL, 0, ivparams);
2155 if (expected->no_reinit) {
2156 if (ret) {
2157 ERR_clear_last_mark();
2158 t->err = "MAC_REINIT_SHOULD_FAIL";
2159 goto err;
2160 }
2161 } else if (ret) {
2162 ERR_clear_last_mark();
2163 OPENSSL_free(got);
2164 got = NULL;
2165 goto retry;
2166 } else {
2167 ERR_clear_last_mark();
2168 t->err = "MAC_REINIT_ERROR";
2169 goto err;
2170 }
2171 /* If reinitialization fails, it is unsupported by the algorithm */
2172 ERR_pop_to_mark();
2173 }
2174 t->err = NULL;
2175
2176 /* Test the EVP_Q_mac interface as well */
2177 if (!xof) {
2178 OPENSSL_cleanse(got, got_len);
2179 if (!TEST_true(EVP_Q_mac(libctx, expected->mac_name, NULL,
2180 expected->alg, params,
2181 expected->key, expected->key_len,
2182 expected->input, expected->input_len,
2183 got, got_len, &size))
2184 || !TEST_mem_eq(got, size,
2185 expected->output, expected->output_len)) {
2186 t->err = "EVP_Q_mac failed";
2187 goto err;
2188 }
2189 }
2190 err:
2191 ctrl2params_free(params, params_n, params_n_allocstart);
2192 EVP_MAC_CTX_free(ctx);
2193 OPENSSL_free(got);
2194 return 1;
2195 }
2196
mac_test_run(EVP_TEST * t)2197 static int mac_test_run(EVP_TEST *t)
2198 {
2199 MAC_DATA *expected = t->data;
2200
2201 if (expected->mac != NULL)
2202 return mac_test_run_mac(t);
2203 return mac_test_run_pkey(t);
2204 }
2205
2206 static const EVP_TEST_METHOD mac_test_method = {
2207 "MAC",
2208 mac_test_init,
2209 mac_test_cleanup,
2210 mac_test_parse,
2211 mac_test_run
2212 };
2213
2214 typedef struct kem_data_st {
2215 /* Context for this operation */
2216 EVP_PKEY_CTX *ctx;
2217 const char *op;
2218 /* Input to decapsulate */
2219 unsigned char *input;
2220 size_t inputlen;
2221 /* Expected secret */
2222 unsigned char *output;
2223 size_t outputlen;
2224 STACK_OF(OPENSSL_STRING) *init_ctrls;
2225 /* Algorithm name */
2226 char *algname;
2227 /* Name of previously generated key */
2228 char *keyname;
2229 /* Encoded public key */
2230 unsigned char *encoded_pub_key;
2231 size_t encoded_pub_key_len;
2232 /* Encoded private key */
2233 unsigned char *encoded_priv_key;
2234 size_t encoded_priv_key_len;
2235 /* Entropy for encapsulation */
2236 unsigned char *entropy;
2237 size_t entropylen;
2238 /* Ciphertext */
2239 unsigned char *ciphertext;
2240 size_t ciphertext_len;
2241 } KEM_DATA;
2242
kem_test_init(EVP_TEST * t,const char * alg)2243 static int kem_test_init(EVP_TEST *t, const char *alg)
2244 {
2245 KEM_DATA *kdata = NULL;
2246 EVP_PKEY *pkey = NULL;
2247
2248 if (!TEST_ptr(kdata = OPENSSL_zalloc(sizeof(*kdata)))
2249 || !TEST_ptr(kdata->algname = OPENSSL_strdup(alg)))
2250 goto err;
2251
2252 kdata->init_ctrls = sk_OPENSSL_STRING_new_null();
2253 t->data = kdata;
2254 return 1;
2255 err:
2256 EVP_PKEY_free(pkey);
2257 OPENSSL_free(kdata);
2258 return 0;
2259 }
2260
kem_test_cleanup(EVP_TEST * t)2261 static void kem_test_cleanup(EVP_TEST *t)
2262 {
2263 KEM_DATA *kdata = t->data;
2264
2265 ctrlfree(kdata->init_ctrls);
2266 OPENSSL_free(kdata->input);
2267 OPENSSL_free(kdata->output);
2268 OPENSSL_free(kdata->algname);
2269 OPENSSL_free(kdata->keyname);
2270 OPENSSL_free(kdata->encoded_pub_key);
2271 OPENSSL_free(kdata->encoded_priv_key);
2272 OPENSSL_free(kdata->entropy);
2273 OPENSSL_free(kdata->ciphertext);
2274 EVP_PKEY_CTX_free(kdata->ctx);
2275 }
2276
kem_test_parse(EVP_TEST * t,const char * keyword,const char * value)2277 static int kem_test_parse(EVP_TEST *t, const char *keyword, const char *value)
2278 {
2279 KEM_DATA *kdata = t->data;
2280
2281 if (strcmp(keyword, "Op") == 0) {
2282 kdata->op = value;
2283 return 1;
2284 }
2285 if (strcmp(keyword, "CtrlInit") == 0)
2286 return ctrladd(kdata->init_ctrls, value);
2287 if (strcmp(keyword, "Input") == 0)
2288 return parse_bin(value, &kdata->input, &kdata->inputlen);
2289 if (strcmp(keyword, "Output") == 0)
2290 return parse_bin(value, &kdata->output, &kdata->outputlen);
2291 if (strcmp(keyword, "EncodedPublicKey") == 0)
2292 return parse_bin(value, &kdata->encoded_pub_key,
2293 &kdata->encoded_pub_key_len);
2294 if (strcmp(keyword, "EncodedPrivateKey") == 0)
2295 return parse_bin(value, &kdata->encoded_priv_key,
2296 &kdata->encoded_priv_key_len);
2297 if (strcmp(keyword, "Entropy") == 0)
2298 return parse_bin(value, &kdata->entropy, &kdata->entropylen);
2299 if (strcmp(keyword, "Ciphertext") == 0)
2300 return parse_bin(value, &kdata->ciphertext, &kdata->ciphertext_len);
2301 if (strcmp(keyword, "KeyName") == 0)
2302 return TEST_ptr(kdata->keyname = OPENSSL_strdup(value));
2303 return 1;
2304 }
2305
encapsulate(EVP_TEST * t,EVP_PKEY_CTX * ctx,const char * op,unsigned char ** outwrapped,size_t * outwrappedlen,unsigned char ** outsecret,size_t * outsecretlen)2306 static int encapsulate(EVP_TEST *t, EVP_PKEY_CTX *ctx, const char *op,
2307 unsigned char **outwrapped, size_t *outwrappedlen,
2308 unsigned char **outsecret, size_t *outsecretlen)
2309 {
2310 int ret = 0;
2311 KEM_DATA *kdata = t->data;
2312 unsigned char *wrapped = NULL, *secret = NULL;
2313 size_t wrappedlen = 0, secretlen = 0;
2314 OSSL_PARAM params[10];
2315 size_t params_n = 0;
2316 /* Reserve space for the terminator and possibly IKME */
2317 const size_t params_max = OSSL_NELEM(params) - 1 - (kdata->entropy != NULL);
2318
2319 if (sk_OPENSSL_STRING_num(kdata->init_ctrls) > 0)
2320 if (!ctrl2params(t, kdata->init_ctrls, NULL, params, params_max,
2321 ¶ms_n))
2322 goto err;
2323
2324 /* We don't expect very many controls here */
2325 if (!TEST_size_t_lt(params_n, params_max))
2326 goto err;
2327
2328 if (kdata->entropy != NULL)
2329 /* Input key material a.k.a entropy */
2330 params[params_n++] = OSSL_PARAM_construct_octet_string(OSSL_KEM_PARAM_IKME,
2331 kdata->entropy,
2332 kdata->entropylen);
2333 params[params_n] = OSSL_PARAM_construct_end();
2334
2335 if (EVP_PKEY_encapsulate_init(ctx, params) <= 0) {
2336 t->err = "TEST_ENCAPSULATE_INIT_ERROR";
2337 goto ok;
2338 }
2339
2340 if (op != NULL && EVP_PKEY_CTX_set_kem_op(ctx, op) <= 0) {
2341 t->err = "TEST_SET_KEM_OP_ERROR";
2342 goto ok;
2343 }
2344 if (EVP_PKEY_encapsulate(ctx, NULL, &wrappedlen, NULL, &secretlen) <= 0) {
2345 t->err = "TEST_ENCAPSULATE_LEN_ERROR";
2346 goto ok;
2347 }
2348 wrapped = OPENSSL_malloc(wrappedlen);
2349 secret = OPENSSL_malloc(secretlen);
2350 if (!TEST_ptr(wrapped) || !TEST_ptr(secret)) {
2351 ret = 0;
2352 goto err;
2353 }
2354 if (EVP_PKEY_encapsulate(ctx, wrapped, &wrappedlen, secret, &secretlen) <= 0) {
2355 t->err = "TEST_ENCAPSULATE_ERROR";
2356 goto ok;
2357 }
2358 ret = pkey_check_fips_approved(ctx, t);
2359
2360 if (kdata->ciphertext != NULL
2361 && !TEST_mem_eq(wrapped, wrappedlen, kdata->ciphertext, kdata->ciphertext_len)) {
2362 ret = 0;
2363 goto err;
2364 }
2365
2366 if (kdata->output != NULL
2367 && !TEST_mem_eq(secret, secretlen, kdata->output, kdata->outputlen)) {
2368 ret = 0;
2369 goto err;
2370 }
2371
2372 if (ret == 0)
2373 goto err;
2374
2375 t->err = NULL;
2376 *outwrapped = wrapped;
2377 *outsecret = secret;
2378 *outwrappedlen = wrappedlen;
2379 *outsecretlen = secretlen;
2380 ok:
2381 ret = 1;
2382 err:
2383 if (ret == 0) {
2384 OPENSSL_free(wrapped);
2385 OPENSSL_free(secret);
2386 }
2387 if (sk_OPENSSL_STRING_num(kdata->init_ctrls) > 0)
2388 ctrl2params_free(params, params_n, 0);
2389 return ret;
2390 }
2391
decapsulate(EVP_TEST * t,EVP_PKEY_CTX * ctx,const char * op,const unsigned char * in,size_t inlen,const unsigned char * expected,size_t expectedlen)2392 static int decapsulate(EVP_TEST *t, EVP_PKEY_CTX *ctx, const char *op,
2393 const unsigned char *in, size_t inlen,
2394 const unsigned char *expected, size_t expectedlen)
2395 {
2396 int ret = 0;
2397 KEM_DATA *kdata = t->data;
2398 size_t outlen = 0;
2399 unsigned char *out = NULL;
2400 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
2401 OSSL_PARAM *p = NULL;
2402 size_t params_n = 0, params_n_allocated = 0;
2403
2404 if (sk_OPENSSL_STRING_num(kdata->init_ctrls) > 0) {
2405 if (!ctrl2params(t, kdata->init_ctrls, NULL,
2406 params, 2, ¶ms_n))
2407 goto err;
2408 p = params;
2409 }
2410
2411 if (EVP_PKEY_decapsulate_init(ctx, p) <= 0) {
2412 t->err = "TEST_DECAPSULATE_INIT_ERROR";
2413 goto ok;
2414 }
2415
2416 if (op != NULL && EVP_PKEY_CTX_set_kem_op(ctx, op) <= 0) {
2417 t->err = "TEST_SET_KEM_OP_ERROR";
2418 goto ok;
2419 }
2420 if (EVP_PKEY_decapsulate(ctx, NULL, &outlen, in, inlen) <= 0) {
2421 t->err = "TEST_DECAPSULATE_LEN_ERROR";
2422 goto ok;
2423 }
2424 if (!TEST_ptr(out = OPENSSL_malloc(outlen))) {
2425 ret = 0;
2426 goto err;
2427 }
2428
2429 if (EVP_PKEY_decapsulate(ctx, out, &outlen, in, inlen) <= 0) {
2430 t->err = "TEST_DECAPSULATE_ERROR";
2431 goto err;
2432 }
2433 if (!pkey_check_fips_approved(ctx, t))
2434 goto err;
2435 if (!TEST_mem_eq(out, outlen, expected, expectedlen)) {
2436 t->err = "TEST_SECRET_MISMATCH";
2437 goto ok;
2438 }
2439 t->err = NULL;
2440 ok:
2441 ret = 1;
2442 err:
2443 OPENSSL_free(out);
2444 if (sk_OPENSSL_STRING_num(kdata->init_ctrls) > 0)
2445 ctrl2params_free(params, params_n, params_n_allocated);
2446 return ret;
2447 }
2448
kem_test_run(EVP_TEST * t)2449 static int kem_test_run(EVP_TEST *t)
2450 {
2451 int ret = 0, found_key = 0;
2452 EVP_PKEY *pkey = NULL;
2453 KEM_DATA *kdata = t->data;
2454 unsigned char *wrapped = NULL, *secret = NULL;
2455
2456 /* Generate either public or private key based on given params */
2457 if (kdata->keyname != NULL) {
2458 /* Previously generated private key */
2459 found_key = find_key(&pkey, kdata->keyname, private_keys);
2460 if (found_key == 0 || pkey == NULL) {
2461 TEST_info("skipping, key '%s' is disabled", kdata->keyname);
2462 t->skip = 1;
2463 goto ok;
2464 }
2465 } else if (kdata->encoded_pub_key != NULL) {
2466 /* Encoded public key */
2467 if ((pkey = EVP_PKEY_new_raw_public_key_ex(libctx, kdata->algname,
2468 propquery,
2469 kdata->encoded_pub_key,
2470 kdata->encoded_pub_key_len))
2471 == NULL) {
2472 t->err = "TEST_PARSE_PUBLIC_KEY_ERROR";
2473 goto ok;
2474 }
2475 } else if (kdata->encoded_priv_key != NULL) {
2476 /* Encoded private key */
2477 if ((pkey = EVP_PKEY_new_raw_private_key_ex(libctx, kdata->algname,
2478 propquery,
2479 kdata->encoded_priv_key,
2480 kdata->encoded_priv_key_len))
2481 == NULL) {
2482 t->err = "TEST_PARSE_PRIVATE_KEY_ERROR";
2483 goto ok;
2484 }
2485 } else {
2486 TEST_info("Missing parameters to create key");
2487 goto err;
2488 }
2489
2490 if (!TEST_ptr(kdata->ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, propquery)))
2491 goto err;
2492
2493 if (kdata->input == NULL) {
2494 size_t wrappedlen = 0, secretlen = 0;
2495
2496 ret = encapsulate(t, kdata->ctx, kdata->op, &wrapped, &wrappedlen,
2497 &secret, &secretlen);
2498 if (ret == 0 || t->err != NULL)
2499 goto err;
2500
2501 /* Also attempt to decrypt if we have the private key */
2502 if (found_key || kdata->encoded_priv_key != NULL)
2503 ret = decapsulate(t, kdata->ctx, kdata->op, wrapped, wrappedlen,
2504 secret, secretlen);
2505 } else {
2506 ret = decapsulate(t, kdata->ctx, kdata->op, kdata->input, kdata->inputlen,
2507 kdata->output, kdata->outputlen);
2508 }
2509
2510 ok:
2511 ret = 1;
2512 err:
2513 if (!found_key)
2514 EVP_PKEY_free(pkey);
2515 OPENSSL_free(wrapped);
2516 OPENSSL_free(secret);
2517 return ret;
2518 }
2519
2520 static const EVP_TEST_METHOD pkey_kem_test_method = {
2521 "Kem",
2522 kem_test_init,
2523 kem_test_cleanup,
2524 kem_test_parse,
2525 kem_test_run
2526 };
2527
2528 /**
2529 ** PUBLIC KEY TESTS
2530 ** These are all very similar and share much common code.
2531 **/
2532
2533 typedef struct pkey_data_st {
2534 /* Context for this operation */
2535 EVP_PKEY_CTX *ctx;
2536 /* Signature algo for such operations */
2537 EVP_SIGNATURE *sigalgo;
2538 /* Key operation to perform */
2539 int (*keyopinit)(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
2540 int (*keyopinit_ex2)(EVP_PKEY_CTX *ctx, EVP_SIGNATURE *algo,
2541 const OSSL_PARAM params[]);
2542 int (*keyop)(EVP_PKEY_CTX *ctx,
2543 unsigned char *sig, size_t *siglen,
2544 const unsigned char *tbs, size_t tbslen);
2545 /* Input to MAC */
2546 unsigned char *input;
2547 size_t input_len;
2548 /* Expected output */
2549 unsigned char *output;
2550 size_t output_len;
2551 STACK_OF(OPENSSL_STRING) *init_controls; /* collection of controls */
2552 STACK_OF(OPENSSL_STRING) *controls; /* collection of controls */
2553 EVP_PKEY *peer;
2554 int validate;
2555 } PKEY_DATA;
2556
2557 /*
2558 * Perform public key operation setup: lookup key, allocated ctx and call
2559 * the appropriate initialisation function
2560 */
pkey_test_init_keyctx(EVP_TEST * t,const char * keyname,int use_public)2561 static int pkey_test_init_keyctx(EVP_TEST *t, const char *keyname,
2562 int use_public)
2563 {
2564 PKEY_DATA *kdata;
2565 EVP_PKEY *pkey = NULL;
2566 int rv = 0;
2567
2568 if (use_public)
2569 rv = find_key(&pkey, keyname, public_keys);
2570 if (rv == 0)
2571 rv = find_key(&pkey, keyname, private_keys);
2572 if (rv == 0 || pkey == NULL) {
2573 TEST_info("skipping, key '%s' is disabled", keyname);
2574 t->skip = 1;
2575 return 1;
2576 }
2577
2578 if (!TEST_ptr(kdata = OPENSSL_zalloc(sizeof(*kdata)))) {
2579 EVP_PKEY_free(pkey);
2580 return 0;
2581 }
2582 if (!TEST_ptr(kdata->ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, propquery))) {
2583 EVP_PKEY_free(pkey);
2584 OPENSSL_free(kdata);
2585 return 0;
2586 }
2587 t->data = kdata;
2588 return 1;
2589 }
2590
pkey_test_init(EVP_TEST * t,const char * name,int use_public,int (* keyopinit)(EVP_PKEY_CTX * ctx,const OSSL_PARAM params[]),int (* keyop)(EVP_PKEY_CTX * ctx,unsigned char * sig,size_t * siglen,const unsigned char * tbs,size_t tbslen))2591 static int pkey_test_init(EVP_TEST *t, const char *name,
2592 int use_public,
2593 int (*keyopinit)(EVP_PKEY_CTX *ctx,
2594 const OSSL_PARAM params[]),
2595 int (*keyop)(EVP_PKEY_CTX *ctx,
2596 unsigned char *sig, size_t *siglen,
2597 const unsigned char *tbs,
2598 size_t tbslen))
2599 {
2600 PKEY_DATA *kdata = NULL;
2601 int rv = 0;
2602
2603 rv = pkey_test_init_keyctx(t, name, use_public);
2604 if (t->skip || !rv)
2605 return rv;
2606 kdata = t->data;
2607 kdata->keyopinit = keyopinit;
2608 kdata->keyop = keyop;
2609 kdata->init_controls = sk_OPENSSL_STRING_new_null();
2610 kdata->controls = sk_OPENSSL_STRING_new_null();
2611 return 1;
2612 }
2613
pkey_test_init_ex2(EVP_TEST * t,const char * name,int use_public,int (* keyopinit)(EVP_PKEY_CTX * ctx,EVP_SIGNATURE * algo,const OSSL_PARAM param[]),int (* keyop)(EVP_PKEY_CTX * ctx,unsigned char * sig,size_t * siglen,const unsigned char * tbs,size_t tbslen))2614 static int pkey_test_init_ex2(EVP_TEST *t, const char *name,
2615 int use_public,
2616 int (*keyopinit)(EVP_PKEY_CTX *ctx,
2617 EVP_SIGNATURE *algo,
2618 const OSSL_PARAM param[]),
2619 int (*keyop)(EVP_PKEY_CTX *ctx,
2620 unsigned char *sig, size_t *siglen,
2621 const unsigned char *tbs,
2622 size_t tbslen))
2623 {
2624 PKEY_DATA *kdata = NULL;
2625 int rv = 0;
2626 char algoname[OSSL_MAX_NAME_SIZE + 1];
2627 const char *p;
2628
2629 if ((p = strchr(name, ':')) == NULL
2630 || p == name || p[1] == '\0' || p - name > OSSL_MAX_NAME_SIZE) {
2631 TEST_info("Can't extract algorithm or key name from '%s'", name);
2632 return 0;
2633 }
2634 memcpy(algoname, name, p - name);
2635 algoname[p - name] = '\0';
2636
2637 if (is_pkey_disabled(algoname)) {
2638 t->skip = 1;
2639 return 1;
2640 }
2641
2642 rv = pkey_test_init_keyctx(t, /* keyname */ p + 1, use_public);
2643 if (t->skip || !rv)
2644 return rv;
2645 kdata = t->data;
2646 kdata->keyopinit_ex2 = keyopinit;
2647 kdata->keyop = keyop;
2648 if (!TEST_ptr(kdata->sigalgo
2649 = EVP_SIGNATURE_fetch(libctx, algoname, propquery))) {
2650 TEST_info("algoname = '%s'", algoname);
2651 return 0;
2652 }
2653 kdata->init_controls = sk_OPENSSL_STRING_new_null();
2654 kdata->controls = sk_OPENSSL_STRING_new_null();
2655 return 1;
2656 }
2657
pkey_test_cleanup(EVP_TEST * t)2658 static void pkey_test_cleanup(EVP_TEST *t)
2659 {
2660 PKEY_DATA *kdata = t->data;
2661
2662 ctrlfree(kdata->init_controls);
2663 ctrlfree(kdata->controls);
2664 OPENSSL_free(kdata->input);
2665 OPENSSL_free(kdata->output);
2666 EVP_PKEY_CTX_free(kdata->ctx);
2667 EVP_SIGNATURE_free(kdata->sigalgo);
2668 }
2669
pkey_test_ctrl(EVP_TEST * t,EVP_PKEY_CTX * pctx,const char * value)2670 static int pkey_test_ctrl(EVP_TEST *t, EVP_PKEY_CTX *pctx,
2671 const char *value)
2672 {
2673 int rv = 0;
2674 char *p, *tmpval;
2675
2676 if (!TEST_ptr(tmpval = OPENSSL_strdup(value)))
2677 return 0;
2678 p = strchr(tmpval, ':');
2679 if (p != NULL) {
2680 *p++ = '\0';
2681 rv = EVP_PKEY_CTX_ctrl_str(pctx, tmpval, p);
2682 }
2683 if (rv == -2) {
2684 t->err = "PKEY_CTRL_INVALID";
2685 rv = 1;
2686 } else if (p != NULL && rv <= 0) {
2687 if (is_digest_disabled(p) || is_cipher_disabled(p)) {
2688 TEST_info("skipping, '%s' is disabled", p);
2689 t->skip = 1;
2690 rv = 1;
2691 } else {
2692 t->err = "PKEY_CTRL_ERROR";
2693 rv = 1;
2694 }
2695 }
2696 OPENSSL_free(tmpval);
2697 return rv > 0;
2698 }
2699
pkey_add_control(EVP_TEST * t,STACK_OF (OPENSSL_STRING)* controls,const char * value)2700 static int pkey_add_control(EVP_TEST *t, STACK_OF(OPENSSL_STRING) *controls,
2701 const char *value)
2702 {
2703 const char *p;
2704
2705 if (controls == NULL)
2706 return 0;
2707
2708 p = strchr(value, ':');
2709 if (p == NULL)
2710 return 0;
2711 p++;
2712 if (is_digest_disabled(p) || is_cipher_disabled(p)) {
2713 TEST_info("skipping, '%s' is disabled", p);
2714 t->skip = 1;
2715 return 1;
2716 }
2717
2718 return ctrladd(controls, value) > 0;
2719 }
2720
pkey_test_parse(EVP_TEST * t,const char * keyword,const char * value)2721 static int pkey_test_parse(EVP_TEST *t,
2722 const char *keyword, const char *value)
2723 {
2724 PKEY_DATA *kdata = t->data;
2725 if (strcmp(keyword, "Input") == 0)
2726 return parse_bin(value, &kdata->input, &kdata->input_len);
2727 if (strcmp(keyword, "Output") == 0)
2728 return parse_bin(value, &kdata->output, &kdata->output_len);
2729 if (strcmp(keyword, "CtrlInit") == 0)
2730 return ctrladd(kdata->init_controls, value);
2731 if (strcmp(keyword, "Ctrl") == 0)
2732 return pkey_add_control(t, kdata->controls, value);
2733 return 0;
2734 }
2735
pkey_test_run_init(EVP_TEST * t)2736 static int pkey_test_run_init(EVP_TEST *t)
2737 {
2738 PKEY_DATA *data = t->data;
2739 int i, ret = 0;
2740 OSSL_PARAM params[5] = {
2741 OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END,
2742 OSSL_PARAM_END, OSSL_PARAM_END
2743 };
2744 OSSL_PARAM *p = NULL;
2745 size_t params_n = 0, params_n_allocstart = 0;
2746
2747 if (sk_OPENSSL_STRING_num(data->init_controls) > 0) {
2748 if (!ctrl2params(t, data->init_controls,
2749 NULL,
2750 params, OSSL_NELEM(params), ¶ms_n))
2751 goto err;
2752 p = params;
2753 }
2754 if (data->keyopinit != NULL) {
2755 if (data->keyopinit(data->ctx, p) <= 0) {
2756 t->err = "KEYOP_INIT_ERROR";
2757 goto err;
2758 }
2759 } else if (data->keyopinit_ex2 != NULL) {
2760 if (data->keyopinit_ex2(data->ctx, data->sigalgo, p) <= 0) {
2761 t->err = "KEYOP_INIT_ERROR";
2762 goto err;
2763 }
2764 } else {
2765 t->err = "KEYOP_INIT_ERROR";
2766 goto err;
2767 }
2768
2769 for (i = 0; i < sk_OPENSSL_STRING_num(data->controls); i++) {
2770 char *value = sk_OPENSSL_STRING_value(data->controls, i);
2771
2772 if (!pkey_test_ctrl(t, data->ctx, value) || t->err != NULL)
2773 goto err;
2774 }
2775 ret = 1;
2776 err:
2777 ctrl2params_free(params, params_n, params_n_allocstart);
2778 return ret;
2779 }
2780
pkey_test_run(EVP_TEST * t)2781 static int pkey_test_run(EVP_TEST *t)
2782 {
2783 PKEY_DATA *expected = t->data;
2784 unsigned char *got = NULL;
2785 size_t got_len;
2786 EVP_PKEY_CTX *copy = NULL;
2787
2788 if (!pkey_test_run_init(t))
2789 goto err;
2790
2791 /* Make a copy of the EVP_PKEY context, for repeat use further down */
2792 if (!TEST_ptr(copy = EVP_PKEY_CTX_dup(expected->ctx))) {
2793 t->err = "INTERNAL_ERROR";
2794 goto err;
2795 }
2796
2797 if (expected->keyop(expected->ctx, NULL, &got_len,
2798 expected->input, expected->input_len)
2799 <= 0
2800 || !TEST_ptr(got = OPENSSL_malloc(got_len))) {
2801 t->err = "KEYOP_LENGTH_ERROR";
2802 goto err;
2803 }
2804 if (expected->keyop(expected->ctx, got, &got_len,
2805 expected->input, expected->input_len)
2806 <= 0) {
2807 t->err = "KEYOP_ERROR";
2808 goto err;
2809 }
2810
2811 if (!memory_err_compare(t, "KEYOP_MISMATCH",
2812 expected->output, expected->output_len,
2813 got, got_len))
2814 goto err;
2815
2816 t->err = NULL;
2817 OPENSSL_free(got);
2818 got = NULL;
2819
2820 /* Repeat the test on the EVP_PKEY context copy. */
2821 if (expected->keyop(copy, NULL, &got_len, expected->input,
2822 expected->input_len)
2823 <= 0
2824 || !TEST_ptr(got = OPENSSL_malloc(got_len))) {
2825 t->err = "KEYOP_LENGTH_ERROR";
2826 goto err;
2827 }
2828 if (expected->keyop(copy, got, &got_len, expected->input,
2829 expected->input_len)
2830 <= 0) {
2831 t->err = "KEYOP_ERROR";
2832 goto err;
2833 }
2834 if (!memory_err_compare(t, "KEYOP_MISMATCH",
2835 expected->output, expected->output_len,
2836 got, got_len))
2837 goto err;
2838
2839 if (pkey_check_fips_approved(expected->ctx, t) <= 0)
2840 goto err;
2841
2842 err:
2843 OPENSSL_free(got);
2844 EVP_PKEY_CTX_free(copy);
2845 return 1;
2846 }
2847
pkey_fromdata_test_init(EVP_TEST * t,const char * name)2848 static int pkey_fromdata_test_init(EVP_TEST *t, const char *name)
2849 {
2850 PKEY_DATA *kdata = NULL;
2851
2852 if (is_pkey_disabled(name)) {
2853 TEST_info("skipping, '%s' is disabled", name);
2854 t->skip = 1;
2855 return 1;
2856 }
2857
2858 if (!TEST_ptr(kdata = OPENSSL_zalloc(sizeof(*kdata))))
2859 return 0;
2860 kdata->ctx = EVP_PKEY_CTX_new_from_name(libctx, name, "");
2861 if (kdata->ctx == NULL)
2862 goto err;
2863 if (EVP_PKEY_fromdata_init(kdata->ctx) <= 0)
2864 goto err;
2865 kdata->controls = sk_OPENSSL_STRING_new_null();
2866 if (kdata->controls == NULL)
2867 goto err;
2868 t->data = kdata;
2869 return 1;
2870 err:
2871 EVP_PKEY_CTX_free(kdata->ctx);
2872 OPENSSL_free(kdata);
2873 return 0;
2874 }
2875
pkey_fromdata_test_cleanup(EVP_TEST * t)2876 static void pkey_fromdata_test_cleanup(EVP_TEST *t)
2877 {
2878 PKEY_DATA *kdata = t->data;
2879
2880 ctrlfree(kdata->controls);
2881 EVP_PKEY_CTX_free(kdata->ctx);
2882 }
2883
pkey_fromdata_test_parse(EVP_TEST * t,const char * keyword,const char * value)2884 static int pkey_fromdata_test_parse(EVP_TEST *t,
2885 const char *keyword, const char *value)
2886 {
2887 PKEY_DATA *kdata = t->data;
2888
2889 if (strcmp(keyword, "Ctrl") == 0)
2890 return pkey_add_control(t, kdata->controls, value);
2891 return 0;
2892 }
2893
pkey_fromdata_test_run(EVP_TEST * t)2894 static int pkey_fromdata_test_run(EVP_TEST *t)
2895 {
2896 EVP_PKEY *key = NULL;
2897 PKEY_DATA *kdata = t->data;
2898 int ret = 0;
2899 static const OSSL_PARAM key_settable_ctx_params[] = {
2900 OSSL_PARAM_octet_string("priv", NULL, 0),
2901 OSSL_PARAM_octet_string("pub", NULL, 0),
2902 OSSL_PARAM_END
2903 };
2904 OSSL_PARAM params[5] = {
2905 OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END,
2906 OSSL_PARAM_END, OSSL_PARAM_END
2907 };
2908 OSSL_PARAM *p = NULL;
2909 size_t params_n = 0, params_n_allocstart = 0;
2910
2911 if (sk_OPENSSL_STRING_num(kdata->controls) > 0) {
2912 if (!ctrl2params(t, kdata->controls, key_settable_ctx_params,
2913 params, OSSL_NELEM(params), ¶ms_n))
2914 goto err;
2915 p = params;
2916 }
2917
2918 ret = 1;
2919 if (EVP_PKEY_fromdata(kdata->ctx, &key, EVP_PKEY_KEYPAIR, p) <= 0) {
2920 t->err = "KEY_FROMDATA_ERROR";
2921 goto err;
2922 }
2923 err:
2924 ctrl2params_free(params, params_n, params_n_allocstart);
2925 EVP_PKEY_free(key);
2926 return ret;
2927 }
2928
2929 static const EVP_TEST_METHOD pkey_fromdata_test_method = {
2930 "KeyFromData",
2931 pkey_fromdata_test_init,
2932 pkey_fromdata_test_cleanup,
2933 pkey_fromdata_test_parse,
2934 pkey_fromdata_test_run
2935 };
2936
2937 /*
2938 * "Sign" implies EVP_PKEY_sign_init_ex2() if the argument is a colon-separated
2939 * pair, {algorithm}:{key}. If not, it implies EVP_PKEY_sign_init_ex()
2940 */
sign_test_init(EVP_TEST * t,const char * name)2941 static int sign_test_init(EVP_TEST *t, const char *name)
2942 {
2943 if (strchr(name, ':') != NULL)
2944 return pkey_test_init_ex2(t, name, 0,
2945 EVP_PKEY_sign_init_ex2, EVP_PKEY_sign);
2946 return pkey_test_init(t, name, 0, EVP_PKEY_sign_init_ex, EVP_PKEY_sign);
2947 }
2948
2949 static const EVP_TEST_METHOD psign_test_method = {
2950 "Sign",
2951 sign_test_init,
2952 pkey_test_cleanup,
2953 pkey_test_parse,
2954 pkey_test_run
2955 };
2956
2957 /*
2958 * "Sign-Message" is like "Sign", but uses EVP_PKEY_sign_message_init()
2959 * The argument must be a colon separated pair, {algorithm}:{key}
2960 */
sign_test_message_init(EVP_TEST * t,const char * name)2961 static int sign_test_message_init(EVP_TEST *t, const char *name)
2962 {
2963 return pkey_test_init_ex2(t, name, 0,
2964 EVP_PKEY_sign_message_init, EVP_PKEY_sign);
2965 }
2966
2967 static const EVP_TEST_METHOD psign_message_test_method = {
2968 "Sign-Message",
2969 sign_test_message_init,
2970 pkey_test_cleanup,
2971 pkey_test_parse,
2972 pkey_test_run
2973 };
2974
2975 /*
2976 * "VerifyRecover" implies EVP_PKEY_verify_recover_init_ex2() if the argument is a
2977 * colon-separated pair, {algorithm}:{key}.
2978 * If not, it implies EVP_PKEY_verify_recover_init_ex()
2979 */
verify_recover_test_init(EVP_TEST * t,const char * name)2980 static int verify_recover_test_init(EVP_TEST *t, const char *name)
2981 {
2982 if (strchr(name, ':') != NULL)
2983 return pkey_test_init_ex2(t, name, 1,
2984 EVP_PKEY_verify_recover_init_ex2,
2985 EVP_PKEY_verify_recover);
2986 return pkey_test_init(t, name, 1, EVP_PKEY_verify_recover_init_ex,
2987 EVP_PKEY_verify_recover);
2988 }
2989
2990 static const EVP_TEST_METHOD pverify_recover_test_method = {
2991 "VerifyRecover",
2992 verify_recover_test_init,
2993 pkey_test_cleanup,
2994 pkey_test_parse,
2995 pkey_test_run
2996 };
2997
decrypt_test_init(EVP_TEST * t,const char * name)2998 static int decrypt_test_init(EVP_TEST *t, const char *name)
2999 {
3000 return pkey_test_init(t, name, 0, EVP_PKEY_decrypt_init_ex,
3001 EVP_PKEY_decrypt);
3002 }
3003
3004 static const EVP_TEST_METHOD pdecrypt_test_method = {
3005 "Decrypt",
3006 decrypt_test_init,
3007 pkey_test_cleanup,
3008 pkey_test_parse,
3009 pkey_test_run
3010 };
3011
3012 /*
3013 * "Verify" implies EVP_PKEY_verify_init_ex2() if the argument is a
3014 * colon-separated pair, {algorithm}:{key}.
3015 * If not, it implies EVP_PKEY_verify_init_ex()
3016 */
verify_test_init(EVP_TEST * t,const char * name)3017 static int verify_test_init(EVP_TEST *t, const char *name)
3018 {
3019 if (strchr(name, ':') != NULL)
3020 return pkey_test_init_ex2(t, name, 1,
3021 EVP_PKEY_verify_init_ex2, NULL);
3022 return pkey_test_init(t, name, 1, EVP_PKEY_verify_init_ex, NULL);
3023 }
3024
verify_test_run(EVP_TEST * t)3025 static int verify_test_run(EVP_TEST *t)
3026 {
3027 int ret = 1;
3028 PKEY_DATA *kdata = t->data;
3029
3030 if (!pkey_test_run_init(t))
3031 goto err;
3032 if (EVP_PKEY_verify(kdata->ctx, kdata->output, kdata->output_len,
3033 kdata->input, kdata->input_len)
3034 <= 0) {
3035 t->err = "VERIFY_ERROR";
3036 goto err;
3037 }
3038 if (!pkey_check_fips_approved(kdata->ctx, t))
3039 ret = 0;
3040 err:
3041 return ret;
3042 }
3043
3044 static const EVP_TEST_METHOD pverify_test_method = {
3045 "Verify",
3046 verify_test_init,
3047 pkey_test_cleanup,
3048 pkey_test_parse,
3049 verify_test_run
3050 };
3051
3052 /*
3053 * "Verify-Message" is like "Verify", but uses EVP_PKEY_verify_message_init()
3054 * The argument must be a colon separated pair, {algorithm}:{key}
3055 */
verify_message_test_init(EVP_TEST * t,const char * name)3056 static int verify_message_test_init(EVP_TEST *t, const char *name)
3057 {
3058 return pkey_test_init_ex2(t, name, 0,
3059 EVP_PKEY_verify_message_init, NULL);
3060 }
3061
3062 static const EVP_TEST_METHOD pverify_message_test_method = {
3063 "Verify-Message",
3064 verify_message_test_init,
3065 pkey_test_cleanup,
3066 pkey_test_parse,
3067 verify_test_run
3068 };
3069
3070 /*
3071 * "Verify-Message-Public" is like "Verify-Message", but uses a public key
3072 * instead of a private key.
3073 * The argument must be a colon separated pair, {algorithm}:{key}
3074 */
verify_message_public_test_init(EVP_TEST * t,const char * name)3075 static int verify_message_public_test_init(EVP_TEST *t, const char *name)
3076 {
3077 return pkey_test_init_ex2(t, name, 1,
3078 EVP_PKEY_verify_message_init, NULL);
3079 }
3080
3081 static const EVP_TEST_METHOD pverify_message_public_test_method = {
3082 "Verify-Message-Public",
3083 verify_message_public_test_init,
3084 pkey_test_cleanup,
3085 pkey_test_parse,
3086 verify_test_run
3087 };
3088
pderive_test_init(EVP_TEST * t,const char * name)3089 static int pderive_test_init(EVP_TEST *t, const char *name)
3090 {
3091 return pkey_test_init(t, name, 0, EVP_PKEY_derive_init_ex, 0);
3092 }
3093
pderive_test_parse(EVP_TEST * t,const char * keyword,const char * value)3094 static int pderive_test_parse(EVP_TEST *t,
3095 const char *keyword, const char *value)
3096 {
3097 PKEY_DATA *kdata = t->data;
3098 int validate = 0;
3099
3100 if (strcmp(keyword, "PeerKeyValidate") == 0)
3101 validate = 1;
3102
3103 if (validate || strcmp(keyword, "PeerKey") == 0) {
3104 EVP_PKEY *peer = NULL;
3105
3106 kdata->validate = validate;
3107 if (find_key(&peer, value, public_keys) == 0)
3108 return -1;
3109 kdata->peer = peer;
3110 return 1;
3111 }
3112 if (strcmp(keyword, "SharedSecret") == 0)
3113 return parse_bin(value, &kdata->output, &kdata->output_len);
3114 if (strcmp(keyword, "Ctrl") == 0)
3115 return pkey_add_control(t, kdata->controls, value);
3116 if (strcmp(keyword, "CtrlInit") == 0)
3117 return ctrladd(kdata->init_controls, value);
3118 return 0;
3119 }
3120
pderive_test_run(EVP_TEST * t)3121 static int pderive_test_run(EVP_TEST *t)
3122 {
3123 EVP_PKEY_CTX *dctx = NULL;
3124 PKEY_DATA *expected = t->data;
3125 unsigned char *got = NULL;
3126 size_t got_len;
3127 int ret = 1;
3128
3129 if (!pkey_test_run_init(t))
3130 goto err;
3131
3132 t->err = NULL;
3133 if (EVP_PKEY_derive_set_peer_ex(expected->ctx, expected->peer,
3134 expected->validate)
3135 <= 0) {
3136 t->err = "DERIVE_SET_PEER_ERROR";
3137 goto err;
3138 }
3139
3140 if (!TEST_ptr(dctx = EVP_PKEY_CTX_dup(expected->ctx))) {
3141 t->err = "DERIVE_ERROR";
3142 goto err;
3143 }
3144
3145 if (EVP_PKEY_derive(dctx, NULL, &got_len) <= 0
3146 || !TEST_size_t_ne(got_len, 0)) {
3147 t->err = "DERIVE_ERROR";
3148 goto err;
3149 }
3150 if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
3151 t->err = "DERIVE_ERROR";
3152 goto err;
3153 }
3154 if (EVP_PKEY_derive(dctx, got, &got_len) <= 0) {
3155 t->err = "DERIVE_ERROR";
3156 goto err;
3157 }
3158 if (!memory_err_compare(t, "SHARED_SECRET_MISMATCH",
3159 expected->output, expected->output_len,
3160 got, got_len))
3161 goto err;
3162
3163 if (!pkey_check_fips_approved(dctx, t)) {
3164 ret = 0;
3165 goto err;
3166 }
3167 t->err = NULL;
3168 err:
3169 OPENSSL_free(got);
3170 EVP_PKEY_CTX_free(dctx);
3171 return ret;
3172 }
3173
3174 static const EVP_TEST_METHOD pderive_test_method = {
3175 "Derive",
3176 pderive_test_init,
3177 pkey_test_cleanup,
3178 pderive_test_parse,
3179 pderive_test_run
3180 };
3181
3182 /**
3183 ** PBE TESTS
3184 **/
3185
3186 typedef enum pbe_type_enum {
3187 PBE_TYPE_INVALID = 0,
3188 PBE_TYPE_SCRYPT,
3189 PBE_TYPE_PBKDF2,
3190 PBE_TYPE_PKCS12
3191 } PBE_TYPE;
3192
3193 typedef struct pbe_data_st {
3194 PBE_TYPE pbe_type;
3195 /* scrypt parameters */
3196 uint64_t N, r, p, maxmem;
3197 /* PKCS#12 parameters */
3198 int id, iter;
3199 const EVP_MD *md;
3200 /* password */
3201 unsigned char *pass;
3202 size_t pass_len;
3203 /* salt */
3204 unsigned char *salt;
3205 size_t salt_len;
3206 /* Expected output */
3207 unsigned char *key;
3208 size_t key_len;
3209 } PBE_DATA;
3210
3211 #ifndef OPENSSL_NO_SCRYPT
3212 /* Parse unsigned decimal 64 bit integer value */
parse_uint64(const char * value,uint64_t * pr)3213 static int parse_uint64(const char *value, uint64_t *pr)
3214 {
3215 const char *p = value;
3216
3217 if (!TEST_true(*p)) {
3218 TEST_info("Invalid empty integer value");
3219 return -1;
3220 }
3221 for (*pr = 0; *p;) {
3222 if (*pr > UINT64_MAX / 10) {
3223 TEST_error("Integer overflow in string %s", value);
3224 return -1;
3225 }
3226 *pr *= 10;
3227 if (!TEST_true(isdigit((unsigned char)*p))) {
3228 TEST_error("Invalid character in string %s", value);
3229 return -1;
3230 }
3231 *pr += *p - '0';
3232 p++;
3233 }
3234 return 1;
3235 }
3236
scrypt_test_parse(EVP_TEST * t,const char * keyword,const char * value)3237 static int scrypt_test_parse(EVP_TEST *t,
3238 const char *keyword, const char *value)
3239 {
3240 PBE_DATA *pdata = t->data;
3241
3242 if (strcmp(keyword, "N") == 0)
3243 return parse_uint64(value, &pdata->N);
3244 if (strcmp(keyword, "p") == 0)
3245 return parse_uint64(value, &pdata->p);
3246 if (strcmp(keyword, "r") == 0)
3247 return parse_uint64(value, &pdata->r);
3248 if (strcmp(keyword, "maxmem") == 0)
3249 return parse_uint64(value, &pdata->maxmem);
3250 return 0;
3251 }
3252 #endif
3253
pbkdf2_test_parse(EVP_TEST * t,const char * keyword,const char * value)3254 static int pbkdf2_test_parse(EVP_TEST *t,
3255 const char *keyword, const char *value)
3256 {
3257 PBE_DATA *pdata = t->data;
3258
3259 if (strcmp(keyword, "iter") == 0) {
3260 pdata->iter = atoi(value);
3261 if (pdata->iter <= 0)
3262 return -1;
3263 return 1;
3264 }
3265 if (strcmp(keyword, "MD") == 0) {
3266 pdata->md = EVP_get_digestbyname(value);
3267 if (pdata->md == NULL)
3268 return -1;
3269 return 1;
3270 }
3271 return 0;
3272 }
3273
pkcs12_test_parse(EVP_TEST * t,const char * keyword,const char * value)3274 static int pkcs12_test_parse(EVP_TEST *t,
3275 const char *keyword, const char *value)
3276 {
3277 PBE_DATA *pdata = t->data;
3278
3279 if (strcmp(keyword, "id") == 0) {
3280 pdata->id = atoi(value);
3281 if (pdata->id <= 0)
3282 return -1;
3283 return 1;
3284 }
3285 return pbkdf2_test_parse(t, keyword, value);
3286 }
3287
pbe_test_init(EVP_TEST * t,const char * alg)3288 static int pbe_test_init(EVP_TEST *t, const char *alg)
3289 {
3290 PBE_DATA *pdat;
3291 PBE_TYPE pbe_type = PBE_TYPE_INVALID;
3292
3293 if (is_kdf_disabled(alg)) {
3294 TEST_info("skipping, '%s' is disabled", alg);
3295 t->skip = 1;
3296 return 1;
3297 }
3298 if (strcmp(alg, "scrypt") == 0) {
3299 pbe_type = PBE_TYPE_SCRYPT;
3300 } else if (strcmp(alg, "pbkdf2") == 0) {
3301 pbe_type = PBE_TYPE_PBKDF2;
3302 } else if (strcmp(alg, "pkcs12") == 0) {
3303 pbe_type = PBE_TYPE_PKCS12;
3304 } else {
3305 TEST_error("Unknown pbe algorithm %s", alg);
3306 return 0;
3307 }
3308 if (!TEST_ptr(pdat = OPENSSL_zalloc(sizeof(*pdat))))
3309 return 0;
3310 pdat->pbe_type = pbe_type;
3311 t->data = pdat;
3312 return 1;
3313 }
3314
pbe_test_cleanup(EVP_TEST * t)3315 static void pbe_test_cleanup(EVP_TEST *t)
3316 {
3317 PBE_DATA *pdat = t->data;
3318
3319 OPENSSL_free(pdat->pass);
3320 OPENSSL_free(pdat->salt);
3321 OPENSSL_free(pdat->key);
3322 }
3323
pbe_test_parse(EVP_TEST * t,const char * keyword,const char * value)3324 static int pbe_test_parse(EVP_TEST *t,
3325 const char *keyword, const char *value)
3326 {
3327 PBE_DATA *pdata = t->data;
3328
3329 if (strcmp(keyword, "Password") == 0)
3330 return parse_bin(value, &pdata->pass, &pdata->pass_len);
3331 if (strcmp(keyword, "Salt") == 0)
3332 return parse_bin(value, &pdata->salt, &pdata->salt_len);
3333 if (strcmp(keyword, "Key") == 0)
3334 return parse_bin(value, &pdata->key, &pdata->key_len);
3335 if (pdata->pbe_type == PBE_TYPE_PBKDF2)
3336 return pbkdf2_test_parse(t, keyword, value);
3337 else if (pdata->pbe_type == PBE_TYPE_PKCS12)
3338 return pkcs12_test_parse(t, keyword, value);
3339 #ifndef OPENSSL_NO_SCRYPT
3340 else if (pdata->pbe_type == PBE_TYPE_SCRYPT)
3341 return scrypt_test_parse(t, keyword, value);
3342 #endif
3343 return 0;
3344 }
3345
pbe_test_run(EVP_TEST * t)3346 static int pbe_test_run(EVP_TEST *t)
3347 {
3348 PBE_DATA *expected = t->data;
3349 unsigned char *key;
3350 EVP_MD *fetched_digest = NULL;
3351 OSSL_LIB_CTX *save_libctx;
3352
3353 save_libctx = OSSL_LIB_CTX_set0_default(libctx);
3354
3355 if (!TEST_ptr(key = OPENSSL_malloc(expected->key_len))) {
3356 t->err = "INTERNAL_ERROR";
3357 goto err;
3358 }
3359 if (expected->pbe_type == PBE_TYPE_PBKDF2) {
3360 if (PKCS5_PBKDF2_HMAC((char *)expected->pass, expected->pass_len,
3361 expected->salt, expected->salt_len,
3362 expected->iter, expected->md,
3363 expected->key_len, key)
3364 == 0) {
3365 t->err = "PBKDF2_ERROR";
3366 goto err;
3367 }
3368 #ifndef OPENSSL_NO_SCRYPT
3369 } else if (expected->pbe_type == PBE_TYPE_SCRYPT) {
3370 if (EVP_PBE_scrypt((const char *)expected->pass, expected->pass_len,
3371 expected->salt, expected->salt_len,
3372 expected->N, expected->r, expected->p,
3373 expected->maxmem, key, expected->key_len)
3374 == 0) {
3375 t->err = "SCRYPT_ERROR";
3376 goto err;
3377 }
3378 #endif
3379 } else if (expected->pbe_type == PBE_TYPE_PKCS12) {
3380 fetched_digest = EVP_MD_fetch(libctx, EVP_MD_get0_name(expected->md),
3381 propquery);
3382 if (fetched_digest == NULL) {
3383 t->err = "PKCS12_ERROR";
3384 goto err;
3385 }
3386 if (PKCS12_key_gen_uni(expected->pass, expected->pass_len,
3387 expected->salt, expected->salt_len,
3388 expected->id, expected->iter, expected->key_len,
3389 key, fetched_digest)
3390 == 0) {
3391 t->err = "PKCS12_ERROR";
3392 goto err;
3393 }
3394 }
3395 if (!memory_err_compare(t, "KEY_MISMATCH", expected->key, expected->key_len,
3396 key, expected->key_len))
3397 goto err;
3398
3399 t->err = NULL;
3400 err:
3401 EVP_MD_free(fetched_digest);
3402 OPENSSL_free(key);
3403 OSSL_LIB_CTX_set0_default(save_libctx);
3404 return 1;
3405 }
3406
3407 static const EVP_TEST_METHOD pbe_test_method = {
3408 "PBE",
3409 pbe_test_init,
3410 pbe_test_cleanup,
3411 pbe_test_parse,
3412 pbe_test_run
3413 };
3414
3415 /**
3416 ** BASE64 TESTS
3417 **/
3418
3419 typedef enum {
3420 BASE64_CANONICAL_ENCODING = 0,
3421 BASE64_VALID_ENCODING = 1,
3422 BASE64_INVALID_ENCODING = 2
3423 } base64_encoding_type;
3424
3425 typedef struct encode_data_st {
3426 /* Input to encoding */
3427 unsigned char *input;
3428 size_t input_len;
3429 /* Expected output */
3430 unsigned char *output;
3431 size_t output_len;
3432 base64_encoding_type encoding;
3433 } ENCODE_DATA;
3434
encode_test_init(EVP_TEST * t,const char * encoding)3435 static int encode_test_init(EVP_TEST *t, const char *encoding)
3436 {
3437 ENCODE_DATA *edata;
3438
3439 if (!TEST_ptr(edata = OPENSSL_zalloc(sizeof(*edata))))
3440 return 0;
3441 if (strcmp(encoding, "canonical") == 0) {
3442 edata->encoding = BASE64_CANONICAL_ENCODING;
3443 } else if (strcmp(encoding, "valid") == 0) {
3444 edata->encoding = BASE64_VALID_ENCODING;
3445 } else if (strcmp(encoding, "invalid") == 0) {
3446 edata->encoding = BASE64_INVALID_ENCODING;
3447 if (!TEST_ptr(t->expected_err = OPENSSL_strdup("DECODE_ERROR")))
3448 goto err;
3449 } else {
3450 TEST_error("Bad encoding: %s."
3451 " Should be one of {canonical, valid, invalid}",
3452 encoding);
3453 goto err;
3454 }
3455 t->data = edata;
3456 return 1;
3457 err:
3458 OPENSSL_free(edata);
3459 return 0;
3460 }
3461
encode_test_cleanup(EVP_TEST * t)3462 static void encode_test_cleanup(EVP_TEST *t)
3463 {
3464 ENCODE_DATA *edata = t->data;
3465
3466 OPENSSL_free(edata->input);
3467 OPENSSL_free(edata->output);
3468 memset(edata, 0, sizeof(*edata));
3469 }
3470
encode_test_parse(EVP_TEST * t,const char * keyword,const char * value)3471 static int encode_test_parse(EVP_TEST *t,
3472 const char *keyword, const char *value)
3473 {
3474 ENCODE_DATA *edata = t->data;
3475
3476 if (strcmp(keyword, "Input") == 0)
3477 return parse_bin(value, &edata->input, &edata->input_len);
3478 if (strcmp(keyword, "Output") == 0)
3479 return parse_bin(value, &edata->output, &edata->output_len);
3480 return 0;
3481 }
3482
encode_test_run(EVP_TEST * t)3483 static int encode_test_run(EVP_TEST *t)
3484 {
3485 ENCODE_DATA *expected = t->data;
3486 unsigned char *encode_out = NULL, *decode_out = NULL;
3487 int output_len, chunk_len;
3488 EVP_ENCODE_CTX *decode_ctx = NULL, *encode_ctx = NULL;
3489 size_t input_len, donelen, decode_length;
3490
3491 if (!TEST_ptr(decode_ctx = EVP_ENCODE_CTX_new())) {
3492 t->err = "INTERNAL_ERROR";
3493 goto err;
3494 }
3495
3496 if (expected->encoding == BASE64_CANONICAL_ENCODING) {
3497
3498 if (!TEST_ptr(encode_ctx = EVP_ENCODE_CTX_new())
3499 || !TEST_ptr(encode_out = OPENSSL_malloc(EVP_ENCODE_LENGTH(expected->input_len))))
3500 goto err;
3501
3502 EVP_EncodeInit(encode_ctx);
3503
3504 input_len = expected->input_len;
3505 donelen = 0;
3506 output_len = 0;
3507 do {
3508 size_t current_len = (size_t)data_chunk_size;
3509
3510 if (data_chunk_size == 0 || (size_t)data_chunk_size > input_len)
3511 current_len = input_len;
3512 if (!TEST_true(EVP_EncodeUpdate(encode_ctx, encode_out, &chunk_len,
3513 expected->input + donelen,
3514 current_len)))
3515 goto err;
3516 donelen += current_len;
3517 input_len -= current_len;
3518 output_len += chunk_len;
3519 } while (input_len > 0);
3520
3521 EVP_EncodeFinal(encode_ctx, encode_out + output_len, &chunk_len);
3522 output_len += chunk_len;
3523
3524 if (!memory_err_compare(t, "BAD_ENCODING",
3525 expected->output, expected->output_len,
3526 encode_out, output_len))
3527 goto err;
3528 }
3529
3530 decode_length = EVP_DECODE_LENGTH(expected->output_len);
3531 if (!TEST_ptr(decode_out = OPENSSL_malloc(decode_length)))
3532 goto err;
3533 /*
3534 * Fill memory with non-zeros
3535 * to check that decoding does not place redundant zeros.
3536 */
3537 memset(decode_out, 0xff, decode_length);
3538
3539 output_len = 0;
3540 EVP_DecodeInit(decode_ctx);
3541
3542 input_len = expected->output_len;
3543 donelen = 0;
3544 do {
3545 size_t current_len = (size_t)data_chunk_size;
3546
3547 if (data_chunk_size == 0 || (size_t)data_chunk_size > input_len)
3548 current_len = input_len;
3549 if (EVP_DecodeUpdate(decode_ctx, decode_out + output_len, &chunk_len,
3550 expected->output + donelen, current_len)
3551 < 0) {
3552 t->err = "DECODE_ERROR";
3553 goto err;
3554 }
3555 donelen += current_len;
3556 input_len -= current_len;
3557 output_len += chunk_len;
3558 } while (input_len > 0);
3559
3560 if (EVP_DecodeFinal(decode_ctx, decode_out + output_len, &chunk_len) != 1) {
3561 t->err = "DECODE_ERROR";
3562 goto err;
3563 }
3564 output_len += chunk_len;
3565
3566 if (expected->encoding != BASE64_INVALID_ENCODING
3567 && !memory_err_compare(t, "BAD_DECODING",
3568 expected->input, expected->input_len,
3569 decode_out, output_len)) {
3570 t->err = "BAD_DECODING";
3571 goto err;
3572 }
3573
3574 for (; output_len < (int)decode_length; output_len++) {
3575 if (decode_out[output_len] != 0xff) {
3576 t->err = "BAD_DECODING";
3577 goto err;
3578 }
3579 }
3580
3581 t->err = NULL;
3582 err:
3583 OPENSSL_free(encode_out);
3584 OPENSSL_free(decode_out);
3585 EVP_ENCODE_CTX_free(decode_ctx);
3586 EVP_ENCODE_CTX_free(encode_ctx);
3587 return 1;
3588 }
3589
3590 static const EVP_TEST_METHOD encode_test_method = {
3591 "Encoding",
3592 encode_test_init,
3593 encode_test_cleanup,
3594 encode_test_parse,
3595 encode_test_run,
3596 };
3597
3598 /**
3599 ** RAND TESTS
3600 **/
3601 #define MAX_RAND_REPEATS 15
3602
3603 typedef struct rand_data_pass_st {
3604 unsigned char *entropy;
3605 unsigned char *reseed_entropy;
3606 unsigned char *nonce;
3607 unsigned char *pers;
3608 unsigned char *reseed_addin;
3609 unsigned char *addinA;
3610 unsigned char *addinB;
3611 unsigned char *pr_entropyA;
3612 unsigned char *pr_entropyB;
3613 unsigned char *output;
3614 size_t entropy_len, nonce_len, pers_len, addinA_len, addinB_len,
3615 pr_entropyA_len, pr_entropyB_len, output_len, reseed_entropy_len,
3616 reseed_addin_len;
3617 } RAND_DATA_PASS;
3618
3619 typedef struct rand_data_st {
3620 /* Context for this operation */
3621 EVP_RAND_CTX *ctx;
3622 EVP_RAND_CTX *parent;
3623 int n;
3624 int prediction_resistance;
3625 int use_df;
3626 unsigned int generate_bits;
3627 char *cipher;
3628 char *digest;
3629 STACK_OF(OPENSSL_STRING) *init_controls; /* collection of controls */
3630
3631 /* Expected output */
3632 RAND_DATA_PASS data[MAX_RAND_REPEATS];
3633 } RAND_DATA;
3634
rand_test_init(EVP_TEST * t,const char * name)3635 static int rand_test_init(EVP_TEST *t, const char *name)
3636 {
3637 RAND_DATA *rdata;
3638 EVP_RAND *rand;
3639 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
3640 unsigned int strength = 256;
3641
3642 if (!TEST_ptr(rdata = OPENSSL_zalloc(sizeof(*rdata))))
3643 return 0;
3644
3645 /* TEST-RAND is available in the FIPS provider but not with "fips=yes" */
3646 rand = EVP_RAND_fetch(libctx, "TEST-RAND", "-fips");
3647 if (rand == NULL)
3648 goto err;
3649 rdata->parent = EVP_RAND_CTX_new(rand, NULL);
3650 EVP_RAND_free(rand);
3651 if (rdata->parent == NULL)
3652 goto err;
3653
3654 *params = OSSL_PARAM_construct_uint(OSSL_RAND_PARAM_STRENGTH, &strength);
3655 if (!EVP_RAND_CTX_set_params(rdata->parent, params))
3656 goto err;
3657
3658 rand = EVP_RAND_fetch(libctx, name, propquery);
3659 if (rand == NULL)
3660 goto err;
3661 rdata->ctx = EVP_RAND_CTX_new(rand, rdata->parent);
3662 EVP_RAND_free(rand);
3663 if (rdata->ctx == NULL)
3664 goto err;
3665 rdata->init_controls = sk_OPENSSL_STRING_new_null();
3666
3667 rdata->n = -1;
3668 t->data = rdata;
3669 return 1;
3670 err:
3671 EVP_RAND_CTX_free(rdata->parent);
3672 OPENSSL_free(rdata);
3673 return 0;
3674 }
3675
rand_test_cleanup(EVP_TEST * t)3676 static void rand_test_cleanup(EVP_TEST *t)
3677 {
3678 RAND_DATA *rdata = t->data;
3679 int i;
3680
3681 ctrlfree(rdata->init_controls);
3682 OPENSSL_free(rdata->cipher);
3683 OPENSSL_free(rdata->digest);
3684
3685 for (i = 0; i <= rdata->n; i++) {
3686 OPENSSL_free(rdata->data[i].entropy);
3687 OPENSSL_free(rdata->data[i].reseed_entropy);
3688 OPENSSL_free(rdata->data[i].nonce);
3689 OPENSSL_free(rdata->data[i].pers);
3690 OPENSSL_free(rdata->data[i].reseed_addin);
3691 OPENSSL_free(rdata->data[i].addinA);
3692 OPENSSL_free(rdata->data[i].addinB);
3693 OPENSSL_free(rdata->data[i].pr_entropyA);
3694 OPENSSL_free(rdata->data[i].pr_entropyB);
3695 OPENSSL_free(rdata->data[i].output);
3696 }
3697 EVP_RAND_CTX_free(rdata->ctx);
3698 EVP_RAND_CTX_free(rdata->parent);
3699 }
3700
rand_test_parse(EVP_TEST * t,const char * keyword,const char * value)3701 static int rand_test_parse(EVP_TEST *t,
3702 const char *keyword, const char *value)
3703 {
3704 RAND_DATA *rdata = t->data;
3705 RAND_DATA_PASS *item;
3706 const char *p;
3707 int n;
3708
3709 if ((p = strchr(keyword, '.')) != NULL) {
3710 n = atoi(++p);
3711 if (n >= MAX_RAND_REPEATS)
3712 return 0;
3713 if (n > rdata->n)
3714 rdata->n = n;
3715 item = rdata->data + n;
3716 if (HAS_PREFIX(keyword, "Entropy."))
3717 return parse_bin(value, &item->entropy, &item->entropy_len);
3718 if (HAS_PREFIX(keyword, "ReseedEntropy."))
3719 return parse_bin(value, &item->reseed_entropy,
3720 &item->reseed_entropy_len);
3721 if (HAS_PREFIX(keyword, "Nonce."))
3722 return parse_bin(value, &item->nonce, &item->nonce_len);
3723 if (HAS_PREFIX(keyword, "PersonalisationString."))
3724 return parse_bin(value, &item->pers, &item->pers_len);
3725 if (HAS_PREFIX(keyword, "ReseedAdditionalInput."))
3726 return parse_bin(value, &item->reseed_addin,
3727 &item->reseed_addin_len);
3728 if (HAS_PREFIX(keyword, "AdditionalInputA."))
3729 return parse_bin(value, &item->addinA, &item->addinA_len);
3730 if (HAS_PREFIX(keyword, "AdditionalInputB."))
3731 return parse_bin(value, &item->addinB, &item->addinB_len);
3732 if (HAS_PREFIX(keyword, "EntropyPredictionResistanceA."))
3733 return parse_bin(value, &item->pr_entropyA, &item->pr_entropyA_len);
3734 if (HAS_PREFIX(keyword, "EntropyPredictionResistanceB."))
3735 return parse_bin(value, &item->pr_entropyB, &item->pr_entropyB_len);
3736 if (HAS_PREFIX(keyword, "Output."))
3737 return parse_bin(value, &item->output, &item->output_len);
3738 } else {
3739 if (strcmp(keyword, "Cipher") == 0)
3740 return TEST_ptr(rdata->cipher = OPENSSL_strdup(value));
3741 if (strcmp(keyword, "Digest") == 0)
3742 return TEST_ptr(rdata->digest = OPENSSL_strdup(value));
3743 if (strcmp(keyword, "DerivationFunction") == 0) {
3744 rdata->use_df = atoi(value) != 0;
3745 return 1;
3746 }
3747 if (strcmp(keyword, "GenerateBits") == 0) {
3748 if ((n = atoi(value)) <= 0 || n % 8 != 0)
3749 return 0;
3750 rdata->generate_bits = (unsigned int)n;
3751 return 1;
3752 }
3753 if (strcmp(keyword, "PredictionResistance") == 0) {
3754 rdata->prediction_resistance = atoi(value) != 0;
3755 return 1;
3756 }
3757 if (strcmp(keyword, "CtrlInit") == 0)
3758 return ctrladd(rdata->init_controls, value);
3759 }
3760 return 0;
3761 }
3762
rand_test_run(EVP_TEST * t)3763 static int rand_test_run(EVP_TEST *t)
3764 {
3765 RAND_DATA *expected = t->data;
3766 RAND_DATA_PASS *item;
3767 unsigned char *got;
3768 size_t got_len = expected->generate_bits / 8;
3769 OSSL_PARAM params[8], *p = params;
3770 int i = -1, ret = 0;
3771 unsigned int strength;
3772 unsigned char *z;
3773 size_t params_n = 0, params_allocated_n = 0;
3774
3775 if (!TEST_ptr(got = OPENSSL_malloc(got_len)))
3776 return 0;
3777
3778 if (sk_OPENSSL_STRING_num(expected->init_controls) > 0) {
3779 if (!ctrl2params(t, expected->init_controls,
3780 NULL,
3781 params, OSSL_NELEM(params), ¶ms_n))
3782 goto err;
3783 }
3784 p = params + params_n;
3785
3786 *p++ = OSSL_PARAM_construct_int(OSSL_DRBG_PARAM_USE_DF, &expected->use_df);
3787 if (expected->cipher != NULL)
3788 *p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_CIPHER,
3789 expected->cipher, 0);
3790 if (expected->digest != NULL)
3791 *p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_DIGEST,
3792 expected->digest, 0);
3793 *p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_MAC, "HMAC", 0);
3794 *p = OSSL_PARAM_construct_end();
3795 if (!EVP_RAND_CTX_set_params(expected->ctx, params)) {
3796 if (t->expect_unapproved == 0) {
3797 t->err = "EVP_RAND_CTX_set_params";
3798 ret = 1;
3799 }
3800 goto err;
3801 }
3802 ctrl2params_free(params, params_n, params_allocated_n);
3803 params_n = 0;
3804
3805 strength = EVP_RAND_get_strength(expected->ctx);
3806 for (i = 0; i <= expected->n; i++) {
3807 item = expected->data + i;
3808
3809 p = params;
3810 z = item->entropy != NULL ? item->entropy : (unsigned char *)"";
3811 *p++ = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY,
3812 z, item->entropy_len);
3813 z = item->nonce != NULL ? item->nonce : (unsigned char *)"";
3814 *p++ = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_NONCE,
3815 z, item->nonce_len);
3816 *p = OSSL_PARAM_construct_end();
3817 if (!TEST_true(EVP_RAND_instantiate(expected->parent, strength,
3818 0, NULL, 0, params)))
3819 goto err;
3820
3821 z = item->pers != NULL ? item->pers : (unsigned char *)"";
3822 if (!TEST_true(EVP_RAND_instantiate(expected->ctx, strength,
3823 expected->prediction_resistance, z,
3824 item->pers_len, NULL)))
3825 goto err;
3826
3827 if (item->reseed_entropy != NULL) {
3828 params[0] = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, item->reseed_entropy,
3829 item->reseed_entropy_len);
3830 params[1] = OSSL_PARAM_construct_end();
3831 if (!TEST_true(EVP_RAND_CTX_set_params(expected->parent, params)))
3832 goto err;
3833
3834 if (!TEST_true(EVP_RAND_reseed(expected->ctx, expected->prediction_resistance,
3835 NULL, 0, item->reseed_addin,
3836 item->reseed_addin_len)))
3837 goto err;
3838 }
3839 if (item->pr_entropyA != NULL) {
3840 params[0] = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, item->pr_entropyA,
3841 item->pr_entropyA_len);
3842 params[1] = OSSL_PARAM_construct_end();
3843 if (!TEST_true(EVP_RAND_CTX_set_params(expected->parent, params)))
3844 goto err;
3845 }
3846 if (!TEST_true(EVP_RAND_generate(expected->ctx, got, got_len,
3847 strength, expected->prediction_resistance,
3848 item->addinA, item->addinA_len)))
3849 goto err;
3850
3851 if (item->pr_entropyB != NULL) {
3852 params[0] = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, item->pr_entropyB,
3853 item->pr_entropyB_len);
3854 params[1] = OSSL_PARAM_construct_end();
3855 if (!TEST_true(EVP_RAND_CTX_set_params(expected->parent, params)))
3856 goto err;
3857 }
3858 if (!TEST_true(EVP_RAND_generate(expected->ctx, got, got_len,
3859 strength, expected->prediction_resistance,
3860 item->addinB, item->addinB_len)))
3861 goto err;
3862 if (!TEST_mem_eq(got, got_len, item->output, item->output_len))
3863 goto err;
3864 if (!rand_check_fips_approved(expected->ctx, t))
3865 goto err;
3866 if (!TEST_true(EVP_RAND_uninstantiate(expected->ctx))
3867 || !TEST_true(EVP_RAND_uninstantiate(expected->parent))
3868 || !TEST_true(EVP_RAND_verify_zeroization(expected->ctx))
3869 || !TEST_int_eq(EVP_RAND_get_state(expected->ctx),
3870 EVP_RAND_STATE_UNINITIALISED))
3871 goto err;
3872 }
3873 t->err = NULL;
3874 ret = 1;
3875
3876 err:
3877 if (ret == 0 && i >= 0)
3878 TEST_info("Error in test case %d of %d\n", i, expected->n + 1);
3879 OPENSSL_free(got);
3880 ctrl2params_free(params, params_n, params_allocated_n);
3881 return ret;
3882 }
3883
3884 static const EVP_TEST_METHOD rand_test_method = {
3885 "RAND",
3886 rand_test_init,
3887 rand_test_cleanup,
3888 rand_test_parse,
3889 rand_test_run
3890 };
3891
3892 /**
3893 ** KDF TESTS
3894 **/
3895 typedef struct kdf_data_st {
3896 /* Context for this operation */
3897 EVP_KDF_CTX *ctx;
3898 /* Expected output */
3899 unsigned char *output;
3900 size_t output_len;
3901 OSSL_PARAM params[20];
3902 OSSL_PARAM *p;
3903 STACK_OF(OPENSSL_STRING) *init_controls; /* collection of controls */
3904 } KDF_DATA;
3905
3906 /*
3907 * Perform public key operation setup: lookup key, allocated ctx and call
3908 * the appropriate initialisation function
3909 */
kdf_test_init(EVP_TEST * t,const char * name)3910 static int kdf_test_init(EVP_TEST *t, const char *name)
3911 {
3912 KDF_DATA *kdata;
3913 EVP_KDF *kdf;
3914
3915 if (is_kdf_disabled(name)) {
3916 TEST_info("skipping, '%s' is disabled", name);
3917 t->skip = 1;
3918 return 1;
3919 }
3920
3921 if (!TEST_ptr(kdata = OPENSSL_zalloc(sizeof(*kdata))))
3922 return 0;
3923 kdata->p = kdata->params;
3924 *kdata->p = OSSL_PARAM_construct_end();
3925
3926 kdf = EVP_KDF_fetch(libctx, name, propquery);
3927 if (kdf == NULL) {
3928 OPENSSL_free(kdata);
3929 return 0;
3930 }
3931 kdata->ctx = EVP_KDF_CTX_new(kdf);
3932 EVP_KDF_free(kdf);
3933 if (kdata->ctx == NULL) {
3934 OPENSSL_free(kdata);
3935 return 0;
3936 }
3937 t->data = kdata;
3938 kdata->init_controls = sk_OPENSSL_STRING_new_null();
3939 return 1;
3940 }
3941
kdf_test_cleanup(EVP_TEST * t)3942 static void kdf_test_cleanup(EVP_TEST *t)
3943 {
3944 KDF_DATA *kdata = t->data;
3945 OSSL_PARAM *p;
3946
3947 ctrlfree(kdata->init_controls);
3948 for (p = kdata->params; p->key != NULL; p++)
3949 OPENSSL_free(p->data);
3950 OPENSSL_free(kdata->output);
3951 EVP_KDF_CTX_free(kdata->ctx);
3952 }
3953
kdf_test_ctrl(EVP_TEST * t,EVP_KDF_CTX * kctx,const char * value)3954 static int kdf_test_ctrl(EVP_TEST *t, EVP_KDF_CTX *kctx,
3955 const char *value)
3956 {
3957 KDF_DATA *kdata = t->data;
3958 int rv;
3959 char *p, *name;
3960 const OSSL_PARAM *defs = EVP_KDF_settable_ctx_params(EVP_KDF_CTX_kdf(kctx));
3961
3962 if (!TEST_ptr(name = OPENSSL_strdup(value)))
3963 return 0;
3964 p = strchr(name, ':');
3965 if (p == NULL)
3966 p = "";
3967 else
3968 *p++ = '\0';
3969
3970 if (strcmp(name, "r") == 0
3971 && OSSL_PARAM_locate_const(defs, name) == NULL) {
3972 TEST_info("skipping, setting 'r' is unsupported");
3973 t->skip = 1;
3974 goto end;
3975 }
3976
3977 if (strcmp(name, "lanes") == 0
3978 && OSSL_PARAM_locate_const(defs, name) == NULL) {
3979 TEST_info("skipping, setting 'lanes' is unsupported");
3980 t->skip = 1;
3981 goto end;
3982 }
3983
3984 if (strcmp(name, "iter") == 0
3985 && OSSL_PARAM_locate_const(defs, name) == NULL) {
3986 TEST_info("skipping, setting 'iter' is unsupported");
3987 t->skip = 1;
3988 goto end;
3989 }
3990
3991 if (strcmp(name, "memcost") == 0
3992 && OSSL_PARAM_locate_const(defs, name) == NULL) {
3993 TEST_info("skipping, setting 'memcost' is unsupported");
3994 t->skip = 1;
3995 goto end;
3996 }
3997
3998 if (strcmp(name, "secret") == 0
3999 && OSSL_PARAM_locate_const(defs, name) == NULL) {
4000 TEST_info("skipping, setting 'secret' is unsupported");
4001 t->skip = 1;
4002 goto end;
4003 }
4004
4005 if (strcmp(name, "pass") == 0
4006 && OSSL_PARAM_locate_const(defs, name) == NULL) {
4007 TEST_info("skipping, setting 'pass' is unsupported");
4008 t->skip = 1;
4009 goto end;
4010 }
4011
4012 if (strcmp(name, "ad") == 0
4013 && OSSL_PARAM_locate_const(defs, name) == NULL) {
4014 TEST_info("skipping, setting 'ad' is unsupported");
4015 t->skip = 1;
4016 goto end;
4017 }
4018
4019 rv = OSSL_PARAM_allocate_from_text(kdata->p, defs, name, p,
4020 strlen(p), NULL);
4021 *++kdata->p = OSSL_PARAM_construct_end();
4022 if (!rv) {
4023 t->err = "KDF_PARAM_ERROR";
4024 OPENSSL_free(name);
4025 return 0;
4026 }
4027 if (strcmp(name, "digest") == 0) {
4028 if (is_digest_disabled(p)) {
4029 TEST_info("skipping, '%s' is disabled", p);
4030 t->skip = 1;
4031 }
4032 goto end;
4033 }
4034
4035 if ((strcmp(name, "cipher") == 0
4036 || strcmp(name, "cekalg") == 0)
4037 && is_cipher_disabled(p)) {
4038 TEST_info("skipping, '%s' is disabled", p);
4039 t->skip = 1;
4040 goto end;
4041 }
4042 if ((strcmp(name, "mac") == 0)
4043 && is_mac_disabled(p)) {
4044 TEST_info("skipping, '%s' is disabled", p);
4045 t->skip = 1;
4046 }
4047 end:
4048 OPENSSL_free(name);
4049 return 1;
4050 }
4051
kdf_test_parse(EVP_TEST * t,const char * keyword,const char * value)4052 static int kdf_test_parse(EVP_TEST *t,
4053 const char *keyword, const char *value)
4054 {
4055 KDF_DATA *kdata = t->data;
4056
4057 if (strcmp(keyword, "Output") == 0)
4058 return parse_bin(value, &kdata->output, &kdata->output_len);
4059 if (strcmp(keyword, "CtrlInit") == 0)
4060 return ctrladd(kdata->init_controls, value);
4061 if (HAS_PREFIX(keyword, "Ctrl"))
4062 return kdf_test_ctrl(t, kdata->ctx, value);
4063 return 0;
4064 }
4065
kdf_test_run(EVP_TEST * t)4066 static int kdf_test_run(EVP_TEST *t)
4067 {
4068 int ret = 1;
4069 KDF_DATA *expected = t->data;
4070 unsigned char *got = NULL;
4071 size_t got_len = expected->output_len;
4072 EVP_KDF_CTX *ctx;
4073 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
4074 size_t params_n = 0, params_allocated_n = 0;
4075
4076 if (sk_OPENSSL_STRING_num(expected->init_controls) > 0) {
4077 if (!ctrl2params(t, expected->init_controls,
4078 NULL,
4079 params, OSSL_NELEM(params), ¶ms_n))
4080 goto err;
4081 if (!EVP_KDF_CTX_set_params(expected->ctx, params)) {
4082 t->err = "KDF_CTRL_ERROR";
4083 goto err;
4084 }
4085 }
4086
4087 if (!EVP_KDF_CTX_set_params(expected->ctx, expected->params)) {
4088 t->err = "KDF_CTRL_ERROR";
4089 goto err;
4090 }
4091 if (!TEST_ptr(got = OPENSSL_malloc(got_len == 0 ? 1 : got_len))) {
4092 t->err = "INTERNAL_ERROR";
4093 goto err;
4094 }
4095 /* FIPS(3.0.0): can't dup KDF contexts #17572 */
4096 if (fips_provider_version_gt(libctx, 3, 0, 0)
4097 && (ctx = EVP_KDF_CTX_dup(expected->ctx)) != NULL) {
4098 EVP_KDF_CTX_free(expected->ctx);
4099 expected->ctx = ctx;
4100 }
4101 if (EVP_KDF_derive(expected->ctx, got, got_len, NULL) <= 0) {
4102 t->err = "KDF_DERIVE_ERROR";
4103 goto err;
4104 }
4105 if (!kdf_check_fips_approved(expected->ctx, t)) {
4106 ret = 0;
4107 goto err;
4108 }
4109 if (!memory_err_compare(t, "KDF_MISMATCH",
4110 expected->output, expected->output_len,
4111 got, got_len))
4112 goto err;
4113
4114 t->err = NULL;
4115
4116 err:
4117 ctrl2params_free(params, params_n, params_allocated_n);
4118 OPENSSL_free(got);
4119 return ret;
4120 }
4121
4122 static const EVP_TEST_METHOD kdf_test_method = {
4123 "KDF",
4124 kdf_test_init,
4125 kdf_test_cleanup,
4126 kdf_test_parse,
4127 kdf_test_run
4128 };
4129
4130 /**
4131 ** PKEY KDF TESTS
4132 **/
4133
4134 typedef struct pkey_kdf_data_st {
4135 /* Context for this operation */
4136 EVP_PKEY_CTX *ctx;
4137 /* Expected output */
4138 unsigned char *output;
4139 size_t output_len;
4140 } PKEY_KDF_DATA;
4141
4142 /*
4143 * Perform public key operation setup: lookup key, allocated ctx and call
4144 * the appropriate initialisation function
4145 */
pkey_kdf_test_init(EVP_TEST * t,const char * name)4146 static int pkey_kdf_test_init(EVP_TEST *t, const char *name)
4147 {
4148 PKEY_KDF_DATA *kdata = NULL;
4149
4150 if (is_kdf_disabled(name)) {
4151 TEST_info("skipping, '%s' is disabled", name);
4152 t->skip = 1;
4153 return 1;
4154 }
4155
4156 if (!TEST_ptr(kdata = OPENSSL_zalloc(sizeof(*kdata))))
4157 return 0;
4158
4159 kdata->ctx = EVP_PKEY_CTX_new_from_name(libctx, name, propquery);
4160 if (kdata->ctx == NULL
4161 || EVP_PKEY_derive_init(kdata->ctx) <= 0)
4162 goto err;
4163
4164 t->data = kdata;
4165 return 1;
4166 err:
4167 EVP_PKEY_CTX_free(kdata->ctx);
4168 OPENSSL_free(kdata);
4169 return 0;
4170 }
4171
pkey_kdf_test_cleanup(EVP_TEST * t)4172 static void pkey_kdf_test_cleanup(EVP_TEST *t)
4173 {
4174 PKEY_KDF_DATA *kdata = t->data;
4175
4176 OPENSSL_free(kdata->output);
4177 EVP_PKEY_CTX_free(kdata->ctx);
4178 }
4179
pkey_kdf_test_parse(EVP_TEST * t,const char * keyword,const char * value)4180 static int pkey_kdf_test_parse(EVP_TEST *t,
4181 const char *keyword, const char *value)
4182 {
4183 PKEY_KDF_DATA *kdata = t->data;
4184
4185 if (strcmp(keyword, "Output") == 0)
4186 return parse_bin(value, &kdata->output, &kdata->output_len);
4187 if (HAS_PREFIX(keyword, "Ctrl"))
4188 return pkey_test_ctrl(t, kdata->ctx, value);
4189 return 0;
4190 }
4191
pkey_kdf_test_run(EVP_TEST * t)4192 static int pkey_kdf_test_run(EVP_TEST *t)
4193 {
4194 int ret = 1;
4195 PKEY_KDF_DATA *expected = t->data;
4196 unsigned char *got = NULL;
4197 size_t got_len = 0;
4198
4199 if (fips_provider_version_eq(libctx, 3, 0, 0)) {
4200 /* FIPS(3.0.0): can't deal with oversized output buffers #18533 */
4201 got_len = expected->output_len;
4202 } else {
4203 /* Find out the KDF output size */
4204 if (EVP_PKEY_derive(expected->ctx, NULL, &got_len) <= 0) {
4205 t->err = "INTERNAL_ERROR";
4206 goto err;
4207 }
4208
4209 /*
4210 * We may get an absurd output size, which signals that anything goes.
4211 * If not, we specify a too big buffer for the output, to test that
4212 * EVP_PKEY_derive() can cope with it.
4213 */
4214 if (got_len == SIZE_MAX || got_len == 0)
4215 got_len = expected->output_len;
4216 else
4217 got_len = expected->output_len * 2;
4218 }
4219
4220 if (!TEST_ptr(got = OPENSSL_malloc(got_len == 0 ? 1 : got_len))) {
4221 t->err = "INTERNAL_ERROR";
4222 goto err;
4223 }
4224 if (EVP_PKEY_derive(expected->ctx, got, &got_len) <= 0) {
4225 t->err = "KDF_DERIVE_ERROR";
4226 goto err;
4227 }
4228 if (!pkey_check_fips_approved(expected->ctx, t)) {
4229 ret = 0;
4230 goto err;
4231 }
4232 if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
4233 t->err = "KDF_MISMATCH";
4234 goto err;
4235 }
4236 t->err = NULL;
4237
4238 err:
4239 OPENSSL_free(got);
4240 return ret;
4241 }
4242
4243 static const EVP_TEST_METHOD pkey_kdf_test_method = {
4244 "PKEYKDF",
4245 pkey_kdf_test_init,
4246 pkey_kdf_test_cleanup,
4247 pkey_kdf_test_parse,
4248 pkey_kdf_test_run
4249 };
4250
4251 /**
4252 ** KEYPAIR TESTS
4253 **/
4254
4255 typedef struct keypair_test_data_st {
4256 EVP_PKEY *privk;
4257 EVP_PKEY *pubk;
4258 } KEYPAIR_TEST_DATA;
4259
keypair_test_init(EVP_TEST * t,const char * pair)4260 static int keypair_test_init(EVP_TEST *t, const char *pair)
4261 {
4262 KEYPAIR_TEST_DATA *data;
4263 int rv = 0;
4264 EVP_PKEY *pk = NULL, *pubk = NULL;
4265 char *pub, *priv = NULL;
4266
4267 /* Split private and public names. */
4268 if (!TEST_ptr(priv = OPENSSL_strdup(pair))
4269 || !TEST_ptr(pub = strchr(priv, ':'))) {
4270 t->err = "PARSING_ERROR";
4271 goto end;
4272 }
4273 *pub++ = '\0';
4274
4275 if (!TEST_true(find_key(&pk, priv, private_keys))) {
4276 TEST_info("Can't find private key: %s", priv);
4277 t->err = "MISSING_PRIVATE_KEY";
4278 goto end;
4279 }
4280 if (!TEST_true(find_key(&pubk, pub, public_keys))) {
4281 TEST_info("Can't find public key: %s", pub);
4282 t->err = "MISSING_PUBLIC_KEY";
4283 goto end;
4284 }
4285
4286 if (pk == NULL && pubk == NULL) {
4287 /* Both keys are listed but unsupported: skip this test */
4288 t->skip = 1;
4289 rv = 1;
4290 goto end;
4291 }
4292
4293 if (!TEST_ptr(data = OPENSSL_malloc(sizeof(*data))))
4294 goto end;
4295 data->privk = pk;
4296 data->pubk = pubk;
4297 t->data = data;
4298 rv = 1;
4299 t->err = NULL;
4300
4301 end:
4302 OPENSSL_free(priv);
4303 return rv;
4304 }
4305
keypair_test_cleanup(EVP_TEST * t)4306 static void keypair_test_cleanup(EVP_TEST *t)
4307 {
4308 OPENSSL_free(t->data);
4309 t->data = NULL;
4310 }
4311
4312 /*
4313 * For tests that do not accept any custom keywords.
4314 */
void_test_parse(EVP_TEST * t,const char * keyword,const char * value)4315 static int void_test_parse(EVP_TEST *t, const char *keyword, const char *value)
4316 {
4317 return 0;
4318 }
4319
keypair_test_run(EVP_TEST * t)4320 static int keypair_test_run(EVP_TEST *t)
4321 {
4322 int rv = 0;
4323 const KEYPAIR_TEST_DATA *pair = t->data;
4324
4325 if (pair->privk == NULL || pair->pubk == NULL) {
4326 /*
4327 * this can only happen if only one of the keys is not set
4328 * which means that one of them was unsupported while the
4329 * other isn't: hence a key type mismatch.
4330 */
4331 t->err = "KEYPAIR_TYPE_MISMATCH";
4332 rv = 1;
4333 goto end;
4334 }
4335
4336 if ((rv = EVP_PKEY_eq(pair->privk, pair->pubk)) != 1) {
4337 if (0 == rv) {
4338 t->err = "KEYPAIR_MISMATCH";
4339 } else if (-1 == rv) {
4340 t->err = "KEYPAIR_TYPE_MISMATCH";
4341 } else if (-2 == rv) {
4342 t->err = "UNSUPPORTED_KEY_COMPARISON";
4343 } else {
4344 TEST_error("Unexpected error in key comparison");
4345 rv = 0;
4346 goto end;
4347 }
4348 rv = 1;
4349 goto end;
4350 }
4351
4352 rv = 1;
4353 t->err = NULL;
4354
4355 end:
4356 return rv;
4357 }
4358
4359 static const EVP_TEST_METHOD keypair_test_method = {
4360 "PrivPubKeyPair",
4361 keypair_test_init,
4362 keypair_test_cleanup,
4363 void_test_parse,
4364 keypair_test_run
4365 };
4366
4367 /**
4368 ** KEYGEN TEST
4369 **/
4370
4371 typedef struct keygen_test_data_st {
4372 char *keyname; /* Key name to store key or NULL */
4373 char *paramname;
4374 char *alg;
4375 STACK_OF(OPENSSL_STRING) *in_controls; /* Collection of controls */
4376 STACK_OF(OPENSSL_STRING) *out_controls;
4377 } KEYGEN_TEST_DATA;
4378
keygen_test_init(EVP_TEST * t,const char * alg)4379 static int keygen_test_init(EVP_TEST *t, const char *alg)
4380 {
4381 KEYGEN_TEST_DATA *data;
4382
4383 if (is_pkey_disabled(alg)) {
4384 t->skip = 1;
4385 return 1;
4386 }
4387
4388 if (!TEST_ptr(data = OPENSSL_zalloc(sizeof(*data))))
4389 return 0;
4390 data->keyname = NULL;
4391 data->paramname = NULL;
4392 data->in_controls = sk_OPENSSL_STRING_new_null();
4393 data->out_controls = sk_OPENSSL_STRING_new_null();
4394 data->alg = OPENSSL_strdup(alg);
4395 t->data = data;
4396 t->err = NULL;
4397 return 1;
4398 }
4399
keygen_test_cleanup(EVP_TEST * t)4400 static void keygen_test_cleanup(EVP_TEST *t)
4401 {
4402 KEYGEN_TEST_DATA *keygen = t->data;
4403
4404 ctrlfree(keygen->in_controls);
4405 ctrlfree(keygen->out_controls);
4406 OPENSSL_free(keygen->alg);
4407 OPENSSL_free(keygen->keyname);
4408 OPENSSL_free(keygen->paramname);
4409 OPENSSL_free(t->data);
4410 t->data = NULL;
4411 }
4412
keygen_test_parse(EVP_TEST * t,const char * keyword,const char * value)4413 static int keygen_test_parse(EVP_TEST *t,
4414 const char *keyword, const char *value)
4415 {
4416 KEYGEN_TEST_DATA *keygen = t->data;
4417
4418 if (strcmp(keyword, "KeyName") == 0)
4419 return TEST_ptr(keygen->keyname = OPENSSL_strdup(value));
4420 if (strcmp(keyword, "KeyParam") == 0)
4421 return TEST_ptr(keygen->paramname = OPENSSL_strdup(value));
4422 if (strcmp(keyword, "Ctrl") == 0)
4423 return ctrladd(keygen->in_controls, value);
4424 if (strcmp(keyword, "CtrlOut") == 0)
4425 return ctrladd(keygen->out_controls, value);
4426 return 0;
4427 }
4428
4429 /* Iterate thru the key's expected values */
check_pkey_expected_values(EVP_TEST * t,const EVP_PKEY * pkey,STACK_OF (OPENSSL_STRING)* out_controls)4430 static int check_pkey_expected_values(EVP_TEST *t, const EVP_PKEY *pkey,
4431 STACK_OF(OPENSSL_STRING) *out_controls)
4432 {
4433 int ret = 0;
4434 OSSL_PARAM out_params[4], *p;
4435 size_t out_params_n = 0, len;
4436
4437 if (sk_OPENSSL_STRING_num(out_controls) > 0) {
4438
4439 if (!ctrl2params(t, out_controls,
4440 EVP_PKEY_gettable_params(pkey),
4441 out_params, OSSL_NELEM(out_params), &out_params_n))
4442 goto err;
4443 for (p = out_params; p->key != NULL; ++p) {
4444 if (p->data_type == OSSL_PARAM_OCTET_STRING) {
4445 uint8_t *data = OPENSSL_malloc(p->data_size);
4446
4447 if (data == NULL)
4448 goto err;
4449 ret = EVP_PKEY_get_octet_string_param(pkey, p->key, data,
4450 p->data_size, &len)
4451 && len == p->data_size
4452 && (TEST_mem_eq(p->data, len, data, len) == 1);
4453 OPENSSL_free(data);
4454 if (ret == 0) {
4455 TEST_error("Expected %s value is incorrect", p->key);
4456 goto err;
4457 }
4458 }
4459 }
4460 }
4461 ret = 1;
4462 err:
4463 ctrl2params_free(out_params, out_params_n, 0);
4464 return ret;
4465 }
4466
keygen_test_run(EVP_TEST * t)4467 static int keygen_test_run(EVP_TEST *t)
4468 {
4469 KEYGEN_TEST_DATA *keygen = t->data;
4470 EVP_PKEY *pkey = NULL, *keyparams = NULL;
4471 EVP_PKEY_CTX *genctx = NULL; /* Keygen context to use */
4472 int rv = 1;
4473 OSSL_PARAM_BLD *bld = NULL;
4474 OSSL_PARAM *params = NULL;
4475 size_t params_n = 0;
4476 int key_free = 1;
4477
4478 if (keygen->paramname != NULL) {
4479 rv = find_key(&keyparams, keygen->paramname, public_keys);
4480 if (rv == 0 || keyparams == NULL) {
4481 TEST_info("skipping, key '%s' is disabled", keygen->paramname);
4482 t->skip = 1;
4483 return 1;
4484 }
4485 if (!TEST_ptr(genctx = EVP_PKEY_CTX_new_from_pkey(libctx, keyparams,
4486 propquery)))
4487 goto err;
4488
4489 } else {
4490 if (!TEST_ptr(genctx = EVP_PKEY_CTX_new_from_name(libctx, keygen->alg,
4491 propquery)))
4492 goto err;
4493 }
4494
4495 if (EVP_PKEY_keygen_init(genctx) <= 0) {
4496 t->err = "KEYGEN_INIT_ERROR";
4497 goto err;
4498 }
4499
4500 if (sk_OPENSSL_STRING_num(keygen->in_controls) > 0) {
4501 if ((params = OPENSSL_malloc(sizeof(OSSL_PARAM) * 4)) == NULL)
4502 goto err;
4503 if (!ctrl2params(t, keygen->in_controls,
4504 EVP_PKEY_CTX_settable_params(genctx),
4505 params, 4, ¶ms_n))
4506 goto err;
4507 if (!EVP_PKEY_CTX_set_params(genctx, params)) {
4508 t->err = "PKEY_CTRL_ERROR";
4509 goto err;
4510 }
4511 }
4512
4513 if (EVP_PKEY_keygen(genctx, &pkey) <= 0) {
4514 t->err = "KEYGEN_GENERATE_ERROR";
4515 goto err;
4516 }
4517
4518 if (!pkey_check_fips_approved(genctx, t)) {
4519 rv = 0;
4520 goto err;
4521 }
4522
4523 if (!evp_pkey_is_provided(pkey)) {
4524 TEST_info("Warning: legacy key generated %s", keygen->keyname);
4525 goto err;
4526 }
4527
4528 if (!check_pkey_expected_values(t, pkey, keygen->out_controls)) {
4529 t->err = "KEYGEN_PKEY_MISMATCH_ERROR";
4530 goto err;
4531 }
4532
4533 if (keygen->keyname != NULL) {
4534 KEY_LIST *key;
4535
4536 rv = 0;
4537 if (find_key(NULL, keygen->keyname, private_keys)) {
4538 TEST_info("Duplicate key %s", keygen->keyname);
4539 goto err;
4540 }
4541
4542 if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key))))
4543 goto err;
4544 key->name = keygen->keyname;
4545 keygen->keyname = NULL;
4546 key->key = pkey;
4547 key->next = private_keys;
4548 private_keys = key;
4549 rv = 1;
4550 key_free = 0;
4551 }
4552
4553 t->err = NULL;
4554 err:
4555 if (key_free) {
4556 EVP_PKEY_free(pkey);
4557 pkey = NULL;
4558 }
4559 EVP_PKEY_CTX_free(genctx);
4560 if (sk_OPENSSL_STRING_num(keygen->in_controls) > 0)
4561 ctrl2params_free(params, params_n, 0);
4562 OSSL_PARAM_free(params);
4563 OSSL_PARAM_BLD_free(bld);
4564 return rv;
4565 }
4566
4567 static const EVP_TEST_METHOD keygen_test_method = {
4568 "KeyGen",
4569 keygen_test_init,
4570 keygen_test_cleanup,
4571 keygen_test_parse,
4572 keygen_test_run,
4573 };
4574
4575 /**
4576 ** DIGEST SIGN+VERIFY TESTS
4577 **/
4578
4579 typedef struct {
4580 int is_verify; /* Set to 1 if verifying */
4581 int is_oneshot; /* Set to 1 for one shot operation */
4582 const EVP_MD *md; /* Digest to use */
4583 EVP_MD_CTX *ctx; /* Digest context */
4584 EVP_PKEY_CTX *pctx;
4585 STACK_OF(EVP_TEST_BUFFER) *input; /* Input data: streaming */
4586 unsigned char *osin; /* Input data if one shot */
4587 size_t osin_len; /* Input length data if one shot */
4588 unsigned char *output; /* Expected output */
4589 size_t output_len; /* Expected output length */
4590 int deterministic_noncetype;
4591 EVP_PKEY *key;
4592 STACK_OF(OPENSSL_STRING) *init_controls; /* collection of controls */
4593 STACK_OF(OPENSSL_STRING) *controls; /* Collection of controls */
4594 } DIGESTSIGN_DATA;
4595
digestsigver_test_init(EVP_TEST * t,const char * alg,int is_verify,int is_oneshot)4596 static int digestsigver_test_init(EVP_TEST *t, const char *alg, int is_verify,
4597 int is_oneshot)
4598 {
4599 const EVP_MD *md = NULL;
4600 DIGESTSIGN_DATA *mdat;
4601
4602 if (strcmp(alg, "NULL") != 0) {
4603 if (is_digest_disabled(alg)) {
4604 t->skip = 1;
4605 return 1;
4606 }
4607 md = EVP_get_digestbyname(alg);
4608 if (md == NULL)
4609 return 0;
4610 }
4611 if (!TEST_ptr(mdat = OPENSSL_zalloc(sizeof(*mdat))))
4612 return 0;
4613 mdat->init_controls = sk_OPENSSL_STRING_new_null();
4614 mdat->controls = sk_OPENSSL_STRING_new_null();
4615 mdat->md = md;
4616 if (!TEST_ptr(mdat->ctx = EVP_MD_CTX_new())) {
4617 OPENSSL_free(mdat);
4618 return 0;
4619 }
4620 mdat->is_verify = is_verify;
4621 mdat->is_oneshot = is_oneshot;
4622 t->data = mdat;
4623 return 1;
4624 }
4625
digestsign_test_init(EVP_TEST * t,const char * alg)4626 static int digestsign_test_init(EVP_TEST *t, const char *alg)
4627 {
4628 return digestsigver_test_init(t, alg, 0, 0);
4629 }
4630
digestsigver_test_cleanup(EVP_TEST * t)4631 static void digestsigver_test_cleanup(EVP_TEST *t)
4632 {
4633 DIGESTSIGN_DATA *mdata = t->data;
4634
4635 ctrlfree(mdata->init_controls);
4636 ctrlfree(mdata->controls);
4637 EVP_MD_CTX_free(mdata->ctx);
4638 sk_EVP_TEST_BUFFER_pop_free(mdata->input, evp_test_buffer_free);
4639 OPENSSL_free(mdata->osin);
4640 OPENSSL_free(mdata->output);
4641 OPENSSL_free(mdata);
4642 t->data = NULL;
4643 }
4644
digestsigver_test_parse(EVP_TEST * t,const char * keyword,const char * value)4645 static int digestsigver_test_parse(EVP_TEST *t,
4646 const char *keyword, const char *value)
4647 {
4648 DIGESTSIGN_DATA *mdata = t->data;
4649
4650 if (strcmp(keyword, "Key") == 0) {
4651 EVP_PKEY *pkey = NULL;
4652 int rv = 0;
4653
4654 if (mdata->is_verify)
4655 rv = find_key(&pkey, value, public_keys);
4656 if (rv == 0)
4657 rv = find_key(&pkey, value, private_keys);
4658 if (rv == 0 || pkey == NULL) {
4659 t->skip = 1;
4660 return 1;
4661 }
4662 mdata->key = pkey;
4663 return 1;
4664 }
4665
4666 if (strcmp(keyword, "Input") == 0) {
4667 if (mdata->is_oneshot)
4668 return parse_bin(value, &mdata->osin, &mdata->osin_len);
4669 return evp_test_buffer_append(value, data_chunk_size, &mdata->input);
4670 }
4671 if (strcmp(keyword, "Output") == 0)
4672 return parse_bin(value, &mdata->output, &mdata->output_len);
4673
4674 if (!mdata->is_oneshot && data_chunk_size == 0) {
4675 if (strcmp(keyword, "Count") == 0)
4676 return evp_test_buffer_set_count(value, mdata->input);
4677 if (strcmp(keyword, "Ncopy") == 0)
4678 return evp_test_buffer_ncopy(value, mdata->input);
4679 }
4680 if (strcmp(keyword, "Ctrl") == 0)
4681 return pkey_add_control(t, mdata->controls, value);
4682 if (strcmp(keyword, "CtrlInit") == 0)
4683 return ctrladd(mdata->init_controls, value);
4684 if (strcmp(keyword, "NonceType") == 0) {
4685 if (strcmp(value, "deterministic") == 0)
4686 mdata->deterministic_noncetype = 1;
4687 return 1;
4688 }
4689 return 0;
4690 }
4691
check_deterministic_noncetype(EVP_TEST * t,DIGESTSIGN_DATA * mdata)4692 static int check_deterministic_noncetype(EVP_TEST *t,
4693 DIGESTSIGN_DATA *mdata)
4694 {
4695 if (mdata->deterministic_noncetype == 1) {
4696 OSSL_PARAM params[2];
4697 unsigned int nonce_type = 1;
4698
4699 params[0] = OSSL_PARAM_construct_uint(OSSL_SIGNATURE_PARAM_NONCE_TYPE,
4700 &nonce_type);
4701 params[1] = OSSL_PARAM_construct_end();
4702 if (!EVP_PKEY_CTX_set_params(mdata->pctx, params))
4703 t->err = "EVP_PKEY_CTX_set_params_ERROR";
4704 else if (!EVP_PKEY_CTX_get_params(mdata->pctx, params))
4705 t->err = "EVP_PKEY_CTX_get_params_ERROR";
4706 else if (!OSSL_PARAM_modified(¶ms[0]))
4707 t->err = "nonce_type_not_modified_ERROR";
4708 else if (nonce_type != 1)
4709 t->err = "nonce_type_value_ERROR";
4710 }
4711 return t->err == NULL;
4712 }
4713
signverify_init(EVP_TEST * t,DIGESTSIGN_DATA * data)4714 static int signverify_init(EVP_TEST *t, DIGESTSIGN_DATA *data)
4715 {
4716 const char *name = data->md == NULL ? NULL : EVP_MD_get0_name(data->md);
4717 OSSL_PARAM params[5];
4718 OSSL_PARAM *p = NULL;
4719 int i, ret = 0;
4720 size_t params_n = 0, params_allocated_n = 0;
4721
4722 if (sk_OPENSSL_STRING_num(data->init_controls) > 0) {
4723 if (!ctrl2params(t, data->init_controls,
4724 NULL,
4725 params, OSSL_NELEM(params), ¶ms_n))
4726 goto err;
4727 p = params;
4728 }
4729
4730 if (data->is_verify) {
4731 if (!EVP_DigestVerifyInit_ex(data->ctx, &data->pctx, name, libctx,
4732 NULL, data->key, p)) {
4733 t->err = "DIGESTVERIFYINIT_ERROR";
4734 goto err;
4735 }
4736 } else {
4737 if (!EVP_DigestSignInit_ex(data->ctx, &data->pctx, name, libctx, NULL,
4738 data->key, p)) {
4739 t->err = "DIGESTSIGNINIT_ERROR";
4740 goto err;
4741 }
4742 }
4743
4744 for (i = 0; i < sk_OPENSSL_STRING_num(data->controls); i++) {
4745 char *value = sk_OPENSSL_STRING_value(data->controls, i);
4746
4747 if (!pkey_test_ctrl(t, data->pctx, value) || t->err != NULL)
4748 goto err;
4749 }
4750 ret = 1;
4751 err:
4752 ctrl2params_free(params, params_n, params_allocated_n);
4753 return ret;
4754 }
4755
digestsign_update_fn(void * ctx,const unsigned char * buf,size_t buflen)4756 static int digestsign_update_fn(void *ctx, const unsigned char *buf,
4757 size_t buflen)
4758 {
4759 return EVP_DigestSignUpdate(ctx, buf, buflen);
4760 }
4761
digestsign_test_run(EVP_TEST * t)4762 static int digestsign_test_run(EVP_TEST *t)
4763 {
4764 int i;
4765 DIGESTSIGN_DATA *expected = t->data;
4766 unsigned char *got = NULL;
4767 size_t got_len;
4768
4769 if (!signverify_init(t, expected))
4770 goto err;
4771 if (!check_deterministic_noncetype(t, expected))
4772 goto err;
4773
4774 for (i = 0; i < sk_OPENSSL_STRING_num(expected->controls); i++) {
4775 char *value = sk_OPENSSL_STRING_value(expected->controls, i);
4776 if (!pkey_test_ctrl(t, expected->pctx, value) || t->err != NULL)
4777 return 0;
4778 }
4779
4780 if (!evp_test_buffer_do(expected->input, digestsign_update_fn,
4781 expected->ctx)) {
4782 t->err = "DIGESTUPDATE_ERROR";
4783 goto err;
4784 }
4785
4786 if (!EVP_DigestSignFinal(expected->ctx, NULL, &got_len)) {
4787 t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";
4788 goto err;
4789 }
4790 if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
4791 t->err = "MALLOC_FAILURE";
4792 goto err;
4793 }
4794 got_len *= 2;
4795 if (!EVP_DigestSignFinal(expected->ctx, got, &got_len)) {
4796 t->err = "DIGESTSIGNFINAL_ERROR";
4797 goto err;
4798 }
4799 if (!memory_err_compare(t, "SIGNATURE_MISMATCH",
4800 expected->output, expected->output_len,
4801 got, got_len))
4802 goto err;
4803
4804 if (!pkey_check_fips_approved(expected->pctx, t)) {
4805 t->err = "FIPS_INDICATOR_ERROR";
4806 goto err;
4807 }
4808
4809 t->err = NULL;
4810 err:
4811 OPENSSL_free(got);
4812 return 1;
4813 }
4814
4815 static const EVP_TEST_METHOD digestsign_test_method = {
4816 "DigestSign",
4817 digestsign_test_init,
4818 digestsigver_test_cleanup,
4819 digestsigver_test_parse,
4820 digestsign_test_run
4821 };
4822
digestverify_test_init(EVP_TEST * t,const char * alg)4823 static int digestverify_test_init(EVP_TEST *t, const char *alg)
4824 {
4825 return digestsigver_test_init(t, alg, 1, 0);
4826 }
4827
digestverify_update_fn(void * ctx,const unsigned char * buf,size_t buflen)4828 static int digestverify_update_fn(void *ctx, const unsigned char *buf,
4829 size_t buflen)
4830 {
4831 return EVP_DigestVerifyUpdate(ctx, buf, buflen);
4832 }
4833
digestverify_test_run(EVP_TEST * t)4834 static int digestverify_test_run(EVP_TEST *t)
4835 {
4836 DIGESTSIGN_DATA *mdata = t->data;
4837
4838 if (!signverify_init(t, mdata))
4839 return 1;
4840
4841 if (!evp_test_buffer_do(mdata->input, digestverify_update_fn, mdata->ctx)) {
4842 t->err = "DIGESTUPDATE_ERROR";
4843 return 1;
4844 }
4845
4846 if (EVP_DigestVerifyFinal(mdata->ctx, mdata->output,
4847 mdata->output_len)
4848 <= 0)
4849 t->err = "VERIFY_ERROR";
4850 else if (!pkey_check_fips_approved(mdata->pctx, t))
4851 return 0;
4852 return 1;
4853 }
4854
4855 static const EVP_TEST_METHOD digestverify_test_method = {
4856 "DigestVerify",
4857 digestverify_test_init,
4858 digestsigver_test_cleanup,
4859 digestsigver_test_parse,
4860 digestverify_test_run
4861 };
4862
oneshot_digestsign_test_init(EVP_TEST * t,const char * alg)4863 static int oneshot_digestsign_test_init(EVP_TEST *t, const char *alg)
4864 {
4865 return digestsigver_test_init(t, alg, 0, 1);
4866 }
4867
oneshot_digestsign_test_run(EVP_TEST * t)4868 static int oneshot_digestsign_test_run(EVP_TEST *t)
4869 {
4870 DIGESTSIGN_DATA *expected = t->data;
4871 unsigned char *got = NULL;
4872 size_t got_len;
4873
4874 if (!signverify_init(t, expected))
4875 goto err;
4876
4877 if (!EVP_DigestSign(expected->ctx, NULL, &got_len,
4878 expected->osin, expected->osin_len)) {
4879 t->err = "DIGESTSIGN_LENGTH_ERROR";
4880 goto err;
4881 }
4882 if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
4883 t->err = "MALLOC_FAILURE";
4884 goto err;
4885 }
4886 got_len *= 2;
4887 if (!EVP_DigestSign(expected->ctx, got, &got_len,
4888 expected->osin, expected->osin_len)) {
4889 t->err = "DIGESTSIGN_ERROR";
4890 goto err;
4891 }
4892 if (!memory_err_compare(t, "SIGNATURE_MISMATCH",
4893 expected->output, expected->output_len,
4894 got, got_len))
4895 goto err;
4896
4897 if (!pkey_check_fips_approved(expected->pctx, t)) {
4898 t->err = "FIPS_INDICATOR_ERROR";
4899 goto err;
4900 }
4901
4902 t->err = NULL;
4903 err:
4904 OPENSSL_free(got);
4905 return 1;
4906 }
4907
4908 static const EVP_TEST_METHOD oneshot_digestsign_test_method = {
4909 "OneShotDigestSign",
4910 oneshot_digestsign_test_init,
4911 digestsigver_test_cleanup,
4912 digestsigver_test_parse,
4913 oneshot_digestsign_test_run
4914 };
4915
oneshot_digestverify_test_init(EVP_TEST * t,const char * alg)4916 static int oneshot_digestverify_test_init(EVP_TEST *t, const char *alg)
4917 {
4918 return digestsigver_test_init(t, alg, 1, 1);
4919 }
4920
oneshot_digestverify_test_run(EVP_TEST * t)4921 static int oneshot_digestverify_test_run(EVP_TEST *t)
4922 {
4923 DIGESTSIGN_DATA *mdata = t->data;
4924
4925 if (!signverify_init(t, mdata))
4926 return 1;
4927
4928 if (EVP_DigestVerify(mdata->ctx, mdata->output, mdata->output_len,
4929 mdata->osin, mdata->osin_len)
4930 <= 0)
4931 t->err = "VERIFY_ERROR";
4932 else if (!pkey_check_fips_approved(mdata->pctx, t))
4933 return 0;
4934 return 1;
4935 }
4936
4937 static const EVP_TEST_METHOD oneshot_digestverify_test_method = {
4938 "OneShotDigestVerify",
4939 oneshot_digestverify_test_init,
4940 digestsigver_test_cleanup,
4941 digestsigver_test_parse,
4942 oneshot_digestverify_test_run
4943 };
4944
4945 /**
4946 ** PARSING AND DISPATCH
4947 **/
4948
4949 static const EVP_TEST_METHOD *evp_test_list[] = {
4950 &rand_test_method,
4951 &cipher_test_method,
4952 &digest_test_method,
4953 &digestsign_test_method,
4954 &digestverify_test_method,
4955 &encode_test_method,
4956 &kdf_test_method,
4957 &pkey_kdf_test_method,
4958 &keypair_test_method,
4959 &keygen_test_method,
4960 &mac_test_method,
4961 &oneshot_digestsign_test_method,
4962 &oneshot_digestverify_test_method,
4963 &pbe_test_method,
4964 &pdecrypt_test_method,
4965 &pderive_test_method,
4966 &psign_test_method,
4967 &psign_message_test_method,
4968 &pverify_recover_test_method,
4969 &pverify_test_method,
4970 &pverify_message_test_method,
4971 &pverify_message_public_test_method,
4972 &pkey_kem_test_method,
4973 &pkey_fromdata_test_method,
4974 NULL
4975 };
4976
find_test(const char * name)4977 static const EVP_TEST_METHOD *find_test(const char *name)
4978 {
4979 const EVP_TEST_METHOD **tt;
4980
4981 for (tt = evp_test_list; *tt; tt++) {
4982 if (strcmp(name, (*tt)->name) == 0)
4983 return *tt;
4984 }
4985 return NULL;
4986 }
4987
clear_test(EVP_TEST * t)4988 static void clear_test(EVP_TEST *t)
4989 {
4990 test_clearstanza(&t->s);
4991 ERR_clear_error();
4992 if (t->data != NULL) {
4993 if (t->meth != NULL)
4994 t->meth->cleanup(t);
4995 OPENSSL_free(t->data);
4996 t->data = NULL;
4997 }
4998 OPENSSL_free(t->expected_err);
4999 t->expected_err = NULL;
5000 OPENSSL_free(t->reason);
5001 t->reason = NULL;
5002
5003 /* Text literal. */
5004 t->err = NULL;
5005 t->skip = 0;
5006 t->meth = NULL;
5007 t->expect_unapproved = 0;
5008 t->expect_unapproved_callback = 0;
5009
5010 #if !defined(OPENSSL_NO_DEFAULT_THREAD_POOL)
5011 OSSL_set_max_threads(libctx, 0);
5012 #endif
5013 }
5014
5015 /* Check for errors in the test structure; return 1 if okay, else 0. */
check_test_error(EVP_TEST * t)5016 static int check_test_error(EVP_TEST *t)
5017 {
5018 unsigned long err;
5019 const char *reason;
5020
5021 if (t->err == NULL && t->expected_err == NULL)
5022 return 1;
5023 if (t->err != NULL && t->expected_err == NULL) {
5024 if (t->aux_err != NULL) {
5025 TEST_info("%s:%d: Source of above error (%s); unexpected error %s",
5026 t->s.test_file, t->s.start, t->aux_err, t->err);
5027 } else {
5028 TEST_info("%s:%d: Source of above error; unexpected error %s",
5029 t->s.test_file, t->s.start, t->err);
5030 }
5031 return 0;
5032 }
5033 if (t->err == NULL && t->expected_err != NULL) {
5034 TEST_info("%s:%d: Succeeded but was expecting %s",
5035 t->s.test_file, t->s.start, t->expected_err);
5036 return 0;
5037 }
5038
5039 if (strcmp(t->err, t->expected_err) != 0) {
5040 TEST_info("%s:%d: Expected %s got %s",
5041 t->s.test_file, t->s.start, t->expected_err, t->err);
5042 return 0;
5043 }
5044
5045 if (t->reason == NULL)
5046 return 1;
5047
5048 if (t->reason == NULL) {
5049 TEST_info("%s:%d: Test is missing function or reason code",
5050 t->s.test_file, t->s.start);
5051 return 0;
5052 }
5053
5054 err = ERR_peek_error();
5055 if (err == 0) {
5056 TEST_info("%s:%d: Expected error \"%s\" not set",
5057 t->s.test_file, t->s.start, t->reason);
5058 return 0;
5059 }
5060
5061 reason = ERR_reason_error_string(err);
5062 if (reason == NULL) {
5063 TEST_info("%s:%d: Expected error \"%s\", no strings available."
5064 " Assuming ok.",
5065 t->s.test_file, t->s.start, t->reason);
5066 return 1;
5067 }
5068
5069 if (strcmp(reason, t->reason) == 0)
5070 return 1;
5071
5072 TEST_info("%s:%d: Expected error \"%s\", got \"%s\"",
5073 t->s.test_file, t->s.start, t->reason, reason);
5074
5075 return 0;
5076 }
5077
5078 /* Run a parsed test. Log a message and return 0 on error. */
run_test(EVP_TEST * t)5079 static int run_test(EVP_TEST *t)
5080 {
5081 if (t->meth == NULL)
5082 return 1;
5083 t->s.numtests++;
5084 if (t->skip) {
5085 t->s.numskip++;
5086 } else {
5087 /* run the test */
5088 if (t->err == NULL && t->meth->run_test(t) != 1) {
5089 TEST_info("%s:%d %s error",
5090 t->s.test_file, t->s.start, t->meth->name);
5091 return 0;
5092 }
5093 if (!check_test_error(t)) {
5094 TEST_openssl_errors();
5095 t->s.errors++;
5096 }
5097 }
5098
5099 /* clean it up */
5100 return 1;
5101 }
5102
find_key(EVP_PKEY ** ppk,const char * name,KEY_LIST * lst)5103 static int find_key(EVP_PKEY **ppk, const char *name, KEY_LIST *lst)
5104 {
5105 for (; lst != NULL; lst = lst->next) {
5106 if (strcmp(lst->name, name) == 0) {
5107 if (ppk != NULL)
5108 *ppk = lst->key;
5109 return 1;
5110 }
5111 }
5112 return 0;
5113 }
5114
free_key_list(KEY_LIST * lst)5115 static void free_key_list(KEY_LIST *lst)
5116 {
5117 while (lst != NULL) {
5118 KEY_LIST *next = lst->next;
5119
5120 EVP_PKEY_free(lst->key);
5121 OPENSSL_free(lst->name);
5122 OPENSSL_free(lst);
5123 lst = next;
5124 }
5125 }
5126
5127 /*
5128 * Is the key type an unsupported algorithm?
5129 */
key_unsupported(void)5130 static int key_unsupported(void)
5131 {
5132 long err = ERR_peek_last_error();
5133 int lib = ERR_GET_LIB(err);
5134 long reason = ERR_GET_REASON(err);
5135
5136 if ((lib == ERR_LIB_EVP && reason == EVP_R_UNSUPPORTED_ALGORITHM)
5137 || (lib == ERR_LIB_EVP && reason == EVP_R_DECODE_ERROR)
5138 || reason == ERR_R_UNSUPPORTED) {
5139 ERR_clear_error();
5140 return 1;
5141 }
5142 #ifndef OPENSSL_NO_EC
5143 /*
5144 * If EC support is enabled we should catch also EC_R_UNKNOWN_GROUP as an
5145 * hint to an unsupported algorithm/curve (e.g. if binary EC support is
5146 * disabled).
5147 */
5148 if (lib == ERR_LIB_EC
5149 && (reason == EC_R_UNKNOWN_GROUP
5150 || reason == EC_R_INVALID_CURVE)) {
5151 ERR_clear_error();
5152 return 1;
5153 }
5154 #endif /* OPENSSL_NO_EC */
5155 return 0;
5156 }
5157
5158 /* NULL out the value from |pp| but return it. This "steals" a pointer. */
take_value(PAIR * pp)5159 static char *take_value(PAIR *pp)
5160 {
5161 char *p = pp->value;
5162
5163 pp->value = NULL;
5164 return p;
5165 }
5166
5167 #if !defined(OPENSSL_NO_FIPS_SECURITYCHECKS)
securitycheck_enabled(void)5168 static int securitycheck_enabled(void)
5169 {
5170 static int enabled = -1;
5171
5172 if (enabled == -1) {
5173 if (OSSL_PROVIDER_available(libctx, "fips")) {
5174 OSSL_PARAM params[2];
5175 OSSL_PROVIDER *prov = NULL;
5176 int check = 1;
5177
5178 prov = OSSL_PROVIDER_load(libctx, "fips");
5179 if (prov != NULL) {
5180 params[0] = OSSL_PARAM_construct_int(OSSL_PROV_PARAM_SECURITY_CHECKS,
5181 &check);
5182 params[1] = OSSL_PARAM_construct_end();
5183 OSSL_PROVIDER_get_params(prov, params);
5184 OSSL_PROVIDER_unload(prov);
5185 }
5186 enabled = check;
5187 return enabled;
5188 }
5189 enabled = 0;
5190 }
5191 return enabled;
5192 }
5193 #endif
5194
5195 /*
5196 * Return 1 if one of the providers named in the string is available.
5197 * The provider names are separated with whitespace.
5198 * NOTE: destructive function, it inserts '\0' after each provider name.
5199 */
prov_available(char * providers)5200 static int prov_available(char *providers)
5201 {
5202 char *p;
5203 int more = 1;
5204
5205 while (more) {
5206 for (; isspace((unsigned char)(*providers)); providers++)
5207 continue;
5208 if (*providers == '\0')
5209 break; /* End of the road */
5210 for (p = providers; *p != '\0' && !isspace((unsigned char)(*p)); p++)
5211 continue;
5212 if (*p == '\0')
5213 more = 0;
5214 else
5215 *p = '\0';
5216 if (OSSL_PROVIDER_available(libctx, providers))
5217 return 1; /* Found one */
5218 }
5219 return 0;
5220 }
5221
5222 /* Read and parse one test. Return 0 if failure, 1 if okay. */
parse(EVP_TEST * t)5223 static int parse(EVP_TEST *t)
5224 {
5225 KEY_LIST *key, **klist;
5226 EVP_PKEY *pkey;
5227 PAIR *pp;
5228 int i, j, skipped = 0;
5229
5230 fips_indicator_callback_unapproved_count = 0;
5231 top:
5232 do {
5233 if (BIO_eof(t->s.fp))
5234 return EOF;
5235 clear_test(t);
5236 if (!test_readstanza(&t->s))
5237 return 0;
5238 } while (t->s.numpairs == 0);
5239 pp = &t->s.pairs[0];
5240
5241 /* Are we adding a key? */
5242 klist = NULL;
5243 pkey = NULL;
5244 start:
5245 if (strcmp(pp->key, "PrivateKey") == 0) {
5246 pkey = PEM_read_bio_PrivateKey_ex(t->s.key, NULL, 0, NULL, libctx, NULL);
5247 if (pkey == NULL && !key_unsupported()) {
5248 EVP_PKEY_free(pkey);
5249 TEST_info("Can't read private key %s", pp->value);
5250 TEST_openssl_errors();
5251 return 0;
5252 }
5253 klist = &private_keys;
5254 } else if (strcmp(pp->key, "PublicKey") == 0) {
5255 pkey = PEM_read_bio_PUBKEY_ex(t->s.key, NULL, 0, NULL, libctx, NULL);
5256 if (pkey == NULL && !key_unsupported()) {
5257 EVP_PKEY_free(pkey);
5258 TEST_info("Can't read public key %s", pp->value);
5259 TEST_openssl_errors();
5260 return 0;
5261 }
5262 klist = &public_keys;
5263 } else if (strcmp(pp->key, "ParamKey") == 0) {
5264 pkey = PEM_read_bio_Parameters_ex(t->s.key, NULL, libctx, NULL);
5265 if (pkey == NULL && !key_unsupported()) {
5266 EVP_PKEY_free(pkey);
5267 TEST_info("Can't read params key %s", pp->value);
5268 TEST_openssl_errors();
5269 return 0;
5270 }
5271 klist = &public_keys;
5272 } else if (strcmp(pp->key, "PrivateKeyRaw") == 0
5273 || strcmp(pp->key, "PublicKeyRaw") == 0) {
5274 char *strnid = NULL, *keydata = NULL;
5275 unsigned char *keybin;
5276 size_t keylen;
5277 int nid;
5278
5279 if (strcmp(pp->key, "PrivateKeyRaw") == 0)
5280 klist = &private_keys;
5281 else
5282 klist = &public_keys;
5283
5284 strnid = strchr(pp->value, ':');
5285 if (strnid != NULL) {
5286 *strnid++ = '\0';
5287 keydata = strchr(strnid, ':');
5288 if (keydata != NULL)
5289 *keydata++ = '\0';
5290 }
5291 if (keydata == NULL) {
5292 TEST_info("Failed to parse %s value", pp->key);
5293 return 0;
5294 }
5295
5296 nid = OBJ_txt2nid(strnid);
5297 if (nid == NID_undef) {
5298 TEST_info("Unrecognised algorithm NID");
5299 return 0;
5300 }
5301 if (!parse_bin(keydata, &keybin, &keylen)) {
5302 TEST_info("Failed to create binary key");
5303 return 0;
5304 }
5305 if (klist == &private_keys)
5306 pkey = EVP_PKEY_new_raw_private_key_ex(libctx, strnid, NULL, keybin,
5307 keylen);
5308 else
5309 pkey = EVP_PKEY_new_raw_public_key_ex(libctx, strnid, NULL, keybin,
5310 keylen);
5311 if (pkey == NULL && !key_unsupported()) {
5312 TEST_info("Can't read %s data", pp->key);
5313 OPENSSL_free(keybin);
5314 TEST_openssl_errors();
5315 return 0;
5316 }
5317 OPENSSL_free(keybin);
5318 } else if (strcmp(pp->key, "Availablein") == 0) {
5319 if (!prov_available(pp->value)) {
5320 TEST_info("skipping, '%s' provider not available: %s:%d",
5321 pp->value, t->s.test_file, t->s.start);
5322 t->skip = 1;
5323 return 0;
5324 }
5325 skipped++;
5326 pp++;
5327 goto start;
5328 } else if (strcmp(pp->key, "FIPSversion") == 0) {
5329 if (prov_available("fips")) {
5330 j = fips_provider_version_match(libctx, pp->value);
5331 if (j < 0) {
5332 TEST_info("Line %d: error matching FIPS versions\n", t->s.curr);
5333 return 0;
5334 } else if (j == 0) {
5335 TEST_info("skipping, FIPS provider incompatible version: %s:%d",
5336 t->s.test_file, t->s.start);
5337 t->skip = 1;
5338 return 0;
5339 }
5340 }
5341 skipped++;
5342 pp++;
5343 goto start;
5344 }
5345
5346 /* If we have a key add to list */
5347 if (klist != NULL) {
5348 if (find_key(NULL, pp->value, *klist)) {
5349 TEST_info("Duplicate key %s", pp->value);
5350 return 0;
5351 }
5352 if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key))))
5353 return 0;
5354 key->name = take_value(pp);
5355 key->key = pkey;
5356 key->next = *klist;
5357 *klist = key;
5358
5359 /* Go back and start a new stanza. */
5360 if ((t->s.numpairs - skipped) != 1)
5361 TEST_info("Line %d: missing blank line\n", t->s.curr);
5362 goto top;
5363 }
5364
5365 /* Find the test, based on first keyword. */
5366 if (!TEST_ptr(t->meth = find_test(pp->key)))
5367 return 0;
5368 if (!t->meth->init(t, pp->value)) {
5369 TEST_error("unknown %s: %s\n", pp->key, pp->value);
5370 return 0;
5371 }
5372 if (t->skip == 1) {
5373 /* TEST_info("skipping %s %s", pp->key, pp->value); */
5374 return 0;
5375 }
5376
5377 for (pp++, i = 1; i < (t->s.numpairs - skipped); pp++, i++) {
5378 if (strcmp(pp->key, "Securitycheck") == 0) {
5379 #if defined(OPENSSL_NO_FIPS_SECURITYCHECKS)
5380 #else
5381 if (!securitycheck_enabled())
5382 #endif
5383 {
5384 TEST_info("skipping, Securitycheck is disabled: %s:%d",
5385 t->s.test_file, t->s.start);
5386 t->skip = 1;
5387 return 0;
5388 }
5389 } else if (strcmp(pp->key, "Availablein") == 0) {
5390 TEST_info("Line %d: 'Availablein' should be the first option",
5391 t->s.curr);
5392 return 0;
5393 } else if (strcmp(pp->key, "Result") == 0) {
5394 if (t->expected_err != NULL) {
5395 TEST_info("Line %d: multiple result lines", t->s.curr);
5396 return 0;
5397 }
5398 t->expected_err = take_value(pp);
5399 } else if (strcmp(pp->key, "Function") == 0) {
5400 /* Ignore old line. */
5401 } else if (strcmp(pp->key, "Reason") == 0) {
5402 if (t->reason != NULL) {
5403 TEST_info("Line %d: multiple reason lines", t->s.curr);
5404 return 0;
5405 }
5406 t->reason = take_value(pp);
5407 } else if (strcmp(pp->key, "Threads") == 0) {
5408 if (OSSL_set_max_threads(libctx, atoi(pp->value)) == 0) {
5409 TEST_info("skipping, '%s' threads not available: %s:%d",
5410 pp->value, t->s.test_file, t->s.start);
5411 t->skip = 1;
5412 }
5413 } else if (strcmp(pp->key, "Unapproved") == 0) {
5414 t->expect_unapproved = 1;
5415 } else if (strcmp(pp->key, "UnapprovedCallback") == 0) {
5416 t->expect_unapproved_callback = 1;
5417 } else if (strcmp(pp->key, "Extended-Test") == 0) {
5418 if (!extended_tests) {
5419 TEST_info("skipping extended test: %s:%d",
5420 t->s.test_file, t->s.start);
5421 t->skip = 1;
5422 }
5423 } else {
5424 /* Must be test specific line: try to parse it */
5425 int rv = t->meth->parse(t, pp->key, pp->value);
5426
5427 if (rv == 0) {
5428 TEST_info("Line %d: unknown keyword %s", t->s.curr, pp->key);
5429 return 0;
5430 }
5431 if (rv < 0) {
5432 TEST_info("Line %d: error processing keyword %s = %s\n",
5433 t->s.curr, pp->key, pp->value);
5434 return 0;
5435 }
5436 if (t->skip)
5437 return 0;
5438 }
5439 }
5440
5441 return 1;
5442 }
5443
run_file_tests(int i)5444 static int run_file_tests(int i)
5445 {
5446 EVP_TEST *t;
5447 const char *testfile = test_get_argument(i);
5448 int c;
5449
5450 if (!TEST_ptr(t = OPENSSL_zalloc(sizeof(*t))))
5451 return 0;
5452 if (!test_start_file(&t->s, testfile)) {
5453 OPENSSL_free(t);
5454 return 0;
5455 }
5456
5457 OSSL_INDICATOR_set_callback(libctx, fips_indicator_cb);
5458 while (!BIO_eof(t->s.fp)) {
5459 c = parse(t);
5460 if (t->skip) {
5461 t->s.numskip++;
5462 continue;
5463 }
5464 if (c == 0 || !run_test(t)) {
5465 t->s.errors++;
5466 break;
5467 }
5468 }
5469 test_end_file(&t->s);
5470 clear_test(t);
5471
5472 free_key_list(public_keys);
5473 public_keys = NULL;
5474 free_key_list(private_keys);
5475 private_keys = NULL;
5476 BIO_free(t->s.key);
5477 c = t->s.errors;
5478 OPENSSL_free(t);
5479 return c == 0;
5480 }
5481
test_get_options(void)5482 const OPTIONS *test_get_options(void)
5483 {
5484 static const OPTIONS test_options[] = {
5485 OPT_TEST_OPTIONS_WITH_EXTRA_USAGE("[file...]\n"),
5486 { "config", OPT_CONFIG_FILE, '<',
5487 "The configuration file to use for the libctx" },
5488 { "process", OPT_IN_PLACE, 's',
5489 "Mode for data processing by cipher tests [in_place/both], both by default" },
5490 { "provider", OPT_PROVIDER_NAME, 's',
5491 "The provider to load (when no configuration file, the default value is 'default')" },
5492 { "propquery", OPT_PROV_PROPQUERY, 's',
5493 "Property query used when fetching algorithms" },
5494 { "chunk", OPT_DATA_CHUNK, 'N', "Size of data chunks to be processed, 0 for default size" },
5495 { OPT_HELP_STR, 1, '-', "file\tFile to run tests on.\n" },
5496 { NULL }
5497 };
5498 return test_options;
5499 }
5500
setup_tests(void)5501 int setup_tests(void)
5502 {
5503 size_t n;
5504 char *config_file = NULL;
5505 char *provider_name = NULL;
5506
5507 OPTION_CHOICE o;
5508
5509 extended_tests = getenv("EVP_TEST_EXTENDED") != NULL;
5510
5511 while ((o = opt_next()) != OPT_EOF) {
5512 switch (o) {
5513 case OPT_CONFIG_FILE:
5514 config_file = opt_arg();
5515 break;
5516 case OPT_IN_PLACE:
5517 if ((process_mode_in_place = evp_test_process_mode(opt_arg())) == -1)
5518 case OPT_DATA_CHUNK:
5519 if (!opt_int(opt_arg(), &data_chunk_size))
5520 return 0;
5521 break;
5522 case OPT_PROVIDER_NAME:
5523 provider_name = opt_arg();
5524 break;
5525 case OPT_PROV_PROPQUERY:
5526 propquery = opt_arg();
5527 break;
5528 case OPT_TEST_CASES:
5529 break;
5530 default:
5531 case OPT_ERR:
5532 return 0;
5533 }
5534 }
5535
5536 /*
5537 * Load the provider via configuration into the created library context.
5538 * Load the 'null' provider into the default library context to ensure that
5539 * the tests do not fallback to using the default provider.
5540 */
5541 if (config_file == NULL && provider_name == NULL)
5542 provider_name = "default";
5543 if (!test_get_libctx(&libctx, &prov_null, config_file, &libprov, provider_name))
5544 return 0;
5545
5546 /* FIPS providers before 3.5 treated a missing indicator as approved. */
5547 missing_fips_indicator_is_approved = OSSL_PROVIDER_available(libctx, "fips")
5548 && fips_provider_version_lt(libctx, 3, 5, 0);
5549
5550 n = test_get_argument_count();
5551 if (n == 0)
5552 return 0;
5553
5554 ADD_ALL_TESTS(run_file_tests, n);
5555 return 1;
5556 }
5557
cleanup_tests(void)5558 void cleanup_tests(void)
5559 {
5560 OSSL_PROVIDER_unload(libprov);
5561 OSSL_PROVIDER_unload(prov_null);
5562 OSSL_LIB_CTX_free(libctx);
5563 }
5564
is_digest_disabled(const char * name)5565 static int is_digest_disabled(const char *name)
5566 {
5567 #ifdef OPENSSL_NO_BLAKE2
5568 if (HAS_CASE_PREFIX(name, "BLAKE"))
5569 return 1;
5570 #endif
5571 #ifdef OPENSSL_NO_MD2
5572 if (OPENSSL_strcasecmp(name, "MD2") == 0)
5573 return 1;
5574 #endif
5575 #ifdef OPENSSL_NO_MDC2
5576 if (OPENSSL_strcasecmp(name, "MDC2") == 0)
5577 return 1;
5578 #endif
5579 #ifdef OPENSSL_NO_MD4
5580 if (OPENSSL_strcasecmp(name, "MD4") == 0)
5581 return 1;
5582 #endif
5583 #ifdef OPENSSL_NO_MD5
5584 if (OPENSSL_strcasecmp(name, "MD5") == 0)
5585 return 1;
5586 #endif
5587 #ifdef OPENSSL_NO_RMD160
5588 if (OPENSSL_strcasecmp(name, "RIPEMD160") == 0)
5589 return 1;
5590 #endif
5591 #ifdef OPENSSL_NO_SM3
5592 if (OPENSSL_strcasecmp(name, "SM3") == 0)
5593 return 1;
5594 #endif
5595 #ifdef OPENSSL_NO_WHIRLPOOL
5596 if (OPENSSL_strcasecmp(name, "WHIRLPOOL") == 0)
5597 return 1;
5598 #endif
5599 return 0;
5600 }
5601
is_pkey_disabled(const char * name)5602 static int is_pkey_disabled(const char *name)
5603 {
5604 #ifdef OPENSSL_NO_EC
5605 if (HAS_CASE_PREFIX(name, "EC"))
5606 return 1;
5607 #endif
5608 #ifdef OPENSSL_NO_DH
5609 if (HAS_CASE_PREFIX(name, "DH"))
5610 return 1;
5611 #endif
5612 #ifdef OPENSSL_NO_DSA
5613 if (HAS_CASE_PREFIX(name, "DSA"))
5614 return 1;
5615 #endif
5616 #ifdef OPENSSL_NO_SM2
5617 if (HAS_CASE_PREFIX(name, "SM2"))
5618 return 1;
5619 #endif
5620
5621 /* For sigalgs we use, we also check for digest suffixes */
5622 #ifdef OPENSSL_NO_RMD160
5623 if (HAS_CASE_SUFFIX(name, "-RIPEMD160"))
5624 return 1;
5625 #endif
5626 #ifdef OPENSSL_NO_SM3
5627 if (HAS_CASE_SUFFIX(name, "-SM3"))
5628 return 1;
5629 #endif
5630 #ifdef OPENSSL_NO_ML_DSA
5631 if (HAS_CASE_PREFIX(name, "ML-DSA"))
5632 return 1;
5633 #endif
5634 return 0;
5635 }
5636
is_mac_disabled(const char * name)5637 static int is_mac_disabled(const char *name)
5638 {
5639 #ifdef OPENSSL_NO_BLAKE2
5640 if (HAS_CASE_PREFIX(name, "BLAKE2BMAC")
5641 || HAS_CASE_PREFIX(name, "BLAKE2SMAC"))
5642 return 1;
5643 #endif
5644 #ifdef OPENSSL_NO_CMAC
5645 if (HAS_CASE_PREFIX(name, "CMAC"))
5646 return 1;
5647 #endif
5648 #ifdef OPENSSL_NO_POLY1305
5649 if (HAS_CASE_PREFIX(name, "Poly1305"))
5650 return 1;
5651 #endif
5652 #ifdef OPENSSL_NO_SIPHASH
5653 if (HAS_CASE_PREFIX(name, "SipHash"))
5654 return 1;
5655 #endif
5656 return 0;
5657 }
is_kdf_disabled(const char * name)5658 static int is_kdf_disabled(const char *name)
5659 {
5660 #ifdef OPENSSL_NO_SCRYPT
5661 if (HAS_CASE_SUFFIX(name, "SCRYPT"))
5662 return 1;
5663 #endif
5664 #ifdef OPENSSL_NO_ARGON2
5665 if (HAS_CASE_SUFFIX(name, "ARGON2"))
5666 return 1;
5667 #endif
5668 return 0;
5669 }
5670
is_cipher_disabled(const char * name)5671 static int is_cipher_disabled(const char *name)
5672 {
5673 #ifdef OPENSSL_NO_ARIA
5674 if (HAS_CASE_PREFIX(name, "ARIA"))
5675 return 1;
5676 #endif
5677 #ifdef OPENSSL_NO_BF
5678 if (HAS_CASE_PREFIX(name, "BF"))
5679 return 1;
5680 #endif
5681 #ifdef OPENSSL_NO_CAMELLIA
5682 if (HAS_CASE_PREFIX(name, "CAMELLIA"))
5683 return 1;
5684 #endif
5685 #ifdef OPENSSL_NO_CAST
5686 if (HAS_CASE_PREFIX(name, "CAST"))
5687 return 1;
5688 #endif
5689 #ifdef OPENSSL_NO_CHACHA
5690 if (HAS_CASE_PREFIX(name, "CHACHA"))
5691 return 1;
5692 #endif
5693 #ifdef OPENSSL_NO_POLY1305
5694 if (HAS_CASE_SUFFIX(name, "Poly1305"))
5695 return 1;
5696 #endif
5697 #ifdef OPENSSL_NO_DES
5698 if (HAS_CASE_PREFIX(name, "DES"))
5699 return 1;
5700 if (HAS_CASE_SUFFIX(name, "3DESwrap"))
5701 return 1;
5702 #endif
5703 #ifdef OPENSSL_NO_OCB
5704 if (HAS_CASE_SUFFIX(name, "OCB"))
5705 return 1;
5706 #endif
5707 #ifdef OPENSSL_NO_IDEA
5708 if (HAS_CASE_PREFIX(name, "IDEA"))
5709 return 1;
5710 #endif
5711 #ifdef OPENSSL_NO_RC2
5712 if (HAS_CASE_PREFIX(name, "RC2"))
5713 return 1;
5714 #endif
5715 #ifdef OPENSSL_NO_RC4
5716 if (HAS_CASE_PREFIX(name, "RC4"))
5717 return 1;
5718 #endif
5719 #ifdef OPENSSL_NO_RC5
5720 if (HAS_CASE_PREFIX(name, "RC5"))
5721 return 1;
5722 #endif
5723 #ifdef OPENSSL_NO_SEED
5724 if (HAS_CASE_PREFIX(name, "SEED"))
5725 return 1;
5726 #endif
5727 #ifdef OPENSSL_NO_SIV
5728 if (HAS_CASE_SUFFIX(name, "SIV"))
5729 return 1;
5730 #endif
5731 #ifdef OPENSSL_NO_SM4
5732 if (HAS_CASE_PREFIX(name, "SM4"))
5733 return 1;
5734 #endif
5735 return 0;
5736 }
5737