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 */ 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 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 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 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 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 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 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 */ 243 static void openssl_free(char *m) 244 { 245 OPENSSL_free(m); 246 } 247 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 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 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 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 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 */ 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 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 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 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 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 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 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 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 */ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 */ 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 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 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 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 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 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 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 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 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 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 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 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 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 */ 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 */ 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 */ 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 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 */ 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 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 */ 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 */ 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 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 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 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 */ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 */ 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 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 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 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 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 */ 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 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 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 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 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 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 */ 4315 static int void_test_parse(EVP_TEST *t, const char *keyword, const char *value) 4316 { 4317 return 0; 4318 } 4319 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 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 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 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 */ 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 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 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 4626 static int digestsign_test_init(EVP_TEST *t, const char *alg) 4627 { 4628 return digestsigver_test_init(t, alg, 0, 0); 4629 } 4630 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 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 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 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 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 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 4823 static int digestverify_test_init(EVP_TEST *t, const char *alg) 4824 { 4825 return digestsigver_test_init(t, alg, 1, 0); 4826 } 4827 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 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 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 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 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 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 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 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. */ 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. */ 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 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 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 */ 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. */ 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) 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 */ 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. */ 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 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 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 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 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 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 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 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 } 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 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