crypto/evp/evp_test.c

   1 /* evp_test.c */
   2 /*
   3  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   4  * project.
   5  */
   6 /* ====================================================================
   7  * Copyright (c) 2015 The OpenSSL Project.  All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  *
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in
  18  *    the documentation and/or other materials provided with the
  19  *    distribution.
  20  *
  21  * 3. All advertising materials mentioning features or use of this
  22  *    software must display the following acknowledgment:
  23  *    "This product includes software developed by the OpenSSL Project
  24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  25  *
  26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  27  *    endorse or promote products derived from this software without
  28  *    prior written permission. For written permission, please contact
  29  *    licensing@OpenSSL.org.
  30  *
  31  * 5. Products derived from this software may not be called "OpenSSL"
  32  *    nor may "OpenSSL" appear in their names without prior written
  33  *    permission of the OpenSSL Project.
  34  *
  35  * 6. Redistributions of any form whatsoever must retain the following
  36  *    acknowledgment:
  37  *    "This product includes software developed by the OpenSSL Project
  38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  51  * OF THE POSSIBILITY OF SUCH DAMAGE.
  52  * ====================================================================
  53  */
  54
  55 #include <stdio.h>
  56 #include <string.h>
  57 #include <stdlib.h>
  58 #include <ctype.h>
  59 #include <openssl/evp.h>
  60 #include <openssl/err.h>
  61 #include <openssl/x509v3.h>
  62
  63 /* Remove spaces from beginning and end of a string */
  64
  65 static void remove_space(char **pval)
  66 {
  67     unsigned char *p = (unsigned char *)*pval;
  68
  69     while (isspace(*p))
  70         p++;
  71
  72     *pval = (char *)p;
  73
  74     p = p + strlen(*pval) - 1;
  75
  76     /* Remove trailing space */
  77     while (isspace(*p))
  78         *p-- = 0;
  79 }
  80
  81 /*
  82  * Given a line of the form:
  83  *      name = value # comment
  84  * extract name and value. NB: modifies passed buffer.
  85  */
  86
  87 static int parse_line(char **pkw, char **pval, char *linebuf)
  88 {
  89     char *p;
  90
  91     p = linebuf + strlen(linebuf) - 1;
  92
  93     if (*p != '\n') {
  94         fprintf(stderr, "FATAL: missing EOL\n");
  95         exit(1);
  96     }
  97
  98     /* Look for # */
  99
 100     p = strchr(linebuf, '#');
 101
 102     if (p)
 103         *p = '\0';
 104
 105     /* Look for = sign */
 106     p = strchr(linebuf, '=');
 107
 108     /* If no '=' exit */
 109     if (!p)
 110         return 0;
 111
 112     *p++ = '\0';
 113
 114     *pkw = linebuf;
 115     *pval = p;
 116
 117     /* Remove spaces from keyword and value */
 118     remove_space(pkw);
 119     remove_space(pval);
 120
 121     return 1;
 122 }
 123
 124 /* For a hex string "value" convert to a binary allocated buffer */
 125 static int test_bin(const char *value, unsigned char **buf, size_t *buflen)
 126 {
 127     long len;
 128     if (!*value) {
 129         /* Don't return NULL for zero length buffer */
 130         *buf = OPENSSL_malloc(1);
 131         if (!*buf)
 132             return 0;
 133         **buf = 0;
 134         *buflen = 0;
 135         return 1;
 136     }
 137     *buf = string_to_hex(value, &len);
 138     if (!*buf) {
 139         fprintf(stderr, "Value=%s\n", value);
 140         ERR_print_errors_fp(stderr);
 141         return -1;
 142     }
 143     /* Size of input buffer means we'll never overflow */
 144     *buflen = len;
 145     return 1;
 146 }
 147
 148 /* Structure holding test information */
 149 struct evp_test {
 150     /* method for this test */
 151     const struct evp_test_method *meth;
 152     /* current line being processed */
 153     unsigned int line;
 154     /* start line of current test */
 155     unsigned int start_line;
 156     /* Error string for test */
 157     const char *err;
 158     /* Expected error value of test */
 159     char *expected_err;
 160     /* Number of tests */
 161     int ntests;
 162     /* Error count */
 163     int errors;
 164     /* If output mismatch expected and got value */
 165     unsigned char *out_got;
 166     unsigned char *out_expected;
 167     size_t out_len;
 168     /* test specific data */
 169     void *data;
 170 };
 171 /* Test method structure */
 172 struct evp_test_method {
 173     /* Name of test as it appears in file */
 174     const char *name;
 175     /* Initialise test for "alg" */
 176     int (*init) (struct evp_test * t, const char *alg);
 177     /* Clean up method */
 178     void (*cleanup) (struct evp_test * t);
 179     /* Test specific name value pair processing */
 180     int (*parse) (struct evp_test * t, const char *name, const char *value);
 181     /* Run the test itself */
 182     int (*run_test) (struct evp_test * t);
 183 };
 184
 185 static const struct evp_test_method digest_test_method, cipher_test_method;
 186 static const struct evp_test_method aead_test_method;
 187
 188 static const struct evp_test_method *evp_test_list[] = {
 189     &digest_test_method,
 190     &cipher_test_method,
 191     NULL,
 192 };
 193
 194 static const struct evp_test_method *evp_find_test(const char *name)
 195 {
 196     const struct evp_test_method **tt;
 197     for (tt = evp_test_list; *tt; tt++) {
 198         if (!strcmp(name, (*tt)->name))
 199             return *tt;
 200     }
 201     return NULL;
 202 }
 203
 204 static void hex_print(const char *name, const unsigned char *buf, size_t len)
 205 {
 206     size_t i;
 207     fprintf(stderr, "%s ", name);
 208     for (i = 0; i < len; i++)
 209         fprintf(stderr, "%02X", buf[i]);
 210     fputs("\n", stderr);
 211 }
 212
 213 static void print_expected(struct evp_test *t)
 214 {
 215     if (t->out_expected == NULL)
 216         return;
 217     hex_print("Expected:", t->out_expected, t->out_len);
 218     hex_print("Got:     ", t->out_got, t->out_len);
 219     OPENSSL_free(t->out_expected);
 220     OPENSSL_free(t->out_got);
 221     t->out_expected = NULL;
 222     t->out_got = NULL;
 223 }
 224
 225 static int check_test_error(struct evp_test *t)
 226 {
 227     if (!t->err && !t->expected_err)
 228         return 1;
 229     if (t->err && !t->expected_err) {
 230         fprintf(stderr, "Test line %d: unexpected error %s\n",
 231                 t->start_line, t->err);
 232         print_expected(t);
 233         return 0;
 234     }
 235     if (!t->err && t->expected_err) {
 236         fprintf(stderr, "Test line %d: succeeded expecting %s\n",
 237                 t->start_line, t->expected_err);
 238         return 0;
 239     }
 240     if (!strcmp(t->err, t->expected_err))
 241         return 1;
 242
 243     fprintf(stderr, "Test line %d: expecting %s got %s\n",
 244             t->start_line, t->expected_err, t->err);
 245     return 0;
 246 }
 247
 248 /* Setup a new test, run any existing test */
 249
 250 static int setup_test(struct evp_test *t, const struct evp_test_method *tmeth)
 251 {
 252     /* If we already have a test set up run it */
 253     if (t->meth) {
 254         t->ntests++;
 255         t->err = NULL;
 256         if (t->meth->run_test(t) != 1) {
 257             fprintf(stderr, "%s test error line %d\n",
 258                     t->meth->name, t->start_line);
 259             return 0;
 260         }
 261         if (!check_test_error(t)) {
 262             if (t->err)
 263                 ERR_print_errors_fp(stderr);
 264             t->errors++;
 265         }
 266         ERR_clear_error();
 267         t->meth->cleanup(t);
 268         /* If new test type free old data */
 269         if (tmeth != t->meth && t->data) {
 270             OPENSSL_free(t->data);
 271             t->data = NULL;
 272         }
 273         if (t->expected_err) {
 274             OPENSSL_free(t->expected_err);
 275             t->expected_err = NULL;
 276         }
 277     }
 278     t->meth = tmeth;
 279     return 1;
 280 }
 281
 282 static int process_test(struct evp_test *t, char *buf, int verbose)
 283 {
 284     char *keyword, *value;
 285     int rv = 0;
 286     const struct evp_test_method *tmeth;
 287     if (verbose)
 288         fputs(buf, stdout);
 289     if (!parse_line(&keyword, &value, buf))
 290         return 1;
 291     /* See if keyword corresponds to a test start */
 292     tmeth = evp_find_test(keyword);
 293     if (tmeth) {
 294         if (!setup_test(t, tmeth))
 295             return 0;
 296         t->start_line = t->line;
 297         if (!tmeth->init(t, value)) {
 298             fprintf(stderr, "Unknown %s: %s\n", keyword, value);
 299             return 0;
 300         }
 301         return 1;
 302     } else if (!strcmp(keyword, "Result")) {
 303         if (t->expected_err) {
 304             fprintf(stderr, "Line %d: multiple result lines\n", t->line);
 305             return 0;
 306         }
 307         t->expected_err = BUF_strdup(value);
 308         if (!t->expected_err)
 309             return 0;
 310     } else {
 311         /* Must be test specific line: try to parse it */
 312         if (t->meth)
 313             rv = t->meth->parse(t, keyword, value);
 314
 315         if (rv == 0)
 316             fprintf(stderr, "line %d: unexpected keyword %s\n",
 317                     t->line, keyword);
 318
 319         if (rv < 0)
 320             fprintf(stderr, "line %d: error processing keyword %s\n",
 321                     t->line, keyword);
 322         if (rv <= 0)
 323             return 0;
 324     }
 325     return 1;
 326 }
 327
 328 static int check_output(struct evp_test *t, const unsigned char *expected,
 329                         const unsigned char *got, size_t len)
 330 {
 331     if (!memcmp(expected, got, len))
 332         return 0;
 333     t->out_expected = BUF_memdup(expected, len);
 334     t->out_got = BUF_memdup(got, len);
 335     t->out_len = len;
 336     if (t->out_expected == NULL || t->out_got == NULL) {
 337         fprintf(stderr, "Memory allocation error!\n");
 338         exit(1);
 339     }
 340     return 1;
 341 }
 342
 343 int main(int argc, char **argv)
 344 {
 345     FILE *in = NULL;
 346     char buf[10240];
 347     struct evp_test t;
 348
 349     if (argc != 2) {
 350         fprintf(stderr, "usage: evp_test testfile.txt\n");
 351         return 1;
 352     }
 353
 354     ERR_load_crypto_strings();
 355     OpenSSL_add_all_algorithms();
 356     t.meth = NULL;
 357     t.err = NULL;
 358     t.line = 0;
 359     t.start_line = -1;
 360     t.errors = 0;
 361     t.ntests = 0;
 362     t.out_expected = NULL;
 363     t.out_got = NULL;
 364     t.out_len = 0;
 365     in = fopen(argv[1], "r");
 366     while (fgets(buf, sizeof(buf), in)) {
 367         t.line++;
 368         if (!process_test(&t, buf, 0))
 369             exit(1);
 370     }
 371     /* Run any final test we have */
 372     if (!setup_test(&t, NULL))
 373         exit(1);
 374     fprintf(stderr, "%d tests completed with %d errors\n",
 375             t.ntests, t.errors);
 376     fclose(in);
 377     return 0;
 378 }
 379
 380 static void test_free(void *d)
 381 {
 382     if (d)
 383         OPENSSL_free(d);
 384 }
 385
 386 /* Message digest tests */
 387
 388 struct digest_data {
 389     /* Digest this test is for */
 390     const EVP_MD *digest;
 391     /* Input to digest */
 392     unsigned char *input;
 393     size_t input_len;
 394     /* Expected output */
 395     unsigned char *output;
 396     size_t output_len;
 397 };
 398
 399 static int digest_test_init(struct evp_test *t, const char *alg)
 400 {
 401     const EVP_MD *digest;
 402     struct digest_data *mdat = t->data;
 403     digest = EVP_get_digestbyname(alg);
 404     if (!digest)
 405         return 0;
 406     mdat = OPENSSL_malloc(sizeof(struct digest_data));
 407     mdat->digest = digest;
 408     mdat->input = NULL;
 409     mdat->output = NULL;
 410     t->data = mdat;
 411     return 1;
 412 }
 413
 414 static void digest_test_cleanup(struct evp_test *t)
 415 {
 416     struct digest_data *mdat = t->data;
 417     test_free(mdat->input);
 418     test_free(mdat->output);
 419 }
 420
 421 static int digest_test_parse(struct evp_test *t,
 422                              const char *keyword, const char *value)
 423 {
 424     struct digest_data *mdata = t->data;
 425     if (!strcmp(keyword, "Input"))
 426         return test_bin(value, &mdata->input, &mdata->input_len);
 427     if (!strcmp(keyword, "Output"))
 428         return test_bin(value, &mdata->output, &mdata->output_len);
 429     return 0;
 430 }
 431
 432 static int digest_test_run(struct evp_test *t)
 433 {
 434     struct digest_data *mdata = t->data;
 435     const char *err = "INTERNAL_ERROR";
 436     EVP_MD_CTX *mctx;
 437     unsigned char md[EVP_MAX_MD_SIZE];
 438     unsigned int md_len;
 439     mctx = EVP_MD_CTX_create();
 440     if (!mctx)
 441         goto err;
 442     err = "DIGESTINIT_ERROR";
 443     if (!EVP_DigestInit_ex(mctx, mdata->digest, NULL))
 444         goto err;
 445     err = "DIGESTUPDATE_ERROR";
 446     if (!EVP_DigestUpdate(mctx, mdata->input, mdata->input_len))
 447         goto err;
 448     err = "DIGESTFINAL_ERROR";
 449     if (!EVP_DigestFinal(mctx, md, &md_len))
 450         goto err;
 451     err = "DIGEST_LENGTH_MISMATCH";
 452     if (md_len != mdata->output_len)
 453         goto err;
 454     err = "DIGEST_MISMATCH";
 455     if (check_output(t, mdata->output, md, md_len))
 456         goto err;
 457     err = NULL;
 458  err:
 459     if (mctx)
 460         EVP_MD_CTX_destroy(mctx);
 461     t->err = err;
 462     return 1;
 463 }
 464
 465 static const struct evp_test_method digest_test_method = {
 466     "Digest",
 467     digest_test_init,
 468     digest_test_cleanup,
 469     digest_test_parse,
 470     digest_test_run
 471 };
 472
 473 /* Cipher tests */
 474 struct cipher_data {
 475     const EVP_CIPHER *cipher;
 476     int enc;
 477     /* Set to EVP_CIPH_GCM_MODE or EVP_CIPH_CCM_MODE if AEAD */
 478     int aead;
 479     unsigned char *key;
 480     size_t key_len;
 481     unsigned char *iv;
 482     size_t iv_len;
 483     unsigned char *plaintext;
 484     size_t plaintext_len;
 485     unsigned char *ciphertext;
 486     size_t ciphertext_len;
 487     /* GCM, CCM only */
 488     unsigned char *aad;
 489     size_t aad_len;
 490     unsigned char *tag;
 491     size_t tag_len;
 492 };
 493
 494 static int cipher_test_init(struct evp_test *t, const char *alg)
 495 {
 496     const EVP_CIPHER *cipher;
 497     struct cipher_data *cdat = t->data;
 498     cipher = EVP_get_cipherbyname(alg);
 499     if (!cipher)
 500         return 0;
 501     cdat = OPENSSL_malloc(sizeof(struct cipher_data));
 502     cdat->cipher = cipher;
 503     cdat->enc = -1;
 504     cdat->key = NULL;
 505     cdat->iv = NULL;
 506     cdat->ciphertext = NULL;
 507     cdat->plaintext = NULL;
 508     cdat->aad = NULL;
 509     cdat->tag = NULL;
 510     t->data = cdat;
 511     if (EVP_CIPHER_mode(cipher) == EVP_CIPH_GCM_MODE
 512         || EVP_CIPHER_mode(cipher) == EVP_CIPH_CCM_MODE)
 513         cdat->aead = EVP_CIPHER_mode(cipher);
 514     else
 515         cdat->aead = 0;
 516
 517     return 1;
 518 }
 519
 520 static void cipher_test_cleanup(struct evp_test *t)
 521 {
 522     struct cipher_data *cdat = t->data;
 523     test_free(cdat->key);
 524     test_free(cdat->iv);
 525     test_free(cdat->ciphertext);
 526     test_free(cdat->plaintext);
 527     test_free(cdat->aad);
 528     test_free(cdat->tag);
 529 }
 530
 531 static int cipher_test_parse(struct evp_test *t, const char *keyword,
 532                              const char *value)
 533 {
 534     struct cipher_data *cdat = t->data;
 535     if (!strcmp(keyword, "Key"))
 536         return test_bin(value, &cdat->key, &cdat->key_len);
 537     if (!strcmp(keyword, "IV"))
 538         return test_bin(value, &cdat->iv, &cdat->iv_len);
 539     if (!strcmp(keyword, "Plaintext"))
 540         return test_bin(value, &cdat->plaintext, &cdat->plaintext_len);
 541     if (!strcmp(keyword, "Ciphertext"))
 542         return test_bin(value, &cdat->ciphertext, &cdat->ciphertext_len);
 543     if (cdat->aead) {
 544         if (!strcmp(keyword, "AAD"))
 545             return test_bin(value, &cdat->aad, &cdat->aad_len);
 546         if (!strcmp(keyword, "Tag"))
 547             return test_bin(value, &cdat->tag, &cdat->tag_len);
 548     }
 549
 550     if (!strcmp(keyword, "Operation")) {
 551         if (!strcmp(value, "ENCRYPT"))
 552             cdat->enc = 1;
 553         else if (!strcmp(value, "DECRYPT"))
 554             cdat->enc = 0;
 555         else
 556             return 0;
 557         return 1;
 558     }
 559     return 0;
 560 }
 561
 562 static int cipher_test_enc(struct evp_test *t, int enc)
 563 {
 564     struct cipher_data *cdat = t->data;
 565     unsigned char *in, *out, *tmp = NULL;
 566     size_t in_len, out_len;
 567     int tmplen, tmpflen;
 568     EVP_CIPHER_CTX *ctx = NULL;
 569     const char *err;
 570     err = "INTERNAL_ERROR";
 571     ctx = EVP_CIPHER_CTX_new();
 572     if (!ctx)
 573         goto err;
 574     EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
 575     if (enc) {
 576         in = cdat->plaintext;
 577         in_len = cdat->plaintext_len;
 578         out = cdat->ciphertext;
 579         out_len = cdat->ciphertext_len;
 580     } else {
 581         in = cdat->ciphertext;
 582         in_len = cdat->ciphertext_len;
 583         out = cdat->plaintext;
 584         out_len = cdat->plaintext_len;
 585     }
 586     tmp = OPENSSL_malloc(in_len + 2 * EVP_MAX_BLOCK_LENGTH);
 587     if (!tmp)
 588         goto err;
 589     err = "CIPHERINIT_ERROR";
 590     if (!EVP_CipherInit_ex(ctx, cdat->cipher, NULL, NULL, NULL, enc))
 591         goto err;
 592     err = "INVALID_IV_LENGTH";
 593     if (cdat->iv) {
 594         if (cdat->aead == EVP_CIPH_GCM_MODE) {
 595             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN,
 596                                      cdat->iv_len, 0))
 597                 goto err;
 598         } else if (cdat->aead == EVP_CIPH_CCM_MODE) {
 599             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_IVLEN,
 600                                      cdat->iv_len, 0))
 601                 goto err;
 602         } else if (cdat->iv_len != (size_t)EVP_CIPHER_CTX_iv_length(ctx))
 603             goto err;
 604     }
 605     if (cdat->aead) {
 606         unsigned char *tag;
 607         /*
 608          * If encrypting just set tag length. If decrypting set
 609          * tag length and value.
 610          */
 611         if (enc) {
 612             err = "TAG_LENGTH_SET_ERROR";
 613             tag = NULL;
 614         } else {
 615             err = "TAG_SET_ERROR";
 616             tag = cdat->tag;
 617         }
 618         if (cdat->aead == EVP_CIPH_GCM_MODE && tag) {
 619             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG,
 620                                      cdat->tag_len, tag))
 621                 goto err;
 622         } else if (cdat->aead == EVP_CIPH_CCM_MODE) {
 623             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_TAG,
 624                                      cdat->tag_len, tag))
 625                 goto err;
 626         }
 627     }
 628
 629     err = "INVALID_KEY_LENGTH";
 630     if (!EVP_CIPHER_CTX_set_key_length(ctx, cdat->key_len))
 631         goto err;
 632     err = "KEY_SET_ERROR";
 633     if (!EVP_CipherInit_ex(ctx, NULL, NULL, cdat->key, cdat->iv, -1))
 634         goto err;
 635
 636     if (cdat->aead == EVP_CIPH_CCM_MODE) {
 637         if (!EVP_CipherUpdate(ctx, NULL, &tmplen, NULL, out_len)) {
 638             err = "CCM_PLAINTEXT_LENGTH_SET_ERROR";
 639             goto err;
 640         }
 641     }
 642     if (cdat->aad) {
 643         if (!EVP_CipherUpdate(ctx, NULL, &tmplen, cdat->aad, cdat->aad_len)) {
 644             err = "AAD_SET_ERROR";
 645             goto err;
 646         }
 647     }
 648     EVP_CIPHER_CTX_set_padding(ctx, 0);
 649     err = "CIPHERUPDATE_ERROR";
 650     if (!EVP_CipherUpdate(ctx, tmp, &tmplen, in, in_len))
 651         goto err;
 652     if (cdat->aead == EVP_CIPH_CCM_MODE)
 653         tmpflen = 0;
 654     else {
 655         err = "CIPHERFINAL_ERROR";
 656         if (!EVP_CipherFinal_ex(ctx, tmp + tmplen, &tmpflen))
 657             goto err;
 658     }
 659     err = "LENGTH_MISMATCH";
 660     if (out_len != (size_t)(tmplen + tmpflen))
 661         goto err;
 662     err = "VALUE_MISMATCH";
 663     if (check_output(t, out, tmp, out_len))
 664         goto err;
 665     if (enc && cdat->aead) {
 666         unsigned char rtag[16];
 667         if (cdat->tag_len > sizeof(rtag)) {
 668             err = "TAG_LENGTH_INTERNAL_ERROR";
 669             goto err;
 670         }
 671         /* EVP_CTRL_CCM_GET_TAG and EVP_CTRL_GCM_GET_TAG are equal. */
 672         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG,
 673                                  cdat->tag_len, rtag)) {
 674             err = "TAG_RETRIEVE_ERROR";
 675             goto err;
 676         }
 677         if (check_output(t, cdat->tag, rtag, cdat->tag_len)) {
 678             err = "TAG_VALUE_MISMATCH";
 679             goto err;
 680         }
 681     }
 682     err = NULL;
 683  err:
 684     if (tmp)
 685         OPENSSL_free(tmp);
 686     EVP_CIPHER_CTX_free(ctx);
 687     t->err = err;
 688     return err ? 0 : 1;
 689 }
 690
 691 static int cipher_test_run(struct evp_test *t)
 692 {
 693     struct cipher_data *cdat = t->data;
 694     int rv;
 695     if (!cdat->key) {
 696         t->err = "NO_KEY";
 697         return 0;
 698     }
 699     if (!cdat->iv && EVP_CIPHER_iv_length(cdat->cipher)) {
 700         /* IV is optional and usually omitted in wrap mode */
 701         if (EVP_CIPHER_mode(cdat->cipher) != EVP_CIPH_WRAP_MODE) {
 702             t->err = "NO_IV";
 703             return 0;
 704         }
 705     }
 706     if (cdat->aead && !cdat->tag) {
 707         t->err = "NO_TAG";
 708         return 0;
 709     }
 710     if (cdat->enc) {
 711         rv = cipher_test_enc(t, 1);
 712         /* Not fatal errors: return */
 713         if (rv != 1) {
 714             if (rv < 0)
 715                 return 0;
 716             return 1;
 717         }
 718     }
 719     if (cdat->enc != 1) {
 720         rv = cipher_test_enc(t, 0);
 721         /* Not fatal errors: return */
 722         if (rv != 1) {
 723             if (rv < 0)
 724                 return 0;
 725             return 1;
 726         }
 727     }
 728     return 1;
 729 }
 730
 731 static const struct evp_test_method cipher_test_method = {
 732     "Cipher",
 733     cipher_test_init,
 734     cipher_test_cleanup,
 735     cipher_test_parse,
 736     cipher_test_run
 737 };