test/evp_test.c: improve output in case of errors.
[openssl.git] / test / evp_test.c
1 /*
2  * Copyright 2015-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (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/x509v3.h>
18 #include <openssl/pkcs12.h>
19 #include <openssl/kdf.h>
20 #include "internal/numbers.h"
21 #include "testutil.h"
22 #include "evp_test.h"
23
24
25 typedef struct evp_test_method_st EVP_TEST_METHOD;
26
27 /*
28  * Structure holding test information
29  */
30 typedef struct evp_test_st {
31     BIO *in;                      /* file being read */
32     int line;                     /* current line being processed */
33     int start_line;               /* start line of current test */
34     int ntests;                   /* Number of tests */
35     int errors;                   /* Error count */
36     int skip;                     /* Current test should be skipped */
37     int nskip;                    /* Number of tests skipped */
38     char buf[10240];              /* Input buffer */
39     BIO *key;                     /* temp memory BIO for reading in keys */
40     const EVP_TEST_METHOD *meth;  /* method for this test */
41     const char *err, *aux_err;    /* Error string for test */
42     char *expected_err;           /* Expected error value of test */
43     char *func;                   /* Expected error function string */
44     char *reason;                 /* Expected error reason string */
45     void *data;                   /* test specific data */
46 } EVP_TEST;
47
48 /*
49  * Test method structure
50  */
51 struct evp_test_method_st {
52     /* Name of test as it appears in file */
53     const char *name;
54     /* Initialise test for "alg" */
55     int (*init) (EVP_TEST * t, const char *alg);
56     /* Clean up method */
57     void (*cleanup) (EVP_TEST * t);
58     /* Test specific name value pair processing */
59     int (*parse) (EVP_TEST * t, const char *name, const char *value);
60     /* Run the test itself */
61     int (*run_test) (EVP_TEST * t);
62 };
63
64
65 /*
66  * Linked list of named keys.
67  */
68 typedef struct key_list_st {
69     char *name;
70     EVP_PKEY *key;
71     struct key_list_st *next;
72 } KEY_LIST;
73
74 /*
75  * List of public and private keys
76  */
77 static KEY_LIST *private_keys;
78 static KEY_LIST *public_keys;
79 static int find_key(EVP_PKEY **ppk, const char *name, KEY_LIST *lst);
80
81 static int parse_bin(const char *value, unsigned char **buf, size_t *buflen);
82
83 static const char *current_test_file = "???";
84
85 /*
86  * Structure used to hold a list of blocks of memory to test
87  * calls to "update" like functions.
88  */
89 struct evp_test_buffer_st {
90     unsigned char *buf;
91     size_t buflen;
92     size_t count;
93     int count_set;
94 };
95
96 static void evp_test_buffer_free(EVP_TEST_BUFFER *db)
97 {
98     if (db != NULL) {
99         OPENSSL_free(db->buf);
100         OPENSSL_free(db);
101     }
102 }
103
104 /*
105  * append buffer to a list
106  */
107 static int evp_test_buffer_append(const char *value,
108                                   STACK_OF(EVP_TEST_BUFFER) **sk)
109 {
110     EVP_TEST_BUFFER *db = NULL;
111
112     if (!TEST_ptr(db = OPENSSL_malloc(sizeof(*db))))
113         goto err;
114
115     if (!parse_bin(value, &db->buf, &db->buflen))
116         goto err;
117     db->count = 1;
118     db->count_set = 0;
119
120     if (*sk == NULL && !TEST_ptr(*sk = sk_EVP_TEST_BUFFER_new_null()))
121         goto err;
122     if (!sk_EVP_TEST_BUFFER_push(*sk, db))
123         goto err;
124
125     return 1;
126
127 err:
128     evp_test_buffer_free(db);
129     return 0;
130 }
131
132 /*
133  * replace last buffer in list with copies of itself
134  */
135 static int evp_test_buffer_ncopy(const char *value,
136                                  STACK_OF(EVP_TEST_BUFFER) *sk)
137 {
138     EVP_TEST_BUFFER *db;
139     unsigned char *tbuf, *p;
140     size_t tbuflen;
141     int ncopy = atoi(value);
142     int i;
143
144     if (ncopy <= 0)
145         return 0;
146     if (sk == NULL || sk_EVP_TEST_BUFFER_num(sk) == 0)
147         return 0;
148     db = sk_EVP_TEST_BUFFER_value(sk, sk_EVP_TEST_BUFFER_num(sk) - 1);
149
150     tbuflen = db->buflen * ncopy;
151     if (!TEST_ptr(tbuf = OPENSSL_malloc(tbuflen)))
152         return 0;
153     for (i = 0, p = tbuf; i < ncopy; i++, p += db->buflen)
154         memcpy(p, db->buf, db->buflen);
155
156     OPENSSL_free(db->buf);
157     db->buf = tbuf;
158     db->buflen = tbuflen;
159     return 1;
160 }
161
162 /*
163  * set repeat count for last buffer in list
164  */
165 static int evp_test_buffer_set_count(const char *value,
166                                      STACK_OF(EVP_TEST_BUFFER) *sk)
167 {
168     EVP_TEST_BUFFER *db;
169     int count = atoi(value);
170
171     if (count <= 0)
172         return 0;
173
174     if (sk == NULL || sk_EVP_TEST_BUFFER_num(sk) == 0)
175         return 0;
176
177     db = sk_EVP_TEST_BUFFER_value(sk, sk_EVP_TEST_BUFFER_num(sk) - 1);
178     if (db->count_set != 0)
179         return 0;
180
181     db->count = (size_t)count;
182     db->count_set = 1;
183     return 1;
184 }
185
186 /*
187  * call "fn" with each element of the list in turn
188  */
189 static int evp_test_buffer_do(STACK_OF(EVP_TEST_BUFFER) *sk,
190                               int (*fn)(void *ctx,
191                                         const unsigned char *buf,
192                                         size_t buflen),
193                               void *ctx)
194 {
195     int i;
196
197     for (i = 0; i < sk_EVP_TEST_BUFFER_num(sk); i++) {
198         EVP_TEST_BUFFER *tb = sk_EVP_TEST_BUFFER_value(sk, i);
199         size_t j;
200
201         for (j = 0; j < tb->count; j++) {
202             if (fn(ctx, tb->buf, tb->buflen) <= 0)
203                 return 0;
204         }
205     }
206     return 1;
207 }
208
209 /*
210  * Unescape some sequences in string literals (only \n for now).
211  * Return an allocated buffer, set |out_len|.  If |input_len|
212  * is zero, get an empty buffer but set length to zero.
213  */
214 static unsigned char* unescape(const char *input, size_t input_len,
215                                size_t *out_len)
216 {
217     unsigned char *ret, *p;
218     size_t i;
219
220     if (input_len == 0) {
221         *out_len = 0;
222         return OPENSSL_zalloc(1);
223     }
224
225     /* Escaping is non-expanding; over-allocate original size for simplicity. */
226     if (!TEST_ptr(ret = p = OPENSSL_malloc(input_len)))
227         return NULL;
228
229     for (i = 0; i < input_len; i++) {
230         if (*input == '\\') {
231             if (i == input_len - 1 || *++input != 'n') {
232                 TEST_error("Bad escape sequence in file");
233                 goto err;
234             }
235             *p++ = '\n';
236             i++;
237             input++;
238         } else {
239             *p++ = *input++;
240         }
241     }
242
243     *out_len = p - ret;
244     return ret;
245
246  err:
247     OPENSSL_free(ret);
248     return NULL;
249 }
250
251 /*
252  * For a hex string "value" convert to a binary allocated buffer.
253  * Return 1 on success or 0 on failure.
254  */
255 static int parse_bin(const char *value, unsigned char **buf, size_t *buflen)
256 {
257     long len;
258
259     /* Check for NULL literal */
260     if (strcmp(value, "NULL") == 0) {
261         *buf = NULL;
262         *buflen = 0;
263         return 1;
264     }
265
266     /* Check for empty value */
267     if (*value == '\0') {
268         /*
269          * Don't return NULL for zero length buffer. This is needed for
270          * some tests with empty keys: HMAC_Init_ex() expects a non-NULL key
271          * buffer even if the key length is 0, in order to detect key reset.
272          */
273         *buf = OPENSSL_malloc(1);
274         if (*buf == NULL)
275             return 0;
276         **buf = 0;
277         *buflen = 0;
278         return 1;
279     }
280
281     /* Check for string literal */
282     if (value[0] == '"') {
283         size_t vlen = strlen(++value);
284
285         if (vlen == 0 || value[vlen - 1] != '"')
286             return 0;
287         vlen--;
288         *buf = unescape(value, vlen, buflen);
289         return *buf == NULL ? 0 : 1;
290     }
291
292     /* Otherwise assume as hex literal and convert it to binary buffer */
293     if (!TEST_ptr(*buf = OPENSSL_hexstr2buf(value, &len))) {
294         TEST_info("Can't convert %s", value);
295         ERR_print_errors(bio_err);
296         return -1;
297     }
298     /* Size of input buffer means we'll never overflow */
299     *buflen = len;
300     return 1;
301 }
302
303
304 /**
305 ***  MESSAGE DIGEST TESTS
306 **/
307
308 typedef struct digest_data_st {
309     /* Digest this test is for */
310     const EVP_MD *digest;
311     /* Input to digest */
312     STACK_OF(EVP_TEST_BUFFER) *input;
313     /* Expected output */
314     unsigned char *output;
315     size_t output_len;
316 } DIGEST_DATA;
317
318 static int digest_test_init(EVP_TEST *t, const char *alg)
319 {
320     DIGEST_DATA *mdat;
321     const EVP_MD *digest;
322
323     if ((digest = EVP_get_digestbyname(alg)) == NULL) {
324         /* If alg has an OID assume disabled algorithm */
325         if (OBJ_sn2nid(alg) != NID_undef || OBJ_ln2nid(alg) != NID_undef) {
326             t->skip = 1;
327             return 1;
328         }
329         return 0;
330     }
331     if (!TEST_ptr(mdat = OPENSSL_zalloc(sizeof(*mdat))))
332         return 0;
333     t->data = mdat;
334     mdat->digest = digest;
335     return 1;
336 }
337
338 static void digest_test_cleanup(EVP_TEST *t)
339 {
340     DIGEST_DATA *mdat = t->data;
341
342     sk_EVP_TEST_BUFFER_pop_free(mdat->input, evp_test_buffer_free);
343     OPENSSL_free(mdat->output);
344 }
345
346 static int digest_test_parse(EVP_TEST *t,
347                              const char *keyword, const char *value)
348 {
349     DIGEST_DATA *mdata = t->data;
350
351     if (strcmp(keyword, "Input") == 0)
352         return evp_test_buffer_append(value, &mdata->input);
353     if (strcmp(keyword, "Output") == 0)
354         return parse_bin(value, &mdata->output, &mdata->output_len);
355     if (strcmp(keyword, "Count") == 0)
356         return evp_test_buffer_set_count(value, mdata->input);
357     if (strcmp(keyword, "Ncopy") == 0)
358         return evp_test_buffer_ncopy(value, mdata->input);
359     return 0;
360 }
361
362 static int digest_update_fn(void *ctx, const unsigned char *buf, size_t buflen)
363 {
364     return EVP_DigestUpdate(ctx, buf, buflen);
365 }
366
367 static int digest_test_run(EVP_TEST *t)
368 {
369     DIGEST_DATA *expected = t->data;
370     EVP_MD_CTX *mctx;
371     unsigned char got[EVP_MAX_MD_SIZE];
372     unsigned int got_len;
373
374     t->err = "TEST_FAILURE";
375     if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
376         goto err;
377
378     if (!EVP_DigestInit_ex(mctx, expected->digest, NULL)) {
379         t->err = "DIGESTINIT_ERROR";
380         goto err;
381     }
382     if (!evp_test_buffer_do(expected->input, digest_update_fn, mctx)) {
383         t->err = "DIGESTUPDATE_ERROR";
384         goto err;
385     }
386
387     if (!EVP_DigestFinal(mctx, got, &got_len)) {
388         t->err = "DIGESTFINAL_ERROR";
389         goto err;
390     }
391     if (!TEST_int_eq(expected->output_len, got_len)) {
392         t->err = "DIGEST_LENGTH_MISMATCH";
393         goto err;
394     }
395     if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
396         t->err = "DIGEST_MISMATCH";
397         goto err;
398     }
399     t->err = NULL;
400
401  err:
402     EVP_MD_CTX_free(mctx);
403     return 1;
404 }
405
406 static const EVP_TEST_METHOD digest_test_method = {
407     "Digest",
408     digest_test_init,
409     digest_test_cleanup,
410     digest_test_parse,
411     digest_test_run
412 };
413
414
415 /**
416 ***  CIPHER TESTS
417 **/
418
419 typedef struct cipher_data_st {
420     const EVP_CIPHER *cipher;
421     int enc;
422     /* EVP_CIPH_GCM_MODE, EVP_CIPH_CCM_MODE or EVP_CIPH_OCB_MODE if AEAD */
423     int aead;
424     unsigned char *key;
425     size_t key_len;
426     unsigned char *iv;
427     size_t iv_len;
428     unsigned char *plaintext;
429     size_t plaintext_len;
430     unsigned char *ciphertext;
431     size_t ciphertext_len;
432     /* GCM, CCM only */
433     unsigned char *aad;
434     size_t aad_len;
435     unsigned char *tag;
436     size_t tag_len;
437 } CIPHER_DATA;
438
439 static int cipher_test_init(EVP_TEST *t, const char *alg)
440 {
441     const EVP_CIPHER *cipher;
442     CIPHER_DATA *cdat;
443     int m;
444
445     if ((cipher = EVP_get_cipherbyname(alg)) == NULL) {
446         /* If alg has an OID assume disabled algorithm */
447         if (OBJ_sn2nid(alg) != NID_undef || OBJ_ln2nid(alg) != NID_undef) {
448             t->skip = 1;
449             return 1;
450         }
451         return 0;
452     }
453     cdat = OPENSSL_zalloc(sizeof(*cdat));
454     cdat->cipher = cipher;
455     cdat->enc = -1;
456     m = EVP_CIPHER_mode(cipher);
457     if (m == EVP_CIPH_GCM_MODE
458             || m == EVP_CIPH_OCB_MODE
459             || m == EVP_CIPH_CCM_MODE)
460         cdat->aead = EVP_CIPHER_mode(cipher);
461     else if (EVP_CIPHER_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER)
462         cdat->aead = -1;
463     else
464         cdat->aead = 0;
465
466     t->data = cdat;
467     return 1;
468 }
469
470 static void cipher_test_cleanup(EVP_TEST *t)
471 {
472     CIPHER_DATA *cdat = t->data;
473
474     OPENSSL_free(cdat->key);
475     OPENSSL_free(cdat->iv);
476     OPENSSL_free(cdat->ciphertext);
477     OPENSSL_free(cdat->plaintext);
478     OPENSSL_free(cdat->aad);
479     OPENSSL_free(cdat->tag);
480 }
481
482 static int cipher_test_parse(EVP_TEST *t, const char *keyword,
483                              const char *value)
484 {
485     CIPHER_DATA *cdat = t->data;
486
487     if (strcmp(keyword, "Key") == 0)
488         return parse_bin(value, &cdat->key, &cdat->key_len);
489     if (strcmp(keyword, "IV") == 0)
490         return parse_bin(value, &cdat->iv, &cdat->iv_len);
491     if (strcmp(keyword, "Plaintext") == 0)
492         return parse_bin(value, &cdat->plaintext, &cdat->plaintext_len);
493     if (strcmp(keyword, "Ciphertext") == 0)
494         return parse_bin(value, &cdat->ciphertext, &cdat->ciphertext_len);
495     if (cdat->aead) {
496         if (strcmp(keyword, "AAD") == 0)
497             return parse_bin(value, &cdat->aad, &cdat->aad_len);
498         if (strcmp(keyword, "Tag") == 0)
499             return parse_bin(value, &cdat->tag, &cdat->tag_len);
500     }
501
502     if (strcmp(keyword, "Operation") == 0) {
503         if (strcmp(value, "ENCRYPT") == 0)
504             cdat->enc = 1;
505         else if (strcmp(value, "DECRYPT") == 0)
506             cdat->enc = 0;
507         else
508             return 0;
509         return 1;
510     }
511     return 0;
512 }
513
514 static int cipher_test_enc(EVP_TEST *t, int enc,
515                            size_t out_misalign, size_t inp_misalign, int frag)
516 {
517     CIPHER_DATA *expected = t->data;
518     unsigned char *in, *expected_out, *tmp = NULL;
519     size_t in_len, out_len, donelen = 0;
520     int ok = 0, tmplen, chunklen, tmpflen;
521     EVP_CIPHER_CTX *ctx = NULL;
522
523     t->err = "TEST_FAILURE";
524     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new()))
525         goto err;
526     EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
527     if (enc) {
528         in = expected->plaintext;
529         in_len = expected->plaintext_len;
530         expected_out = expected->ciphertext;
531         out_len = expected->ciphertext_len;
532     } else {
533         in = expected->ciphertext;
534         in_len = expected->ciphertext_len;
535         expected_out = expected->plaintext;
536         out_len = expected->plaintext_len;
537     }
538     if (inp_misalign == (size_t)-1) {
539         /*
540          * Exercise in-place encryption
541          */
542         tmp = OPENSSL_malloc(out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH);
543         if (!tmp)
544             goto err;
545         in = memcpy(tmp + out_misalign, in, in_len);
546     } else {
547         inp_misalign += 16 - ((out_misalign + in_len) & 15);
548         /*
549          * 'tmp' will store both output and copy of input. We make the copy
550          * of input to specifically aligned part of 'tmp'. So we just
551          * figured out how much padding would ensure the required alignment,
552          * now we allocate extended buffer and finally copy the input just
553          * past inp_misalign in expression below. Output will be written
554          * past out_misalign...
555          */
556         tmp = OPENSSL_malloc(out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH +
557                              inp_misalign + in_len);
558         if (!tmp)
559             goto err;
560         in = memcpy(tmp + out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH +
561                     inp_misalign, in, in_len);
562     }
563     if (!EVP_CipherInit_ex(ctx, expected->cipher, NULL, NULL, NULL, enc)) {
564         t->err = "CIPHERINIT_ERROR";
565         goto err;
566     }
567     if (expected->iv) {
568         if (expected->aead) {
569             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN,
570                                      expected->iv_len, 0)) {
571                 t->err = "INVALID_IV_LENGTH";
572                 goto err;
573             }
574         } else if (expected->iv_len != (size_t)EVP_CIPHER_CTX_iv_length(ctx)) {
575             t->err = "INVALID_IV_LENGTH";
576             goto err;
577         }
578     }
579     if (expected->aead) {
580         unsigned char *tag;
581         /*
582          * If encrypting or OCB just set tag length initially, otherwise
583          * set tag length and value.
584          */
585         if (enc || expected->aead == EVP_CIPH_OCB_MODE) {
586             t->err = "TAG_LENGTH_SET_ERROR";
587             tag = NULL;
588         } else {
589             t->err = "TAG_SET_ERROR";
590             tag = expected->tag;
591         }
592         if (tag || expected->aead != EVP_CIPH_GCM_MODE) {
593             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
594                                      expected->tag_len, tag))
595                 goto err;
596         }
597     }
598
599     if (!EVP_CIPHER_CTX_set_key_length(ctx, expected->key_len)) {
600         t->err = "INVALID_KEY_LENGTH";
601         goto err;
602     }
603     if (!EVP_CipherInit_ex(ctx, NULL, NULL, expected->key, expected->iv, -1)) {
604         t->err = "KEY_SET_ERROR";
605         goto err;
606     }
607
608     if (!enc && expected->aead == EVP_CIPH_OCB_MODE) {
609         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
610                                  expected->tag_len, expected->tag)) {
611             t->err = "TAG_SET_ERROR";
612             goto err;
613         }
614     }
615
616     if (expected->aead == EVP_CIPH_CCM_MODE) {
617         if (!EVP_CipherUpdate(ctx, NULL, &tmplen, NULL, out_len)) {
618             t->err = "CCM_PLAINTEXT_LENGTH_SET_ERROR";
619             goto err;
620         }
621     }
622     if (expected->aad) {
623         t->err = "AAD_SET_ERROR";
624         if (!frag) {
625             if (!EVP_CipherUpdate(ctx, NULL, &chunklen, expected->aad,
626                                   expected->aad_len))
627                 goto err;
628         } else {
629             /*
630              * Supply the AAD in chunks less than the block size where possible
631              */
632             if (expected->aad_len > 0) {
633                 if (!EVP_CipherUpdate(ctx, NULL, &chunklen, expected->aad, 1))
634                     goto err;
635                 donelen++;
636             }
637             if (expected->aad_len > 2) {
638                 if (!EVP_CipherUpdate(ctx, NULL, &chunklen,
639                                       expected->aad + donelen,
640                                       expected->aad_len - 2))
641                     goto err;
642                 donelen += expected->aad_len - 2;
643             }
644             if (expected->aad_len > 1
645                     && !EVP_CipherUpdate(ctx, NULL, &chunklen,
646                                          expected->aad + donelen, 1))
647                 goto err;
648         }
649     }
650     EVP_CIPHER_CTX_set_padding(ctx, 0);
651     t->err = "CIPHERUPDATE_ERROR";
652     tmplen = 0;
653     if (!frag) {
654         /* We supply the data all in one go */
655         if (!EVP_CipherUpdate(ctx, tmp + out_misalign, &tmplen, in, in_len))
656             goto err;
657     } else {
658         /* Supply the data in chunks less than the block size where possible */
659         if (in_len > 0) {
660             if (!EVP_CipherUpdate(ctx, tmp + out_misalign, &chunklen, in, 1))
661                 goto err;
662             tmplen += chunklen;
663             in++;
664             in_len--;
665         }
666         if (in_len > 1) {
667             if (!EVP_CipherUpdate(ctx, tmp + out_misalign + tmplen, &chunklen,
668                                   in, in_len - 1))
669                 goto err;
670             tmplen += chunklen;
671             in += in_len - 1;
672             in_len = 1;
673         }
674         if (in_len > 0 ) {
675             if (!EVP_CipherUpdate(ctx, tmp + out_misalign + tmplen, &chunklen,
676                                   in, 1))
677                 goto err;
678             tmplen += chunklen;
679         }
680     }
681     if (!EVP_CipherFinal_ex(ctx, tmp + out_misalign + tmplen, &tmpflen)) {
682         t->err = "CIPHERFINAL_ERROR";
683         goto err;
684     }
685     if (!TEST_mem_eq(expected_out, out_len,
686                      tmp + out_misalign, tmplen + tmpflen)) {
687         t->err = "VALUE_MISMATCH";
688         goto err;
689     }
690     if (enc && expected->aead) {
691         unsigned char rtag[16];
692
693         if (!TEST_size_t_le(expected->tag_len, sizeof(rtag))) {
694             t->err = "TAG_LENGTH_INTERNAL_ERROR";
695             goto err;
696         }
697         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
698                                  expected->tag_len, rtag)) {
699             t->err = "TAG_RETRIEVE_ERROR";
700             goto err;
701         }
702         if (!TEST_mem_eq(expected->tag, expected->tag_len,
703                          rtag, expected->tag_len)) {
704             t->err = "TAG_VALUE_MISMATCH";
705             goto err;
706         }
707     }
708     t->err = NULL;
709     ok = 1;
710  err:
711     OPENSSL_free(tmp);
712     EVP_CIPHER_CTX_free(ctx);
713     return ok;
714 }
715
716 static int cipher_test_run(EVP_TEST *t)
717 {
718     CIPHER_DATA *cdat = t->data;
719     int rv, frag = 0;
720     size_t out_misalign, inp_misalign;
721
722     if (!cdat->key) {
723         t->err = "NO_KEY";
724         return 0;
725     }
726     if (!cdat->iv && EVP_CIPHER_iv_length(cdat->cipher)) {
727         /* IV is optional and usually omitted in wrap mode */
728         if (EVP_CIPHER_mode(cdat->cipher) != EVP_CIPH_WRAP_MODE) {
729             t->err = "NO_IV";
730             return 0;
731         }
732     }
733     if (cdat->aead && !cdat->tag) {
734         t->err = "NO_TAG";
735         return 0;
736     }
737     for (out_misalign = 0; out_misalign <= 1;) {
738         static char aux_err[64];
739         t->aux_err = aux_err;
740         for (inp_misalign = (size_t)-1; inp_misalign != 2; inp_misalign++) {
741             if (inp_misalign == (size_t)-1) {
742                 /* kludge: inp_misalign == -1 means "exercise in-place" */
743                 BIO_snprintf(aux_err, sizeof(aux_err),
744                              "%s in-place, %sfragmented",
745                              out_misalign ? "misaligned" : "aligned",
746                              frag ? "" : "not ");
747             } else {
748                 BIO_snprintf(aux_err, sizeof(aux_err),
749                              "%s output and %s input, %sfragmented",
750                              out_misalign ? "misaligned" : "aligned",
751                              inp_misalign ? "misaligned" : "aligned",
752                              frag ? "" : "not ");
753             }
754             if (cdat->enc) {
755                 rv = cipher_test_enc(t, 1, out_misalign, inp_misalign, frag);
756                 /* Not fatal errors: return */
757                 if (rv != 1) {
758                     if (rv < 0)
759                         return 0;
760                     return 1;
761                 }
762             }
763             if (cdat->enc != 1) {
764                 rv = cipher_test_enc(t, 0, out_misalign, inp_misalign, frag);
765                 /* Not fatal errors: return */
766                 if (rv != 1) {
767                     if (rv < 0)
768                         return 0;
769                     return 1;
770                 }
771             }
772         }
773
774         if (out_misalign == 1 && frag == 0) {
775             /*
776              * XTS, CCM and Wrap modes have special requirements about input
777              * lengths so we don't fragment for those
778              */
779             if (cdat->aead == EVP_CIPH_CCM_MODE
780                     || EVP_CIPHER_mode(cdat->cipher) == EVP_CIPH_XTS_MODE
781                     || EVP_CIPHER_mode(cdat->cipher) == EVP_CIPH_WRAP_MODE)
782                 break;
783             out_misalign = 0;
784             frag++;
785         } else {
786             out_misalign++;
787         }
788     }
789     t->aux_err = NULL;
790
791     return 1;
792 }
793
794 static const EVP_TEST_METHOD cipher_test_method = {
795     "Cipher",
796     cipher_test_init,
797     cipher_test_cleanup,
798     cipher_test_parse,
799     cipher_test_run
800 };
801
802
803 /**
804 ***  MAC TESTS
805 **/
806
807 typedef struct mac_data_st {
808     /* MAC type */
809     int type;
810     /* Algorithm string for this MAC */
811     char *alg;
812     /* MAC key */
813     unsigned char *key;
814     size_t key_len;
815     /* Input to MAC */
816     unsigned char *input;
817     size_t input_len;
818     /* Expected output */
819     unsigned char *output;
820     size_t output_len;
821 } MAC_DATA;
822
823 static int mac_test_init(EVP_TEST *t, const char *alg)
824 {
825     int type;
826     MAC_DATA *mdat;
827
828     if (strcmp(alg, "HMAC") == 0) {
829         type = EVP_PKEY_HMAC;
830     } else if (strcmp(alg, "CMAC") == 0) {
831 #ifndef OPENSSL_NO_CMAC
832         type = EVP_PKEY_CMAC;
833 #else
834         t->skip = 1;
835         return 1;
836 #endif
837     } else if (strcmp(alg, "Poly1305") == 0) {
838 #ifndef OPENSSL_NO_POLY1305
839         type = EVP_PKEY_POLY1305;
840 #else
841         t->skip = 1;
842         return 1;
843 #endif
844     } else if (strcmp(alg, "SipHash") == 0) {
845 #ifndef OPENSSL_NO_SIPHASH
846         type = EVP_PKEY_SIPHASH;
847 #else
848         t->skip = 1;
849         return 1;
850 #endif
851     } else
852         return 0;
853
854     mdat = OPENSSL_zalloc(sizeof(*mdat));
855     mdat->type = type;
856     t->data = mdat;
857     return 1;
858 }
859
860 static void mac_test_cleanup(EVP_TEST *t)
861 {
862     MAC_DATA *mdat = t->data;
863
864     OPENSSL_free(mdat->alg);
865     OPENSSL_free(mdat->key);
866     OPENSSL_free(mdat->input);
867     OPENSSL_free(mdat->output);
868 }
869
870 static int mac_test_parse(EVP_TEST *t,
871                           const char *keyword, const char *value)
872 {
873     MAC_DATA *mdata = t->data;
874
875     if (strcmp(keyword, "Key") == 0)
876         return parse_bin(value, &mdata->key, &mdata->key_len);
877     if (strcmp(keyword, "Algorithm") == 0) {
878         mdata->alg = OPENSSL_strdup(value);
879         if (!mdata->alg)
880             return 0;
881         return 1;
882     }
883     if (strcmp(keyword, "Input") == 0)
884         return parse_bin(value, &mdata->input, &mdata->input_len);
885     if (strcmp(keyword, "Output") == 0)
886         return parse_bin(value, &mdata->output, &mdata->output_len);
887     return 0;
888 }
889
890 static int mac_test_run(EVP_TEST *t)
891 {
892     MAC_DATA *expected = t->data;
893     EVP_MD_CTX *mctx = NULL;
894     EVP_PKEY_CTX *pctx = NULL, *genctx = NULL;
895     EVP_PKEY *key = NULL;
896     const EVP_MD *md = NULL;
897     unsigned char *got = NULL;
898     size_t got_len;
899
900 #ifdef OPENSSL_NO_DES
901     if (expected->alg != NULL && strstr(expected->alg, "DES") != NULL) {
902         /* Skip DES */
903         t->err = NULL;
904         goto err;
905     }
906 #endif
907
908     if (!TEST_ptr(genctx = EVP_PKEY_CTX_new_id(expected->type, NULL))) {
909         t->err = "MAC_PKEY_CTX_ERROR";
910         goto err;
911     }
912
913     if (EVP_PKEY_keygen_init(genctx) <= 0) {
914         t->err = "MAC_KEYGEN_INIT_ERROR";
915         goto err;
916     }
917     if (expected->type == EVP_PKEY_CMAC
918              && EVP_PKEY_CTX_ctrl_str(genctx, "cipher", expected->alg) <= 0) {
919         t->err = "MAC_ALGORITHM_SET_ERROR";
920         goto err;
921     }
922
923     if (EVP_PKEY_CTX_set_mac_key(genctx, expected->key,
924                                  expected->key_len) <= 0) {
925         t->err = "MAC_KEY_SET_ERROR";
926         goto err;
927     }
928
929     if (EVP_PKEY_keygen(genctx, &key) <= 0) {
930         t->err = "MAC_KEY_GENERATE_ERROR";
931         goto err;
932     }
933     if (expected->type == EVP_PKEY_HMAC) {
934         if (!TEST_ptr(md = EVP_get_digestbyname(expected->alg))) {
935             t->err = "MAC_ALGORITHM_SET_ERROR";
936             goto err;
937         }
938     }
939     if (!TEST_ptr(mctx = EVP_MD_CTX_new())) {
940         t->err = "INTERNAL_ERROR";
941         goto err;
942     }
943     if (!EVP_DigestSignInit(mctx, &pctx, md, NULL, key)) {
944         t->err = "DIGESTSIGNINIT_ERROR";
945         goto err;
946     }
947
948     if (!EVP_DigestSignUpdate(mctx, expected->input, expected->input_len)) {
949         t->err = "DIGESTSIGNUPDATE_ERROR";
950         goto err;
951     }
952     if (!EVP_DigestSignFinal(mctx, NULL, &got_len)) {
953         t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";
954         goto err;
955     }
956     if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
957         t->err = "TEST_FAILURE";
958         goto err;
959     }
960     if (!EVP_DigestSignFinal(mctx, got, &got_len)
961             || !TEST_mem_eq(expected->output, expected->output_len,
962                             got, got_len)) {
963         t->err = "TEST_MAC_ERR";
964         goto err;
965     }
966     t->err = NULL;
967  err:
968     EVP_MD_CTX_free(mctx);
969     OPENSSL_free(got);
970     EVP_PKEY_CTX_free(genctx);
971     EVP_PKEY_free(key);
972     return 1;
973 }
974
975 static const EVP_TEST_METHOD mac_test_method = {
976     "MAC",
977     mac_test_init,
978     mac_test_cleanup,
979     mac_test_parse,
980     mac_test_run
981 };
982
983
984 /**
985 ***  PUBLIC KEY TESTS
986 ***  These are all very similar and share much common code.
987 **/
988
989 typedef struct pkey_data_st {
990     /* Context for this operation */
991     EVP_PKEY_CTX *ctx;
992     /* Key operation to perform */
993     int (*keyop) (EVP_PKEY_CTX *ctx,
994                   unsigned char *sig, size_t *siglen,
995                   const unsigned char *tbs, size_t tbslen);
996     /* Input to MAC */
997     unsigned char *input;
998     size_t input_len;
999     /* Expected output */
1000     unsigned char *output;
1001     size_t output_len;
1002 } PKEY_DATA;
1003
1004 /*
1005  * Perform public key operation setup: lookup key, allocated ctx and call
1006  * the appropriate initialisation function
1007  */
1008 static int pkey_test_init(EVP_TEST *t, const char *name,
1009                           int use_public,
1010                           int (*keyopinit) (EVP_PKEY_CTX *ctx),
1011                           int (*keyop)(EVP_PKEY_CTX *ctx,
1012                                        unsigned char *sig, size_t *siglen,
1013                                        const unsigned char *tbs,
1014                                        size_t tbslen))
1015 {
1016     PKEY_DATA *kdata;
1017     EVP_PKEY *pkey = NULL;
1018     int rv = 0;
1019
1020     if (use_public)
1021         rv = find_key(&pkey, name, public_keys);
1022     if (rv == 0)
1023         rv = find_key(&pkey, name, private_keys);
1024     if (rv == 0 || pkey == NULL) {
1025         t->skip = 1;
1026         return 1;
1027     }
1028
1029     if (!TEST_ptr(kdata = OPENSSL_zalloc(sizeof(*kdata)))) {
1030         EVP_PKEY_free(pkey);
1031         return 0;
1032     }
1033     kdata->keyop = keyop;
1034     if (!TEST_ptr(kdata->ctx = EVP_PKEY_CTX_new(pkey, NULL)))
1035         return 0;
1036     if (keyopinit(kdata->ctx) <= 0)
1037         t->err = "KEYOP_INIT_ERROR";
1038     t->data = kdata;
1039     return 1;
1040 }
1041
1042 static void pkey_test_cleanup(EVP_TEST *t)
1043 {
1044     PKEY_DATA *kdata = t->data;
1045
1046     OPENSSL_free(kdata->input);
1047     OPENSSL_free(kdata->output);
1048     EVP_PKEY_CTX_free(kdata->ctx);
1049 }
1050
1051 static int pkey_test_ctrl(EVP_TEST *t, EVP_PKEY_CTX *pctx,
1052                           const char *value)
1053 {
1054     int rv;
1055     char *p, *tmpval;
1056
1057     if (!TEST_ptr(tmpval = OPENSSL_strdup(value)))
1058         return 0;
1059     p = strchr(tmpval, ':');
1060     if (p != NULL)
1061         *p++ = '\0';
1062     rv = EVP_PKEY_CTX_ctrl_str(pctx, tmpval, p);
1063     if (rv == -2) {
1064         t->err = "PKEY_CTRL_INVALID";
1065         rv = 1;
1066     } else if (p != NULL && rv <= 0) {
1067         /* If p has an OID and lookup fails assume disabled algorithm */
1068         int nid = OBJ_sn2nid(p);
1069
1070         if (nid == NID_undef)
1071              nid = OBJ_ln2nid(p);
1072         if (nid != NID_undef
1073                 && EVP_get_digestbynid(nid) == NULL
1074                 && EVP_get_cipherbynid(nid) == NULL) {
1075             t->skip = 1;
1076             rv = 1;
1077         } else {
1078             t->err = "PKEY_CTRL_ERROR";
1079             rv = 1;
1080         }
1081     }
1082     OPENSSL_free(tmpval);
1083     return rv > 0;
1084 }
1085
1086 static int pkey_test_parse(EVP_TEST *t,
1087                            const char *keyword, const char *value)
1088 {
1089     PKEY_DATA *kdata = t->data;
1090     if (strcmp(keyword, "Input") == 0)
1091         return parse_bin(value, &kdata->input, &kdata->input_len);
1092     if (strcmp(keyword, "Output") == 0)
1093         return parse_bin(value, &kdata->output, &kdata->output_len);
1094     if (strcmp(keyword, "Ctrl") == 0)
1095         return pkey_test_ctrl(t, kdata->ctx, value);
1096     return 0;
1097 }
1098
1099 static int pkey_test_run(EVP_TEST *t)
1100 {
1101     PKEY_DATA *expected = t->data;
1102     unsigned char *got = NULL;
1103     size_t got_len;
1104
1105     if (expected->keyop(expected->ctx, NULL, &got_len,
1106                         expected->input, expected->input_len) <= 0
1107             || !TEST_ptr(got = OPENSSL_malloc(got_len))) {
1108         t->err = "KEYOP_LENGTH_ERROR";
1109         goto err;
1110     }
1111     if (expected->keyop(expected->ctx, got, &got_len,
1112                         expected->input, expected->input_len) <= 0) {
1113         t->err = "KEYOP_ERROR";
1114         goto err;
1115     }
1116     if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
1117         t->err = "KEYOP_MISMATCH";
1118         goto err;
1119     }
1120     t->err = NULL;
1121  err:
1122     OPENSSL_free(got);
1123     return 1;
1124 }
1125
1126 static int sign_test_init(EVP_TEST *t, const char *name)
1127 {
1128     return pkey_test_init(t, name, 0, EVP_PKEY_sign_init, EVP_PKEY_sign);
1129 }
1130
1131 static const EVP_TEST_METHOD psign_test_method = {
1132     "Sign",
1133     sign_test_init,
1134     pkey_test_cleanup,
1135     pkey_test_parse,
1136     pkey_test_run
1137 };
1138
1139 static int verify_recover_test_init(EVP_TEST *t, const char *name)
1140 {
1141     return pkey_test_init(t, name, 1, EVP_PKEY_verify_recover_init,
1142                           EVP_PKEY_verify_recover);
1143 }
1144
1145 static const EVP_TEST_METHOD pverify_recover_test_method = {
1146     "VerifyRecover",
1147     verify_recover_test_init,
1148     pkey_test_cleanup,
1149     pkey_test_parse,
1150     pkey_test_run
1151 };
1152
1153 static int decrypt_test_init(EVP_TEST *t, const char *name)
1154 {
1155     return pkey_test_init(t, name, 0, EVP_PKEY_decrypt_init,
1156                           EVP_PKEY_decrypt);
1157 }
1158
1159 static const EVP_TEST_METHOD pdecrypt_test_method = {
1160     "Decrypt",
1161     decrypt_test_init,
1162     pkey_test_cleanup,
1163     pkey_test_parse,
1164     pkey_test_run
1165 };
1166
1167 static int verify_test_init(EVP_TEST *t, const char *name)
1168 {
1169     return pkey_test_init(t, name, 1, EVP_PKEY_verify_init, 0);
1170 }
1171
1172 static int verify_test_run(EVP_TEST *t)
1173 {
1174     PKEY_DATA *kdata = t->data;
1175
1176     if (EVP_PKEY_verify(kdata->ctx, kdata->output, kdata->output_len,
1177                         kdata->input, kdata->input_len) <= 0)
1178         t->err = "VERIFY_ERROR";
1179     return 1;
1180 }
1181
1182 static const EVP_TEST_METHOD pverify_test_method = {
1183     "Verify",
1184     verify_test_init,
1185     pkey_test_cleanup,
1186     pkey_test_parse,
1187     verify_test_run
1188 };
1189
1190
1191 static int pderive_test_init(EVP_TEST *t, const char *name)
1192 {
1193     return pkey_test_init(t, name, 0, EVP_PKEY_derive_init, 0);
1194 }
1195
1196 static int pderive_test_parse(EVP_TEST *t,
1197                               const char *keyword, const char *value)
1198 {
1199     PKEY_DATA *kdata = t->data;
1200
1201     if (strcmp(keyword, "PeerKey") == 0) {
1202         EVP_PKEY *peer;
1203         if (find_key(&peer, value, public_keys) == 0)
1204             return 0;
1205         if (EVP_PKEY_derive_set_peer(kdata->ctx, peer) <= 0)
1206             return 0;
1207         return 1;
1208     }
1209     if (strcmp(keyword, "SharedSecret") == 0)
1210         return parse_bin(value, &kdata->output, &kdata->output_len);
1211     if (strcmp(keyword, "Ctrl") == 0)
1212         return pkey_test_ctrl(t, kdata->ctx, value);
1213     return 0;
1214 }
1215
1216 static int pderive_test_run(EVP_TEST *t)
1217 {
1218     PKEY_DATA *expected = t->data;
1219     unsigned char *got = NULL;
1220     size_t got_len;
1221
1222     got_len = expected->output_len;
1223     if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
1224         t->err = "DERIVE_ERROR";
1225         goto err;
1226     }
1227     if (EVP_PKEY_derive(expected->ctx, got, &got_len) <= 0) {
1228         t->err = "DERIVE_ERROR";
1229         goto err;
1230     }
1231     if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
1232         t->err = "SHARED_SECRET_MISMATCH";
1233         goto err;
1234     }
1235
1236     t->err = NULL;
1237  err:
1238     OPENSSL_free(got);
1239     return 1;
1240 }
1241
1242 static const EVP_TEST_METHOD pderive_test_method = {
1243     "Derive",
1244     pderive_test_init,
1245     pkey_test_cleanup,
1246     pderive_test_parse,
1247     pderive_test_run
1248 };
1249
1250
1251 /**
1252 ***  PBE TESTS
1253 **/
1254
1255 typedef enum pbe_type_enum {
1256     PBE_TYPE_INVALID = 0,
1257     PBE_TYPE_SCRYPT, PBE_TYPE_PBKDF2, PBE_TYPE_PKCS12
1258 } PBE_TYPE;
1259
1260 typedef struct pbe_data_st {
1261     PBE_TYPE pbe_type;
1262         /* scrypt parameters */
1263     uint64_t N, r, p, maxmem;
1264         /* PKCS#12 parameters */
1265     int id, iter;
1266     const EVP_MD *md;
1267         /* password */
1268     unsigned char *pass;
1269     size_t pass_len;
1270         /* salt */
1271     unsigned char *salt;
1272     size_t salt_len;
1273         /* Expected output */
1274     unsigned char *key;
1275     size_t key_len;
1276 } PBE_DATA;
1277
1278 #ifndef OPENSSL_NO_SCRYPT
1279 /*
1280  * Parse unsigned decimal 64 bit integer value
1281  */
1282 static int parse_uint64(const char *value, uint64_t *pr)
1283 {
1284     const char *p = value;
1285
1286     if (!TEST_true(*p)) {
1287         TEST_info("Invalid empty integer value");
1288         return -1;
1289     }
1290     for (*pr = 0; *p; ) {
1291         if (*pr > UINT64_MAX / 10) {
1292             TEST_error("Integer overflow in string %s", value);
1293             return -1;
1294         }
1295         *pr *= 10;
1296         if (!TEST_true(isdigit(*p))) {
1297             TEST_error("Invalid character in string %s", value);
1298             return -1;
1299         }
1300         *pr += *p - '0';
1301         p++;
1302     }
1303     return 1;
1304 }
1305
1306 static int scrypt_test_parse(EVP_TEST *t,
1307                              const char *keyword, const char *value)
1308 {
1309     PBE_DATA *pdata = t->data;
1310
1311     if (strcmp(keyword, "N") == 0)
1312         return parse_uint64(value, &pdata->N);
1313     if (strcmp(keyword, "p") == 0)
1314         return parse_uint64(value, &pdata->p);
1315     if (strcmp(keyword, "r") == 0)
1316         return parse_uint64(value, &pdata->r);
1317     if (strcmp(keyword, "maxmem") == 0)
1318         return parse_uint64(value, &pdata->maxmem);
1319     return 0;
1320 }
1321 #endif
1322
1323 static int pbkdf2_test_parse(EVP_TEST *t,
1324                              const char *keyword, const char *value)
1325 {
1326     PBE_DATA *pdata = t->data;
1327
1328     if (strcmp(keyword, "iter") == 0) {
1329         pdata->iter = atoi(value);
1330         if (pdata->iter <= 0)
1331             return -1;
1332         return 1;
1333     }
1334     if (strcmp(keyword, "MD") == 0) {
1335         pdata->md = EVP_get_digestbyname(value);
1336         if (pdata->md == NULL)
1337             return -1;
1338         return 1;
1339     }
1340     return 0;
1341 }
1342
1343 static int pkcs12_test_parse(EVP_TEST *t,
1344                              const char *keyword, const char *value)
1345 {
1346     PBE_DATA *pdata = t->data;
1347
1348     if (strcmp(keyword, "id") == 0) {
1349         pdata->id = atoi(value);
1350         if (pdata->id <= 0)
1351             return -1;
1352         return 1;
1353     }
1354     return pbkdf2_test_parse(t, keyword, value);
1355 }
1356
1357 static int pbe_test_init(EVP_TEST *t, const char *alg)
1358 {
1359     PBE_DATA *pdat;
1360     PBE_TYPE pbe_type = PBE_TYPE_INVALID;
1361
1362     if (strcmp(alg, "scrypt") == 0) {
1363 #ifndef OPENSSL_NO_SCRYPT
1364         pbe_type = PBE_TYPE_SCRYPT;
1365 #else
1366         t->skip = 1;
1367         return 1;
1368 #endif
1369     } else if (strcmp(alg, "pbkdf2") == 0) {
1370         pbe_type = PBE_TYPE_PBKDF2;
1371     } else if (strcmp(alg, "pkcs12") == 0) {
1372         pbe_type = PBE_TYPE_PKCS12;
1373     } else {
1374         TEST_error("Unknown pbe algorithm %s", alg);
1375     }
1376     pdat = OPENSSL_zalloc(sizeof(*pdat));
1377     pdat->pbe_type = pbe_type;
1378     t->data = pdat;
1379     return 1;
1380 }
1381
1382 static void pbe_test_cleanup(EVP_TEST *t)
1383 {
1384     PBE_DATA *pdat = t->data;
1385
1386     OPENSSL_free(pdat->pass);
1387     OPENSSL_free(pdat->salt);
1388     OPENSSL_free(pdat->key);
1389 }
1390
1391 static int pbe_test_parse(EVP_TEST *t,
1392                           const char *keyword, const char *value)
1393 {
1394     PBE_DATA *pdata = t->data;
1395
1396     if (strcmp(keyword, "Password") == 0)
1397         return parse_bin(value, &pdata->pass, &pdata->pass_len);
1398     if (strcmp(keyword, "Salt") == 0)
1399         return parse_bin(value, &pdata->salt, &pdata->salt_len);
1400     if (strcmp(keyword, "Key") == 0)
1401         return parse_bin(value, &pdata->key, &pdata->key_len);
1402     if (pdata->pbe_type == PBE_TYPE_PBKDF2)
1403         return pbkdf2_test_parse(t, keyword, value);
1404     else if (pdata->pbe_type == PBE_TYPE_PKCS12)
1405         return pkcs12_test_parse(t, keyword, value);
1406 #ifndef OPENSSL_NO_SCRYPT
1407     else if (pdata->pbe_type == PBE_TYPE_SCRYPT)
1408         return scrypt_test_parse(t, keyword, value);
1409 #endif
1410     return 0;
1411 }
1412
1413 static int pbe_test_run(EVP_TEST *t)
1414 {
1415     PBE_DATA *expected = t->data;
1416     unsigned char *key;
1417
1418     if (!TEST_ptr(key = OPENSSL_malloc(expected->key_len))) {
1419         t->err = "INTERNAL_ERROR";
1420         goto err;
1421     }
1422     if (expected->pbe_type == PBE_TYPE_PBKDF2) {
1423         if (PKCS5_PBKDF2_HMAC((char *)expected->pass, expected->pass_len,
1424                               expected->salt, expected->salt_len,
1425                               expected->iter, expected->md,
1426                               expected->key_len, key) == 0) {
1427             t->err = "PBKDF2_ERROR";
1428             goto err;
1429         }
1430 #ifndef OPENSSL_NO_SCRYPT
1431     } else if (expected->pbe_type == PBE_TYPE_SCRYPT) {
1432         if (EVP_PBE_scrypt((const char *)expected->pass, expected->pass_len,
1433                            expected->salt, expected->salt_len, expected->N,
1434                            expected->r, expected->p, expected->maxmem,
1435                            key, expected->key_len) == 0) {
1436             t->err = "SCRYPT_ERROR";
1437             goto err;
1438         }
1439 #endif
1440     } else if (expected->pbe_type == PBE_TYPE_PKCS12) {
1441         if (PKCS12_key_gen_uni(expected->pass, expected->pass_len,
1442                                expected->salt, expected->salt_len,
1443                                expected->id, expected->iter, expected->key_len,
1444                                key, expected->md) == 0) {
1445             t->err = "PKCS12_ERROR";
1446             goto err;
1447         }
1448     }
1449     if (!TEST_mem_eq(expected->key, expected->key_len,
1450                      key, expected->key_len)) {
1451         t->err = "KEY_MISMATCH";
1452         goto err;
1453     }
1454     t->err = NULL;
1455 err:
1456     OPENSSL_free(key);
1457     return 1;
1458 }
1459
1460 static const EVP_TEST_METHOD pbe_test_method = {
1461     "PBE",
1462     pbe_test_init,
1463     pbe_test_cleanup,
1464     pbe_test_parse,
1465     pbe_test_run
1466 };
1467
1468
1469 /**
1470 ***  BASE64 TESTS
1471 **/
1472
1473 typedef enum {
1474     BASE64_CANONICAL_ENCODING = 0,
1475     BASE64_VALID_ENCODING = 1,
1476     BASE64_INVALID_ENCODING = 2
1477 } base64_encoding_type;
1478
1479 typedef struct encode_data_st {
1480     /* Input to encoding */
1481     unsigned char *input;
1482     size_t input_len;
1483     /* Expected output */
1484     unsigned char *output;
1485     size_t output_len;
1486     base64_encoding_type encoding;
1487 } ENCODE_DATA;
1488
1489 static int encode_test_init(EVP_TEST *t, const char *encoding)
1490 {
1491     ENCODE_DATA *edata;
1492
1493     if (!TEST_ptr(edata = OPENSSL_zalloc(sizeof(*edata))))
1494         return 0;
1495     if (strcmp(encoding, "canonical") == 0) {
1496         edata->encoding = BASE64_CANONICAL_ENCODING;
1497     } else if (strcmp(encoding, "valid") == 0) {
1498         edata->encoding = BASE64_VALID_ENCODING;
1499     } else if (strcmp(encoding, "invalid") == 0) {
1500         edata->encoding = BASE64_INVALID_ENCODING;
1501         if (!TEST_ptr(t->expected_err = OPENSSL_strdup("DECODE_ERROR")))
1502             return 0;
1503     } else {
1504         TEST_error("Bad encoding: %s."
1505                    " Should be one of {canonical, valid, invalid}",
1506                    encoding);
1507         return 0;
1508     }
1509     t->data = edata;
1510     return 1;
1511 }
1512
1513 static void encode_test_cleanup(EVP_TEST *t)
1514 {
1515     ENCODE_DATA *edata = t->data;
1516
1517     OPENSSL_free(edata->input);
1518     OPENSSL_free(edata->output);
1519     memset(edata, 0, sizeof(*edata));
1520 }
1521
1522 static int encode_test_parse(EVP_TEST *t,
1523                              const char *keyword, const char *value)
1524 {
1525     ENCODE_DATA *edata = t->data;
1526
1527     if (strcmp(keyword, "Input") == 0)
1528         return parse_bin(value, &edata->input, &edata->input_len);
1529     if (strcmp(keyword, "Output") == 0)
1530         return parse_bin(value, &edata->output, &edata->output_len);
1531     return 0;
1532 }
1533
1534 static int encode_test_run(EVP_TEST *t)
1535 {
1536     ENCODE_DATA *expected = t->data;
1537     unsigned char *encode_out = NULL, *decode_out = NULL;
1538     int output_len, chunk_len;
1539     EVP_ENCODE_CTX *decode_ctx;
1540
1541     if (!TEST_ptr(decode_ctx = EVP_ENCODE_CTX_new())) {
1542         t->err = "INTERNAL_ERROR";
1543         goto err;
1544     }
1545
1546     if (expected->encoding == BASE64_CANONICAL_ENCODING) {
1547         EVP_ENCODE_CTX *encode_ctx;
1548
1549         if (!TEST_ptr(encode_ctx = EVP_ENCODE_CTX_new())
1550                 || !TEST_ptr(encode_out =
1551                         OPENSSL_malloc(EVP_ENCODE_LENGTH(expected->input_len))))
1552             goto err;
1553
1554         EVP_EncodeInit(encode_ctx);
1555         EVP_EncodeUpdate(encode_ctx, encode_out, &chunk_len,
1556                          expected->input, expected->input_len);
1557         output_len = chunk_len;
1558
1559         EVP_EncodeFinal(encode_ctx, encode_out + chunk_len, &chunk_len);
1560         output_len += chunk_len;
1561
1562         EVP_ENCODE_CTX_free(encode_ctx);
1563
1564         if (!TEST_mem_eq(expected->output, expected->output_len,
1565                          encode_out, output_len)) {
1566             t->err = "BAD_ENCODING";
1567             goto err;
1568         }
1569     }
1570
1571     if (!TEST_ptr(decode_out =
1572                 OPENSSL_malloc(EVP_DECODE_LENGTH(expected->output_len))))
1573         goto err;
1574
1575     EVP_DecodeInit(decode_ctx);
1576     if (EVP_DecodeUpdate(decode_ctx, decode_out, &chunk_len, expected->output,
1577                          expected->output_len) < 0) {
1578         t->err = "DECODE_ERROR";
1579         goto err;
1580     }
1581     output_len = chunk_len;
1582
1583     if (EVP_DecodeFinal(decode_ctx, decode_out + chunk_len, &chunk_len) != 1) {
1584         t->err = "DECODE_ERROR";
1585         goto err;
1586     }
1587     output_len += chunk_len;
1588
1589     if (expected->encoding != BASE64_INVALID_ENCODING
1590             && !TEST_mem_eq(expected->input, expected->input_len,
1591                             decode_out, output_len)) {
1592         t->err = "BAD_DECODING";
1593         goto err;
1594     }
1595
1596     t->err = NULL;
1597  err:
1598     OPENSSL_free(encode_out);
1599     OPENSSL_free(decode_out);
1600     EVP_ENCODE_CTX_free(decode_ctx);
1601     return 1;
1602 }
1603
1604 static const EVP_TEST_METHOD encode_test_method = {
1605     "Encoding",
1606     encode_test_init,
1607     encode_test_cleanup,
1608     encode_test_parse,
1609     encode_test_run,
1610 };
1611
1612 /**
1613 ***  KDF TESTS
1614 **/
1615
1616 typedef struct kdf_data_st {
1617     /* Context for this operation */
1618     EVP_PKEY_CTX *ctx;
1619     /* Expected output */
1620     unsigned char *output;
1621     size_t output_len;
1622 } KDF_DATA;
1623
1624 /*
1625  * Perform public key operation setup: lookup key, allocated ctx and call
1626  * the appropriate initialisation function
1627  */
1628 static int kdf_test_init(EVP_TEST *t, const char *name)
1629 {
1630     KDF_DATA *kdata;
1631
1632     if (!TEST_ptr(kdata = OPENSSL_zalloc(sizeof(*kdata))))
1633         return 0;
1634     kdata->ctx = EVP_PKEY_CTX_new_id(OBJ_sn2nid(name), NULL);
1635     if (kdata->ctx == NULL)
1636         return 0;
1637     if (EVP_PKEY_derive_init(kdata->ctx) <= 0)
1638         return 0;
1639     t->data = kdata;
1640     return 1;
1641 }
1642
1643 static void kdf_test_cleanup(EVP_TEST *t)
1644 {
1645     KDF_DATA *kdata = t->data;
1646     OPENSSL_free(kdata->output);
1647     EVP_PKEY_CTX_free(kdata->ctx);
1648 }
1649
1650 static int kdf_test_parse(EVP_TEST *t,
1651                           const char *keyword, const char *value)
1652 {
1653     KDF_DATA *kdata = t->data;
1654
1655     if (strcmp(keyword, "Output") == 0)
1656         return parse_bin(value, &kdata->output, &kdata->output_len);
1657     if (strncmp(keyword, "Ctrl", 4) == 0)
1658         return pkey_test_ctrl(t, kdata->ctx, value);
1659     return 0;
1660 }
1661
1662 static int kdf_test_run(EVP_TEST *t)
1663 {
1664     KDF_DATA *expected = t->data;
1665     unsigned char *got = NULL;
1666     size_t got_len = expected->output_len;
1667
1668     if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
1669         t->err = "INTERNAL_ERROR";
1670         goto err;
1671     }
1672     if (EVP_PKEY_derive(expected->ctx, got, &got_len) <= 0) {
1673         t->err = "KDF_DERIVE_ERROR";
1674         goto err;
1675     }
1676     if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
1677         t->err = "KDF_MISMATCH";
1678         goto err;
1679     }
1680     t->err = NULL;
1681
1682  err:
1683     OPENSSL_free(got);
1684     return 1;
1685 }
1686
1687 static const EVP_TEST_METHOD kdf_test_method = {
1688     "KDF",
1689     kdf_test_init,
1690     kdf_test_cleanup,
1691     kdf_test_parse,
1692     kdf_test_run
1693 };
1694
1695
1696 /**
1697 ***  KEYPAIR TESTS
1698 **/
1699
1700 typedef struct keypair_test_data_st {
1701     EVP_PKEY *privk;
1702     EVP_PKEY *pubk;
1703 } KEYPAIR_TEST_DATA;
1704
1705 static int keypair_test_init(EVP_TEST *t, const char *pair)
1706 {
1707     KEYPAIR_TEST_DATA *data;
1708     int rv = 0;
1709     EVP_PKEY *pk = NULL, *pubk = NULL;
1710     char *pub, *priv = NULL;
1711
1712     /* Split private and public names. */
1713     if (!TEST_ptr(priv = OPENSSL_strdup(pair))
1714             || !TEST_ptr(pub = strchr(priv, ':'))) {
1715         t->err = "PARSING_ERROR";
1716         goto end;
1717     }
1718     *pub++ = '\0';
1719
1720     if (!TEST_true(find_key(&pk, priv, private_keys))) {
1721         TEST_info("Can't find private key: %s", priv);
1722         t->err = "MISSING_PRIVATE_KEY";
1723         goto end;
1724     }
1725     if (!TEST_true(find_key(&pubk, pub, public_keys))) {
1726         TEST_info("Can't find public key: %s", pub);
1727         t->err = "MISSING_PUBLIC_KEY";
1728         goto end;
1729     }
1730
1731     if (pk == NULL && pubk == NULL) {
1732         /* Both keys are listed but unsupported: skip this test */
1733         t->skip = 1;
1734         rv = 1;
1735         goto end;
1736     }
1737
1738     if (!TEST_ptr(data = OPENSSL_malloc(sizeof(*data))))
1739         goto end;
1740     data->privk = pk;
1741     data->pubk = pubk;
1742     t->data = data;
1743     rv = 1;
1744     t->err = NULL;
1745
1746 end:
1747     OPENSSL_free(priv);
1748     return rv;
1749 }
1750
1751 static void keypair_test_cleanup(EVP_TEST *t)
1752 {
1753     OPENSSL_free(t->data);
1754     t->data = NULL;
1755 }
1756
1757 /*
1758  * For tests that do not accept any custom keywords.
1759  */
1760 static int void_test_parse(EVP_TEST *t, const char *keyword, const char *value)
1761 {
1762     return 0;
1763 }
1764
1765 static int keypair_test_run(EVP_TEST *t)
1766 {
1767     int rv = 0;
1768     const KEYPAIR_TEST_DATA *pair = t->data;
1769
1770     if (pair->privk == NULL || pair->pubk == NULL) {
1771         /*
1772          * this can only happen if only one of the keys is not set
1773          * which means that one of them was unsupported while the
1774          * other isn't: hence a key type mismatch.
1775          */
1776         t->err = "KEYPAIR_TYPE_MISMATCH";
1777         rv = 1;
1778         goto end;
1779     }
1780
1781     if ((rv = EVP_PKEY_cmp(pair->privk, pair->pubk)) != 1 ) {
1782         if ( 0 == rv ) {
1783             t->err = "KEYPAIR_MISMATCH";
1784         } else if ( -1 == rv ) {
1785             t->err = "KEYPAIR_TYPE_MISMATCH";
1786         } else if ( -2 == rv ) {
1787             t->err = "UNSUPPORTED_KEY_COMPARISON";
1788         } else {
1789             TEST_error("Unexpected error in key comparison");
1790             rv = 0;
1791             goto end;
1792         }
1793         rv = 1;
1794         goto end;
1795     }
1796
1797     rv = 1;
1798     t->err = NULL;
1799
1800 end:
1801     return rv;
1802 }
1803
1804 static const EVP_TEST_METHOD keypair_test_method = {
1805     "PrivPubKeyPair",
1806     keypair_test_init,
1807     keypair_test_cleanup,
1808     void_test_parse,
1809     keypair_test_run
1810 };
1811
1812
1813 /**
1814 ***  DIGEST SIGN+VERIFY TESTS
1815 **/
1816
1817 typedef struct {
1818     int is_verify; /* Set to 1 if verifying */
1819     int is_oneshot; /* Set to 1 for one shot operation */
1820     const EVP_MD *md; /* Digest to use */
1821     EVP_MD_CTX *ctx; /* Digest context */
1822     EVP_PKEY_CTX *pctx;
1823     STACK_OF(EVP_TEST_BUFFER) *input; /* Input data: streaming */
1824     unsigned char *osin; /* Input data if one shot */
1825     size_t osin_len; /* Input length data if one shot */
1826     unsigned char *output; /* Expected output */
1827     size_t output_len; /* Expected output length */
1828 } DIGESTSIGN_DATA;
1829
1830 static int digestsigver_test_init(EVP_TEST *t, const char *alg, int is_verify,
1831                                   int is_oneshot)
1832 {
1833     const EVP_MD *md = NULL;
1834     DIGESTSIGN_DATA *mdat;
1835
1836     if (strcmp(alg, "NULL") != 0) {
1837         if ((md = EVP_get_digestbyname(alg)) == NULL) {
1838             /* If alg has an OID assume disabled algorithm */
1839             if (OBJ_sn2nid(alg) != NID_undef || OBJ_ln2nid(alg) != NID_undef) {
1840                 t->skip = 1;
1841                 return 1;
1842             }
1843             return 0;
1844         }
1845     }
1846     if (!TEST_ptr(mdat = OPENSSL_zalloc(sizeof(*mdat))))
1847         return 0;
1848     mdat->md = md;
1849     if (!TEST_ptr(mdat->ctx = EVP_MD_CTX_new())) {
1850         OPENSSL_free(mdat);
1851         return 0;
1852     }
1853     mdat->is_verify = is_verify;
1854     mdat->is_oneshot = is_oneshot;
1855     t->data = mdat;
1856     return 1;
1857 }
1858
1859 static int digestsign_test_init(EVP_TEST *t, const char *alg)
1860 {
1861     return digestsigver_test_init(t, alg, 0, 0);
1862 }
1863
1864 static void digestsigver_test_cleanup(EVP_TEST *t)
1865 {
1866     DIGESTSIGN_DATA *mdata = t->data;
1867
1868     EVP_MD_CTX_free(mdata->ctx);
1869     sk_EVP_TEST_BUFFER_pop_free(mdata->input, evp_test_buffer_free);
1870     OPENSSL_free(mdata->osin);
1871     OPENSSL_free(mdata->output);
1872     OPENSSL_free(mdata);
1873     t->data = NULL;
1874 }
1875
1876 static int digestsigver_test_parse(EVP_TEST *t,
1877                                    const char *keyword, const char *value)
1878 {
1879     DIGESTSIGN_DATA *mdata = t->data;
1880
1881     if (strcmp(keyword, "Key") == 0) {
1882         EVP_PKEY *pkey = NULL;
1883         int rv = 0;
1884
1885         if (mdata->is_verify)
1886             rv = find_key(&pkey, value, public_keys);
1887         if (rv == 0)
1888             rv = find_key(&pkey, value, private_keys);
1889         if (rv == 0 || pkey == NULL) {
1890             t->skip = 1;
1891             return 1;
1892         }
1893         if (mdata->is_verify) {
1894             if (!EVP_DigestVerifyInit(mdata->ctx, &mdata->pctx, mdata->md,
1895                                       NULL, pkey))
1896                 t->err = "DIGESTVERIFYINIT_ERROR";
1897             return 1;
1898         }
1899         if (!EVP_DigestSignInit(mdata->ctx, &mdata->pctx, mdata->md, NULL,
1900                                 pkey))
1901             t->err = "DIGESTSIGNINIT_ERROR";
1902         return 1;
1903     }
1904
1905     if (strcmp(keyword, "Input") == 0) {
1906         if (mdata->is_oneshot)
1907             return parse_bin(value, &mdata->osin, &mdata->osin_len);
1908         return evp_test_buffer_append(value, &mdata->input);
1909     }
1910     if (strcmp(keyword, "Output") == 0)
1911         return parse_bin(value, &mdata->output, &mdata->output_len);
1912
1913     if (!mdata->is_oneshot) {
1914         if (strcmp(keyword, "Count") == 0)
1915             return evp_test_buffer_set_count(value, mdata->input);
1916         if (strcmp(keyword, "Ncopy") == 0)
1917             return evp_test_buffer_ncopy(value, mdata->input);
1918     }
1919     if (strcmp(keyword, "Ctrl") == 0) {
1920         if (mdata->pctx == NULL)
1921             return 0;
1922         return pkey_test_ctrl(t, mdata->pctx, value);
1923     }
1924     return 0;
1925 }
1926
1927 static int digestsign_update_fn(void *ctx, const unsigned char *buf,
1928                                 size_t buflen)
1929 {
1930     return EVP_DigestSignUpdate(ctx, buf, buflen);
1931 }
1932
1933 static int digestsign_test_run(EVP_TEST *t)
1934 {
1935     DIGESTSIGN_DATA *expected = t->data;
1936     unsigned char *got = NULL;
1937     size_t got_len;
1938
1939     if (!evp_test_buffer_do(expected->input, digestsign_update_fn,
1940                             expected->ctx)) {
1941         t->err = "DIGESTUPDATE_ERROR";
1942         goto err;
1943     }
1944
1945     if (!EVP_DigestSignFinal(expected->ctx, NULL, &got_len)) {
1946         t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";
1947         goto err;
1948     }
1949     if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
1950         t->err = "MALLOC_FAILURE";
1951         goto err;
1952     }
1953     if (!EVP_DigestSignFinal(expected->ctx, got, &got_len)) {
1954         t->err = "DIGESTSIGNFINAL_ERROR";
1955         goto err;
1956     }
1957     if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
1958         t->err = "SIGNATURE_MISMATCH";
1959         goto err;
1960     }
1961
1962  err:
1963     OPENSSL_free(got);
1964     return 1;
1965 }
1966
1967 static const EVP_TEST_METHOD digestsign_test_method = {
1968     "DigestSign",
1969     digestsign_test_init,
1970     digestsigver_test_cleanup,
1971     digestsigver_test_parse,
1972     digestsign_test_run
1973 };
1974
1975 static int digestverify_test_init(EVP_TEST *t, const char *alg)
1976 {
1977     return digestsigver_test_init(t, alg, 1, 0);
1978 }
1979
1980 static int digestverify_update_fn(void *ctx, const unsigned char *buf,
1981                                   size_t buflen)
1982 {
1983     return EVP_DigestVerifyUpdate(ctx, buf, buflen);
1984 }
1985
1986 static int digestverify_test_run(EVP_TEST *t)
1987 {
1988     DIGESTSIGN_DATA *mdata = t->data;
1989
1990     if (!evp_test_buffer_do(mdata->input, digestverify_update_fn, mdata->ctx)) {
1991         t->err = "DIGESTUPDATE_ERROR";
1992         return 1;
1993     }
1994
1995     if (EVP_DigestVerifyFinal(mdata->ctx, mdata->output,
1996                               mdata->output_len) <= 0)
1997         t->err = "VERIFY_ERROR";
1998     return 1;
1999 }
2000
2001 static const EVP_TEST_METHOD digestverify_test_method = {
2002     "DigestVerify",
2003     digestverify_test_init,
2004     digestsigver_test_cleanup,
2005     digestsigver_test_parse,
2006     digestverify_test_run
2007 };
2008
2009 static int oneshot_digestsign_test_init(EVP_TEST *t, const char *alg)
2010 {
2011     return digestsigver_test_init(t, alg, 0, 1);
2012 }
2013
2014 static int oneshot_digestsign_test_run(EVP_TEST *t)
2015 {
2016     DIGESTSIGN_DATA *expected = t->data;
2017     unsigned char *got = NULL;
2018     size_t got_len;
2019
2020     if (!EVP_DigestSign(expected->ctx, NULL, &got_len,
2021                         expected->osin, expected->osin_len)) {
2022         t->err = "DIGESTSIGN_LENGTH_ERROR";
2023         goto err;
2024     }
2025     if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
2026         t->err = "MALLOC_FAILURE";
2027         goto err;
2028     }
2029     if (!EVP_DigestSign(expected->ctx, got, &got_len,
2030                         expected->osin, expected->osin_len)) {
2031         t->err = "DIGESTSIGN_ERROR";
2032         goto err;
2033     }
2034     if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
2035         t->err = "SIGNATURE_MISMATCH";
2036         goto err;
2037     }
2038
2039  err:
2040     OPENSSL_free(got);
2041     return 1;
2042 }
2043
2044 static const EVP_TEST_METHOD oneshot_digestsign_test_method = {
2045     "OneShotDigestSign",
2046     oneshot_digestsign_test_init,
2047     digestsigver_test_cleanup,
2048     digestsigver_test_parse,
2049     oneshot_digestsign_test_run
2050 };
2051
2052 static int oneshot_digestverify_test_init(EVP_TEST *t, const char *alg)
2053 {
2054     return digestsigver_test_init(t, alg, 1, 1);
2055 }
2056
2057 static int oneshot_digestverify_test_run(EVP_TEST *t)
2058 {
2059     DIGESTSIGN_DATA *mdata = t->data;
2060
2061     if (EVP_DigestVerify(mdata->ctx, mdata->output, mdata->output_len,
2062                          mdata->osin, mdata->osin_len) <= 0)
2063         t->err = "VERIFY_ERROR";
2064     return 1;
2065 }
2066
2067 static const EVP_TEST_METHOD oneshot_digestverify_test_method = {
2068     "OneShotDigestVerify",
2069     oneshot_digestverify_test_init,
2070     digestsigver_test_cleanup,
2071     digestsigver_test_parse,
2072     oneshot_digestverify_test_run
2073 };
2074
2075
2076 /**
2077 ***  PARSING AND DISPATCH
2078 **/
2079
2080 static const EVP_TEST_METHOD *evp_test_list[] = {
2081     &cipher_test_method,
2082     &digest_test_method,
2083     &digestsign_test_method,
2084     &digestverify_test_method,
2085     &encode_test_method,
2086     &kdf_test_method,
2087     &keypair_test_method,
2088     &mac_test_method,
2089     &oneshot_digestsign_test_method,
2090     &oneshot_digestverify_test_method,
2091     &pbe_test_method,
2092     &pdecrypt_test_method,
2093     &pderive_test_method,
2094     &psign_test_method,
2095     &pverify_recover_test_method,
2096     &pverify_test_method,
2097     NULL
2098 };
2099
2100 static const EVP_TEST_METHOD *find_test(const char *name)
2101 {
2102     const EVP_TEST_METHOD **tt;
2103
2104     for (tt = evp_test_list; *tt; tt++) {
2105         if (strcmp(name, (*tt)->name) == 0)
2106             return *tt;
2107     }
2108     return NULL;
2109 }
2110
2111 static void clear_test(EVP_TEST *t)
2112 {
2113     ERR_clear_error();
2114     if (t->data != NULL) {
2115         if (t->meth != NULL)
2116             t->meth->cleanup(t);
2117         OPENSSL_free(t->data);
2118         t->data = NULL;
2119     }
2120     OPENSSL_free(t->expected_err);
2121     t->expected_err = NULL;
2122     OPENSSL_free(t->func);
2123     t->func = NULL;
2124     OPENSSL_free(t->reason);
2125     t->reason = NULL;
2126     /* Text literal. */
2127     t->err = NULL;
2128     t->skip = 0;
2129     t->meth = NULL;
2130 }
2131
2132 /*
2133  * Check for errors in the test structure; return 1 if okay, else 0.
2134  */
2135 static int check_test_error(EVP_TEST *t)
2136 {
2137     unsigned long err;
2138     const char *func;
2139     const char *reason;
2140
2141     if (t->err == NULL && t->expected_err == NULL)
2142         return 1;
2143     if (t->err != NULL && t->expected_err == NULL) {
2144         if (t->aux_err != NULL) {
2145             TEST_info("Above error from the test at %s:%d "
2146                       "(%s) unexpected error %s",
2147                       current_test_file, t->start_line, t->aux_err, t->err);
2148         } else {
2149             TEST_info("Above error from the test at %s:%d "
2150                       "unexpected error %s",
2151                       current_test_file, t->start_line, t->err);
2152         }
2153         return 0;
2154     }
2155     if (t->err == NULL && t->expected_err != NULL) {
2156         TEST_info("Test line %d: succeeded but was expecting %s",
2157                   t->start_line, t->expected_err);
2158         return 0;
2159     }
2160
2161     if (strcmp(t->err, t->expected_err) != 0) {
2162         TEST_info("Test line %d: expecting %s got %s",
2163                   t->start_line, t->expected_err, t->err);
2164         return 0;
2165     }
2166
2167     if (t->func == NULL && t->reason == NULL)
2168         return 1;
2169
2170     if (t->func == NULL || t->reason == NULL) {
2171         TEST_info("Test line %d: missing function or reason code",
2172                   t->start_line);
2173         return 0;
2174     }
2175
2176     err = ERR_peek_error();
2177     if (err == 0) {
2178         TEST_info("Test line %d, expected error \"%s:%s\" not set",
2179                   t->start_line, t->func, t->reason);
2180         return 0;
2181     }
2182
2183     func = ERR_func_error_string(err);
2184     reason = ERR_reason_error_string(err);
2185     if (func == NULL && reason == NULL) {
2186         TEST_info("Test line %d: expected error \"%s:%s\","
2187                   " no strings available.  Skipping...\n",
2188                   t->start_line, t->func, t->reason);
2189         return 1;
2190     }
2191
2192     if (strcmp(func, t->func) == 0 && strcmp(reason, t->reason) == 0)
2193         return 1;
2194
2195     TEST_info("Test line %d: expected error \"%s:%s\", got \"%s:%s\"",
2196               t->start_line, t->func, t->reason, func, reason);
2197
2198     return 0;
2199 }
2200
2201 /*
2202  * Run a parsed test. Log a message and return 0 on error.
2203  */
2204 static int run_test(EVP_TEST *t)
2205 {
2206     if (t->meth == NULL)
2207         return 1;
2208     t->ntests++;
2209     if (t->skip) {
2210         t->nskip++;
2211     } else {
2212         /* run the test */
2213         if (t->err == NULL && t->meth->run_test(t) != 1) {
2214             TEST_info("Line %d error %s", t->start_line, t->meth->name);
2215             return 0;
2216         }
2217         if (!check_test_error(t)) {
2218             test_openssl_errors();
2219             t->errors++;
2220         }
2221     }
2222
2223     /* clean it up */
2224     return 1;
2225 }
2226
2227 static int find_key(EVP_PKEY **ppk, const char *name, KEY_LIST *lst)
2228 {
2229     for (; lst != NULL; lst = lst->next) {
2230         if (strcmp(lst->name, name) == 0) {
2231             if (ppk != NULL)
2232                 *ppk = lst->key;
2233             return 1;
2234         }
2235     }
2236     return 0;
2237 }
2238
2239 static void free_key_list(KEY_LIST *lst)
2240 {
2241     while (lst != NULL) {
2242         KEY_LIST *next = lst->next;
2243
2244         EVP_PKEY_free(lst->key);
2245         OPENSSL_free(lst->name);
2246         OPENSSL_free(lst);
2247         lst = next;
2248     }
2249 }
2250
2251
2252 /*
2253  * Read a line, remove the newline, return EOF or first char.
2254  * Comment lines are treated like empty lines.
2255  */
2256 static int read_line(EVP_TEST *t)
2257 {
2258     char *p;
2259
2260     if (!BIO_gets(t->in, t->buf, sizeof(t->buf)))
2261         return EOF;
2262     t->line++;
2263     if ((p = strchr(t->buf, '\n')) != NULL)
2264         *p = '\0';
2265     if (t->buf[0] == '#')
2266         t->buf[0] = '\0';
2267     return t->buf[0];
2268 }
2269
2270 /*
2271  * Skip leading spaces and remove trailing spaces from string.
2272  */
2273 static char *strip_spaces(char *pval)
2274 {
2275     char *p, *start;
2276
2277     for (start = pval; isspace(*start); )
2278         start++;
2279     if (*start == '\0')
2280         return start;
2281
2282     for (p = start + strlen(start); --p >= start && isspace(*p); )
2283         *p = '\0';
2284     return start;
2285 }
2286
2287 /*
2288  * Split line into 'key = value'; return 1 if okay, 0 on error.
2289  */
2290 static int split_line(EVP_TEST *t, char **keyword, char **value)
2291 {
2292     char *p;
2293
2294     /* Look for = sign */
2295     if ((p = strchr(t->buf, '=')) == NULL) {
2296         TEST_error("Line %d: Missing '=' in test file", t->line);
2297         return 0;
2298     }
2299     *p++ = '\0';
2300     *keyword = strip_spaces(t->buf);
2301     *value = strip_spaces(p);
2302     if (**keyword == '\0') {
2303         TEST_error("Line %d: Missing key; malformed input line", t->line);
2304         return 0;
2305     }
2306     return 1;
2307 }
2308
2309 /*
2310  * Read a PEM block.  Return 1 if okay, 0 on error.
2311  */
2312 static int read_key(EVP_TEST *t)
2313 {
2314     char tmpbuf[128];
2315
2316     if (t->key == NULL) {
2317         if (!TEST_ptr(t->key = BIO_new(BIO_s_mem())))
2318             return 0;
2319     } else if (!TEST_int_gt(BIO_reset(t->key), 0)) {
2320         return 0;
2321     }
2322
2323     /* Read to PEM end line and place content in memory BIO */
2324     while (BIO_gets(t->in, tmpbuf, sizeof(tmpbuf))) {
2325         t->line++;
2326         if (!TEST_int_gt(BIO_puts(t->key, tmpbuf), 0))
2327             return 0;
2328         if (strncmp(tmpbuf, "-----END", 8) == 0)
2329             return 1;
2330     }
2331     TEST_error("Can't find key end");
2332     return 0;
2333 }
2334
2335 /*
2336  * Is the key type an unsupported algorithm?
2337  */
2338 static int key_unsupported()
2339 {
2340     long err = ERR_peek_error();
2341
2342     if (ERR_GET_LIB(err) == ERR_LIB_EVP
2343             && ERR_GET_REASON(err) == EVP_R_UNSUPPORTED_ALGORITHM) {
2344         ERR_clear_error();
2345         return 1;
2346     }
2347 #ifndef OPENSSL_NO_EC
2348     /*
2349      * If EC support is enabled we should catch also EC_R_UNKNOWN_GROUP as an
2350      * hint to an unsupported algorithm/curve (e.g. if binary EC support is
2351      * disabled).
2352      */
2353     if (ERR_GET_LIB(err) == ERR_LIB_EC
2354         && ERR_GET_REASON(err) == EC_R_UNKNOWN_GROUP) {
2355         ERR_clear_error();
2356         return 1;
2357     }
2358 #endif /* OPENSSL_NO_EC */
2359     return 0;
2360 }
2361
2362 /*
2363  * Read, parse, and execute one test.  Return EOF; 0 if failure, 1 if okay.
2364  */
2365 static int read_stanza(EVP_TEST *t)
2366 {
2367     int c;
2368     char *keyword, *value;
2369     KEY_LIST **klist, *key;
2370     EVP_PKEY *pkey;
2371
2372     clear_test(t);
2373 top:
2374     /* Find the first line of a stanza. */
2375     for ( ; ; ) {
2376         c = read_line(t);
2377         if (c == EOF)
2378             return EOF;
2379         if (c == '\0')
2380             continue;
2381         break;
2382     }
2383     if (!split_line(t, &keyword, &value))
2384         return 0;
2385
2386     /* Handle a few special cases here. */
2387     if (strcmp(keyword, "Title") == 0) {
2388         TEST_info("Starting \"%s\" tests", value);
2389         goto top;
2390     }
2391
2392     klist = NULL;
2393     pkey = NULL;
2394     if (strcmp(keyword, "PrivateKey") == 0) {
2395         if (!read_key(t))
2396             return 0;
2397         pkey = PEM_read_bio_PrivateKey(t->key, NULL, 0, NULL);
2398         if (pkey == NULL && !key_unsupported()) {
2399             TEST_info("Can't read private key %s", value);
2400             ERR_print_errors_fp(stderr);
2401             return 0;
2402         }
2403         klist = &private_keys;
2404     }
2405     else if (strcmp(keyword, "PublicKey") == 0) {
2406         if (!read_key(t))
2407             return 0;
2408         pkey = PEM_read_bio_PUBKEY(t->key, NULL, 0, NULL);
2409         if (pkey == NULL && !key_unsupported()) {
2410             TEST_info("Can't read public key %s", value);
2411             ERR_print_errors_fp(stderr);
2412             return 0;
2413         }
2414         klist = &public_keys;
2415     }
2416
2417     /* If we have a key add to list */
2418     if (klist != NULL) {
2419         if (find_key(NULL, value, *klist)) {
2420             TEST_info("Duplicate key %s", value);
2421             return 0;
2422         }
2423         if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key)))
2424                 || !TEST_ptr(key->name = OPENSSL_strdup(value)))
2425             return 0;
2426         key->key = pkey;
2427         key->next = *klist;
2428         *klist = key;
2429
2430         /* Go back and start a new stanza. */
2431         goto top;
2432     }
2433
2434     /* Start of a new text.  Look it up. */
2435     if (!TEST_ptr(t->meth = find_test(keyword)))
2436         goto skiptoend;
2437     t->start_line = t->line;
2438     if (!t->meth->init(t, value)) {
2439         TEST_error("unknown %s: %s\n", keyword, value);
2440         goto skiptoend;
2441     }
2442     if (t->skip == 1) {
2443         /* TEST_info("skipping %s %s", keyword, value); */
2444         goto skiptoend;
2445     }
2446
2447     /* Read rest of stanza. */
2448     for ( ; ; ) {
2449         c = read_line(t);
2450         if (c == EOF)
2451             return c;
2452         if (c == '\0')
2453             break;
2454         if (!split_line(t, &keyword, &value))
2455             goto skiptoend;
2456         if (strcmp(keyword, "Result") == 0) {
2457             if (t->expected_err != NULL) {
2458                 TEST_info("Line %d: multiple result lines", t->line);
2459                 goto skiptoend;
2460             }
2461             if (!TEST_ptr(t->expected_err = OPENSSL_strdup(value)))
2462                 goto skiptoend;
2463         } else if (strcmp(keyword, "Function") == 0) {
2464             if (t->func != NULL) {
2465                 TEST_info("Line %d: multiple function lines\n", t->line);
2466                 goto skiptoend;
2467             }
2468             if (!TEST_ptr(t->func = OPENSSL_strdup(value)))
2469                 goto skiptoend;
2470         } else if (strcmp(keyword, "Reason") == 0) {
2471             if (t->reason != NULL) {
2472                 TEST_info("Line %d: multiple reason lines", t->line);
2473                 goto skiptoend;
2474             }
2475             if (!TEST_ptr(t->reason = OPENSSL_strdup(value)))
2476                 goto skiptoend;
2477         } else {
2478             /* Must be test specific line: try to parse it */
2479             int rv = t->meth->parse(t, keyword, value);
2480
2481             if (rv == 0) {
2482                 TEST_info("Line %d: unknown keyword %s", t->line, keyword);
2483                 goto skiptoend;
2484             }
2485             if (rv < 0) {
2486                 TEST_info("Line %d: error processing keyword %s\n",
2487                         t->line, keyword);
2488                 goto skiptoend;
2489             }
2490         }
2491     }
2492
2493     return 1;
2494
2495 skiptoend:
2496     /* Read to end of stanza and return failure */
2497     for ( ; ; ) {
2498         c = read_line(t);
2499         if (c == EOF)
2500             return EOF;
2501         if (c == '\0')
2502             break;
2503     }
2504     return 0;
2505 }
2506
2507 static int do_test_file(const char *testfile)
2508 {
2509     BIO *in;
2510     EVP_TEST t;
2511     int c;
2512
2513     set_test_title(testfile);
2514     current_test_file = testfile;
2515     if (!TEST_ptr(in = BIO_new_file(testfile, "rb")))
2516         return 0;
2517     memset(&t, 0, sizeof(t));
2518     t.in = in;
2519
2520     TEST_info("Reading %s", testfile);
2521     for ( ; ; ) {
2522         c = read_stanza(&t);
2523         if (t.skip)
2524             continue;
2525         if (c == 0 || !run_test(&t)) {
2526             t.errors++;
2527             break;
2528         }
2529         if (c == EOF)
2530             break;
2531     }
2532     clear_test(&t);
2533
2534     TEST_info("Completed %d tests with %d errors and %d skipped",
2535               t.ntests, t.errors, t.nskip);
2536     free_key_list(public_keys);
2537     free_key_list(private_keys);
2538     BIO_free(t.key);
2539     BIO_free(in);
2540     return t.errors == 0;
2541 }
2542
2543 static char * const *testfiles;
2544
2545 static int run_file_tests(int i)
2546 {
2547     return do_test_file(testfiles[i]);
2548 }
2549
2550 int test_main(int argc, char *argv[])
2551 {
2552     if (argc < 2) {
2553         TEST_error("Usage: %s file...", argv[0]);
2554         return 0;
2555     }
2556     testfiles = &argv[1];
2557
2558     ADD_ALL_TESTS(run_file_tests, argc - 1);
2559
2560     return run_tests(argv[0]);
2561 }