test/evp_test.c

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