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