test/evp_test.c

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