luna - wolfssl/tests/api/test_ossl

   1/* test_ossl_bio.c
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22#include <tests/unit.h>
  23
  24#ifdef NO_INLINE
  25    #include <wolfssl/wolfcrypt/misc.h>
  26#else
  27    #define WOLFSSL_MISC_INCLUDED
  28    #include <wolfcrypt/src/misc.c>
  29#endif
  30
  31#include <wolfssl/openssl/bio.h>
  32#include <wolfssl/openssl/buffer.h>
  33#include <wolfssl/wolfcrypt/types.h>
  34#include <tests/api/api.h>
  35#include <tests/api/test_ossl_bio.h>
  36
  37/*******************************************************************************
  38 * BIO OpenSSL compatibility API Testing
  39 ******************************************************************************/
  40
  41#ifndef NO_BIO
  42
  43int test_wolfSSL_BIO_gets(void)
  44{
  45    EXPECT_DECLS;
  46#if defined(OPENSSL_EXTRA)
  47    BIO* bio = NULL;
  48    BIO* bio2 = NULL;
  49    char msg[] = "\nhello wolfSSL\n security plus\t---...**adf\na...b.c";
  50    char emp[] = "";
  51    char bio_buffer[20];
  52    int bufferSz = 20;
  53#ifdef OPENSSL_ALL
  54    BUF_MEM* emp_bm = NULL;
  55    BUF_MEM* msg_bm = NULL;
  56#endif
  57
  58    /* try with bad args */
  59    ExpectNull(bio = BIO_new_mem_buf(NULL, sizeof(msg)));
  60#ifdef OPENSSL_ALL
  61    ExpectIntEQ(BIO_set_mem_buf(bio, NULL, BIO_NOCLOSE),
  62        WC_NO_ERR_TRACE(BAD_FUNC_ARG));
  63#endif
  64
  65    /* try with real msg */
  66    ExpectNotNull(bio = BIO_new_mem_buf((void*)msg, -1));
  67    XMEMSET(bio_buffer, 0, bufferSz);
  68    ExpectNotNull(BIO_push(bio, BIO_new(BIO_s_bio())));
  69    ExpectNull(bio2 = BIO_find_type(bio, BIO_TYPE_FILE));
  70    ExpectNotNull(bio2 = BIO_find_type(bio, BIO_TYPE_BIO));
  71    ExpectFalse(bio2 != BIO_next(bio));
  72
  73    /* make buffer filled with no terminating characters */
  74    XMEMSET(bio_buffer, 1, bufferSz);
  75
  76    /* BIO_gets reads a line of data */
  77    ExpectIntEQ(BIO_gets(bio, bio_buffer, -3), 0);
  78    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 1);
  79    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 14);
  80    ExpectStrEQ(bio_buffer, "hello wolfSSL\n");
  81    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 19);
  82    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 8);
  83    ExpectIntEQ(BIO_gets(bio, bio_buffer, -1), 0);
  84
  85#ifdef OPENSSL_ALL
  86    /* test setting the mem_buf manually */
  87    BIO_free(bio);
  88    ExpectNotNull(bio = BIO_new_mem_buf((void*)msg, -1));
  89    ExpectNotNull(emp_bm = BUF_MEM_new());
  90    ExpectNotNull(msg_bm = BUF_MEM_new());
  91    ExpectIntEQ(BUF_MEM_grow(msg_bm, sizeof(msg)), sizeof(msg));
  92    if (EXPECT_SUCCESS()) {
  93        XFREE(msg_bm->data, NULL, DYNAMIC_TYPE_OPENSSL);
  94        msg_bm->data = NULL;
  95    }
  96    /* emp size is 1 for terminator */
  97    ExpectIntEQ(BUF_MEM_grow(emp_bm, sizeof(emp)), sizeof(emp));
  98    if (EXPECT_SUCCESS()) {
  99        XFREE(emp_bm->data, NULL, DYNAMIC_TYPE_OPENSSL);
 100        emp_bm->data = emp;
 101        msg_bm->data = msg;
 102    }
 103    ExpectIntEQ(BIO_set_mem_buf(bio, emp_bm, BIO_CLOSE), WOLFSSL_SUCCESS);
 104
 105    /* check reading an empty string */
 106    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 1); /* just terminator */
 107    ExpectStrEQ(emp, bio_buffer);
 108    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 0); /* Nothing to read */
 109
 110    /* BIO_gets reads a line of data */
 111    ExpectIntEQ(BIO_set_mem_buf(bio, msg_bm, BIO_NOCLOSE), WOLFSSL_SUCCESS);
 112    ExpectIntEQ(BIO_gets(bio, bio_buffer, -3), 0);
 113    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 1);
 114    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 14);
 115    ExpectStrEQ(bio_buffer, "hello wolfSSL\n");
 116    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 19);
 117    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 8);
 118    ExpectIntEQ(BIO_gets(bio, bio_buffer, -1), 0);
 119
 120    if (EXPECT_SUCCESS())
 121        emp_bm->data = NULL;
 122    BUF_MEM_free(emp_bm);
 123    if (EXPECT_SUCCESS())
 124        msg_bm->data = NULL;
 125    BUF_MEM_free(msg_bm);
 126#endif
 127
 128    /* check not null terminated string */
 129    BIO_free(bio);
 130    bio = NULL;
 131    msg[0] = 0x33;
 132    msg[1] = 0x33;
 133    msg[2] = 0x33;
 134    ExpectNotNull(bio = BIO_new_mem_buf((void*)msg, 3));
 135    ExpectIntEQ(BIO_gets(bio, bio_buffer, 3), 2);
 136    ExpectIntEQ(bio_buffer[0], msg[0]);
 137    ExpectIntEQ(bio_buffer[1], msg[1]);
 138    ExpectIntNE(bio_buffer[2], msg[2]);
 139
 140    BIO_free(bio);
 141    bio = NULL;
 142    msg[3]    = 0x33;
 143    bio_buffer[3] = 0x33;
 144    ExpectNotNull(bio = BIO_new_mem_buf((void*)msg, 3));
 145    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 3);
 146    ExpectIntEQ(bio_buffer[0], msg[0]);
 147    ExpectIntEQ(bio_buffer[1], msg[1]);
 148    ExpectIntEQ(bio_buffer[2], msg[2]);
 149    ExpectIntNE(bio_buffer[3], 0x33); /* make sure null terminator was set */
 150
 151    /* check reading an empty string */
 152    BIO_free(bio);
 153    bio = NULL;
 154    ExpectNotNull(bio = BIO_new_mem_buf((void*)emp, sizeof(emp)));
 155    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 1); /* just terminator */
 156    ExpectStrEQ(emp, bio_buffer);
 157    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 0); /* Nothing to read */
 158
 159    /* check error cases */
 160    BIO_free(bio);
 161    bio = NULL;
 162    ExpectIntEQ(BIO_gets(NULL, NULL, 0), WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 163    ExpectNotNull(bio = BIO_new(BIO_s_mem()));
 164    ExpectIntEQ(BIO_gets(bio, bio_buffer, 2), 0); /* nothing to read */
 165
 166#if !defined(NO_FILESYSTEM)
 167    {
 168        BIO*  f_bio = NULL;
 169        XFILE f = XBADFILE;
 170
 171        ExpectNotNull(f_bio = BIO_new(BIO_s_file()));
 172        ExpectIntLE(BIO_gets(f_bio, bio_buffer, bufferSz), 0);
 173
 174        ExpectTrue((f = XFOPEN(svrCertFile, "rb")) != XBADFILE);
 175        ExpectIntEQ((int)BIO_set_fp(f_bio, f, BIO_CLOSE), SSL_SUCCESS);
 176        if (EXPECT_FAIL() && (f != XBADFILE)) {
 177            XFCLOSE(f);
 178        }
 179        ExpectIntGT(BIO_gets(f_bio, bio_buffer, bufferSz), 0);
 180
 181        BIO_free(f_bio);
 182        f_bio = NULL;
 183    }
 184#endif /* NO_FILESYSTEM */
 185
 186    BIO_free(bio);
 187    bio = NULL;
 188    BIO_free(bio2);
 189    bio2 = NULL;
 190
 191    /* try with type BIO */
 192    XMEMCPY(msg, "\nhello wolfSSL\n security plus\t---...**adf\na...b.c",
 193        sizeof(msg));
 194    ExpectNotNull(bio = BIO_new(BIO_s_bio()));
 195    ExpectIntEQ(BIO_gets(bio, bio_buffer, 2), 0); /* nothing to read */
 196    ExpectNotNull(bio2 = BIO_new(BIO_s_bio()));
 197
 198    ExpectIntEQ(BIO_set_write_buf_size(bio, 10),           SSL_SUCCESS);
 199    ExpectIntEQ(BIO_set_write_buf_size(bio2, sizeof(msg)), SSL_SUCCESS);
 200    ExpectIntEQ(BIO_make_bio_pair(bio, bio2),              SSL_SUCCESS);
 201
 202    ExpectIntEQ(BIO_write(bio2, msg, sizeof(msg)), sizeof(msg));
 203    ExpectIntEQ(BIO_gets(bio, bio_buffer, -3), 0);
 204    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 1);
 205    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 14);
 206    ExpectStrEQ(bio_buffer, "hello wolfSSL\n");
 207    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 19);
 208    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 8);
 209    ExpectIntEQ(BIO_gets(bio, bio_buffer, -1), 0);
 210
 211    BIO_free(bio);
 212    bio = NULL;
 213    BIO_free(bio2);
 214    bio2 = NULL;
 215
 216    /* check reading an empty string */
 217    ExpectNotNull(bio = BIO_new(BIO_s_bio()));
 218    ExpectIntEQ(BIO_set_write_buf_size(bio, sizeof(emp)), SSL_SUCCESS);
 219    ExpectIntEQ(BIO_gets(bio, bio_buffer, bufferSz), 0); /* Nothing to read */
 220    ExpectStrEQ(emp, bio_buffer);
 221
 222    BIO_free(bio);
 223    bio = NULL;
 224#endif
 225    return EXPECT_RESULT();
 226}
 227
 228
 229int test_wolfSSL_BIO_puts(void)
 230{
 231    EXPECT_DECLS;
 232#if defined(OPENSSL_EXTRA)
 233    BIO* bio = NULL;
 234    char input[] = "hello\0world\n.....ok\n\0";
 235    char output[128];
 236
 237    XMEMSET(output, 0, sizeof(output));
 238    ExpectNotNull(bio = BIO_new(BIO_s_mem()));
 239    ExpectIntEQ(BIO_puts(bio, input), 5);
 240    ExpectIntEQ(BIO_pending(bio), 5);
 241    ExpectIntEQ(BIO_puts(bio, input + 6), 14);
 242    ExpectIntEQ(BIO_pending(bio), 19);
 243    ExpectIntEQ(BIO_gets(bio, output, sizeof(output)), 11);
 244    ExpectStrEQ(output, "helloworld\n");
 245    ExpectIntEQ(BIO_pending(bio), 8);
 246    ExpectIntEQ(BIO_gets(bio, output, sizeof(output)), 8);
 247    ExpectStrEQ(output, ".....ok\n");
 248    ExpectIntEQ(BIO_pending(bio), 0);
 249    ExpectIntEQ(BIO_puts(bio, ""), -1);
 250
 251    BIO_free(bio);
 252#endif
 253    return EXPECT_RESULT();
 254}
 255
 256int test_wolfSSL_BIO_dump(void)
 257{
 258    EXPECT_DECLS;
 259#if defined(OPENSSL_EXTRA) && !defined(NO_FILESYSTEM)
 260    BIO* bio;
 261    static const unsigned char data[] = {
 262        0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE,
 263        0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D,
 264        0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0x55, 0xBF, 0xF4,
 265        0x0F, 0x44, 0x50, 0x9A, 0x3D, 0xCE, 0x9B, 0xB7, 0xF0, 0xC5,
 266        0x4D, 0xF5, 0x70, 0x7B, 0xD4, 0xEC, 0x24, 0x8E, 0x19, 0x80,
 267        0xEC, 0x5A, 0x4C, 0xA2, 0x24, 0x03, 0x62, 0x2C, 0x9B, 0xDA,
 268        0xEF, 0xA2, 0x35, 0x12, 0x43, 0x84, 0x76, 0x16, 0xC6, 0x56,
 269        0x95, 0x06, 0xCC, 0x01, 0xA9, 0xBD, 0xF6, 0x75, 0x1A, 0x42,
 270        0xF7, 0xBD, 0xA9, 0xB2, 0x36, 0x22, 0x5F, 0xC7, 0x5D, 0x7F,
 271        0xB4
 272    };
 273    /* Generated with OpenSSL. */
 274    static const char expected[] =
 275"0000 - 30 59 30 13 06 07 2a 86-48 ce 3d 02 01 06 08 2a   0Y0...*.H.=....*\n"
 276"0010 - 86 48 ce 3d 03 01 07 03-42 00 04 55 bf f4 0f 44   .H.=....B..U...D\n"
 277"0020 - 50 9a 3d ce 9b b7 f0 c5-4d f5 70 7b d4 ec 24 8e   P.=.....M.p{..$.\n"
 278"0030 - 19 80 ec 5a 4c a2 24 03-62 2c 9b da ef a2 35 12   ...ZL.$.b,....5.\n"
 279"0040 - 43 84 76 16 c6 56 95 06-cc 01 a9 bd f6 75 1a 42   C.v..V.......u.B\n"
 280"0050 - f7 bd a9 b2 36 22 5f c7-5d 7f b4                  ....6\"_.]..\n";
 281    static const char expectedAll[] =
 282"0000 - 00 01 02 03 04 05 06 07-08 09 0a 0b 0c 0d 0e 0f   ................\n"
 283"0010 - 10 11 12 13 14 15 16 17-18 19 1a 1b 1c 1d 1e 1f   ................\n"
 284"0020 - 20 21 22 23 24 25 26 27-28 29 2a 2b 2c 2d 2e 2f    !\"#$%&'()*+,-./\n"
 285"0030 - 30 31 32 33 34 35 36 37-38 39 3a 3b 3c 3d 3e 3f   0123456789:;<=>?\n"
 286"0040 - 40 41 42 43 44 45 46 47-48 49 4a 4b 4c 4d 4e 4f   @ABCDEFGHIJKLMNO\n"
 287"0050 - 50 51 52 53 54 55 56 57-58 59 5a 5b 5c 5d 5e 5f   PQRSTUVWXYZ[\\]^_\n"
 288"0060 - 60 61 62 63 64 65 66 67-68 69 6a 6b 6c 6d 6e 6f   `abcdefghijklmno\n"
 289"0070 - 70 71 72 73 74 75 76 77-78 79 7a 7b 7c 7d 7e 7f   pqrstuvwxyz{|}~.\n"
 290"0080 - 80 81 82 83 84 85 86 87-88 89 8a 8b 8c 8d 8e 8f   ................\n"
 291"0090 - 90 91 92 93 94 95 96 97-98 99 9a 9b 9c 9d 9e 9f   ................\n"
 292"00a0 - a0 a1 a2 a3 a4 a5 a6 a7-a8 a9 aa ab ac ad ae af   ................\n"
 293"00b0 - b0 b1 b2 b3 b4 b5 b6 b7-b8 b9 ba bb bc bd be bf   ................\n"
 294"00c0 - c0 c1 c2 c3 c4 c5 c6 c7-c8 c9 ca cb cc cd ce cf   ................\n"
 295"00d0 - d0 d1 d2 d3 d4 d5 d6 d7-d8 d9 da db dc dd de df   ................\n"
 296"00e0 - e0 e1 e2 e3 e4 e5 e6 e7-e8 e9 ea eb ec ed ee ef   ................\n"
 297"00f0 - f0 f1 f2 f3 f4 f5 f6 f7-f8 f9 fa fb fc fd fe ff   ................\n";
 298    char output[16 * 80];
 299    int i;
 300
 301    ExpectNotNull(bio = BIO_new(BIO_s_mem()));
 302
 303    /* Example key dumped. */
 304    ExpectIntEQ(BIO_dump(bio, (const char*)data, (int)sizeof(data)),
 305        sizeof(expected) - 1);
 306    ExpectIntEQ(BIO_read(bio, output, sizeof(output)), sizeof(expected) - 1);
 307    ExpectIntEQ(XMEMCMP(output, expected, sizeof(expected) - 1), 0);
 308
 309    /* Try every possible value for a character. */
 310    for (i = 0; i < 256; i++)
 311       output[i] = i;
 312    ExpectIntEQ(BIO_dump(bio, output, 256), sizeof(expectedAll) - 1);
 313    ExpectIntEQ(BIO_read(bio, output, sizeof(output)), sizeof(expectedAll) - 1);
 314    ExpectIntEQ(XMEMCMP(output, expectedAll, sizeof(expectedAll) - 1), 0);
 315
 316    BIO_free(bio);
 317#endif
 318    return EXPECT_RESULT();
 319}
 320
 321#if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_CERTS) && \
 322    !defined(NO_RSA) && defined(HAVE_EXT_CACHE) && \
 323    defined(HAVE_IO_TESTS_DEPENDENCIES) && defined(USE_WOLFSSL_IO)
 324static int forceWantRead(WOLFSSL *ssl, char *buf, int sz, void *ctx)
 325{
 326    (void)ssl;
 327    (void)buf;
 328    (void)sz;
 329    (void)ctx;
 330    return WOLFSSL_CBIO_ERR_WANT_READ;
 331}
 332#endif
 333
 334int test_wolfSSL_BIO_should_retry(void)
 335{
 336    EXPECT_DECLS;
 337#if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_CERTS) && \
 338    !defined(NO_RSA) && defined(HAVE_EXT_CACHE) && \
 339    defined(HAVE_IO_TESTS_DEPENDENCIES) && defined(USE_WOLFSSL_IO)
 340    tcp_ready ready;
 341    func_args server_args;
 342    THREAD_TYPE serverThread;
 343    SOCKET_T sockfd = 0;
 344    WOLFSSL_CTX* ctx = NULL;
 345    WOLFSSL*     ssl = NULL;
 346    char msg[64] = "hello wolfssl!";
 347    char reply[1024];
 348    int  msgSz = (int)XSTRLEN(msg);
 349    int  ret;
 350    BIO* bio = NULL;
 351
 352    XMEMSET(&server_args, 0, sizeof(func_args));
 353#ifdef WOLFSSL_TIRTOS
 354    fdOpenSession(Task_self());
 355#endif
 356
 357    StartTCP();
 358    InitTcpReady(&ready);
 359
 360
 361    server_args.signal = &ready;
 362    start_thread(test_server_nofail, &server_args, &serverThread);
 363    wait_tcp_ready(&server_args);
 364
 365
 366    ExpectNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_client_method()));
 367#ifdef OPENSSL_COMPATIBLE_DEFAULTS
 368    ExpectIntEQ(wolfSSL_CTX_clear_mode(ctx, SSL_MODE_AUTO_RETRY), 0);
 369#endif
 370    ExpectIntEQ(WOLFSSL_SUCCESS,
 371            wolfSSL_CTX_load_verify_locations(ctx, caCertFile, 0));
 372    ExpectIntEQ(WOLFSSL_SUCCESS,
 373          wolfSSL_CTX_use_certificate_file(ctx, cliCertFile, SSL_FILETYPE_PEM));
 374    ExpectIntEQ(WOLFSSL_SUCCESS,
 375            wolfSSL_CTX_use_PrivateKey_file(ctx, cliKeyFile, SSL_FILETYPE_PEM));
 376    tcp_connect(&sockfd, wolfSSLIP, server_args.signal->port, 0, 0, NULL);
 377
 378    /* force retry */
 379    ExpectNotNull(bio = wolfSSL_BIO_new_ssl(ctx, 1));
 380    ExpectIntEQ(BIO_get_ssl(bio, &ssl), 1);
 381    ExpectNotNull(ssl);
 382    ExpectIntEQ(wolfSSL_set_fd(ssl, sockfd), WOLFSSL_SUCCESS);
 383    wolfSSL_SSLSetIORecv(ssl, forceWantRead);
 384    if (EXPECT_FAIL()) {
 385        wolfSSL_free(ssl);
 386        ssl = NULL;
 387    }
 388
 389    ExpectIntLE(BIO_write(bio, msg, msgSz), 0);
 390    ExpectIntNE(BIO_should_retry(bio), 0);
 391    ExpectIntEQ(BIO_should_read(bio), 0);
 392    ExpectIntEQ(BIO_should_write(bio), 0);
 393
 394
 395    /* now perform successful connection */
 396    wolfSSL_SSLSetIORecv(ssl, EmbedReceive);
 397    ExpectIntEQ(BIO_write(bio, msg, msgSz), msgSz);
 398    ExpectIntNE(BIO_read(bio, reply, sizeof(reply)), 0);
 399    ret = wolfSSL_get_error(ssl, -1);
 400    if (ret == WOLFSSL_ERROR_WANT_READ || ret == WOLFSSL_ERROR_WANT_WRITE) {
 401        ExpectIntNE(BIO_should_retry(bio), 0);
 402
 403        if (ret == WOLFSSL_ERROR_WANT_READ)
 404            ExpectIntEQ(BIO_should_read(bio), 1);
 405        else
 406            ExpectIntEQ(BIO_should_read(bio), 0);
 407
 408        if (ret == WOLFSSL_ERROR_WANT_WRITE)
 409            ExpectIntEQ(BIO_should_write(bio), 1);
 410        else
 411            ExpectIntEQ(BIO_should_write(bio), 0);
 412    }
 413    else {
 414        ExpectIntEQ(BIO_should_retry(bio), 0);
 415        ExpectIntEQ(BIO_should_read(bio), 0);
 416        ExpectIntEQ(BIO_should_write(bio), 0);
 417    }
 418    ExpectIntEQ(XMEMCMP(reply, "I hear you fa shizzle!",
 419                XSTRLEN("I hear you fa shizzle!")), 0);
 420    BIO_free(bio);
 421    wolfSSL_CTX_free(ctx);
 422
 423    CloseSocket(sockfd);
 424
 425    join_thread(serverThread);
 426    FreeTcpReady(&ready);
 427
 428#ifdef WOLFSSL_TIRTOS
 429    fdOpenSession(Task_self());
 430#endif
 431#endif
 432    return EXPECT_RESULT();
 433}
 434
 435int test_wolfSSL_BIO_connect(void)
 436{
 437    EXPECT_DECLS;
 438#if defined(OPENSSL_ALL) && defined(HAVE_IO_TESTS_DEPENDENCIES) && \
 439            defined(HAVE_HTTP_CLIENT) && !defined(NO_WOLFSSL_CLIENT)
 440    tcp_ready ready;
 441    func_args server_args;
 442    THREAD_TYPE serverThread;
 443    BIO *tcpBio = NULL;
 444    BIO *sslBio = NULL;
 445    SSL_CTX* ctx = NULL;
 446    SSL *ssl = NULL;
 447    SSL *sslPtr;
 448    char msg[] = "hello wolfssl!";
 449    char reply[30];
 450    char buff[10] = {0};
 451
 452    ExpectNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_client_method()));
 453    ExpectIntEQ(WOLFSSL_SUCCESS,
 454            wolfSSL_CTX_load_verify_locations(ctx, caCertFile, 0));
 455    ExpectIntEQ(WOLFSSL_SUCCESS,
 456          wolfSSL_CTX_use_certificate_file(ctx, cliCertFile, SSL_FILETYPE_PEM));
 457    ExpectIntEQ(WOLFSSL_SUCCESS,
 458            wolfSSL_CTX_use_PrivateKey_file(ctx, cliKeyFile, SSL_FILETYPE_PEM));
 459
 460    /* Setup server */
 461    XMEMSET(&server_args, 0, sizeof(func_args));
 462    StartTCP();
 463    InitTcpReady(&ready);
 464    server_args.signal = &ready;
 465    start_thread(test_server_nofail, &server_args, &serverThread);
 466    wait_tcp_ready(&server_args);
 467    ExpectIntGT(XSNPRINTF(buff, sizeof(buff), "%d", ready.port), 0);
 468
 469    /* Start the test proper */
 470    /* Setup the TCP BIO */
 471    ExpectNotNull(tcpBio = BIO_new_connect(wolfSSLIP));
 472    ExpectIntEQ(BIO_set_conn_port(tcpBio, buff), 1);
 473    /* Setup the SSL object */
 474    ExpectNotNull(ssl = SSL_new(ctx));
 475    SSL_set_connect_state(ssl);
 476    /* Setup the SSL BIO */
 477    ExpectNotNull(sslBio = BIO_new(BIO_f_ssl()));
 478    ExpectIntEQ(BIO_set_ssl(sslBio, ssl, BIO_CLOSE), 1);
 479    if (EXPECT_FAIL()) {
 480        wolfSSL_free(ssl);
 481    }
 482    /* Verify that BIO_get_ssl works. */
 483    ExpectIntEQ(BIO_get_ssl(sslBio, &sslPtr), 1);
 484    ExpectPtrEq(ssl, sslPtr);
 485    /* Link BIO's so that sslBio uses tcpBio for IO */
 486    ExpectPtrEq(BIO_push(sslBio, tcpBio), sslBio);
 487    /* Do TCP connect */
 488    ExpectIntEQ(BIO_do_connect(sslBio), 1);
 489    /* Do TLS handshake */
 490    ExpectIntEQ(BIO_do_handshake(sslBio), 1);
 491    /* Test writing */
 492    ExpectIntEQ(BIO_write(sslBio, msg, sizeof(msg)), sizeof(msg));
 493    /* Expect length of default wolfSSL reply */
 494    ExpectIntEQ(BIO_read(sslBio, reply, sizeof(reply)), 23);
 495
 496    /* Clean it all up */
 497    BIO_free_all(sslBio);
 498    /* Server clean up */
 499    join_thread(serverThread);
 500    FreeTcpReady(&ready);
 501
 502    /* Run the same test, but use BIO_new_ssl_connect and set the IP and port
 503     * after. */
 504    XMEMSET(&server_args, 0, sizeof(func_args));
 505    StartTCP();
 506    InitTcpReady(&ready);
 507    server_args.signal = &ready;
 508    start_thread(test_server_nofail, &server_args, &serverThread);
 509    wait_tcp_ready(&server_args);
 510    ExpectIntGT(XSNPRINTF(buff, sizeof(buff), "%d", ready.port), 0);
 511
 512    ExpectNotNull(sslBio = BIO_new_ssl_connect(ctx));
 513    ExpectIntEQ(BIO_set_conn_hostname(sslBio, (char*)wolfSSLIP), 1);
 514    ExpectIntEQ(BIO_set_conn_port(sslBio, buff), 1);
 515    ExpectIntEQ(BIO_do_connect(sslBio), 1);
 516    ExpectIntEQ(BIO_do_handshake(sslBio), 1);
 517    ExpectIntEQ(BIO_write(sslBio, msg, sizeof(msg)), sizeof(msg));
 518    ExpectIntEQ(BIO_read(sslBio, reply, sizeof(reply)), 23);
 519    /* Attempt to close the TLS connection gracefully. */
 520    BIO_ssl_shutdown(sslBio);
 521
 522    BIO_free_all(sslBio);
 523    join_thread(serverThread);
 524    FreeTcpReady(&ready);
 525
 526    SSL_CTX_free(ctx);
 527
 528#if defined(HAVE_ECC) && defined(FP_ECC) && defined(HAVE_THREAD_LS)
 529    wc_ecc_fp_free();  /* free per thread cache */
 530#endif
 531#endif
 532    return EXPECT_RESULT();
 533}
 534
 535
 536int test_wolfSSL_BIO_tls(void)
 537{
 538    EXPECT_DECLS;
 539#if !defined(NO_BIO) && defined(OPENSSL_EXTRA) && \
 540    !defined(NO_WOLFSSL_CLIENT) && !defined(NO_TLS)
 541    SSL_CTX* ctx = NULL;
 542    SSL *ssl = NULL;
 543    BIO *readBio = NULL;
 544    BIO *writeBio = NULL;
 545    int ret;
 546    int err = 0;
 547
 548    ExpectNotNull(ctx = SSL_CTX_new(SSLv23_method()));
 549    ExpectNotNull(ssl = SSL_new(ctx));
 550
 551    ExpectNotNull(readBio = BIO_new(BIO_s_mem()));
 552    ExpectNotNull(writeBio = BIO_new(BIO_s_mem()));
 553    /* Qt reads data from write-bio,
 554     * then writes the read data into plain packet.
 555     * Qt reads data from plain packet,
 556     * then writes the read data into read-bio.
 557     */
 558    SSL_set_bio(ssl, readBio, writeBio);
 559
 560    do {
 561    #ifdef WOLFSSL_ASYNC_CRYPT
 562        if (err == WC_NO_ERR_TRACE(WC_PENDING_E)) {
 563            ret = wolfSSL_AsyncPoll(ssl, WOLF_POLL_FLAG_CHECK_HW);
 564            if (ret < 0) { break; } else if (ret == 0) { continue; }
 565        }
 566    #endif
 567        ret = SSL_connect(ssl);
 568        err = SSL_get_error(ssl, 0);
 569    } while (err == WC_NO_ERR_TRACE(WC_PENDING_E));
 570    ExpectIntEQ(ret, WC_NO_ERR_TRACE(WOLFSSL_FATAL_ERROR));
 571    /* in this use case, should return WANT READ
 572     * so that Qt will read the data from plain packet for next state.
 573     */
 574    ExpectIntEQ(err, SSL_ERROR_WANT_READ);
 575
 576    SSL_free(ssl);
 577    SSL_CTX_free(ctx);
 578#endif
 579    return EXPECT_RESULT();
 580}
 581
 582
 583int test_wolfSSL_BIO_datagram(void)
 584{
 585    EXPECT_DECLS;
 586#if !defined(NO_BIO) && defined(WOLFSSL_DTLS) && \
 587    defined(WOLFSSL_HAVE_BIO_ADDR) && defined(OPENSSL_EXTRA)
 588    int ret;
 589    SOCKET_T fd1 = SOCKET_INVALID, fd2 = SOCKET_INVALID;
 590    WOLFSSL_BIO *bio1 = NULL, *bio2 = NULL;
 591    WOLFSSL_BIO_ADDR *bio_addr1 = NULL, *bio_addr2 = NULL;
 592    SOCKADDR_IN sin1, sin2;
 593    socklen_t slen;
 594    static const char test_msg[] = "I am a datagram, short and stout.";
 595    char test_msg_recvd[sizeof(test_msg) + 10];
 596#ifdef USE_WINDOWS_API
 597    static const DWORD timeout = 250; /* ms */
 598#else
 599    static const struct timeval timeout = { 0, 250000 };
 600#endif
 601
 602    StartTCP();
 603
 604    if (EXPECT_SUCCESS()) {
 605        fd1 = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 606        ExpectIntNE(fd1, SOCKET_INVALID);
 607    }
 608    if (EXPECT_SUCCESS()) {
 609        fd2 = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 610        ExpectIntNE(fd2, SOCKET_INVALID);
 611    }
 612
 613    if (EXPECT_SUCCESS()) {
 614        bio1 = wolfSSL_BIO_new_dgram(fd1, 1 /* closeF */);
 615        ExpectNotNull(bio1);
 616    }
 617
 618    if (EXPECT_SUCCESS()) {
 619        bio2 = wolfSSL_BIO_new_dgram(fd2, 1 /* closeF */);
 620        ExpectNotNull(bio2);
 621    }
 622
 623    if (EXPECT_SUCCESS()) {
 624        sin1.sin_family = AF_INET;
 625        sin1.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 626        sin1.sin_port = 0;
 627        slen = (socklen_t)sizeof(sin1);
 628        ExpectIntEQ(bind(fd1, (const struct sockaddr *)&sin1, slen), 0);
 629        ExpectIntEQ(setsockopt(fd1, SOL_SOCKET, SO_RCVTIMEO,
 630            (const char *)&timeout, sizeof(timeout)), 0);
 631        ExpectIntEQ(getsockname(fd1, (struct sockaddr *)&sin1, &slen), 0);
 632    }
 633
 634    if (EXPECT_SUCCESS()) {
 635        sin2.sin_family = AF_INET;
 636        sin2.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 637        sin2.sin_port = 0;
 638        slen = (socklen_t)sizeof(sin2);
 639        ExpectIntEQ(bind(fd2, (const struct sockaddr *)&sin2, slen), 0);
 640        ExpectIntEQ(setsockopt(fd2, SOL_SOCKET, SO_RCVTIMEO,
 641            (const char *)&timeout, sizeof(timeout)), 0);
 642        ExpectIntEQ(getsockname(fd2, (struct sockaddr *)&sin2, &slen), 0);
 643    }
 644
 645    if (EXPECT_SUCCESS()) {
 646        bio_addr1 = wolfSSL_BIO_ADDR_new();
 647        ExpectNotNull(bio_addr1);
 648    }
 649
 650    if (EXPECT_SUCCESS()) {
 651        bio_addr2 = wolfSSL_BIO_ADDR_new();
 652        ExpectNotNull(bio_addr2);
 653    }
 654
 655    if (EXPECT_SUCCESS()) {
 656        /* for OpenSSL compatibility, direct copying of sockaddrs into BIO_ADDRs
 657         * must work right. */
 658        XMEMCPY(&bio_addr2->sa_in, &sin2, sizeof(sin2));
 659        ExpectIntEQ((int)wolfSSL_BIO_ctrl(bio1, BIO_CTRL_DGRAM_SET_PEER, 0,
 660            bio_addr2), WOLFSSL_SUCCESS);
 661        wolfSSL_BIO_ADDR_clear(bio_addr2);
 662    }
 663
 664    test_msg_recvd[0] = 0;
 665    ExpectIntEQ(wolfSSL_BIO_write(bio1, test_msg, sizeof(test_msg)),
 666        (int)sizeof(test_msg));
 667    ExpectIntEQ(wolfSSL_BIO_read(bio2, test_msg_recvd, sizeof(test_msg_recvd)),
 668        (int)sizeof(test_msg));
 669    ExpectIntEQ(XMEMCMP(test_msg_recvd, test_msg, sizeof(test_msg)), 0);
 670
 671#ifdef WOLFSSL_BIO_HAVE_FLOW_STATS
 672    ExpectIntEQ(wolfSSL_BIO_number_written(bio1), sizeof(test_msg));
 673    ExpectIntEQ(wolfSSL_BIO_number_read(bio2), sizeof(test_msg));
 674#endif
 675
 676    /* bio2 should now have bio1's addr stored as its peer_addr, because the
 677     * BIOs aren't "connected" yet.  use it to send a reply.
 678     */
 679
 680    test_msg_recvd[0] = 0;
 681    ExpectIntEQ(wolfSSL_BIO_write(bio2, test_msg, sizeof(test_msg)),
 682        (int)sizeof(test_msg));
 683    ExpectIntEQ(wolfSSL_BIO_read(bio1, test_msg_recvd, sizeof(test_msg_recvd)),
 684        (int)sizeof(test_msg));
 685    ExpectIntEQ(XMEMCMP(test_msg_recvd, test_msg, sizeof(test_msg)), 0);
 686
 687    ExpectIntEQ(wolfSSL_BIO_read(bio1, test_msg_recvd, sizeof(test_msg_recvd)),
 688        WOLFSSL_BIO_ERROR);
 689    ExpectIntNE(BIO_should_retry(bio1), 0);
 690
 691    ExpectIntEQ(wolfSSL_BIO_read(bio2, test_msg_recvd, sizeof(test_msg_recvd)),
 692        WOLFSSL_BIO_ERROR);
 693    ExpectIntNE(BIO_should_retry(bio2), 0);
 694
 695    /* now "connect" the sockets. */
 696
 697    ExpectIntEQ(connect(fd1, (const struct sockaddr *)&sin2,
 698        (socklen_t)sizeof(sin2)), 0);
 699    ExpectIntEQ(connect(fd2, (const struct sockaddr *)&sin1,
 700        (socklen_t)sizeof(sin1)), 0);
 701
 702    if (EXPECT_SUCCESS()) {
 703        XMEMCPY(&bio_addr2->sa_in, &sin2, sizeof(sin2));
 704        ExpectIntEQ((int)wolfSSL_BIO_ctrl(bio1, BIO_CTRL_DGRAM_SET_CONNECTED, 0,
 705            bio_addr2), WOLFSSL_SUCCESS);
 706        wolfSSL_BIO_ADDR_clear(bio_addr2);
 707    }
 708
 709    if (EXPECT_SUCCESS()) {
 710        XMEMCPY(&bio_addr1->sa_in, &sin1, sizeof(sin1));
 711        ExpectIntEQ((int)wolfSSL_BIO_ctrl(bio2, BIO_CTRL_DGRAM_SET_CONNECTED, 0,
 712            bio_addr1), WOLFSSL_SUCCESS);
 713        wolfSSL_BIO_ADDR_clear(bio_addr1);
 714    }
 715
 716    test_msg_recvd[0] = 0;
 717    ExpectIntEQ(wolfSSL_BIO_write(bio2, test_msg, sizeof(test_msg)),
 718        (int)sizeof(test_msg));
 719    ExpectIntEQ(wolfSSL_BIO_read(bio1, test_msg_recvd, sizeof(test_msg_recvd)),
 720        (int)sizeof(test_msg));
 721    ExpectIntEQ(XMEMCMP(test_msg_recvd, test_msg, sizeof(test_msg)), 0);
 722
 723    test_msg_recvd[0] = 0;
 724    ExpectIntEQ(wolfSSL_BIO_write(bio1, test_msg, sizeof(test_msg)),
 725        (int)sizeof(test_msg));
 726    ExpectIntEQ(wolfSSL_BIO_read(bio2, test_msg_recvd, sizeof(test_msg_recvd)),
 727        (int)sizeof(test_msg));
 728    ExpectIntEQ(XMEMCMP(test_msg_recvd, test_msg, sizeof(test_msg)), 0);
 729
 730#ifdef __linux__
 731    /* now "disconnect" the sockets and attempt transmits expected to fail. */
 732
 733    sin1.sin_family = AF_UNSPEC;
 734    ExpectIntEQ(connect(fd1, (const struct sockaddr *)&sin1,
 735        (socklen_t)sizeof(sin1)), 0);
 736    ExpectIntEQ(connect(fd2, (const struct sockaddr *)&sin1,
 737        (socklen_t)sizeof(sin1)), 0);
 738    sin1.sin_family = AF_INET;
 739
 740    ExpectIntEQ((int)wolfSSL_BIO_ctrl(bio1, BIO_CTRL_DGRAM_SET_CONNECTED, 0,
 741        NULL), WOLFSSL_SUCCESS);
 742    ExpectIntEQ((int)wolfSSL_BIO_ctrl(bio2, BIO_CTRL_DGRAM_SET_CONNECTED, 0,
 743        NULL), WOLFSSL_SUCCESS);
 744
 745    if (EXPECT_SUCCESS()) {
 746        /* 192.168.192.168 -- invalid for loopback interface. */
 747        sin2.sin_addr.s_addr = htonl(0xc0a8c0a8);
 748        XMEMCPY(&bio_addr2->sa_in, &sin2, sizeof(sin2));
 749        ExpectIntEQ((int)wolfSSL_BIO_ctrl(bio1, BIO_CTRL_DGRAM_SET_PEER, 0,
 750            bio_addr2), WOLFSSL_SUCCESS);
 751        wolfSSL_BIO_ADDR_clear(bio_addr2);
 752    }
 753
 754    test_msg_recvd[0] = 0;
 755    errno = 0;
 756    ExpectIntEQ(wolfSSL_BIO_write(bio1, test_msg, sizeof(test_msg)), -1);
 757    ExpectTrue((errno == EINVAL) || (errno == ENETUNREACH));
 758
 759#endif /* __linux__ */
 760
 761
 762    if (bio1) {
 763        ret = wolfSSL_BIO_free(bio1);
 764        ExpectIntEQ(ret, WOLFSSL_SUCCESS);
 765    } else if (fd1 != SOCKET_INVALID)
 766        CloseSocket(fd1);
 767    if (bio2) {
 768        ret = wolfSSL_BIO_free(bio2);
 769        ExpectIntEQ(ret, WOLFSSL_SUCCESS);
 770    } else if (fd2 != SOCKET_INVALID)
 771        CloseSocket(fd2);
 772    if (bio_addr1)
 773        wolfSSL_BIO_ADDR_free(bio_addr1);
 774    if (bio_addr2)
 775        wolfSSL_BIO_ADDR_free(bio_addr2);
 776
 777#endif /* !NO_BIO && WOLFSSL_DTLS && WOLFSSL_HAVE_BIO_ADDR && OPENSSL_EXTRA */
 778
 779    return EXPECT_RESULT();
 780}
 781
 782int test_wolfSSL_BIO_s_null(void)
 783{
 784    EXPECT_DECLS;
 785#if !defined(NO_BIO) && defined(OPENSSL_EXTRA)
 786    BIO *b = NULL;
 787    char testData[10] = {'t','e','s','t',0};
 788
 789    ExpectNotNull(b = BIO_new(BIO_s_null()));
 790    ExpectIntEQ(BIO_write(b, testData, sizeof(testData)), sizeof(testData));
 791    ExpectIntEQ(BIO_read(b, testData, sizeof(testData)), 0);
 792    ExpectIntEQ(BIO_puts(b, testData), 4);
 793    ExpectIntEQ(BIO_gets(b, testData, sizeof(testData)), 0);
 794    ExpectIntEQ(BIO_pending(b), 0);
 795    ExpectIntEQ(BIO_eof(b), 1);
 796
 797    BIO_free(b);
 798#endif
 799    return EXPECT_RESULT();
 800}
 801
 802#if defined(OPENSSL_ALL) && defined(HAVE_IO_TESTS_DEPENDENCIES) && \
 803    defined(HAVE_HTTP_CLIENT)
 804static THREAD_RETURN WOLFSSL_THREAD test_wolfSSL_BIO_accept_client(void* args)
 805{
 806    BIO* clientBio;
 807    SSL* sslClient;
 808    SSL_CTX* ctx;
 809    char connectAddr[20]; /* IP + port */;
 810
 811    (void)args;
 812
 813    AssertIntGT(snprintf(connectAddr, sizeof(connectAddr), "%s:%d", wolfSSLIP,
 814        wolfSSLPort), 0);
 815    clientBio = BIO_new_connect(connectAddr);
 816    AssertNotNull(clientBio);
 817    AssertIntEQ(BIO_do_connect(clientBio), 1);
 818    ctx = SSL_CTX_new(SSLv23_method());
 819    AssertNotNull(ctx);
 820    sslClient = SSL_new(ctx);
 821    AssertNotNull(sslClient);
 822    AssertIntEQ(wolfSSL_CTX_load_verify_locations(ctx, caCertFile, 0),
 823        WOLFSSL_SUCCESS);
 824    SSL_set_bio(sslClient, clientBio, clientBio);
 825    AssertIntEQ(SSL_connect(sslClient), 1);
 826
 827    SSL_free(sslClient);
 828    SSL_CTX_free(ctx);
 829
 830#if defined(HAVE_ECC) && defined(FP_ECC) && defined(HAVE_THREAD_LS)
 831    wc_ecc_fp_free();  /* free per thread cache */
 832#endif
 833
 834    WOLFSSL_RETURN_FROM_THREAD(0);
 835}
 836#endif
 837
 838int test_wolfSSL_BIO_accept(void)
 839{
 840    EXPECT_DECLS;
 841#if defined(OPENSSL_ALL) && defined(HAVE_IO_TESTS_DEPENDENCIES) && \
 842    defined(HAVE_HTTP_CLIENT)
 843    BIO* serverBindBio = NULL;
 844    BIO* serverAcceptBio = NULL;
 845    SSL* sslServer = NULL;
 846    SSL_CTX* ctx = NULL;
 847    func_args args;
 848    THREAD_TYPE thread;
 849    char port[10]; /* 10 bytes should be enough to store the string
 850                    * representation of the port */
 851
 852    ExpectIntGT(snprintf(port, sizeof(port), "%d", wolfSSLPort), 0);
 853    ExpectNotNull(serverBindBio = BIO_new_accept(port));
 854
 855    /* First BIO_do_accept binds the port */
 856    ExpectIntEQ(BIO_do_accept(serverBindBio), 1);
 857
 858    XMEMSET(&args, 0, sizeof(func_args));
 859    start_thread(test_wolfSSL_BIO_accept_client, &args, &thread);
 860
 861    ExpectIntEQ(BIO_do_accept(serverBindBio), 1);
 862    /* Let's plug it into SSL to test */
 863    ExpectNotNull(ctx = SSL_CTX_new(SSLv23_method()));
 864    ExpectIntEQ(wolfSSL_CTX_use_certificate_file(ctx, svrCertFile,
 865        SSL_FILETYPE_PEM), WOLFSSL_SUCCESS);
 866    ExpectIntEQ(wolfSSL_CTX_use_PrivateKey_file(ctx, svrKeyFile,
 867        SSL_FILETYPE_PEM), WOLFSSL_SUCCESS);
 868    ExpectNotNull(sslServer = SSL_new(ctx));
 869    ExpectNotNull(serverAcceptBio = BIO_pop(serverBindBio));
 870    SSL_set_bio(sslServer, serverAcceptBio, serverAcceptBio);
 871    ExpectIntEQ(SSL_accept(sslServer), 1);
 872
 873    join_thread(thread);
 874
 875    BIO_free(serverBindBio);
 876    SSL_free(sslServer);
 877    SSL_CTX_free(ctx);
 878
 879#if defined(HAVE_ECC) && defined(FP_ECC) && defined(HAVE_THREAD_LS)
 880    wc_ecc_fp_free();  /* free per thread cache */
 881#endif
 882#endif
 883    return EXPECT_RESULT();
 884}
 885
 886int test_wolfSSL_BIO_write(void)
 887{
 888    EXPECT_DECLS;
 889#if defined(OPENSSL_EXTRA) && defined(WOLFSSL_BASE64_ENCODE)
 890    BIO* bio = NULL;
 891    BIO* bio64 = NULL;
 892    BIO* bio_mem = NULL;
 893    BIO* ptr = NULL;
 894    int  sz;
 895    char msg[] = "conversion test";
 896    char out[40];
 897    char expected[] = "Y29udmVyc2lvbiB0ZXN0AA==\n";
 898    void* bufPtr = NULL;
 899    BUF_MEM* buf = NULL;
 900
 901    ExpectNotNull(bio64 = BIO_new(BIO_f_base64()));
 902    ExpectNotNull(bio   = BIO_push(bio64, BIO_new(BIO_s_mem())));
 903    if (EXPECT_FAIL()) {
 904        BIO_free(bio64);
 905    }
 906
 907    /* now should convert to base64 then write to memory */
 908    ExpectIntEQ(BIO_write(bio, msg, sizeof(msg)), sizeof(msg));
 909    BIO_flush(bio);
 910
 911    /* test BIO chain */
 912    ExpectIntEQ(SSL_SUCCESS, (int)BIO_get_mem_ptr(bio, &buf));
 913    ExpectNotNull(buf);
 914    ExpectIntEQ(buf->length, 25);
 915    ExpectIntEQ(BIO_get_mem_data(bio, &bufPtr), 25);
 916    ExpectPtrEq(buf->data, bufPtr);
 917
 918    ExpectNotNull(ptr = BIO_find_type(bio, BIO_TYPE_MEM));
 919    sz = sizeof(out);
 920    XMEMSET(out, 0, sz);
 921    ExpectIntEQ((sz = BIO_read(ptr, out, sz)), 25);
 922    ExpectIntEQ(XMEMCMP(out, expected, sz), 0);
 923
 924    /* write then read should return the same message */
 925    ExpectIntEQ(BIO_write(bio, msg, sizeof(msg)), sizeof(msg));
 926    sz = sizeof(out);
 927    XMEMSET(out, 0, sz);
 928    ExpectIntEQ(BIO_read(bio, out, sz), 16);
 929    ExpectIntEQ(XMEMCMP(out, msg, sizeof(msg)), 0);
 930
 931    /* now try encoding with no line ending */
 932    BIO_set_flags(bio64, BIO_FLAGS_BASE64_NO_NL);
 933#ifdef HAVE_EX_DATA
 934    BIO_set_ex_data(bio64, 0, (void*) "data");
 935    ExpectIntEQ(strcmp((const char*)BIO_get_ex_data(bio64, 0), "data"), 0);
 936#endif
 937    ExpectIntEQ(BIO_write(bio, msg, sizeof(msg)), sizeof(msg));
 938    BIO_flush(bio);
 939    sz = sizeof(out);
 940    XMEMSET(out, 0, sz);
 941    ExpectIntEQ((sz = BIO_read(ptr, out, sz)), 24);
 942    ExpectIntEQ(XMEMCMP(out, expected, sz), 0);
 943
 944    BIO_free_all(bio); /* frees bio64 also */
 945    bio = NULL;
 946
 947    /* test with more than one bio64 in list */
 948    ExpectNotNull(bio64 = BIO_new(BIO_f_base64()));
 949    ExpectNotNull(bio   = BIO_push(BIO_new(BIO_f_base64()), bio64));
 950    if (EXPECT_FAIL()) {
 951        BIO_free_all(bio);
 952        bio = NULL;
 953        bio64 = NULL;
 954    }
 955    ExpectNotNull(bio_mem = BIO_new(BIO_s_mem()));
 956    ExpectNotNull(BIO_push(bio64, bio_mem));
 957    if (EXPECT_FAIL()) {
 958        BIO_free(bio_mem);
 959    }
 960
 961    /* now should convert to base64 when stored and then decode with read */
 962    if (bio == NULL) {
 963        ExpectNotNull(bio = BIO_new(BIO_f_base64()));
 964    }
 965    ExpectIntEQ(BIO_write(bio, msg, sizeof(msg)), 25);
 966    BIO_flush(bio);
 967    sz = sizeof(out);
 968    XMEMSET(out, 0, sz);
 969    ExpectIntEQ((sz = BIO_read(bio, out, sz)), 16);
 970    ExpectIntEQ(XMEMCMP(out, msg, sz), 0);
 971    BIO_clear_flags(bio64, ~0);
 972    BIO_set_retry_read(bio);
 973    BIO_free_all(bio); /* frees bio64s also */
 974    bio = NULL;
 975
 976    ExpectNotNull(bio = BIO_new_mem_buf(out, 0));
 977    ExpectIntEQ(BIO_write(bio, msg, sizeof(msg)), sizeof(msg));
 978    BIO_free(bio);
 979#endif
 980    return EXPECT_RESULT();
 981}
 982
 983
 984int test_wolfSSL_BIO_printf(void)
 985{
 986    EXPECT_DECLS;
 987#if defined(OPENSSL_ALL)
 988    BIO* bio = NULL;
 989    int  sz = 7;
 990    char msg[] = "TLS 1.3 for the world";
 991    char out[60];
 992    char expected[] = "TLS 1.3 for the world : sz = 7";
 993
 994    XMEMSET(out, 0, sizeof(out));
 995    ExpectNotNull(bio = BIO_new(BIO_s_mem()));
 996    ExpectIntEQ(BIO_printf(bio, "%s : sz = %d", msg, sz), 30);
 997    ExpectIntEQ(BIO_printf(NULL, ""), WC_NO_ERR_TRACE(WOLFSSL_FATAL_ERROR));
 998    ExpectIntEQ(BIO_read(bio, out, sizeof(out)), 30);
 999    ExpectIntEQ(XSTRNCMP(out, expected, sizeof(expected)), 0);
1000    BIO_free(bio);
1001#endif
1002    return EXPECT_RESULT();
1003}
1004
1005int test_wolfSSL_BIO_f_md(void)
1006{
1007    EXPECT_DECLS;
1008#if defined(OPENSSL_ALL) && !defined(NO_SHA256)
1009    BIO* bio = NULL;
1010    BIO* mem = NULL;
1011    char msg[] = "message to hash";
1012    char out[60];
1013    EVP_MD_CTX* ctx = NULL;
1014    const unsigned char testKey[] =
1015    {
1016        0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
1017        0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
1018        0x0b, 0x0b, 0x0b, 0x0b
1019    };
1020    const char testData[] = "Hi There";
1021    const unsigned char testResult[] =
1022    {
1023        0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53,
1024        0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b,
1025        0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7,
1026        0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7
1027    };
1028    const unsigned char expectedHash[] =
1029    {
1030       0x66, 0x49, 0x3C, 0xE8, 0x8A, 0x57, 0xB0, 0x60,
1031       0xDC, 0x55, 0x7D, 0xFC, 0x1F, 0xA5, 0xE5, 0x07,
1032       0x70, 0x5A, 0xF6, 0xD7, 0xC4, 0x1F, 0x1A, 0xE4,
1033       0x2D, 0xA6, 0xFD, 0xD1, 0x29, 0x7D, 0x60, 0x0D
1034    };
1035    const unsigned char emptyHash[] =
1036    {
1037        0xE3, 0xB0, 0xC4, 0x42, 0x98, 0xFC, 0x1C, 0x14,
1038        0x9A, 0xFB, 0xF4, 0xC8, 0x99, 0x6F, 0xB9, 0x24,
1039        0x27, 0xAE, 0x41, 0xE4, 0x64, 0x9B, 0x93, 0x4C,
1040        0xA4, 0x95, 0x99, 0x1B, 0x78, 0x52, 0xB8, 0x55
1041    };
1042    unsigned char check[sizeof(testResult) + 1];
1043    size_t checkSz = sizeof(check);
1044    EVP_PKEY* key = NULL;
1045
1046    XMEMSET(out, 0, sizeof(out));
1047    ExpectNotNull(bio = BIO_new(BIO_f_md()));
1048    ExpectNotNull(mem = BIO_new(BIO_s_mem()));
1049
1050    ExpectIntEQ(BIO_get_md_ctx(bio, &ctx), 1);
1051    ExpectIntEQ(EVP_DigestInit(ctx, EVP_sha256()), 1);
1052
1053    /* should not be able to write/read yet since just digest wrapper and no
1054     * data is passing through the bio */
1055    ExpectIntEQ(BIO_write(bio, msg, 0), 0);
1056    ExpectIntEQ(BIO_pending(bio), 0);
1057    ExpectIntEQ(BIO_read(bio, out, sizeof(out)), 0);
1058    ExpectIntEQ(BIO_gets(bio, out, 3), 0);
1059    ExpectIntEQ(BIO_gets(bio, out, sizeof(out)), 32);
1060    ExpectIntEQ(XMEMCMP(emptyHash, out, 32), 0);
1061    BIO_reset(bio);
1062
1063    /* append BIO mem to bio in order to read/write */
1064    ExpectNotNull(bio = BIO_push(bio, mem));
1065
1066    XMEMSET(out, 0, sizeof(out));
1067    ExpectIntEQ(BIO_write(mem, msg, sizeof(msg)), 16);
1068    ExpectIntEQ(BIO_pending(bio), 16);
1069
1070    /* this just reads the message and does not hash it (gets calls final) */
1071    ExpectIntEQ(BIO_read(bio, out, sizeof(out)), 16);
1072    ExpectIntEQ(XMEMCMP(out, msg, sizeof(msg)), 0);
1073
1074    /* create a message digest using BIO */
1075    XMEMSET(out, 0, sizeof(out));
1076    ExpectIntEQ(BIO_write(bio, msg, sizeof(msg)), 16);
1077    ExpectIntEQ(BIO_pending(mem), 16);
1078    ExpectIntEQ(BIO_pending(bio), 16);
1079    ExpectIntEQ(BIO_gets(bio, out, sizeof(out)), 32);
1080    ExpectIntEQ(XMEMCMP(expectedHash, out, 32), 0);
1081    BIO_free(bio);
1082    bio = NULL;
1083    BIO_free(mem);
1084    mem = NULL;
1085
1086    /* test with HMAC */
1087    XMEMSET(out, 0, sizeof(out));
1088    ExpectNotNull(bio = BIO_new(BIO_f_md()));
1089    ExpectNotNull(mem = BIO_new(BIO_s_mem()));
1090    BIO_get_md_ctx(bio, &ctx);
1091    ExpectNotNull(key = EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL, testKey,
1092        (int)sizeof(testKey)));
1093    EVP_DigestSignInit(ctx, NULL, EVP_sha256(), NULL, key);
1094    ExpectNotNull(bio = BIO_push(bio, mem));
1095    BIO_write(bio, testData, (int)strlen(testData));
1096    checkSz = sizeof(check);
1097    ExpectIntEQ(EVP_DigestSignFinal(ctx, NULL, &checkSz), 1);
1098    checkSz = sizeof(check);
1099    ExpectIntEQ(EVP_DigestSignFinal(ctx, check, &checkSz), 1);
1100
1101    ExpectIntEQ(XMEMCMP(check, testResult, sizeof(testResult)), 0);
1102
1103    EVP_PKEY_free(key);
1104    BIO_free(bio);
1105    BIO_free(mem);
1106#endif
1107    return EXPECT_RESULT();
1108}
1109
1110int test_wolfSSL_BIO_up_ref(void)
1111{
1112    EXPECT_DECLS;
1113#if defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA)
1114    BIO* bio = NULL;
1115
1116    ExpectNotNull(bio = BIO_new(BIO_f_md()));
1117    ExpectIntEQ(BIO_up_ref(NULL), 0);
1118    ExpectIntEQ(BIO_up_ref(bio), 1);
1119    BIO_free(bio);
1120    ExpectIntEQ(BIO_up_ref(bio), 1);
1121    BIO_free(bio);
1122    BIO_free(bio);
1123#endif
1124    return EXPECT_RESULT();
1125}
1126int test_wolfSSL_BIO_reset(void)
1127{
1128    EXPECT_DECLS;
1129#if defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA)
1130    BIO* bio = NULL;
1131    byte buf[16];
1132
1133    ExpectNotNull(bio = BIO_new_mem_buf("secure your data",
1134        (word32)XSTRLEN("secure your data")));
1135    ExpectIntEQ(BIO_read(bio, buf, 6), 6);
1136    ExpectIntEQ(XMEMCMP(buf, "secure", 6), 0);
1137    XMEMSET(buf, 0, 16);
1138    ExpectIntEQ(BIO_read(bio, buf, 16), 10);
1139    ExpectIntEQ(XMEMCMP(buf, " your data", 10), 0);
1140    /* You cannot write to MEM BIO with read-only mode. */
1141    ExpectIntEQ(BIO_write(bio, "WriteToReadonly", 15), WOLFSSL_BIO_ERROR);
1142    ExpectIntEQ(BIO_read(bio, buf, 16), -1);
1143    XMEMSET(buf, 0, 16);
1144    ExpectIntEQ(BIO_reset(bio), 1);
1145    ExpectIntEQ(BIO_read(bio, buf, 16), 16);
1146    ExpectIntEQ(XMEMCMP(buf, "secure your data", 16), 0);
1147    BIO_free(bio);
1148#endif
1149    return EXPECT_RESULT();
1150}
1151
1152int test_wolfSSL_BIO_get_len(void)
1153{
1154    EXPECT_DECLS;
1155#if defined(OPENSSL_EXTRA) && !defined(NO_BIO) && !defined(NO_FILESYSTEM)
1156    BIO *bio = NULL;
1157    const char txt[] = "Some example text to push to the BIO.";
1158
1159    ExpectIntEQ(wolfSSL_BIO_get_len(bio), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
1160
1161    ExpectNotNull(bio = wolfSSL_BIO_new(wolfSSL_BIO_s_mem()));
1162
1163    ExpectIntEQ(wolfSSL_BIO_write(bio, txt, sizeof(txt)), sizeof(txt));
1164    ExpectIntEQ(wolfSSL_BIO_get_len(bio), sizeof(txt));
1165    BIO_free(bio);
1166    bio = NULL;
1167
1168    ExpectNotNull(bio = BIO_new_fd(STDERR_FILENO, BIO_NOCLOSE));
1169    ExpectIntEQ(wolfSSL_BIO_get_len(bio), WC_NO_ERR_TRACE(WOLFSSL_BAD_FILE));
1170    BIO_free(bio);
1171#endif
1172    return EXPECT_RESULT();
1173}
1174
1175#if defined(OPENSSL_EXTRA) && !defined(NO_BIO)
1176static long bioCallback(BIO *bio, int cmd, const char* argp, int argi,
1177                 long argl, long ret)
1178{
1179    (void)bio;
1180    (void)cmd;
1181    (void)argp;
1182    (void)argi;
1183    (void)argl;
1184    return ret;
1185}
1186#endif
1187
1188int test_wolfSSL_BIO(void)
1189{
1190    EXPECT_DECLS;
1191#if defined(OPENSSL_EXTRA) && !defined(NO_BIO)
1192    const unsigned char* p = NULL;
1193    byte buff[20];
1194    BIO* bio1 = NULL;
1195    BIO* bio2 = NULL;
1196    BIO* bio3 = NULL;
1197    char* bufPt = NULL;
1198    int i;
1199
1200    for (i = 0; i < 20; i++) {
1201        buff[i] = i;
1202    }
1203    /* test BIO_free with NULL */
1204    ExpectIntEQ(BIO_free(NULL), WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1205
1206    /* Creating and testing type BIO_s_bio */
1207    ExpectNotNull(bio1 = BIO_new(BIO_s_bio()));
1208    ExpectNotNull(bio2 = BIO_new(BIO_s_bio()));
1209    ExpectNotNull(bio3 = BIO_new(BIO_s_bio()));
1210
1211    /* read/write before set up */
1212    ExpectIntEQ(BIO_read(bio1, buff, 2),  WOLFSSL_BIO_UNSET);
1213    ExpectIntEQ(BIO_write(bio1, buff, 2), WOLFSSL_BIO_UNSET);
1214
1215    ExpectIntEQ(BIO_set_nbio(bio1, 1), 1);
1216    ExpectIntEQ(BIO_set_write_buf_size(bio1, 20), WOLFSSL_SUCCESS);
1217    ExpectIntEQ(BIO_set_write_buf_size(bio2, 8),  WOLFSSL_SUCCESS);
1218    ExpectIntEQ(BIO_make_bio_pair(bio1, bio2),    WOLFSSL_SUCCESS);
1219
1220    ExpectIntEQ(BIO_nwrite(bio1, &bufPt, 10), 10);
1221    ExpectNotNull(XMEMCPY(bufPt, buff, 10));
1222    ExpectIntEQ(BIO_write(bio1, buff + 10, 10), 10);
1223    /* write buffer full */
1224    ExpectIntEQ(BIO_write(bio1, buff, 10), WOLFSSL_BIO_ERROR);
1225    ExpectIntEQ(BIO_flush(bio1), WOLFSSL_SUCCESS);
1226    ExpectIntEQ((int)BIO_ctrl_pending(bio1), 0);
1227
1228    /* write the other direction with pair */
1229    ExpectIntEQ((int)BIO_nwrite(bio2, &bufPt, 10), 8);
1230    ExpectNotNull(XMEMCPY(bufPt, buff, 8));
1231    ExpectIntEQ(BIO_write(bio2, buff, 10), WOLFSSL_BIO_ERROR);
1232
1233    /* try read */
1234    ExpectIntEQ((int)BIO_ctrl_pending(bio1), 8);
1235    ExpectIntEQ((int)BIO_ctrl_pending(bio2), 20);
1236
1237    /* try read using ctrl function */
1238    ExpectIntEQ((int)BIO_ctrl(bio1, BIO_CTRL_WPENDING, 0, NULL), 8);
1239    ExpectIntEQ((int)BIO_ctrl(bio1, BIO_CTRL_PENDING, 0, NULL), 8);
1240    ExpectIntEQ((int)BIO_ctrl(bio2, BIO_CTRL_WPENDING, 0, NULL), 20);
1241    ExpectIntEQ((int)BIO_ctrl(bio2, BIO_CTRL_PENDING, 0, NULL), 20);
1242
1243    ExpectIntEQ(BIO_nread(bio2, &bufPt, (int)BIO_ctrl_pending(bio2)), 20);
1244    for (i = 0; i < 20; i++) {
1245        ExpectIntEQ((int)bufPt[i], i);
1246    }
1247    ExpectIntEQ(BIO_nread(bio2, &bufPt, 1), 0);
1248    ExpectIntEQ(BIO_nread(bio1, &bufPt, (int)BIO_ctrl_pending(bio1)), 8);
1249    for (i = 0; i < 8; i++) {
1250        ExpectIntEQ((int)bufPt[i], i);
1251    }
1252    ExpectIntEQ(BIO_nread(bio1, &bufPt, 1), 0);
1253    ExpectIntEQ(BIO_ctrl_reset_read_request(bio1), 1);
1254
1255    /* new pair */
1256    ExpectIntEQ(BIO_make_bio_pair(bio1, bio3),
1257        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1258    BIO_free(bio2); /* free bio2 and automatically remove from pair */
1259    bio2 = NULL;
1260    ExpectIntEQ(BIO_make_bio_pair(bio1, bio3), WOLFSSL_SUCCESS);
1261    ExpectIntEQ((int)BIO_ctrl_pending(bio3), 0);
1262    ExpectIntEQ(BIO_nread(bio3, &bufPt, 10), 0);
1263
1264    /* test wrap around... */
1265    ExpectIntEQ(BIO_reset(bio1), 1);
1266    ExpectIntEQ(BIO_reset(bio3), 1);
1267
1268    /* fill write buffer, read only small amount then write again */
1269    ExpectIntEQ(BIO_nwrite(bio1, &bufPt, 20), 20);
1270    ExpectNotNull(XMEMCPY(bufPt, buff, 20));
1271    ExpectIntEQ(BIO_nread(bio3, &bufPt, 4), 4);
1272    for (i = 0; i < 4; i++) {
1273        ExpectIntEQ(bufPt[i], i);
1274    }
1275
1276    /* try writing over read index */
1277    ExpectIntEQ(BIO_nwrite(bio1, &bufPt, 5), 4);
1278    ExpectNotNull(XMEMSET(bufPt, 0, 4));
1279    ExpectIntEQ((int)BIO_ctrl_pending(bio3), 20);
1280
1281    /* read and write 0 bytes */
1282    ExpectIntEQ(BIO_nread(bio3, &bufPt, 0), 0);
1283    ExpectIntEQ(BIO_nwrite(bio1, &bufPt, 0), 0);
1284
1285    /* should read only to end of write buffer then need to read again */
1286    ExpectIntEQ(BIO_nread(bio3, &bufPt, 20), 16);
1287    for (i = 0; i < 16; i++) {
1288        ExpectIntEQ(bufPt[i], buff[4 + i]);
1289    }
1290
1291    ExpectIntEQ(BIO_nread(bio3, NULL, 0), WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1292    ExpectIntEQ(BIO_nread0(bio3, &bufPt), 4);
1293    for (i = 0; i < 4; i++) {
1294        ExpectIntEQ(bufPt[i], 0);
1295    }
1296
1297    /* read index should not have advanced with nread0 */
1298    ExpectIntEQ(BIO_nread(bio3, &bufPt, 5), 4);
1299    for (i = 0; i < 4; i++) {
1300        ExpectIntEQ(bufPt[i], 0);
1301    }
1302
1303    /* write and fill up buffer checking reset of index state */
1304    ExpectIntEQ(BIO_nwrite(bio1, &bufPt, 20), 20);
1305    ExpectNotNull(XMEMCPY(bufPt, buff, 20));
1306
1307    /* test reset on data in bio1 write buffer */
1308    ExpectIntEQ(BIO_reset(bio1), 1);
1309    ExpectIntEQ((int)BIO_ctrl_pending(bio3), 0);
1310    ExpectIntEQ(BIO_nread(bio3, &bufPt, 3), 0);
1311    ExpectIntEQ(BIO_nwrite(bio1, &bufPt, 20), 20);
1312    ExpectIntEQ((int)BIO_ctrl(bio1, BIO_CTRL_INFO, 0, &p), 20);
1313    ExpectNotNull(p);
1314    ExpectNotNull(XMEMCPY(bufPt, buff, 20));
1315    ExpectIntEQ(BIO_nread(bio3, &bufPt, 6), 6);
1316    for (i = 0; i < 6; i++) {
1317        ExpectIntEQ(bufPt[i], i);
1318    }
1319
1320    /* test case of writing twice with offset read index */
1321    ExpectIntEQ(BIO_nwrite(bio1, &bufPt, 3), 3);
1322    ExpectIntEQ(BIO_nwrite(bio1, &bufPt, 4), 3); /* try overwriting */
1323    ExpectIntEQ(BIO_nwrite(bio1, &bufPt, 4), WOLFSSL_BIO_ERROR);
1324    ExpectIntEQ(BIO_nread(bio3, &bufPt, 0), 0);
1325    ExpectIntEQ(BIO_nwrite(bio1, &bufPt, 4), WOLFSSL_BIO_ERROR);
1326    ExpectIntEQ(BIO_nread(bio3, &bufPt, 1), 1);
1327    ExpectIntEQ(BIO_nwrite(bio1, &bufPt, 4), 1);
1328    ExpectIntEQ(BIO_nwrite(bio1, &bufPt, 4), WOLFSSL_BIO_ERROR);
1329
1330    BIO_free(bio1);
1331    bio1 = NULL;
1332    BIO_free(bio3);
1333    bio3 = NULL;
1334
1335    #if defined(OPENSSL_ALL) || defined(WOLFSSL_ASIO)
1336    {
1337        BIO* bioA = NULL;
1338        BIO* bioB = NULL;
1339        ExpectIntEQ(BIO_new_bio_pair(NULL, 256, NULL, 256),
1340            WC_NO_ERR_TRACE(BAD_FUNC_ARG));
1341        ExpectIntEQ(BIO_new_bio_pair(&bioA, 256, &bioB, 256), WOLFSSL_SUCCESS);
1342        BIO_free(bioA);
1343        bioA = NULL;
1344        BIO_free(bioB);
1345        bioB = NULL;
1346    }
1347    #endif /* OPENSSL_ALL || WOLFSSL_ASIO */
1348
1349    /* BIOs with file pointers */
1350    #if !defined(NO_FILESYSTEM)
1351    {
1352        XFILE f1 = XBADFILE;
1353        XFILE f2 = XBADFILE;
1354        BIO*  f_bio1 = NULL;
1355        BIO*  f_bio2 = NULL;
1356        unsigned char cert[300];
1357        char testFile[] = "tests/bio_write_test.txt";
1358        char msg[]      = "bio_write_test.txt contains the first 300 bytes of "
1359                          "certs/server-cert.pem\n"
1360                          "created by tests/unit.test\n\n";
1361
1362        ExpectNotNull(f_bio1 = BIO_new(BIO_s_file()));
1363        ExpectNotNull(f_bio2 = BIO_new(BIO_s_file()));
1364
1365        /* Failure due to wrong BIO type */
1366        ExpectIntEQ((int)BIO_set_mem_eof_return(f_bio1, -1), 0);
1367        ExpectIntEQ((int)BIO_set_mem_eof_return(NULL, -1),   0);
1368
1369        ExpectTrue((f1 = XFOPEN(svrCertFile, "rb+")) != XBADFILE);
1370        ExpectIntEQ((int)BIO_set_fp(f_bio1, f1, BIO_CLOSE), WOLFSSL_SUCCESS);
1371        ExpectIntEQ(BIO_write_filename(f_bio2, testFile),
1372                WOLFSSL_SUCCESS);
1373
1374        ExpectIntEQ(BIO_read(f_bio1, cert, sizeof(cert)), sizeof(cert));
1375        ExpectIntEQ(BIO_tell(f_bio1),sizeof(cert));
1376        ExpectIntEQ(BIO_write(f_bio2, msg, sizeof(msg)), sizeof(msg));
1377        ExpectIntEQ(BIO_tell(f_bio2),sizeof(msg));
1378        ExpectIntEQ(BIO_write(f_bio2, cert, sizeof(cert)), sizeof(cert));
1379        ExpectIntEQ(BIO_tell(f_bio2),sizeof(cert) + sizeof(msg));
1380
1381        ExpectIntEQ((int)BIO_get_fp(f_bio2, &f2), WOLFSSL_SUCCESS);
1382        ExpectIntEQ(BIO_reset(f_bio2), 1);
1383        ExpectIntEQ(BIO_tell(NULL),-1);
1384        ExpectIntEQ(BIO_tell(f_bio2),0);
1385        ExpectIntEQ(BIO_seek(f_bio2, 4), 0);
1386        ExpectIntEQ(BIO_tell(f_bio2),4);
1387
1388        BIO_free(f_bio1);
1389        f_bio1 = NULL;
1390        BIO_free(f_bio2);
1391        f_bio2 = NULL;
1392
1393        ExpectNotNull(f_bio1 = BIO_new_file(svrCertFile, "rb+"));
1394        ExpectIntEQ((int)BIO_set_mem_eof_return(f_bio1, -1), 0);
1395        ExpectIntEQ(BIO_read(f_bio1, cert, sizeof(cert)), sizeof(cert));
1396        BIO_free(f_bio1);
1397        f_bio1 = NULL;
1398    }
1399    #endif /* !defined(NO_FILESYSTEM) */
1400
1401    /* BIO info callback */
1402    {
1403        const char* testArg = "test";
1404        BIO* cb_bio = NULL;
1405        ExpectNotNull(cb_bio = BIO_new(BIO_s_mem()));
1406
1407        BIO_set_callback(cb_bio, bioCallback);
1408        ExpectNotNull(BIO_get_callback(cb_bio));
1409        BIO_set_callback(cb_bio, NULL);
1410        ExpectNull(BIO_get_callback(cb_bio));
1411
1412        BIO_set_callback_arg(cb_bio, (char*)testArg);
1413        ExpectStrEQ(BIO_get_callback_arg(cb_bio), testArg);
1414        ExpectNull(BIO_get_callback_arg(NULL));
1415
1416        BIO_free(cb_bio);
1417        cb_bio = NULL;
1418    }
1419
1420    /* BIO_vfree */
1421    ExpectNotNull(bio1 = BIO_new(BIO_s_bio()));
1422    BIO_vfree(NULL);
1423    BIO_vfree(bio1);
1424#endif
1425    return EXPECT_RESULT();
1426}
1427
1428int test_wolfSSL_BIO_BIO_ring_read(void)
1429{
1430    EXPECT_DECLS;
1431#if defined(OPENSSL_ALL) && !defined(NO_BIO)
1432    BIO* bio1 = NULL;
1433    BIO* bio2 = NULL;
1434    byte data[50];
1435    byte tmp[50];
1436
1437    XMEMSET(data, 42, sizeof(data));
1438
1439
1440    ExpectIntEQ(BIO_new_bio_pair(&bio1, sizeof(data), &bio2, sizeof(data)),
1441            SSL_SUCCESS);
1442
1443    ExpectIntEQ(BIO_write(bio1, data, 40), 40);
1444    ExpectIntEQ(BIO_read(bio1, tmp, 20), -1);
1445    ExpectIntEQ(BIO_read(bio2, tmp, 20), 20);
1446    ExpectBufEQ(tmp, data, 20);
1447    ExpectIntEQ(BIO_write(bio1, data, 20), 20);
1448    ExpectIntEQ(BIO_read(bio2, tmp, 40), 40);
1449    ExpectBufEQ(tmp, data, 40);
1450
1451    BIO_free(bio1);
1452    BIO_free(bio2);
1453#endif
1454    return EXPECT_RESULT();
1455}
1456
1457/* Custom BIO backing store for test_wolfSSL_BIO_custom_method */
1458#if defined(OPENSSL_EXTRA)
1459
1460static int custom_bio_destroyCalled = 0;
1461
1462struct custom_bio_data {
1463    char buf[256];
1464    int len;
1465    byte createCalled:1;
1466    byte writeCalled:1;
1467    byte readCalled:1;
1468    byte putsCalled:1;
1469    byte getsCalled:1;
1470    byte ctrlCalled:1;
1471};
1472
1473static int custom_bio_createCb(WOLFSSL_BIO* bio)
1474{
1475    struct custom_bio_data* data;
1476    data = (struct custom_bio_data*)XMALLOC(sizeof(*data), NULL,
1477            DYNAMIC_TYPE_TMP_BUFFER);
1478    if (data == NULL)
1479        return 0;
1480    XMEMSET(data, 0, sizeof(*data));
1481    data->createCalled = 1;
1482    BIO_set_data(bio, data);
1483    BIO_set_init(bio, 1);
1484    return 1;
1485}
1486
1487static int custom_bio_destroyCb(WOLFSSL_BIO* bio)
1488{
1489    struct custom_bio_data* data = (struct custom_bio_data*)BIO_get_data(bio);
1490    if (data != NULL) {
1491        custom_bio_destroyCalled = 1;
1492        XFREE(data, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1493    }
1494    BIO_set_data(bio, NULL);
1495    return 1;
1496}
1497
1498static int custom_bio_writeCb(WOLFSSL_BIO* bio, const char* in, int len)
1499{
1500    struct custom_bio_data* data = (struct custom_bio_data*)BIO_get_data(bio);
1501    int avail;
1502    if (data == NULL || in == NULL || len <= 0)
1503        return -1;
1504    data->writeCalled = 1;
1505    avail = (int)sizeof(data->buf) - data->len;
1506    if (len > avail)
1507        len = avail;
1508    XMEMCPY(data->buf + data->len, in, (size_t)len);
1509    data->len += len;
1510    return len;
1511}
1512
1513static int custom_bio_readCb(WOLFSSL_BIO* bio, char* out, int len)
1514{
1515    struct custom_bio_data* data = (struct custom_bio_data*)BIO_get_data(bio);
1516    if (data == NULL || out == NULL || len <= 0)
1517        return -1;
1518    data->readCalled = 1;
1519    if (data->len == 0)
1520        return 0;
1521    if (len > data->len)
1522        len = data->len;
1523    XMEMCPY(out, data->buf, (size_t)len);
1524    /* shift remaining data */
1525    data->len -= len;
1526    if (data->len > 0)
1527        XMEMMOVE(data->buf, data->buf + len, (size_t)data->len);
1528    return len;
1529}
1530
1531static int custom_bio_putsCb(WOLFSSL_BIO* bio, const char* str)
1532{
1533    struct custom_bio_data* data = (struct custom_bio_data*)BIO_get_data(bio);
1534    if (str == NULL || data == NULL)
1535        return -1;
1536    data->putsCalled = 1;
1537    return custom_bio_writeCb(bio, str, (int)XSTRLEN(str));
1538}
1539
1540static int custom_bio_getsCb(WOLFSSL_BIO* bio, char* buf, int sz)
1541{
1542    struct custom_bio_data* data = (struct custom_bio_data*)BIO_get_data(bio);
1543    int i;
1544    int readLen;
1545    if (data == NULL || buf == NULL || sz <= 1)
1546        return -1;
1547    data->getsCalled = 1;
1548    if (data->len == 0)
1549        return 0;
1550    /* read up to newline or sz-1 bytes */
1551    readLen = (sz - 1 < data->len) ? sz - 1 : data->len;
1552    for (i = 0; i < readLen; i++) {
1553        buf[i] = data->buf[i];
1554        if (data->buf[i] == '\n') {
1555            i++;
1556            break;
1557        }
1558    }
1559    buf[i] = '\0';
1560    /* shift remaining data */
1561    data->len -= i;
1562    if (data->len > 0)
1563        XMEMMOVE(data->buf, data->buf + i, (size_t)data->len);
1564    return i;
1565}
1566
1567static long custom_bio_ctrlCb(WOLFSSL_BIO* bio, int cmd, long larg, void* parg)
1568{
1569    struct custom_bio_data* data = (struct custom_bio_data*)BIO_get_data(bio);
1570    (void)larg;
1571    if (data == NULL)
1572        return -1;
1573    data->ctrlCalled = 1;
1574    switch (cmd) {
1575        case BIO_CTRL_PENDING:
1576            return (long)data->len;
1577        case BIO_CTRL_RESET:
1578            data->len = 0;
1579            return WOLFSSL_SUCCESS;
1580        case BIO_CTRL_FLUSH:
1581            return 1;
1582        case BIO_CTRL_INFO:
1583            if (parg != NULL)
1584                *(char**)parg = data->buf;
1585            return (long)data->len;
1586        default:
1587            return 0;
1588    }
1589}
1590
1591#endif /* OPENSSL_EXTRA */
1592
1593int test_wolfSSL_BIO_custom_method(void)
1594{
1595    EXPECT_DECLS;
1596#if defined(OPENSSL_EXTRA)
1597    BIO_METHOD* method = NULL;
1598    BIO* bio = NULL;
1599    struct custom_bio_data* data = NULL;
1600    char buf[256];
1601    char* memPtr = NULL;
1602
1603    /* Create custom method and set all callbacks */
1604    ExpectNotNull(method = BIO_meth_new(WOLFSSL_BIO_UNDEF, "custom_test"));
1605    ExpectIntEQ(BIO_meth_set_create(method, custom_bio_createCb),
1606            WOLFSSL_SUCCESS);
1607    ExpectIntEQ(BIO_meth_set_destroy(method, custom_bio_destroyCb),
1608            WOLFSSL_SUCCESS);
1609    ExpectIntEQ(BIO_meth_set_write(method, custom_bio_writeCb),
1610            WOLFSSL_SUCCESS);
1611    ExpectIntEQ(BIO_meth_set_read(method, custom_bio_readCb),
1612            WOLFSSL_SUCCESS);
1613    ExpectIntEQ(BIO_meth_set_puts(method, custom_bio_putsCb),
1614            WOLFSSL_SUCCESS);
1615    ExpectIntEQ(BIO_meth_set_gets(method, custom_bio_getsCb),
1616            WOLFSSL_SUCCESS);
1617    ExpectIntEQ(BIO_meth_set_ctrl(method, custom_bio_ctrlCb),
1618            WOLFSSL_SUCCESS);
1619
1620    /* Create BIO - should invoke createCb */
1621    ExpectNotNull(bio = BIO_new(method));
1622    ExpectNotNull(data = (struct custom_bio_data*)BIO_get_data(bio));
1623    ExpectTrue(data->createCalled);
1624
1625    /* write */
1626    ExpectIntEQ(BIO_write(bio, "hello", 5), 5);
1627    ExpectTrue(data->writeCalled);
1628
1629    /* ctrl_pending via ctrlCb */
1630    ExpectIntEQ((int)BIO_ctrl_pending(bio), 5);
1631    ExpectTrue(data->ctrlCalled);
1632
1633    /* read */
1634    XMEMSET(buf, 0, sizeof(buf));
1635    ExpectIntEQ(BIO_read(bio, buf, 5), 5);
1636    ExpectBufEQ(buf, "hello", 5);
1637    ExpectTrue(data->readCalled);
1638    ExpectIntEQ((int)BIO_ctrl_pending(bio), 0);
1639
1640    /* puts */
1641    ExpectIntEQ(BIO_puts(bio, "world\nfoo"), 9);
1642    ExpectTrue(data->putsCalled);
1643    ExpectIntEQ((int)BIO_ctrl_pending(bio), 9);
1644
1645    /* gets - should read up to and including first newline */
1646    XMEMSET(buf, 0, sizeof(buf));
1647    ExpectIntEQ(BIO_gets(bio, buf, (int)sizeof(buf)), 6);
1648    ExpectStrEQ(buf, "world\n");
1649    ExpectTrue(data->getsCalled);
1650    ExpectIntEQ((int)BIO_ctrl_pending(bio), 3);
1651
1652    /* get_mem_data via BIO_CTRL_INFO */
1653    ExpectIntEQ(BIO_get_mem_data(bio, &memPtr), 3);
1654    ExpectNotNull(memPtr);
1655
1656    /* reset via ctrlCb */
1657    ExpectIntEQ(BIO_reset(bio), WOLFSSL_SUCCESS);
1658    ExpectIntEQ((int)BIO_ctrl_pending(bio), 0);
1659
1660    /* free - should invoke destroyCb */
1661    custom_bio_destroyCalled = 0;
1662    BIO_free(bio);
1663    ExpectTrue(custom_bio_destroyCalled);
1664    BIO_meth_free(method);
1665#endif
1666    return EXPECT_RESULT();
1667}
1668
1669int test_wolfSSL_BIO_set_conn_hostname(void)
1670{
1671    EXPECT_DECLS;
1672#if defined(OPENSSL_EXTRA)
1673    BIO* bio = NULL;
1674
1675    /* NULL bio should fail */
1676    ExpectIntEQ(BIO_set_conn_hostname(NULL, (char*)"localhost"),
1677        WOLFSSL_FAILURE);
1678
1679    /* Create a bare socket BIO (ip starts as NULL) */
1680    ExpectNotNull(bio = BIO_new(BIO_s_socket()));
1681
1682    /* NULL hostname should fail */
1683    ExpectIntEQ(BIO_set_conn_hostname(bio, NULL), WOLFSSL_FAILURE);
1684
1685    /* Set initial hostname (ip == NULL, triggers malloc) */
1686    ExpectIntEQ(BIO_set_conn_hostname(bio, (char*)"127.0.0.1"),
1687        WOLFSSL_SUCCESS);
1688
1689    /* Set same-length hostname (reuses existing buffer) */
1690    ExpectIntEQ(BIO_set_conn_hostname(bio, (char*)"192.168.0"),
1691        WOLFSSL_SUCCESS);
1692
1693    /* Set shorter hostname (triggers free + malloc) */
1694    ExpectIntEQ(BIO_set_conn_hostname(bio, (char*)"short"), WOLFSSL_SUCCESS);
1695
1696    /* Set longer hostname (triggers free + malloc) */
1697    ExpectIntEQ(BIO_set_conn_hostname(bio, (char*)"a]longer.hostname.example"),
1698        WOLFSSL_SUCCESS);
1699
1700    BIO_free(bio);
1701#endif
1702    return EXPECT_RESULT();
1703}
1704
1705#if defined(OPENSSL_EXTRA)
1706static long pending_ctrlCb(WOLFSSL_BIO* bio, int cmd, long larg, void* parg)
1707{
1708    (void)bio;
1709    (void)larg;
1710    (void)parg;
1711    if (cmd == BIO_CTRL_PENDING)
1712        return 42;
1713    return 0;
1714}
1715#endif
1716
1717int test_wolfSSL_BIO_ctrl_pending_chain(void)
1718{
1719    EXPECT_DECLS;
1720#if defined(OPENSSL_EXTRA)
1721    BIO* md = NULL;
1722    BIO* b64 = NULL;
1723    BIO* mem = NULL;
1724    char msg[] = "hello";
1725
1726    /* Build chain: md -> b64 -> mem */
1727    ExpectNotNull(md = BIO_new(BIO_f_md()));
1728    ExpectNotNull(b64 = BIO_new(BIO_f_base64()));
1729    ExpectNotNull(mem = BIO_new(BIO_s_mem()));
1730    ExpectNotNull(BIO_push(md, b64));
1731    ExpectNotNull(BIO_push(b64, mem));
1732
1733    /* Write directly to mem so wrSz is set */
1734    ExpectIntEQ(BIO_write(mem, msg, sizeof(msg)), (int)sizeof(msg));
1735
1736    /* ctrl_pending on mem should work */
1737    ExpectIntEQ((int)BIO_ctrl_pending(mem), (int)sizeof(msg));
1738
1739    /* ctrl_pending on the head of the chain (md) should skip both wrappers
1740     * and return mem's pending count */
1741    ExpectIntEQ((int)BIO_ctrl_pending(md), (int)sizeof(msg));
1742
1743    BIO_free(md);
1744    BIO_free(b64);
1745    BIO_free(mem);
1746
1747    /* Test that ctrl_pending reaches a custom ctrlCb through a wrapper.
1748     * Chain: md -> custom(with ctrlCb) -> mem. The custom BIO's ctrlCb
1749     * returns 42 for BIO_CTRL_PENDING, so ctrl_pending on md should
1750     * return 42 (stopping at custom), not fall through to mem. */
1751    {
1752        BIO* md2 = NULL;
1753        BIO* custom = NULL;
1754        BIO* mem2 = NULL;
1755        BIO_METHOD* meth = NULL;
1756
1757        ExpectNotNull(meth = BIO_meth_new(0, "pending_test"));
1758        ExpectIntEQ(BIO_meth_set_ctrl(meth, pending_ctrlCb), WOLFSSL_SUCCESS);
1759        ExpectNotNull(md2 = BIO_new(BIO_f_md()));
1760        ExpectNotNull(custom = BIO_new(meth));
1761        ExpectNotNull(mem2 = BIO_new(BIO_s_mem()));
1762        ExpectNotNull(BIO_push(md2, custom));
1763        ExpectNotNull(BIO_push(custom, mem2));
1764
1765        ExpectIntEQ((int)BIO_ctrl_pending(md2), 42);
1766
1767        BIO_free(md2);
1768        BIO_free(custom);
1769        BIO_free(mem2);
1770        BIO_meth_free(meth);
1771    }
1772#endif
1773    return EXPECT_RESULT();
1774}
1775
1776int test_wolfSSL_BIO_meth_type_large(void)
1777{
1778    EXPECT_DECLS;
1779#if defined(OPENSSL_EXTRA)
1780    BIO_METHOD* method = NULL;
1781    BIO* bio = NULL;
1782
1783    /* Type value exceeding 255, as used by applications like HAProxy (0x666) */
1784    ExpectNotNull(method = BIO_meth_new(0x666, "large_type_test"));
1785    ExpectNotNull(bio = BIO_new(method));
1786    ExpectIntEQ(BIO_method_type(bio), 0x666);
1787
1788    BIO_free(bio);
1789    BIO_meth_free(method);
1790#endif
1791    return EXPECT_RESULT();
1792}
1793
1794int test_wolfSSL_BIO_get_init(void)
1795{
1796    EXPECT_DECLS;
1797#if defined(OPENSSL_EXTRA)
1798    BIO_METHOD* method = NULL;
1799    BIO* bio = NULL;
1800
1801    /* BIO_new with a custom method that calls BIO_set_init(bio, 1) */
1802    ExpectNotNull(method = BIO_meth_new(WOLFSSL_BIO_UNDEF, "get_init_test"));
1803    ExpectIntEQ(BIO_meth_set_create(method, custom_bio_createCb),
1804        WOLFSSL_SUCCESS);
1805    ExpectIntEQ(BIO_meth_set_destroy(method, custom_bio_destroyCb),
1806        WOLFSSL_SUCCESS);
1807
1808    ExpectNotNull(bio = BIO_new(method));
1809
1810    /* createCb calls BIO_set_init(bio, 1), so get_init should return 1 */
1811    ExpectIntEQ(BIO_get_init(bio), 1);
1812
1813    /* Clear init and verify it returns 0 */
1814    BIO_set_init(bio, 0);
1815    ExpectIntEQ(BIO_get_init(bio), 0);
1816
1817    /* Set init back and verify */
1818    BIO_set_init(bio, 1);
1819    ExpectIntEQ(BIO_get_init(bio), 1);
1820
1821    /* NULL should return 0 */
1822    ExpectIntEQ(BIO_get_init(NULL), 0);
1823
1824    BIO_free(bio);
1825    BIO_meth_free(method);
1826#endif
1827    return EXPECT_RESULT();
1828}
1829
1830#endif /* !NO_BIO */
1831