X-Git-Url: https://git.openssl.org/gitweb/?p=openssl.git;a=blobdiff_plain;f=test%2Fevp_test.c;h=a0dbffb2daf5d05489e880d01ca00ced5f48cb08;hp=eb7ef5017afbe0d32f4c4fb7418a824a2a4cedbd;hb=b2b3024e0eef58589f7a49ebd48da98d4564a348;hpb=3cdd1e94b1d71f2ce3002738f9506da91fe2af45 diff --git a/test/evp_test.c b/test/evp_test.c index eb7ef5017a..a0dbffb2da 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-2016 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,6 +16,7 @@ #include #include #include +#include #include "internal/numbers.h" /* Remove spaces from beginning and end of a string */ @@ -169,6 +125,8 @@ static unsigned char* unescape(const char *input, size_t input_len, static int test_bin(const char *value, unsigned char **buf, size_t *buflen) { long len; + + *buflen = 0; if (!*value) { /* * Don't return NULL for zero length buffer. @@ -197,7 +155,7 @@ static int test_bin(const char *value, unsigned char **buf, size_t *buflen) return 1; } - *buf = string_to_hex(value, &len); + *buf = OPENSSL_hexstr2buf(value, &len); if (!*buf) { fprintf(stderr, "Value=%s\n", value); ERR_print_errors_fp(stderr); @@ -207,6 +165,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) { @@ -231,11 +191,12 @@ 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; /* List of public and private keys */ struct key_list *private; struct key_list *public; @@ -246,7 +207,7 @@ 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; /* Number of tests */ @@ -291,8 +252,10 @@ 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 *evp_test_list[] = { &digest_test_method, @@ -302,8 +265,10 @@ 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, NULL }; @@ -355,8 +320,13 @@ static int check_test_error(struct evp_test *t) 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; } @@ -456,8 +426,8 @@ 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); + save_pos = BIO_tell(t->in); + pk = PEM_read_bio_PrivateKey(t->in, NULL, 0, NULL); if (pk == NULL && !check_unsupported()) { fprintf(stderr, "Error reading private key %s\n", value); ERR_print_errors_fp(stderr); @@ -467,8 +437,8 @@ 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); + save_pos = BIO_tell(t->in); + pk = PEM_read_bio_PUBKEY(t->in, NULL, 0, NULL); if (pk == NULL && !check_unsupported()) { fprintf(stderr, "Error reading public key %s\n", value); ERR_print_errors_fp(stderr); @@ -487,13 +457,13 @@ 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)) { + (void)BIO_seek(t->in, save_pos); + while (BIO_gets(t->in,tmpbuf, sizeof(tmpbuf))) { t->line++; if (strncmp(tmpbuf, "-----END", 8) == 0) return 1; @@ -521,7 +491,7 @@ 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); + t->expected_err = OPENSSL_strdup(value); if (!t->expected_err) return 0; } else { @@ -554,9 +524,9 @@ static int check_var_length_output(struct evp_test *t, } /* The result printing code expects a non-NULL buffer. */ - t->out_expected = BUF_memdup(expected, expected_len ? expected_len : 1); + t->out_expected = OPENSSL_memdup(expected, expected_len ? expected_len : 1); t->out_expected_len = expected_len; - t->out_received = BUF_memdup(received, received_len ? received_len : 1); + 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"); @@ -575,7 +545,7 @@ static int check_output(struct evp_test *t, int main(int argc, char **argv) { - FILE *in = NULL; + BIO *in = NULL; char buf[10240]; struct evp_test t; @@ -586,14 +556,15 @@ 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.start_line = -1; - in = fopen(argv[1], "r"); + in = BIO_new_file(argv[1], "r"); + 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)) { + while (BIO_gets(in, buf, sizeof(buf))) { t.line++; if (!process_test(&t, buf, 0)) exit(1); @@ -605,12 +576,12 @@ 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(in); + +#ifndef OPENSSL_NO_CRYPTO_MDEBUG + if (CRYPTO_mem_leaks_fp(stderr) <= 0) + return 1; +#endif if (t.errors) return 1; return 0; @@ -639,7 +610,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 */ @@ -691,7 +662,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"; @@ -713,8 +684,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; } @@ -775,6 +745,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; @@ -823,7 +795,8 @@ 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) { struct cipher_data *cdat = t->data; unsigned char *in, *out, *tmp = NULL; @@ -847,9 +820,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; @@ -911,20 +906,20 @@ static int cipher_test_enc(struct evp_test *t, int enc) } EVP_CIPHER_CTX_set_padding(ctx, 0); err = "CIPHERUPDATE_ERROR"; - if (!EVP_CipherUpdate(ctx, tmp, &tmplen, in, in_len)) + if (!EVP_CipherUpdate(ctx, tmp + out_misalign, &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)) + 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]; @@ -954,6 +949,8 @@ static int cipher_test_run(struct evp_test *t) { struct cipher_data *cdat = t->data; int rv; + size_t out_misalign, inp_misalign; + if (!cdat->key) { t->err = "NO_KEY"; return 0; @@ -969,24 +966,41 @@ 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; - } - } - if (cdat->enc != 1) { - rv = cipher_test_enc(t, 0); - /* Not fatal errors: return */ - if (rv != 1) { - if (rv < 0) - return 0; - return 1; + for (out_misalign = 0; out_misalign <= 1; out_misalign++) { + 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", + out_misalign ? "misaligned" : "aligned"); + } else { + BIO_snprintf(aux_err, sizeof(aux_err), "%s output and %s input", + out_misalign ? "misaligned" : "aligned", + inp_misalign ? "misaligned" : "aligned"); + } + if (cdat->enc) { + rv = cipher_test_enc(t, 1, out_misalign, inp_misalign); + /* 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); + /* Not fatal errors: return */ + if (rv != 1) { + if (rv < 0) + return 0; + return 1; + } + } } } + t->aux_err = NULL; + return 1; } @@ -1018,11 +1032,16 @@ 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 return 0; mdat = OPENSSL_malloc(sizeof(*mdat)); @@ -1051,7 +1070,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; @@ -1074,6 +1093,14 @@ static int mac_test_run(struct evp_test *t) unsigned char *mac = NULL; size_t mac_len; +#ifdef OPENSSL_NO_DES + if (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) @@ -1101,7 +1128,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"; @@ -1129,8 +1156,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); @@ -1220,6 +1246,22 @@ static void pkey_test_cleanup(struct evp_test *t) EVP_PKEY_CTX_free(kdata->ctx); } +static int pkey_test_ctrl(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); + OPENSSL_free(tmpval); + return rv > 0; +} + static int pkey_test_parse(struct evp_test *t, const char *keyword, const char *value) { @@ -1228,14 +1270,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(kdata->ctx, value); return 0; } @@ -1333,6 +1369,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(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 @@ -1420,16 +1519,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) { #ifndef OPENSSL_NO_SCRYPT - if (strcmp(alg, "scrypt") == 0) pbe_type = PBE_TYPE_SCRYPT; +#else + t->skip = 1; + return 1; #endif - else if (strcmp(alg, "pbkdf2") == 0) + } 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; @@ -1554,7 +1657,7 @@ static int encode_test_init(struct evp_test *t, const char *encoding) edata->encoding = BASE64_VALID_ENCODING; } else if (strcmp(encoding, "invalid") == 0) { edata->encoding = BASE64_INVALID_ENCODING; - t->expected_err = BUF_strdup("DECODE_ERROR"); + t->expected_err = OPENSSL_strdup("DECODE_ERROR"); if (t->expected_err == NULL) return 0; } else { @@ -1591,22 +1694,29 @@ static int encode_test_run(struct evp_test *t) 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 *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 *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, + 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); + 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"; @@ -1618,15 +1728,15 @@ static int encode_test_run(struct evp_test *t) if (decode_out == NULL) goto err; - EVP_DecodeInit(&decode_ctx); - if (EVP_DecodeUpdate(&decode_ctx, decode_out, &chunk_len, edata->output, + 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) { + if (EVP_DecodeFinal(decode_ctx, decode_out + chunk_len, &chunk_len) != 1) { err = "DECODE_ERROR"; goto err; } @@ -1644,6 +1754,7 @@ static int encode_test_run(struct evp_test *t) t->err = err; OPENSSL_free(encode_out); OPENSSL_free(decode_out); + EVP_ENCODE_CTX_free(decode_ctx); return 1; } @@ -1654,3 +1765,88 @@ static const struct evp_test_method encode_test_method = { 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(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 +};