Make OpenSSL compile with no-rc4
[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/pem.h>
61 #include <openssl/err.h>
62 #include <openssl/x509v3.h>
63
64 /* Remove spaces from beginning and end of a string */
65
66 static void remove_space(char **pval)
67 {
68     unsigned char *p = (unsigned char *)*pval;
69
70     while (isspace(*p))
71         p++;
72
73     *pval = (char *)p;
74
75     p = p + strlen(*pval) - 1;
76
77     /* Remove trailing space */
78     while (isspace(*p))
79         *p-- = 0;
80 }
81
82 /*
83  * Given a line of the form:
84  *      name = value # comment
85  * extract name and value. NB: modifies passed buffer.
86  */
87
88 static int parse_line(char **pkw, char **pval, char *linebuf)
89 {
90     char *p;
91
92     p = linebuf + strlen(linebuf) - 1;
93
94     if (*p != '\n') {
95         fprintf(stderr, "FATAL: missing EOL\n");
96         exit(1);
97     }
98
99     /* Look for # */
100
101     p = strchr(linebuf, '#');
102
103     if (p)
104         *p = '\0';
105
106     /* Look for = sign */
107     p = strchr(linebuf, '=');
108
109     /* If no '=' exit */
110     if (!p)
111         return 0;
112
113     *p++ = '\0';
114
115     *pkw = linebuf;
116     *pval = p;
117
118     /* Remove spaces from keyword and value */
119     remove_space(pkw);
120     remove_space(pval);
121
122     return 1;
123 }
124
125 /* For a hex string "value" convert to a binary allocated buffer */
126 static int test_bin(const char *value, unsigned char **buf, size_t *buflen)
127 {
128     long len;
129     if (!*value) {
130         /* Don't return NULL for zero length buffer */
131         *buf = OPENSSL_malloc(1);
132         if (!*buf)
133             return 0;
134         **buf = 0;
135         *buflen = 0;
136         return 1;
137     }
138     /* Check for string literal */
139     if (value[0] == '"') {
140         size_t vlen;
141         value++;
142         vlen = strlen(value);
143         if (value[vlen - 1] != '"')
144             return 0;
145         vlen--;
146         *buf = BUF_memdup(value, vlen);
147         *buflen = vlen;
148         return 1;
149     }
150     *buf = string_to_hex(value, &len);
151     if (!*buf) {
152         fprintf(stderr, "Value=%s\n", value);
153         ERR_print_errors_fp(stderr);
154         return -1;
155     }
156     /* Size of input buffer means we'll never overflow */
157     *buflen = len;
158     return 1;
159 }
160
161 /* Structure holding test information */
162 struct evp_test {
163     /* file being read */
164     FILE *in;
165     /* List of public and private keys */
166     struct key_list *private;
167     struct key_list *public;
168     /* method for this test */
169     const struct evp_test_method *meth;
170     /* current line being processed */
171     unsigned int line;
172     /* start line of current test */
173     unsigned int start_line;
174     /* Error string for test */
175     const char *err;
176     /* Expected error value of test */
177     char *expected_err;
178     /* Number of tests */
179     int ntests;
180     /* Error count */
181     int errors;
182     /* Number of tests skipped */
183     int nskip;
184     /* If output mismatch expected and got value */
185     unsigned char *out_got;
186     unsigned char *out_expected;
187     size_t out_len;
188     /* test specific data */
189     void *data;
190     /* Current test should be skipped */
191     int skip;
192 };
193
194 struct key_list {
195     char *name;
196     EVP_PKEY *key;
197     struct key_list *next;
198 };
199
200 /* Test method structure */
201 struct evp_test_method {
202     /* Name of test as it appears in file */
203     const char *name;
204     /* Initialise test for "alg" */
205     int (*init) (struct evp_test * t, const char *alg);
206     /* Clean up method */
207     void (*cleanup) (struct evp_test * t);
208     /* Test specific name value pair processing */
209     int (*parse) (struct evp_test * t, const char *name, const char *value);
210     /* Run the test itself */
211     int (*run_test) (struct evp_test * t);
212 };
213
214 static const struct evp_test_method digest_test_method, cipher_test_method;
215 static const struct evp_test_method mac_test_method;
216 static const struct evp_test_method psign_test_method, pverify_test_method;
217 static const struct evp_test_method pdecrypt_test_method;
218 static const struct evp_test_method pverify_recover_test_method;
219
220 static const struct evp_test_method *evp_test_list[] = {
221     &digest_test_method,
222     &cipher_test_method,
223     &mac_test_method,
224     &psign_test_method,
225     &pverify_test_method,
226     &pdecrypt_test_method,
227     &pverify_recover_test_method,
228     NULL
229 };
230
231 static const struct evp_test_method *evp_find_test(const char *name)
232 {
233     const struct evp_test_method **tt;
234     for (tt = evp_test_list; *tt; tt++) {
235         if (!strcmp(name, (*tt)->name))
236             return *tt;
237     }
238     return NULL;
239 }
240
241 static void hex_print(const char *name, const unsigned char *buf, size_t len)
242 {
243     size_t i;
244     fprintf(stderr, "%s ", name);
245     for (i = 0; i < len; i++)
246         fprintf(stderr, "%02X", buf[i]);
247     fputs("\n", stderr);
248 }
249
250 static void print_expected(struct evp_test *t)
251 {
252     if (t->out_expected == NULL)
253         return;
254     hex_print("Expected:", t->out_expected, t->out_len);
255     hex_print("Got:     ", t->out_got, t->out_len);
256     OPENSSL_free(t->out_expected);
257     OPENSSL_free(t->out_got);
258     t->out_expected = NULL;
259     t->out_got = NULL;
260 }
261
262 static int check_test_error(struct evp_test *t)
263 {
264     if (!t->err && !t->expected_err)
265         return 1;
266     if (t->err && !t->expected_err) {
267         fprintf(stderr, "Test line %d: unexpected error %s\n",
268                 t->start_line, t->err);
269         print_expected(t);
270         return 0;
271     }
272     if (!t->err && t->expected_err) {
273         fprintf(stderr, "Test line %d: succeeded expecting %s\n",
274                 t->start_line, t->expected_err);
275         return 0;
276     }
277     if (!strcmp(t->err, t->expected_err))
278         return 1;
279
280     fprintf(stderr, "Test line %d: expecting %s got %s\n",
281             t->start_line, t->expected_err, t->err);
282     return 0;
283 }
284
285 /* Setup a new test, run any existing test */
286
287 static int setup_test(struct evp_test *t, const struct evp_test_method *tmeth)
288 {
289     /* If we already have a test set up run it */
290     if (t->meth) {
291         t->ntests++;
292         if (t->skip) {
293             t->nskip++;
294             return 1;
295         }
296         t->err = NULL;
297         if (t->meth->run_test(t) != 1) {
298             fprintf(stderr, "%s test error line %d\n",
299                     t->meth->name, t->start_line);
300             return 0;
301         }
302         if (!check_test_error(t)) {
303             if (t->err)
304                 ERR_print_errors_fp(stderr);
305             t->errors++;
306         }
307         ERR_clear_error();
308         t->meth->cleanup(t);
309         OPENSSL_free(t->data);
310         t->data = NULL;
311         if (t->expected_err) {
312             OPENSSL_free(t->expected_err);
313             t->expected_err = NULL;
314         }
315     }
316     t->meth = tmeth;
317     return 1;
318 }
319
320 static int find_key(EVP_PKEY **ppk, const char *name, struct key_list *lst)
321 {
322     for (; lst; lst = lst->next) {
323         if (!strcmp(lst->name, name)) {
324             if (ppk)
325                 *ppk = lst->key;
326             return 1;
327         }
328     }
329     return 0;
330 }
331
332 static void free_key_list(struct key_list *lst)
333 {
334     while (lst != NULL) {
335         struct key_list *ltmp;
336         EVP_PKEY_free(lst->key);
337         OPENSSL_free(lst->name);
338         ltmp = lst->next;
339         OPENSSL_free(lst);
340         lst = ltmp;
341     }
342 }
343
344 static int check_unsupported()
345 {
346     long err = ERR_peek_error();
347     if (ERR_GET_LIB(err) == ERR_LIB_EVP
348          && ERR_GET_REASON(err) == EVP_R_UNSUPPORTED_ALGORITHM) {
349         ERR_clear_error();
350         return 1;
351     }
352     return 0;
353 }
354
355 static int process_test(struct evp_test *t, char *buf, int verbose)
356 {
357     char *keyword, *value;
358     int rv = 0, add_key = 0;
359     long save_pos;
360     struct key_list **lst, *key;
361     EVP_PKEY *pk = NULL;
362     const struct evp_test_method *tmeth;
363     if (verbose)
364         fputs(buf, stdout);
365     if (!parse_line(&keyword, &value, buf))
366         return 1;
367     if (!strcmp(keyword, "PrivateKey")) {
368         save_pos = ftell(t->in);
369         pk = PEM_read_PrivateKey(t->in, NULL, 0, NULL);
370         if (pk == NULL && !check_unsupported()) {
371             fprintf(stderr, "Error reading private key %s\n", value);
372             ERR_print_errors_fp(stderr);
373             return 0;
374         }
375         lst = &t->private;
376         add_key = 1;
377     }
378     if (!strcmp(keyword, "PublicKey")) {
379         save_pos = ftell(t->in);
380         pk = PEM_read_PUBKEY(t->in, NULL, 0, NULL);
381         if (pk == NULL && !check_unsupported()) {
382             fprintf(stderr, "Error reading public key %s\n", value);
383             ERR_print_errors_fp(stderr);
384             return 0;
385         }
386         lst = &t->public;
387         add_key = 1;
388     }
389     /* If we have a key add to list */
390     if (add_key) {
391         char tmpbuf[80];
392         if (find_key(NULL, value, *lst)) {
393             fprintf(stderr, "Duplicate key %s\n", value);
394             return 0;
395         }
396         key = OPENSSL_malloc(sizeof(struct key_list));
397         if (!key)
398             return 0;
399         key->name = BUF_strdup(value);
400         key->key = pk;
401         key->next = *lst;
402         *lst = key;
403         /* Rewind input, read to end and update line numbers */
404         fseek(t->in, save_pos, SEEK_SET);
405         while (fgets(tmpbuf, sizeof(tmpbuf), t->in)) {
406             t->line++;
407             if (!strncmp(tmpbuf, "-----END", 8))
408                 return 1;
409         }
410         fprintf(stderr, "Can't find key end\n");
411         return 0;
412     }
413
414     /* See if keyword corresponds to a test start */
415     tmeth = evp_find_test(keyword);
416     if (tmeth) {
417         if (!setup_test(t, tmeth))
418             return 0;
419         t->start_line = t->line;
420         t->skip = 0;
421         if (!tmeth->init(t, value)) {
422             fprintf(stderr, "Unknown %s: %s\n", keyword, value);
423             return 0;
424         }
425         return 1;
426     } else if (t->skip) {
427         return 1;
428     } else if (!strcmp(keyword, "Result")) {
429         if (t->expected_err) {
430             fprintf(stderr, "Line %d: multiple result lines\n", t->line);
431             return 0;
432         }
433         t->expected_err = BUF_strdup(value);
434         if (!t->expected_err)
435             return 0;
436     } else {
437         /* Must be test specific line: try to parse it */
438         if (t->meth)
439             rv = t->meth->parse(t, keyword, value);
440
441         if (rv == 0)
442             fprintf(stderr, "line %d: unexpected keyword %s\n",
443                     t->line, keyword);
444
445         if (rv < 0)
446             fprintf(stderr, "line %d: error processing keyword %s\n",
447                     t->line, keyword);
448         if (rv <= 0)
449             return 0;
450     }
451     return 1;
452 }
453
454 static int check_output(struct evp_test *t, const unsigned char *expected,
455                         const unsigned char *got, size_t len)
456 {
457     if (!memcmp(expected, got, len))
458         return 0;
459     t->out_expected = BUF_memdup(expected, len);
460     t->out_got = BUF_memdup(got, len);
461     t->out_len = len;
462     if (t->out_expected == NULL || t->out_got == NULL) {
463         fprintf(stderr, "Memory allocation error!\n");
464         exit(1);
465     }
466     return 1;
467 }
468
469 int main(int argc, char **argv)
470 {
471     FILE *in = NULL;
472     char buf[10240];
473     struct evp_test t;
474
475     if (argc != 2) {
476         fprintf(stderr, "usage: evp_test testfile.txt\n");
477         return 1;
478     }
479
480     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
481
482     ERR_load_crypto_strings();
483     OpenSSL_add_all_algorithms();
484
485     memset(&t,0,sizeof(t));
486     t.meth = NULL;
487     t.public = NULL;
488     t.private = NULL;
489     t.err = NULL;
490     t.line = 0;
491     t.start_line = -1;
492     t.errors = 0;
493     t.ntests = 0;
494     t.out_expected = NULL;
495     t.out_got = NULL;
496     t.out_len = 0;
497     in = fopen(argv[1], "r");
498     t.in = in;
499     while (fgets(buf, sizeof(buf), in)) {
500         t.line++;
501         if (!process_test(&t, buf, 0))
502             exit(1);
503     }
504     /* Run any final test we have */
505     if (!setup_test(&t, NULL))
506         exit(1);
507     fprintf(stderr, "%d tests completed with %d errors, %d skipped\n",
508             t.ntests, t.errors, t.nskip);
509     free_key_list(t.public);
510     free_key_list(t.private);
511     fclose(in);
512     EVP_cleanup();
513     CRYPTO_cleanup_all_ex_data();
514     ERR_remove_thread_state(NULL);
515     ERR_free_strings();
516     CRYPTO_mem_leaks_fp(stderr);
517     if (t.errors)
518         return 1;
519     return 0;
520 }
521
522 static void test_free(void *d)
523 {
524     if (d)
525         OPENSSL_free(d);
526 }
527
528 /* Message digest tests */
529
530 struct digest_data {
531     /* Digest this test is for */
532     const EVP_MD *digest;
533     /* Input to digest */
534     unsigned char *input;
535     size_t input_len;
536     /* Expected output */
537     unsigned char *output;
538     size_t output_len;
539 };
540
541 static int digest_test_init(struct evp_test *t, const char *alg)
542 {
543     const EVP_MD *digest;
544     struct digest_data *mdat = t->data;
545     digest = EVP_get_digestbyname(alg);
546     if (!digest)
547         return 0;
548     mdat = OPENSSL_malloc(sizeof(struct digest_data));
549     mdat->digest = digest;
550     mdat->input = NULL;
551     mdat->output = NULL;
552     t->data = mdat;
553     return 1;
554 }
555
556 static void digest_test_cleanup(struct evp_test *t)
557 {
558     struct digest_data *mdat = t->data;
559     test_free(mdat->input);
560     test_free(mdat->output);
561 }
562
563 static int digest_test_parse(struct evp_test *t,
564                              const char *keyword, const char *value)
565 {
566     struct digest_data *mdata = t->data;
567     if (!strcmp(keyword, "Input"))
568         return test_bin(value, &mdata->input, &mdata->input_len);
569     if (!strcmp(keyword, "Output"))
570         return test_bin(value, &mdata->output, &mdata->output_len);
571     return 0;
572 }
573
574 static int digest_test_run(struct evp_test *t)
575 {
576     struct digest_data *mdata = t->data;
577     const char *err = "INTERNAL_ERROR";
578     EVP_MD_CTX *mctx;
579     unsigned char md[EVP_MAX_MD_SIZE];
580     unsigned int md_len;
581     mctx = EVP_MD_CTX_create();
582     if (!mctx)
583         goto err;
584     err = "DIGESTINIT_ERROR";
585     if (!EVP_DigestInit_ex(mctx, mdata->digest, NULL))
586         goto err;
587     err = "DIGESTUPDATE_ERROR";
588     if (!EVP_DigestUpdate(mctx, mdata->input, mdata->input_len))
589         goto err;
590     err = "DIGESTFINAL_ERROR";
591     if (!EVP_DigestFinal(mctx, md, &md_len))
592         goto err;
593     err = "DIGEST_LENGTH_MISMATCH";
594     if (md_len != mdata->output_len)
595         goto err;
596     err = "DIGEST_MISMATCH";
597     if (check_output(t, mdata->output, md, md_len))
598         goto err;
599     err = NULL;
600  err:
601     if (mctx)
602         EVP_MD_CTX_destroy(mctx);
603     t->err = err;
604     return 1;
605 }
606
607 static const struct evp_test_method digest_test_method = {
608     "Digest",
609     digest_test_init,
610     digest_test_cleanup,
611     digest_test_parse,
612     digest_test_run
613 };
614
615 /* Cipher tests */
616 struct cipher_data {
617     const EVP_CIPHER *cipher;
618     int enc;
619     /* Set to EVP_CIPH_GCM_MODE or EVP_CIPH_CCM_MODE if AEAD */
620     int aead;
621     unsigned char *key;
622     size_t key_len;
623     unsigned char *iv;
624     size_t iv_len;
625     unsigned char *plaintext;
626     size_t plaintext_len;
627     unsigned char *ciphertext;
628     size_t ciphertext_len;
629     /* GCM, CCM only */
630     unsigned char *aad;
631     size_t aad_len;
632     unsigned char *tag;
633     size_t tag_len;
634 };
635
636 static int cipher_test_init(struct evp_test *t, const char *alg)
637 {
638     const EVP_CIPHER *cipher;
639     struct cipher_data *cdat = t->data;
640     cipher = EVP_get_cipherbyname(alg);
641     if (!cipher)
642         return 0;
643     cdat = OPENSSL_malloc(sizeof(struct cipher_data));
644     cdat->cipher = cipher;
645     cdat->enc = -1;
646     cdat->key = NULL;
647     cdat->iv = NULL;
648     cdat->ciphertext = NULL;
649     cdat->plaintext = NULL;
650     cdat->aad = NULL;
651     cdat->tag = NULL;
652     t->data = cdat;
653     if (EVP_CIPHER_mode(cipher) == EVP_CIPH_GCM_MODE
654         || EVP_CIPHER_mode(cipher) == EVP_CIPH_CCM_MODE)
655         cdat->aead = EVP_CIPHER_mode(cipher);
656     else
657         cdat->aead = 0;
658
659     return 1;
660 }
661
662 static void cipher_test_cleanup(struct evp_test *t)
663 {
664     struct cipher_data *cdat = t->data;
665     test_free(cdat->key);
666     test_free(cdat->iv);
667     test_free(cdat->ciphertext);
668     test_free(cdat->plaintext);
669     test_free(cdat->aad);
670     test_free(cdat->tag);
671 }
672
673 static int cipher_test_parse(struct evp_test *t, const char *keyword,
674                              const char *value)
675 {
676     struct cipher_data *cdat = t->data;
677     if (!strcmp(keyword, "Key"))
678         return test_bin(value, &cdat->key, &cdat->key_len);
679     if (!strcmp(keyword, "IV"))
680         return test_bin(value, &cdat->iv, &cdat->iv_len);
681     if (!strcmp(keyword, "Plaintext"))
682         return test_bin(value, &cdat->plaintext, &cdat->plaintext_len);
683     if (!strcmp(keyword, "Ciphertext"))
684         return test_bin(value, &cdat->ciphertext, &cdat->ciphertext_len);
685     if (cdat->aead) {
686         if (!strcmp(keyword, "AAD"))
687             return test_bin(value, &cdat->aad, &cdat->aad_len);
688         if (!strcmp(keyword, "Tag"))
689             return test_bin(value, &cdat->tag, &cdat->tag_len);
690     }
691
692     if (!strcmp(keyword, "Operation")) {
693         if (!strcmp(value, "ENCRYPT"))
694             cdat->enc = 1;
695         else if (!strcmp(value, "DECRYPT"))
696             cdat->enc = 0;
697         else
698             return 0;
699         return 1;
700     }
701     return 0;
702 }
703
704 static int cipher_test_enc(struct evp_test *t, int enc)
705 {
706     struct cipher_data *cdat = t->data;
707     unsigned char *in, *out, *tmp = NULL;
708     size_t in_len, out_len;
709     int tmplen, tmpflen;
710     EVP_CIPHER_CTX *ctx = NULL;
711     const char *err;
712     err = "INTERNAL_ERROR";
713     ctx = EVP_CIPHER_CTX_new();
714     if (!ctx)
715         goto err;
716     EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
717     if (enc) {
718         in = cdat->plaintext;
719         in_len = cdat->plaintext_len;
720         out = cdat->ciphertext;
721         out_len = cdat->ciphertext_len;
722     } else {
723         in = cdat->ciphertext;
724         in_len = cdat->ciphertext_len;
725         out = cdat->plaintext;
726         out_len = cdat->plaintext_len;
727     }
728     tmp = OPENSSL_malloc(in_len + 2 * EVP_MAX_BLOCK_LENGTH);
729     if (!tmp)
730         goto err;
731     err = "CIPHERINIT_ERROR";
732     if (!EVP_CipherInit_ex(ctx, cdat->cipher, NULL, NULL, NULL, enc))
733         goto err;
734     err = "INVALID_IV_LENGTH";
735     if (cdat->iv) {
736         if (cdat->aead == EVP_CIPH_GCM_MODE) {
737             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN,
738                                      cdat->iv_len, 0))
739                 goto err;
740         } else if (cdat->aead == EVP_CIPH_CCM_MODE) {
741             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_IVLEN,
742                                      cdat->iv_len, 0))
743                 goto err;
744         } else if (cdat->iv_len != (size_t)EVP_CIPHER_CTX_iv_length(ctx))
745             goto err;
746     }
747     if (cdat->aead) {
748         unsigned char *tag;
749         /*
750          * If encrypting just set tag length. If decrypting set
751          * tag length and value.
752          */
753         if (enc) {
754             err = "TAG_LENGTH_SET_ERROR";
755             tag = NULL;
756         } else {
757             err = "TAG_SET_ERROR";
758             tag = cdat->tag;
759         }
760         if (cdat->aead == EVP_CIPH_GCM_MODE && tag) {
761             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG,
762                                      cdat->tag_len, tag))
763                 goto err;
764         } else if (cdat->aead == EVP_CIPH_CCM_MODE) {
765             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_TAG,
766                                      cdat->tag_len, tag))
767                 goto err;
768         }
769     }
770
771     err = "INVALID_KEY_LENGTH";
772     if (!EVP_CIPHER_CTX_set_key_length(ctx, cdat->key_len))
773         goto err;
774     err = "KEY_SET_ERROR";
775     if (!EVP_CipherInit_ex(ctx, NULL, NULL, cdat->key, cdat->iv, -1))
776         goto err;
777
778     if (cdat->aead == EVP_CIPH_CCM_MODE) {
779         if (!EVP_CipherUpdate(ctx, NULL, &tmplen, NULL, out_len)) {
780             err = "CCM_PLAINTEXT_LENGTH_SET_ERROR";
781             goto err;
782         }
783     }
784     if (cdat->aad) {
785         if (!EVP_CipherUpdate(ctx, NULL, &tmplen, cdat->aad, cdat->aad_len)) {
786             err = "AAD_SET_ERROR";
787             goto err;
788         }
789     }
790     EVP_CIPHER_CTX_set_padding(ctx, 0);
791     err = "CIPHERUPDATE_ERROR";
792     if (!EVP_CipherUpdate(ctx, tmp, &tmplen, in, in_len))
793         goto err;
794     if (cdat->aead == EVP_CIPH_CCM_MODE)
795         tmpflen = 0;
796     else {
797         err = "CIPHERFINAL_ERROR";
798         if (!EVP_CipherFinal_ex(ctx, tmp + tmplen, &tmpflen))
799             goto err;
800     }
801     err = "LENGTH_MISMATCH";
802     if (out_len != (size_t)(tmplen + tmpflen))
803         goto err;
804     err = "VALUE_MISMATCH";
805     if (check_output(t, out, tmp, out_len))
806         goto err;
807     if (enc && cdat->aead) {
808         unsigned char rtag[16];
809         if (cdat->tag_len > sizeof(rtag)) {
810             err = "TAG_LENGTH_INTERNAL_ERROR";
811             goto err;
812         }
813         /* EVP_CTRL_CCM_GET_TAG and EVP_CTRL_GCM_GET_TAG are equal. */
814         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG,
815                                  cdat->tag_len, rtag)) {
816             err = "TAG_RETRIEVE_ERROR";
817             goto err;
818         }
819         if (check_output(t, cdat->tag, rtag, cdat->tag_len)) {
820             err = "TAG_VALUE_MISMATCH";
821             goto err;
822         }
823     }
824     err = NULL;
825  err:
826     if (tmp)
827         OPENSSL_free(tmp);
828     EVP_CIPHER_CTX_free(ctx);
829     t->err = err;
830     return err ? 0 : 1;
831 }
832
833 static int cipher_test_run(struct evp_test *t)
834 {
835     struct cipher_data *cdat = t->data;
836     int rv;
837     if (!cdat->key) {
838         t->err = "NO_KEY";
839         return 0;
840     }
841     if (!cdat->iv && EVP_CIPHER_iv_length(cdat->cipher)) {
842         /* IV is optional and usually omitted in wrap mode */
843         if (EVP_CIPHER_mode(cdat->cipher) != EVP_CIPH_WRAP_MODE) {
844             t->err = "NO_IV";
845             return 0;
846         }
847     }
848     if (cdat->aead && !cdat->tag) {
849         t->err = "NO_TAG";
850         return 0;
851     }
852     if (cdat->enc) {
853         rv = cipher_test_enc(t, 1);
854         /* Not fatal errors: return */
855         if (rv != 1) {
856             if (rv < 0)
857                 return 0;
858             return 1;
859         }
860     }
861     if (cdat->enc != 1) {
862         rv = cipher_test_enc(t, 0);
863         /* Not fatal errors: return */
864         if (rv != 1) {
865             if (rv < 0)
866                 return 0;
867             return 1;
868         }
869     }
870     return 1;
871 }
872
873 static const struct evp_test_method cipher_test_method = {
874     "Cipher",
875     cipher_test_init,
876     cipher_test_cleanup,
877     cipher_test_parse,
878     cipher_test_run
879 };
880
881 struct mac_data {
882     /* MAC type */
883     int type;
884     /* Algorithm string for this MAC */
885     char *alg;
886     /* MAC key */
887     unsigned char *key;
888     size_t key_len;
889     /* Input to MAC */
890     unsigned char *input;
891     size_t input_len;
892     /* Expected output */
893     unsigned char *output;
894     size_t output_len;
895 };
896
897 static int mac_test_init(struct evp_test *t, const char *alg)
898 {
899     int type;
900     struct mac_data *mdat;
901     if (!strcmp(alg, "HMAC"))
902         type = EVP_PKEY_HMAC;
903     else if (!strcmp(alg, "CMAC"))
904         type = EVP_PKEY_CMAC;
905     else
906         return 0;
907
908     mdat = OPENSSL_malloc(sizeof(struct mac_data));
909     mdat->type = type;
910     mdat->alg = NULL;
911     mdat->key = NULL;
912     mdat->input = NULL;
913     mdat->output = NULL;
914     t->data = mdat;
915     return 1;
916 }
917
918 static void mac_test_cleanup(struct evp_test *t)
919 {
920     struct mac_data *mdat = t->data;
921     test_free(mdat->alg);
922     test_free(mdat->key);
923     test_free(mdat->input);
924     test_free(mdat->output);
925 }
926
927 static int mac_test_parse(struct evp_test *t,
928                           const char *keyword, const char *value)
929 {
930     struct mac_data *mdata = t->data;
931     if (!strcmp(keyword, "Key"))
932         return test_bin(value, &mdata->key, &mdata->key_len);
933     if (!strcmp(keyword, "Algorithm")) {
934         mdata->alg = BUF_strdup(value);
935         if (!mdata->alg)
936             return 0;
937         return 1;
938     }
939     if (!strcmp(keyword, "Input"))
940         return test_bin(value, &mdata->input, &mdata->input_len);
941     if (!strcmp(keyword, "Output"))
942         return test_bin(value, &mdata->output, &mdata->output_len);
943     return 0;
944 }
945
946 static int mac_test_run(struct evp_test *t)
947 {
948     struct mac_data *mdata = t->data;
949     const char *err = "INTERNAL_ERROR";
950     EVP_MD_CTX *mctx = NULL;
951     EVP_PKEY_CTX *pctx = NULL, *genctx = NULL;
952     EVP_PKEY *key = NULL;
953     const EVP_MD *md = NULL;
954     unsigned char *mac = NULL;
955     size_t mac_len;
956
957     err = "MAC_PKEY_CTX_ERROR";
958     genctx = EVP_PKEY_CTX_new_id(mdata->type, NULL);
959     if (!genctx)
960         goto err;
961
962     err = "MAC_KEYGEN_INIT_ERROR";
963     if (EVP_PKEY_keygen_init(genctx) <= 0)
964         goto err;
965     if (mdata->type == EVP_PKEY_CMAC) {
966         err = "MAC_ALGORITHM_SET_ERROR";
967         if (EVP_PKEY_CTX_ctrl_str(genctx, "cipher", mdata->alg) <= 0)
968             goto err;
969     }
970
971     err = "MAC_KEY_SET_ERROR";
972     if (EVP_PKEY_CTX_set_mac_key(genctx, mdata->key, mdata->key_len) <= 0)
973         goto err;
974
975     err = "MAC_KEY_GENERATE_ERROR";
976     if (EVP_PKEY_keygen(genctx, &key) <= 0)
977         goto err;
978     if (mdata->type == EVP_PKEY_HMAC) {
979         err = "MAC_ALGORITHM_SET_ERROR";
980         md = EVP_get_digestbyname(mdata->alg);
981         if (!md)
982             goto err;
983     }
984     mctx = EVP_MD_CTX_create();
985     if (!mctx)
986         goto err;
987     err = "DIGESTSIGNINIT_ERROR";
988     if (!EVP_DigestSignInit(mctx, &pctx, md, NULL, key))
989         goto err;
990
991     err = "DIGESTSIGNUPDATE_ERROR";
992     if (!EVP_DigestSignUpdate(mctx, mdata->input, mdata->input_len))
993         goto err;
994     err = "DIGESTSIGNFINAL_LENGTH_ERROR";
995     if (!EVP_DigestSignFinal(mctx, NULL, &mac_len))
996         goto err;
997     mac = OPENSSL_malloc(mac_len);
998     if (!mac) {
999         fprintf(stderr, "Error allocating mac buffer!\n");
1000         exit(1);
1001     }
1002     if (!EVP_DigestSignFinal(mctx, mac, &mac_len))
1003         goto err;
1004     err = "MAC_LENGTH_MISMATCH";
1005     if (mac_len != mdata->output_len)
1006         goto err;
1007     err = "MAC_MISMATCH";
1008     if (check_output(t, mdata->output, mac, mac_len))
1009         goto err;
1010     err = NULL;
1011  err:
1012     if (mctx)
1013         EVP_MD_CTX_destroy(mctx);
1014     if (mac)
1015         OPENSSL_free(mac);
1016     if (genctx)
1017         EVP_PKEY_CTX_free(genctx);
1018     if (key)
1019         EVP_PKEY_free(key);
1020     t->err = err;
1021     return 1;
1022 }
1023
1024 static const struct evp_test_method mac_test_method = {
1025     "MAC",
1026     mac_test_init,
1027     mac_test_cleanup,
1028     mac_test_parse,
1029     mac_test_run
1030 };
1031
1032 /*
1033  * Public key operations. These are all very similar and can share
1034  * a lot of common code.
1035  */
1036
1037 struct pkey_data {
1038     /* Context for this operation */
1039     EVP_PKEY_CTX *ctx;
1040     /* Key operation to perform */
1041     int (*keyop) (EVP_PKEY_CTX *ctx,
1042                   unsigned char *sig, size_t *siglen,
1043                   const unsigned char *tbs, size_t tbslen);
1044     /* Input to MAC */
1045     unsigned char *input;
1046     size_t input_len;
1047     /* Expected output */
1048     unsigned char *output;
1049     size_t output_len;
1050 };
1051
1052 /*
1053  * Perform public key operation setup: lookup key, allocated ctx and call
1054  * the appropriate initialisation function
1055  */
1056 static int pkey_test_init(struct evp_test *t, const char *name,
1057                           int use_public,
1058                           int (*keyopinit) (EVP_PKEY_CTX *ctx),
1059                           int (*keyop) (EVP_PKEY_CTX *ctx,
1060                                         unsigned char *sig, size_t *siglen,
1061                                         const unsigned char *tbs,
1062                                         size_t tbslen)
1063     )
1064 {
1065     struct pkey_data *kdata;
1066     EVP_PKEY *pkey = NULL;
1067     int rv = 0;
1068     if (use_public)
1069         rv = find_key(&pkey, name, t->public);
1070     if (!rv)
1071         rv = find_key(&pkey, name, t->private);
1072     if (!rv)
1073         return 0;
1074     if (!pkey) {
1075         t->skip = 1;
1076         return 1;
1077     }
1078
1079     kdata = OPENSSL_malloc(sizeof(struct pkey_data));
1080     if (!kdata) {
1081         EVP_PKEY_free(pkey);
1082         return 0;
1083     }
1084     kdata->ctx = NULL;
1085     kdata->input = NULL;
1086     kdata->output = NULL;
1087     kdata->keyop = keyop;
1088     t->data = kdata;
1089     kdata->ctx = EVP_PKEY_CTX_new(pkey, NULL);
1090     if (!kdata->ctx)
1091         return 0;
1092     if (keyopinit(kdata->ctx) <= 0)
1093         return 0;
1094     return 1;
1095 }
1096
1097 static void pkey_test_cleanup(struct evp_test *t)
1098 {
1099     struct pkey_data *kdata = t->data;
1100     if (kdata->input)
1101         OPENSSL_free(kdata->input);
1102     if (kdata->output)
1103         OPENSSL_free(kdata->output);
1104     if (kdata->ctx)
1105         EVP_PKEY_CTX_free(kdata->ctx);
1106 }
1107
1108 static int pkey_test_parse(struct evp_test *t,
1109                            const char *keyword, const char *value)
1110 {
1111     struct pkey_data *kdata = t->data;
1112     if (!strcmp(keyword, "Input"))
1113         return test_bin(value, &kdata->input, &kdata->input_len);
1114     if (!strcmp(keyword, "Output"))
1115         return test_bin(value, &kdata->output, &kdata->output_len);
1116     if (!strcmp(keyword, "Ctrl")) {
1117         char *p = strchr(value, ':');
1118         if (p)
1119             *p++ = 0;
1120         if (EVP_PKEY_CTX_ctrl_str(kdata->ctx, value, p) <= 0)
1121             return 0;
1122         return 1;
1123     }
1124     return 0;
1125 }
1126
1127 static int pkey_test_run(struct evp_test *t)
1128 {
1129     struct pkey_data *kdata = t->data;
1130     unsigned char *out = NULL;
1131     size_t out_len;
1132     const char *err = "KEYOP_LENGTH_ERROR";
1133     if (kdata->keyop(kdata->ctx, NULL, &out_len, kdata->input,
1134                      kdata->input_len) <= 0)
1135         goto err;
1136     out = OPENSSL_malloc(out_len);
1137     if (!out) {
1138         fprintf(stderr, "Error allocating output buffer!\n");
1139         exit(1);
1140     }
1141     err = "KEYOP_ERROR";
1142     if (kdata->keyop
1143         (kdata->ctx, out, &out_len, kdata->input, kdata->input_len) <= 0)
1144         goto err;
1145     err = "KEYOP_LENGTH_MISMATCH";
1146     if (out_len != kdata->output_len)
1147         goto err;
1148     err = "KEYOP_MISMATCH";
1149     if (check_output(t, kdata->output, out, out_len))
1150         goto err;
1151     err = NULL;
1152  err:
1153     if (out)
1154         OPENSSL_free(out);
1155     t->err = err;
1156     return 1;
1157 }
1158
1159 static int sign_test_init(struct evp_test *t, const char *name)
1160 {
1161     return pkey_test_init(t, name, 0, EVP_PKEY_sign_init, EVP_PKEY_sign);
1162 }
1163
1164 static const struct evp_test_method psign_test_method = {
1165     "Sign",
1166     sign_test_init,
1167     pkey_test_cleanup,
1168     pkey_test_parse,
1169     pkey_test_run
1170 };
1171
1172 static int verify_recover_test_init(struct evp_test *t, const char *name)
1173 {
1174     return pkey_test_init(t, name, 1, EVP_PKEY_verify_recover_init,
1175                           EVP_PKEY_verify_recover);
1176 }
1177
1178 static const struct evp_test_method pverify_recover_test_method = {
1179     "VerifyRecover",
1180     verify_recover_test_init,
1181     pkey_test_cleanup,
1182     pkey_test_parse,
1183     pkey_test_run
1184 };
1185
1186 static int decrypt_test_init(struct evp_test *t, const char *name)
1187 {
1188     return pkey_test_init(t, name, 0, EVP_PKEY_decrypt_init,
1189                           EVP_PKEY_decrypt);
1190 }
1191
1192 static const struct evp_test_method pdecrypt_test_method = {
1193     "Decrypt",
1194     decrypt_test_init,
1195     pkey_test_cleanup,
1196     pkey_test_parse,
1197     pkey_test_run
1198 };
1199
1200 static int verify_test_init(struct evp_test *t, const char *name)
1201 {
1202     return pkey_test_init(t, name, 1, EVP_PKEY_verify_init, 0);
1203 }
1204
1205 static int verify_test_run(struct evp_test *t)
1206 {
1207     struct pkey_data *kdata = t->data;
1208     if (EVP_PKEY_verify(kdata->ctx, kdata->output, kdata->output_len,
1209                         kdata->input, kdata->input_len) <= 0)
1210         t->err = "VERIFY_ERROR";
1211     return 1;
1212 }
1213
1214 static const struct evp_test_method pverify_test_method = {
1215     "Verify",
1216     verify_test_init,
1217     pkey_test_cleanup,
1218     pkey_test_parse,
1219     verify_test_run
1220 };