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