test/evp_test.c

   1 /*
   2  * Copyright 2015-2021 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #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 "internal/e_os.h" /* strcasecmp and strncasecmp */
  16 #include <openssl/evp.h>
  17 #include <openssl/pem.h>
  18 #include <openssl/err.h>
  19 #include <openssl/provider.h>
  20 #include <openssl/x509v3.h>
  21 #include <openssl/pkcs12.h>
  22 #include <openssl/kdf.h>
  23 #include <openssl/params.h>
  24 #include <openssl/core_names.h>
  25 #include <openssl/fips_names.h>
  26 #include "internal/numbers.h"
  27 #include "internal/nelem.h"
  28 #include "crypto/evp.h"
  29 #include "testutil.h"
  30
  31 typedef struct evp_test_buffer_st EVP_TEST_BUFFER;
  32 DEFINE_STACK_OF(EVP_TEST_BUFFER)
  33
  34 #define AAD_NUM 4
  35
  36 typedef struct evp_test_method_st EVP_TEST_METHOD;
  37
  38 /* Structure holding test information */
  39 typedef struct evp_test_st {
  40     STANZA s;                     /* Common test stanza */
  41     char *name;
  42     int skip;                     /* Current test should be skipped */
  43     const EVP_TEST_METHOD *meth;  /* method for this test */
  44     const char *err, *aux_err;    /* Error string for test */
  45     char *expected_err;           /* Expected error value of test */
  46     char *reason;                 /* Expected error reason string */
  47     void *data;                   /* test specific data */
  48 } EVP_TEST;
  49
  50 /* Test method structure */
  51 struct evp_test_method_st {
  52     /* Name of test as it appears in file */
  53     const char *name;
  54     /* Initialise test for "alg" */
  55     int (*init) (EVP_TEST * t, const char *alg);
  56     /* Clean up method */
  57     void (*cleanup) (EVP_TEST * t);
  58     /* Test specific name value pair processing */
  59     int (*parse) (EVP_TEST * t, const char *name, const char *value);
  60     /* Run the test itself */
  61     int (*run_test) (EVP_TEST * t);
  62 };
  63
  64 /* Linked list of named keys. */
  65 typedef struct key_list_st {
  66     char *name;
  67     EVP_PKEY *key;
  68     struct key_list_st *next;
  69 } KEY_LIST;
  70
  71 typedef enum OPTION_choice {
  72     OPT_ERR = -1,
  73     OPT_EOF = 0,
  74     OPT_CONFIG_FILE,
  75     OPT_TEST_ENUM
  76 } OPTION_CHOICE;
  77
  78 static OSSL_PROVIDER *prov_null = NULL;
  79 static OSSL_LIB_CTX *libctx = NULL;
  80
  81 /* List of public and private keys */
  82 static KEY_LIST *private_keys;
  83 static KEY_LIST *public_keys;
  84
  85 static int find_key(EVP_PKEY **ppk, const char *name, KEY_LIST *lst);
  86 static int parse_bin(const char *value, unsigned char **buf, size_t *buflen);
  87 static int is_digest_disabled(const char *name);
  88 static int is_pkey_disabled(const char *name);
  89 static int is_mac_disabled(const char *name);
  90 static int is_cipher_disabled(const char *name);
  91 static int is_kdf_disabled(const char *name);
  92
  93 /*
  94  * Compare two memory regions for equality, returning zero if they differ.
  95  * However, if there is expected to be an error and the actual error
  96  * matches then the memory is expected to be different so handle this
  97  * case without producing unnecessary test framework output.
  98  */
  99 static int memory_err_compare(EVP_TEST *t, const char *err,
 100                               const void *expected, size_t expected_len,
 101                               const void *got, size_t got_len)
 102 {
 103     int r;
 104
 105     if (t->expected_err != NULL && strcmp(t->expected_err, err) == 0)
 106         r = !TEST_mem_ne(expected, expected_len, got, got_len);
 107     else
 108         r = TEST_mem_eq(expected, expected_len, got, got_len);
 109     if (!r)
 110         t->err = err;
 111     return r;
 112 }
 113
 114 /*
 115  * Structure used to hold a list of blocks of memory to test
 116  * calls to "update" like functions.
 117  */
 118 struct evp_test_buffer_st {
 119     unsigned char *buf;
 120     size_t buflen;
 121     size_t count;
 122     int count_set;
 123 };
 124
 125 static void evp_test_buffer_free(EVP_TEST_BUFFER *db)
 126 {
 127     if (db != NULL) {
 128         OPENSSL_free(db->buf);
 129         OPENSSL_free(db);
 130     }
 131 }
 132
 133 /* append buffer to a list */
 134 static int evp_test_buffer_append(const char *value,
 135                                   STACK_OF(EVP_TEST_BUFFER) **sk)
 136 {
 137     EVP_TEST_BUFFER *db = NULL;
 138
 139     if (!TEST_ptr(db = OPENSSL_malloc(sizeof(*db))))
 140         goto err;
 141
 142     if (!parse_bin(value, &db->buf, &db->buflen))
 143         goto err;
 144     db->count = 1;
 145     db->count_set = 0;
 146
 147     if (*sk == NULL && !TEST_ptr(*sk = sk_EVP_TEST_BUFFER_new_null()))
 148         goto err;
 149     if (!sk_EVP_TEST_BUFFER_push(*sk, db))
 150         goto err;
 151
 152     return 1;
 153
 154 err:
 155     evp_test_buffer_free(db);
 156     return 0;
 157 }
 158
 159 /* replace last buffer in list with copies of itself */
 160 static int evp_test_buffer_ncopy(const char *value,
 161                                  STACK_OF(EVP_TEST_BUFFER) *sk)
 162 {
 163     EVP_TEST_BUFFER *db;
 164     unsigned char *tbuf, *p;
 165     size_t tbuflen;
 166     int ncopy = atoi(value);
 167     int i;
 168
 169     if (ncopy <= 0)
 170         return 0;
 171     if (sk == NULL || sk_EVP_TEST_BUFFER_num(sk) == 0)
 172         return 0;
 173     db = sk_EVP_TEST_BUFFER_value(sk, sk_EVP_TEST_BUFFER_num(sk) - 1);
 174
 175     tbuflen = db->buflen * ncopy;
 176     if (!TEST_ptr(tbuf = OPENSSL_malloc(tbuflen)))
 177         return 0;
 178     for (i = 0, p = tbuf; i < ncopy; i++, p += db->buflen)
 179         memcpy(p, db->buf, db->buflen);
 180
 181     OPENSSL_free(db->buf);
 182     db->buf = tbuf;
 183     db->buflen = tbuflen;
 184     return 1;
 185 }
 186
 187 /* set repeat count for last buffer in list */
 188 static int evp_test_buffer_set_count(const char *value,
 189                                      STACK_OF(EVP_TEST_BUFFER) *sk)
 190 {
 191     EVP_TEST_BUFFER *db;
 192     int count = atoi(value);
 193
 194     if (count <= 0)
 195         return 0;
 196
 197     if (sk == NULL || sk_EVP_TEST_BUFFER_num(sk) == 0)
 198         return 0;
 199
 200     db = sk_EVP_TEST_BUFFER_value(sk, sk_EVP_TEST_BUFFER_num(sk) - 1);
 201     if (db->count_set != 0)
 202         return 0;
 203
 204     db->count = (size_t)count;
 205     db->count_set = 1;
 206     return 1;
 207 }
 208
 209 /* call "fn" with each element of the list in turn */
 210 static int evp_test_buffer_do(STACK_OF(EVP_TEST_BUFFER) *sk,
 211                               int (*fn)(void *ctx,
 212                                         const unsigned char *buf,
 213                                         size_t buflen),
 214                               void *ctx)
 215 {
 216     int i;
 217
 218     for (i = 0; i < sk_EVP_TEST_BUFFER_num(sk); i++) {
 219         EVP_TEST_BUFFER *tb = sk_EVP_TEST_BUFFER_value(sk, i);
 220         size_t j;
 221
 222         for (j = 0; j < tb->count; j++) {
 223             if (fn(ctx, tb->buf, tb->buflen) <= 0)
 224                 return 0;
 225         }
 226     }
 227     return 1;
 228 }
 229
 230 /*
 231  * Unescape some sequences in string literals (only \n for now).
 232  * Return an allocated buffer, set |out_len|.  If |input_len|
 233  * is zero, get an empty buffer but set length to zero.
 234  */
 235 static unsigned char* unescape(const char *input, size_t input_len,
 236                                size_t *out_len)
 237 {
 238     unsigned char *ret, *p;
 239     size_t i;
 240
 241     if (input_len == 0) {
 242         *out_len = 0;
 243         return OPENSSL_zalloc(1);
 244     }
 245
 246     /* Escaping is non-expanding; over-allocate original size for simplicity. */
 247     if (!TEST_ptr(ret = p = OPENSSL_malloc(input_len)))
 248         return NULL;
 249
 250     for (i = 0; i < input_len; i++) {
 251         if (*input == '\\') {
 252             if (i == input_len - 1 || *++input != 'n') {
 253                 TEST_error("Bad escape sequence in file");
 254                 goto err;
 255             }
 256             *p++ = '\n';
 257             i++;
 258             input++;
 259         } else {
 260             *p++ = *input++;
 261         }
 262     }
 263
 264     *out_len = p - ret;
 265     return ret;
 266
 267  err:
 268     OPENSSL_free(ret);
 269     return NULL;
 270 }
 271
 272 /*
 273  * For a hex string "value" convert to a binary allocated buffer.
 274  * Return 1 on success or 0 on failure.
 275  */
 276 static int parse_bin(const char *value, unsigned char **buf, size_t *buflen)
 277 {
 278     long len;
 279
 280     /* Check for NULL literal */
 281     if (strcmp(value, "NULL") == 0) {
 282         *buf = NULL;
 283         *buflen = 0;
 284         return 1;
 285     }
 286
 287     /* Check for empty value */
 288     if (*value == '\0') {
 289         /*
 290          * Don't return NULL for zero length buffer. This is needed for
 291          * some tests with empty keys: HMAC_Init_ex() expects a non-NULL key
 292          * buffer even if the key length is 0, in order to detect key reset.
 293          */
 294         *buf = OPENSSL_malloc(1);
 295         if (*buf == NULL)
 296             return 0;
 297         **buf = 0;
 298         *buflen = 0;
 299         return 1;
 300     }
 301
 302     /* Check for string literal */
 303     if (value[0] == '"') {
 304         size_t vlen = strlen(++value);
 305
 306         if (vlen == 0 || value[vlen - 1] != '"')
 307             return 0;
 308         vlen--;
 309         *buf = unescape(value, vlen, buflen);
 310         return *buf == NULL ? 0 : 1;
 311     }
 312
 313     /* Otherwise assume as hex literal and convert it to binary buffer */
 314     if (!TEST_ptr(*buf = OPENSSL_hexstr2buf(value, &len))) {
 315         TEST_info("Can't convert %s", value);
 316         TEST_openssl_errors();
 317         return -1;
 318     }
 319     /* Size of input buffer means we'll never overflow */
 320     *buflen = len;
 321     return 1;
 322 }
 323
 324 /**
 325  **  MESSAGE DIGEST TESTS
 326  **/
 327
 328 typedef struct digest_data_st {
 329     /* Digest this test is for */
 330     const EVP_MD *digest;
 331     EVP_MD *fetched_digest;
 332     /* Input to digest */
 333     STACK_OF(EVP_TEST_BUFFER) *input;
 334     /* Expected output */
 335     unsigned char *output;
 336     size_t output_len;
 337     /* Padding type */
 338     int pad_type;
 339 } DIGEST_DATA;
 340
 341 static int digest_test_init(EVP_TEST *t, const char *alg)
 342 {
 343     DIGEST_DATA *mdat;
 344     const EVP_MD *digest;
 345     EVP_MD *fetched_digest;
 346
 347     if (is_digest_disabled(alg)) {
 348         TEST_info("skipping, '%s' is disabled", alg);
 349         t->skip = 1;
 350         return 1;
 351     }
 352
 353     if ((digest = fetched_digest = EVP_MD_fetch(libctx, alg, NULL)) == NULL
 354         && (digest = EVP_get_digestbyname(alg)) == NULL)
 355         return 0;
 356     if (!TEST_ptr(mdat = OPENSSL_zalloc(sizeof(*mdat))))
 357         return 0;
 358     t->data = mdat;
 359     mdat->digest = digest;
 360     mdat->fetched_digest = fetched_digest;
 361     mdat->pad_type = 0;
 362     if (fetched_digest != NULL)
 363         TEST_info("%s is fetched", alg);
 364     return 1;
 365 }
 366
 367 static void digest_test_cleanup(EVP_TEST *t)
 368 {
 369     DIGEST_DATA *mdat = t->data;
 370
 371     sk_EVP_TEST_BUFFER_pop_free(mdat->input, evp_test_buffer_free);
 372     OPENSSL_free(mdat->output);
 373     EVP_MD_free(mdat->fetched_digest);
 374 }
 375
 376 static int digest_test_parse(EVP_TEST *t,
 377                              const char *keyword, const char *value)
 378 {
 379     DIGEST_DATA *mdata = t->data;
 380
 381     if (strcmp(keyword, "Input") == 0)
 382         return evp_test_buffer_append(value, &mdata->input);
 383     if (strcmp(keyword, "Output") == 0)
 384         return parse_bin(value, &mdata->output, &mdata->output_len);
 385     if (strcmp(keyword, "Count") == 0)
 386         return evp_test_buffer_set_count(value, mdata->input);
 387     if (strcmp(keyword, "Ncopy") == 0)
 388         return evp_test_buffer_ncopy(value, mdata->input);
 389     if (strcmp(keyword, "Padding") == 0)
 390         return (mdata->pad_type = atoi(value)) > 0;
 391     return 0;
 392 }
 393
 394 static int digest_update_fn(void *ctx, const unsigned char *buf, size_t buflen)
 395 {
 396     return EVP_DigestUpdate(ctx, buf, buflen);
 397 }
 398
 399 static int test_duplicate_md_ctx(EVP_TEST *t, EVP_MD_CTX *mctx)
 400 {
 401     char dont[] = "touch";
 402
 403     if (!TEST_ptr(mctx))
 404         return 0;
 405     if (!EVP_DigestFinalXOF(mctx, (unsigned char *)dont, 0)) {
 406         EVP_MD_CTX_free(mctx);
 407         t->err = "DIGESTFINALXOF_ERROR";
 408         return 0;
 409     }
 410     if (!TEST_str_eq(dont, "touch")) {
 411         EVP_MD_CTX_free(mctx);
 412         t->err = "DIGESTFINALXOF_ERROR";
 413         return 0;
 414     }
 415     EVP_MD_CTX_free(mctx);
 416     return 1;
 417 }
 418
 419 static int digest_test_run(EVP_TEST *t)
 420 {
 421     DIGEST_DATA *expected = t->data;
 422     EVP_TEST_BUFFER *inbuf;
 423     EVP_MD_CTX *mctx;
 424     unsigned char *got = NULL;
 425     unsigned int got_len;
 426     size_t size = 0;
 427     int xof = 0;
 428     OSSL_PARAM params[2];
 429
 430     printf("test %s (%d %d)\n", t->name, t->s.start, t->s.curr);
 431     t->err = "TEST_FAILURE";
 432     if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
 433         goto err;
 434
 435     got = OPENSSL_malloc(expected->output_len > EVP_MAX_MD_SIZE ?
 436                          expected->output_len : EVP_MAX_MD_SIZE);
 437     if (!TEST_ptr(got))
 438         goto err;
 439
 440     if (!EVP_DigestInit_ex(mctx, expected->digest, NULL)) {
 441         t->err = "DIGESTINIT_ERROR";
 442         goto err;
 443     }
 444     if (expected->pad_type > 0) {
 445         params[0] = OSSL_PARAM_construct_int(OSSL_DIGEST_PARAM_PAD_TYPE,
 446                                               &expected->pad_type);
 447         params[1] = OSSL_PARAM_construct_end();
 448         if (!TEST_int_gt(EVP_MD_CTX_set_params(mctx, params), 0)) {
 449             t->err = "PARAMS_ERROR";
 450             goto err;
 451         }
 452     }
 453     if (!evp_test_buffer_do(expected->input, digest_update_fn, mctx)) {
 454         t->err = "DIGESTUPDATE_ERROR";
 455         goto err;
 456     }
 457
 458     xof = (EVP_MD_get_flags(expected->digest) & EVP_MD_FLAG_XOF) != 0;
 459     if (xof) {
 460         EVP_MD_CTX *mctx_cpy;
 461
 462         if (!TEST_ptr(mctx_cpy = EVP_MD_CTX_new())) {
 463             goto err;
 464         }
 465         if (!TEST_true(EVP_MD_CTX_copy(mctx_cpy, mctx))) {
 466             EVP_MD_CTX_free(mctx_cpy);
 467             goto err;
 468         } else if (!test_duplicate_md_ctx(t, mctx_cpy)) {
 469             goto err;
 470         }
 471
 472         if (!test_duplicate_md_ctx(t, EVP_MD_CTX_dup(mctx)))
 473             goto err;
 474
 475         got_len = expected->output_len;
 476         if (!EVP_DigestFinalXOF(mctx, got, got_len)) {
 477             t->err = "DIGESTFINALXOF_ERROR";
 478             goto err;
 479         }
 480     } else {
 481         if (!EVP_DigestFinal(mctx, got, &got_len)) {
 482             t->err = "DIGESTFINAL_ERROR";
 483             goto err;
 484         }
 485     }
 486     if (!TEST_int_eq(expected->output_len, got_len)) {
 487         t->err = "DIGEST_LENGTH_MISMATCH";
 488         goto err;
 489     }
 490     if (!memory_err_compare(t, "DIGEST_MISMATCH",
 491                             expected->output, expected->output_len,
 492                             got, got_len))
 493         goto err;
 494
 495     t->err = NULL;
 496
 497     /* Test the EVP_Q_digest interface as well */
 498     if (sk_EVP_TEST_BUFFER_num(expected->input) == 1
 499             && !xof
 500             /* This should never fail but we need the returned pointer now */
 501             && !TEST_ptr(inbuf = sk_EVP_TEST_BUFFER_value(expected->input, 0))
 502             && !inbuf->count_set) {
 503         OPENSSL_cleanse(got, got_len);
 504         if (!TEST_true(EVP_Q_digest(libctx,
 505                                     EVP_MD_get0_name(expected->fetched_digest),
 506                                     NULL, inbuf->buf, inbuf->buflen,
 507                                     got, &size))
 508                 || !TEST_mem_eq(got, size,
 509                                 expected->output, expected->output_len)) {
 510             t->err = "EVP_Q_digest failed";
 511             goto err;
 512         }
 513     }
 514
 515  err:
 516     OPENSSL_free(got);
 517     EVP_MD_CTX_free(mctx);
 518     return 1;
 519 }
 520
 521 static const EVP_TEST_METHOD digest_test_method = {
 522     "Digest",
 523     digest_test_init,
 524     digest_test_cleanup,
 525     digest_test_parse,
 526     digest_test_run
 527 };
 528
 529 /**
 530 ***  CIPHER TESTS
 531 **/
 532
 533 typedef struct cipher_data_st {
 534     const EVP_CIPHER *cipher;
 535     EVP_CIPHER *fetched_cipher;
 536     int enc;
 537     /* EVP_CIPH_GCM_MODE, EVP_CIPH_CCM_MODE or EVP_CIPH_OCB_MODE if AEAD */
 538     int aead;
 539     unsigned char *key;
 540     size_t key_len;
 541     size_t key_bits; /* Used by RC2 */
 542     unsigned char *iv;
 543     unsigned char *next_iv; /* Expected IV state after operation */
 544     unsigned int rounds;
 545     size_t iv_len;
 546     unsigned char *plaintext;
 547     size_t plaintext_len;
 548     unsigned char *ciphertext;
 549     size_t ciphertext_len;
 550     /* AEAD ciphers only */
 551     unsigned char *aad[AAD_NUM];
 552     size_t aad_len[AAD_NUM];
 553     int tls_aad;
 554     int tls_version;
 555     unsigned char *tag;
 556     const char *cts_mode;
 557     size_t tag_len;
 558     int tag_late;
 559     unsigned char *mac_key;
 560     size_t mac_key_len;
 561 } CIPHER_DATA;
 562
 563 static int cipher_test_init(EVP_TEST *t, const char *alg)
 564 {
 565     const EVP_CIPHER *cipher;
 566     EVP_CIPHER *fetched_cipher;
 567     CIPHER_DATA *cdat;
 568     int m;
 569
 570     if (is_cipher_disabled(alg)) {
 571         t->skip = 1;
 572         TEST_info("skipping, '%s' is disabled", alg);
 573         return 1;
 574     }
 575
 576     ERR_set_mark();
 577     if ((cipher = fetched_cipher = EVP_CIPHER_fetch(libctx, alg, NULL)) == NULL
 578         && (cipher = EVP_get_cipherbyname(alg)) == NULL) {
 579         /* a stitched cipher might not be available */
 580         if (strstr(alg, "HMAC") != NULL) {
 581             ERR_pop_to_mark();
 582             t->skip = 1;
 583             TEST_info("skipping, '%s' is not available", alg);
 584             return 1;
 585         }
 586         ERR_clear_last_mark();
 587         return 0;
 588     }
 589     ERR_clear_last_mark();
 590
 591     if (!TEST_ptr(cdat = OPENSSL_zalloc(sizeof(*cdat))))
 592         return 0;
 593
 594     cdat->cipher = cipher;
 595     cdat->fetched_cipher = fetched_cipher;
 596     cdat->enc = -1;
 597     m = EVP_CIPHER_get_mode(cipher);
 598     if (EVP_CIPHER_get_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER)
 599         cdat->aead = m != 0 ? m : -1;
 600     else
 601         cdat->aead = 0;
 602
 603     t->data = cdat;
 604     if (fetched_cipher != NULL)
 605         TEST_info("%s is fetched", alg);
 606     return 1;
 607 }
 608
 609 static void cipher_test_cleanup(EVP_TEST *t)
 610 {
 611     int i;
 612     CIPHER_DATA *cdat = t->data;
 613
 614     OPENSSL_free(cdat->key);
 615     OPENSSL_free(cdat->iv);
 616     OPENSSL_free(cdat->next_iv);
 617     OPENSSL_free(cdat->ciphertext);
 618     OPENSSL_free(cdat->plaintext);
 619     for (i = 0; i < AAD_NUM; i++)
 620         OPENSSL_free(cdat->aad[i]);
 621     OPENSSL_free(cdat->tag);
 622     OPENSSL_free(cdat->mac_key);
 623     EVP_CIPHER_free(cdat->fetched_cipher);
 624 }
 625
 626 static int cipher_test_parse(EVP_TEST *t, const char *keyword,
 627                              const char *value)
 628 {
 629     CIPHER_DATA *cdat = t->data;
 630     int i;
 631
 632     if (strcmp(keyword, "Key") == 0)
 633         return parse_bin(value, &cdat->key, &cdat->key_len);
 634     if (strcmp(keyword, "Rounds") == 0) {
 635         i = atoi(value);
 636         if (i < 0)
 637             return -1;
 638         cdat->rounds = (unsigned int)i;
 639         return 1;
 640     }
 641     if (strcmp(keyword, "IV") == 0)
 642         return parse_bin(value, &cdat->iv, &cdat->iv_len);
 643     if (strcmp(keyword, "NextIV") == 0)
 644         return parse_bin(value, &cdat->next_iv, &cdat->iv_len);
 645     if (strcmp(keyword, "Plaintext") == 0)
 646         return parse_bin(value, &cdat->plaintext, &cdat->plaintext_len);
 647     if (strcmp(keyword, "Ciphertext") == 0)
 648         return parse_bin(value, &cdat->ciphertext, &cdat->ciphertext_len);
 649     if (strcmp(keyword, "KeyBits") == 0) {
 650         i = atoi(value);
 651         if (i < 0)
 652             return -1;
 653         cdat->key_bits = (size_t)i;
 654         return 1;
 655     }
 656     if (cdat->aead) {
 657         int tls_aad = 0;
 658
 659         if (strcmp(keyword, "TLSAAD") == 0)
 660             cdat->tls_aad = tls_aad = 1;
 661         if (strcmp(keyword, "AAD") == 0 || tls_aad) {
 662             for (i = 0; i < AAD_NUM; i++) {
 663                 if (cdat->aad[i] == NULL)
 664                     return parse_bin(value, &cdat->aad[i], &cdat->aad_len[i]);
 665             }
 666             return -1;
 667         }
 668         if (strcmp(keyword, "Tag") == 0)
 669             return parse_bin(value, &cdat->tag, &cdat->tag_len);
 670         if (strcmp(keyword, "SetTagLate") == 0) {
 671             if (strcmp(value, "TRUE") == 0)
 672                 cdat->tag_late = 1;
 673             else if (strcmp(value, "FALSE") == 0)
 674                 cdat->tag_late = 0;
 675             else
 676                 return -1;
 677             return 1;
 678         }
 679         if (strcmp(keyword, "MACKey") == 0)
 680             return parse_bin(value, &cdat->mac_key, &cdat->mac_key_len);
 681         if (strcmp(keyword, "TLSVersion") == 0) {
 682             char *endptr;
 683
 684             cdat->tls_version = (int)strtol(value, &endptr, 0);
 685             return value[0] != '\0' && endptr[0] == '\0';
 686         }
 687     }
 688
 689     if (strcmp(keyword, "Operation") == 0) {
 690         if (strcmp(value, "ENCRYPT") == 0)
 691             cdat->enc = 1;
 692         else if (strcmp(value, "DECRYPT") == 0)
 693             cdat->enc = 0;
 694         else
 695             return -1;
 696         return 1;
 697     }
 698     if (strcmp(keyword, "CTSMode") == 0) {
 699         cdat->cts_mode = value;
 700         return 1;
 701     }
 702     return 0;
 703 }
 704
 705 static int cipher_test_enc(EVP_TEST *t, int enc,
 706                            size_t out_misalign, size_t inp_misalign, int frag)
 707 {
 708     CIPHER_DATA *expected = t->data;
 709     unsigned char *in, *expected_out, *tmp = NULL;
 710     size_t in_len, out_len, donelen = 0;
 711     int ok = 0, tmplen, chunklen, tmpflen, i;
 712     EVP_CIPHER_CTX *ctx_base = NULL;
 713     EVP_CIPHER_CTX *ctx = NULL, *duped;
 714
 715     t->err = "TEST_FAILURE";
 716     if (!TEST_ptr(ctx_base = EVP_CIPHER_CTX_new()))
 717         goto err;
 718     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new()))
 719         goto err;
 720     EVP_CIPHER_CTX_set_flags(ctx_base, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
 721     if (enc) {
 722         in = expected->plaintext;
 723         in_len = expected->plaintext_len;
 724         expected_out = expected->ciphertext;
 725         out_len = expected->ciphertext_len;
 726     } else {
 727         in = expected->ciphertext;
 728         in_len = expected->ciphertext_len;
 729         expected_out = expected->plaintext;
 730         out_len = expected->plaintext_len;
 731     }
 732     if (inp_misalign == (size_t)-1) {
 733         /* Exercise in-place encryption */
 734         tmp = OPENSSL_malloc(out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH);
 735         if (!tmp)
 736             goto err;
 737         in = memcpy(tmp + out_misalign, in, in_len);
 738     } else {
 739         inp_misalign += 16 - ((out_misalign + in_len) & 15);
 740         /*
 741          * 'tmp' will store both output and copy of input. We make the copy
 742          * of input to specifically aligned part of 'tmp'. So we just
 743          * figured out how much padding would ensure the required alignment,
 744          * now we allocate extended buffer and finally copy the input just
 745          * past inp_misalign in expression below. Output will be written
 746          * past out_misalign...
 747          */
 748         tmp = OPENSSL_malloc(out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH +
 749                              inp_misalign + in_len);
 750         if (!tmp)
 751             goto err;
 752         in = memcpy(tmp + out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH +
 753                     inp_misalign, in, in_len);
 754     }
 755     if (!EVP_CipherInit_ex(ctx_base, expected->cipher, NULL, NULL, NULL, enc)) {
 756         t->err = "CIPHERINIT_ERROR";
 757         goto err;
 758     }
 759     if (expected->cts_mode != NULL) {
 760         OSSL_PARAM params[2];
 761
 762         params[0] = OSSL_PARAM_construct_utf8_string(OSSL_CIPHER_PARAM_CTS_MODE,
 763                                                      (char *)expected->cts_mode,
 764                                                      0);
 765         params[1] = OSSL_PARAM_construct_end();
 766         if (!EVP_CIPHER_CTX_set_params(ctx_base, params)) {
 767             t->err = "INVALID_CTS_MODE";
 768             goto err;
 769         }
 770     }
 771     if (expected->iv) {
 772         if (expected->aead) {
 773             if (!EVP_CIPHER_CTX_ctrl(ctx_base, EVP_CTRL_AEAD_SET_IVLEN,
 774                                      expected->iv_len, 0)) {
 775                 t->err = "INVALID_IV_LENGTH";
 776                 goto err;
 777             }
 778         } else if (expected->iv_len != (size_t)EVP_CIPHER_CTX_get_iv_length(ctx_base)) {
 779             t->err = "INVALID_IV_LENGTH";
 780             goto err;
 781         }
 782     }
 783     if (expected->aead && !expected->tls_aad) {
 784         unsigned char *tag;
 785         /*
 786          * If encrypting or OCB just set tag length initially, otherwise
 787          * set tag length and value.
 788          */
 789         if (enc || expected->aead == EVP_CIPH_OCB_MODE || expected->tag_late) {
 790             t->err = "TAG_LENGTH_SET_ERROR";
 791             tag = NULL;
 792         } else {
 793             t->err = "TAG_SET_ERROR";
 794             tag = expected->tag;
 795         }
 796         if (tag || expected->aead != EVP_CIPH_GCM_MODE) {
 797             if (!EVP_CIPHER_CTX_ctrl(ctx_base, EVP_CTRL_AEAD_SET_TAG,
 798                                      expected->tag_len, tag))
 799                 goto err;
 800         }
 801     }
 802
 803     if (expected->rounds > 0) {
 804         int  rounds = (int)expected->rounds;
 805
 806         if (!EVP_CIPHER_CTX_ctrl(ctx_base, EVP_CTRL_SET_RC5_ROUNDS, rounds, NULL)) {
 807             t->err = "INVALID_ROUNDS";
 808             goto err;
 809         }
 810     }
 811
 812     if (!EVP_CIPHER_CTX_set_key_length(ctx_base, expected->key_len)) {
 813         t->err = "INVALID_KEY_LENGTH";
 814         goto err;
 815     }
 816     if (expected->key_bits > 0) {
 817         int bits = (int)expected->key_bits;
 818
 819         if (!EVP_CIPHER_CTX_ctrl(ctx_base, EVP_CTRL_SET_RC2_KEY_BITS, bits, NULL)) {
 820             t->err = "INVALID KEY BITS";
 821             goto err;
 822         }
 823     }
 824     if (!EVP_CipherInit_ex(ctx_base, NULL, NULL, expected->key, expected->iv, -1)) {
 825         t->err = "KEY_SET_ERROR";
 826         goto err;
 827     }
 828
 829     /* Check that we get the same IV back */
 830     if (expected->iv != NULL) {
 831         /* Some (e.g., GCM) tests use IVs longer than EVP_MAX_IV_LENGTH. */
 832         unsigned char iv[128];
 833         if (!TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx_base, iv, sizeof(iv)))
 834             || ((EVP_CIPHER_get_flags(expected->cipher) & EVP_CIPH_CUSTOM_IV) == 0
 835                 && !TEST_mem_eq(expected->iv, expected->iv_len, iv,
 836                                 expected->iv_len))) {
 837             t->err = "INVALID_IV";
 838             goto err;
 839         }
 840     }
 841
 842     /* Test that the cipher dup functions correctly if it is supported */
 843     ERR_set_mark();
 844     if (EVP_CIPHER_CTX_copy(ctx, ctx_base)) {
 845         EVP_CIPHER_CTX_free(ctx_base);
 846         ctx_base = NULL;
 847     } else {
 848         EVP_CIPHER_CTX_free(ctx);
 849         ctx = ctx_base;
 850     }
 851     /* Likewise for dup */
 852     duped = EVP_CIPHER_CTX_dup(ctx);
 853     if (duped != NULL) {
 854         EVP_CIPHER_CTX_free(ctx);
 855         ctx = duped;
 856     }
 857     ERR_pop_to_mark();
 858
 859     if (expected->mac_key != NULL
 860         && !EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY,
 861                                 (int)expected->mac_key_len,
 862                                 (void *)expected->mac_key)) {
 863         t->err = "SET_MAC_KEY_ERROR";
 864         goto err;
 865     }
 866
 867     if (expected->tls_version) {
 868         OSSL_PARAM params[2];
 869
 870         params[0] = OSSL_PARAM_construct_int(OSSL_CIPHER_PARAM_TLS_VERSION,
 871                                              &expected->tls_version);
 872         params[1] = OSSL_PARAM_construct_end();
 873         if (!EVP_CIPHER_CTX_set_params(ctx, params)) {
 874             t->err = "SET_TLS_VERSION_ERROR";
 875             goto err;
 876         }
 877     }
 878
 879     if (expected->aead == EVP_CIPH_CCM_MODE) {
 880         if (!EVP_CipherUpdate(ctx, NULL, &tmplen, NULL, out_len)) {
 881             t->err = "CCM_PLAINTEXT_LENGTH_SET_ERROR";
 882             goto err;
 883         }
 884     }
 885     if (expected->aad[0] != NULL && !expected->tls_aad) {
 886         t->err = "AAD_SET_ERROR";
 887         if (!frag) {
 888             for (i = 0; expected->aad[i] != NULL; i++) {
 889                 if (!EVP_CipherUpdate(ctx, NULL, &chunklen, expected->aad[i],
 890                                       expected->aad_len[i]))
 891                     goto err;
 892             }
 893         } else {
 894             /*
 895              * Supply the AAD in chunks less than the block size where possible
 896              */
 897             for (i = 0; expected->aad[i] != NULL; i++) {
 898                 if (expected->aad_len[i] > 0) {
 899                     if (!EVP_CipherUpdate(ctx, NULL, &chunklen, expected->aad[i], 1))
 900                         goto err;
 901                     donelen++;
 902                 }
 903                 if (expected->aad_len[i] > 2) {
 904                     if (!EVP_CipherUpdate(ctx, NULL, &chunklen,
 905                                           expected->aad[i] + donelen,
 906                                           expected->aad_len[i] - 2))
 907                         goto err;
 908                     donelen += expected->aad_len[i] - 2;
 909                 }
 910                 if (expected->aad_len[i] > 1
 911                     && !EVP_CipherUpdate(ctx, NULL, &chunklen,
 912                                          expected->aad[i] + donelen, 1))
 913                     goto err;
 914             }
 915         }
 916     }
 917
 918     if (expected->tls_aad) {
 919         OSSL_PARAM params[2];
 920         char *tls_aad;
 921
 922         /* duplicate the aad as the implementation might modify it */
 923         if ((tls_aad = OPENSSL_memdup(expected->aad[0],
 924                                       expected->aad_len[0])) == NULL)
 925             goto err;
 926         params[0] = OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD,
 927                                                       tls_aad,
 928                                                       expected->aad_len[0]);
 929         params[1] = OSSL_PARAM_construct_end();
 930         if (!EVP_CIPHER_CTX_set_params(ctx, params)) {
 931             OPENSSL_free(tls_aad);
 932             t->err = "TLS1_AAD_ERROR";
 933             goto err;
 934         }
 935         OPENSSL_free(tls_aad);
 936     } else if (!enc && (expected->aead == EVP_CIPH_OCB_MODE
 937                         || expected->tag_late)) {
 938         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
 939                                  expected->tag_len, expected->tag)) {
 940             t->err = "TAG_SET_ERROR";
 941             goto err;
 942         }
 943     }
 944
 945     EVP_CIPHER_CTX_set_padding(ctx, 0);
 946     t->err = "CIPHERUPDATE_ERROR";
 947     tmplen = 0;
 948     if (!frag) {
 949         /* We supply the data all in one go */
 950         if (!EVP_CipherUpdate(ctx, tmp + out_misalign, &tmplen, in, in_len))
 951             goto err;
 952     } else {
 953         /* Supply the data in chunks less than the block size where possible */
 954         if (in_len > 0) {
 955             if (!EVP_CipherUpdate(ctx, tmp + out_misalign, &chunklen, in, 1))
 956                 goto err;
 957             tmplen += chunklen;
 958             in++;
 959             in_len--;
 960         }
 961         if (in_len > 1) {
 962             if (!EVP_CipherUpdate(ctx, tmp + out_misalign + tmplen, &chunklen,
 963                                   in, in_len - 1))
 964                 goto err;
 965             tmplen += chunklen;
 966             in += in_len - 1;
 967             in_len = 1;
 968         }
 969         if (in_len > 0) {
 970             if (!EVP_CipherUpdate(ctx, tmp + out_misalign + tmplen, &chunklen,
 971                                   in, 1))
 972                 goto err;
 973             tmplen += chunklen;
 974         }
 975     }
 976     if (!EVP_CipherFinal_ex(ctx, tmp + out_misalign + tmplen, &tmpflen)) {
 977         t->err = "CIPHERFINAL_ERROR";
 978         goto err;
 979     }
 980     if (!enc && expected->tls_aad) {
 981         if (expected->tls_version >= TLS1_1_VERSION
 982             && (EVP_CIPHER_is_a(expected->cipher, "AES-128-CBC-HMAC-SHA1")
 983                 || EVP_CIPHER_is_a(expected->cipher, "AES-256-CBC-HMAC-SHA1"))) {
 984             tmplen -= expected->iv_len;
 985             expected_out += expected->iv_len;
 986             out_misalign += expected->iv_len;
 987         }
 988         if ((int)out_len > tmplen + tmpflen)
 989             out_len = tmplen + tmpflen;
 990     }
 991     if (!memory_err_compare(t, "VALUE_MISMATCH", expected_out, out_len,
 992                             tmp + out_misalign, tmplen + tmpflen))
 993         goto err;
 994     if (enc && expected->aead && !expected->tls_aad) {
 995         unsigned char rtag[16];
 996
 997         if (!TEST_size_t_le(expected->tag_len, sizeof(rtag))) {
 998             t->err = "TAG_LENGTH_INTERNAL_ERROR";
 999             goto err;
1000         }
1001         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
1002                                  expected->tag_len, rtag)) {
1003             t->err = "TAG_RETRIEVE_ERROR";
1004             goto err;
1005         }
1006         if (!memory_err_compare(t, "TAG_VALUE_MISMATCH",
1007                                 expected->tag, expected->tag_len,
1008                                 rtag, expected->tag_len))
1009             goto err;
1010     }
1011     /* Check the updated IV */
1012     if (expected->next_iv != NULL) {
1013         /* Some (e.g., GCM) tests use IVs longer than EVP_MAX_IV_LENGTH. */
1014         unsigned char iv[128];
1015         if (!TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, iv, sizeof(iv)))
1016             || ((EVP_CIPHER_get_flags(expected->cipher) & EVP_CIPH_CUSTOM_IV) == 0
1017                 && !TEST_mem_eq(expected->next_iv, expected->iv_len, iv,
1018                                 expected->iv_len))) {
1019             t->err = "INVALID_NEXT_IV";
1020             goto err;
1021         }
1022     }
1023
1024     t->err = NULL;
1025     ok = 1;
1026  err:
1027     OPENSSL_free(tmp);
1028     if (ctx != ctx_base)
1029         EVP_CIPHER_CTX_free(ctx_base);
1030     EVP_CIPHER_CTX_free(ctx);
1031     return ok;
1032 }
1033
1034 static int cipher_test_run(EVP_TEST *t)
1035 {
1036     CIPHER_DATA *cdat = t->data;
1037     int rv, frag = 0;
1038     size_t out_misalign, inp_misalign;
1039
1040     if (!cdat->key) {
1041         t->err = "NO_KEY";
1042         return 0;
1043     }
1044     if (!cdat->iv && EVP_CIPHER_get_iv_length(cdat->cipher)) {
1045         /* IV is optional and usually omitted in wrap mode */
1046         if (EVP_CIPHER_get_mode(cdat->cipher) != EVP_CIPH_WRAP_MODE) {
1047             t->err = "NO_IV";
1048             return 0;
1049         }
1050     }
1051     if (cdat->aead && cdat->tag == NULL && !cdat->tls_aad) {
1052         t->err = "NO_TAG";
1053         return 0;
1054     }
1055     for (out_misalign = 0; out_misalign <= 1;) {
1056         static char aux_err[64];
1057         t->aux_err = aux_err;
1058         for (inp_misalign = (size_t)-1; inp_misalign != 2; inp_misalign++) {
1059             if (inp_misalign == (size_t)-1) {
1060                 /* kludge: inp_misalign == -1 means "exercise in-place" */
1061                 BIO_snprintf(aux_err, sizeof(aux_err),
1062                              "%s in-place, %sfragmented",
1063                              out_misalign ? "misaligned" : "aligned",
1064                              frag ? "" : "not ");
1065             } else {
1066                 BIO_snprintf(aux_err, sizeof(aux_err),
1067                              "%s output and %s input, %sfragmented",
1068                              out_misalign ? "misaligned" : "aligned",
1069                              inp_misalign ? "misaligned" : "aligned",
1070                              frag ? "" : "not ");
1071             }
1072             if (cdat->enc) {
1073                 rv = cipher_test_enc(t, 1, out_misalign, inp_misalign, frag);
1074                 /* Not fatal errors: return */
1075                 if (rv != 1) {
1076                     if (rv < 0)
1077                         return 0;
1078                     return 1;
1079                 }
1080             }
1081             if (cdat->enc != 1) {
1082                 rv = cipher_test_enc(t, 0, out_misalign, inp_misalign, frag);
1083                 /* Not fatal errors: return */
1084                 if (rv != 1) {
1085                     if (rv < 0)
1086                         return 0;
1087                     return 1;
1088                 }
1089             }
1090         }
1091
1092         if (out_misalign == 1 && frag == 0) {
1093             /*
1094              * XTS, SIV, CCM, stitched ciphers and Wrap modes have special
1095              * requirements about input lengths so we don't fragment for those
1096              */
1097             if (cdat->aead == EVP_CIPH_CCM_MODE
1098                 || cdat->aead == EVP_CIPH_CBC_MODE
1099                 || (cdat->aead == -1
1100                     && EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_STREAM_CIPHER)
1101                 || ((EVP_CIPHER_get_flags(cdat->cipher) & EVP_CIPH_FLAG_CTS) != 0)
1102                 || EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_SIV_MODE
1103                 || EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_XTS_MODE
1104                 || EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_WRAP_MODE)
1105                 break;
1106             out_misalign = 0;
1107             frag++;
1108         } else {
1109             out_misalign++;
1110         }
1111     }
1112     t->aux_err = NULL;
1113
1114     return 1;
1115 }
1116
1117 static const EVP_TEST_METHOD cipher_test_method = {
1118     "Cipher",
1119     cipher_test_init,
1120     cipher_test_cleanup,
1121     cipher_test_parse,
1122     cipher_test_run
1123 };
1124
1125
1126 /**
1127  **  MAC TESTS
1128  **/
1129
1130 typedef struct mac_data_st {
1131     /* MAC type in one form or another */
1132     char *mac_name;
1133     EVP_MAC *mac;                /* for mac_test_run_mac */
1134     int type;                    /* for mac_test_run_pkey */
1135     /* Algorithm string for this MAC */
1136     char *alg;
1137     /* MAC key */
1138     unsigned char *key;
1139     size_t key_len;
1140     /* MAC IV (GMAC) */
1141     unsigned char *iv;
1142     size_t iv_len;
1143     /* Input to MAC */
1144     unsigned char *input;
1145     size_t input_len;
1146     /* Expected output */
1147     unsigned char *output;
1148     size_t output_len;
1149     unsigned char *custom;
1150     size_t custom_len;
1151     /* MAC salt (blake2) */
1152     unsigned char *salt;
1153     size_t salt_len;
1154     /* XOF mode? */
1155     int xof;
1156     /* Collection of controls */
1157     STACK_OF(OPENSSL_STRING) *controls;
1158     /* Output size */
1159     int output_size;
1160     /* Block size */
1161     int block_size;
1162 } MAC_DATA;
1163
1164 static int mac_test_init(EVP_TEST *t, const char *alg)
1165 {
1166     EVP_MAC *mac = NULL;
1167     int type = NID_undef;
1168     MAC_DATA *mdat;
1169
1170     if (is_mac_disabled(alg)) {
1171         TEST_info("skipping, '%s' is disabled", alg);
1172         t->skip = 1;
1173         return 1;
1174     }
1175     if ((mac = EVP_MAC_fetch(libctx, alg, NULL)) == NULL) {
1176         /*
1177          * Since we didn't find an EVP_MAC, we check for known EVP_PKEY methods
1178          * For debugging purposes, we allow 'NNNN by EVP_PKEY' to force running
1179          * the EVP_PKEY method.
1180          */
1181         size_t sz = strlen(alg);
1182         static const char epilogue[] = " by EVP_PKEY";
1183
1184         if (sz >= sizeof(epilogue)
1185             && strcmp(alg + sz - (sizeof(epilogue) - 1), epilogue) == 0)
1186             sz -= sizeof(epilogue) - 1;
1187
1188         if (strncmp(alg, "HMAC", sz) == 0)
1189             type = EVP_PKEY_HMAC;
1190         else if (strncmp(alg, "CMAC", sz) == 0)
1191             type = EVP_PKEY_CMAC;
1192         else if (strncmp(alg, "Poly1305", sz) == 0)
1193             type = EVP_PKEY_POLY1305;
1194         else if (strncmp(alg, "SipHash", sz) == 0)
1195             type = EVP_PKEY_SIPHASH;
1196         else
1197             return 0;
1198     }
1199
1200     if (!TEST_ptr(mdat = OPENSSL_zalloc(sizeof(*mdat))))
1201         return 0;
1202
1203     mdat->type = type;
1204     if (!TEST_ptr(mdat->mac_name = OPENSSL_strdup(alg))) {
1205         OPENSSL_free(mdat);
1206         return 0;
1207     }
1208
1209     mdat->mac = mac;
1210     if (!TEST_ptr(mdat->controls = sk_OPENSSL_STRING_new_null())) {
1211         OPENSSL_free(mdat->mac_name);
1212         OPENSSL_free(mdat);
1213         return 0;
1214     }
1215
1216     mdat->output_size = mdat->block_size = -1;
1217     t->data = mdat;
1218     return 1;
1219 }
1220
1221 /* Because OPENSSL_free is a macro, it can't be passed as a function pointer */
1222 static void openssl_free(char *m)
1223 {
1224     OPENSSL_free(m);
1225 }
1226
1227 static void mac_test_cleanup(EVP_TEST *t)
1228 {
1229     MAC_DATA *mdat = t->data;
1230
1231     EVP_MAC_free(mdat->mac);
1232     OPENSSL_free(mdat->mac_name);
1233     sk_OPENSSL_STRING_pop_free(mdat->controls, openssl_free);
1234     OPENSSL_free(mdat->alg);
1235     OPENSSL_free(mdat->key);
1236     OPENSSL_free(mdat->iv);
1237     OPENSSL_free(mdat->custom);
1238     OPENSSL_free(mdat->salt);
1239     OPENSSL_free(mdat->input);
1240     OPENSSL_free(mdat->output);
1241 }
1242
1243 static int mac_test_parse(EVP_TEST *t,
1244                           const char *keyword, const char *value)
1245 {
1246     MAC_DATA *mdata = t->data;
1247
1248     if (strcmp(keyword, "Key") == 0)
1249         return parse_bin(value, &mdata->key, &mdata->key_len);
1250     if (strcmp(keyword, "IV") == 0)
1251         return parse_bin(value, &mdata->iv, &mdata->iv_len);
1252     if (strcmp(keyword, "Custom") == 0)
1253         return parse_bin(value, &mdata->custom, &mdata->custom_len);
1254     if (strcmp(keyword, "Salt") == 0)
1255         return parse_bin(value, &mdata->salt, &mdata->salt_len);
1256     if (strcmp(keyword, "Algorithm") == 0) {
1257         mdata->alg = OPENSSL_strdup(value);
1258         if (!mdata->alg)
1259             return -1;
1260         return 1;
1261     }
1262     if (strcmp(keyword, "Input") == 0)
1263         return parse_bin(value, &mdata->input, &mdata->input_len);
1264     if (strcmp(keyword, "Output") == 0)
1265         return parse_bin(value, &mdata->output, &mdata->output_len);
1266     if (strcmp(keyword, "XOF") == 0)
1267         return mdata->xof = 1;
1268     if (strcmp(keyword, "Ctrl") == 0)
1269         return sk_OPENSSL_STRING_push(mdata->controls,
1270                                       OPENSSL_strdup(value)) != 0;
1271     if (strcmp(keyword, "OutputSize") == 0) {
1272         mdata->output_size = atoi(value);
1273         if (mdata->output_size < 0)
1274             return -1;
1275         return 1;
1276     }
1277     if (strcmp(keyword, "BlockSize") == 0) {
1278         mdata->block_size = atoi(value);
1279         if (mdata->block_size < 0)
1280             return -1;
1281         return 1;
1282     }
1283     return 0;
1284 }
1285
1286 static int mac_test_ctrl_pkey(EVP_TEST *t, EVP_PKEY_CTX *pctx,
1287                               const char *value)
1288 {
1289     int rv = 0;
1290     char *p, *tmpval;
1291
1292     if (!TEST_ptr(tmpval = OPENSSL_strdup(value)))
1293         return 0;
1294     p = strchr(tmpval, ':');
1295     if (p != NULL) {
1296         *p++ = '\0';
1297         rv = EVP_PKEY_CTX_ctrl_str(pctx, tmpval, p);
1298     }
1299     if (rv == -2)
1300         t->err = "PKEY_CTRL_INVALID";
1301     else if (rv <= 0)
1302         t->err = "PKEY_CTRL_ERROR";
1303     else
1304         rv = 1;
1305     OPENSSL_free(tmpval);
1306     return rv > 0;
1307 }
1308
1309 static int mac_test_run_pkey(EVP_TEST *t)
1310 {
1311     MAC_DATA *expected = t->data;
1312     EVP_MD_CTX *mctx = NULL;
1313     EVP_PKEY_CTX *pctx = NULL, *genctx = NULL;
1314     EVP_PKEY *key = NULL;
1315     const char *mdname = NULL;
1316     EVP_CIPHER *cipher = NULL;
1317     unsigned char *got = NULL;
1318     size_t got_len;
1319     int i;
1320
1321     /* We don't do XOF mode via PKEY */
1322     if (expected->xof)
1323         return 1;
1324
1325     if (expected->alg == NULL)
1326         TEST_info("Trying the EVP_PKEY %s test", OBJ_nid2sn(expected->type));
1327     else
1328         TEST_info("Trying the EVP_PKEY %s test with %s",
1329                   OBJ_nid2sn(expected->type), expected->alg);
1330
1331     if (expected->type == EVP_PKEY_CMAC) {
1332 #ifdef OPENSSL_NO_DEPRECATED_3_0
1333         TEST_info("skipping, PKEY CMAC '%s' is disabled", expected->alg);
1334         t->skip = 1;
1335         t->err = NULL;
1336         goto err;
1337 #else
1338         OSSL_LIB_CTX *tmpctx;
1339
1340         if (expected->alg != NULL && is_cipher_disabled(expected->alg)) {
1341             TEST_info("skipping, PKEY CMAC '%s' is disabled", expected->alg);
1342             t->skip = 1;
1343             t->err = NULL;
1344             goto err;
1345         }
1346         if (!TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, expected->alg, NULL))) {
1347             t->err = "MAC_KEY_CREATE_ERROR";
1348             goto err;
1349         }
1350         tmpctx = OSSL_LIB_CTX_set0_default(libctx);
1351         key = EVP_PKEY_new_CMAC_key(NULL, expected->key, expected->key_len,
1352                                     cipher);
1353         OSSL_LIB_CTX_set0_default(tmpctx);
1354 #endif
1355     } else {
1356         key = EVP_PKEY_new_raw_private_key_ex(libctx,
1357                                               OBJ_nid2sn(expected->type), NULL,
1358                                               expected->key, expected->key_len);
1359     }
1360     if (key == NULL) {
1361         t->err = "MAC_KEY_CREATE_ERROR";
1362         goto err;
1363     }
1364
1365     if (expected->type == EVP_PKEY_HMAC && expected->alg != NULL) {
1366         if (is_digest_disabled(expected->alg)) {
1367             TEST_info("skipping, HMAC '%s' is disabled", expected->alg);
1368             t->skip = 1;
1369             t->err = NULL;
1370             goto err;
1371         }
1372         mdname = expected->alg;
1373     }
1374     if (!TEST_ptr(mctx = EVP_MD_CTX_new())) {
1375         t->err = "INTERNAL_ERROR";
1376         goto err;
1377     }
1378     if (!EVP_DigestSignInit_ex(mctx, &pctx, mdname, libctx, NULL, key, NULL)) {
1379         t->err = "DIGESTSIGNINIT_ERROR";
1380         goto err;
1381     }
1382     for (i = 0; i < sk_OPENSSL_STRING_num(expected->controls); i++)
1383         if (!mac_test_ctrl_pkey(t, pctx,
1384                                 sk_OPENSSL_STRING_value(expected->controls,
1385                                                         i))) {
1386             t->err = "EVPPKEYCTXCTRL_ERROR";
1387             goto err;
1388         }
1389     if (!EVP_DigestSignUpdate(mctx, expected->input, expected->input_len)) {
1390         t->err = "DIGESTSIGNUPDATE_ERROR";
1391         goto err;
1392     }
1393     if (!EVP_DigestSignFinal(mctx, NULL, &got_len)) {
1394         t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";
1395         goto err;
1396     }
1397     if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
1398         t->err = "TEST_FAILURE";
1399         goto err;
1400     }
1401     if (!EVP_DigestSignFinal(mctx, got, &got_len)
1402             || !memory_err_compare(t, "TEST_MAC_ERR",
1403                                    expected->output, expected->output_len,
1404                                    got, got_len)) {
1405         t->err = "TEST_MAC_ERR";
1406         goto err;
1407     }
1408     t->err = NULL;
1409  err:
1410     EVP_CIPHER_free(cipher);
1411     EVP_MD_CTX_free(mctx);
1412     OPENSSL_free(got);
1413     EVP_PKEY_CTX_free(genctx);
1414     EVP_PKEY_free(key);
1415     return 1;
1416 }
1417
1418 static int mac_test_run_mac(EVP_TEST *t)
1419 {
1420     MAC_DATA *expected = t->data;
1421     EVP_MAC_CTX *ctx = NULL;
1422     unsigned char *got = NULL;
1423     size_t got_len = 0, size = 0;
1424     int i, block_size = -1, output_size = -1;
1425     OSSL_PARAM params[21], sizes[3], *psizes = sizes;
1426     size_t params_n = 0;
1427     size_t params_n_allocstart = 0;
1428     const OSSL_PARAM *defined_params =
1429         EVP_MAC_settable_ctx_params(expected->mac);
1430     int xof;
1431
1432     if (expected->alg == NULL)
1433         TEST_info("Trying the EVP_MAC %s test", expected->mac_name);
1434     else
1435         TEST_info("Trying the EVP_MAC %s test with %s",
1436                   expected->mac_name, expected->alg);
1437
1438     if (expected->alg != NULL) {
1439         /*
1440          * The underlying algorithm may be a cipher or a digest.
1441          * We don't know which it is, but we can ask the MAC what it
1442          * should be and bet on that.
1443          */
1444         if (OSSL_PARAM_locate_const(defined_params,
1445                                     OSSL_MAC_PARAM_CIPHER) != NULL) {
1446             params[params_n++] =
1447                 OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_CIPHER,
1448                                                  expected->alg, 0);
1449         } else if (OSSL_PARAM_locate_const(defined_params,
1450                                            OSSL_MAC_PARAM_DIGEST) != NULL) {
1451             params[params_n++] =
1452                 OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
1453                                                  expected->alg, 0);
1454         } else {
1455             t->err = "MAC_BAD_PARAMS";
1456             goto err;
1457         }
1458     }
1459     if (expected->custom != NULL)
1460         params[params_n++] =
1461             OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_CUSTOM,
1462                                               expected->custom,
1463                                               expected->custom_len);
1464     if (expected->salt != NULL)
1465         params[params_n++] =
1466             OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_SALT,
1467                                               expected->salt,
1468                                               expected->salt_len);
1469     if (expected->iv != NULL)
1470         params[params_n++] =
1471             OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_IV,
1472                                               expected->iv,
1473                                               expected->iv_len);
1474
1475     /* Unknown controls.  They must match parameters that the MAC recognizes */
1476     if (params_n + sk_OPENSSL_STRING_num(expected->controls)
1477         >= OSSL_NELEM(params)) {
1478         t->err = "MAC_TOO_MANY_PARAMETERS";
1479         goto err;
1480     }
1481     params_n_allocstart = params_n;
1482     for (i = 0; i < sk_OPENSSL_STRING_num(expected->controls); i++) {
1483         char *tmpkey, *tmpval;
1484         char *value = sk_OPENSSL_STRING_value(expected->controls, i);
1485
1486         if (!TEST_ptr(tmpkey = OPENSSL_strdup(value))) {
1487             t->err = "MAC_PARAM_ERROR";
1488             goto err;
1489         }
1490         tmpval = strchr(tmpkey, ':');
1491         if (tmpval != NULL)
1492             *tmpval++ = '\0';
1493
1494         if (tmpval == NULL
1495             || !OSSL_PARAM_allocate_from_text(&params[params_n],
1496                                               defined_params,
1497                                               tmpkey, tmpval,
1498                                               strlen(tmpval), NULL)) {
1499             OPENSSL_free(tmpkey);
1500             t->err = "MAC_PARAM_ERROR";
1501             goto err;
1502         }
1503         params_n++;
1504
1505         OPENSSL_free(tmpkey);
1506     }
1507     params[params_n] = OSSL_PARAM_construct_end();
1508
1509     if ((ctx = EVP_MAC_CTX_new(expected->mac)) == NULL) {
1510         t->err = "MAC_CREATE_ERROR";
1511         goto err;
1512     }
1513
1514     if (!EVP_MAC_init(ctx, expected->key, expected->key_len, params)) {
1515         t->err = "MAC_INIT_ERROR";
1516         goto err;
1517     }
1518     if (expected->output_size >= 0)
1519         *psizes++ = OSSL_PARAM_construct_int(OSSL_MAC_PARAM_SIZE,
1520                                              &output_size);
1521     if (expected->block_size >= 0)
1522         *psizes++ = OSSL_PARAM_construct_int(OSSL_MAC_PARAM_BLOCK_SIZE,
1523                                              &block_size);
1524     if (psizes != sizes) {
1525         *psizes = OSSL_PARAM_construct_end();
1526         if (!TEST_true(EVP_MAC_CTX_get_params(ctx, sizes))) {
1527             t->err = "INTERNAL_ERROR";
1528             goto err;
1529         }
1530         if (expected->output_size >= 0
1531                 && !TEST_int_eq(output_size, expected->output_size)) {
1532             t->err = "TEST_FAILURE";
1533             goto err;
1534         }
1535         if (expected->block_size >= 0
1536                 && !TEST_int_eq(block_size, expected->block_size)) {
1537             t->err = "TEST_FAILURE";
1538             goto err;
1539         }
1540     }
1541     if (!EVP_MAC_update(ctx, expected->input, expected->input_len)) {
1542         t->err = "MAC_UPDATE_ERROR";
1543         goto err;
1544     }
1545     xof = expected->xof;
1546     if (xof) {
1547         if (!TEST_ptr(got = OPENSSL_malloc(expected->output_len))) {
1548             t->err = "TEST_FAILURE";
1549             goto err;
1550         }
1551         if (!EVP_MAC_finalXOF(ctx, got, expected->output_len)
1552             || !memory_err_compare(t, "TEST_MAC_ERR",
1553                                    expected->output, expected->output_len,
1554                                    got, expected->output_len)) {
1555             t->err = "MAC_FINAL_ERROR";
1556             goto err;
1557         }
1558     } else {
1559         if (!EVP_MAC_final(ctx, NULL, &got_len, 0)) {
1560             t->err = "MAC_FINAL_LENGTH_ERROR";
1561             goto err;
1562         }
1563         if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
1564             t->err = "TEST_FAILURE";
1565             goto err;
1566         }
1567         if (!EVP_MAC_final(ctx, got, &got_len, got_len)
1568             || !memory_err_compare(t, "TEST_MAC_ERR",
1569                                    expected->output, expected->output_len,
1570                                    got, got_len)) {
1571             t->err = "TEST_MAC_ERR";
1572             goto err;
1573         }
1574     }
1575     t->err = NULL;
1576
1577     /* Test the EVP_Q_mac interface as well */
1578     if (!xof) {
1579         OPENSSL_cleanse(got, got_len);
1580         if (!TEST_true(EVP_Q_mac(libctx, expected->mac_name, NULL,
1581                                  expected->alg, params,
1582                                  expected->key, expected->key_len,
1583                                  expected->input, expected->input_len,
1584                                  got, got_len, &size))
1585                 || !TEST_mem_eq(got, size,
1586                                 expected->output, expected->output_len)) {
1587             t->err = "EVP_Q_mac failed";
1588             goto err;
1589         }
1590     }
1591  err:
1592     while (params_n-- > params_n_allocstart) {
1593         OPENSSL_free(params[params_n].data);
1594     }
1595     EVP_MAC_CTX_free(ctx);
1596     OPENSSL_free(got);
1597     return 1;
1598 }
1599
1600 static int mac_test_run(EVP_TEST *t)
1601 {
1602     MAC_DATA *expected = t->data;
1603
1604     if (expected->mac != NULL)
1605         return mac_test_run_mac(t);
1606     return mac_test_run_pkey(t);
1607 }
1608
1609 static const EVP_TEST_METHOD mac_test_method = {
1610     "MAC",
1611     mac_test_init,
1612     mac_test_cleanup,
1613     mac_test_parse,
1614     mac_test_run
1615 };
1616
1617
1618 /**
1619  **  PUBLIC KEY TESTS
1620  **  These are all very similar and share much common code.
1621  **/
1622
1623 typedef struct pkey_data_st {
1624     /* Context for this operation */
1625     EVP_PKEY_CTX *ctx;
1626     /* Key operation to perform */
1627     int (*keyop) (EVP_PKEY_CTX *ctx,
1628                   unsigned char *sig, size_t *siglen,
1629                   const unsigned char *tbs, size_t tbslen);
1630     /* Input to MAC */
1631     unsigned char *input;
1632     size_t input_len;
1633     /* Expected output */
1634     unsigned char *output;
1635     size_t output_len;
1636 } PKEY_DATA;
1637
1638 /*
1639  * Perform public key operation setup: lookup key, allocated ctx and call
1640  * the appropriate initialisation function
1641  */
1642 static int pkey_test_init(EVP_TEST *t, const char *name,
1643                           int use_public,
1644                           int (*keyopinit) (EVP_PKEY_CTX *ctx),
1645                           int (*keyop)(EVP_PKEY_CTX *ctx,
1646                                        unsigned char *sig, size_t *siglen,
1647                                        const unsigned char *tbs,
1648                                        size_t tbslen))
1649 {
1650     PKEY_DATA *kdata;
1651     EVP_PKEY *pkey = NULL;
1652     int rv = 0;
1653
1654     if (use_public)
1655         rv = find_key(&pkey, name, public_keys);
1656     if (rv == 0)
1657         rv = find_key(&pkey, name, private_keys);
1658     if (rv == 0 || pkey == NULL) {
1659         TEST_info("skipping, key '%s' is disabled", name);
1660         t->skip = 1;
1661         return 1;
1662     }
1663
1664     if (!TEST_ptr(kdata = OPENSSL_zalloc(sizeof(*kdata)))) {
1665         EVP_PKEY_free(pkey);
1666         return 0;
1667     }
1668     kdata->keyop = keyop;
1669     if (!TEST_ptr(kdata->ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, NULL))) {
1670         EVP_PKEY_free(pkey);
1671         OPENSSL_free(kdata);
1672         return 0;
1673     }
1674     if (keyopinit(kdata->ctx) <= 0)
1675         t->err = "KEYOP_INIT_ERROR";
1676     t->data = kdata;
1677     return 1;
1678 }
1679
1680 static void pkey_test_cleanup(EVP_TEST *t)
1681 {
1682     PKEY_DATA *kdata = t->data;
1683
1684     OPENSSL_free(kdata->input);
1685     OPENSSL_free(kdata->output);
1686     EVP_PKEY_CTX_free(kdata->ctx);
1687 }
1688
1689 static int pkey_test_ctrl(EVP_TEST *t, EVP_PKEY_CTX *pctx,
1690                           const char *value)
1691 {
1692     int rv = 0;
1693     char *p, *tmpval;
1694
1695     if (!TEST_ptr(tmpval = OPENSSL_strdup(value)))
1696         return 0;
1697     p = strchr(tmpval, ':');
1698     if (p != NULL) {
1699         *p++ = '\0';
1700         rv = EVP_PKEY_CTX_ctrl_str(pctx, tmpval, p);
1701     }
1702     if (rv == -2) {
1703         t->err = "PKEY_CTRL_INVALID";
1704         rv = 1;
1705     } else if (p != NULL && rv <= 0) {
1706         if (is_digest_disabled(p) || is_cipher_disabled(p)) {
1707             TEST_info("skipping, '%s' is disabled", p);
1708             t->skip = 1;
1709             rv = 1;
1710         } else {
1711             t->err = "PKEY_CTRL_ERROR";
1712             rv = 1;
1713         }
1714     }
1715     OPENSSL_free(tmpval);
1716     return rv > 0;
1717 }
1718
1719 static int pkey_test_parse(EVP_TEST *t,
1720                            const char *keyword, const char *value)
1721 {
1722     PKEY_DATA *kdata = t->data;
1723     if (strcmp(keyword, "Input") == 0)
1724         return parse_bin(value, &kdata->input, &kdata->input_len);
1725     if (strcmp(keyword, "Output") == 0)
1726         return parse_bin(value, &kdata->output, &kdata->output_len);
1727     if (strcmp(keyword, "Ctrl") == 0)
1728         return pkey_test_ctrl(t, kdata->ctx, value);
1729     return 0;
1730 }
1731
1732 static int pkey_test_run(EVP_TEST *t)
1733 {
1734     PKEY_DATA *expected = t->data;
1735     unsigned char *got = NULL;
1736     size_t got_len;
1737     EVP_PKEY_CTX *copy = NULL;
1738
1739     if (expected->keyop(expected->ctx, NULL, &got_len,
1740                         expected->input, expected->input_len) <= 0
1741             || !TEST_ptr(got = OPENSSL_malloc(got_len))) {
1742         t->err = "KEYOP_LENGTH_ERROR";
1743         goto err;
1744     }
1745     if (expected->keyop(expected->ctx, got, &got_len,
1746                         expected->input, expected->input_len) <= 0) {
1747         t->err = "KEYOP_ERROR";
1748         goto err;
1749     }
1750     if (!memory_err_compare(t, "KEYOP_MISMATCH",
1751                             expected->output, expected->output_len,
1752                             got, got_len))
1753         goto err;
1754
1755     t->err = NULL;
1756     OPENSSL_free(got);
1757     got = NULL;
1758
1759     /* Repeat the test on a copy. */
1760     if (!TEST_ptr(copy = EVP_PKEY_CTX_dup(expected->ctx))) {
1761         t->err = "INTERNAL_ERROR";
1762         goto err;
1763     }
1764     if (expected->keyop(copy, NULL, &got_len, expected->input,
1765                         expected->input_len) <= 0
1766             || !TEST_ptr(got = OPENSSL_malloc(got_len))) {
1767         t->err = "KEYOP_LENGTH_ERROR";
1768         goto err;
1769     }
1770     if (expected->keyop(copy, got, &got_len, expected->input,
1771                         expected->input_len) <= 0) {
1772         t->err = "KEYOP_ERROR";
1773         goto err;
1774     }
1775     if (!memory_err_compare(t, "KEYOP_MISMATCH",
1776                             expected->output, expected->output_len,
1777                             got, got_len))
1778         goto err;
1779
1780  err:
1781     OPENSSL_free(got);
1782     EVP_PKEY_CTX_free(copy);
1783     return 1;
1784 }
1785
1786 static int sign_test_init(EVP_TEST *t, const char *name)
1787 {
1788     return pkey_test_init(t, name, 0, EVP_PKEY_sign_init, EVP_PKEY_sign);
1789 }
1790
1791 static const EVP_TEST_METHOD psign_test_method = {
1792     "Sign",
1793     sign_test_init,
1794     pkey_test_cleanup,
1795     pkey_test_parse,
1796     pkey_test_run
1797 };
1798
1799 static int verify_recover_test_init(EVP_TEST *t, const char *name)
1800 {
1801     return pkey_test_init(t, name, 1, EVP_PKEY_verify_recover_init,
1802                           EVP_PKEY_verify_recover);
1803 }
1804
1805 static const EVP_TEST_METHOD pverify_recover_test_method = {
1806     "VerifyRecover",
1807     verify_recover_test_init,
1808     pkey_test_cleanup,
1809     pkey_test_parse,
1810     pkey_test_run
1811 };
1812
1813 static int decrypt_test_init(EVP_TEST *t, const char *name)
1814 {
1815     return pkey_test_init(t, name, 0, EVP_PKEY_decrypt_init,
1816                           EVP_PKEY_decrypt);
1817 }
1818
1819 static const EVP_TEST_METHOD pdecrypt_test_method = {
1820     "Decrypt",
1821     decrypt_test_init,
1822     pkey_test_cleanup,
1823     pkey_test_parse,
1824     pkey_test_run
1825 };
1826
1827 static int verify_test_init(EVP_TEST *t, const char *name)
1828 {
1829     return pkey_test_init(t, name, 1, EVP_PKEY_verify_init, 0);
1830 }
1831
1832 static int verify_test_run(EVP_TEST *t)
1833 {
1834     PKEY_DATA *kdata = t->data;
1835
1836     if (EVP_PKEY_verify(kdata->ctx, kdata->output, kdata->output_len,
1837                         kdata->input, kdata->input_len) <= 0)
1838         t->err = "VERIFY_ERROR";
1839     return 1;
1840 }
1841
1842 static const EVP_TEST_METHOD pverify_test_method = {
1843     "Verify",
1844     verify_test_init,
1845     pkey_test_cleanup,
1846     pkey_test_parse,
1847     verify_test_run
1848 };
1849
1850 static int pderive_test_init(EVP_TEST *t, const char *name)
1851 {
1852     return pkey_test_init(t, name, 0, EVP_PKEY_derive_init, 0);
1853 }
1854
1855 static int pderive_test_parse(EVP_TEST *t,
1856                               const char *keyword, const char *value)
1857 {
1858     PKEY_DATA *kdata = t->data;
1859     int validate = 0;
1860
1861     if (strcmp(keyword, "PeerKeyValidate") == 0)
1862         validate = 1;
1863
1864     if (validate || strcmp(keyword, "PeerKey") == 0) {
1865         EVP_PKEY *peer;
1866         if (find_key(&peer, value, public_keys) == 0)
1867             return -1;
1868         if (EVP_PKEY_derive_set_peer_ex(kdata->ctx, peer, validate) <= 0) {
1869             t->err = "DERIVE_SET_PEER_ERROR";
1870             return 1;
1871         }
1872         t->err = NULL;
1873         return 1;
1874     }
1875     if (strcmp(keyword, "SharedSecret") == 0)
1876         return parse_bin(value, &kdata->output, &kdata->output_len);
1877     if (strcmp(keyword, "Ctrl") == 0)
1878         return pkey_test_ctrl(t, kdata->ctx, value);
1879     if (strcmp(keyword, "KDFType") == 0) {
1880         OSSL_PARAM params[2];
1881
1882         params[0] = OSSL_PARAM_construct_utf8_string(OSSL_EXCHANGE_PARAM_KDF_TYPE,
1883                                                      (char *)value, 0);
1884         params[1] = OSSL_PARAM_construct_end();
1885         if (EVP_PKEY_CTX_set_params(kdata->ctx, params) == 0)
1886             return -1;
1887         return 1;
1888     }
1889     if (strcmp(keyword, "KDFDigest") == 0) {
1890         OSSL_PARAM params[2];
1891
1892         params[0] = OSSL_PARAM_construct_utf8_string(OSSL_EXCHANGE_PARAM_KDF_DIGEST,
1893                                                      (char *)value, 0);
1894         params[1] = OSSL_PARAM_construct_end();
1895         if (EVP_PKEY_CTX_set_params(kdata->ctx, params) == 0)
1896             return -1;
1897         return 1;
1898     }
1899     if (strcmp(keyword, "CEKAlg") == 0) {
1900         OSSL_PARAM params[2];
1901
1902         params[0] = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_CEK_ALG,
1903                                                      (char *)value, 0);
1904         params[1] = OSSL_PARAM_construct_end();
1905         if (EVP_PKEY_CTX_set_params(kdata->ctx, params) == 0)
1906             return -1;
1907         return 1;
1908     }
1909     if (strcmp(keyword, "KDFOutlen") == 0) {
1910         OSSL_PARAM params[2];
1911         char *endptr;
1912         size_t outlen = (size_t)strtoul(value, &endptr, 0);
1913
1914         if (endptr[0] != '\0')
1915             return -1;
1916
1917         params[0] = OSSL_PARAM_construct_size_t(OSSL_EXCHANGE_PARAM_KDF_OUTLEN,
1918                                                 &outlen);
1919         params[1] = OSSL_PARAM_construct_end();
1920         if (EVP_PKEY_CTX_set_params(kdata->ctx, params) == 0)
1921             return -1;
1922         return 1;
1923     }
1924     return 0;
1925 }
1926
1927 static int pderive_test_run(EVP_TEST *t)
1928 {
1929     EVP_PKEY_CTX *dctx = NULL;
1930     PKEY_DATA *expected = t->data;
1931     unsigned char *got = NULL;
1932     size_t got_len;
1933
1934     if (!TEST_ptr(dctx = EVP_PKEY_CTX_dup(expected->ctx))) {
1935         t->err = "DERIVE_ERROR";
1936         goto err;
1937     }
1938
1939     if (EVP_PKEY_derive(dctx, NULL, &got_len) <= 0
1940         || !TEST_size_t_ne(got_len, 0)) {
1941         t->err = "DERIVE_ERROR";
1942         goto err;
1943     }
1944     if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
1945         t->err = "DERIVE_ERROR";
1946         goto err;
1947     }
1948     if (EVP_PKEY_derive(dctx, got, &got_len) <= 0) {
1949         t->err = "DERIVE_ERROR";
1950         goto err;
1951     }
1952     if (!memory_err_compare(t, "SHARED_SECRET_MISMATCH",
1953                             expected->output, expected->output_len,
1954                             got, got_len))
1955         goto err;
1956
1957     t->err = NULL;
1958  err:
1959     OPENSSL_free(got);
1960     EVP_PKEY_CTX_free(dctx);
1961     return 1;
1962 }
1963
1964 static const EVP_TEST_METHOD pderive_test_method = {
1965     "Derive",
1966     pderive_test_init,
1967     pkey_test_cleanup,
1968     pderive_test_parse,
1969     pderive_test_run
1970 };
1971
1972
1973 /**
1974  **  PBE TESTS
1975  **/
1976
1977 typedef enum pbe_type_enum {
1978     PBE_TYPE_INVALID = 0,
1979     PBE_TYPE_SCRYPT, PBE_TYPE_PBKDF2, PBE_TYPE_PKCS12
1980 } PBE_TYPE;
1981
1982 typedef struct pbe_data_st {
1983     PBE_TYPE pbe_type;
1984         /* scrypt parameters */
1985     uint64_t N, r, p, maxmem;
1986         /* PKCS#12 parameters */
1987     int id, iter;
1988     const EVP_MD *md;
1989         /* password */
1990     unsigned char *pass;
1991     size_t pass_len;
1992         /* salt */
1993     unsigned char *salt;
1994     size_t salt_len;
1995         /* Expected output */
1996     unsigned char *key;
1997     size_t key_len;
1998 } PBE_DATA;
1999
2000 #ifndef OPENSSL_NO_SCRYPT
2001 /* Parse unsigned decimal 64 bit integer value */
2002 static int parse_uint64(const char *value, uint64_t *pr)
2003 {
2004     const char *p = value;
2005
2006     if (!TEST_true(*p)) {
2007         TEST_info("Invalid empty integer value");
2008         return -1;
2009     }
2010     for (*pr = 0; *p; ) {
2011         if (*pr > UINT64_MAX / 10) {
2012             TEST_error("Integer overflow in string %s", value);
2013             return -1;
2014         }
2015         *pr *= 10;
2016         if (!TEST_true(isdigit((unsigned char)*p))) {
2017             TEST_error("Invalid character in string %s", value);
2018             return -1;
2019         }
2020         *pr += *p - '0';
2021         p++;
2022     }
2023     return 1;
2024 }
2025
2026 static int scrypt_test_parse(EVP_TEST *t,
2027                              const char *keyword, const char *value)
2028 {
2029     PBE_DATA *pdata = t->data;
2030
2031     if (strcmp(keyword, "N") == 0)
2032         return parse_uint64(value, &pdata->N);
2033     if (strcmp(keyword, "p") == 0)
2034         return parse_uint64(value, &pdata->p);
2035     if (strcmp(keyword, "r") == 0)
2036         return parse_uint64(value, &pdata->r);
2037     if (strcmp(keyword, "maxmem") == 0)
2038         return parse_uint64(value, &pdata->maxmem);
2039     return 0;
2040 }
2041 #endif
2042
2043 static int pbkdf2_test_parse(EVP_TEST *t,
2044                              const char *keyword, const char *value)
2045 {
2046     PBE_DATA *pdata = t->data;
2047
2048     if (strcmp(keyword, "iter") == 0) {
2049         pdata->iter = atoi(value);
2050         if (pdata->iter <= 0)
2051             return -1;
2052         return 1;
2053     }
2054     if (strcmp(keyword, "MD") == 0) {
2055         pdata->md = EVP_get_digestbyname(value);
2056         if (pdata->md == NULL)
2057             return -1;
2058         return 1;
2059     }
2060     return 0;
2061 }
2062
2063 static int pkcs12_test_parse(EVP_TEST *t,
2064                              const char *keyword, const char *value)
2065 {
2066     PBE_DATA *pdata = t->data;
2067
2068     if (strcmp(keyword, "id") == 0) {
2069         pdata->id = atoi(value);
2070         if (pdata->id <= 0)
2071             return -1;
2072         return 1;
2073     }
2074     return pbkdf2_test_parse(t, keyword, value);
2075 }
2076
2077 static int pbe_test_init(EVP_TEST *t, const char *alg)
2078 {
2079     PBE_DATA *pdat;
2080     PBE_TYPE pbe_type = PBE_TYPE_INVALID;
2081
2082     if (is_kdf_disabled(alg)) {
2083         TEST_info("skipping, '%s' is disabled", alg);
2084         t->skip = 1;
2085         return 1;
2086     }
2087     if (strcmp(alg, "scrypt") == 0) {
2088         pbe_type = PBE_TYPE_SCRYPT;
2089     } else if (strcmp(alg, "pbkdf2") == 0) {
2090         pbe_type = PBE_TYPE_PBKDF2;
2091     } else if (strcmp(alg, "pkcs12") == 0) {
2092         pbe_type = PBE_TYPE_PKCS12;
2093     } else {
2094         TEST_error("Unknown pbe algorithm %s", alg);
2095         return 0;
2096     }
2097     if (!TEST_ptr(pdat = OPENSSL_zalloc(sizeof(*pdat))))
2098         return 0;
2099     pdat->pbe_type = pbe_type;
2100     t->data = pdat;
2101     return 1;
2102 }
2103
2104 static void pbe_test_cleanup(EVP_TEST *t)
2105 {
2106     PBE_DATA *pdat = t->data;
2107
2108     OPENSSL_free(pdat->pass);
2109     OPENSSL_free(pdat->salt);
2110     OPENSSL_free(pdat->key);
2111 }
2112
2113 static int pbe_test_parse(EVP_TEST *t,
2114                           const char *keyword, const char *value)
2115 {
2116     PBE_DATA *pdata = t->data;
2117
2118     if (strcmp(keyword, "Password") == 0)
2119         return parse_bin(value, &pdata->pass, &pdata->pass_len);
2120     if (strcmp(keyword, "Salt") == 0)
2121         return parse_bin(value, &pdata->salt, &pdata->salt_len);
2122     if (strcmp(keyword, "Key") == 0)
2123         return parse_bin(value, &pdata->key, &pdata->key_len);
2124     if (pdata->pbe_type == PBE_TYPE_PBKDF2)
2125         return pbkdf2_test_parse(t, keyword, value);
2126     else if (pdata->pbe_type == PBE_TYPE_PKCS12)
2127         return pkcs12_test_parse(t, keyword, value);
2128 #ifndef OPENSSL_NO_SCRYPT
2129     else if (pdata->pbe_type == PBE_TYPE_SCRYPT)
2130         return scrypt_test_parse(t, keyword, value);
2131 #endif
2132     return 0;
2133 }
2134
2135 static int pbe_test_run(EVP_TEST *t)
2136 {
2137     PBE_DATA *expected = t->data;
2138     unsigned char *key;
2139     EVP_MD *fetched_digest = NULL;
2140     OSSL_LIB_CTX *save_libctx;
2141
2142     save_libctx = OSSL_LIB_CTX_set0_default(libctx);
2143
2144     if (!TEST_ptr(key = OPENSSL_malloc(expected->key_len))) {
2145         t->err = "INTERNAL_ERROR";
2146         goto err;
2147     }
2148     if (expected->pbe_type == PBE_TYPE_PBKDF2) {
2149         if (PKCS5_PBKDF2_HMAC((char *)expected->pass, expected->pass_len,
2150                               expected->salt, expected->salt_len,
2151                               expected->iter, expected->md,
2152                               expected->key_len, key) == 0) {
2153             t->err = "PBKDF2_ERROR";
2154             goto err;
2155         }
2156 #ifndef OPENSSL_NO_SCRYPT
2157     } else if (expected->pbe_type == PBE_TYPE_SCRYPT) {
2158         if (EVP_PBE_scrypt((const char *)expected->pass, expected->pass_len,
2159                             expected->salt, expected->salt_len,
2160                             expected->N, expected->r, expected->p,
2161                             expected->maxmem, key, expected->key_len) == 0) {
2162             t->err = "SCRYPT_ERROR";
2163             goto err;
2164         }
2165 #endif
2166     } else if (expected->pbe_type == PBE_TYPE_PKCS12) {
2167         fetched_digest = EVP_MD_fetch(libctx, EVP_MD_get0_name(expected->md),
2168                                       NULL);
2169         if (fetched_digest == NULL) {
2170             t->err = "PKCS12_ERROR";
2171             goto err;
2172         }
2173         if (PKCS12_key_gen_uni(expected->pass, expected->pass_len,
2174                                expected->salt, expected->salt_len,
2175                                expected->id, expected->iter, expected->key_len,
2176                                key, fetched_digest) == 0) {
2177             t->err = "PKCS12_ERROR";
2178             goto err;
2179         }
2180     }
2181     if (!memory_err_compare(t, "KEY_MISMATCH", expected->key, expected->key_len,
2182                             key, expected->key_len))
2183         goto err;
2184
2185     t->err = NULL;
2186 err:
2187     EVP_MD_free(fetched_digest);
2188     OPENSSL_free(key);
2189     OSSL_LIB_CTX_set0_default(save_libctx);
2190     return 1;
2191 }
2192
2193 static const EVP_TEST_METHOD pbe_test_method = {
2194     "PBE",
2195     pbe_test_init,
2196     pbe_test_cleanup,
2197     pbe_test_parse,
2198     pbe_test_run
2199 };
2200
2201
2202 /**
2203  **  BASE64 TESTS
2204  **/
2205
2206 typedef enum {
2207     BASE64_CANONICAL_ENCODING = 0,
2208     BASE64_VALID_ENCODING = 1,
2209     BASE64_INVALID_ENCODING = 2
2210 } base64_encoding_type;
2211
2212 typedef struct encode_data_st {
2213     /* Input to encoding */
2214     unsigned char *input;
2215     size_t input_len;
2216     /* Expected output */
2217     unsigned char *output;
2218     size_t output_len;
2219     base64_encoding_type encoding;
2220 } ENCODE_DATA;
2221
2222 static int encode_test_init(EVP_TEST *t, const char *encoding)
2223 {
2224     ENCODE_DATA *edata;
2225
2226     if (!TEST_ptr(edata = OPENSSL_zalloc(sizeof(*edata))))
2227         return 0;
2228     if (strcmp(encoding, "canonical") == 0) {
2229         edata->encoding = BASE64_CANONICAL_ENCODING;
2230     } else if (strcmp(encoding, "valid") == 0) {
2231         edata->encoding = BASE64_VALID_ENCODING;
2232     } else if (strcmp(encoding, "invalid") == 0) {
2233         edata->encoding = BASE64_INVALID_ENCODING;
2234         if (!TEST_ptr(t->expected_err = OPENSSL_strdup("DECODE_ERROR")))
2235             goto err;
2236     } else {
2237         TEST_error("Bad encoding: %s."
2238                    " Should be one of {canonical, valid, invalid}",
2239                    encoding);
2240         goto err;
2241     }
2242     t->data = edata;
2243     return 1;
2244 err:
2245     OPENSSL_free(edata);
2246     return 0;
2247 }
2248
2249 static void encode_test_cleanup(EVP_TEST *t)
2250 {
2251     ENCODE_DATA *edata = t->data;
2252
2253     OPENSSL_free(edata->input);
2254     OPENSSL_free(edata->output);
2255     memset(edata, 0, sizeof(*edata));
2256 }
2257
2258 static int encode_test_parse(EVP_TEST *t,
2259                              const char *keyword, const char *value)
2260 {
2261     ENCODE_DATA *edata = t->data;
2262
2263     if (strcmp(keyword, "Input") == 0)
2264         return parse_bin(value, &edata->input, &edata->input_len);
2265     if (strcmp(keyword, "Output") == 0)
2266         return parse_bin(value, &edata->output, &edata->output_len);
2267     return 0;
2268 }
2269
2270 static int encode_test_run(EVP_TEST *t)
2271 {
2272     ENCODE_DATA *expected = t->data;
2273     unsigned char *encode_out = NULL, *decode_out = NULL;
2274     int output_len, chunk_len;
2275     EVP_ENCODE_CTX *decode_ctx = NULL, *encode_ctx = NULL;
2276
2277     if (!TEST_ptr(decode_ctx = EVP_ENCODE_CTX_new())) {
2278         t->err = "INTERNAL_ERROR";
2279         goto err;
2280     }
2281
2282     if (expected->encoding == BASE64_CANONICAL_ENCODING) {
2283
2284         if (!TEST_ptr(encode_ctx = EVP_ENCODE_CTX_new())
2285                 || !TEST_ptr(encode_out =
2286                         OPENSSL_malloc(EVP_ENCODE_LENGTH(expected->input_len))))
2287             goto err;
2288
2289         EVP_EncodeInit(encode_ctx);
2290         if (!TEST_true(EVP_EncodeUpdate(encode_ctx, encode_out, &chunk_len,
2291                                         expected->input, expected->input_len)))
2292             goto err;
2293
2294         output_len = chunk_len;
2295
2296         EVP_EncodeFinal(encode_ctx, encode_out + chunk_len, &chunk_len);
2297         output_len += chunk_len;
2298
2299         if (!memory_err_compare(t, "BAD_ENCODING",
2300                                 expected->output, expected->output_len,
2301                                 encode_out, output_len))
2302             goto err;
2303     }
2304
2305     if (!TEST_ptr(decode_out =
2306                 OPENSSL_malloc(EVP_DECODE_LENGTH(expected->output_len))))
2307         goto err;
2308
2309     EVP_DecodeInit(decode_ctx);
2310     if (EVP_DecodeUpdate(decode_ctx, decode_out, &chunk_len, expected->output,
2311                          expected->output_len) < 0) {
2312         t->err = "DECODE_ERROR";
2313         goto err;
2314     }
2315     output_len = chunk_len;
2316
2317     if (EVP_DecodeFinal(decode_ctx, decode_out + chunk_len, &chunk_len) != 1) {
2318         t->err = "DECODE_ERROR";
2319         goto err;
2320     }
2321     output_len += chunk_len;
2322
2323     if (expected->encoding != BASE64_INVALID_ENCODING
2324             && !memory_err_compare(t, "BAD_DECODING",
2325                                    expected->input, expected->input_len,
2326                                    decode_out, output_len)) {
2327         t->err = "BAD_DECODING";
2328         goto err;
2329     }
2330
2331     t->err = NULL;
2332  err:
2333     OPENSSL_free(encode_out);
2334     OPENSSL_free(decode_out);
2335     EVP_ENCODE_CTX_free(decode_ctx);
2336     EVP_ENCODE_CTX_free(encode_ctx);
2337     return 1;
2338 }
2339
2340 static const EVP_TEST_METHOD encode_test_method = {
2341     "Encoding",
2342     encode_test_init,
2343     encode_test_cleanup,
2344     encode_test_parse,
2345     encode_test_run,
2346 };
2347
2348
2349 /**
2350  **  RAND TESTS
2351  **/
2352 #define MAX_RAND_REPEATS    15
2353
2354 typedef struct rand_data_pass_st {
2355     unsigned char *entropy;
2356     unsigned char *reseed_entropy;
2357     unsigned char *nonce;
2358     unsigned char *pers;
2359     unsigned char *reseed_addin;
2360     unsigned char *addinA;
2361     unsigned char *addinB;
2362     unsigned char *pr_entropyA;
2363     unsigned char *pr_entropyB;
2364     unsigned char *output;
2365     size_t entropy_len, nonce_len, pers_len, addinA_len, addinB_len,
2366            pr_entropyA_len, pr_entropyB_len, output_len, reseed_entropy_len,
2367            reseed_addin_len;
2368 } RAND_DATA_PASS;
2369
2370 typedef struct rand_data_st {
2371     /* Context for this operation */
2372     EVP_RAND_CTX *ctx;
2373     EVP_RAND_CTX *parent;
2374     int n;
2375     int prediction_resistance;
2376     int use_df;
2377     unsigned int generate_bits;
2378     char *cipher;
2379     char *digest;
2380
2381     /* Expected output */
2382     RAND_DATA_PASS data[MAX_RAND_REPEATS];
2383 } RAND_DATA;
2384
2385 static int rand_test_init(EVP_TEST *t, const char *name)
2386 {
2387     RAND_DATA *rdata;
2388     EVP_RAND *rand;
2389     OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
2390     unsigned int strength = 256;
2391
2392     if (!TEST_ptr(rdata = OPENSSL_zalloc(sizeof(*rdata))))
2393         return 0;
2394
2395     /* TEST-RAND is available in the FIPS provider but not with "fips=yes" */
2396     rand = EVP_RAND_fetch(libctx, "TEST-RAND", "-fips");
2397     if (rand == NULL)
2398         goto err;
2399     rdata->parent = EVP_RAND_CTX_new(rand, NULL);
2400     EVP_RAND_free(rand);
2401     if (rdata->parent == NULL)
2402         goto err;
2403
2404     *params = OSSL_PARAM_construct_uint(OSSL_RAND_PARAM_STRENGTH, &strength);
2405     if (!EVP_RAND_CTX_set_params(rdata->parent, params))
2406         goto err;
2407
2408     rand = EVP_RAND_fetch(libctx, name, NULL);
2409     if (rand == NULL)
2410         goto err;
2411     rdata->ctx = EVP_RAND_CTX_new(rand, rdata->parent);
2412     EVP_RAND_free(rand);
2413     if (rdata->ctx == NULL)
2414         goto err;
2415
2416     rdata->n = -1;
2417     t->data = rdata;
2418     return 1;
2419  err:
2420     EVP_RAND_CTX_free(rdata->parent);
2421     OPENSSL_free(rdata);
2422     return 0;
2423 }
2424
2425 static void rand_test_cleanup(EVP_TEST *t)
2426 {
2427     RAND_DATA *rdata = t->data;
2428     int i;
2429
2430     OPENSSL_free(rdata->cipher);
2431     OPENSSL_free(rdata->digest);
2432
2433     for (i = 0; i <= rdata->n; i++) {
2434         OPENSSL_free(rdata->data[i].entropy);
2435         OPENSSL_free(rdata->data[i].reseed_entropy);
2436         OPENSSL_free(rdata->data[i].nonce);
2437         OPENSSL_free(rdata->data[i].pers);
2438         OPENSSL_free(rdata->data[i].reseed_addin);
2439         OPENSSL_free(rdata->data[i].addinA);
2440         OPENSSL_free(rdata->data[i].addinB);
2441         OPENSSL_free(rdata->data[i].pr_entropyA);
2442         OPENSSL_free(rdata->data[i].pr_entropyB);
2443         OPENSSL_free(rdata->data[i].output);
2444     }
2445     EVP_RAND_CTX_free(rdata->ctx);
2446     EVP_RAND_CTX_free(rdata->parent);
2447 }
2448
2449 static int rand_test_parse(EVP_TEST *t,
2450                           const char *keyword, const char *value)
2451 {
2452     RAND_DATA *rdata = t->data;
2453     RAND_DATA_PASS *item;
2454     const char *p;
2455     int n;
2456
2457     if ((p = strchr(keyword, '.')) != NULL) {
2458         n = atoi(++p);
2459         if (n >= MAX_RAND_REPEATS)
2460             return 0;
2461         if (n > rdata->n)
2462             rdata->n = n;
2463         item = rdata->data + n;
2464         if (HAS_PREFIX(keyword, "Entropy."))
2465             return parse_bin(value, &item->entropy, &item->entropy_len);
2466         if (HAS_PREFIX(keyword, "ReseedEntropy."))
2467             return parse_bin(value, &item->reseed_entropy,
2468                              &item->reseed_entropy_len);
2469         if (HAS_PREFIX(keyword, "Nonce."))
2470             return parse_bin(value, &item->nonce, &item->nonce_len);
2471         if (HAS_PREFIX(keyword, "PersonalisationString."))
2472             return parse_bin(value, &item->pers, &item->pers_len);
2473         if (HAS_PREFIX(keyword, "ReseedAdditionalInput."))
2474             return parse_bin(value, &item->reseed_addin,
2475                              &item->reseed_addin_len);
2476         if (HAS_PREFIX(keyword, "AdditionalInputA."))
2477             return parse_bin(value, &item->addinA, &item->addinA_len);
2478         if (HAS_PREFIX(keyword, "AdditionalInputB."))
2479             return parse_bin(value, &item->addinB, &item->addinB_len);
2480         if (HAS_PREFIX(keyword, "EntropyPredictionResistanceA."))
2481             return parse_bin(value, &item->pr_entropyA, &item->pr_entropyA_len);
2482         if (HAS_PREFIX(keyword, "EntropyPredictionResistanceB."))
2483             return parse_bin(value, &item->pr_entropyB, &item->pr_entropyB_len);
2484         if (HAS_PREFIX(keyword, "Output."))
2485             return parse_bin(value, &item->output, &item->output_len);
2486     } else {
2487         if (strcmp(keyword, "Cipher") == 0)
2488             return TEST_ptr(rdata->cipher = OPENSSL_strdup(value));
2489         if (strcmp(keyword, "Digest") == 0)
2490             return TEST_ptr(rdata->digest = OPENSSL_strdup(value));
2491         if (strcmp(keyword, "DerivationFunction") == 0) {
2492             rdata->use_df = atoi(value) != 0;
2493             return 1;
2494         }
2495         if (strcmp(keyword, "GenerateBits") == 0) {
2496             if ((n = atoi(value)) <= 0 || n % 8 != 0)
2497                 return 0;
2498             rdata->generate_bits = (unsigned int)n;
2499             return 1;
2500         }
2501         if (strcmp(keyword, "PredictionResistance") == 0) {
2502             rdata->prediction_resistance = atoi(value) != 0;
2503             return 1;
2504         }
2505     }
2506     return 0;
2507 }
2508
2509 static int rand_test_run(EVP_TEST *t)
2510 {
2511     RAND_DATA *expected = t->data;
2512     RAND_DATA_PASS *item;
2513     unsigned char *got;
2514     size_t got_len = expected->generate_bits / 8;
2515     OSSL_PARAM params[5], *p = params;
2516     int i = -1, ret = 0;
2517     unsigned int strength;
2518     unsigned char *z;
2519
2520     if (!TEST_ptr(got = OPENSSL_malloc(got_len)))
2521         return 0;
2522
2523     *p++ = OSSL_PARAM_construct_int(OSSL_DRBG_PARAM_USE_DF, &expected->use_df);
2524     if (expected->cipher != NULL)
2525         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_CIPHER,
2526                                                 expected->cipher, 0);
2527     if (expected->digest != NULL)
2528         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_DIGEST,
2529                                                 expected->digest, 0);
2530     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_MAC, "HMAC", 0);
2531     *p = OSSL_PARAM_construct_end();
2532     if (!TEST_true(EVP_RAND_CTX_set_params(expected->ctx, params)))
2533         goto err;
2534
2535     strength = EVP_RAND_get_strength(expected->ctx);
2536     for (i = 0; i <= expected->n; i++) {
2537         item = expected->data + i;
2538
2539         p = params;
2540         z = item->entropy != NULL ? item->entropy : (unsigned char *)"";
2541         *p++ = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY,
2542                                                  z, item->entropy_len);
2543         z = item->nonce != NULL ? item->nonce : (unsigned char *)"";
2544         *p++ = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_NONCE,
2545                                                  z, item->nonce_len);
2546         *p = OSSL_PARAM_construct_end();
2547         if (!TEST_true(EVP_RAND_instantiate(expected->parent, strength,
2548                                             0, NULL, 0, params)))
2549             goto err;
2550
2551         z = item->pers != NULL ? item->pers : (unsigned char *)"";
2552         if (!TEST_true(EVP_RAND_instantiate
2553                            (expected->ctx, strength,
2554                             expected->prediction_resistance, z,
2555                             item->pers_len, NULL)))
2556             goto err;
2557
2558         if (item->reseed_entropy != NULL) {
2559             params[0] = OSSL_PARAM_construct_octet_string
2560                            (OSSL_RAND_PARAM_TEST_ENTROPY, item->reseed_entropy,
2561                             item->reseed_entropy_len);
2562             params[1] = OSSL_PARAM_construct_end();
2563             if (!TEST_true(EVP_RAND_CTX_set_params(expected->parent, params)))
2564                 goto err;
2565
2566             if (!TEST_true(EVP_RAND_reseed
2567                                (expected->ctx, expected->prediction_resistance,
2568                                 NULL, 0, item->reseed_addin,
2569                                 item->reseed_addin_len)))
2570                 goto err;
2571         }
2572         if (item->pr_entropyA != NULL) {
2573             params[0] = OSSL_PARAM_construct_octet_string
2574                            (OSSL_RAND_PARAM_TEST_ENTROPY, item->pr_entropyA,
2575                             item->pr_entropyA_len);
2576             params[1] = OSSL_PARAM_construct_end();
2577             if (!TEST_true(EVP_RAND_CTX_set_params(expected->parent, params)))
2578                 goto err;
2579         }
2580         if (!TEST_true(EVP_RAND_generate
2581                            (expected->ctx, got, got_len,
2582                             strength, expected->prediction_resistance,
2583                             item->addinA, item->addinA_len)))
2584             goto err;
2585
2586         if (item->pr_entropyB != NULL) {
2587             params[0] = OSSL_PARAM_construct_octet_string
2588                            (OSSL_RAND_PARAM_TEST_ENTROPY, item->pr_entropyB,
2589                             item->pr_entropyB_len);
2590             params[1] = OSSL_PARAM_construct_end();
2591             if (!TEST_true(EVP_RAND_CTX_set_params(expected->parent, params)))
2592                 goto err;
2593         }
2594         if (!TEST_true(EVP_RAND_generate
2595                            (expected->ctx, got, got_len,
2596                             strength, expected->prediction_resistance,
2597                             item->addinB, item->addinB_len)))
2598             goto err;
2599         if (!TEST_mem_eq(got, got_len, item->output, item->output_len))
2600             goto err;
2601         if (!TEST_true(EVP_RAND_uninstantiate(expected->ctx))
2602                 || !TEST_true(EVP_RAND_uninstantiate(expected->parent))
2603                 || !TEST_true(EVP_RAND_verify_zeroization(expected->ctx))
2604                 || !TEST_int_eq(EVP_RAND_get_state(expected->ctx),
2605                                 EVP_RAND_STATE_UNINITIALISED))
2606             goto err;
2607     }
2608     t->err = NULL;
2609     ret = 1;
2610
2611  err:
2612     if (ret == 0 && i >= 0)
2613         TEST_info("Error in test case %d of %d\n", i, expected->n + 1);
2614     OPENSSL_free(got);
2615     return ret;
2616 }
2617
2618 static const EVP_TEST_METHOD rand_test_method = {
2619     "RAND",
2620     rand_test_init,
2621     rand_test_cleanup,
2622     rand_test_parse,
2623     rand_test_run
2624 };
2625
2626
2627 /**
2628  **  KDF TESTS
2629  **/
2630 typedef struct kdf_data_st {
2631     /* Context for this operation */
2632     EVP_KDF_CTX *ctx;
2633     /* Expected output */
2634     unsigned char *output;
2635     size_t output_len;
2636     OSSL_PARAM params[20];
2637     OSSL_PARAM *p;
2638 } KDF_DATA;
2639
2640 /*
2641  * Perform public key operation setup: lookup key, allocated ctx and call
2642  * the appropriate initialisation function
2643  */
2644 static int kdf_test_init(EVP_TEST *t, const char *name)
2645 {
2646     KDF_DATA *kdata;
2647     EVP_KDF *kdf;
2648
2649     if (is_kdf_disabled(name)) {
2650         TEST_info("skipping, '%s' is disabled", name);
2651         t->skip = 1;
2652         return 1;
2653     }
2654
2655     if (!TEST_ptr(kdata = OPENSSL_zalloc(sizeof(*kdata))))
2656         return 0;
2657     kdata->p = kdata->params;
2658     *kdata->p = OSSL_PARAM_construct_end();
2659
2660     kdf = EVP_KDF_fetch(libctx, name, NULL);
2661     if (kdf == NULL) {
2662         OPENSSL_free(kdata);
2663         return 0;
2664     }
2665     kdata->ctx = EVP_KDF_CTX_new(kdf);
2666     EVP_KDF_free(kdf);
2667     if (kdata->ctx == NULL) {
2668         OPENSSL_free(kdata);
2669         return 0;
2670     }
2671     t->data = kdata;
2672     return 1;
2673 }
2674
2675 static void kdf_test_cleanup(EVP_TEST *t)
2676 {
2677     KDF_DATA *kdata = t->data;
2678     OSSL_PARAM *p;
2679
2680     for (p = kdata->params; p->key != NULL; p++)
2681         OPENSSL_free(p->data);
2682     OPENSSL_free(kdata->output);
2683     EVP_KDF_CTX_free(kdata->ctx);
2684 }
2685
2686 static int kdf_test_ctrl(EVP_TEST *t, EVP_KDF_CTX *kctx,
2687                          const char *value)
2688 {
2689     KDF_DATA *kdata = t->data;
2690     int rv;
2691     char *p, *name;
2692     const OSSL_PARAM *defs = EVP_KDF_settable_ctx_params(EVP_KDF_CTX_kdf(kctx));
2693
2694     if (!TEST_ptr(name = OPENSSL_strdup(value)))
2695         return 0;
2696     p = strchr(name, ':');
2697     if (p != NULL)
2698         *p++ = '\0';
2699
2700     if (strcmp(name, "r") == 0
2701         && OSSL_PARAM_locate_const(defs, name) == NULL) {
2702         TEST_info("skipping, setting 'r' is unsupported");
2703         t->skip = 1;
2704         goto end;
2705     }
2706
2707     rv = OSSL_PARAM_allocate_from_text(kdata->p, defs, name, p,
2708                                        p != NULL ? strlen(p) : 0, NULL);
2709     *++kdata->p = OSSL_PARAM_construct_end();
2710     if (!rv) {
2711         t->err = "KDF_PARAM_ERROR";
2712         OPENSSL_free(name);
2713         return 0;
2714     }
2715     if (p != NULL && strcmp(name, "digest") == 0) {
2716         if (is_digest_disabled(p)) {
2717             TEST_info("skipping, '%s' is disabled", p);
2718             t->skip = 1;
2719         }
2720         goto end;
2721     }
2722     if (p != NULL
2723         && (strcmp(name, "cipher") == 0
2724             || strcmp(name, "cekalg") == 0)
2725         && is_cipher_disabled(p)) {
2726         TEST_info("skipping, '%s' is disabled", p);
2727         t->skip = 1;
2728         goto end;
2729     }
2730     if (p != NULL
2731         && (strcmp(name, "mac") == 0)
2732         && is_mac_disabled(p)) {
2733         TEST_info("skipping, '%s' is disabled", p);
2734         t->skip = 1;
2735     }
2736  end:
2737     OPENSSL_free(name);
2738     return 1;
2739 }
2740
2741 static int kdf_test_parse(EVP_TEST *t,
2742                           const char *keyword, const char *value)
2743 {
2744     KDF_DATA *kdata = t->data;
2745
2746     if (strcmp(keyword, "Output") == 0)
2747         return parse_bin(value, &kdata->output, &kdata->output_len);
2748     if (HAS_PREFIX(keyword, "Ctrl"))
2749         return kdf_test_ctrl(t, kdata->ctx, value);
2750     return 0;
2751 }
2752
2753 static int kdf_test_run(EVP_TEST *t)
2754 {
2755     KDF_DATA *expected = t->data;
2756     unsigned char *got = NULL;
2757     size_t got_len = expected->output_len;
2758     EVP_KDF_CTX *ctx;
2759
2760     if (!EVP_KDF_CTX_set_params(expected->ctx, expected->params)) {
2761         t->err = "KDF_CTRL_ERROR";
2762         return 1;
2763     }
2764     if (!TEST_ptr(got = OPENSSL_malloc(got_len == 0 ? 1 : got_len))) {
2765         t->err = "INTERNAL_ERROR";
2766         goto err;
2767     }
2768     if ((ctx = EVP_KDF_CTX_dup(expected->ctx)) != NULL) {
2769         EVP_KDF_CTX_free(expected->ctx);
2770         expected->ctx = ctx;
2771     }
2772     if (EVP_KDF_derive(expected->ctx, got, got_len, NULL) <= 0) {
2773         t->err = "KDF_DERIVE_ERROR";
2774         goto err;
2775     }
2776     if (!memory_err_compare(t, "KDF_MISMATCH",
2777                             expected->output, expected->output_len,
2778                             got, got_len))
2779         goto err;
2780
2781     t->err = NULL;
2782
2783  err:
2784     OPENSSL_free(got);
2785     return 1;
2786 }
2787
2788 static const EVP_TEST_METHOD kdf_test_method = {
2789     "KDF",
2790     kdf_test_init,
2791     kdf_test_cleanup,
2792     kdf_test_parse,
2793     kdf_test_run
2794 };
2795
2796 /**
2797  **  PKEY KDF TESTS
2798  **/
2799
2800 typedef struct pkey_kdf_data_st {
2801     /* Context for this operation */
2802     EVP_PKEY_CTX *ctx;
2803     /* Expected output */
2804     unsigned char *output;
2805     size_t output_len;
2806 } PKEY_KDF_DATA;
2807
2808 /*
2809  * Perform public key operation setup: lookup key, allocated ctx and call
2810  * the appropriate initialisation function
2811  */
2812 static int pkey_kdf_test_init(EVP_TEST *t, const char *name)
2813 {
2814     PKEY_KDF_DATA *kdata = NULL;
2815
2816     if (is_kdf_disabled(name)) {
2817         TEST_info("skipping, '%s' is disabled", name);
2818         t->skip = 1;
2819         return 1;
2820     }
2821
2822     if (!TEST_ptr(kdata = OPENSSL_zalloc(sizeof(*kdata))))
2823         return 0;
2824
2825     kdata->ctx = EVP_PKEY_CTX_new_from_name(libctx, name, NULL);
2826     if (kdata->ctx == NULL
2827         || EVP_PKEY_derive_init(kdata->ctx) <= 0)
2828         goto err;
2829
2830     t->data = kdata;
2831     return 1;
2832 err:
2833     EVP_PKEY_CTX_free(kdata->ctx);
2834     OPENSSL_free(kdata);
2835     return 0;
2836 }
2837
2838 static void pkey_kdf_test_cleanup(EVP_TEST *t)
2839 {
2840     PKEY_KDF_DATA *kdata = t->data;
2841
2842     OPENSSL_free(kdata->output);
2843     EVP_PKEY_CTX_free(kdata->ctx);
2844 }
2845
2846 static int pkey_kdf_test_parse(EVP_TEST *t,
2847                                const char *keyword, const char *value)
2848 {
2849     PKEY_KDF_DATA *kdata = t->data;
2850
2851     if (strcmp(keyword, "Output") == 0)
2852         return parse_bin(value, &kdata->output, &kdata->output_len);
2853     if (HAS_PREFIX(keyword, "Ctrl"))
2854         return pkey_test_ctrl(t, kdata->ctx, value);
2855     return 0;
2856 }
2857
2858 static int pkey_kdf_test_run(EVP_TEST *t)
2859 {
2860     PKEY_KDF_DATA *expected = t->data;
2861     unsigned char *got = NULL;
2862     size_t got_len = expected->output_len;
2863
2864     if (!TEST_ptr(got = OPENSSL_malloc(got_len == 0 ? 1 : got_len))) {
2865         t->err = "INTERNAL_ERROR";
2866         goto err;
2867     }
2868     if (EVP_PKEY_derive(expected->ctx, got, &got_len) <= 0) {
2869         t->err = "KDF_DERIVE_ERROR";
2870         goto err;
2871     }
2872     if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
2873         t->err = "KDF_MISMATCH";
2874         goto err;
2875     }
2876     t->err = NULL;
2877
2878  err:
2879     OPENSSL_free(got);
2880     return 1;
2881 }
2882
2883 static const EVP_TEST_METHOD pkey_kdf_test_method = {
2884     "PKEYKDF",
2885     pkey_kdf_test_init,
2886     pkey_kdf_test_cleanup,
2887     pkey_kdf_test_parse,
2888     pkey_kdf_test_run
2889 };
2890
2891 /**
2892  **  KEYPAIR TESTS
2893  **/
2894
2895 typedef struct keypair_test_data_st {
2896     EVP_PKEY *privk;
2897     EVP_PKEY *pubk;
2898 } KEYPAIR_TEST_DATA;
2899
2900 static int keypair_test_init(EVP_TEST *t, const char *pair)
2901 {
2902     KEYPAIR_TEST_DATA *data;
2903     int rv = 0;
2904     EVP_PKEY *pk = NULL, *pubk = NULL;
2905     char *pub, *priv = NULL;
2906
2907     /* Split private and public names. */
2908     if (!TEST_ptr(priv = OPENSSL_strdup(pair))
2909             || !TEST_ptr(pub = strchr(priv, ':'))) {
2910         t->err = "PARSING_ERROR";
2911         goto end;
2912     }
2913     *pub++ = '\0';
2914
2915     if (!TEST_true(find_key(&pk, priv, private_keys))) {
2916         TEST_info("Can't find private key: %s", priv);
2917         t->err = "MISSING_PRIVATE_KEY";
2918         goto end;
2919     }
2920     if (!TEST_true(find_key(&pubk, pub, public_keys))) {
2921         TEST_info("Can't find public key: %s", pub);
2922         t->err = "MISSING_PUBLIC_KEY";
2923         goto end;
2924     }
2925
2926     if (pk == NULL && pubk == NULL) {
2927         /* Both keys are listed but unsupported: skip this test */
2928         t->skip = 1;
2929         rv = 1;
2930         goto end;
2931     }
2932
2933     if (!TEST_ptr(data = OPENSSL_malloc(sizeof(*data))))
2934         goto end;
2935     data->privk = pk;
2936     data->pubk = pubk;
2937     t->data = data;
2938     rv = 1;
2939     t->err = NULL;
2940
2941 end:
2942     OPENSSL_free(priv);
2943     return rv;
2944 }
2945
2946 static void keypair_test_cleanup(EVP_TEST *t)
2947 {
2948     OPENSSL_free(t->data);
2949     t->data = NULL;
2950 }
2951
2952 /*
2953  * For tests that do not accept any custom keywords.
2954  */
2955 static int void_test_parse(EVP_TEST *t, const char *keyword, const char *value)
2956 {
2957     return 0;
2958 }
2959
2960 static int keypair_test_run(EVP_TEST *t)
2961 {
2962     int rv = 0;
2963     const KEYPAIR_TEST_DATA *pair = t->data;
2964
2965     if (pair->privk == NULL || pair->pubk == NULL) {
2966         /*
2967          * this can only happen if only one of the keys is not set
2968          * which means that one of them was unsupported while the
2969          * other isn't: hence a key type mismatch.
2970          */
2971         t->err = "KEYPAIR_TYPE_MISMATCH";
2972         rv = 1;
2973         goto end;
2974     }
2975
2976     if ((rv = EVP_PKEY_eq(pair->privk, pair->pubk)) != 1) {
2977         if (0 == rv) {
2978             t->err = "KEYPAIR_MISMATCH";
2979         } else if (-1 == rv) {
2980             t->err = "KEYPAIR_TYPE_MISMATCH";
2981         } else if (-2 == rv) {
2982             t->err = "UNSUPPORTED_KEY_COMPARISON";
2983         } else {
2984             TEST_error("Unexpected error in key comparison");
2985             rv = 0;
2986             goto end;
2987         }
2988         rv = 1;
2989         goto end;
2990     }
2991
2992     rv = 1;
2993     t->err = NULL;
2994
2995 end:
2996     return rv;
2997 }
2998
2999 static const EVP_TEST_METHOD keypair_test_method = {
3000     "PrivPubKeyPair",
3001     keypair_test_init,
3002     keypair_test_cleanup,
3003     void_test_parse,
3004     keypair_test_run
3005 };
3006
3007 /**
3008  **  KEYGEN TEST
3009  **/
3010
3011 typedef struct keygen_test_data_st {
3012     EVP_PKEY_CTX *genctx; /* Keygen context to use */
3013     char *keyname; /* Key name to store key or NULL */
3014 } KEYGEN_TEST_DATA;
3015
3016 static int keygen_test_init(EVP_TEST *t, const char *alg)
3017 {
3018     KEYGEN_TEST_DATA *data;
3019     EVP_PKEY_CTX *genctx;
3020     int nid = OBJ_sn2nid(alg);
3021
3022     if (nid == NID_undef) {
3023         nid = OBJ_ln2nid(alg);
3024         if (nid == NID_undef)
3025             return 0;
3026     }
3027
3028     if (is_pkey_disabled(alg)) {
3029         t->skip = 1;
3030         return 1;
3031     }
3032     if (!TEST_ptr(genctx = EVP_PKEY_CTX_new_from_name(libctx, alg, NULL)))
3033         goto err;
3034
3035     if (EVP_PKEY_keygen_init(genctx) <= 0) {
3036         t->err = "KEYGEN_INIT_ERROR";
3037         goto err;
3038     }
3039
3040     if (!TEST_ptr(data = OPENSSL_malloc(sizeof(*data))))
3041         goto err;
3042     data->genctx = genctx;
3043     data->keyname = NULL;
3044     t->data = data;
3045     t->err = NULL;
3046     return 1;
3047
3048 err:
3049     EVP_PKEY_CTX_free(genctx);
3050     return 0;
3051 }
3052
3053 static void keygen_test_cleanup(EVP_TEST *t)
3054 {
3055     KEYGEN_TEST_DATA *keygen = t->data;
3056
3057     EVP_PKEY_CTX_free(keygen->genctx);
3058     OPENSSL_free(keygen->keyname);
3059     OPENSSL_free(t->data);
3060     t->data = NULL;
3061 }
3062
3063 static int keygen_test_parse(EVP_TEST *t,
3064                              const char *keyword, const char *value)
3065 {
3066     KEYGEN_TEST_DATA *keygen = t->data;
3067
3068     if (strcmp(keyword, "KeyName") == 0)
3069         return TEST_ptr(keygen->keyname = OPENSSL_strdup(value));
3070     if (strcmp(keyword, "Ctrl") == 0)
3071         return pkey_test_ctrl(t, keygen->genctx, value);
3072     return 0;
3073 }
3074
3075 static int keygen_test_run(EVP_TEST *t)
3076 {
3077     KEYGEN_TEST_DATA *keygen = t->data;
3078     EVP_PKEY *pkey = NULL;
3079     int rv = 1;
3080
3081     if (EVP_PKEY_keygen(keygen->genctx, &pkey) <= 0) {
3082         t->err = "KEYGEN_GENERATE_ERROR";
3083         goto err;
3084     }
3085
3086     if (!evp_pkey_is_provided(pkey)) {
3087         TEST_info("Warning: legacy key generated %s", keygen->keyname);
3088         goto err;
3089     }
3090     if (keygen->keyname != NULL) {
3091         KEY_LIST *key;
3092
3093         rv = 0;
3094         if (find_key(NULL, keygen->keyname, private_keys)) {
3095             TEST_info("Duplicate key %s", keygen->keyname);
3096             goto err;
3097         }
3098
3099         if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key))))
3100             goto err;
3101         key->name = keygen->keyname;
3102         keygen->keyname = NULL;
3103         key->key = pkey;
3104         key->next = private_keys;
3105         private_keys = key;
3106         rv = 1;
3107     } else {
3108         EVP_PKEY_free(pkey);
3109     }
3110
3111     t->err = NULL;
3112
3113 err:
3114     return rv;
3115 }
3116
3117 static const EVP_TEST_METHOD keygen_test_method = {
3118     "KeyGen",
3119     keygen_test_init,
3120     keygen_test_cleanup,
3121     keygen_test_parse,
3122     keygen_test_run,
3123 };
3124
3125 /**
3126  **  DIGEST SIGN+VERIFY TESTS
3127  **/
3128
3129 typedef struct {
3130     int is_verify; /* Set to 1 if verifying */
3131     int is_oneshot; /* Set to 1 for one shot operation */
3132     const EVP_MD *md; /* Digest to use */
3133     EVP_MD_CTX *ctx; /* Digest context */
3134     EVP_PKEY_CTX *pctx;
3135     STACK_OF(EVP_TEST_BUFFER) *input; /* Input data: streaming */
3136     unsigned char *osin; /* Input data if one shot */
3137     size_t osin_len; /* Input length data if one shot */
3138     unsigned char *output; /* Expected output */
3139     size_t output_len; /* Expected output length */
3140 } DIGESTSIGN_DATA;
3141
3142 static int digestsigver_test_init(EVP_TEST *t, const char *alg, int is_verify,
3143                                   int is_oneshot)
3144 {
3145     const EVP_MD *md = NULL;
3146     DIGESTSIGN_DATA *mdat;
3147
3148     if (strcmp(alg, "NULL") != 0) {
3149         if (is_digest_disabled(alg)) {
3150             t->skip = 1;
3151             return 1;
3152         }
3153         md = EVP_get_digestbyname(alg);
3154         if (md == NULL)
3155             return 0;
3156     }
3157     if (!TEST_ptr(mdat = OPENSSL_zalloc(sizeof(*mdat))))
3158         return 0;
3159     mdat->md = md;
3160     if (!TEST_ptr(mdat->ctx = EVP_MD_CTX_new())) {
3161         OPENSSL_free(mdat);
3162         return 0;
3163     }
3164     mdat->is_verify = is_verify;
3165     mdat->is_oneshot = is_oneshot;
3166     t->data = mdat;
3167     return 1;
3168 }
3169
3170 static int digestsign_test_init(EVP_TEST *t, const char *alg)
3171 {
3172     return digestsigver_test_init(t, alg, 0, 0);
3173 }
3174
3175 static void digestsigver_test_cleanup(EVP_TEST *t)
3176 {
3177     DIGESTSIGN_DATA *mdata = t->data;
3178
3179     EVP_MD_CTX_free(mdata->ctx);
3180     sk_EVP_TEST_BUFFER_pop_free(mdata->input, evp_test_buffer_free);
3181     OPENSSL_free(mdata->osin);
3182     OPENSSL_free(mdata->output);
3183     OPENSSL_free(mdata);
3184     t->data = NULL;
3185 }
3186
3187 static int digestsigver_test_parse(EVP_TEST *t,
3188                                    const char *keyword, const char *value)
3189 {
3190     DIGESTSIGN_DATA *mdata = t->data;
3191
3192     if (strcmp(keyword, "Key") == 0) {
3193         EVP_PKEY *pkey = NULL;
3194         int rv = 0;
3195         const char *name = mdata->md == NULL ? NULL : EVP_MD_get0_name(mdata->md);
3196
3197         if (mdata->is_verify)
3198             rv = find_key(&pkey, value, public_keys);
3199         if (rv == 0)
3200             rv = find_key(&pkey, value, private_keys);
3201         if (rv == 0 || pkey == NULL) {
3202             t->skip = 1;
3203             return 1;
3204         }
3205         if (mdata->is_verify) {
3206             if (!EVP_DigestVerifyInit_ex(mdata->ctx, &mdata->pctx, name, libctx,
3207                                          NULL, pkey, NULL))
3208                 t->err = "DIGESTVERIFYINIT_ERROR";
3209             return 1;
3210         }
3211         if (!EVP_DigestSignInit_ex(mdata->ctx, &mdata->pctx, name, libctx, NULL,
3212                                    pkey, NULL))
3213             t->err = "DIGESTSIGNINIT_ERROR";
3214         return 1;
3215     }
3216
3217     if (strcmp(keyword, "Input") == 0) {
3218         if (mdata->is_oneshot)
3219             return parse_bin(value, &mdata->osin, &mdata->osin_len);
3220         return evp_test_buffer_append(value, &mdata->input);
3221     }
3222     if (strcmp(keyword, "Output") == 0)
3223         return parse_bin(value, &mdata->output, &mdata->output_len);
3224
3225     if (!mdata->is_oneshot) {
3226         if (strcmp(keyword, "Count") == 0)
3227             return evp_test_buffer_set_count(value, mdata->input);
3228         if (strcmp(keyword, "Ncopy") == 0)
3229             return evp_test_buffer_ncopy(value, mdata->input);
3230     }
3231     if (strcmp(keyword, "Ctrl") == 0) {
3232         if (mdata->pctx == NULL)
3233             return -1;
3234         return pkey_test_ctrl(t, mdata->pctx, value);
3235     }
3236     return 0;
3237 }
3238
3239 static int digestsign_update_fn(void *ctx, const unsigned char *buf,
3240                                 size_t buflen)
3241 {
3242     return EVP_DigestSignUpdate(ctx, buf, buflen);
3243 }
3244
3245 static int digestsign_test_run(EVP_TEST *t)
3246 {
3247     DIGESTSIGN_DATA *expected = t->data;
3248     unsigned char *got = NULL;
3249     size_t got_len;
3250
3251     if (!evp_test_buffer_do(expected->input, digestsign_update_fn,
3252                             expected->ctx)) {
3253         t->err = "DIGESTUPDATE_ERROR";
3254         goto err;
3255     }
3256
3257     if (!EVP_DigestSignFinal(expected->ctx, NULL, &got_len)) {
3258         t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";
3259         goto err;
3260     }
3261     if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
3262         t->err = "MALLOC_FAILURE";
3263         goto err;
3264     }
3265     if (!EVP_DigestSignFinal(expected->ctx, got, &got_len)) {
3266         t->err = "DIGESTSIGNFINAL_ERROR";
3267         goto err;
3268     }
3269     if (!memory_err_compare(t, "SIGNATURE_MISMATCH",
3270                             expected->output, expected->output_len,
3271                             got, got_len))
3272         goto err;
3273
3274     t->err = NULL;
3275  err:
3276     OPENSSL_free(got);
3277     return 1;
3278 }
3279
3280 static const EVP_TEST_METHOD digestsign_test_method = {
3281     "DigestSign",
3282     digestsign_test_init,
3283     digestsigver_test_cleanup,
3284     digestsigver_test_parse,
3285     digestsign_test_run
3286 };
3287
3288 static int digestverify_test_init(EVP_TEST *t, const char *alg)
3289 {
3290     return digestsigver_test_init(t, alg, 1, 0);
3291 }
3292
3293 static int digestverify_update_fn(void *ctx, const unsigned char *buf,
3294                                   size_t buflen)
3295 {
3296     return EVP_DigestVerifyUpdate(ctx, buf, buflen);
3297 }
3298
3299 static int digestverify_test_run(EVP_TEST *t)
3300 {
3301     DIGESTSIGN_DATA *mdata = t->data;
3302
3303     if (!evp_test_buffer_do(mdata->input, digestverify_update_fn, mdata->ctx)) {
3304         t->err = "DIGESTUPDATE_ERROR";
3305         return 1;
3306     }
3307
3308     if (EVP_DigestVerifyFinal(mdata->ctx, mdata->output,
3309                               mdata->output_len) <= 0)
3310         t->err = "VERIFY_ERROR";
3311     return 1;
3312 }
3313
3314 static const EVP_TEST_METHOD digestverify_test_method = {
3315     "DigestVerify",
3316     digestverify_test_init,
3317     digestsigver_test_cleanup,
3318     digestsigver_test_parse,
3319     digestverify_test_run
3320 };
3321
3322 static int oneshot_digestsign_test_init(EVP_TEST *t, const char *alg)
3323 {
3324     return digestsigver_test_init(t, alg, 0, 1);
3325 }
3326
3327 static int oneshot_digestsign_test_run(EVP_TEST *t)
3328 {
3329     DIGESTSIGN_DATA *expected = t->data;
3330     unsigned char *got = NULL;
3331     size_t got_len;
3332
3333     if (!EVP_DigestSign(expected->ctx, NULL, &got_len,
3334                         expected->osin, expected->osin_len)) {
3335         t->err = "DIGESTSIGN_LENGTH_ERROR";
3336         goto err;
3337     }
3338     if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
3339         t->err = "MALLOC_FAILURE";
3340         goto err;
3341     }
3342     if (!EVP_DigestSign(expected->ctx, got, &got_len,
3343                         expected->osin, expected->osin_len)) {
3344         t->err = "DIGESTSIGN_ERROR";
3345         goto err;
3346     }
3347     if (!memory_err_compare(t, "SIGNATURE_MISMATCH",
3348                             expected->output, expected->output_len,
3349                             got, got_len))
3350         goto err;
3351
3352     t->err = NULL;
3353  err:
3354     OPENSSL_free(got);
3355     return 1;
3356 }
3357
3358 static const EVP_TEST_METHOD oneshot_digestsign_test_method = {
3359     "OneShotDigestSign",
3360     oneshot_digestsign_test_init,
3361     digestsigver_test_cleanup,
3362     digestsigver_test_parse,
3363     oneshot_digestsign_test_run
3364 };
3365
3366 static int oneshot_digestverify_test_init(EVP_TEST *t, const char *alg)
3367 {
3368     return digestsigver_test_init(t, alg, 1, 1);
3369 }
3370
3371 static int oneshot_digestverify_test_run(EVP_TEST *t)
3372 {
3373     DIGESTSIGN_DATA *mdata = t->data;
3374
3375     if (EVP_DigestVerify(mdata->ctx, mdata->output, mdata->output_len,
3376                          mdata->osin, mdata->osin_len) <= 0)
3377         t->err = "VERIFY_ERROR";
3378     return 1;
3379 }
3380
3381 static const EVP_TEST_METHOD oneshot_digestverify_test_method = {
3382     "OneShotDigestVerify",
3383     oneshot_digestverify_test_init,
3384     digestsigver_test_cleanup,
3385     digestsigver_test_parse,
3386     oneshot_digestverify_test_run
3387 };
3388
3389
3390 /**
3391  **  PARSING AND DISPATCH
3392  **/
3393
3394 static const EVP_TEST_METHOD *evp_test_list[] = {
3395     &rand_test_method,
3396     &cipher_test_method,
3397     &digest_test_method,
3398     &digestsign_test_method,
3399     &digestverify_test_method,
3400     &encode_test_method,
3401     &kdf_test_method,
3402     &pkey_kdf_test_method,
3403     &keypair_test_method,
3404     &keygen_test_method,
3405     &mac_test_method,
3406     &oneshot_digestsign_test_method,
3407     &oneshot_digestverify_test_method,
3408     &pbe_test_method,
3409     &pdecrypt_test_method,
3410     &pderive_test_method,
3411     &psign_test_method,
3412     &pverify_recover_test_method,
3413     &pverify_test_method,
3414     NULL
3415 };
3416
3417 static const EVP_TEST_METHOD *find_test(const char *name)
3418 {
3419     const EVP_TEST_METHOD **tt;
3420
3421     for (tt = evp_test_list; *tt; tt++) {
3422         if (strcmp(name, (*tt)->name) == 0)
3423             return *tt;
3424     }
3425     return NULL;
3426 }
3427
3428 static void clear_test(EVP_TEST *t)
3429 {
3430     test_clearstanza(&t->s);
3431     ERR_clear_error();
3432     if (t->data != NULL) {
3433         if (t->meth != NULL)
3434             t->meth->cleanup(t);
3435         OPENSSL_free(t->data);
3436         t->data = NULL;
3437     }
3438     OPENSSL_free(t->expected_err);
3439     t->expected_err = NULL;
3440     OPENSSL_free(t->reason);
3441     t->reason = NULL;
3442
3443     /* Text literal. */
3444     t->err = NULL;
3445     t->skip = 0;
3446     t->meth = NULL;
3447 }
3448
3449 /* Check for errors in the test structure; return 1 if okay, else 0. */
3450 static int check_test_error(EVP_TEST *t)
3451 {
3452     unsigned long err;
3453     const char *reason;
3454
3455     if (t->err == NULL && t->expected_err == NULL)
3456         return 1;
3457     if (t->err != NULL && t->expected_err == NULL) {
3458         if (t->aux_err != NULL) {
3459             TEST_info("%s:%d: Source of above error (%s); unexpected error %s",
3460                       t->s.test_file, t->s.start, t->aux_err, t->err);
3461         } else {
3462             TEST_info("%s:%d: Source of above error; unexpected error %s",
3463                       t->s.test_file, t->s.start, t->err);
3464         }
3465         return 0;
3466     }
3467     if (t->err == NULL && t->expected_err != NULL) {
3468         TEST_info("%s:%d: Succeeded but was expecting %s",
3469                   t->s.test_file, t->s.start, t->expected_err);
3470         return 0;
3471     }
3472
3473     if (strcmp(t->err, t->expected_err) != 0) {
3474         TEST_info("%s:%d: Expected %s got %s",
3475                   t->s.test_file, t->s.start, t->expected_err, t->err);
3476         return 0;
3477     }
3478
3479     if (t->reason == NULL)
3480         return 1;
3481
3482     if (t->reason == NULL) {
3483         TEST_info("%s:%d: Test is missing function or reason code",
3484                   t->s.test_file, t->s.start);
3485         return 0;
3486     }
3487
3488     err = ERR_peek_error();
3489     if (err == 0) {
3490         TEST_info("%s:%d: Expected error \"%s\" not set",
3491                   t->s.test_file, t->s.start, t->reason);
3492         return 0;
3493     }
3494
3495     reason = ERR_reason_error_string(err);
3496     if (reason == NULL) {
3497         TEST_info("%s:%d: Expected error \"%s\", no strings available."
3498                   " Assuming ok.",
3499                   t->s.test_file, t->s.start, t->reason);
3500         return 1;
3501     }
3502
3503     if (strcmp(reason, t->reason) == 0)
3504         return 1;
3505
3506     TEST_info("%s:%d: Expected error \"%s\", got \"%s\"",
3507               t->s.test_file, t->s.start, t->reason, reason);
3508
3509     return 0;
3510 }
3511
3512 /* Run a parsed test. Log a message and return 0 on error. */
3513 static int run_test(EVP_TEST *t)
3514 {
3515     if (t->meth == NULL)
3516         return 1;
3517     t->s.numtests++;
3518     if (t->skip) {
3519         t->s.numskip++;
3520     } else {
3521         /* run the test */
3522         if (t->err == NULL && t->meth->run_test(t) != 1) {
3523             TEST_info("%s:%d %s error",
3524                       t->s.test_file, t->s.start, t->meth->name);
3525             return 0;
3526         }
3527         if (!check_test_error(t)) {
3528             TEST_openssl_errors();
3529             t->s.errors++;
3530         }
3531     }
3532
3533     /* clean it up */
3534     return 1;
3535 }
3536
3537 static int find_key(EVP_PKEY **ppk, const char *name, KEY_LIST *lst)
3538 {
3539     for (; lst != NULL; lst = lst->next) {
3540         if (strcmp(lst->name, name) == 0) {
3541             if (ppk != NULL)
3542                 *ppk = lst->key;
3543             return 1;
3544         }
3545     }
3546     return 0;
3547 }
3548
3549 static void free_key_list(KEY_LIST *lst)
3550 {
3551     while (lst != NULL) {
3552         KEY_LIST *next = lst->next;
3553
3554         EVP_PKEY_free(lst->key);
3555         OPENSSL_free(lst->name);
3556         OPENSSL_free(lst);
3557         lst = next;
3558     }
3559 }
3560
3561 /*
3562  * Is the key type an unsupported algorithm?
3563  */
3564 static int key_unsupported(void)
3565 {
3566     long err = ERR_peek_last_error();
3567     int lib = ERR_GET_LIB(err);
3568     long reason = ERR_GET_REASON(err);
3569
3570     if ((lib == ERR_LIB_EVP && reason == EVP_R_UNSUPPORTED_ALGORITHM)
3571         || (lib == ERR_LIB_EVP && reason == EVP_R_DECODE_ERROR)
3572         || reason == ERR_R_UNSUPPORTED) {
3573         ERR_clear_error();
3574         return 1;
3575     }
3576 #ifndef OPENSSL_NO_EC
3577     /*
3578      * If EC support is enabled we should catch also EC_R_UNKNOWN_GROUP as an
3579      * hint to an unsupported algorithm/curve (e.g. if binary EC support is
3580      * disabled).
3581      */
3582     if (lib == ERR_LIB_EC
3583         && (reason == EC_R_UNKNOWN_GROUP
3584             || reason == EC_R_INVALID_CURVE)) {
3585         ERR_clear_error();
3586         return 1;
3587     }
3588 #endif /* OPENSSL_NO_EC */
3589     return 0;
3590 }
3591
3592 /* NULL out the value from |pp| but return it.  This "steals" a pointer. */
3593 static char *take_value(PAIR *pp)
3594 {
3595     char *p = pp->value;
3596
3597     pp->value = NULL;
3598     return p;
3599 }
3600
3601 #if !defined(OPENSSL_NO_FIPS_SECURITYCHECKS)
3602 static int securitycheck_enabled(void)
3603 {
3604     static int enabled = -1;
3605
3606     if (enabled == -1) {
3607         if (OSSL_PROVIDER_available(libctx, "fips")) {
3608             OSSL_PARAM params[2];
3609             OSSL_PROVIDER *prov = NULL;
3610             int check = 1;
3611
3612             prov = OSSL_PROVIDER_load(libctx, "fips");
3613             if (prov != NULL) {
3614                 params[0] =
3615                     OSSL_PARAM_construct_int(OSSL_PROV_PARAM_SECURITY_CHECKS,
3616                                              &check);
3617                 params[1] = OSSL_PARAM_construct_end();
3618                 OSSL_PROVIDER_get_params(prov, params);
3619                 OSSL_PROVIDER_unload(prov);
3620             }
3621             enabled = check;
3622             return enabled;
3623         }
3624         enabled = 0;
3625     }
3626     return enabled;
3627 }
3628 #endif
3629
3630 /*
3631  * Return 1 if one of the providers named in the string is available.
3632  * The provider names are separated with whitespace.
3633  * NOTE: destructive function, it inserts '\0' after each provider name.
3634  */
3635 static int prov_available(char *providers)
3636 {
3637     char *p;
3638     int more = 1;
3639
3640     while (more) {
3641         for (; isspace(*providers); providers++)
3642             continue;
3643         if (*providers == '\0')
3644             break;               /* End of the road */
3645         for (p = providers; *p != '\0' && !isspace(*p); p++)
3646             continue;
3647         if (*p == '\0')
3648             more = 0;
3649         else
3650             *p = '\0';
3651         if (OSSL_PROVIDER_available(libctx, providers))
3652             return 1;            /* Found one */
3653     }
3654     return 0;
3655 }
3656
3657 /* Read and parse one test.  Return 0 if failure, 1 if okay. */
3658 static int parse(EVP_TEST *t)
3659 {
3660     KEY_LIST *key, **klist;
3661     EVP_PKEY *pkey;
3662     PAIR *pp;
3663     int i, skip_availablein = 0;
3664
3665 top:
3666     do {
3667         if (BIO_eof(t->s.fp))
3668             return EOF;
3669         clear_test(t);
3670         if (!test_readstanza(&t->s))
3671             return 0;
3672     } while (t->s.numpairs == 0);
3673     pp = &t->s.pairs[0];
3674
3675     /* Are we adding a key? */
3676     klist = NULL;
3677     pkey = NULL;
3678 start:
3679     if (strcmp(pp->key, "PrivateKey") == 0) {
3680         pkey = PEM_read_bio_PrivateKey_ex(t->s.key, NULL, 0, NULL, libctx, NULL);
3681         if (pkey == NULL && !key_unsupported()) {
3682             EVP_PKEY_free(pkey);
3683             TEST_info("Can't read private key %s", pp->value);
3684             TEST_openssl_errors();
3685             return 0;
3686         }
3687         klist = &private_keys;
3688     } else if (strcmp(pp->key, "PublicKey") == 0) {
3689         pkey = PEM_read_bio_PUBKEY_ex(t->s.key, NULL, 0, NULL, libctx, NULL);
3690         if (pkey == NULL && !key_unsupported()) {
3691             EVP_PKEY_free(pkey);
3692             TEST_info("Can't read public key %s", pp->value);
3693             TEST_openssl_errors();
3694             return 0;
3695         }
3696         klist = &public_keys;
3697     } else if (strcmp(pp->key, "PrivateKeyRaw") == 0
3698                || strcmp(pp->key, "PublicKeyRaw") == 0) {
3699         char *strnid = NULL, *keydata = NULL;
3700         unsigned char *keybin;
3701         size_t keylen;
3702         int nid;
3703
3704         if (strcmp(pp->key, "PrivateKeyRaw") == 0)
3705             klist = &private_keys;
3706         else
3707             klist = &public_keys;
3708
3709         strnid = strchr(pp->value, ':');
3710         if (strnid != NULL) {
3711             *strnid++ = '\0';
3712             keydata = strchr(strnid, ':');
3713             if (keydata != NULL)
3714                 *keydata++ = '\0';
3715         }
3716         if (keydata == NULL) {
3717             TEST_info("Failed to parse %s value", pp->key);
3718             return 0;
3719         }
3720
3721         nid = OBJ_txt2nid(strnid);
3722         if (nid == NID_undef) {
3723             TEST_info("Unrecognised algorithm NID");
3724             return 0;
3725         }
3726         if (!parse_bin(keydata, &keybin, &keylen)) {
3727             TEST_info("Failed to create binary key");
3728             return 0;
3729         }
3730         if (klist == &private_keys)
3731             pkey = EVP_PKEY_new_raw_private_key_ex(libctx, strnid, NULL, keybin,
3732                                                    keylen);
3733         else
3734             pkey = EVP_PKEY_new_raw_public_key_ex(libctx, strnid, NULL, keybin,
3735                                                   keylen);
3736         if (pkey == NULL && !key_unsupported()) {
3737             TEST_info("Can't read %s data", pp->key);
3738             OPENSSL_free(keybin);
3739             TEST_openssl_errors();
3740             return 0;
3741         }
3742         OPENSSL_free(keybin);
3743     } else if (strcmp(pp->key, "Availablein") == 0) {
3744         if (!prov_available(pp->value)) {
3745             TEST_info("skipping, '%s' provider not available: %s:%d",
3746                       pp->value, t->s.test_file, t->s.start);
3747                 t->skip = 1;
3748                 return 0;
3749         }
3750         skip_availablein++;
3751         pp++;
3752         goto start;
3753     }
3754
3755     /* If we have a key add to list */
3756     if (klist != NULL) {
3757         if (find_key(NULL, pp->value, *klist)) {
3758             TEST_info("Duplicate key %s", pp->value);
3759             return 0;
3760         }
3761         if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key))))
3762             return 0;
3763         key->name = take_value(pp);
3764         key->key = pkey;
3765         key->next = *klist;
3766         *klist = key;
3767
3768         /* Go back and start a new stanza. */
3769         if ((t->s.numpairs - skip_availablein) != 1)
3770             TEST_info("Line %d: missing blank line\n", t->s.curr);
3771         goto top;
3772     }
3773
3774     /* Find the test, based on first keyword. */
3775     if (!TEST_ptr(t->meth = find_test(pp->key)))
3776         return 0;
3777     if (!t->meth->init(t, pp->value)) {
3778         TEST_error("unknown %s: %s\n", pp->key, pp->value);
3779         return 0;
3780     }
3781     if (t->skip == 1) {
3782         /* TEST_info("skipping %s %s", pp->key, pp->value); */
3783         return 0;
3784     }
3785
3786     for (pp++, i = 1; i < (t->s.numpairs - skip_availablein); pp++, i++) {
3787         if (strcmp(pp->key, "Securitycheck") == 0) {
3788 #if defined(OPENSSL_NO_FIPS_SECURITYCHECKS)
3789 #else
3790             if (!securitycheck_enabled())
3791 #endif
3792             {
3793                 TEST_info("skipping, Securitycheck is disabled: %s:%d",
3794                           t->s.test_file, t->s.start);
3795                 t->skip = 1;
3796                 return 0;
3797             }
3798         } else if (strcmp(pp->key, "Availablein") == 0) {
3799             TEST_info("Line %d: 'Availablein' should be the first option",
3800                       t->s.curr);
3801             return 0;
3802         } else if (strcmp(pp->key, "Result") == 0) {
3803             if (t->expected_err != NULL) {
3804                 TEST_info("Line %d: multiple result lines", t->s.curr);
3805                 return 0;
3806             }
3807             t->expected_err = take_value(pp);
3808         } else if (strcmp(pp->key, "Function") == 0) {
3809             /* Ignore old line. */
3810         } else if (strcmp(pp->key, "Reason") == 0) {
3811             if (t->reason != NULL) {
3812                 TEST_info("Line %d: multiple reason lines", t->s.curr);
3813                 return 0;
3814             }
3815             t->reason = take_value(pp);
3816         } else {
3817             /* Must be test specific line: try to parse it */
3818             int rv = t->meth->parse(t, pp->key, pp->value);
3819
3820             if (rv == 0) {
3821                 TEST_info("Line %d: unknown keyword %s", t->s.curr, pp->key);
3822                 return 0;
3823             }
3824             if (rv < 0) {
3825                 TEST_info("Line %d: error processing keyword %s = %s\n",
3826                           t->s.curr, pp->key, pp->value);
3827                 return 0;
3828             }
3829         }
3830     }
3831
3832     return 1;
3833 }
3834
3835 static int run_file_tests(int i)
3836 {
3837     EVP_TEST *t;
3838     const char *testfile = test_get_argument(i);
3839     int c;
3840
3841     if (!TEST_ptr(t = OPENSSL_zalloc(sizeof(*t))))
3842         return 0;
3843     if (!test_start_file(&t->s, testfile)) {
3844         OPENSSL_free(t);
3845         return 0;
3846     }
3847
3848     while (!BIO_eof(t->s.fp)) {
3849         c = parse(t);
3850         if (t->skip) {
3851             t->s.numskip++;
3852             continue;
3853         }
3854         if (c == 0 || !run_test(t)) {
3855             t->s.errors++;
3856             break;
3857         }
3858     }
3859     test_end_file(&t->s);
3860     clear_test(t);
3861
3862     free_key_list(public_keys);
3863     free_key_list(private_keys);
3864     BIO_free(t->s.key);
3865     c = t->s.errors;
3866     OPENSSL_free(t);
3867     return c == 0;
3868 }
3869
3870 const OPTIONS *test_get_options(void)
3871 {
3872     static const OPTIONS test_options[] = {
3873         OPT_TEST_OPTIONS_WITH_EXTRA_USAGE("[file...]\n"),
3874         { "config", OPT_CONFIG_FILE, '<',
3875           "The configuration file to use for the libctx" },
3876         { OPT_HELP_STR, 1, '-', "file\tFile to run tests on.\n" },
3877         { NULL }
3878     };
3879     return test_options;
3880 }
3881
3882 int setup_tests(void)
3883 {
3884     size_t n;
3885     char *config_file = NULL;
3886
3887     OPTION_CHOICE o;
3888
3889     while ((o = opt_next()) != OPT_EOF) {
3890         switch (o) {
3891         case OPT_CONFIG_FILE:
3892             config_file = opt_arg();
3893             break;
3894         case OPT_TEST_CASES:
3895            break;
3896         default:
3897         case OPT_ERR:
3898             return 0;
3899         }
3900     }
3901
3902     /*
3903      * Load the provider via configuration into the created library context.
3904      * Load the 'null' provider into the default library context to ensure that
3905      * the tests do not fallback to using the default provider.
3906      */
3907     if (!test_get_libctx(&libctx, &prov_null, config_file, NULL, NULL))
3908         return 0;
3909
3910     n = test_get_argument_count();
3911     if (n == 0)
3912         return 0;
3913
3914     ADD_ALL_TESTS(run_file_tests, n);
3915     return 1;
3916 }
3917
3918 void cleanup_tests(void)
3919 {
3920     OSSL_PROVIDER_unload(prov_null);
3921     OSSL_LIB_CTX_free(libctx);
3922 }
3923
3924 static int is_digest_disabled(const char *name)
3925 {
3926 #ifdef OPENSSL_NO_BLAKE2
3927     if (HAS_CASE_PREFIX(name, "BLAKE"))
3928         return 1;
3929 #endif
3930 #ifdef OPENSSL_NO_MD2
3931     if (strcasecmp(name, "MD2") == 0)
3932         return 1;
3933 #endif
3934 #ifdef OPENSSL_NO_MDC2
3935     if (strcasecmp(name, "MDC2") == 0)
3936         return 1;
3937 #endif
3938 #ifdef OPENSSL_NO_MD4
3939     if (strcasecmp(name, "MD4") == 0)
3940         return 1;
3941 #endif
3942 #ifdef OPENSSL_NO_MD5
3943     if (strcasecmp(name, "MD5") == 0)
3944         return 1;
3945 #endif
3946 #ifdef OPENSSL_NO_RMD160
3947     if (strcasecmp(name, "RIPEMD160") == 0)
3948         return 1;
3949 #endif
3950 #ifdef OPENSSL_NO_SM3
3951     if (strcasecmp(name, "SM3") == 0)
3952         return 1;
3953 #endif
3954 #ifdef OPENSSL_NO_WHIRLPOOL
3955     if (strcasecmp(name, "WHIRLPOOL") == 0)
3956         return 1;
3957 #endif
3958     return 0;
3959 }
3960
3961 static int is_pkey_disabled(const char *name)
3962 {
3963 #ifdef OPENSSL_NO_EC
3964     if (HAS_CASE_PREFIX(name, "EC"))
3965         return 1;
3966 #endif
3967 #ifdef OPENSSL_NO_DH
3968     if (HAS_CASE_PREFIX(name, "DH"))
3969         return 1;
3970 #endif
3971 #ifdef OPENSSL_NO_DSA
3972     if (HAS_CASE_PREFIX(name, "DSA"))
3973         return 1;
3974 #endif
3975     return 0;
3976 }
3977
3978 static int is_mac_disabled(const char *name)
3979 {
3980 #ifdef OPENSSL_NO_BLAKE2
3981     if (HAS_CASE_PREFIX(name, "BLAKE2BMAC")
3982         || HAS_CASE_PREFIX(name, "BLAKE2SMAC"))
3983         return 1;
3984 #endif
3985 #ifdef OPENSSL_NO_CMAC
3986     if (HAS_CASE_PREFIX(name, "CMAC"))
3987         return 1;
3988 #endif
3989 #ifdef OPENSSL_NO_POLY1305
3990     if (HAS_CASE_PREFIX(name, "Poly1305"))
3991         return 1;
3992 #endif
3993 #ifdef OPENSSL_NO_SIPHASH
3994     if (HAS_CASE_PREFIX(name, "SipHash"))
3995         return 1;
3996 #endif
3997     return 0;
3998 }
3999 static int is_kdf_disabled(const char *name)
4000 {
4001 #ifdef OPENSSL_NO_SCRYPT
4002     if (HAS_CASE_SUFFIX(name, "SCRYPT"))
4003         return 1;
4004 #endif
4005     return 0;
4006 }
4007
4008 static int is_cipher_disabled(const char *name)
4009 {
4010 #ifdef OPENSSL_NO_ARIA
4011     if (HAS_CASE_PREFIX(name, "ARIA"))
4012         return 1;
4013 #endif
4014 #ifdef OPENSSL_NO_BF
4015     if (HAS_CASE_PREFIX(name, "BF"))
4016         return 1;
4017 #endif
4018 #ifdef OPENSSL_NO_CAMELLIA
4019     if (HAS_CASE_PREFIX(name, "CAMELLIA"))
4020         return 1;
4021 #endif
4022 #ifdef OPENSSL_NO_CAST
4023     if (HAS_CASE_PREFIX(name, "CAST"))
4024         return 1;
4025 #endif
4026 #ifdef OPENSSL_NO_CHACHA
4027     if (HAS_CASE_PREFIX(name, "CHACHA"))
4028         return 1;
4029 #endif
4030 #ifdef OPENSSL_NO_POLY1305
4031     if (HAS_CASE_SUFFIX(name, "Poly1305"))
4032         return 1;
4033 #endif
4034 #ifdef OPENSSL_NO_DES
4035     if (HAS_CASE_PREFIX(name, "DES"))
4036         return 1;
4037     if (HAS_CASE_SUFFIX(name, "3DESwrap"))
4038         return 1;
4039 #endif
4040 #ifdef OPENSSL_NO_OCB
4041     if (HAS_CASE_SUFFIX(name, "OCB"))
4042         return 1;
4043 #endif
4044 #ifdef OPENSSL_NO_IDEA
4045     if (HAS_CASE_PREFIX(name, "IDEA"))
4046         return 1;
4047 #endif
4048 #ifdef OPENSSL_NO_RC2
4049     if (HAS_CASE_PREFIX(name, "RC2"))
4050         return 1;
4051 #endif
4052 #ifdef OPENSSL_NO_RC4
4053     if (HAS_CASE_PREFIX(name, "RC4"))
4054         return 1;
4055 #endif
4056 #ifdef OPENSSL_NO_RC5
4057     if (HAS_CASE_PREFIX(name, "RC5"))
4058         return 1;
4059 #endif
4060 #ifdef OPENSSL_NO_SEED
4061     if (HAS_CASE_PREFIX(name, "SEED"))
4062         return 1;
4063 #endif
4064 #ifdef OPENSSL_NO_SIV
4065     if (HAS_CASE_SUFFIX(name, "SIV"))
4066         return 1;
4067 #endif
4068 #ifdef OPENSSL_NO_SM4
4069     if (HAS_CASE_PREFIX(name, "SM4"))
4070         return 1;
4071 #endif
4072     return 0;
4073 }