New macro to set mac key.
[openssl.git] / 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     if (t.errors)
378         return 1;
379     return 0;
380 }
381
382 static void test_free(void *d)
383 {
384     if (d)
385         OPENSSL_free(d);
386 }
387
388 /* Message digest tests */
389
390 struct digest_data {
391     /* Digest this test is for */
392     const EVP_MD *digest;
393     /* Input to digest */
394     unsigned char *input;
395     size_t input_len;
396     /* Expected output */
397     unsigned char *output;
398     size_t output_len;
399 };
400
401 static int digest_test_init(struct evp_test *t, const char *alg)
402 {
403     const EVP_MD *digest;
404     struct digest_data *mdat = t->data;
405     digest = EVP_get_digestbyname(alg);
406     if (!digest)
407         return 0;
408     mdat = OPENSSL_malloc(sizeof(struct digest_data));
409     mdat->digest = digest;
410     mdat->input = NULL;
411     mdat->output = NULL;
412     t->data = mdat;
413     return 1;
414 }
415
416 static void digest_test_cleanup(struct evp_test *t)
417 {
418     struct digest_data *mdat = t->data;
419     test_free(mdat->input);
420     test_free(mdat->output);
421 }
422
423 static int digest_test_parse(struct evp_test *t,
424                              const char *keyword, const char *value)
425 {
426     struct digest_data *mdata = t->data;
427     if (!strcmp(keyword, "Input"))
428         return test_bin(value, &mdata->input, &mdata->input_len);
429     if (!strcmp(keyword, "Output"))
430         return test_bin(value, &mdata->output, &mdata->output_len);
431     return 0;
432 }
433
434 static int digest_test_run(struct evp_test *t)
435 {
436     struct digest_data *mdata = t->data;
437     const char *err = "INTERNAL_ERROR";
438     EVP_MD_CTX *mctx;
439     unsigned char md[EVP_MAX_MD_SIZE];
440     unsigned int md_len;
441     mctx = EVP_MD_CTX_create();
442     if (!mctx)
443         goto err;
444     err = "DIGESTINIT_ERROR";
445     if (!EVP_DigestInit_ex(mctx, mdata->digest, NULL))
446         goto err;
447     err = "DIGESTUPDATE_ERROR";
448     if (!EVP_DigestUpdate(mctx, mdata->input, mdata->input_len))
449         goto err;
450     err = "DIGESTFINAL_ERROR";
451     if (!EVP_DigestFinal(mctx, md, &md_len))
452         goto err;
453     err = "DIGEST_LENGTH_MISMATCH";
454     if (md_len != mdata->output_len)
455         goto err;
456     err = "DIGEST_MISMATCH";
457     if (check_output(t, mdata->output, md, md_len))
458         goto err;
459     err = NULL;
460  err:
461     if (mctx)
462         EVP_MD_CTX_destroy(mctx);
463     t->err = err;
464     return 1;
465 }
466
467 static const struct evp_test_method digest_test_method = {
468     "Digest",
469     digest_test_init,
470     digest_test_cleanup,
471     digest_test_parse,
472     digest_test_run
473 };
474
475 /* Cipher tests */
476 struct cipher_data {
477     const EVP_CIPHER *cipher;
478     int enc;
479     /* Set to EVP_CIPH_GCM_MODE or EVP_CIPH_CCM_MODE if AEAD */
480     int aead;
481     unsigned char *key;
482     size_t key_len;
483     unsigned char *iv;
484     size_t iv_len;
485     unsigned char *plaintext;
486     size_t plaintext_len;
487     unsigned char *ciphertext;
488     size_t ciphertext_len;
489     /* GCM, CCM only */
490     unsigned char *aad;
491     size_t aad_len;
492     unsigned char *tag;
493     size_t tag_len;
494 };
495
496 static int cipher_test_init(struct evp_test *t, const char *alg)
497 {
498     const EVP_CIPHER *cipher;
499     struct cipher_data *cdat = t->data;
500     cipher = EVP_get_cipherbyname(alg);
501     if (!cipher)
502         return 0;
503     cdat = OPENSSL_malloc(sizeof(struct cipher_data));
504     cdat->cipher = cipher;
505     cdat->enc = -1;
506     cdat->key = NULL;
507     cdat->iv = NULL;
508     cdat->ciphertext = NULL;
509     cdat->plaintext = NULL;
510     cdat->aad = NULL;
511     cdat->tag = NULL;
512     t->data = cdat;
513     if (EVP_CIPHER_mode(cipher) == EVP_CIPH_GCM_MODE
514         || EVP_CIPHER_mode(cipher) == EVP_CIPH_CCM_MODE)
515         cdat->aead = EVP_CIPHER_mode(cipher);
516     else
517         cdat->aead = 0;
518
519     return 1;
520 }
521
522 static void cipher_test_cleanup(struct evp_test *t)
523 {
524     struct cipher_data *cdat = t->data;
525     test_free(cdat->key);
526     test_free(cdat->iv);
527     test_free(cdat->ciphertext);
528     test_free(cdat->plaintext);
529     test_free(cdat->aad);
530     test_free(cdat->tag);
531 }
532
533 static int cipher_test_parse(struct evp_test *t, const char *keyword,
534                              const char *value)
535 {
536     struct cipher_data *cdat = t->data;
537     if (!strcmp(keyword, "Key"))
538         return test_bin(value, &cdat->key, &cdat->key_len);
539     if (!strcmp(keyword, "IV"))
540         return test_bin(value, &cdat->iv, &cdat->iv_len);
541     if (!strcmp(keyword, "Plaintext"))
542         return test_bin(value, &cdat->plaintext, &cdat->plaintext_len);
543     if (!strcmp(keyword, "Ciphertext"))
544         return test_bin(value, &cdat->ciphertext, &cdat->ciphertext_len);
545     if (cdat->aead) {
546         if (!strcmp(keyword, "AAD"))
547             return test_bin(value, &cdat->aad, &cdat->aad_len);
548         if (!strcmp(keyword, "Tag"))
549             return test_bin(value, &cdat->tag, &cdat->tag_len);
550     }
551
552     if (!strcmp(keyword, "Operation")) {
553         if (!strcmp(value, "ENCRYPT"))
554             cdat->enc = 1;
555         else if (!strcmp(value, "DECRYPT"))
556             cdat->enc = 0;
557         else
558             return 0;
559         return 1;
560     }
561     return 0;
562 }
563
564 static int cipher_test_enc(struct evp_test *t, int enc)
565 {
566     struct cipher_data *cdat = t->data;
567     unsigned char *in, *out, *tmp = NULL;
568     size_t in_len, out_len;
569     int tmplen, tmpflen;
570     EVP_CIPHER_CTX *ctx = NULL;
571     const char *err;
572     err = "INTERNAL_ERROR";
573     ctx = EVP_CIPHER_CTX_new();
574     if (!ctx)
575         goto err;
576     EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
577     if (enc) {
578         in = cdat->plaintext;
579         in_len = cdat->plaintext_len;
580         out = cdat->ciphertext;
581         out_len = cdat->ciphertext_len;
582     } else {
583         in = cdat->ciphertext;
584         in_len = cdat->ciphertext_len;
585         out = cdat->plaintext;
586         out_len = cdat->plaintext_len;
587     }
588     tmp = OPENSSL_malloc(in_len + 2 * EVP_MAX_BLOCK_LENGTH);
589     if (!tmp)
590         goto err;
591     err = "CIPHERINIT_ERROR";
592     if (!EVP_CipherInit_ex(ctx, cdat->cipher, NULL, NULL, NULL, enc))
593         goto err;
594     err = "INVALID_IV_LENGTH";
595     if (cdat->iv) {
596         if (cdat->aead == EVP_CIPH_GCM_MODE) {
597             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN,
598                                      cdat->iv_len, 0))
599                 goto err;
600         } else if (cdat->aead == EVP_CIPH_CCM_MODE) {
601             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_IVLEN,
602                                      cdat->iv_len, 0))
603                 goto err;
604         } else if (cdat->iv_len != (size_t)EVP_CIPHER_CTX_iv_length(ctx))
605             goto err;
606     }
607     if (cdat->aead) {
608         unsigned char *tag;
609         /*
610          * If encrypting just set tag length. If decrypting set
611          * tag length and value.
612          */
613         if (enc) {
614             err = "TAG_LENGTH_SET_ERROR";
615             tag = NULL;
616         } else {
617             err = "TAG_SET_ERROR";
618             tag = cdat->tag;
619         }
620         if (cdat->aead == EVP_CIPH_GCM_MODE && tag) {
621             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG,
622                                      cdat->tag_len, tag))
623                 goto err;
624         } else if (cdat->aead == EVP_CIPH_CCM_MODE) {
625             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_TAG,
626                                      cdat->tag_len, tag))
627                 goto err;
628         }
629     }
630
631     err = "INVALID_KEY_LENGTH";
632     if (!EVP_CIPHER_CTX_set_key_length(ctx, cdat->key_len))
633         goto err;
634     err = "KEY_SET_ERROR";
635     if (!EVP_CipherInit_ex(ctx, NULL, NULL, cdat->key, cdat->iv, -1))
636         goto err;
637
638     if (cdat->aead == EVP_CIPH_CCM_MODE) {
639         if (!EVP_CipherUpdate(ctx, NULL, &tmplen, NULL, out_len)) {
640             err = "CCM_PLAINTEXT_LENGTH_SET_ERROR";
641             goto err;
642         }
643     }
644     if (cdat->aad) {
645         if (!EVP_CipherUpdate(ctx, NULL, &tmplen, cdat->aad, cdat->aad_len)) {
646             err = "AAD_SET_ERROR";
647             goto err;
648         }
649     }
650     EVP_CIPHER_CTX_set_padding(ctx, 0);
651     err = "CIPHERUPDATE_ERROR";
652     if (!EVP_CipherUpdate(ctx, tmp, &tmplen, in, in_len))
653         goto err;
654     if (cdat->aead == EVP_CIPH_CCM_MODE)
655         tmpflen = 0;
656     else {
657         err = "CIPHERFINAL_ERROR";
658         if (!EVP_CipherFinal_ex(ctx, tmp + tmplen, &tmpflen))
659             goto err;
660     }
661     err = "LENGTH_MISMATCH";
662     if (out_len != (size_t)(tmplen + tmpflen))
663         goto err;
664     err = "VALUE_MISMATCH";
665     if (check_output(t, out, tmp, out_len))
666         goto err;
667     if (enc && cdat->aead) {
668         unsigned char rtag[16];
669         if (cdat->tag_len > sizeof(rtag)) {
670             err = "TAG_LENGTH_INTERNAL_ERROR";
671             goto err;
672         }
673         /* EVP_CTRL_CCM_GET_TAG and EVP_CTRL_GCM_GET_TAG are equal. */
674         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG,
675                                  cdat->tag_len, rtag)) {
676             err = "TAG_RETRIEVE_ERROR";
677             goto err;
678         }
679         if (check_output(t, cdat->tag, rtag, cdat->tag_len)) {
680             err = "TAG_VALUE_MISMATCH";
681             goto err;
682         }
683     }
684     err = NULL;
685  err:
686     if (tmp)
687         OPENSSL_free(tmp);
688     EVP_CIPHER_CTX_free(ctx);
689     t->err = err;
690     return err ? 0 : 1;
691 }
692
693 static int cipher_test_run(struct evp_test *t)
694 {
695     struct cipher_data *cdat = t->data;
696     int rv;
697     if (!cdat->key) {
698         t->err = "NO_KEY";
699         return 0;
700     }
701     if (!cdat->iv && EVP_CIPHER_iv_length(cdat->cipher)) {
702         /* IV is optional and usually omitted in wrap mode */
703         if (EVP_CIPHER_mode(cdat->cipher) != EVP_CIPH_WRAP_MODE) {
704             t->err = "NO_IV";
705             return 0;
706         }
707     }
708     if (cdat->aead && !cdat->tag) {
709         t->err = "NO_TAG";
710         return 0;
711     }
712     if (cdat->enc) {
713         rv = cipher_test_enc(t, 1);
714         /* Not fatal errors: return */
715         if (rv != 1) {
716             if (rv < 0)
717                 return 0;
718             return 1;
719         }
720     }
721     if (cdat->enc != 1) {
722         rv = cipher_test_enc(t, 0);
723         /* Not fatal errors: return */
724         if (rv != 1) {
725             if (rv < 0)
726                 return 0;
727             return 1;
728         }
729     }
730     return 1;
731 }
732
733 static const struct evp_test_method cipher_test_method = {
734     "Cipher",
735     cipher_test_init,
736     cipher_test_cleanup,
737     cipher_test_parse,
738     cipher_test_run
739 };