Add OpenSSL compat: BIO_get_new_index, i2d_PUBKEY_bio, OpenSSL_version

src/bio.c

@@ -2099,6 +2099,23 @@ long wolfSSL_BIO_set_nbio(WOLFSSL_BIO* bio, long on)
     return WOLFSSL_SUCCESS;
 }
 
+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_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)
 {

src/ssl.c

@@ -10856,18 +10856,37 @@ 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:
+#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:
+            return "OPENSSLDIR: N/A";
+        case OPENSSL_ENGINES_DIR:
+            return "ENGINESDIR: N/A";
+        default:
+            return "not available";
+    }
 }
 #else
 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 */

tests/api.c

@@ -18519,6 +18519,71 @@ 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) && \
+    !defined(NO_ASN) && !defined(NO_PWDBASED)
+    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)
@@ -27620,12 +27685,42 @@ 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));
+    ExpectStrEQ(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING);
+
+    /* Test OPENSSL_CFLAGS type */
+    ExpectNotNull(ver = OpenSSL_version(OPENSSL_CFLAGS));
+    ExpectStrEQ(ver, "compiler: information not available");
+
+    /* Test OPENSSL_BUILT_ON type */
+    ExpectNotNull(ver = OpenSSL_version(OPENSSL_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));
+    ExpectStrEQ(ver, "platform: information not available");
+
+    /* Test OPENSSL_DIR type */
+    ExpectNotNull(ver = OpenSSL_version(OPENSSL_DIR));
+    ExpectStrEQ(ver, "OPENSSLDIR: N/A");
+
+    /* Test OPENSSL_ENGINES_DIR type */
+    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
     ExpectNotNull(ver = OpenSSL_version());
+    ExpectStrEQ(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING);
 #endif
-    ExpectIntEQ(XMEMCMP(ver, "wolfSSL " LIBWOLFSSL_VERSION_STRING,
-        XSTRLEN("wolfSSL " LIBWOLFSSL_VERSION_STRING)), 0);
 #endif
     return EXPECT_RESULT();
 }
@@ -34672,6 +34767,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),
 #endif
     TEST_DECL(test_wolfSSL_d2i_and_i2d_DSAparams),
     TEST_DECL(test_wolfSSL_i2d_PrivateKey),

tests/api/test_ossl_bio.c

@@ -1827,5 +1827,45 @@ 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 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);
+
+    /* 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"));
+    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 */
 

tests/api/test_ossl_bio.h

@@ -47,6 +47,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),           \
@@ -66,7 +67,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),    \

wolfcrypt/src/evp_pk.c

@@ -2420,6 +2420,59 @@ 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;
+    byte* derPtr = NULL;
+
+    WOLFSSL_ENTER("wolfSSL_i2d_PUBKEY_bio");
+
+    if (bio == NULL || key == NULL) {
+        return WOLFSSL_FAILURE;
+    }
+
+    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;
+    }
+
+    ret = WOLFSSL_SUCCESS;
+
+cleanup:
+    XFREE(der, NULL, DYNAMIC_TYPE_TMP_BUFFER);
+    return ret;
+}
+#endif /* !NO_BIO */
+
 #endif /* !NO_ASN && !NO_PWDBASED */
 
 #endif /* OPENSSL_EXTRA */

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

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

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

wolfssl/ssl.h

@@ -772,6 +772,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,
@@ -2176,6 +2181,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);
@@ -2468,6 +2474,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,