/* * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (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 */ /* * This program tests the following known key type specific function against * the corresponding OSSL_ENCODER implementation: * * - i2d_{TYPE}PrivateKey() * - i2d_{TYPE}PublicKey(), * - i2d_{TYPE}params(), * - i2d_{TYPE}_PUBKEY(), * - PEM_write_bio_{TYPE}PrivateKey() * - PEM_write_bio_{TYPE}PublicKey() * - PEM_write_bio_{TYPE}params() * - PEM_write_bio_{TYPE}_PUBKEY() * * as well as the following functions against the corresponding OSSL_DECODER * implementation. * * - d2i_{TYPE}PrivateKey() * - d2i_{TYPE}PublicKey(), * - d2i_{TYPE}params(), * - d2i_{TYPE}_PUBKEY(), * - PEM_read_bio_{TYPE}PrivateKey() * - PEM_read_bio_{TYPE}PublicKey() * - PEM_read_bio_{TYPE}params() * - PEM_read_bio_{TYPE}_PUBKEY() */ #include #include /* * We test deprecated functions, so we need to suppress deprecation warnings. */ #define OPENSSL_SUPPRESS_DEPRECATED #include #include #include #include #include #include #include #include #include #ifndef OPENSSL_NO_DEPRECATED_3_0 # include #endif #include "internal/nelem.h" #include "crypto/evp.h" #include "testutil.h" typedef int PEM_write_bio_of_void_protected(BIO *out, const void *obj, const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u); typedef int PEM_write_bio_of_void_unprotected(BIO *out, const void *obj); typedef void *PEM_read_bio_of_void(BIO *out, void **obj, pem_password_cb *cb, void *u); typedef int EVP_PKEY_print_fn(BIO *out, const EVP_PKEY *pkey, int indent, ASN1_PCTX *pctx); typedef int EVP_PKEY_eq_fn(const EVP_PKEY *a, const EVP_PKEY *b); static struct test_stanza_st { const char *keytype; const char *structure[2]; int evp_type; i2d_of_void *i2d_PrivateKey; i2d_of_void *i2d_PublicKey; i2d_of_void *i2d_params; i2d_of_void *i2d_PUBKEY; PEM_write_bio_of_void_protected *pem_write_bio_PrivateKey; PEM_write_bio_of_void_unprotected *pem_write_bio_PublicKey; PEM_write_bio_of_void_unprotected *pem_write_bio_params; PEM_write_bio_of_void_unprotected *pem_write_bio_PUBKEY; d2i_of_void *d2i_PrivateKey; d2i_of_void *d2i_PublicKey; d2i_of_void *d2i_params; d2i_of_void *d2i_PUBKEY; PEM_read_bio_of_void *pem_read_bio_PrivateKey; PEM_read_bio_of_void *pem_read_bio_PublicKey; PEM_read_bio_of_void *pem_read_bio_params; PEM_read_bio_of_void *pem_read_bio_PUBKEY; } test_stanzas[] = { #ifndef OPENSSL_NO_DH { "DH", { "DH", "type-specific" }, EVP_PKEY_DH, NULL, /* No i2d_DHPrivateKey */ NULL, /* No i2d_DHPublicKey */ (i2d_of_void *)i2d_DHparams, NULL, /* No i2d_DH_PUBKEY */ NULL, /* No PEM_write_bio_DHPrivateKey */ NULL, /* No PEM_write_bio_DHPublicKey */ (PEM_write_bio_of_void_unprotected *)PEM_write_bio_DHparams, NULL, /* No PEM_write_bio_DH_PUBKEY */ NULL, /* No d2i_DHPrivateKey */ NULL, /* No d2i_DHPublicKey */ (d2i_of_void *)d2i_DHparams, NULL, /* No d2i_DH_PUBKEY */ NULL, /* No PEM_read_bio_DHPrivateKey */ NULL, /* No PEM_read_bio_DHPublicKey */ (PEM_read_bio_of_void *)PEM_read_bio_DHparams, NULL }, /* No PEM_read_bio_DH_PUBKEY */ { "DHX", { "DHX", "type-specific" }, EVP_PKEY_DHX, NULL, /* No i2d_DHxPrivateKey */ NULL, /* No i2d_DHxPublicKey */ (i2d_of_void *)i2d_DHxparams, NULL, /* No i2d_DHx_PUBKEY */ NULL, /* No PEM_write_bio_DHxPrivateKey */ NULL, /* No PEM_write_bio_DHxPublicKey */ (PEM_write_bio_of_void_unprotected *)PEM_write_bio_DHxparams, NULL, /* No PEM_write_bio_DHx_PUBKEY */ NULL, /* No d2i_DHxPrivateKey */ NULL, /* No d2i_DHxPublicKey */ (d2i_of_void *)d2i_DHxparams, NULL, /* No d2i_DHx_PUBKEY */ NULL, /* No PEM_read_bio_DHxPrivateKey */ NULL, /* No PEM_read_bio_DHxPublicKey */ NULL, /* No PEM_read_bio_DHxparams */ NULL }, /* No PEM_read_bio_DHx_PUBKEY */ #endif #ifndef OPENSSL_NO_DSA { "DSA", { "DSA", "type-specific" }, EVP_PKEY_DSA, (i2d_of_void *)i2d_DSAPrivateKey, (i2d_of_void *)i2d_DSAPublicKey, (i2d_of_void *)i2d_DSAparams, (i2d_of_void *)i2d_DSA_PUBKEY, (PEM_write_bio_of_void_protected *)PEM_write_bio_DSAPrivateKey, NULL, /* No PEM_write_bio_DSAPublicKey */ (PEM_write_bio_of_void_unprotected *)PEM_write_bio_DSAparams, (PEM_write_bio_of_void_unprotected *)PEM_write_bio_DSA_PUBKEY, (d2i_of_void *)d2i_DSAPrivateKey, (d2i_of_void *)d2i_DSAPublicKey, (d2i_of_void *)d2i_DSAparams, (d2i_of_void *)d2i_DSA_PUBKEY, (PEM_read_bio_of_void *)PEM_read_bio_DSAPrivateKey, NULL, /* No PEM_write_bio_DSAPublicKey */ (PEM_read_bio_of_void *)PEM_read_bio_DSAparams, (PEM_read_bio_of_void *)PEM_read_bio_DSA_PUBKEY }, #endif #ifndef OPENSSL_NO_EC { "EC", { "EC", "type-specific" }, EVP_PKEY_EC, (i2d_of_void *)i2d_ECPrivateKey, NULL, /* No i2d_ECPublicKey */ (i2d_of_void *)i2d_ECParameters, (i2d_of_void *)i2d_EC_PUBKEY, (PEM_write_bio_of_void_protected *)PEM_write_bio_ECPrivateKey, NULL, /* No PEM_write_bio_ECPublicKey */ NULL, /* No PEM_write_bio_ECParameters */ (PEM_write_bio_of_void_unprotected *)PEM_write_bio_EC_PUBKEY, (d2i_of_void *)d2i_ECPrivateKey, NULL, /* No d2i_ECPublicKey */ (d2i_of_void *)d2i_ECParameters, (d2i_of_void *)d2i_EC_PUBKEY, (PEM_read_bio_of_void *)PEM_read_bio_ECPrivateKey, NULL, /* No PEM_read_bio_ECPublicKey */ NULL, /* No PEM_read_bio_ECParameters */ (PEM_read_bio_of_void *)PEM_read_bio_EC_PUBKEY, }, #endif { "RSA", { "RSA", "type-specific" }, EVP_PKEY_RSA, (i2d_of_void *)i2d_RSAPrivateKey, (i2d_of_void *)i2d_RSAPublicKey, NULL, /* No i2d_RSAparams */ (i2d_of_void *)i2d_RSA_PUBKEY, (PEM_write_bio_of_void_protected *)PEM_write_bio_RSAPrivateKey, (PEM_write_bio_of_void_unprotected *)PEM_write_bio_RSAPublicKey, NULL, /* No PEM_write_bio_RSAparams */ (PEM_write_bio_of_void_unprotected *)PEM_write_bio_RSA_PUBKEY, (d2i_of_void *)d2i_RSAPrivateKey, (d2i_of_void *)d2i_RSAPublicKey, NULL, /* No d2i_RSAparams */ (d2i_of_void *)d2i_RSA_PUBKEY, (PEM_read_bio_of_void *)PEM_read_bio_RSAPrivateKey, (PEM_read_bio_of_void *)PEM_read_bio_RSAPublicKey, NULL, /* No PEM_read_bio_RSAparams */ (PEM_read_bio_of_void *)PEM_read_bio_RSA_PUBKEY } }; /* * Keys that we're going to test with. We initialize this with the intended * key types, and generate the keys themselves on program setup. * They must all be downgradable with EVP_PKEY_get0() */ #ifndef OPENSSL_NO_DH static const OSSL_PARAM DH_params[] = { OSSL_PARAM_END }; static const OSSL_PARAM DHX_params[] = { OSSL_PARAM_END }; #endif #ifndef OPENSSL_NO_DSA static size_t qbits = 160; /* PVK only tolerates 160 Q bits */ static size_t pbits = 1024; /* With 160 Q bits, we MUST use 1024 P bits */ static const OSSL_PARAM DSA_params[] = { OSSL_PARAM_size_t("pbits", &pbits), OSSL_PARAM_size_t("qbits", &qbits), OSSL_PARAM_END }; #endif #ifndef OPENSSL_NO_EC static char groupname[] = "prime256v1"; static const OSSL_PARAM EC_params[] = { OSSL_PARAM_utf8_string("group", groupname, sizeof(groupname) - 1), OSSL_PARAM_END }; #endif static struct key_st { const char *keytype; int evp_type; /* non-NULL if a template EVP_PKEY must be generated first */ const OSSL_PARAM *template_params; EVP_PKEY *key; } keys[] = { #ifndef OPENSSL_NO_DH { "DH", EVP_PKEY_DH, DH_params, NULL }, { "DHX", EVP_PKEY_DHX, DHX_params, NULL }, #endif #ifndef OPENSSL_NO_DSA { "DSA", EVP_PKEY_DSA, DSA_params, NULL }, #endif #ifndef OPENSSL_NO_EC { "EC", EVP_PKEY_EC, EC_params, NULL }, #endif #ifndef OPENSSL_NO_DEPRECATED_3_0 { "RSA", EVP_PKEY_RSA, NULL, NULL }, #endif }; static EVP_PKEY *make_key(const char *type, const OSSL_PARAM *gen_template_params) { EVP_PKEY *template = NULL; EVP_PKEY *pkey = NULL; EVP_PKEY_CTX *ctx = NULL; OSSL_PARAM *gen_template_params_noconst = (OSSL_PARAM *)gen_template_params; if (gen_template_params != NULL && ((ctx = EVP_PKEY_CTX_new_from_name(NULL, type, NULL)) == NULL || EVP_PKEY_paramgen_init(ctx) <= 0 || (gen_template_params[0].key != NULL && EVP_PKEY_CTX_set_params(ctx, gen_template_params_noconst) <= 0) || EVP_PKEY_generate(ctx, &template) <= 0)) goto end; EVP_PKEY_CTX_free(ctx); /* * No real need to check the errors other than for the cascade * effect. |pkey| will simply remain NULL if something goes wrong. */ ctx = template != NULL ? EVP_PKEY_CTX_new(template, NULL) : EVP_PKEY_CTX_new_from_name(NULL, type, NULL); (void)(ctx != NULL && EVP_PKEY_keygen_init(ctx) > 0 && EVP_PKEY_keygen(ctx, &pkey) > 0); end: EVP_PKEY_free(template); EVP_PKEY_CTX_free(ctx); return pkey; } static struct key_st *lookup_key(const char *type) { size_t i; for (i = 0; i < OSSL_NELEM(keys); i++) { if (strcmp(keys[i].keytype, type) == 0) return &keys[i]; } return NULL; } static int test_membio_str_eq(BIO *bio_provided, BIO *bio_legacy) { char *str_provided = NULL, *str_legacy = NULL; long len_provided = BIO_get_mem_data(bio_provided, &str_provided); long len_legacy = BIO_get_mem_data(bio_legacy, &str_legacy); return TEST_long_ge(len_legacy, 0) && TEST_long_ge(len_provided, 0) && TEST_strn2_eq(str_provided, len_provided, str_legacy, len_legacy); } static int test_protected_PEM(const char *keytype, int evp_type, const void *legacy_key, PEM_write_bio_of_void_protected *pem_write_bio, PEM_read_bio_of_void *pem_read_bio, EVP_PKEY_eq_fn *evp_pkey_eq, EVP_PKEY_print_fn *evp_pkey_print, EVP_PKEY *provided_pkey, int selection, const char *structure) { int ok = 0; BIO *membio_legacy = NULL; BIO *membio_provided = NULL; OSSL_ENCODER_CTX *ectx = NULL; OSSL_DECODER_CTX *dctx = NULL; void *decoded_legacy_key = NULL; EVP_PKEY *decoded_legacy_pkey = NULL; EVP_PKEY *decoded_provided_pkey = NULL; /* Set up the BIOs, so we have them */ if (!TEST_ptr(membio_legacy = BIO_new(BIO_s_mem())) || !TEST_ptr(membio_provided = BIO_new(BIO_s_mem()))) goto end; if (!TEST_ptr(ectx = OSSL_ENCODER_CTX_new_for_pkey(provided_pkey, selection, "PEM", structure, NULL)) || !TEST_true(OSSL_ENCODER_to_bio(ectx, membio_provided)) || !TEST_true(pem_write_bio(membio_legacy, legacy_key, NULL, NULL, 0, NULL, NULL)) || !test_membio_str_eq(membio_provided, membio_legacy)) goto end; if (pem_read_bio != NULL) { /* Now try decoding the results and compare the resulting keys */ if (!TEST_ptr(decoded_legacy_pkey = EVP_PKEY_new()) || !TEST_ptr(dctx = OSSL_DECODER_CTX_new_for_pkey(&decoded_provided_pkey, "PEM", structure, keytype, selection, NULL, NULL)) || !TEST_true(OSSL_DECODER_from_bio(dctx, membio_provided)) || !TEST_ptr(decoded_legacy_key = pem_read_bio(membio_legacy, NULL, NULL, NULL)) || !TEST_true(EVP_PKEY_assign(decoded_legacy_pkey, evp_type, decoded_legacy_key))) goto end; if (!TEST_int_gt(evp_pkey_eq(decoded_provided_pkey, decoded_legacy_pkey), 0)) { TEST_info("decoded_provided_pkey:"); evp_pkey_print(bio_out, decoded_provided_pkey, 0, NULL); TEST_info("decoded_legacy_pkey:"); evp_pkey_print(bio_out, decoded_legacy_pkey, 0, NULL); } } ok = 1; end: EVP_PKEY_free(decoded_legacy_pkey); EVP_PKEY_free(decoded_provided_pkey); OSSL_ENCODER_CTX_free(ectx); OSSL_DECODER_CTX_free(dctx); BIO_free(membio_provided); BIO_free(membio_legacy); return ok; } static int test_unprotected_PEM(const char *keytype, int evp_type, const void *legacy_key, PEM_write_bio_of_void_unprotected *pem_write_bio, PEM_read_bio_of_void *pem_read_bio, EVP_PKEY_eq_fn *evp_pkey_eq, EVP_PKEY_print_fn *evp_pkey_print, EVP_PKEY *provided_pkey, int selection, const char *structure) { int ok = 0; BIO *membio_legacy = NULL; BIO *membio_provided = NULL; OSSL_ENCODER_CTX *ectx = NULL; OSSL_DECODER_CTX *dctx = NULL; void *decoded_legacy_key = NULL; EVP_PKEY *decoded_legacy_pkey = NULL; EVP_PKEY *decoded_provided_pkey = NULL; /* Set up the BIOs, so we have them */ if (!TEST_ptr(membio_legacy = BIO_new(BIO_s_mem())) || !TEST_ptr(membio_provided = BIO_new(BIO_s_mem()))) goto end; if (!TEST_ptr(ectx = OSSL_ENCODER_CTX_new_for_pkey(provided_pkey, selection, "PEM", structure, NULL)) || !TEST_true(OSSL_ENCODER_to_bio(ectx, membio_provided)) || !TEST_true(pem_write_bio(membio_legacy, legacy_key)) || !test_membio_str_eq(membio_provided, membio_legacy)) goto end; if (pem_read_bio != NULL) { /* Now try decoding the results and compare the resulting keys */ if (!TEST_ptr(decoded_legacy_pkey = EVP_PKEY_new()) || !TEST_ptr(dctx = OSSL_DECODER_CTX_new_for_pkey(&decoded_provided_pkey, "PEM", structure, keytype, selection, NULL, NULL)) || !TEST_true(OSSL_DECODER_from_bio(dctx, membio_provided)) || !TEST_ptr(decoded_legacy_key = pem_read_bio(membio_legacy, NULL, NULL, NULL)) || !TEST_true(EVP_PKEY_assign(decoded_legacy_pkey, evp_type, decoded_legacy_key))) goto end; if (!TEST_int_gt(evp_pkey_eq(decoded_provided_pkey, decoded_legacy_pkey), 0)) { TEST_info("decoded_provided_pkey:"); evp_pkey_print(bio_out, decoded_provided_pkey, 0, NULL); TEST_info("decoded_legacy_pkey:"); evp_pkey_print(bio_out, decoded_legacy_pkey, 0, NULL); } } ok = 1; end: EVP_PKEY_free(decoded_legacy_pkey); EVP_PKEY_free(decoded_provided_pkey); OSSL_ENCODER_CTX_free(ectx); OSSL_DECODER_CTX_free(dctx); BIO_free(membio_provided); BIO_free(membio_legacy); return ok; } static int test_DER(const char *keytype, int evp_type, const void *legacy_key, i2d_of_void *i2d, d2i_of_void *d2i, EVP_PKEY_eq_fn *evp_pkey_eq, EVP_PKEY_print_fn *evp_pkey_print, EVP_PKEY *provided_pkey, int selection, const char *structure) { int ok = 0; unsigned char *der_legacy = NULL; const unsigned char *pder_legacy = NULL; size_t der_legacy_len = 0; unsigned char *der_provided = NULL; const unsigned char *pder_provided = NULL; size_t der_provided_len = 0; size_t tmp_size; OSSL_ENCODER_CTX *ectx = NULL; OSSL_DECODER_CTX *dctx = NULL; void *decoded_legacy_key = NULL; EVP_PKEY *decoded_legacy_pkey = NULL; EVP_PKEY *decoded_provided_pkey = NULL; if (!TEST_ptr(ectx = OSSL_ENCODER_CTX_new_for_pkey(provided_pkey, selection, "DER", structure, NULL)) || !TEST_true(OSSL_ENCODER_to_data(ectx, &der_provided, &der_provided_len)) || !TEST_size_t_gt(der_legacy_len = i2d(legacy_key, &der_legacy), 0) || !TEST_mem_eq(der_provided, der_provided_len, der_legacy, der_legacy_len)) goto end; if (d2i != NULL) { /* Now try decoding the results and compare the resulting keys */ if (!TEST_ptr(decoded_legacy_pkey = EVP_PKEY_new()) || !TEST_ptr(dctx = OSSL_DECODER_CTX_new_for_pkey(&decoded_provided_pkey, "DER", structure, keytype, selection, NULL, NULL)) || !TEST_true((pder_provided = der_provided, tmp_size = der_provided_len, OSSL_DECODER_from_data(dctx, &pder_provided, &tmp_size))) || !TEST_ptr((pder_legacy = der_legacy, decoded_legacy_key = d2i(NULL, &pder_legacy, (long)der_legacy_len))) || !TEST_true(EVP_PKEY_assign(decoded_legacy_pkey, evp_type, decoded_legacy_key))) goto end; if (!TEST_int_gt(evp_pkey_eq(decoded_provided_pkey, decoded_legacy_pkey), 0)) { TEST_info("decoded_provided_pkey:"); evp_pkey_print(bio_out, decoded_provided_pkey, 0, NULL); TEST_info("decoded_legacy_pkey:"); evp_pkey_print(bio_out, decoded_legacy_pkey, 0, NULL); } } ok = 1; end: EVP_PKEY_free(decoded_legacy_pkey); EVP_PKEY_free(decoded_provided_pkey); OSSL_ENCODER_CTX_free(ectx); OSSL_DECODER_CTX_free(dctx); OPENSSL_free(der_provided); OPENSSL_free(der_legacy); return ok; } static int test_key(int idx) { struct test_stanza_st *test_stanza = NULL; struct key_st *key = NULL; int ok = 0; size_t i; EVP_PKEY *pkey = NULL, *downgraded_pkey = NULL; const void *legacy_obj = NULL; /* Get the test data */ if (!TEST_ptr(test_stanza = &test_stanzas[idx]) || !TEST_ptr(key = lookup_key(test_stanza->keytype))) goto end; /* Set up the keys */ if (!TEST_ptr(pkey = key->key) || !TEST_true(evp_pkey_copy_downgraded(&downgraded_pkey, pkey)) || !TEST_ptr(downgraded_pkey) || !TEST_int_eq(EVP_PKEY_get_id(downgraded_pkey), key->evp_type) || !TEST_ptr(legacy_obj = EVP_PKEY_get0(downgraded_pkey))) goto end; ok = 1; /* Test PrivateKey to PEM */ if (test_stanza->pem_write_bio_PrivateKey != NULL) { int selection = OSSL_KEYMGMT_SELECT_ALL; for (i = 0; i < OSSL_NELEM(test_stanza->structure); i++) { const char *structure = test_stanza->structure[i]; TEST_info("Test OSSL_ENCODER against PEM_write_bio_{TYPE}PrivateKey for %s, %s", test_stanza->keytype, structure); if (!test_protected_PEM(key->keytype, key->evp_type, legacy_obj, test_stanza->pem_write_bio_PrivateKey, test_stanza->pem_read_bio_PrivateKey, EVP_PKEY_eq, EVP_PKEY_print_private, pkey, selection, structure)) ok = 0; } } /* Test PublicKey to PEM */ if (test_stanza->pem_write_bio_PublicKey != NULL) { int selection = OSSL_KEYMGMT_SELECT_PUBLIC_KEY | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS; for (i = 0; i < OSSL_NELEM(test_stanza->structure); i++) { const char *structure = test_stanza->structure[i]; TEST_info("Test OSSL_ENCODER against PEM_write_bio_{TYPE}PublicKey for %s, %s", test_stanza->keytype, structure); if (!test_unprotected_PEM(key->keytype, key->evp_type, legacy_obj, test_stanza->pem_write_bio_PublicKey, test_stanza->pem_read_bio_PublicKey, EVP_PKEY_eq, EVP_PKEY_print_public, pkey, selection, structure)) ok = 0; } } /* Test params to PEM */ if (test_stanza->pem_write_bio_params != NULL) { int selection = OSSL_KEYMGMT_SELECT_ALL_PARAMETERS; for (i = 0; i < OSSL_NELEM(test_stanza->structure); i++) { const char *structure = test_stanza->structure[i]; TEST_info("Test OSSL_ENCODER against PEM_write_bio_{TYPE}params for %s, %s", test_stanza->keytype, structure); if (!test_unprotected_PEM(key->keytype, key->evp_type, legacy_obj, test_stanza->pem_write_bio_params, test_stanza->pem_read_bio_params, EVP_PKEY_parameters_eq, EVP_PKEY_print_params, pkey, selection, structure)) ok = 0; } } /* Test PUBKEY to PEM */ if (test_stanza->pem_write_bio_PUBKEY != NULL) { int selection = OSSL_KEYMGMT_SELECT_PUBLIC_KEY | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS; const char *structure = "SubjectPublicKeyInfo"; TEST_info("Test OSSL_ENCODER against PEM_write_bio_{TYPE}_PUBKEY for %s, %s", test_stanza->keytype, structure); if (!test_unprotected_PEM(key->keytype, key->evp_type, legacy_obj, test_stanza->pem_write_bio_PUBKEY, test_stanza->pem_read_bio_PUBKEY, EVP_PKEY_eq, EVP_PKEY_print_public, pkey, selection, structure)) ok = 0; } /* Test PrivateKey to DER */ if (test_stanza->i2d_PrivateKey != NULL) { int selection = OSSL_KEYMGMT_SELECT_ALL; for (i = 0; i < OSSL_NELEM(test_stanza->structure); i++) { const char *structure = test_stanza->structure[i]; TEST_info("Test OSSL_ENCODER against i2d_{TYPE}PrivateKey for %s, %s", test_stanza->keytype, structure); if (!test_DER(key->keytype, key->evp_type, legacy_obj, test_stanza->i2d_PrivateKey, test_stanza->d2i_PrivateKey, EVP_PKEY_eq, EVP_PKEY_print_private, pkey, selection, structure)) ok = 0; } } /* Test PublicKey to DER */ if (test_stanza->i2d_PublicKey != NULL) { int selection = OSSL_KEYMGMT_SELECT_PUBLIC_KEY | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS; for (i = 0; i < OSSL_NELEM(test_stanza->structure); i++) { const char *structure = test_stanza->structure[i]; TEST_info("Test OSSL_ENCODER against i2d_{TYPE}PublicKey for %s, %s", test_stanza->keytype, structure); if (!test_DER(key->keytype, key->evp_type, legacy_obj, test_stanza->i2d_PublicKey, test_stanza->d2i_PublicKey, EVP_PKEY_eq, EVP_PKEY_print_public, pkey, selection, structure)) ok = 0; } } /* Test params to DER */ if (test_stanza->i2d_params != NULL) { int selection = OSSL_KEYMGMT_SELECT_ALL_PARAMETERS; for (i = 0; i < OSSL_NELEM(test_stanza->structure); i++) { const char *structure = test_stanza->structure[i]; TEST_info("Test OSSL_ENCODER against i2d_{TYPE}params for %s, %s", test_stanza->keytype, structure); if (!test_DER(key->keytype, key->evp_type, legacy_obj, test_stanza->i2d_params, test_stanza->d2i_params, EVP_PKEY_parameters_eq, EVP_PKEY_print_params, pkey, selection, structure)) ok = 0; } } /* Test PUBKEY to DER */ if (test_stanza->i2d_PUBKEY != NULL) { int selection = OSSL_KEYMGMT_SELECT_PUBLIC_KEY | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS; const char *structure = "SubjectPublicKeyInfo"; TEST_info("Test OSSL_ENCODER against i2d_{TYPE}_PUBKEY for %s, %s", test_stanza->keytype, structure); if (!test_DER(key->keytype, key->evp_type, legacy_obj, test_stanza->i2d_PUBKEY, test_stanza->d2i_PUBKEY, EVP_PKEY_eq, EVP_PKEY_print_public, pkey, selection, structure)) ok = 0; } end: EVP_PKEY_free(downgraded_pkey); return ok; } #define USAGE "rsa-key.pem dh-key.pem\n" OPT_TEST_DECLARE_USAGE(USAGE) int setup_tests(void) { size_t i; if (!test_skip_common_options()) { TEST_error("Error parsing test options\n"); return 0; } if (test_get_argument_count() != 2) { TEST_error("usage: endecoder_legacy_test %s", USAGE); return 0; } TEST_info("Generating keys..."); for (i = 0; i < OSSL_NELEM(keys); i++) { #ifndef OPENSSL_NO_DH if (strcmp(keys[i].keytype, "DH") == 0) { if (!TEST_ptr(keys[i].key = load_pkey_pem(test_get_argument(1), NULL))) return 0; continue; } #endif #ifndef OPENSSL_NO_DEPRECATED_3_0 if (strcmp(keys[i].keytype, "RSA") == 0) { if (!TEST_ptr(keys[i].key = load_pkey_pem(test_get_argument(0), NULL))) return 0; continue; } #endif TEST_info("Generating %s key...", keys[i].keytype); if (!TEST_ptr(keys[i].key = make_key(keys[i].keytype, keys[i].template_params))) return 0; } TEST_info("Generating keys done"); ADD_ALL_TESTS(test_key, OSSL_NELEM(test_stanzas)); return 1; } void cleanup_tests(void) { size_t i; for (i = 0; i < OSSL_NELEM(keys); i++) EVP_PKEY_free(keys[i].key); }