X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=test%2Fevp_test.c;h=e7396f7b2aab2d96dd3440c57b5e508bddf6fadf;hb=76e0d0b21cc4e8a879d54f4d78a392826dadb1d1;hp=90441f36fa2c84b9cdb8f458cd7b845c23bbbb28;hpb=351fe21402496dfdb2673a610162519b80991665;p=oweals%2Fopenssl.git diff --git a/test/evp_test.c b/test/evp_test.c index 90441f36fa..e7396f7b2a 100644 --- a/test/evp_test.c +++ b/test/evp_test.c @@ -1,55 +1,10 @@ -/* evp_test.c */ /* - * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL - * project. - */ -/* ==================================================================== - * Copyright (c) 2015 The OpenSSL Project. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * - * 3. All advertising materials mentioning features or use of this - * software must display the following acknowledgment: - * "This product includes software developed by the OpenSSL Project - * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" - * - * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For written permission, please contact - * licensing@OpenSSL.org. + * Copyright 2015-2017 The OpenSSL Project Authors. All Rights Reserved. * - * 5. Products derived from this software may not be called "OpenSSL" - * nor may "OpenSSL" appear in their names without prior written - * permission of the OpenSSL Project. - * - * 6. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by the OpenSSL Project - * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" - * - * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY - * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR - * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED - * OF THE POSSIBILITY OF SUCH DAMAGE. - * ==================================================================== + * Licensed under the OpenSSL license (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html */ #include @@ -61,23 +16,24 @@ #include #include #include +#include #include "internal/numbers.h" /* Remove spaces from beginning and end of a string */ static void remove_space(char **pval) { - unsigned char *p = (unsigned char *)*pval; + unsigned char *p = (unsigned char *)*pval, *beginning; while (isspace(*p)) p++; - *pval = (char *)p; + *pval = (char *)(beginning = p); p = p + strlen(*pval) - 1; /* Remove trailing space */ - while (isspace(*p)) + while (p >= beginning && isspace(*p)) *p-- = 0; } @@ -124,12 +80,62 @@ static int parse_line(char **pkw, char **pval, char *linebuf) return 1; } +/* + * Unescape some escape sequences in string literals. + * Return the result in a newly allocated buffer. + * Currently only supports '\n'. + * If the input length is 0, returns a valid 1-byte buffer, but sets + * the length to 0. + */ +static unsigned char* unescape(const char *input, size_t input_len, + size_t *out_len) +{ + unsigned char *ret, *p; + size_t i; + if (input_len == 0) { + *out_len = 0; + return OPENSSL_zalloc(1); + } + + /* Escaping is non-expanding; over-allocate original size for simplicity. */ + ret = p = OPENSSL_malloc(input_len); + if (ret == NULL) + return NULL; + + for (i = 0; i < input_len; i++) { + if (input[i] == '\\') { + if (i == input_len - 1 || input[i+1] != 'n') + goto err; + *p++ = '\n'; + i++; + } else { + *p++ = input[i]; + } + } + + *out_len = p - ret; + return ret; + + err: + OPENSSL_free(ret); + return NULL; +} + /* For a hex string "value" convert to a binary allocated buffer */ static int test_bin(const char *value, unsigned char **buf, size_t *buflen) { long len; + + *buflen = 0; + + /* Check for empty value */ if (!*value) { - /* Don't return NULL for zero length buffer */ + /* + * Don't return NULL for zero length buffer. + * This is needed for some tests with empty keys: HMAC_Init_ex() expects + * a non-NULL key buffer even if the key length is 0, in order to detect + * key reset. + */ *buf = OPENSSL_malloc(1); if (!*buf) return 0; @@ -137,6 +143,14 @@ static int test_bin(const char *value, unsigned char **buf, size_t *buflen) *buflen = 0; return 1; } + + /* Check for NULL literal */ + if (strcmp(value, "NULL") == 0) { + *buf = NULL; + *buflen = 0; + return 1; + } + /* Check for string literal */ if (value[0] == '"') { size_t vlen; @@ -145,20 +159,14 @@ static int test_bin(const char *value, unsigned char **buf, size_t *buflen) if (value[vlen - 1] != '"') return 0; vlen--; - if (vlen == 0) { - *buf = OPENSSL_malloc(1); - if (*buf == NULL) - return 0; - **buf = 0; - } else { - *buf = BUF_memdup(value, vlen); - if (*buf == NULL) - return 0; - } - *buflen = vlen; + *buf = unescape(value, vlen, buflen); + if (*buf == NULL) + return 0; return 1; } - *buf = string_to_hex(value, &len); + + /* Otherwise assume as hex literal and convert it to binary buffer */ + *buf = OPENSSL_hexstr2buf(value, &len); if (!*buf) { fprintf(stderr, "Value=%s\n", value); ERR_print_errors_fp(stderr); @@ -168,6 +176,8 @@ static int test_bin(const char *value, unsigned char **buf, size_t *buflen) *buflen = len; return 1; } +#ifndef OPENSSL_NO_SCRYPT +/* Currently only used by scrypt tests */ /* Parse unsigned decimal 64 bit integer value */ static int test_uint64(const char *value, uint64_t *pr) { @@ -192,11 +202,14 @@ static int test_uint64(const char *value, uint64_t *pr) } return 1; } +#endif /* Structure holding test information */ struct evp_test { /* file being read */ - FILE *in; + BIO *in; + /* temp memory BIO for reading in keys */ + BIO *key; /* List of public and private keys */ struct key_list *private; struct key_list *public; @@ -207,9 +220,13 @@ struct evp_test { /* start line of current test */ unsigned int start_line; /* Error string for test */ - const char *err; + const char *err, *aux_err; /* Expected error value of test */ char *expected_err; + /* Expected error function string */ + char *func; + /* Expected error reason string */ + char *reason; /* Number of tests */ int ntests; /* Error count */ @@ -217,9 +234,10 @@ struct evp_test { /* Number of tests skipped */ int nskip; /* If output mismatch expected and got value */ - unsigned char *out_got; + unsigned char *out_received; + size_t out_received_len; unsigned char *out_expected; - size_t out_len; + size_t out_expected_len; /* test specific data */ void *data; /* Current test should be skipped */ @@ -251,7 +269,11 @@ static const struct evp_test_method mac_test_method; static const struct evp_test_method psign_test_method, pverify_test_method; static const struct evp_test_method pdecrypt_test_method; static const struct evp_test_method pverify_recover_test_method; +static const struct evp_test_method pderive_test_method; static const struct evp_test_method pbe_test_method; +static const struct evp_test_method encode_test_method; +static const struct evp_test_method kdf_test_method; +static const struct evp_test_method keypair_test_method; static const struct evp_test_method *evp_test_list[] = { &digest_test_method, @@ -261,7 +283,11 @@ static const struct evp_test_method *evp_test_list[] = { &pverify_test_method, &pdecrypt_test_method, &pverify_recover_test_method, + &pderive_test_method, &pbe_test_method, + &encode_test_method, + &kdf_test_method, + &keypair_test_method, NULL }; @@ -289,28 +315,44 @@ static void free_expected(struct evp_test *t) { OPENSSL_free(t->expected_err); t->expected_err = NULL; + OPENSSL_free(t->func); + t->func = NULL; + OPENSSL_free(t->reason); + t->reason = NULL; OPENSSL_free(t->out_expected); - OPENSSL_free(t->out_got); + OPENSSL_free(t->out_received); t->out_expected = NULL; - t->out_got = NULL; + t->out_received = NULL; + t->out_expected_len = 0; + t->out_received_len = 0; + /* Literals. */ + t->err = NULL; } static void print_expected(struct evp_test *t) { - if (t->out_expected == NULL) + if (t->out_expected == NULL && t->out_received == NULL) return; - hex_print("Expected:", t->out_expected, t->out_len); - hex_print("Got: ", t->out_got, t->out_len); + hex_print("Expected:", t->out_expected, t->out_expected_len); + hex_print("Got: ", t->out_received, t->out_received_len); free_expected(t); } static int check_test_error(struct evp_test *t) { + unsigned long err; + const char *func; + const char *reason; if (!t->err && !t->expected_err) return 1; if (t->err && !t->expected_err) { - fprintf(stderr, "Test line %d: unexpected error %s\n", - t->start_line, t->err); + if (t->aux_err != NULL) { + fprintf(stderr, "Test line %d(%s): unexpected error %s\n", + t->start_line, t->aux_err, t->err); + } else { + fprintf(stderr, "Test line %d: unexpected error %s\n", + t->start_line, t->err); + } print_expected(t); return 0; } @@ -319,11 +361,44 @@ static int check_test_error(struct evp_test *t) t->start_line, t->expected_err); return 0; } - if (strcmp(t->err, t->expected_err) == 0) + + if (strcmp(t->err, t->expected_err) != 0) { + fprintf(stderr, "Test line %d: expecting %s got %s\n", + t->start_line, t->expected_err, t->err); + return 0; + } + + if (t->func == NULL && t->reason == NULL) + return 1; + + if (t->func == NULL || t->reason == NULL) { + fprintf(stderr, "Test line %d: missing function or reason code\n", + t->start_line); + return 0; + } + + err = ERR_peek_error(); + if (err == 0) { + fprintf(stderr, "Test line %d, expected error \"%s:%s\" not set\n", + t->start_line, t->func, t->reason); + return 0; + } + + func = ERR_func_error_string(err); + reason = ERR_reason_error_string(err); + + if (func == NULL && reason == NULL) { + fprintf(stderr, "Test line %d: expected error \"%s:%s\", no strings available. Skipping...\n", + t->start_line, t->func, t->reason); + return 1; + } + + if (strcmp(func, t->func) == 0 && strcmp(reason, t->reason) == 0) return 1; - fprintf(stderr, "Test line %d: expecting %s got %s\n", - t->start_line, t->expected_err, t->err); + fprintf(stderr, "Test line %d: expected error \"%s:%s\", got \"%s:%s\"\n", + t->start_line, t->func, t->reason, func, reason); + return 0; } @@ -335,25 +410,27 @@ static int setup_test(struct evp_test *t, const struct evp_test_method *tmeth) if (t->meth) { t->ntests++; if (t->skip) { - t->meth = tmeth; t->nskip++; - return 1; - } - t->err = NULL; - if (t->meth->run_test(t) != 1) { - fprintf(stderr, "%s test error line %d\n", - t->meth->name, t->start_line); - return 0; - } - if (!check_test_error(t)) { - if (t->err) - ERR_print_errors_fp(stderr); - t->errors++; + } else { + /* run the test */ + if (t->err == NULL && t->meth->run_test(t) != 1) { + fprintf(stderr, "%s test error line %d\n", + t->meth->name, t->start_line); + return 0; + } + if (!check_test_error(t)) { + if (t->err) + ERR_print_errors_fp(stderr); + t->errors++; + } } + /* clean it up */ ERR_clear_error(); - t->meth->cleanup(t); - OPENSSL_free(t->data); - t->data = NULL; + if (t->data != NULL) { + t->meth->cleanup(t); + OPENSSL_free(t->data); + t->data = NULL; + } OPENSSL_free(t->expected_err); t->expected_err = NULL; free_expected(t); @@ -394,6 +471,44 @@ static int check_unsupported() ERR_clear_error(); return 1; } +#ifndef OPENSSL_NO_EC + /* + * If EC support is enabled we should catch also EC_R_UNKNOWN_GROUP as an + * hint to an unsupported algorithm/curve (e.g. if binary EC support is + * disabled). + */ + if (ERR_GET_LIB(err) == ERR_LIB_EC + && ERR_GET_REASON(err) == EC_R_UNKNOWN_GROUP) { + ERR_clear_error(); + return 1; + } +#endif /* OPENSSL_NO_EC */ + return 0; +} + + +static int read_key(struct evp_test *t) +{ + char tmpbuf[80]; + if (t->key == NULL) + t->key = BIO_new(BIO_s_mem()); + else if (BIO_reset(t->key) <= 0) + return 0; + if (t->key == NULL) { + fprintf(stderr, "Error allocating key memory BIO\n"); + return 0; + } + /* Read to PEM end line and place content in memory BIO */ + while (BIO_gets(t->in, tmpbuf, sizeof(tmpbuf))) { + t->line++; + if (BIO_puts(t->key, tmpbuf) <= 0) { + fprintf(stderr, "Error writing to key memory BIO\n"); + return 0; + } + if (strncmp(tmpbuf, "-----END", 8) == 0) + return 1; + } + fprintf(stderr, "Can't find key end\n"); return 0; } @@ -401,7 +516,6 @@ static int process_test(struct evp_test *t, char *buf, int verbose) { char *keyword = NULL, *value = NULL; int rv = 0, add_key = 0; - long save_pos = 0; struct key_list **lst = NULL, *key = NULL; EVP_PKEY *pk = NULL; const struct evp_test_method *tmeth = NULL; @@ -410,8 +524,9 @@ static int process_test(struct evp_test *t, char *buf, int verbose) if (!parse_line(&keyword, &value, buf)) return 1; if (strcmp(keyword, "PrivateKey") == 0) { - save_pos = ftell(t->in); - pk = PEM_read_PrivateKey(t->in, NULL, 0, NULL); + if (!read_key(t)) + return 0; + pk = PEM_read_bio_PrivateKey(t->key, NULL, 0, NULL); if (pk == NULL && !check_unsupported()) { fprintf(stderr, "Error reading private key %s\n", value); ERR_print_errors_fp(stderr); @@ -421,8 +536,9 @@ static int process_test(struct evp_test *t, char *buf, int verbose) add_key = 1; } if (strcmp(keyword, "PublicKey") == 0) { - save_pos = ftell(t->in); - pk = PEM_read_PUBKEY(t->in, NULL, 0, NULL); + if (!read_key(t)) + return 0; + pk = PEM_read_bio_PUBKEY(t->key, NULL, 0, NULL); if (pk == NULL && !check_unsupported()) { fprintf(stderr, "Error reading public key %s\n", value); ERR_print_errors_fp(stderr); @@ -433,7 +549,6 @@ static int process_test(struct evp_test *t, char *buf, int verbose) } /* If we have a key add to list */ if (add_key) { - char tmpbuf[80]; if (find_key(NULL, value, *lst)) { fprintf(stderr, "Duplicate key %s\n", value); return 0; @@ -441,19 +556,11 @@ static int process_test(struct evp_test *t, char *buf, int verbose) key = OPENSSL_malloc(sizeof(*key)); if (!key) return 0; - key->name = BUF_strdup(value); + key->name = OPENSSL_strdup(value); key->key = pk; key->next = *lst; *lst = key; - /* Rewind input, read to end and update line numbers */ - fseek(t->in, save_pos, SEEK_SET); - while (fgets(tmpbuf, sizeof(tmpbuf), t->in)) { - t->line++; - if (strncmp(tmpbuf, "-----END", 8) == 0) - return 1; - } - fprintf(stderr, "Can't find key end\n"); - return 0; + return 1; } /* See if keyword corresponds to a test start */ @@ -475,8 +582,24 @@ static int process_test(struct evp_test *t, char *buf, int verbose) fprintf(stderr, "Line %d: multiple result lines\n", t->line); return 0; } - t->expected_err = BUF_strdup(value); - if (!t->expected_err) + t->expected_err = OPENSSL_strdup(value); + if (t->expected_err == NULL) + return 0; + } else if (strcmp(keyword, "Function") == 0) { + if (t->func != NULL) { + fprintf(stderr, "Line %d: multiple function lines\n", t->line); + return 0; + } + t->func = OPENSSL_strdup(value); + if (t->func == NULL) + return 0; + } else if (strcmp(keyword, "Reason") == 0) { + if (t->reason != NULL) { + fprintf(stderr, "Line %d: multiple reason lines\n", t->line); + return 0; + } + t->reason = OPENSSL_strdup(value); + if (t->reason == NULL) return 0; } else { /* Must be test specific line: try to parse it */ @@ -496,24 +619,40 @@ static int process_test(struct evp_test *t, char *buf, int verbose) return 1; } -static int check_output(struct evp_test *t, const unsigned char *expected, - const unsigned char *got, size_t len) +static int check_var_length_output(struct evp_test *t, + const unsigned char *expected, + size_t expected_len, + const unsigned char *received, + size_t received_len) { - if (!memcmp(expected, got, len)) + if (expected_len == received_len && + memcmp(expected, received, expected_len) == 0) { return 0; - t->out_expected = BUF_memdup(expected, len); - t->out_got = BUF_memdup(got, len); - t->out_len = len; - if (t->out_expected == NULL || t->out_got == NULL) { + } + + /* The result printing code expects a non-NULL buffer. */ + t->out_expected = OPENSSL_memdup(expected, expected_len ? expected_len : 1); + t->out_expected_len = expected_len; + t->out_received = OPENSSL_memdup(received, received_len ? received_len : 1); + t->out_received_len = received_len; + if (t->out_expected == NULL || t->out_received == NULL) { fprintf(stderr, "Memory allocation error!\n"); exit(1); } return 1; } +static int check_output(struct evp_test *t, + const unsigned char *expected, + const unsigned char *received, + size_t len) +{ + return check_var_length_output(t, expected, len, received, len); +} + int main(int argc, char **argv) { - FILE *in = NULL; + BIO *in = NULL; char buf[10240]; struct evp_test t; @@ -524,24 +663,16 @@ int main(int argc, char **argv) CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON); - ERR_load_crypto_strings(); - OpenSSL_add_all_algorithms(); - memset(&t, 0, sizeof(t)); - t.meth = NULL; - t.public = NULL; - t.private = NULL; - t.err = NULL; - t.line = 0; t.start_line = -1; - t.errors = 0; - t.ntests = 0; - t.out_expected = NULL; - t.out_got = NULL; - t.out_len = 0; - in = fopen(argv[1], "r"); + in = BIO_new_file(argv[1], "rb"); + if (in == NULL) { + fprintf(stderr, "Can't open %s for reading\n", argv[1]); + return 1; + } t.in = in; - while (fgets(buf, sizeof(buf), in)) { + t.err = NULL; + while (BIO_gets(in, buf, sizeof(buf))) { t.line++; if (!process_test(&t, buf, 0)) exit(1); @@ -553,12 +684,13 @@ int main(int argc, char **argv) t.ntests, t.errors, t.nskip); free_key_list(t.public); free_key_list(t.private); - fclose(in); - EVP_cleanup(); - CRYPTO_cleanup_all_ex_data(); - ERR_remove_thread_state(NULL); - ERR_free_strings(); - CRYPTO_mem_leaks_fp(stderr); + BIO_free(t.key); + BIO_free(in); + +#ifndef OPENSSL_NO_CRYPTO_MDEBUG + if (CRYPTO_mem_leaks_fp(stderr) <= 0) + return 1; +#endif if (t.errors) return 1; return 0; @@ -587,7 +719,7 @@ struct digest_data { static int digest_test_init(struct evp_test *t, const char *alg) { const EVP_MD *digest; - struct digest_data *mdat = t->data; + struct digest_data *mdat; digest = EVP_get_digestbyname(alg); if (!digest) { /* If alg has an OID assume disabled algorithm */ @@ -639,7 +771,7 @@ static int digest_test_run(struct evp_test *t) EVP_MD_CTX *mctx; unsigned char md[EVP_MAX_MD_SIZE]; unsigned int md_len; - mctx = EVP_MD_CTX_create(); + mctx = EVP_MD_CTX_new(); if (!mctx) goto err; err = "DIGESTINIT_ERROR"; @@ -661,8 +793,7 @@ static int digest_test_run(struct evp_test *t) goto err; err = NULL; err: - if (mctx) - EVP_MD_CTX_destroy(mctx); + EVP_MD_CTX_free(mctx); t->err = err; return 1; } @@ -723,6 +854,8 @@ static int cipher_test_init(struct evp_test *t, const char *alg) || EVP_CIPHER_mode(cipher) == EVP_CIPH_OCB_MODE || EVP_CIPHER_mode(cipher) == EVP_CIPH_CCM_MODE) cdat->aead = EVP_CIPHER_mode(cipher); + else if (EVP_CIPHER_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) + cdat->aead = -1; else cdat->aead = 0; @@ -771,12 +904,13 @@ static int cipher_test_parse(struct evp_test *t, const char *keyword, return 0; } -static int cipher_test_enc(struct evp_test *t, int enc) +static int cipher_test_enc(struct evp_test *t, int enc, + size_t out_misalign, size_t inp_misalign, int frag) { struct cipher_data *cdat = t->data; unsigned char *in, *out, *tmp = NULL; - size_t in_len, out_len; - int tmplen, tmpflen; + size_t in_len, out_len, donelen = 0; + int tmplen, chunklen, tmpflen; EVP_CIPHER_CTX *ctx = NULL; const char *err; err = "INTERNAL_ERROR"; @@ -795,9 +929,31 @@ static int cipher_test_enc(struct evp_test *t, int enc) out = cdat->plaintext; out_len = cdat->plaintext_len; } - tmp = OPENSSL_malloc(in_len + 2 * EVP_MAX_BLOCK_LENGTH); - if (!tmp) - goto err; + if (inp_misalign == (size_t)-1) { + /* + * Exercise in-place encryption + */ + tmp = OPENSSL_malloc(out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH); + if (!tmp) + goto err; + in = memcpy(tmp + out_misalign, in, in_len); + } else { + inp_misalign += 16 - ((out_misalign + in_len) & 15); + /* + * 'tmp' will store both output and copy of input. We make the copy + * of input to specifically aligned part of 'tmp'. So we just + * figured out how much padding would ensure the required alignment, + * now we allocate extended buffer and finally copy the input just + * past inp_misalign in expression below. Output will be written + * past out_misalign... + */ + tmp = OPENSSL_malloc(out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH + + inp_misalign + in_len); + if (!tmp) + goto err; + in = memcpy(tmp + out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH + + inp_misalign, in, in_len); + } err = "CIPHERINIT_ERROR"; if (!EVP_CipherInit_ex(ctx, cdat->cipher, NULL, NULL, NULL, enc)) goto err; @@ -852,27 +1008,71 @@ static int cipher_test_enc(struct evp_test *t, int enc) } } if (cdat->aad) { - if (!EVP_CipherUpdate(ctx, NULL, &tmplen, cdat->aad, cdat->aad_len)) { - err = "AAD_SET_ERROR"; - goto err; + err = "AAD_SET_ERROR"; + if (!frag) { + if (!EVP_CipherUpdate(ctx, NULL, &chunklen, cdat->aad, + cdat->aad_len)) + goto err; + } else { + /* + * Supply the AAD in chunks less than the block size where possible + */ + if (cdat->aad_len > 0) { + if (!EVP_CipherUpdate(ctx, NULL, &chunklen, cdat->aad, 1)) + goto err; + donelen++; + } + if (cdat->aad_len > 2) { + if (!EVP_CipherUpdate(ctx, NULL, &chunklen, cdat->aad + donelen, + cdat->aad_len - 2)) + goto err; + donelen += cdat->aad_len - 2; + } + if (cdat->aad_len > 1 + && !EVP_CipherUpdate(ctx, NULL, &chunklen, + cdat->aad + donelen, 1)) + goto err; } } EVP_CIPHER_CTX_set_padding(ctx, 0); err = "CIPHERUPDATE_ERROR"; - if (!EVP_CipherUpdate(ctx, tmp, &tmplen, in, in_len)) - goto err; - if (cdat->aead == EVP_CIPH_CCM_MODE) - tmpflen = 0; - else { - err = "CIPHERFINAL_ERROR"; - if (!EVP_CipherFinal_ex(ctx, tmp + tmplen, &tmpflen)) + tmplen = 0; + if (!frag) { + /* We supply the data all in one go */ + if (!EVP_CipherUpdate(ctx, tmp + out_misalign, &tmplen, in, in_len)) goto err; + } else { + /* Supply the data in chunks less than the block size where possible */ + if (in_len > 0) { + if (!EVP_CipherUpdate(ctx, tmp + out_misalign, &chunklen, in, 1)) + goto err; + tmplen += chunklen; + in++; + in_len--; + } + if (in_len > 1) { + if (!EVP_CipherUpdate(ctx, tmp + out_misalign + tmplen, &chunklen, + in, in_len - 1)) + goto err; + tmplen += chunklen; + in += in_len - 1; + in_len = 1; + } + if (in_len > 0 ) { + if (!EVP_CipherUpdate(ctx, tmp + out_misalign + tmplen, &chunklen, + in, 1)) + goto err; + tmplen += chunklen; + } } + err = "CIPHERFINAL_ERROR"; + if (!EVP_CipherFinal_ex(ctx, tmp + out_misalign + tmplen, &tmpflen)) + goto err; err = "LENGTH_MISMATCH"; if (out_len != (size_t)(tmplen + tmpflen)) goto err; err = "VALUE_MISMATCH"; - if (check_output(t, out, tmp, out_len)) + if (check_output(t, out, tmp + out_misalign, out_len)) goto err; if (enc && cdat->aead) { unsigned char rtag[16]; @@ -901,7 +1101,9 @@ static int cipher_test_enc(struct evp_test *t, int enc) static int cipher_test_run(struct evp_test *t) { struct cipher_data *cdat = t->data; - int rv; + int rv, frag = 0; + size_t out_misalign, inp_misalign; + if (!cdat->key) { t->err = "NO_KEY"; return 0; @@ -917,24 +1119,60 @@ static int cipher_test_run(struct evp_test *t) t->err = "NO_TAG"; return 0; } - if (cdat->enc) { - rv = cipher_test_enc(t, 1); - /* Not fatal errors: return */ - if (rv != 1) { - if (rv < 0) - return 0; - return 1; + for (out_misalign = 0; out_misalign <= 1;) { + static char aux_err[64]; + t->aux_err = aux_err; + for (inp_misalign = (size_t)-1; inp_misalign != 2; inp_misalign++) { + if (inp_misalign == (size_t)-1) { + /* kludge: inp_misalign == -1 means "exercise in-place" */ + BIO_snprintf(aux_err, sizeof(aux_err), + "%s in-place, %sfragmented", + out_misalign ? "misaligned" : "aligned", + frag ? "" : "not "); + } else { + BIO_snprintf(aux_err, sizeof(aux_err), + "%s output and %s input, %sfragmented", + out_misalign ? "misaligned" : "aligned", + inp_misalign ? "misaligned" : "aligned", + frag ? "" : "not "); + } + if (cdat->enc) { + rv = cipher_test_enc(t, 1, out_misalign, inp_misalign, frag); + /* Not fatal errors: return */ + if (rv != 1) { + if (rv < 0) + return 0; + return 1; + } + } + if (cdat->enc != 1) { + rv = cipher_test_enc(t, 0, out_misalign, inp_misalign, frag); + /* Not fatal errors: return */ + if (rv != 1) { + if (rv < 0) + return 0; + return 1; + } + } } - } - if (cdat->enc != 1) { - rv = cipher_test_enc(t, 0); - /* Not fatal errors: return */ - if (rv != 1) { - if (rv < 0) - return 0; - return 1; + + if (out_misalign == 1 && frag == 0) { + /* + * XTS, CCM and Wrap modes have special requirements about input + * lengths so we don't fragment for those + */ + if (cdat->aead == EVP_CIPH_CCM_MODE + || EVP_CIPHER_mode(cdat->cipher) == EVP_CIPH_XTS_MODE + || EVP_CIPHER_mode(cdat->cipher) == EVP_CIPH_WRAP_MODE) + break; + out_misalign = 0; + frag++; + } else { + out_misalign++; } } + t->aux_err = NULL; + return 1; } @@ -966,11 +1204,30 @@ static int mac_test_init(struct evp_test *t, const char *alg) { int type; struct mac_data *mdat; - if (strcmp(alg, "HMAC") == 0) + if (strcmp(alg, "HMAC") == 0) { type = EVP_PKEY_HMAC; - else if (strcmp(alg, "CMAC") == 0) + } else if (strcmp(alg, "CMAC") == 0) { +#ifndef OPENSSL_NO_CMAC type = EVP_PKEY_CMAC; - else +#else + t->skip = 1; + return 1; +#endif + } else if (strcmp(alg, "Poly1305") == 0) { +#ifndef OPENSSL_NO_POLY1305 + type = EVP_PKEY_POLY1305; +#else + t->skip = 1; + return 1; +#endif + } else if (strcmp(alg, "SipHash") == 0) { +#ifndef OPENSSL_NO_SIPHASH + type = EVP_PKEY_SIPHASH; +#else + t->skip = 1; + return 1; +#endif + } else return 0; mdat = OPENSSL_malloc(sizeof(*mdat)); @@ -999,7 +1256,7 @@ static int mac_test_parse(struct evp_test *t, if (strcmp(keyword, "Key") == 0) return test_bin(value, &mdata->key, &mdata->key_len); if (strcmp(keyword, "Algorithm") == 0) { - mdata->alg = BUF_strdup(value); + mdata->alg = OPENSSL_strdup(value); if (!mdata->alg) return 0; return 1; @@ -1022,6 +1279,14 @@ static int mac_test_run(struct evp_test *t) unsigned char *mac = NULL; size_t mac_len; +#ifdef OPENSSL_NO_DES + if (mdata->alg != NULL && strstr(mdata->alg, "DES") != NULL) { + /* Skip DES */ + err = NULL; + goto err; + } +#endif + err = "MAC_PKEY_CTX_ERROR"; genctx = EVP_PKEY_CTX_new_id(mdata->type, NULL); if (!genctx) @@ -1049,7 +1314,7 @@ static int mac_test_run(struct evp_test *t) if (!md) goto err; } - mctx = EVP_MD_CTX_create(); + mctx = EVP_MD_CTX_new(); if (!mctx) goto err; err = "DIGESTSIGNINIT_ERROR"; @@ -1077,8 +1342,7 @@ static int mac_test_run(struct evp_test *t) goto err; err = NULL; err: - if (mctx) - EVP_MD_CTX_destroy(mctx); + EVP_MD_CTX_free(mctx); OPENSSL_free(mac); EVP_PKEY_CTX_free(genctx); EVP_PKEY_free(key); @@ -1134,9 +1398,7 @@ static int pkey_test_init(struct evp_test *t, const char *name, rv = find_key(&pkey, name, t->public); if (!rv) rv = find_key(&pkey, name, t->private); - if (!rv) - return 0; - if (!pkey) { + if (!rv || pkey == NULL) { t->skip = 1; return 1; } @@ -1155,7 +1417,7 @@ static int pkey_test_init(struct evp_test *t, const char *name, if (!kdata->ctx) return 0; if (keyopinit(kdata->ctx) <= 0) - return 0; + t->err = "KEYOP_INIT_ERROR"; return 1; } @@ -1168,6 +1430,40 @@ static void pkey_test_cleanup(struct evp_test *t) EVP_PKEY_CTX_free(kdata->ctx); } +static int pkey_test_ctrl(struct evp_test *t, EVP_PKEY_CTX *pctx, + const char *value) +{ + int rv; + char *p, *tmpval; + + tmpval = OPENSSL_strdup(value); + if (tmpval == NULL) + return 0; + p = strchr(tmpval, ':'); + if (p != NULL) + *p++ = 0; + rv = EVP_PKEY_CTX_ctrl_str(pctx, tmpval, p); + if (rv == -2) { + t->err = "PKEY_CTRL_INVALID"; + rv = 1; + } else if (p != NULL && rv <= 0) { + /* If p has an OID and lookup fails assume disabled algorithm */ + int nid = OBJ_sn2nid(p); + if (nid == NID_undef) + nid = OBJ_ln2nid(p); + if ((nid != NID_undef) && EVP_get_digestbynid(nid) == NULL && + EVP_get_cipherbynid(nid) == NULL) { + t->skip = 1; + rv = 1; + } else { + t->err = "PKEY_CTRL_ERROR"; + rv = 1; + } + } + OPENSSL_free(tmpval); + return rv > 0; +} + static int pkey_test_parse(struct evp_test *t, const char *keyword, const char *value) { @@ -1176,14 +1472,8 @@ static int pkey_test_parse(struct evp_test *t, return test_bin(value, &kdata->input, &kdata->input_len); if (strcmp(keyword, "Output") == 0) return test_bin(value, &kdata->output, &kdata->output_len); - if (strcmp(keyword, "Ctrl") == 0) { - char *p = strchr(value, ':'); - if (p) - *p++ = 0; - if (EVP_PKEY_CTX_ctrl_str(kdata->ctx, value, p) <= 0) - return 0; - return 1; - } + if (strcmp(keyword, "Ctrl") == 0) + return pkey_test_ctrl(t, kdata->ctx, value); return 0; } @@ -1281,6 +1571,69 @@ static const struct evp_test_method pverify_test_method = { verify_test_run }; + +static int pderive_test_init(struct evp_test *t, const char *name) +{ + return pkey_test_init(t, name, 0, EVP_PKEY_derive_init, 0); +} + +static int pderive_test_parse(struct evp_test *t, + const char *keyword, const char *value) +{ + struct pkey_data *kdata = t->data; + + if (strcmp(keyword, "PeerKey") == 0) { + EVP_PKEY *peer; + if (find_key(&peer, value, t->public) == 0) + return 0; + if (EVP_PKEY_derive_set_peer(kdata->ctx, peer) <= 0) + return 0; + return 1; + } + if (strcmp(keyword, "SharedSecret") == 0) + return test_bin(value, &kdata->output, &kdata->output_len); + if (strcmp(keyword, "Ctrl") == 0) + return pkey_test_ctrl(t, kdata->ctx, value); + return 0; +} + +static int pderive_test_run(struct evp_test *t) +{ + struct pkey_data *kdata = t->data; + unsigned char *out = NULL; + size_t out_len; + const char *err = "INTERNAL_ERROR"; + + out_len = kdata->output_len; + out = OPENSSL_malloc(out_len); + if (!out) { + fprintf(stderr, "Error allocating output buffer!\n"); + exit(1); + } + err = "DERIVE_ERROR"; + if (EVP_PKEY_derive(kdata->ctx, out, &out_len) <= 0) + goto err; + err = "SHARED_SECRET_LENGTH_MISMATCH"; + if (out_len != kdata->output_len) + goto err; + err = "SHARED_SECRET_MISMATCH"; + if (check_output(t, kdata->output, out, out_len)) + goto err; + err = NULL; + err: + OPENSSL_free(out); + t->err = err; + return 1; +} + +static const struct evp_test_method pderive_test_method = { + "Derive", + pderive_test_init, + pkey_test_cleanup, + pderive_test_parse, + pderive_test_run +}; + /* PBE tests */ #define PBE_TYPE_SCRYPT 1 @@ -1311,6 +1664,7 @@ struct pbe_data { size_t key_len; }; +#ifndef OPENSSL_NO_SCRYPT static int scrypt_test_parse(struct evp_test *t, const char *keyword, const char *value) { @@ -1326,6 +1680,7 @@ static int scrypt_test_parse(struct evp_test *t, return test_uint64(value, &pdata->maxmem); return 0; } +#endif static int pbkdf2_test_parse(struct evp_test *t, const char *keyword, const char *value) @@ -1366,14 +1721,20 @@ static int pbe_test_init(struct evp_test *t, const char *alg) struct pbe_data *pdat; int pbe_type = 0; - if (strcmp(alg, "scrypt") == 0) + if (strcmp(alg, "scrypt") == 0) { +#ifndef OPENSSL_NO_SCRYPT pbe_type = PBE_TYPE_SCRYPT; - else if (strcmp(alg, "pbkdf2") == 0) +#else + t->skip = 1; + return 1; +#endif + } else if (strcmp(alg, "pbkdf2") == 0) { pbe_type = PBE_TYPE_PBKDF2; - else if (strcmp(alg, "pkcs12") == 0) + } else if (strcmp(alg, "pkcs12") == 0) { pbe_type = PBE_TYPE_PKCS12; - else + } else { fprintf(stderr, "Unknown pbe algorithm %s\n", alg); + } pdat = OPENSSL_malloc(sizeof(*pdat)); pdat->pbe_type = pbe_type; pdat->pass = NULL; @@ -1408,12 +1769,14 @@ static int pbe_test_parse(struct evp_test *t, return test_bin(value, &pdata->salt, &pdata->salt_len); if (strcmp(keyword, "Key") == 0) return test_bin(value, &pdata->key, &pdata->key_len); - if (pdata->pbe_type == PBE_TYPE_SCRYPT) - return scrypt_test_parse(t, keyword, value); - else if (pdata->pbe_type == PBE_TYPE_PBKDF2) + if (pdata->pbe_type == PBE_TYPE_PBKDF2) return pbkdf2_test_parse(t, keyword, value); else if (pdata->pbe_type == PBE_TYPE_PKCS12) return pkcs12_test_parse(t, keyword, value); +#ifndef OPENSSL_NO_SCRYPT + else if (pdata->pbe_type == PBE_TYPE_SCRYPT) + return scrypt_test_parse(t, keyword, value); +#endif return 0; } @@ -1433,6 +1796,7 @@ static int pbe_test_run(struct evp_test *t) pdata->iter, pdata->md, pdata->key_len, key) == 0) goto err; +#ifndef OPENSSL_NO_SCRYPT } else if (pdata->pbe_type == PBE_TYPE_SCRYPT) { err = "SCRYPT_ERROR"; if (EVP_PBE_scrypt((const char *)pdata->pass, pdata->pass_len, @@ -1440,6 +1804,7 @@ static int pbe_test_run(struct evp_test *t) pdata->N, pdata->r, pdata->p, pdata->maxmem, key, pdata->key_len) == 0) goto err; +#endif } else if (pdata->pbe_type == PBE_TYPE_PKCS12) { err = "PKCS12_ERROR"; if (PKCS12_key_gen_uni(pdata->pass, pdata->pass_len, @@ -1465,3 +1830,353 @@ static const struct evp_test_method pbe_test_method = { pbe_test_parse, pbe_test_run }; + +/* Base64 tests */ + +typedef enum { + BASE64_CANONICAL_ENCODING = 0, + BASE64_VALID_ENCODING = 1, + BASE64_INVALID_ENCODING = 2 +} base64_encoding_type; + +struct encode_data { + /* Input to encoding */ + unsigned char *input; + size_t input_len; + /* Expected output */ + unsigned char *output; + size_t output_len; + base64_encoding_type encoding; +}; + +static int encode_test_init(struct evp_test *t, const char *encoding) +{ + struct encode_data *edata = OPENSSL_zalloc(sizeof(*edata)); + + if (strcmp(encoding, "canonical") == 0) { + edata->encoding = BASE64_CANONICAL_ENCODING; + } else if (strcmp(encoding, "valid") == 0) { + edata->encoding = BASE64_VALID_ENCODING; + } else if (strcmp(encoding, "invalid") == 0) { + edata->encoding = BASE64_INVALID_ENCODING; + t->expected_err = OPENSSL_strdup("DECODE_ERROR"); + if (t->expected_err == NULL) + return 0; + } else { + fprintf(stderr, "Bad encoding: %s. Should be one of " + "{canonical, valid, invalid}\n", encoding); + return 0; + } + t->data = edata; + return 1; +} + +static void encode_test_cleanup(struct evp_test *t) +{ + struct encode_data *edata = t->data; + test_free(edata->input); + test_free(edata->output); + memset(edata, 0, sizeof(*edata)); +} + +static int encode_test_parse(struct evp_test *t, + const char *keyword, const char *value) +{ + struct encode_data *edata = t->data; + if (strcmp(keyword, "Input") == 0) + return test_bin(value, &edata->input, &edata->input_len); + if (strcmp(keyword, "Output") == 0) + return test_bin(value, &edata->output, &edata->output_len); + return 0; +} + +static int encode_test_run(struct evp_test *t) +{ + struct encode_data *edata = t->data; + unsigned char *encode_out = NULL, *decode_out = NULL; + int output_len, chunk_len; + const char *err = "INTERNAL_ERROR"; + EVP_ENCODE_CTX *decode_ctx = EVP_ENCODE_CTX_new(); + + if (decode_ctx == NULL) + goto err; + + if (edata->encoding == BASE64_CANONICAL_ENCODING) { + EVP_ENCODE_CTX *encode_ctx = EVP_ENCODE_CTX_new(); + if (encode_ctx == NULL) + goto err; + encode_out = OPENSSL_malloc(EVP_ENCODE_LENGTH(edata->input_len)); + if (encode_out == NULL) + goto err; + + EVP_EncodeInit(encode_ctx); + EVP_EncodeUpdate(encode_ctx, encode_out, &chunk_len, + edata->input, edata->input_len); + output_len = chunk_len; + + EVP_EncodeFinal(encode_ctx, encode_out + chunk_len, &chunk_len); + output_len += chunk_len; + + EVP_ENCODE_CTX_free(encode_ctx); + + if (check_var_length_output(t, edata->output, edata->output_len, + encode_out, output_len)) { + err = "BAD_ENCODING"; + goto err; + } + } + + decode_out = OPENSSL_malloc(EVP_DECODE_LENGTH(edata->output_len)); + if (decode_out == NULL) + goto err; + + EVP_DecodeInit(decode_ctx); + if (EVP_DecodeUpdate(decode_ctx, decode_out, &chunk_len, edata->output, + edata->output_len) < 0) { + err = "DECODE_ERROR"; + goto err; + } + output_len = chunk_len; + + if (EVP_DecodeFinal(decode_ctx, decode_out + chunk_len, &chunk_len) != 1) { + err = "DECODE_ERROR"; + goto err; + } + output_len += chunk_len; + + if (edata->encoding != BASE64_INVALID_ENCODING && + check_var_length_output(t, edata->input, edata->input_len, + decode_out, output_len)) { + err = "BAD_DECODING"; + goto err; + } + + err = NULL; + err: + t->err = err; + OPENSSL_free(encode_out); + OPENSSL_free(decode_out); + EVP_ENCODE_CTX_free(decode_ctx); + return 1; +} + +static const struct evp_test_method encode_test_method = { + "Encoding", + encode_test_init, + encode_test_cleanup, + encode_test_parse, + encode_test_run, +}; + +/* KDF operations */ + +struct kdf_data { + /* Context for this operation */ + EVP_PKEY_CTX *ctx; + /* Expected output */ + unsigned char *output; + size_t output_len; +}; + +/* + * Perform public key operation setup: lookup key, allocated ctx and call + * the appropriate initialisation function + */ +static int kdf_test_init(struct evp_test *t, const char *name) +{ + struct kdf_data *kdata; + + kdata = OPENSSL_malloc(sizeof(*kdata)); + if (kdata == NULL) + return 0; + kdata->ctx = NULL; + kdata->output = NULL; + t->data = kdata; + kdata->ctx = EVP_PKEY_CTX_new_id(OBJ_sn2nid(name), NULL); + if (kdata->ctx == NULL) + return 0; + if (EVP_PKEY_derive_init(kdata->ctx) <= 0) + return 0; + return 1; +} + +static void kdf_test_cleanup(struct evp_test *t) +{ + struct kdf_data *kdata = t->data; + OPENSSL_free(kdata->output); + EVP_PKEY_CTX_free(kdata->ctx); +} + +static int kdf_test_parse(struct evp_test *t, + const char *keyword, const char *value) +{ + struct kdf_data *kdata = t->data; + if (strcmp(keyword, "Output") == 0) + return test_bin(value, &kdata->output, &kdata->output_len); + if (strncmp(keyword, "Ctrl", 4) == 0) + return pkey_test_ctrl(t, kdata->ctx, value); + return 0; +} + +static int kdf_test_run(struct evp_test *t) +{ + struct kdf_data *kdata = t->data; + unsigned char *out = NULL; + size_t out_len = kdata->output_len; + const char *err = "INTERNAL_ERROR"; + out = OPENSSL_malloc(out_len); + if (!out) { + fprintf(stderr, "Error allocating output buffer!\n"); + exit(1); + } + err = "KDF_DERIVE_ERROR"; + if (EVP_PKEY_derive(kdata->ctx, out, &out_len) <= 0) + goto err; + err = "KDF_LENGTH_MISMATCH"; + if (out_len != kdata->output_len) + goto err; + err = "KDF_MISMATCH"; + if (check_output(t, kdata->output, out, out_len)) + goto err; + err = NULL; + err: + OPENSSL_free(out); + t->err = err; + return 1; +} + +static const struct evp_test_method kdf_test_method = { + "KDF", + kdf_test_init, + kdf_test_cleanup, + kdf_test_parse, + kdf_test_run +}; + +struct keypair_test_data { + EVP_PKEY *privk; + EVP_PKEY *pubk; +}; + +static int keypair_test_init(struct evp_test *t, const char *pair) +{ + int rv = 0; + EVP_PKEY *pk = NULL, *pubk = NULL; + char *pub, *priv = NULL; + const char *err = "INTERNAL_ERROR"; + struct keypair_test_data *data; + + priv = OPENSSL_strdup(pair); + if (priv == NULL) + return 0; + pub = strchr(priv, ':'); + if ( pub == NULL ) { + fprintf(stderr, "Wrong syntax \"%s\"\n", pair); + goto end; + } + *pub++ = 0; /* split priv and pub strings */ + + if (find_key(&pk, priv, t->private) == 0) { + fprintf(stderr, "Cannot find private key: %s\n", priv); + err = "MISSING_PRIVATE_KEY"; + goto end; + } + if (find_key(&pubk, pub, t->public) == 0) { + fprintf(stderr, "Cannot find public key: %s\n", pub); + err = "MISSING_PUBLIC_KEY"; + goto end; + } + + if (pk == NULL && pubk == NULL) { + /* Both keys are listed but unsupported: skip this test */ + t->skip = 1; + rv = 1; + goto end; + } + + data = OPENSSL_malloc(sizeof(*data)); + if (data == NULL ) + goto end; + + data->privk = pk; + data->pubk = pubk; + t->data = data; + + rv = 1; + err = NULL; + +end: + if (priv) + OPENSSL_free(priv); + t->err = err; + return rv; +} + +static void keypair_test_cleanup(struct evp_test *t) +{ + struct keypair_test_data *data = t->data; + t->data = NULL; + if (data) + test_free(data); + return; +} + +/* For test that do not accept any custom keyword: + * return 0 if called + */ +static int void_test_parse(struct evp_test *t, const char *keyword, const char *value) +{ + return 0; +} + +static int keypair_test_run(struct evp_test *t) +{ + int rv = 0; + const struct keypair_test_data *pair = t->data; + const char *err = "INTERNAL_ERROR"; + + if (pair == NULL) + goto end; + + if (pair->privk == NULL || pair->pubk == NULL) { + /* this can only happen if only one of the keys is not set + * which means that one of them was unsupported while the + * other isn't: hence a key type mismatch. + */ + err = "KEYPAIR_TYPE_MISMATCH"; + rv = 1; + goto end; + } + + if ((rv = EVP_PKEY_cmp(pair->privk, pair->pubk)) != 1 ) { + if ( 0 == rv ) { + err = "KEYPAIR_MISMATCH"; + } else if ( -1 == rv ) { + err = "KEYPAIR_TYPE_MISMATCH"; + } else if ( -2 == rv ) { + err = "UNSUPPORTED_KEY_COMPARISON"; + } else { + fprintf(stderr, "Unexpected error in key comparison\n"); + rv = 0; + goto end; + } + rv = 1; + goto end; + } + + rv = 1; + err = NULL; + +end: + t->err = err; + return rv; +} + +static const struct evp_test_method keypair_test_method = { + "PrivPubKeyPair", + keypair_test_init, + keypair_test_cleanup, + void_test_parse, + keypair_test_run +}; +