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