| /* |
| * 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 <stdlib.h> |
| #include <string.h> |
| |
| /* |
| * We test deprecated functions, so we need to suppress deprecation warnings. |
| */ |
| #define OPENSSL_SUPPRESS_DEPRECATED |
| |
| #include <openssl/bio.h> |
| #include <openssl/evp.h> |
| #include <openssl/asn1.h> |
| #include <openssl/pem.h> |
| #include <openssl/params.h> |
| #include <openssl/encoder.h> |
| #include <openssl/decoder.h> |
| #include <openssl/dh.h> |
| #include <openssl/dsa.h> |
| #ifndef OPENSSL_NO_DEPRECATED_3_0 |
| # include <openssl/rsa.h> |
| #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); |
| } |
