test/evp_test.c

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