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