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