mirror/openssl
2
0
Fork 0
mirror of https://github.com/openssl/openssl.git synced 2024-12-03 05:41:46 +08:00
Code Issues Packages Projects Releases Wiki Activity
50aba7ffde
openssl/test/endecoder_legacy_test.c

732 lines
28 KiB
C
Raw Normal View History

test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
/*
Update copyright year Reviewed-by: Tomas Mraz <tomas@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14235)
2021-02-18 22:57:13 +08:00
* Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
*
* 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>
Deprecate RSA harder This deprecates all functions that deal with the types RSA and RSA_METHOD Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13096)
2020-10-04 22:34:31 +08:00
/*
* We test deprecated functions, so we need to suppress deprecation warnings.
*/
#define OPENSSL_SUPPRESS_DEPRECATED
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
#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"
Make the EVP_PKEY_get0* functions have a const return type OTC have decided that the EVP_PKEY_get0* functions should have a const return type. This is a breaking change to emphasise that these values should be considered as immutable. Reviewed-by: Richard Levitte <levitte@openssl.org> Reviewed-by: Shane Lontis <shane.lontis@oracle.com> Reviewed-by: Paul Dale <pauli@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14319)
2021-03-02 23:52:00 +08:00
typedef int PEM_write_bio_of_void_protected(BIO *out, const void *obj,
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
const EVP_CIPHER *enc,
unsigned char *kstr, int klen,
pem_password_cb *cb, void *u);
Make the EVP_PKEY_get0* functions have a const return type OTC have decided that the EVP_PKEY_get0* functions should have a const return type. This is a breaking change to emphasise that these values should be considered as immutable. Reviewed-by: Richard Levitte <levitte@openssl.org> Reviewed-by: Shane Lontis <shane.lontis@oracle.com> Reviewed-by: Paul Dale <pauli@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14319)
2021-03-02 23:52:00 +08:00
typedef int PEM_write_bio_of_void_unprotected(BIO *out, const void *obj);
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
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)
Add convenience functions and macros for asymmetric key generation Add EVP_PKEY_gen(), EVP_PKEY_Q_gen(), EVP_RSA_gen(), and EVP_EC_gen(). Also export auxiliary function OSSL_EC_curve_nid2name() and improve deprecation info on RSA and EC key generation/management functions. Reviewed-by: Shane Lontis <shane.lontis@oracle.com> (Merged from https://github.com/openssl/openssl/pull/14695)
2021-03-20 20:49:08 +08:00
|| EVP_PKEY_generate(ctx, &template) <= 0))
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
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);
test: fix coverity 1469427 Improper use of negative value (NEGATIVE_RETURNS) Reviewed-by: Tomas Mraz <tomas@openssl.org> (Merged from https://github.com/openssl/openssl/pull/15943)
2021-06-29 05:59:00 +08:00
return TEST_long_ge(len_legacy, 0)
&& TEST_long_ge(len_provided, 0)
test: fix coverity 1469427: impropery use of negative value Reviewed-by: Tomas Mraz <tomas@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14638)
2021-03-22 10:35:36 +08:00
&& TEST_strn2_eq(str_provided, len_provided,
str_legacy, len_legacy);
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
}
static int test_protected_PEM(const char *keytype, int evp_type,
Make the EVP_PKEY_get0* functions have a const return type OTC have decided that the EVP_PKEY_get0* functions should have a const return type. This is a breaking change to emphasise that these values should be considered as immutable. Reviewed-by: Richard Levitte <levitte@openssl.org> Reviewed-by: Shane Lontis <shane.lontis@oracle.com> Reviewed-by: Paul Dale <pauli@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14319)
2021-03-02 23:52:00 +08:00
const void *legacy_key,
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
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 =
Rename OSSL_ENCODER_CTX_new_by_EVP_PKEY and OSSL_DECODER_CTX_new_by_EVP_PKEY Additional renames done in encoder and decoder implementation to follow the style. Fixes #13622 Reviewed-by: Richard Levitte <levitte@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14155)
2021-02-11 23:57:37 +08:00
OSSL_ENCODER_CTX_new_for_pkey(provided_pkey, selection,
"PEM", structure,
NULL))
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
|| !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 =
Rename OSSL_ENCODER_CTX_new_by_EVP_PKEY and OSSL_DECODER_CTX_new_by_EVP_PKEY Additional renames done in encoder and decoder implementation to follow the style. Fixes #13622 Reviewed-by: Richard Levitte <levitte@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14155)
2021-02-11 23:57:37 +08:00
OSSL_DECODER_CTX_new_for_pkey(&decoded_provided_pkey,
"PEM", structure,
keytype, selection,
NULL, NULL))
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
|| !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,
Make the EVP_PKEY_get0* functions have a const return type OTC have decided that the EVP_PKEY_get0* functions should have a const return type. This is a breaking change to emphasise that these values should be considered as immutable. Reviewed-by: Richard Levitte <levitte@openssl.org> Reviewed-by: Shane Lontis <shane.lontis@oracle.com> Reviewed-by: Paul Dale <pauli@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14319)
2021-03-02 23:52:00 +08:00
const void *legacy_key,
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
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 =
Rename OSSL_ENCODER_CTX_new_by_EVP_PKEY and OSSL_DECODER_CTX_new_by_EVP_PKEY Additional renames done in encoder and decoder implementation to follow the style. Fixes #13622 Reviewed-by: Richard Levitte <levitte@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14155)
2021-02-11 23:57:37 +08:00
OSSL_ENCODER_CTX_new_for_pkey(provided_pkey, selection,
"PEM", structure,
NULL))
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
|| !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 =
Rename OSSL_ENCODER_CTX_new_by_EVP_PKEY and OSSL_DECODER_CTX_new_by_EVP_PKEY Additional renames done in encoder and decoder implementation to follow the style. Fixes #13622 Reviewed-by: Richard Levitte <levitte@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14155)
2021-02-11 23:57:37 +08:00
OSSL_DECODER_CTX_new_for_pkey(&decoded_provided_pkey,
"PEM", structure,
keytype, selection,
NULL, NULL))
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
|| !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,
Make the EVP_PKEY_get0* functions have a const return type OTC have decided that the EVP_PKEY_get0* functions should have a const return type. This is a breaking change to emphasise that these values should be considered as immutable. Reviewed-by: Richard Levitte <levitte@openssl.org> Reviewed-by: Shane Lontis <shane.lontis@oracle.com> Reviewed-by: Paul Dale <pauli@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14319)
2021-03-02 23:52:00 +08:00
const void *legacy_key, i2d_of_void *i2d, d2i_of_void *d2i,
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
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 =
Rename OSSL_ENCODER_CTX_new_by_EVP_PKEY and OSSL_DECODER_CTX_new_by_EVP_PKEY Additional renames done in encoder and decoder implementation to follow the style. Fixes #13622 Reviewed-by: Richard Levitte <levitte@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14155)
2021-02-11 23:57:37 +08:00
OSSL_ENCODER_CTX_new_for_pkey(provided_pkey, selection,
"DER", structure,
NULL))
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
|| !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 =
Rename OSSL_ENCODER_CTX_new_by_EVP_PKEY and OSSL_DECODER_CTX_new_by_EVP_PKEY Additional renames done in encoder and decoder implementation to follow the style. Fixes #13622 Reviewed-by: Richard Levitte <levitte@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14155)
2021-02-11 23:57:37 +08:00
OSSL_DECODER_CTX_new_for_pkey(&decoded_provided_pkey,
"DER", structure,
keytype, selection,
NULL, NULL))
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
|| !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;
Make the EVP_PKEY_get0* functions have a const return type OTC have decided that the EVP_PKEY_get0* functions should have a const return type. This is a breaking change to emphasise that these values should be considered as immutable. Reviewed-by: Richard Levitte <levitte@openssl.org> Reviewed-by: Shane Lontis <shane.lontis@oracle.com> Reviewed-by: Paul Dale <pauli@openssl.org> (Merged from https://github.com/openssl/openssl/pull/14319)
2021-03-02 23:52:00 +08:00
const void *legacy_obj = NULL;
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
/* 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)
Rename all getters to use get/get0 in name For functions that exist in 1.1.1 provide a simple aliases via #define. Fixes #15236 Functions with OSSL_DECODER_, OSSL_ENCODER_, OSSL_STORE_LOADER_, EVP_KEYEXCH_, EVP_KEM_, EVP_ASYM_CIPHER_, EVP_SIGNATURE_, EVP_KEYMGMT_, EVP_RAND_, EVP_MAC_, EVP_KDF_, EVP_PKEY_, EVP_MD_, and EVP_CIPHER_ prefixes are renamed. Reviewed-by: Paul Dale <pauli@openssl.org> (Merged from https://github.com/openssl/openssl/pull/15405)
2021-05-21 22:58:08 +08:00
|| !TEST_int_eq(EVP_PKEY_get_id(downgraded_pkey), key->evp_type)
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
|| !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;
}
TEST: Prefer using precomputed RSA and DH keys for more efficient tests Reviewed-by: Tomas Mraz <tomas@openssl.org> Reviewed-by: Paul Dale <pauli@openssl.org> (Merged from https://github.com/openssl/openssl/pull/13715)
2020-12-13 05:04:05 +08:00
#define USAGE "rsa-key.pem dh-key.pem\n"
OPT_TEST_DECLARE_USAGE(USAGE)
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
int setup_tests(void)
{
size_t i;
TEST: Prefer using precomputed RSA and DH keys for more efficient tests Reviewed-by: Tomas Mraz <tomas@openssl.org> Reviewed-by: Paul Dale <pauli@openssl.org> (Merged from https://github.com/openssl/openssl/pull/13715)
2020-12-13 05:04:05 +08:00
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/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
TEST_info("Generating keys...");
for (i = 0; i < OSSL_NELEM(keys); i++) {
TEST: Prefer using precomputed RSA and DH keys for more efficient tests Reviewed-by: Tomas Mraz <tomas@openssl.org> Reviewed-by: Paul Dale <pauli@openssl.org> (Merged from https://github.com/openssl/openssl/pull/13715)
2020-12-13 05:04:05 +08:00
#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);
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
if (!TEST_ptr(keys[i].key =
make_key(keys[i].keytype, keys[i].template_params)))
return 0;
}
TEST: Prefer using precomputed RSA and DH keys for more efficient tests Reviewed-by: Tomas Mraz <tomas@openssl.org> Reviewed-by: Paul Dale <pauli@openssl.org> (Merged from https://github.com/openssl/openssl/pull/13715)
2020-12-13 05:04:05 +08:00
TEST_info("Generating keys done");
test/endecoder_legacy_test.c: new test for legacy comparison It checks that all of these functions have a corresponding OSSL_ENCODER implementation, and that the output is the same: - 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}Parameters - PEM_write_bio_{TYPE}_PUBKEY It also checks that all of these functions have a corresponding OSSL_DECODER implementation, and that the decoding result matches: - 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() Reviewed-by: Paul Dale <paul.dale@oracle.com> (Merged from https://github.com/openssl/openssl/pull/13262)
2020-10-17 14:59:48 +08:00
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);
}
Reference in New Issue Copy Permalink