X-Git-Url: https://git.openssl.org/?a=blobdiff_plain;f=test%2Fevp_test.c;h=326ed0d1533fb616804dfcc84b6893f372366ce1;hb=ec307bcc36393969967c4156d98fca50cd446c81;hp=f24494bbc35f7f3743809716fc591da5f11d46ab;hpb=254b26af2003c49958b52215f9fec03b4c7eed03;p=openssl.git diff --git a/test/evp_test.c b/test/evp_test.c index f24494bbc3..326ed0d153 100644 --- a/test/evp_test.c +++ b/test/evp_test.c @@ -1,4 +1,3 @@ -/* evp_test.c */ /* * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL * project. @@ -61,6 +60,7 @@ #include #include #include +#include #include "internal/numbers.h" /* Remove spaces from beginning and end of a string */ @@ -293,6 +293,7 @@ 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 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, @@ -304,6 +305,7 @@ static const struct evp_test_method *evp_test_list[] = { &pverify_recover_test_method, &pbe_test_method, &encode_test_method, + &kdf_test_method, NULL }; @@ -487,7 +489,7 @@ 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; @@ -521,7 +523,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 +556,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"); @@ -610,7 +612,9 @@ int main(int argc, char **argv) CRYPTO_cleanup_all_ex_data(); ERR_remove_thread_state(NULL); ERR_free_strings(); +#ifndef OPENSSL_NO_CRYPTO_MDEBUG CRYPTO_mem_leaks_fp(stderr); +#endif if (t.errors) return 1; return 0; @@ -1052,7 +1056,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; @@ -1554,7 +1558,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 { @@ -1662,3 +1666,115 @@ static const struct evp_test_method encode_test_method = { encode_test_parse, encode_test_run, }; + +/* + * KDF operations: initially just TLS1 PRF but can be adapted. + */ + +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_ctrl(EVP_PKEY_CTX *ctx, int op, const char *value) +{ + unsigned char *buf = NULL; + size_t buf_len; + int rv = 0; + if (test_bin(value, &buf, &buf_len) == 0) + return 0; + if (EVP_PKEY_CTX_ctrl(ctx, -1, -1, op, buf_len, buf) <= 0) + goto err; + rv = 1; + err: + OPENSSL_free(buf); + return rv; +} + +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); + else if (strcmp(keyword, "MD") == 0) { + const EVP_MD *md = EVP_get_digestbyname(value); + if (md == NULL) + return 0; + if (EVP_PKEY_CTX_set_tls1_prf_md(kdata->ctx, md) <= 0) + return 0; + return 1; + } else if (strcmp(keyword, "Secret") == 0) { + return kdf_ctrl(kdata->ctx, EVP_PKEY_CTRL_TLS_SECRET, value); + } else if (strncmp("Seed", keyword, 4) == 0) { + return kdf_ctrl(kdata->ctx, EVP_PKEY_CTRL_TLS_SEED, 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 +};