From 9ad52e9ba982284cbd1e3f19558ca0d20db12091 Mon Sep 17 00:00:00 2001 From: Roy Carter Date: Sun, 19 Apr 2026 10:59:15 +0300 Subject: [PATCH 01/10] Initial commit to add some more openssl compatibility layer functions --- src/bio.c | 24 ++++++++++ src/ssl.c | 23 +++++++-- tests/api.c | 96 +++++++++++++++++++++++++++++++++++++- tests/api/test_ossl_bio.c | 37 +++++++++++++++ tests/api/test_ossl_bio.h | 4 +- wolfcrypt/src/evp_pk.c | 39 ++++++++++++++++ wolfssl/openssl/bio.h | 2 + wolfssl/openssl/opensslv.h | 15 ++++++ wolfssl/openssl/ssl.h | 1 + wolfssl/ssl.h | 7 +++ 10 files changed, 241 insertions(+), 7 deletions(-) diff --git a/src/bio.c b/src/bio.c index 9d94144f57f..ecfb10fb66e 100644 --- a/src/bio.c +++ b/src/bio.c @@ -2119,6 +2119,30 @@ long wolfSSL_BIO_set_nbio(WOLFSSL_BIO* bio, long on) return WOLFSSL_SUCCESS; } +/* Returns a unique index for a new custom BIO type. + * In OpenSSL, custom BIO types start at BIO_TYPE_START (128|0x0200). + * wolfSSL uses a simpler scheme starting at 128. + * + * @return New unique BIO type index on success. + * @return -1 when the index space is exhausted. + */ +int wolfSSL_BIO_get_new_index(void) +{ + static int bio_type_idx = WOLFSSL_BIO_TYPE_START; + int idx; + + WOLFSSL_ENTER("wolfSSL_BIO_get_new_index"); + + idx = bio_type_idx; + if (idx > WOLFSSL_BIO_TYPE_MAX + WOLFSSL_BIO_TYPE_START) { + WOLFSSL_MSG("BIO type index space exhausted"); + return -1; + } + bio_type_idx++; + + return idx; +} + /* creates a new custom WOLFSSL_BIO_METHOD */ WOLFSSL_BIO_METHOD *wolfSSL_BIO_meth_new(int type, const char *name) { diff --git a/src/ssl.c b/src/ssl.c index 5368c107fa7..6d889f88d1f 100644 --- a/src/ssl.c +++ b/src/ssl.c @@ -5900,10 +5900,25 @@ const char* wolfSSL_lib_version(void) #ifdef OPENSSL_EXTRA #if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L -const char* wolfSSL_OpenSSL_version(int a) -{ - (void)a; - return "wolfSSL " LIBWOLFSSL_VERSION_STRING; +const char* wolfSSL_OpenSSL_version(int type) +{ + WOLFSSL_ENTER("wolfSSL_OpenSSL_version"); + switch (type) { + case OPENSSL_VERSION: + return "wolfSSL " LIBWOLFSSL_VERSION_STRING; + case OPENSSL_CFLAGS: + return "compiler: information not available"; + case OPENSSL_BUILT_ON: + return "built on: " __DATE__ " " __TIME__; + case OPENSSL_PLATFORM: + return "platform: information not available"; + case OPENSSL_DIR: + return "OPENSSLDIR: \"\""; + case OPENSSL_ENGINES_DIR: + return "ENGINESDIR: N/A"; + default: + return "wolfSSL " LIBWOLFSSL_VERSION_STRING; + } } #else const char* wolfSSL_OpenSSL_version(void) diff --git a/tests/api.c b/tests/api.c index 14f10ca8745..954ef5de093 100644 --- a/tests/api.c +++ b/tests/api.c @@ -20119,6 +20119,70 @@ defined(OPENSSL_EXTRA) && defined(WOLFSSL_DH_EXTRA) return EXPECT_RESULT(); } +static int test_wolfSSL_i2d_PUBKEY_bio(void) +{ + EXPECT_DECLS; +#if defined(OPENSSL_EXTRA) && !defined(NO_BIO) + BIO* bio = NULL; + EVP_PKEY* pkey = NULL; + EVP_PKEY* pkey2 = NULL; + + /* NULL parameter tests */ + ExpectIntEQ(wolfSSL_i2d_PUBKEY_bio(NULL, NULL), WOLFSSL_FAILURE); + +#if defined(USE_CERT_BUFFERS_2048) && !defined(NO_RSA) + { + const unsigned char* p = client_keypub_der_2048; + /* Load an RSA public key from DER buffer */ + ExpectNotNull(pkey = d2i_PUBKEY(NULL, &p, + sizeof_client_keypub_der_2048)); + + /* Write it to BIO */ + ExpectNotNull(bio = BIO_new(BIO_s_mem())); + ExpectIntEQ(i2d_PUBKEY_bio(bio, pkey), WOLFSSL_SUCCESS); + + /* Read it back and verify round-trip */ + ExpectNotNull(pkey2 = d2i_PUBKEY_bio(bio, NULL)); + + EVP_PKEY_free(pkey2); + pkey2 = NULL; + EVP_PKEY_free(pkey); + pkey = NULL; + BIO_free(bio); + bio = NULL; + } +#endif + +#if defined(USE_CERT_BUFFERS_256) && defined(HAVE_ECC) + { + const unsigned char* p = ecc_clikeypub_der_256; + /* Load an ECC public key from DER buffer */ + ExpectNotNull(pkey = d2i_PUBKEY(NULL, &p, + sizeof_ecc_clikeypub_der_256)); + + /* Write it to BIO */ + ExpectNotNull(bio = BIO_new(BIO_s_mem())); + ExpectIntEQ(i2d_PUBKEY_bio(bio, pkey), WOLFSSL_SUCCESS); + + /* Read it back and verify round-trip */ + ExpectNotNull(pkey2 = d2i_PUBKEY_bio(bio, NULL)); + + EVP_PKEY_free(pkey2); + pkey2 = NULL; + EVP_PKEY_free(pkey); + pkey = NULL; + BIO_free(bio); + bio = NULL; + } +#endif + + (void)pkey; + (void)pkey2; + (void)bio; +#endif + return EXPECT_RESULT(); +} + #if (defined(OPENSSL_ALL) || defined(WOLFSSL_ASIO)) && !defined(NO_RSA) && \ !defined(NO_TLS) static int test_wolfSSL_d2i_PrivateKeys_bio(void) @@ -30236,12 +30300,39 @@ static int test_wolfSSL_OpenSSL_version(void) const char* ver; #if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L - ExpectNotNull(ver = OpenSSL_version(0)); + ExpectNotNull(ver = OpenSSL_version(OPENSSL_VERSION)); + ExpectIntEQ(XMEMCMP(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING, + XSTRLEN("wolfSSL " LIBWOLFSSL_VERSION_STRING)), 0); + + /* Test OPENSSL_CFLAGS type */ + ExpectNotNull(ver = OpenSSL_version(OPENSSL_CFLAGS)); + ExpectNotNull(XSTRSTR(ver, "compiler:")); + + /* Test OPENSSL_BUILT_ON type */ + ExpectNotNull(ver = OpenSSL_version(OPENSSL_BUILT_ON)); + ExpectNotNull(XSTRSTR(ver, "built on:")); + + /* Test OPENSSL_PLATFORM type */ + ExpectNotNull(ver = OpenSSL_version(OPENSSL_PLATFORM)); + ExpectNotNull(XSTRSTR(ver, "platform:")); + + /* Test OPENSSL_DIR type */ + ExpectNotNull(ver = OpenSSL_version(OPENSSL_DIR)); + ExpectNotNull(XSTRSTR(ver, "OPENSSLDIR:")); + + /* Test OPENSSL_ENGINES_DIR type */ + ExpectNotNull(ver = OpenSSL_version(OPENSSL_ENGINES_DIR)); + ExpectNotNull(XSTRSTR(ver, "ENGINESDIR:")); + + /* Test unknown type falls back to version string */ + ExpectNotNull(ver = OpenSSL_version(99)); + ExpectIntEQ(XMEMCMP(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING, + XSTRLEN("wolfSSL " LIBWOLFSSL_VERSION_STRING)), 0); #else ExpectNotNull(ver = OpenSSL_version()); -#endif ExpectIntEQ(XMEMCMP(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING, XSTRLEN("wolfSSL " LIBWOLFSSL_VERSION_STRING)), 0); +#endif #endif return EXPECT_RESULT(); } @@ -38210,6 +38301,7 @@ TEST_CASE testCases[] = { TEST_DECL(test_wolfSSL_d2i_and_i2d_PublicKey_ecc), #ifndef NO_BIO TEST_DECL(test_wolfSSL_d2i_PUBKEY), + TEST_DECL(test_wolfSSL_i2d_PUBKEY_bio), #if defined(OPENSSL_EXTRA) && defined(WOLFSSL_HAVE_MLDSA) && \ defined(WOLFSSL_MLDSA_NO_ASN1) && !defined(WOLFSSL_NO_ML_DSA_44) && \ !defined(WOLFSSL_NO_ML_DSA_65) && !defined(WOLFSSL_MLDSA_NO_VERIFY) diff --git a/tests/api/test_ossl_bio.c b/tests/api/test_ossl_bio.c index 6223ee8f932..851e1dcec5b 100644 --- a/tests/api/test_ossl_bio.c +++ b/tests/api/test_ossl_bio.c @@ -1899,5 +1899,42 @@ int test_wolfSSL_BIO_get_init(void) return EXPECT_RESULT(); } +int test_wolfSSL_BIO_get_new_index(void) +{ + EXPECT_DECLS; +#if defined(OPENSSL_EXTRA) + int idx1, idx2, idx3; + BIO_METHOD* meth = NULL; + BIO* bio = NULL; + + /* Get three consecutive indices - should be unique and >= 128 */ + idx1 = BIO_get_new_index(); + idx2 = BIO_get_new_index(); + idx3 = BIO_get_new_index(); + + ExpectIntGE(idx1, BIO_TYPE_START); + ExpectIntGE(idx2, BIO_TYPE_START); + ExpectIntGE(idx3, BIO_TYPE_START); + + /* Each index must be unique */ + ExpectIntNE(idx1, idx2); + ExpectIntNE(idx2, idx3); + ExpectIntNE(idx1, idx3); + + /* Indices should be sequential */ + ExpectIntEQ(idx2, idx1 + 1); + ExpectIntEQ(idx3, idx2 + 1); + + /* Use returned index with BIO_meth_new */ + ExpectNotNull(meth = BIO_meth_new(idx1, "custom_test")); + ExpectNotNull(bio = BIO_new(meth)); + ExpectIntEQ(BIO_method_type(bio), idx1); + + BIO_free(bio); + BIO_meth_free(meth); +#endif + return EXPECT_RESULT(); +} + #endif /* !NO_BIO */ diff --git a/tests/api/test_ossl_bio.h b/tests/api/test_ossl_bio.h index 7aac4f4addf..de1140ad115 100644 --- a/tests/api/test_ossl_bio.h +++ b/tests/api/test_ossl_bio.h @@ -49,6 +49,7 @@ int test_wolfSSL_BIO_set_conn_hostname(void); int test_wolfSSL_BIO_ctrl_pending_chain(void); int test_wolfSSL_BIO_meth_type_large(void); int test_wolfSSL_BIO_get_init(void); +int test_wolfSSL_BIO_get_new_index(void); #define TEST_OSSL_BIO_DECLS \ TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_gets), \ @@ -70,7 +71,8 @@ int test_wolfSSL_BIO_get_init(void); TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_set_conn_hostname), \ TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_ctrl_pending_chain), \ TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_meth_type_large), \ - TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_get_init) + TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_get_init), \ + TEST_DECL_GROUP("ossl_bio", test_wolfSSL_BIO_get_new_index) #define TEST_OSSL_BIO_TLS_DECLS \ TEST_DECL_GROUP("ossl_bio_tls", test_wolfSSL_BIO_connect), \ diff --git a/wolfcrypt/src/evp_pk.c b/wolfcrypt/src/evp_pk.c index 73b9ddc3f6a..89ac5c9e1dc 100644 --- a/wolfcrypt/src/evp_pk.c +++ b/wolfcrypt/src/evp_pk.c @@ -2452,6 +2452,45 @@ int wolfSSL_i2d_PUBKEY(const WOLFSSL_EVP_PKEY *key, unsigned char **der) { return wolfSSL_i2d_PublicKey(key, der); } + +#ifndef NO_BIO +/* Encode public key as DER data and write to BIO. + * + * @param [in] bio BIO to write data to. + * @param [in] key Public key to encode. + * @return WOLFSSL_SUCCESS on success. + * @return WOLFSSL_FAILURE on failure. + */ +int wolfSSL_i2d_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key) +{ + int ret = WC_NO_ERR_TRACE(WOLFSSL_FAILURE); + int derSz = 0; + byte* der = NULL; + + WOLFSSL_ENTER("wolfSSL_i2d_PUBKEY_bio"); + + if (bio == NULL || key == NULL) { + return WOLFSSL_FAILURE; + } + + derSz = wolfSSL_i2d_PUBKEY(key, &der); + if (derSz <= 0) { + WOLFSSL_MSG("wolfSSL_i2d_PUBKEY failed"); + return WOLFSSL_FAILURE; + } + + if (wolfSSL_BIO_write(bio, der, derSz) != derSz) { + goto cleanup; + } + + ret = WOLFSSL_SUCCESS; + +cleanup: + XFREE(der, NULL, DYNAMIC_TYPE_OPENSSL); + return ret; +} +#endif /* !NO_BIO */ + #endif /* !NO_ASN && !NO_PWDBASED */ #endif /* OPENSSL_EXTRA */ diff --git a/wolfssl/openssl/bio.h b/wolfssl/openssl/bio.h index f797d94ab58..f34bc1450cf 100644 --- a/wolfssl/openssl/bio.h +++ b/wolfssl/openssl/bio.h @@ -138,6 +138,8 @@ #define BIO_TYPE_BIO WOLFSSL_BIO_BIO #define BIO_TYPE_MEM WOLFSSL_BIO_MEMORY #define BIO_TYPE_BASE64 WOLFSSL_BIO_BASE64 +#define BIO_TYPE_START WOLFSSL_BIO_TYPE_START +#define BIO_get_new_index wolfSSL_BIO_get_new_index #define BIO_vprintf wolfSSL_BIO_vprintf #define BIO_printf wolfSSL_BIO_printf diff --git a/wolfssl/openssl/opensslv.h b/wolfssl/openssl/opensslv.h index df75d9e0d43..a11284c9c34 100644 --- a/wolfssl/openssl/opensslv.h +++ b/wolfssl/openssl/opensslv.h @@ -68,6 +68,21 @@ #ifndef OPENSSL_VERSION #define OPENSSL_VERSION 0 #endif +#ifndef OPENSSL_CFLAGS + #define OPENSSL_CFLAGS 1 +#endif +#ifndef OPENSSL_BUILT_ON + #define OPENSSL_BUILT_ON 2 +#endif +#ifndef OPENSSL_PLATFORM + #define OPENSSL_PLATFORM 3 +#endif +#ifndef OPENSSL_DIR + #define OPENSSL_DIR 4 +#endif +#ifndef OPENSSL_ENGINES_DIR + #define OPENSSL_ENGINES_DIR 5 +#endif #ifndef OPENSSL_IS_WOLFSSL #define OPENSSL_IS_WOLFSSL diff --git a/wolfssl/openssl/ssl.h b/wolfssl/openssl/ssl.h index 5c95da71316..af0fb730644 100644 --- a/wolfssl/openssl/ssl.h +++ b/wolfssl/openssl/ssl.h @@ -273,6 +273,7 @@ typedef STACK_OF(ACCESS_DESCRIPTION) AUTHORITY_INFO_ACCESS; #define SSL_CTX_set_ecdh_auto wolfSSL_CTX_set_ecdh_auto #define i2d_PUBKEY wolfSSL_i2d_PUBKEY +#define i2d_PUBKEY_bio wolfSSL_i2d_PUBKEY_bio #define i2d_X509_PUBKEY wolfSSL_i2d_X509_PUBKEY #define d2i_PUBKEY wolfSSL_d2i_PUBKEY #define d2i_PUBKEY_bio wolfSSL_d2i_PUBKEY_bio diff --git a/wolfssl/ssl.h b/wolfssl/ssl.h index 423f027c740..e3e3e9c3481 100644 --- a/wolfssl/ssl.h +++ b/wolfssl/ssl.h @@ -782,6 +782,11 @@ enum BIO_TYPE { WOLFSSL_BIO_NULL = 10 }; +/* Starting index for custom BIO types returned by wolfSSL_BIO_get_new_index. + * Matches OpenSSL BIO_TYPE_START (128). */ +#define WOLFSSL_BIO_TYPE_START 128 +#define WOLFSSL_BIO_TYPE_MAX 255 + enum BIO_FLAGS { WOLFSSL_BIO_FLAG_BASE64_NO_NL = 0x01, WOLFSSL_BIO_FLAG_READ = 0x02, @@ -2193,6 +2198,7 @@ WOLFSSL_API int wolfSSL_BIO_should_retry(WOLFSSL_BIO *bio); WOLFSSL_API int wolfSSL_BIO_should_read(WOLFSSL_BIO *bio); WOLFSSL_API int wolfSSL_BIO_should_write(WOLFSSL_BIO *bio); +WOLFSSL_API int wolfSSL_BIO_get_new_index(void); WOLFSSL_API WOLFSSL_BIO_METHOD *wolfSSL_BIO_meth_new(int type, const char* name); WOLFSSL_API void wolfSSL_BIO_meth_free(WOLFSSL_BIO_METHOD* biom); WOLFSSL_API int wolfSSL_BIO_meth_set_write(WOLFSSL_BIO_METHOD* biom, wolfSSL_BIO_meth_write_cb biom_write); @@ -2489,6 +2495,7 @@ WOLFSSL_API WOLFSSL_EVP_PKEY* wolfSSL_d2i_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_API WOLFSSL_EVP_PKEY* wolfSSL_d2i_PUBKEY(WOLFSSL_EVP_PKEY** key, const unsigned char** in, long inSz); WOLFSSL_API int wolfSSL_i2d_PUBKEY(const WOLFSSL_EVP_PKEY *key, unsigned char **der); +WOLFSSL_API int wolfSSL_i2d_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key); WOLFSSL_API int wolfSSL_i2d_X509_PUBKEY(WOLFSSL_X509_PUBKEY* x509_PubKey, unsigned char** der); WOLFSSL_API WOLFSSL_EVP_PKEY* wolfSSL_d2i_PublicKey(int type, WOLFSSL_EVP_PKEY** pkey, From 901b75cbab515e38e06e63b5d2ab34ffb68b182f Mon Sep 17 00:00:00 2001 From: Roy Carter Date: Thu, 23 Apr 2026 21:27:48 +0300 Subject: [PATCH 02/10] Refactor : fix some buggy logic + cleaned code --- src/bio.c | 9 +-------- src/ssl.c | 6 +++--- tests/api/test_ossl_bio.c | 11 +++++++---- wolfcrypt/src/evp_pk.c | 6 ++++-- 4 files changed, 15 insertions(+), 17 deletions(-) diff --git a/src/bio.c b/src/bio.c index ecfb10fb66e..b964ec4737a 100644 --- a/src/bio.c +++ b/src/bio.c @@ -2119,13 +2119,6 @@ long wolfSSL_BIO_set_nbio(WOLFSSL_BIO* bio, long on) return WOLFSSL_SUCCESS; } -/* Returns a unique index for a new custom BIO type. - * In OpenSSL, custom BIO types start at BIO_TYPE_START (128|0x0200). - * wolfSSL uses a simpler scheme starting at 128. - * - * @return New unique BIO type index on success. - * @return -1 when the index space is exhausted. - */ int wolfSSL_BIO_get_new_index(void) { static int bio_type_idx = WOLFSSL_BIO_TYPE_START; @@ -2134,7 +2127,7 @@ int wolfSSL_BIO_get_new_index(void) WOLFSSL_ENTER("wolfSSL_BIO_get_new_index"); idx = bio_type_idx; - if (idx > WOLFSSL_BIO_TYPE_MAX + WOLFSSL_BIO_TYPE_START) { + if (idx > WOLFSSL_BIO_TYPE_MAX) { WOLFSSL_MSG("BIO type index space exhausted"); return -1; } diff --git a/src/ssl.c b/src/ssl.c index 6d889f88d1f..8c747080ebb 100644 --- a/src/ssl.c +++ b/src/ssl.c @@ -5913,7 +5913,7 @@ const char* wolfSSL_OpenSSL_version(int type) case OPENSSL_PLATFORM: return "platform: information not available"; case OPENSSL_DIR: - return "OPENSSLDIR: \"\""; + return "OPENSSLDIR: N/A"; case OPENSSL_ENGINES_DIR: return "ENGINESDIR: N/A"; default: @@ -5925,8 +5925,8 @@ const char* wolfSSL_OpenSSL_version(void) { return "wolfSSL " LIBWOLFSSL_VERSION_STRING; } -#endif /* WOLFSSL_QT */ -#endif +#endif /* OPENSSL_VERSION_NUMBER >= 0x10100000L */ +#endif /* OPENSSL_EXTRA */ /* current library version in hex */ diff --git a/tests/api/test_ossl_bio.c b/tests/api/test_ossl_bio.c index 851e1dcec5b..e197fc549e6 100644 --- a/tests/api/test_ossl_bio.c +++ b/tests/api/test_ossl_bio.c @@ -1907,23 +1907,26 @@ int test_wolfSSL_BIO_get_new_index(void) BIO_METHOD* meth = NULL; BIO* bio = NULL; - /* Get three consecutive indices - should be unique and >= 128 */ + /* Get three consecutive indices - should be unique and in valid range */ idx1 = BIO_get_new_index(); idx2 = BIO_get_new_index(); idx3 = BIO_get_new_index(); ExpectIntGE(idx1, BIO_TYPE_START); + ExpectIntLE(idx1, WOLFSSL_BIO_TYPE_MAX); ExpectIntGE(idx2, BIO_TYPE_START); + ExpectIntLE(idx2, WOLFSSL_BIO_TYPE_MAX); ExpectIntGE(idx3, BIO_TYPE_START); + ExpectIntLE(idx3, WOLFSSL_BIO_TYPE_MAX); /* Each index must be unique */ ExpectIntNE(idx1, idx2); ExpectIntNE(idx2, idx3); ExpectIntNE(idx1, idx3); - /* Indices should be sequential */ - ExpectIntEQ(idx2, idx1 + 1); - ExpectIntEQ(idx3, idx2 + 1); + /* Each consecutive call must return a strictly increasing value */ + ExpectIntGT(idx2, idx1); + ExpectIntGT(idx3, idx2); /* Use returned index with BIO_meth_new */ ExpectNotNull(meth = BIO_meth_new(idx1, "custom_test")); diff --git a/wolfcrypt/src/evp_pk.c b/wolfcrypt/src/evp_pk.c index 89ac5c9e1dc..1d381ff4bed 100644 --- a/wolfcrypt/src/evp_pk.c +++ b/wolfcrypt/src/evp_pk.c @@ -2473,8 +2473,10 @@ int wolfSSL_i2d_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key) return WOLFSSL_FAILURE; } + /* Let wolfSSL_i2d_PUBKEY allocate the buffer (pass NULL to trigger + * internal allocation). We free it ourselves after writing to the BIO. */ derSz = wolfSSL_i2d_PUBKEY(key, &der); - if (derSz <= 0) { + if (derSz <= 0 || der == NULL) { WOLFSSL_MSG("wolfSSL_i2d_PUBKEY failed"); return WOLFSSL_FAILURE; } @@ -2486,7 +2488,7 @@ int wolfSSL_i2d_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key) ret = WOLFSSL_SUCCESS; cleanup: - XFREE(der, NULL, DYNAMIC_TYPE_OPENSSL); + XFREE(der, NULL, DYNAMIC_TYPE_TMP_BUFFER); return ret; } #endif /* !NO_BIO */ From 842f1a7c0c78ce81302091e309c8106e92e9ad96 Mon Sep 17 00:00:00 2001 From: Roy Carter Date: Sun, 26 Apr 2026 09:57:14 +0300 Subject: [PATCH 03/10] Fix: Handle build errors with .deb package + date build time --- src/ssl.c | 4 ++++ tests/api.c | 3 ++- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/src/ssl.c b/src/ssl.c index 8c747080ebb..ac1cc5b0f69 100644 --- a/src/ssl.c +++ b/src/ssl.c @@ -5909,7 +5909,11 @@ const char* wolfSSL_OpenSSL_version(int type) case OPENSSL_CFLAGS: return "compiler: information not available"; case OPENSSL_BUILT_ON: +#ifdef HAVE_REPRODUCIBLE_BUILD + return "built on: date not available"; +#else return "built on: " __DATE__ " " __TIME__; +#endif case OPENSSL_PLATFORM: return "platform: information not available"; case OPENSSL_DIR: diff --git a/tests/api.c b/tests/api.c index 954ef5de093..b837bce7da8 100644 --- a/tests/api.c +++ b/tests/api.c @@ -20122,7 +20122,8 @@ defined(OPENSSL_EXTRA) && defined(WOLFSSL_DH_EXTRA) static int test_wolfSSL_i2d_PUBKEY_bio(void) { EXPECT_DECLS; -#if defined(OPENSSL_EXTRA) && !defined(NO_BIO) +#if defined(OPENSSL_EXTRA) && !defined(NO_BIO) && \ + !defined(NO_ASN) && !defined(NO_PWDBASED) BIO* bio = NULL; EVP_PKEY* pkey = NULL; EVP_PKEY* pkey2 = NULL; From 42a750d23c68379e9213ae2bb5b762b4b2e69bdb Mon Sep 17 00:00:00 2001 From: Roy Carter Date: Wed, 29 Apr 2026 13:20:12 +0300 Subject: [PATCH 04/10] Fix note regarding unitest handling --- tests/api.c | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/tests/api.c b/tests/api.c index b837bce7da8..690c0c4deab 100644 --- a/tests/api.c +++ b/tests/api.c @@ -30302,37 +30302,40 @@ static int test_wolfSSL_OpenSSL_version(void) #if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L ExpectNotNull(ver = OpenSSL_version(OPENSSL_VERSION)); - ExpectIntEQ(XMEMCMP(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING, - XSTRLEN("wolfSSL " LIBWOLFSSL_VERSION_STRING)), 0); + ExpectStrEQ(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING); /* Test OPENSSL_CFLAGS type */ ExpectNotNull(ver = OpenSSL_version(OPENSSL_CFLAGS)); - ExpectNotNull(XSTRSTR(ver, "compiler:")); + ExpectStrEQ(ver, "compiler: information not available"); /* Test OPENSSL_BUILT_ON type */ ExpectNotNull(ver = OpenSSL_version(OPENSSL_BUILT_ON)); - ExpectNotNull(XSTRSTR(ver, "built on:")); +#ifdef HAVE_REPRODUCIBLE_BUILD + ExpectStrEQ(ver, "built on: date not available"); +#else + /* __DATE__/__TIME__ differ between translation units, so just check + * the prefix is present. */ + ExpectNotNull(XSTRSTR(ver, "built on: ")); +#endif /* Test OPENSSL_PLATFORM type */ ExpectNotNull(ver = OpenSSL_version(OPENSSL_PLATFORM)); - ExpectNotNull(XSTRSTR(ver, "platform:")); + ExpectStrEQ(ver, "platform: information not available"); /* Test OPENSSL_DIR type */ ExpectNotNull(ver = OpenSSL_version(OPENSSL_DIR)); - ExpectNotNull(XSTRSTR(ver, "OPENSSLDIR:")); + ExpectStrEQ(ver, "OPENSSLDIR: N/A"); /* Test OPENSSL_ENGINES_DIR type */ ExpectNotNull(ver = OpenSSL_version(OPENSSL_ENGINES_DIR)); - ExpectNotNull(XSTRSTR(ver, "ENGINESDIR:")); + ExpectStrEQ(ver, "ENGINESDIR: N/A"); /* Test unknown type falls back to version string */ ExpectNotNull(ver = OpenSSL_version(99)); - ExpectIntEQ(XMEMCMP(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING, - XSTRLEN("wolfSSL " LIBWOLFSSL_VERSION_STRING)), 0); + ExpectStrEQ(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING); #else ExpectNotNull(ver = OpenSSL_version()); - ExpectIntEQ(XMEMCMP(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING, - XSTRLEN("wolfSSL " LIBWOLFSSL_VERSION_STRING)), 0); + ExpectStrEQ(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING); #endif #endif return EXPECT_RESULT(); From fce97640879139cd607921ff707ed211e058b99d Mon Sep 17 00:00:00 2001 From: Roy Carter Date: Fri, 22 May 2026 19:15:34 +0300 Subject: [PATCH 05/10] Refactor - Implement PR fix for better behavior --- src/ssl.c | 2 +- wolfcrypt/src/evp_pk.c | 22 +++++++++++++++++----- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/src/ssl.c b/src/ssl.c index ac1cc5b0f69..6c5afc5cd13 100644 --- a/src/ssl.c +++ b/src/ssl.c @@ -5921,7 +5921,7 @@ const char* wolfSSL_OpenSSL_version(int type) case OPENSSL_ENGINES_DIR: return "ENGINESDIR: N/A"; default: - return "wolfSSL " LIBWOLFSSL_VERSION_STRING; + return "not available"; } } #else diff --git a/wolfcrypt/src/evp_pk.c b/wolfcrypt/src/evp_pk.c index 1d381ff4bed..b1cf7cbe0d3 100644 --- a/wolfcrypt/src/evp_pk.c +++ b/wolfcrypt/src/evp_pk.c @@ -2466,6 +2466,7 @@ int wolfSSL_i2d_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key) int ret = WC_NO_ERR_TRACE(WOLFSSL_FAILURE); int derSz = 0; byte* der = NULL; + byte* derPtr = NULL; WOLFSSL_ENTER("wolfSSL_i2d_PUBKEY_bio"); @@ -2473,14 +2474,25 @@ int wolfSSL_i2d_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key) return WOLFSSL_FAILURE; } - /* Let wolfSSL_i2d_PUBKEY allocate the buffer (pass NULL to trigger - * internal allocation). We free it ourselves after writing to the BIO. */ - derSz = wolfSSL_i2d_PUBKEY(key, &der); - if (derSz <= 0 || der == NULL) { - WOLFSSL_MSG("wolfSSL_i2d_PUBKEY failed"); + derSz = wolfSSL_i2d_PUBKEY(key, NULL); + if (derSz <= 0) { + WOLFSSL_MSG("wolfSSL_i2d_PUBKEY size query failed"); + return WOLFSSL_FAILURE; + } + + der = (byte*)XMALLOC((size_t)derSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); + if (der == NULL) { + WOLFSSL_MSG("XMALLOC failed"); return WOLFSSL_FAILURE; } + derPtr = der; + derSz = wolfSSL_i2d_PUBKEY(key, &derPtr); + if (derSz <= 0) { + WOLFSSL_MSG("wolfSSL_i2d_PUBKEY failed"); + goto cleanup; + } + if (wolfSSL_BIO_write(bio, der, derSz) != derSz) { goto cleanup; } From 68393e25c9eb5bf7ec26402e806ea3ff770f9bcc Mon Sep 17 00:00:00 2001 From: Roy Carter Date: Sun, 7 Jun 2026 09:21:54 +0300 Subject: [PATCH 06/10] Fix - change test string default case --- tests/api.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/api.c b/tests/api.c index 690c0c4deab..81b8a36be32 100644 --- a/tests/api.c +++ b/tests/api.c @@ -30332,7 +30332,7 @@ static int test_wolfSSL_OpenSSL_version(void) /* Test unknown type falls back to version string */ ExpectNotNull(ver = OpenSSL_version(99)); - ExpectStrEQ(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING); + ExpectStrEQ(ver, "not available"); #else ExpectNotNull(ver = OpenSSL_version()); ExpectStrEQ(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING); From 416e34d47dd9621583f24bf7e6debe1a02d98e4e Mon Sep 17 00:00:00 2001 From: Roy Carter Date: Sun, 21 Jun 2026 15:16:45 +0300 Subject: [PATCH 07/10] Remove old comment --- tests/api.c | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/api.c b/tests/api.c index 81b8a36be32..5437f6f3080 100644 --- a/tests/api.c +++ b/tests/api.c @@ -30330,7 +30330,6 @@ static int test_wolfSSL_OpenSSL_version(void) ExpectNotNull(ver = OpenSSL_version(OPENSSL_ENGINES_DIR)); ExpectStrEQ(ver, "ENGINESDIR: N/A"); - /* Test unknown type falls back to version string */ ExpectNotNull(ver = OpenSSL_version(99)); ExpectStrEQ(ver, "not available"); #else From 18302aed7d8e39b5806bed72cefc73b06ff7a75a Mon Sep 17 00:00:00 2001 From: Juliusz Sosinowicz Date: Tue, 28 Jul 2026 09:52:28 +0000 Subject: [PATCH 08/10] Fix wolfSSL_OpenSSL_version prototype mismatch wolfSSL_OpenSSL_version() was declared with either an int or a void parameter list depending on OPENSSL_VERSION_NUMBER. That macro does not evaluate the same way in the library and in the application: with OPENSSL_COEXIST the library additionally pulls in the real OpenSSL headers and gets their version number, while an application that turns coexist off gets wolfSSL's default. The two builds then disagreed on the argument list and the selector read garbage, so OpenSSL_version() always hit the default case. Give the function a single unconditional signature. Also match the test guards for wolfSSL_i2d_PUBKEY_bio and wolfSSL_OpenSSL_version to the guards on their implementations. --- src/ssl.c | 16 ++++------------ tests/api.c | 14 ++++++-------- wolfssl/openssl/ssl.h | 4 ---- wolfssl/ssl.h | 6 +----- 4 files changed, 11 insertions(+), 29 deletions(-) diff --git a/src/ssl.c b/src/ssl.c index 6c5afc5cd13..cfe4f0cc3f4 100644 --- a/src/ssl.c +++ b/src/ssl.c @@ -5562,12 +5562,7 @@ size_t wolfSSL_get_client_random(const WOLFSSL* ssl, unsigned char* out, const char* wolfSSLeay_version(int type) { - (void)type; -#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L return wolfSSL_OpenSSL_version(type); -#else - return wolfSSL_OpenSSL_version(); -#endif } #endif /* OPENSSL_EXTRA */ @@ -5899,7 +5894,10 @@ const char* wolfSSL_lib_version(void) } #ifdef OPENSSL_EXTRA -#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L +/* Signature deliberately does not depend on OPENSSL_VERSION_NUMBER. That macro + * can evaluate differently in the library and in the application (e.g. under + * OPENSSL_COEXIST the library also sees the real OpenSSL headers), which would + * make the caller and the definition disagree on the argument list. */ const char* wolfSSL_OpenSSL_version(int type) { WOLFSSL_ENTER("wolfSSL_OpenSSL_version"); @@ -5924,12 +5922,6 @@ const char* wolfSSL_OpenSSL_version(int type) return "not available"; } } -#else -const char* wolfSSL_OpenSSL_version(void) -{ - return "wolfSSL " LIBWOLFSSL_VERSION_STRING; -} -#endif /* OPENSSL_VERSION_NUMBER >= 0x10100000L */ #endif /* OPENSSL_EXTRA */ diff --git a/tests/api.c b/tests/api.c index 5437f6f3080..0d8d281c598 100644 --- a/tests/api.c +++ b/tests/api.c @@ -20122,8 +20122,10 @@ defined(OPENSSL_EXTRA) && defined(WOLFSSL_DH_EXTRA) static int test_wolfSSL_i2d_PUBKEY_bio(void) { EXPECT_DECLS; -#if defined(OPENSSL_EXTRA) && !defined(NO_BIO) && \ - !defined(NO_ASN) && !defined(NO_PWDBASED) +/* Guards must match wolfSSL_i2d_PUBKEY_bio() in wolfcrypt/src/evp_pk.c. */ +#if defined(OPENSSL_EXTRA) && !defined(WOLFCRYPT_ONLY) && \ + !defined(NO_CERTS) && !defined(NO_BIO) && !defined(NO_ASN) && \ + !defined(NO_PWDBASED) BIO* bio = NULL; EVP_PKEY* pkey = NULL; EVP_PKEY* pkey2 = NULL; @@ -30297,10 +30299,9 @@ static int test_wolfSSL_CTX_set_timeout(void) static int test_wolfSSL_OpenSSL_version(void) { EXPECT_DECLS; -#if defined(OPENSSL_EXTRA) +#if defined(OPENSSL_EXTRA) && !defined(WOLFCRYPT_ONLY) const char* ver; -#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L ExpectNotNull(ver = OpenSSL_version(OPENSSL_VERSION)); ExpectStrEQ(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING); @@ -30330,12 +30331,9 @@ static int test_wolfSSL_OpenSSL_version(void) ExpectNotNull(ver = OpenSSL_version(OPENSSL_ENGINES_DIR)); ExpectStrEQ(ver, "ENGINESDIR: N/A"); + /* Unknown selector returns the OpenSSL fallback string. */ ExpectNotNull(ver = OpenSSL_version(99)); ExpectStrEQ(ver, "not available"); -#else - ExpectNotNull(ver = OpenSSL_version()); - ExpectStrEQ(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING); -#endif #endif return EXPECT_RESULT(); } diff --git a/wolfssl/openssl/ssl.h b/wolfssl/openssl/ssl.h index af0fb730644..1b28b695780 100644 --- a/wolfssl/openssl/ssl.h +++ b/wolfssl/openssl/ssl.h @@ -1878,11 +1878,7 @@ typedef WOLFSSL_SRTP_PROTECTION_PROFILE SRTP_PROTECTION_PROFILE; #define X509_OBJECT_new wolfSSL_X509_OBJECT_new #define X509_OBJECT_free wolfSSL_X509_OBJECT_free #define X509_OBJECT_get_type wolfSSL_X509_OBJECT_get_type -#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L #define OpenSSL_version(x) wolfSSL_OpenSSL_version(x) -#else -#define OpenSSL_version(x) wolfSSL_OpenSSL_version() -#endif #define X509_OBJECT_retrieve_by_subject wolfSSL_X509_OBJECT_retrieve_by_subject diff --git a/wolfssl/ssl.h b/wolfssl/ssl.h index e3e3e9c3481..1dbf226b0b2 100644 --- a/wolfssl/ssl.h +++ b/wolfssl/ssl.h @@ -3539,11 +3539,7 @@ WOLFSSL_API void wolfSSL_set_security_level(WOLFSSL * ssl, int level); /* which library version do we have */ WOLFSSL_API const char* wolfSSL_lib_version(void); -#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L -WOLFSSL_API const char* wolfSSL_OpenSSL_version(int a); -#else -WOLFSSL_API const char* wolfSSL_OpenSSL_version(void); -#endif +WOLFSSL_API const char* wolfSSL_OpenSSL_version(int type); /* which library version do we have in hex */ WOLFSSL_API word32 wolfSSL_lib_version_hex(void); From 8297038499b2ec32e8bd9250e043f08e885e94b1 Mon Sep 17 00:00:00 2001 From: Juliusz Sosinowicz Date: Wed, 29 Jul 2026 14:41:23 +0000 Subject: [PATCH 09/10] Don't use __DATE__/__TIME__ in kernel module builds The Linux kernel build compiles with -Werror=date-time, so OPENSSL_BUILT_ON broke libwolfssl.ko. --- src/ssl.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/ssl.c b/src/ssl.c index cfe4f0cc3f4..78ac47af3b4 100644 --- a/src/ssl.c +++ b/src/ssl.c @@ -5907,7 +5907,8 @@ const char* wolfSSL_OpenSSL_version(int type) case OPENSSL_CFLAGS: return "compiler: information not available"; case OPENSSL_BUILT_ON: -#ifdef HAVE_REPRODUCIBLE_BUILD + /* Kernel module builds compile with -Werror=date-time. */ +#if defined(HAVE_REPRODUCIBLE_BUILD) || defined(WOLFSSL_LINUXKM) return "built on: date not available"; #else return "built on: " __DATE__ " " __TIME__; From 549d18e02011e1bb3d63d1ac289b3cf59d6bb135 Mon Sep 17 00:00:00 2001 From: Juliusz Sosinowicz Date: Wed, 5 Aug 2026 11:31:12 +0000 Subject: [PATCH 10/10] Address review: BIO/EVP/OpenSSL_version compat feedback - wolfSSL_BIO_get_new_index: claim the index atomically when atomics are available (zero-initialized count), with a plain-increment fallback; return WOLFSSL_FATAL_ERROR on exhaustion. - wolfSSL_i2d_PUBKEY_bio: make key const and use bio->heap for the temp buffer alloc/free. - OpenSSL_version: add WOLFSSL_OPENSSL_NO_BUILD_DATE to drop the build date without the full reproducible-build option. - Add BIO_TYPE_MASK compat alias and use it in the test. --- src/bio.c | 21 ++++++++++++++++++++- src/ssl.c | 7 +++++-- tests/api/test_ossl_bio.c | 6 +++--- wolfcrypt/src/evp_pk.c | 6 +++--- wolfssl/openssl/bio.h | 1 + wolfssl/ssl.h | 5 ++++- 6 files changed, 36 insertions(+), 10 deletions(-) diff --git a/src/bio.c b/src/bio.c index b964ec4737a..78805b5819c 100644 --- a/src/bio.c +++ b/src/bio.c @@ -2121,6 +2121,24 @@ long wolfSSL_BIO_set_nbio(WOLFSSL_BIO* bio, long on) int wolfSSL_BIO_get_new_index(void) { +#if defined(WOLFSSL_ATOMIC_OPS) && !defined(SINGLE_THREADED) + /* Zero-initialized count (no initializer needed); atomically claim the next + * offset so concurrent callers get distinct indices without a lock. The + * first index returned is WOLFSSL_BIO_TYPE_START. */ + static wolfSSL_Atomic_Int bio_type_count; + int idx; + + WOLFSSL_ENTER("wolfSSL_BIO_get_new_index"); + + idx = WOLFSSL_BIO_TYPE_START + + (int)wolfSSL_Atomic_Int_FetchAdd(&bio_type_count, 1); + if (idx > WOLFSSL_BIO_TYPE_MAX) { + WOLFSSL_MSG("BIO type index space exhausted"); + return WOLFSSL_FATAL_ERROR; + } + + return idx; +#else static int bio_type_idx = WOLFSSL_BIO_TYPE_START; int idx; @@ -2129,11 +2147,12 @@ int wolfSSL_BIO_get_new_index(void) idx = bio_type_idx; if (idx > WOLFSSL_BIO_TYPE_MAX) { WOLFSSL_MSG("BIO type index space exhausted"); - return -1; + return WOLFSSL_FATAL_ERROR; } bio_type_idx++; return idx; +#endif } /* creates a new custom WOLFSSL_BIO_METHOD */ diff --git a/src/ssl.c b/src/ssl.c index 78ac47af3b4..9dd748627f5 100644 --- a/src/ssl.c +++ b/src/ssl.c @@ -5907,8 +5907,11 @@ const char* wolfSSL_OpenSSL_version(int type) case OPENSSL_CFLAGS: return "compiler: information not available"; case OPENSSL_BUILT_ON: - /* Kernel module builds compile with -Werror=date-time. */ -#if defined(HAVE_REPRODUCIBLE_BUILD) || defined(WOLFSSL_LINUXKM) + /* Kernel module builds compile with -Werror=date-time. Define + * WOLFSSL_OPENSSL_NO_BUILD_DATE to drop the date without needing the + * full reproducible-build option. */ +#if defined(HAVE_REPRODUCIBLE_BUILD) || defined(WOLFSSL_LINUXKM) || \ + defined(WOLFSSL_OPENSSL_NO_BUILD_DATE) return "built on: date not available"; #else return "built on: " __DATE__ " " __TIME__; diff --git a/tests/api/test_ossl_bio.c b/tests/api/test_ossl_bio.c index e197fc549e6..0e04aa3f440 100644 --- a/tests/api/test_ossl_bio.c +++ b/tests/api/test_ossl_bio.c @@ -1913,11 +1913,11 @@ int test_wolfSSL_BIO_get_new_index(void) idx3 = BIO_get_new_index(); ExpectIntGE(idx1, BIO_TYPE_START); - ExpectIntLE(idx1, WOLFSSL_BIO_TYPE_MAX); + ExpectIntLE(idx1, BIO_TYPE_MASK); ExpectIntGE(idx2, BIO_TYPE_START); - ExpectIntLE(idx2, WOLFSSL_BIO_TYPE_MAX); + ExpectIntLE(idx2, BIO_TYPE_MASK); ExpectIntGE(idx3, BIO_TYPE_START); - ExpectIntLE(idx3, WOLFSSL_BIO_TYPE_MAX); + ExpectIntLE(idx3, BIO_TYPE_MASK); /* Each index must be unique */ ExpectIntNE(idx1, idx2); diff --git a/wolfcrypt/src/evp_pk.c b/wolfcrypt/src/evp_pk.c index b1cf7cbe0d3..b61d98f8e72 100644 --- a/wolfcrypt/src/evp_pk.c +++ b/wolfcrypt/src/evp_pk.c @@ -2461,7 +2461,7 @@ int wolfSSL_i2d_PUBKEY(const WOLFSSL_EVP_PKEY *key, unsigned char **der) * @return WOLFSSL_SUCCESS on success. * @return WOLFSSL_FAILURE on failure. */ -int wolfSSL_i2d_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key) +int wolfSSL_i2d_PUBKEY_bio(WOLFSSL_BIO* bio, const WOLFSSL_EVP_PKEY* key) { int ret = WC_NO_ERR_TRACE(WOLFSSL_FAILURE); int derSz = 0; @@ -2480,7 +2480,7 @@ int wolfSSL_i2d_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key) return WOLFSSL_FAILURE; } - der = (byte*)XMALLOC((size_t)derSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); + der = (byte*)XMALLOC((size_t)derSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (der == NULL) { WOLFSSL_MSG("XMALLOC failed"); return WOLFSSL_FAILURE; @@ -2500,7 +2500,7 @@ int wolfSSL_i2d_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key) ret = WOLFSSL_SUCCESS; cleanup: - XFREE(der, NULL, DYNAMIC_TYPE_TMP_BUFFER); + XFREE(der, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); return ret; } #endif /* !NO_BIO */ diff --git a/wolfssl/openssl/bio.h b/wolfssl/openssl/bio.h index f34bc1450cf..a650607e190 100644 --- a/wolfssl/openssl/bio.h +++ b/wolfssl/openssl/bio.h @@ -139,6 +139,7 @@ #define BIO_TYPE_MEM WOLFSSL_BIO_MEMORY #define BIO_TYPE_BASE64 WOLFSSL_BIO_BASE64 #define BIO_TYPE_START WOLFSSL_BIO_TYPE_START +#define BIO_TYPE_MASK WOLFSSL_BIO_TYPE_MASK #define BIO_get_new_index wolfSSL_BIO_get_new_index #define BIO_vprintf wolfSSL_BIO_vprintf diff --git a/wolfssl/ssl.h b/wolfssl/ssl.h index 1dbf226b0b2..761300e4412 100644 --- a/wolfssl/ssl.h +++ b/wolfssl/ssl.h @@ -786,6 +786,8 @@ enum BIO_TYPE { * Matches OpenSSL BIO_TYPE_START (128). */ #define WOLFSSL_BIO_TYPE_START 128 #define WOLFSSL_BIO_TYPE_MAX 255 +/* Mask for the BIO type bits. Matches OpenSSL BIO_TYPE_MASK (0xFF). */ +#define WOLFSSL_BIO_TYPE_MASK 0xFF enum BIO_FLAGS { WOLFSSL_BIO_FLAG_BASE64_NO_NL = 0x01, @@ -2495,7 +2497,8 @@ WOLFSSL_API WOLFSSL_EVP_PKEY* wolfSSL_d2i_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_API WOLFSSL_EVP_PKEY* wolfSSL_d2i_PUBKEY(WOLFSSL_EVP_PKEY** key, const unsigned char** in, long inSz); WOLFSSL_API int wolfSSL_i2d_PUBKEY(const WOLFSSL_EVP_PKEY *key, unsigned char **der); -WOLFSSL_API int wolfSSL_i2d_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key); +WOLFSSL_API int wolfSSL_i2d_PUBKEY_bio(WOLFSSL_BIO* bio, + const WOLFSSL_EVP_PKEY* key); WOLFSSL_API int wolfSSL_i2d_X509_PUBKEY(WOLFSSL_X509_PUBKEY* x509_PubKey, unsigned char** der); WOLFSSL_API WOLFSSL_EVP_PKEY* wolfSSL_d2i_PublicKey(int type, WOLFSSL_EVP_PKEY** pkey,