luna - wolfssl/tests/api/test

   1/* test_dtls.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/ssl.h>
  32#include <wolfssl/internal.h>
  33
  34#include <tests/utils.h>
  35#include <tests/api/test_dtls.h>
  36
  37int test_dtls12_basic_connection_id(void)
  38{
  39    EXPECT_DECLS;
  40#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS_CID)
  41    unsigned char client_cid[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
  42    unsigned char server_cid[] = { 0, 1, 2, 3, 4, 5 };
  43    unsigned char readBuf[40];
  44    void *        cid = NULL;
  45    const char* params[] = {
  46#ifndef NO_RSA
  47#ifndef NO_SHA256
  48#if defined(WOLFSSL_AES_128) && defined(WOLFSSL_STATIC_RSA)
  49        "AES128-SHA256",
  50#ifdef HAVE_AESCCM
  51        "AES128-CCM8",
  52#endif
  53#endif /* WOLFSSL_AES_128 && WOLFSSL_STATIC_RSA */
  54#if defined(WOLFSSL_AES_128)
  55        "DHE-RSA-AES128-SHA256",
  56        "ECDHE-RSA-AES128-SHA256",
  57#ifdef HAVE_AESGCM
  58        "DHE-RSA-AES128-GCM-SHA256",
  59        "ECDHE-RSA-AES128-GCM-SHA256",
  60#endif
  61#endif /* WOLFSSL_AES_128 */
  62#endif /* NO_SHA256 */
  63#endif /* NO_RSA */
  64#if defined(HAVE_CHACHA) && defined(HAVE_POLY1305) && !defined(HAVE_FIPS)
  65        "DHE-RSA-CHACHA20-POLY1305",
  66        "DHE-RSA-CHACHA20-POLY1305-OLD",
  67        "ECDHE-RSA-CHACHA20-POLY1305",
  68        "ECDHE-RSA-CHACHA20-POLY1305-OLD",
  69#endif
  70#ifndef NO_PSK
  71        "DHE-PSK-AES128-CBC-SHA256",
  72    #ifdef WOLFSSL_AES_256
  73        "DHE-PSK-AES256-GCM-SHA384",
  74    #endif
  75#ifdef HAVE_NULL_CIPHER
  76        "DHE-PSK-NULL-SHA256",
  77#endif
  78        "DHE-PSK-AES128-CCM",
  79#endif
  80    };
  81    size_t i;
  82    struct {
  83        byte drop:1;
  84        byte changeCID:1;
  85    } run_params[] = {
  86        { .drop = 0, .changeCID = 0 },
  87        { .drop = 1, .changeCID = 0 },
  88        { .drop = 0, .changeCID = 1 },
  89    };
  90
  91    /* We check if the side included the CID in their output */
  92#define CLIENT_CID() mymemmem(test_ctx.s_buff, test_ctx.s_len, \
  93                              client_cid, sizeof(client_cid))
  94#define SERVER_CID() mymemmem(test_ctx.c_buff, test_ctx.c_len, \
  95                              server_cid, sizeof(server_cid))
  96#define RESET_CID(cid) if ((cid) != NULL) { \
  97                           ((char*)(cid))[0] = -1; \
  98                       }
  99
 100
 101    printf("\n");
 102    for (i = 0; i < XELEM_CNT(params) && EXPECT_SUCCESS(); i++) {
 103        size_t j;
 104        for (j = 0; j < XELEM_CNT(run_params); j++) {
 105            WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
 106            WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
 107            struct test_memio_ctx test_ctx;
 108
 109            printf("Testing %s run #%ld ... ", params[i], (long int)j);
 110
 111            XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 112
 113            ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c,
 114                &ssl_s, wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method),
 115                0);
 116
 117            ExpectIntEQ(wolfSSL_set_cipher_list(ssl_c, params[i]), 1);
 118            ExpectIntEQ(wolfSSL_set_cipher_list(ssl_s, params[i]), 1);
 119
 120            ExpectIntEQ(wolfSSL_dtls_cid_use(ssl_c), 1);
 121            ExpectIntEQ(wolfSSL_dtls_cid_set(ssl_c, server_cid,
 122                    sizeof(server_cid)), 1);
 123            ExpectIntEQ(wolfSSL_dtls_cid_use(ssl_s), 1);
 124            ExpectIntEQ(wolfSSL_dtls_cid_set(ssl_s, client_cid,
 125                    sizeof(client_cid)), 1);
 126
 127#ifndef NO_PSK
 128            if (XSTRSTR(params[i], "-PSK-") != NULL) {
 129                wolfSSL_set_psk_client_callback(ssl_c, my_psk_client_cb);
 130                wolfSSL_set_psk_server_callback(ssl_s, my_psk_server_cb);
 131            }
 132#endif
 133
 134#ifdef HAVE_SECURE_RENEGOTIATION
 135            ExpectIntEQ(wolfSSL_UseSecureRenegotiation(ssl_c), 1);
 136            ExpectIntEQ(wolfSSL_UseSecureRenegotiation(ssl_s), 1);
 137#endif
 138
 139            /* CH1 */
 140            wolfSSL_SetLoggingPrefix("client");
 141            ExpectIntEQ(wolfSSL_negotiate(ssl_c), -1);
 142            ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 143            ExpectNull(CLIENT_CID());
 144            if (run_params[j].drop) {
 145                test_memio_clear_buffer(&test_ctx, 0);
 146                test_memio_clear_buffer(&test_ctx, 1);
 147                ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), 1);
 148                ExpectNull(CLIENT_CID());
 149            }
 150            /* HVR */
 151            wolfSSL_SetLoggingPrefix("server");
 152            ExpectIntEQ(wolfSSL_negotiate(ssl_s), -1);
 153            ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 154            ExpectNull(SERVER_CID());
 155            /* No point dropping HVR */
 156            /* CH2 */
 157            wolfSSL_SetLoggingPrefix("client");
 158            ExpectIntEQ(wolfSSL_negotiate(ssl_c), -1);
 159            ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 160            ExpectNull(CLIENT_CID());
 161            if (run_params[j].drop) {
 162                test_memio_clear_buffer(&test_ctx, 0);
 163                test_memio_clear_buffer(&test_ctx, 1);
 164                ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), 1);
 165                ExpectNull(CLIENT_CID());
 166            }
 167            /* Server first flight */
 168            wolfSSL_SetLoggingPrefix("server");
 169            ExpectIntEQ(wolfSSL_negotiate(ssl_s), -1);
 170            ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 171            ExpectNull(SERVER_CID());
 172            if (run_params[j].drop) {
 173                test_memio_clear_buffer(&test_ctx, 0);
 174                test_memio_clear_buffer(&test_ctx, 1);
 175                ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_s), 1);
 176                ExpectNull(SERVER_CID());
 177            }
 178            /* Client second flight */
 179            wolfSSL_SetLoggingPrefix("client");
 180            ExpectIntEQ(wolfSSL_negotiate(ssl_c), -1);
 181            ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 182            ExpectNotNull(CLIENT_CID());
 183            if (run_params[j].drop) {
 184                test_memio_clear_buffer(&test_ctx, 0);
 185                test_memio_clear_buffer(&test_ctx, 1);
 186                ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), 1);
 187                ExpectNotNull(CLIENT_CID());
 188            }
 189            /* Server second flight */
 190            wolfSSL_SetLoggingPrefix("server");
 191            ExpectIntEQ(wolfSSL_negotiate(ssl_s), 1);
 192            ExpectNotNull(SERVER_CID());
 193            if (run_params[j].drop) {
 194                test_memio_clear_buffer(&test_ctx, 0);
 195                test_memio_clear_buffer(&test_ctx, 1);
 196                ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_s), 1);
 197                ExpectNotNull(SERVER_CID());
 198            }
 199            /* Client complete connection */
 200            wolfSSL_SetLoggingPrefix("client");
 201            ExpectIntEQ(wolfSSL_negotiate(ssl_c), 1);
 202            ExpectNull(CLIENT_CID());
 203
 204            /* Write some data */
 205            wolfSSL_SetLoggingPrefix("client");
 206            ExpectIntEQ(wolfSSL_write(ssl_c, params[i],
 207                    (int)XSTRLEN(params[i])), XSTRLEN(params[i]));
 208            ExpectNotNull(CLIENT_CID());
 209            wolfSSL_SetLoggingPrefix("server");
 210            ExpectIntEQ(wolfSSL_write(ssl_s, params[i],
 211                    (int)XSTRLEN(params[i])), XSTRLEN(params[i]));
 212            ExpectNotNull(SERVER_CID());
 213            /* Read the data */
 214            wolfSSL_SetLoggingPrefix("client");
 215            XMEMSET(readBuf, 0, sizeof(readBuf));
 216            ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)),
 217                    XSTRLEN(params[i]));
 218            ExpectStrEQ(readBuf, params[i]);
 219            XMEMSET(readBuf, 0, sizeof(readBuf));
 220            wolfSSL_SetLoggingPrefix("server");
 221            ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)),
 222                    XSTRLEN(params[i]));
 223            ExpectStrEQ(readBuf, params[i]);
 224            /* Write short data */
 225            wolfSSL_SetLoggingPrefix("client");
 226            ExpectIntEQ(wolfSSL_write(ssl_c, params[i], 1), 1);
 227            ExpectNotNull(CLIENT_CID());
 228            wolfSSL_SetLoggingPrefix("server");
 229            ExpectIntEQ(wolfSSL_write(ssl_s, params[i], 1), 1);
 230            ExpectNotNull(SERVER_CID());
 231            /* Read the short data */
 232            XMEMSET(readBuf, 0, sizeof(readBuf));
 233            wolfSSL_SetLoggingPrefix("client");
 234            ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)), 1);
 235            ExpectIntEQ(readBuf[0], params[i][0]);
 236            XMEMSET(readBuf, 0, sizeof(readBuf));
 237            wolfSSL_SetLoggingPrefix("server");
 238            ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), 1);
 239            ExpectIntEQ(readBuf[0], params[i][0]);
 240            /* Write some data but with wrong CID */
 241            wolfSSL_SetLoggingPrefix("client");
 242            ExpectIntEQ(wolfSSL_write(ssl_c, params[i],
 243                    (int)XSTRLEN(params[i])), XSTRLEN(params[i]));
 244            /* Reset client cid. */
 245            ExpectNotNull(cid = CLIENT_CID());
 246            RESET_CID(cid);
 247            wolfSSL_SetLoggingPrefix("server");
 248            ExpectIntEQ(wolfSSL_write(ssl_s, params[i],
 249                    (int)XSTRLEN(params[i])), XSTRLEN(params[i]));
 250            /* Reset server cid. */
 251            ExpectNotNull(cid = SERVER_CID());
 252            RESET_CID(cid);
 253            /* Try to read the data but it shouldn't be there */
 254            wolfSSL_SetLoggingPrefix("client");
 255            ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)), -1);
 256            ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 257            wolfSSL_SetLoggingPrefix("server");
 258            ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
 259            ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 260
 261#ifdef HAVE_SECURE_RENEGOTIATION
 262            /* do two SCR's */
 263            wolfSSL_SetLoggingPrefix("client");
 264            ExpectIntEQ(wolfSSL_Rehandshake(ssl_c), -1);
 265            ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 266            ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
 267            ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 268            ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 269            /* SCR's after the first one have extra internal logic */
 270            wolfSSL_SetLoggingPrefix("client");
 271            ExpectIntEQ(wolfSSL_Rehandshake(ssl_c), -1);
 272            ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 273            ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
 274            ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 275            ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 276
 277            if (run_params[j].changeCID) {
 278                ExpectIntEQ(wolfSSL_dtls_cid_set(ssl_c, client_cid,
 279                        sizeof(client_cid)), 0);
 280                /* Forcefully change the CID */
 281                ssl_c->dtlsCidInfo->rx->id[0] = -1;
 282                /* We need to init the rehandshake from the client, otherwise
 283                 * we won't be able to test changing the CID. It would be
 284                 * rejected by the record CID matching code. */
 285                wolfSSL_SetLoggingPrefix("client");
 286                ExpectIntEQ(wolfSSL_Rehandshake(ssl_c), -1);
 287                ExpectIntEQ(wolfSSL_get_error(ssl_c, -1),
 288                        WOLFSSL_ERROR_WANT_READ);
 289                ExpectNotNull(CLIENT_CID());
 290                ExpectIntEQ(wolfSSL_SSL_renegotiate_pending(ssl_c), 1);
 291                /* Server first flight */
 292                wolfSSL_SetLoggingPrefix("server");
 293                ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
 294                /* We expect the server to reject the CID change. */
 295                ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), DTLS_CID_ERROR);
 296                goto loop_exit;
 297            }
 298            /* Server init'd SCR */
 299            /* Server request */
 300            wolfSSL_SetLoggingPrefix("server");
 301            ExpectIntEQ(wolfSSL_Rehandshake(ssl_s), -1);
 302            ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 303            ExpectNotNull(SERVER_CID());
 304            ExpectIntEQ(wolfSSL_SSL_renegotiate_pending(ssl_s), 1);
 305            if (run_params[j].drop) {
 306                test_memio_clear_buffer(&test_ctx, 0);
 307                test_memio_clear_buffer(&test_ctx, 1);
 308                ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_s), 1);
 309                ExpectNotNull(SERVER_CID());
 310            }
 311            /* Init SCR on client side with the server's request */
 312            /* CH no HVR on SCR */
 313            XMEMSET(readBuf, 0, sizeof(readBuf));
 314            wolfSSL_SetLoggingPrefix("client");
 315            ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)), -1);
 316            ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 317            ExpectNotNull(CLIENT_CID());
 318            ExpectIntEQ(wolfSSL_SSL_renegotiate_pending(ssl_c), 1);
 319            if (run_params[j].drop) {
 320                test_memio_clear_buffer(&test_ctx, 0);
 321                test_memio_clear_buffer(&test_ctx, 1);
 322                ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), 1);
 323                ExpectNotNull(CLIENT_CID());
 324            }
 325            /* Server first flight */
 326            wolfSSL_SetLoggingPrefix("server");
 327            ExpectIntEQ(wolfSSL_negotiate(ssl_s), -1);
 328            ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 329            ExpectNotNull(SERVER_CID());
 330            if (run_params[j].drop) {
 331                test_memio_clear_buffer(&test_ctx, 0);
 332                test_memio_clear_buffer(&test_ctx, 1);
 333                ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_s), 1);
 334                ExpectNotNull(SERVER_CID());
 335            }
 336            /* Client second flight */
 337            wolfSSL_SetLoggingPrefix("client");
 338            ExpectIntEQ(wolfSSL_negotiate(ssl_c), -1);
 339            ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 340            ExpectNotNull(CLIENT_CID());
 341            if (run_params[j].drop) {
 342                test_memio_clear_buffer(&test_ctx, 0);
 343                test_memio_clear_buffer(&test_ctx, 1);
 344                ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), 1);
 345                ExpectNotNull(CLIENT_CID());
 346            }
 347            ExpectIntEQ(wolfSSL_write(ssl_c, params[i],
 348                    (int)XSTRLEN(params[i])), XSTRLEN(params[i]));
 349            /* Server second flight */
 350            wolfSSL_SetLoggingPrefix("server");
 351            ExpectIntEQ(wolfSSL_negotiate(ssl_s), 1);
 352            XMEMSET(readBuf, 0, sizeof(readBuf));
 353            ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)),
 354                    XSTRLEN(params[i]));
 355            ExpectStrEQ(readBuf, params[i]);
 356            if (!run_params[j].drop) {
 357                ExpectIntEQ(wolfSSL_write(ssl_s, params[i],
 358                        (int)XSTRLEN(params[i])), XSTRLEN(params[i]));
 359            }
 360            /* Test loading old epoch */
 361            /* Client complete connection */
 362            wolfSSL_SetLoggingPrefix("client");
 363            if (!run_params[j].drop) {
 364                ExpectIntEQ(wolfSSL_negotiate(ssl_c), 1);
 365                XMEMSET(readBuf, 0, sizeof(readBuf));
 366                ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)),
 367                        XSTRLEN(params[i]));
 368                ExpectStrEQ(readBuf, params[i]);
 369            }
 370            ExpectIntEQ(wolfSSL_negotiate(ssl_c), 1);
 371            ExpectNull(CLIENT_CID());
 372            ExpectIntEQ(wolfSSL_SSL_renegotiate_pending(ssl_c), 0);
 373            ExpectIntEQ(wolfSSL_SSL_renegotiate_pending(ssl_s), 0);
 374#endif
 375            /* Close connection */
 376            wolfSSL_SetLoggingPrefix("client");
 377            ExpectIntEQ(wolfSSL_shutdown(ssl_c), WOLFSSL_SHUTDOWN_NOT_DONE);
 378            ExpectNotNull(CLIENT_CID());
 379            wolfSSL_SetLoggingPrefix("server");
 380            ExpectIntEQ(wolfSSL_shutdown(ssl_s), WOLFSSL_SHUTDOWN_NOT_DONE);
 381            ExpectNotNull(SERVER_CID());
 382            wolfSSL_SetLoggingPrefix("client");
 383            ExpectIntEQ(wolfSSL_shutdown(ssl_c), 1);
 384            wolfSSL_SetLoggingPrefix("server");
 385            ExpectIntEQ(wolfSSL_shutdown(ssl_s), 1);
 386
 387#ifdef HAVE_SECURE_RENEGOTIATION
 388loop_exit:
 389#endif
 390            wolfSSL_SetLoggingPrefix(NULL);
 391            wolfSSL_free(ssl_c);
 392            wolfSSL_CTX_free(ctx_c);
 393            wolfSSL_free(ssl_s);
 394            wolfSSL_CTX_free(ctx_s);
 395
 396            if (EXPECT_SUCCESS())
 397                printf("ok\n");
 398            else
 399                printf("failed\n");
 400        }
 401
 402    }
 403
 404#undef CLIENT_CID
 405#undef SERVER_CID
 406#undef RESET_CID
 407#endif
 408    return EXPECT_RESULT();
 409}
 410
 411int test_dtls13_basic_connection_id(void)
 412{
 413    EXPECT_DECLS;
 414#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS13) \
 415    && defined(WOLFSSL_DTLS_CID)
 416    unsigned char client_cid[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
 417    unsigned char server_cid[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 418    unsigned char readBuf[50];
 419    void *        cid = NULL;
 420    const char* params[] = {
 421#ifndef NO_SHA256
 422#ifdef WOLFSSL_AES_128
 423#ifdef HAVE_AESGCM
 424        "TLS13-AES128-GCM-SHA256",
 425#endif
 426#if defined(HAVE_CHACHA) && defined(HAVE_POLY1305)
 427        "TLS13-CHACHA20-POLY1305-SHA256",
 428#endif
 429#ifdef HAVE_AESCCM
 430        "TLS13-AES128-CCM-8-SHA256",
 431        "TLS13-AES128-CCM-SHA256",
 432#endif
 433#endif
 434#ifdef HAVE_NULL_CIPHER
 435        "TLS13-SHA256-SHA256",
 436#endif
 437#endif
 438    };
 439    size_t i;
 440
 441    /* We check if the side included the CID in their output */
 442#define CLIENT_CID() mymemmem(test_ctx.s_buff, test_ctx.s_len, \
 443                              client_cid, sizeof(client_cid))
 444#define SERVER_CID() mymemmem(test_ctx.c_buff, test_ctx.c_len, \
 445                              server_cid, sizeof(server_cid))
 446#define RESET_CID(cid) if ((cid) != NULL) { \
 447                           ((char*)(cid))[0] = -1; \
 448                       }
 449
 450
 451    printf("\n");
 452    for (i = 0; i < XELEM_CNT(params) && EXPECT_SUCCESS(); i++) {
 453        WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
 454        WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
 455        struct test_memio_ctx test_ctx;
 456
 457        printf("Testing %s ... ", params[i]);
 458
 459        XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 460
 461        ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 462            wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method), 0);
 463
 464        ExpectIntEQ(wolfSSL_set_cipher_list(ssl_c, params[i]), WOLFSSL_SUCCESS);
 465        ExpectIntEQ(wolfSSL_set_cipher_list(ssl_s, params[i]), WOLFSSL_SUCCESS);
 466
 467        ExpectIntEQ(wolfSSL_dtls_cid_use(ssl_c), 1);
 468        ExpectIntEQ(wolfSSL_dtls_cid_set(ssl_c, server_cid, sizeof(server_cid)),
 469                1);
 470        ExpectIntEQ(wolfSSL_dtls_cid_use(ssl_s), 1);
 471        ExpectIntEQ(wolfSSL_dtls_cid_set(ssl_s, client_cid, sizeof(client_cid)),
 472                1);
 473
 474        /* CH1 */
 475        ExpectIntEQ(wolfSSL_negotiate(ssl_c), -1);
 476        ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 477        ExpectNull(CLIENT_CID());
 478        /* HRR */
 479        ExpectIntEQ(wolfSSL_negotiate(ssl_s), -1);
 480        ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 481        ExpectNull(SERVER_CID());
 482        /* CH2 */
 483        ExpectIntEQ(wolfSSL_negotiate(ssl_c), -1);
 484        ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 485        ExpectNull(CLIENT_CID());
 486        /* Server first flight */
 487        ExpectIntEQ(wolfSSL_negotiate(ssl_s), -1);
 488        ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 489        ExpectNotNull(SERVER_CID());
 490        /* Client second flight */
 491        ExpectIntEQ(wolfSSL_negotiate(ssl_c), -1);
 492        ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 493        ExpectNotNull(CLIENT_CID());
 494        /* Server process flight */
 495        ExpectIntEQ(wolfSSL_negotiate(ssl_s), 1);
 496        /* Client process flight */
 497        ExpectIntEQ(wolfSSL_negotiate(ssl_c), 1);
 498
 499        /* Write some data */
 500        ExpectIntEQ(wolfSSL_write(ssl_c, params[i], (int)XSTRLEN(params[i])),
 501                XSTRLEN(params[i]));
 502        ExpectNotNull(CLIENT_CID());
 503        ExpectIntEQ(wolfSSL_write(ssl_s, params[i], (int)XSTRLEN(params[i])),
 504                XSTRLEN(params[i]));
 505        ExpectNotNull(SERVER_CID());
 506        /* Read the data */
 507        XMEMSET(readBuf, 0, sizeof(readBuf));
 508        ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)),
 509                XSTRLEN(params[i]));
 510        ExpectStrEQ(readBuf, params[i]);
 511        XMEMSET(readBuf, 0, sizeof(readBuf));
 512        ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)),
 513                XSTRLEN(params[i]));
 514        ExpectStrEQ(readBuf, params[i]);
 515        /* Write short data */
 516        ExpectIntEQ(wolfSSL_write(ssl_c, params[i], 1), 1);
 517        ExpectNotNull(CLIENT_CID());
 518        ExpectIntEQ(wolfSSL_write(ssl_s, params[i], 1), 1);
 519        ExpectNotNull(SERVER_CID());
 520        /* Read the short data */
 521        XMEMSET(readBuf, 0, sizeof(readBuf));
 522        ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)), 1);
 523        ExpectIntEQ(readBuf[0], params[i][0]);
 524        XMEMSET(readBuf, 0, sizeof(readBuf));
 525        ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), 1);
 526        ExpectIntEQ(readBuf[0], params[i][0]);
 527        /* Write some data but with wrong CID */
 528        ExpectIntEQ(wolfSSL_write(ssl_c, params[i], (int)XSTRLEN(params[i])),
 529                XSTRLEN(params[i]));
 530        /* Reset client cid. */
 531        ExpectNotNull(cid = CLIENT_CID());
 532        RESET_CID(cid);
 533        ExpectIntEQ(wolfSSL_write(ssl_s, params[i], (int)XSTRLEN(params[i])),
 534                XSTRLEN(params[i]));
 535        /* Reset server cid. */
 536        ExpectNotNull(cid = SERVER_CID());
 537        RESET_CID(cid);
 538        /* Try to read the data but it shouldn't be there */
 539        ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)), -1);
 540        ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 541        ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
 542        ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 543
 544        /* Close connection */
 545        ExpectIntEQ(wolfSSL_shutdown(ssl_c), WOLFSSL_SHUTDOWN_NOT_DONE);
 546        ExpectNotNull(CLIENT_CID());
 547        ExpectIntEQ(wolfSSL_shutdown(ssl_s), WOLFSSL_SHUTDOWN_NOT_DONE);
 548        ExpectNotNull(SERVER_CID());
 549        ExpectIntEQ(wolfSSL_shutdown(ssl_c), 1);
 550        ExpectIntEQ(wolfSSL_shutdown(ssl_s), 1);
 551
 552        if (EXPECT_SUCCESS())
 553            printf("ok\n");
 554        else
 555            printf("failed\n");
 556
 557        wolfSSL_free(ssl_c);
 558        wolfSSL_CTX_free(ctx_c);
 559        wolfSSL_free(ssl_s);
 560        wolfSSL_CTX_free(ctx_s);
 561    }
 562
 563#undef CLIENT_CID
 564#undef SERVER_CID
 565#undef RESET_CID
 566
 567#endif
 568    return EXPECT_RESULT();
 569}
 570
 571/** Test DTLS 1.3 behavior when server hits WANT_WRITE during HRR
 572 * The test sets up a DTLS 1.3 connection where the server is forced to
 573 * return WANT_WRITE when sending the HelloRetryRequest. After the handshake,
 574 * application data is exchanged in both directions to verify the connection
 575 * works as expected.
 576 */
 577int test_dtls13_hrr_want_write(void)
 578{
 579    EXPECT_DECLS;
 580#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS13)
 581    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
 582    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
 583    const char msg[] = "hello";
 584    const int msgLen = sizeof(msg);
 585    struct test_memio_ctx test_ctx;
 586    char readBuf[sizeof(msg)];
 587
 588    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 589
 590    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 591                    wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method),
 592        0);
 593
 594    /* Client sends first ClientHello */
 595    ExpectIntEQ(wolfSSL_negotiate(ssl_c), -1);
 596    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 597
 598    /* Force server to hit WANT_WRITE when producing the HRR */
 599    test_memio_simulate_want_write(&test_ctx, 0, 1);
 600    ExpectIntEQ(wolfSSL_negotiate(ssl_s), -1);
 601    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_WRITE);
 602
 603    /* Allow the server to flush the HRR and proceed */
 604    test_memio_simulate_want_write(&test_ctx, 0, 0);
 605    ExpectIntEQ(wolfSSL_negotiate(ssl_s), -1);
 606    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 607
 608    /* Resume the DTLS 1.3 handshake */
 609    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 610
 611    /* Verify post-handshake application data in both directions */
 612    XMEMSET(readBuf, 0, sizeof(readBuf));
 613    ExpectIntEQ(wolfSSL_write(ssl_c, msg, msgLen), msgLen);
 614    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), msgLen);
 615    ExpectStrEQ(readBuf, msg);
 616
 617    XMEMSET(readBuf, 0, sizeof(readBuf));
 618    ExpectIntEQ(wolfSSL_write(ssl_s, msg, msgLen), msgLen);
 619    ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)), msgLen);
 620    ExpectStrEQ(readBuf, msg);
 621
 622    wolfSSL_free(ssl_c);
 623    wolfSSL_CTX_free(ctx_c);
 624    wolfSSL_free(ssl_s);
 625    wolfSSL_CTX_free(ctx_s);
 626#endif
 627    return EXPECT_RESULT();
 628}
 629
 630#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS13)
 631struct test_dtls13_wwrite_ctx {
 632    int want_write;
 633    struct test_memio_ctx *text_ctx;
 634};
 635static int test_dtls13_want_write_send_cb(WOLFSSL *ssl, char *data, int sz, void *ctx)
 636{
 637    struct test_dtls13_wwrite_ctx *wwctx = (struct test_dtls13_wwrite_ctx *)ctx;
 638    wwctx->want_write = !wwctx->want_write;
 639    if (wwctx->want_write) {
 640        return WOLFSSL_CBIO_ERR_WANT_WRITE;
 641    }
 642    return test_memio_write_cb(ssl, data, sz, wwctx->text_ctx);
 643}
 644#endif
 645/** Test DTLS 1.3 behavior when every other write returns WANT_WRITE
 646 * The test sets up a DTLS 1.3 connection where both client and server
 647 * alternate between WANT_WRITE and successful writes. After the handshake,
 648 * application data is exchanged in both directions to verify the connection
 649 * works as expected.
 650 *
 651 * Data exchanged after the handshake is also tested with simulated WANT_WRITE
 652 * conditions to ensure the connection remains functional.
 653 */
 654int test_dtls13_every_write_want_write(void)
 655{
 656    EXPECT_DECLS;
 657#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS13)
 658    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
 659    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
 660    struct test_memio_ctx test_ctx;
 661    const char msg[] = "want-write";
 662    const int msgLen = sizeof(msg);
 663    char readBuf[sizeof(msg)];
 664    struct test_dtls13_wwrite_ctx wwctx_c;
 665    struct test_dtls13_wwrite_ctx wwctx_s;
 666
 667    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 668
 669    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 670                    wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method),
 671        0);
 672
 673    wwctx_c.want_write = 0;
 674    wwctx_c.text_ctx = &test_ctx;
 675    wolfSSL_SetIOWriteCtx(ssl_c, &wwctx_c);
 676    wolfSSL_SSLSetIOSend(ssl_c, test_dtls13_want_write_send_cb);
 677    wwctx_s.want_write = 0;
 678    wwctx_s.text_ctx = &test_ctx;
 679    wolfSSL_SetIOWriteCtx(ssl_s, &wwctx_s);
 680    wolfSSL_SSLSetIOSend(ssl_s, test_dtls13_want_write_send_cb);
 681
 682    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 20, NULL), 0);
 683
 684    ExpectTrue(wolfSSL_is_init_finished(ssl_c));
 685    ExpectTrue(wolfSSL_is_init_finished(ssl_s));
 686
 687    test_memio_simulate_want_write(&test_ctx, 0, 0);
 688    test_memio_simulate_want_write(&test_ctx, 1, 0);
 689
 690    wolfSSL_SetIOWriteCtx(ssl_c, &test_ctx);
 691    wolfSSL_SSLSetIOSend(ssl_c, test_memio_write_cb);
 692    wolfSSL_SetIOWriteCtx(ssl_s, &test_ctx);
 693    wolfSSL_SSLSetIOSend(ssl_s, test_memio_write_cb);
 694
 695    XMEMSET(readBuf, 0, sizeof(readBuf));
 696    ExpectIntEQ(wolfSSL_write(ssl_c, msg, msgLen), msgLen);
 697    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), msgLen);
 698    ExpectStrEQ(readBuf, msg);
 699
 700    XMEMSET(readBuf, 0, sizeof(readBuf));
 701    ExpectIntEQ(wolfSSL_write(ssl_s, msg, msgLen), msgLen);
 702    ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)), msgLen);
 703    ExpectStrEQ(readBuf, msg);
 704
 705    test_memio_simulate_want_write(&test_ctx, 0, 1);
 706    XMEMSET(readBuf, 0, sizeof(readBuf));
 707    ExpectIntEQ(wolfSSL_write(ssl_s, msg, msgLen), -1);
 708    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_WRITE);
 709    test_memio_simulate_want_write(&test_ctx, 0, 0);
 710    ExpectIntEQ(wolfSSL_write(ssl_s, msg, msgLen), msgLen);
 711    ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)), msgLen);
 712    ExpectStrEQ(readBuf, msg);
 713
 714    XMEMSET(readBuf, 0, sizeof(readBuf));
 715    test_memio_simulate_want_write(&test_ctx, 1, 1);
 716    ExpectIntEQ(wolfSSL_write(ssl_c, msg, msgLen), -1);
 717    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_WRITE);
 718    test_memio_simulate_want_write(&test_ctx, 1, 0);
 719    ExpectIntEQ(wolfSSL_write(ssl_c, msg, msgLen), msgLen);
 720    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), msgLen);
 721    ExpectStrEQ(readBuf, msg);
 722
 723    wolfSSL_free(ssl_c);
 724    wolfSSL_CTX_free(ctx_c);
 725    wolfSSL_free(ssl_s);
 726    wolfSSL_CTX_free(ctx_s);
 727#endif
 728    return EXPECT_RESULT();
 729}
 730
 731int test_wolfSSL_dtls_cid_parse(void)
 732{
 733    EXPECT_DECLS;
 734#if defined(WOLFSSL_DTLS) && defined(WOLFSSL_DTLS_CID)
 735    /* Taken from Wireshark. Right-click -> copy -> ... as escaped string */
 736    /* Plaintext ServerHelloDone. No CID. */
 737    byte noCid[] =
 738            "\x16\xfe\xfd\x00\x00\x00\x00\x00\x00\x00\x04\x00\x0c\x0e\x00\x00" \
 739            "\x00\x00\x04\x00\x00\x00\x00\x00\x00";
 740    /* 1.2 app data containing CID */
 741    byte cid12[] =
 742            "\x19\xfe\xfd\x00\x01\x00\x00\x00\x00\x00\x01\x77\xa3\x79\x34\xb3" \
 743            "\xf1\x1f\x34\x00\x1f\xdb\x8c\x28\x25\x9f\xe1\x02\x26\x77\x1c\x3a" \
 744            "\x50\x1b\x50\x99\xd0\xb5\x20\xd8\x2c\x2e\xaa\x36\x36\xe0\xb7\xb7" \
 745            "\xf7\x7d\xff\xb0";
 746#ifdef WOLFSSL_DTLS13
 747    /* 1.3 app data containing CID */
 748    byte cid13[] =
 749            "\x3f\x70\x64\x04\xc6\xfb\x97\x21\xd9\x28\x27\x00\x17\xc1\x01\x86" \
 750            "\xe7\x23\x2c\xad\x65\x83\xa8\xf4\xbf\xbf\x7b\x25\x16\x80\x19\xc3" \
 751            "\x81\xda\xf5\x3f";
 752#endif
 753
 754    ExpectPtrEq(wolfSSL_dtls_cid_parse(noCid, sizeof(noCid), 8), NULL);
 755    ExpectPtrEq(wolfSSL_dtls_cid_parse(cid12, sizeof(cid12), 8), cid12 + 11);
 756#ifdef WOLFSSL_DTLS13
 757    ExpectPtrEq(wolfSSL_dtls_cid_parse(cid13, sizeof(cid13), 8), cid13 + 1);
 758#endif
 759#endif
 760    return EXPECT_RESULT();
 761}
 762
 763int test_wolfSSL_dtls_set_pending_peer(void)
 764{
 765    EXPECT_DECLS;
 766#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
 767    defined(WOLFSSL_DTLS) && defined(WOLFSSL_DTLS_CID)
 768    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
 769    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
 770    struct test_memio_ctx test_ctx;
 771    unsigned char peer[10];
 772    unsigned int peerSz;
 773    unsigned char readBuf[10];
 774    unsigned char client_cid[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
 775    unsigned char server_cid[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 776
 777    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 778
 779    /* Setup DTLS contexts */
 780    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 781            wolfDTLS_client_method, wolfDTLS_server_method), 0);
 782
 783    ExpectIntEQ(wolfSSL_dtls_cid_use(ssl_c), 1);
 784    ExpectIntEQ(wolfSSL_dtls_cid_set(ssl_c, server_cid,
 785            sizeof(server_cid)), 1);
 786    ExpectIntEQ(wolfSSL_dtls_cid_use(ssl_s), 1);
 787    ExpectIntEQ(wolfSSL_dtls_cid_set(ssl_s, client_cid,
 788            sizeof(client_cid)), 1);
 789
 790    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 791
 792    peerSz = sizeof(peer);
 793    /* Fail since no peer set */
 794    ExpectIntEQ(wolfSSL_dtls_get_peer(ssl_s, peer, &peerSz), 0);
 795    ExpectIntEQ(wolfSSL_dtls_set_pending_peer(ssl_s, (void*)"123", 4), 1);
 796    ExpectIntEQ(wolfSSL_write(ssl_c, "test", 5), 5);
 797    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), 5);
 798    ExpectStrEQ(readBuf, "test");
 799    peerSz = sizeof(peer);
 800    ExpectIntEQ(wolfSSL_dtls_get_peer(ssl_s, peer, &peerSz), 1);
 801    ExpectIntEQ(peerSz, 4);
 802    ExpectStrEQ(peer, "123");
 803
 804    wolfSSL_free(ssl_s);
 805    wolfSSL_free(ssl_c);
 806    wolfSSL_CTX_free(ctx_s);
 807    wolfSSL_CTX_free(ctx_c);
 808#endif
 809    return EXPECT_RESULT();
 810}
 811
 812int test_dtls13_epochs(void) {
 813    EXPECT_DECLS;
 814#if defined(WOLFSSL_DTLS13) && !defined(NO_WOLFSSL_CLIENT)
 815    WOLFSSL_CTX* ctx = NULL;
 816    WOLFSSL* ssl = NULL;
 817    byte input[20];
 818    word32 inOutIdx = 0;
 819
 820    XMEMSET(input, 0, sizeof(input));
 821
 822    ExpectNotNull(ctx = wolfSSL_CTX_new(wolfDTLSv1_3_client_method()));
 823    ExpectNotNull(ssl = wolfSSL_new(ctx));
 824    /* Some manual setup to enter the epoch check */
 825    ExpectTrue(ssl->options.tls1_3 = 1);
 826
 827    inOutIdx = 0;
 828    if (ssl != NULL) ssl->keys.curEpoch64 = w64From32(0x0, 0x0);
 829    ExpectIntEQ(DoApplicationData(ssl, input, &inOutIdx, 0), SANITY_MSG_E);
 830    inOutIdx = 0;
 831    if (ssl != NULL) ssl->keys.curEpoch64 = w64From32(0x0, 0x2);
 832    ExpectIntEQ(DoApplicationData(ssl, input, &inOutIdx, 0), SANITY_MSG_E);
 833
 834    if (ssl != NULL) ssl->keys.curEpoch64 = w64From32(0x0, 0x1);
 835    ExpectIntEQ(Dtls13CheckEpoch(ssl, client_hello), SANITY_MSG_E);
 836    ExpectIntEQ(Dtls13CheckEpoch(ssl, server_hello), SANITY_MSG_E);
 837    ExpectIntEQ(Dtls13CheckEpoch(ssl, hello_verify_request), SANITY_MSG_E);
 838    ExpectIntEQ(Dtls13CheckEpoch(ssl, hello_retry_request), SANITY_MSG_E);
 839    ExpectIntEQ(Dtls13CheckEpoch(ssl, hello_request), SANITY_MSG_E);
 840    ExpectIntEQ(Dtls13CheckEpoch(ssl, encrypted_extensions), SANITY_MSG_E);
 841    ExpectIntEQ(Dtls13CheckEpoch(ssl, server_key_exchange), SANITY_MSG_E);
 842    ExpectIntEQ(Dtls13CheckEpoch(ssl, server_hello_done), SANITY_MSG_E);
 843    ExpectIntEQ(Dtls13CheckEpoch(ssl, client_key_exchange), SANITY_MSG_E);
 844    ExpectIntEQ(Dtls13CheckEpoch(ssl, certificate_request), SANITY_MSG_E);
 845    ExpectIntEQ(Dtls13CheckEpoch(ssl, certificate), SANITY_MSG_E);
 846    ExpectIntEQ(Dtls13CheckEpoch(ssl, certificate_verify), SANITY_MSG_E);
 847    ExpectIntEQ(Dtls13CheckEpoch(ssl, finished), SANITY_MSG_E);
 848    ExpectIntEQ(Dtls13CheckEpoch(ssl, certificate_status), SANITY_MSG_E);
 849    ExpectIntEQ(Dtls13CheckEpoch(ssl, change_cipher_hs), SANITY_MSG_E);
 850    ExpectIntEQ(Dtls13CheckEpoch(ssl, key_update), SANITY_MSG_E);
 851    ExpectIntEQ(Dtls13CheckEpoch(ssl, session_ticket), SANITY_MSG_E);
 852    ExpectIntEQ(Dtls13CheckEpoch(ssl, end_of_early_data), SANITY_MSG_E);
 853    ExpectIntEQ(Dtls13CheckEpoch(ssl, message_hash), SANITY_MSG_E);
 854    ExpectIntEQ(Dtls13CheckEpoch(ssl, no_shake), SANITY_MSG_E);
 855
 856    wolfSSL_CTX_free(ctx);
 857    wolfSSL_free(ssl);
 858#endif
 859    return EXPECT_RESULT();
 860}
 861
 862int test_dtls13_ack_order(void)
 863{
 864    EXPECT_DECLS;
 865#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS13)
 866    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
 867    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
 868    struct test_memio_ctx test_ctx;
 869    unsigned char readBuf[50];
 870    word32 length = 0;
 871    /* struct {
 872     *     uint64 epoch;
 873     *     uint64 sequence_number;
 874     * } RecordNumber;
 875     * Big endian */
 876    static const unsigned char expected_output[] = {
 877        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
 878        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 879        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
 880        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
 881        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
 882        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
 883        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
 884        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 885        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
 886        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
 887        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
 888        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
 889        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
 890        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
 891        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
 892        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
 893    };
 894
 895    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 896
 897    /* Get a populated DTLS object */
 898    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 899        wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method), 0);
 900    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 901    ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)), -1);
 902    /* Clear the buffer of any extra messages */
 903    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 904    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
 905    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 906    ExpectIntEQ(test_ctx.c_len, 0);
 907    ExpectIntEQ(test_ctx.s_len, 0);
 908
 909    /* Add seen records */
 910    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 3), w64From32(0, 2)), 0);
 911    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 3), w64From32(0, 0)), 0);
 912    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 3), w64From32(0, 1)), 0);
 913    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 3), w64From32(0, 4)), 0);
 914    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 2), w64From32(0, 0)), 0);
 915    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 3), w64From32(0, 6)), 0);
 916    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 3), w64From32(0, 6)), 0);
 917    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 2), w64From32(0, 1)), 0);
 918    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 2), w64From32(0, 2)), 0);
 919    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 2), w64From32(0, 2)), 0);
 920    ExpectIntEQ(Dtls13WriteAckMessage(ssl_c, ssl_c->dtls13Rtx.seenRecords,
 921            ssl_c->dtls13Rtx.seenRecordsCount, &length), 0);
 922
 923    /* must zero the span reserved for the header to avoid read of uninited
 924     * data.
 925     */
 926    XMEMSET(ssl_c->buffers.outputBuffer.buffer, 0,
 927            5 /* DTLS13_UNIFIED_HEADER_SIZE */);
 928    /* N * RecordNumber + 2 extra bytes for length */
 929    ExpectIntEQ(length, sizeof(expected_output) + 2);
 930    ExpectNotNull(mymemmem(ssl_c->buffers.outputBuffer.buffer,
 931            ssl_c->buffers.outputBuffer.bufferSize, expected_output,
 932            sizeof(expected_output)));
 933
 934    wolfSSL_free(ssl_c);
 935    wolfSSL_CTX_free(ctx_c);
 936    wolfSSL_free(ssl_s);
 937    wolfSSL_CTX_free(ctx_s);
 938#endif
 939    return EXPECT_RESULT();
 940}
 941
 942int test_dtls13_ack_overflow(void)
 943{
 944    EXPECT_DECLS;
 945#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS13)
 946    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
 947    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
 948    struct test_memio_ctx test_ctx;
 949    unsigned char readBuf[50];
 950    word32 length = 0;
 951    int i;
 952
 953    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 954
 955    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 956        wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method), 0);
 957    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 958    ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)), -1);
 959    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 960    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
 961    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 962
 963    /* Edge case 1: one below limit - all inserts must succeed */
 964    for (i = 0; i < DTLS13_ACK_MAX_RECORDS - 1; i++) {
 965        ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 0),
 966                                    w64From32(0, (word32)i)), 0);
 967    }
 968    ExpectIntEQ(ssl_c->dtls13Rtx.seenRecordsCount, DTLS13_ACK_MAX_RECORDS - 1);
 969
 970    /* Edge case 2: insert the last allowed record - must succeed */
 971    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 0),
 972                    w64From32(0, (word32)(DTLS13_ACK_MAX_RECORDS - 1))), 0);
 973    ExpectIntEQ(ssl_c->dtls13Rtx.seenRecordsCount, DTLS13_ACK_MAX_RECORDS);
 974
 975    /* Writing a full-but-valid list must succeed */
 976    ExpectIntEQ(Dtls13WriteAckMessage(ssl_c, ssl_c->dtls13Rtx.seenRecords,
 977                    ssl_c->dtls13Rtx.seenRecordsCount, &length), 0);
 978
 979    /* Edge case 3: one over limit - must be silently dropped */
 980    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 0),
 981                    w64From32(0, (word32)DTLS13_ACK_MAX_RECORDS)), 0);
 982    ExpectIntEQ(ssl_c->dtls13Rtx.seenRecordsCount, DTLS13_ACK_MAX_RECORDS);
 983
 984    /* Bypass the insert guard to force the list one element over the limit,
 985     * then verify Dtls13WriteAckMessage errors out instead of overflowing */
 986    ssl_c->dtls13Rtx.seenRecordsCount = 0;
 987    ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 1),
 988                    w64From32(0, (word32)DTLS13_ACK_MAX_RECORDS)), 0);
 989    ssl_c->dtls13Rtx.seenRecordsCount = (word16)(DTLS13_ACK_MAX_RECORDS + 1);
 990    ExpectIntEQ(Dtls13WriteAckMessage(ssl_c, ssl_c->dtls13Rtx.seenRecords,
 991                    ssl_c->dtls13Rtx.seenRecordsCount, &length), BUFFER_E);
 992
 993    wolfSSL_free(ssl_c);
 994    wolfSSL_CTX_free(ctx_c);
 995    wolfSSL_free(ssl_s);
 996    wolfSSL_CTX_free(ctx_s);
 997#endif
 998    return EXPECT_RESULT();
 999}
1000
1001int test_dtls13_ack_dup_write_counter(void)
1002{
1003    EXPECT_DECLS;
1004#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS13) \
1005    && defined(HAVE_WRITE_DUP)
1006    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1007    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1008    WOLFSSL *ssl_c2 = NULL;
1009    struct test_memio_ctx test_ctx;
1010    unsigned char readBuf[50];
1011    int i;
1012
1013    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1014
1015    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1016        wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method), 0);
1017    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
1018    /* Drain any post-handshake messages */
1019    ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)), -1);
1020    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
1021    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
1022    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
1023
1024    /* Split ssl_c: ssl_c becomes READ_DUP_SIDE, ssl_c2 becomes WRITE_DUP_SIDE */
1025    ExpectNotNull(ssl_c2 = wolfSSL_write_dup(ssl_c));
1026
1027    /* Cycle 1: add records, trigger handoff, verify counter is reset to 0 */
1028    for (i = 0; i < 5; i++)
1029        ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 3),
1030                                    w64From32(0, (word32)i)), 0);
1031    ExpectIntEQ(ssl_c->dtls13Rtx.seenRecordsCount, 5);
1032    ssl_c->dtls13Rtx.sendAcks = 1;
1033    ExpectIntEQ(Dtls13DoScheduledWork(ssl_c), 0);
1034    /* seenRecords ownership was transferred to dupWrite->sendAckList;
1035     * seenRecordsCount must be reset to 0,  not left at 5. */
1036    ExpectNull(ssl_c->dtls13Rtx.seenRecords);
1037    ExpectIntEQ(ssl_c->dtls13Rtx.seenRecordsCount, 0);
1038
1039    /* Cycle 2 (different epoch to avoid the dup-filter): verify the counter
1040     * did not accumulate across the previous transfer.  Without the fix,
1041     * seenRecordsCount would now be 10 after this second batch. */
1042    for (i = 0; i < 5; i++)
1043        ExpectIntEQ(Dtls13RtxAddAck(ssl_c, w64From32(0, 4),
1044                                    w64From32(0, (word32)i)), 0);
1045    ExpectIntEQ(ssl_c->dtls13Rtx.seenRecordsCount, 5);
1046    ssl_c->dtls13Rtx.sendAcks = 1;
1047    ExpectIntEQ(Dtls13DoScheduledWork(ssl_c), 0);
1048    ExpectNull(ssl_c->dtls13Rtx.seenRecords);
1049    ExpectIntEQ(ssl_c->dtls13Rtx.seenRecordsCount, 0);
1050
1051    wolfSSL_free(ssl_c);
1052    wolfSSL_free(ssl_c2);
1053    wolfSSL_CTX_free(ctx_c);
1054    wolfSSL_free(ssl_s);
1055    wolfSSL_CTX_free(ctx_s);
1056#endif
1057    return EXPECT_RESULT();
1058}
1059
1060int test_dtls_version_checking(void)
1061{
1062    EXPECT_DECLS;
1063#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS)
1064    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1065    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1066    struct test_memio_ctx test_ctx;
1067
1068    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1069
1070    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1071                    wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method),
1072        0);
1073
1074    /* CH */
1075    ExpectIntEQ(wolfSSL_connect(ssl_c), WOLFSSL_FATAL_ERROR);
1076    ExpectIntEQ(wolfSSL_get_error(ssl_c, WOLFSSL_FATAL_ERROR),
1077        WOLFSSL_ERROR_WANT_READ);
1078
1079    /* modify CH DTLS header to have version 1.1 (0xfe, 0xfe) */
1080    ExpectIntGE(test_ctx.s_len, 3);
1081    if (EXPECT_SUCCESS()) {
1082        test_ctx.s_buff[1] = 0xfe;
1083        test_ctx.s_buff[2] = 0xfe;
1084    }
1085
1086    ExpectIntEQ(wolfSSL_accept(ssl_s), WOLFSSL_FATAL_ERROR);
1087    ExpectIntEQ(wolfSSL_get_error(ssl_s, WOLFSSL_FATAL_ERROR),
1088        WOLFSSL_ERROR_WANT_READ);
1089    /* server should drop the message */
1090    ExpectIntEQ(test_ctx.c_len, 0);
1091
1092    wolfSSL_free(ssl_c);
1093    ssl_c = wolfSSL_new(ctx_c);
1094    ExpectNotNull(ssl_c);
1095    wolfSSL_SetIOWriteCtx(ssl_c, &test_ctx);
1096    wolfSSL_SetIOReadCtx(ssl_c, &test_ctx);
1097
1098    /* try again */
1099    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
1100
1101    wolfSSL_free(ssl_c);
1102    wolfSSL_CTX_free(ctx_c);
1103    wolfSSL_free(ssl_s);
1104    wolfSSL_CTX_free(ctx_s);
1105#endif /* HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES && WOLFSSL_DTLS */
1106    return EXPECT_RESULT();
1107}
1108
1109#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS)
1110static int test_dtls_shutdown(WOLFSSL *s, WOLFSSL *c, WOLFSSL_CTX *cc, WOLFSSL_CTX *cs)
1111{
1112    EXPECT_DECLS;
1113    /* Cleanup */
1114    wolfSSL_SetLoggingPrefix("client");
1115    ExpectIntEQ(wolfSSL_shutdown(c), WOLFSSL_SHUTDOWN_NOT_DONE);
1116    wolfSSL_SetLoggingPrefix("server");
1117    ExpectIntEQ(wolfSSL_shutdown(s), WOLFSSL_SHUTDOWN_NOT_DONE);
1118    wolfSSL_SetLoggingPrefix("client");
1119    ExpectIntEQ(wolfSSL_shutdown(c), 1);
1120    wolfSSL_SetLoggingPrefix("server");
1121    ExpectIntEQ(wolfSSL_shutdown(s), 1);
1122
1123    wolfSSL_SetLoggingPrefix(NULL);
1124    wolfSSL_free(c);
1125    wolfSSL_CTX_free(cc);
1126    wolfSSL_free(s);
1127    wolfSSL_CTX_free(cs);
1128    return EXPECT_RESULT();
1129}
1130
1131static int test_dtls_communication(WOLFSSL *s, WOLFSSL *c)
1132{
1133    EXPECT_DECLS;
1134    unsigned char readBuf[50];
1135
1136    wolfSSL_SetLoggingPrefix("client");
1137    ExpectIntEQ(wolfSSL_write(c, "client message", 14), 14);
1138
1139    wolfSSL_SetLoggingPrefix("server");
1140    XMEMSET(readBuf, 0, sizeof(readBuf));
1141    ExpectIntEQ(wolfSSL_read(s, readBuf, sizeof(readBuf)), 14);
1142    ExpectStrEQ(readBuf, "client message");
1143
1144    wolfSSL_SetLoggingPrefix("server");
1145    ExpectIntEQ(wolfSSL_write(s, "server message", 14), 14);
1146
1147    wolfSSL_SetLoggingPrefix("client");
1148    XMEMSET(readBuf, 0, sizeof(readBuf));
1149    ExpectIntEQ(wolfSSL_read(c, readBuf, sizeof(readBuf)), 14);
1150    ExpectStrEQ(readBuf, "server message");
1151
1152    /* this extra round is consuming newSessionTicket and acks */
1153    wolfSSL_SetLoggingPrefix("client");
1154    ExpectIntEQ(wolfSSL_write(c, "client message 2", 16), 16);
1155
1156    wolfSSL_SetLoggingPrefix("server");
1157    XMEMSET(readBuf, 0, sizeof(readBuf));
1158    ExpectIntEQ(wolfSSL_read(s, readBuf, sizeof(readBuf)), 16);
1159    ExpectStrEQ(readBuf, "client message 2");
1160
1161    wolfSSL_SetLoggingPrefix("server");
1162    ExpectIntEQ(wolfSSL_write(s, "server message 2", 16), 16);
1163
1164    wolfSSL_SetLoggingPrefix("client");
1165    XMEMSET(readBuf, 0, sizeof(readBuf));
1166    ExpectIntEQ(wolfSSL_read(c, readBuf, sizeof(readBuf)), 16);
1167    ExpectStrEQ(readBuf, "server message 2");
1168
1169    return EXPECT_RESULT();
1170}
1171
1172#if defined(WOLFSSL_DTLS13) && !defined(WOLFSSL_DTLS_RECORDS_CAN_SPAN_DATAGRAMS)
1173int test_dtls13_longer_length(void)
1174{
1175    EXPECT_DECLS;
1176    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1177    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1178    struct test_memio_ctx test_ctx;
1179    unsigned char readBuf[50];
1180    int seq16bit = 0;
1181    int ret;
1182
1183    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1184
1185    /* Setup DTLS contexts */
1186    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1187                    wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method),
1188        0);
1189
1190    /* Complete handshake */
1191    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
1192
1193    /* Create good record with length mismatch */
1194    wolfSSL_SetLoggingPrefix("client");
1195    ExpectIntEQ(wolfSSL_write(ssl_c, "client message", 14), 14);
1196
1197    /* check client wrote the record */
1198    ExpectIntGT(test_ctx.s_len, 14);
1199    /* check length is included  in the record header */
1200    ExpectIntGT(test_ctx.s_buff[0x0] & (1 << 2), 0);
1201    seq16bit = (test_ctx.s_buff[0x0] & (1 << 3)) != 0;
1202    /* big endian, modify LSB byte */
1203    seq16bit *= 2;
1204    /* modify length to be bigger */
1205    test_ctx.s_buff[0x2 + seq16bit] = 0xff;
1206
1207    /* Try to read the malformed record */
1208    wolfSSL_SetLoggingPrefix("server");
1209    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
1210    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
1211    ExpectIntEQ(test_ctx.s_len, 0);
1212
1213    ExpectIntEQ(test_dtls_communication(ssl_s, ssl_c), TEST_SUCCESS);
1214    ret = test_dtls_shutdown(ssl_s, ssl_c, ctx_c, ctx_s);
1215    ExpectIntEQ(ret, TEST_SUCCESS);
1216
1217    return EXPECT_RESULT();
1218}
1219#else
1220int test_dtls13_longer_length(void)
1221{
1222    return TEST_SKIPPED;
1223}
1224#endif /* WOLFSSL_DTLS13 && !defined(WOLFSSL_DTLS_RECORDS_CAN_SPAN_DATAGRAMS) */
1225
1226#if defined(WOLFSSL_DTLS13) && !defined(WOLFSSL_DTLS_RECORDS_CAN_SPAN_DATAGRAMS)
1227int test_dtls13_short_read(void)
1228{
1229    EXPECT_DECLS;
1230    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1231    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1232    struct test_memio_ctx test_ctx;
1233    unsigned char readBuf[50];
1234    int i;
1235    int ret;
1236
1237    /* we setup two test, in the first one the server reads just two bytes of
1238     * the header, in the second one it reads just the header (5) */
1239    for (i = 0; i < 2; i++) {
1240        XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1241
1242        /* Setup DTLS contexts */
1243        ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1244                        wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method),
1245            0);
1246
1247        /* Complete handshake */
1248        ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
1249
1250        /* create a good record in the buffer */
1251        wolfSSL_SetLoggingPrefix("client");
1252        ExpectIntEQ(wolfSSL_write(ssl_c, "client message", 14), 14);
1253
1254        /* check client wrote the record */
1255        ExpectIntGT(test_ctx.s_len, 14);
1256        /* return less data */
1257        ExpectIntEQ(
1258            test_memio_modify_message_len(&test_ctx, 0, 0, i == 0 ? 2 : 5), 0);
1259        /* Try to read the malformed record */
1260        wolfSSL_SetLoggingPrefix("server");
1261        ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
1262        ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
1263        ExpectIntEQ(test_ctx.s_len, 0);
1264
1265        ExpectIntEQ(test_dtls_communication(ssl_s, ssl_c), TEST_SUCCESS);
1266        ret = test_dtls_shutdown(ssl_s, ssl_c, ctx_c, ctx_s);
1267        ExpectIntEQ(ret, TEST_SUCCESS);
1268        ssl_c = ssl_s = NULL;
1269        ctx_c = ctx_s = NULL;
1270    }
1271
1272    return EXPECT_RESULT();
1273}
1274#else
1275int test_dtls13_short_read(void)
1276{
1277    return TEST_SKIPPED;
1278}
1279#endif /* WOLFSSL_DTLS13 && !defined(WOLFSSL_DTLS_RECORDS_CAN_SPAN_DATAGRAMS) */
1280
1281#if !defined(WOLFSSL_DTLS_RECORDS_CAN_SPAN_DATAGRAMS)
1282int test_dtls12_short_read(void)
1283{
1284    EXPECT_DECLS;
1285    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1286    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1287    struct test_memio_ctx test_ctx;
1288    unsigned char readBuf[50];
1289    int i;
1290    int ret;
1291
1292    for (i = 0; i < 3; i++) {
1293        XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1294
1295        /* Setup DTLS contexts */
1296        ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1297                        wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method),
1298            0);
1299        /* Complete handshake */
1300        ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
1301
1302        /* create a good record in the buffer */
1303        wolfSSL_SetLoggingPrefix("client");
1304        ExpectIntEQ(wolfSSL_write(ssl_c, "bad", 3), 3);
1305
1306        /* check client wrote the record */
1307        ExpectIntGT(test_ctx.s_len, 13 + 3);
1308        /* return less data */
1309        switch (i) {
1310        case 0:
1311            ExpectIntEQ(test_memio_modify_message_len(&test_ctx, 0, 0, 2), 0);
1312            break;
1313        case 1:
1314            ExpectIntEQ(test_memio_modify_message_len(&test_ctx, 0, 0, 13), 0);
1315            break;
1316        case 2:
1317            ExpectIntEQ(test_memio_modify_message_len(&test_ctx, 0, 0, 15), 0);
1318            break;
1319        }
1320
1321        /* Try to read the malformed record */
1322        wolfSSL_SetLoggingPrefix("server");
1323        ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
1324        ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
1325        ExpectIntEQ(test_ctx.s_len, 0);
1326
1327        ExpectIntEQ(test_dtls_communication(ssl_s, ssl_c), TEST_SUCCESS);
1328        ret = test_dtls_shutdown(ssl_s, ssl_c, ctx_c, ctx_s);
1329        ExpectIntEQ(ret, TEST_SUCCESS);
1330        ssl_c = ssl_s = NULL;
1331        ctx_c = ctx_s = NULL;
1332    }
1333
1334    return EXPECT_RESULT();
1335}
1336#else
1337int test_dtls12_short_read(void)
1338{
1339    return TEST_SKIPPED;
1340}
1341#endif /* !defined(WOLFSSL_DTLS_RECORDS_CAN_SPAN_DATAGRAMS) */
1342
1343#if !defined(WOLFSSL_DTLS_RECORDS_CAN_SPAN_DATAGRAMS)
1344int test_dtls12_record_length_mismatch(void)
1345{
1346    EXPECT_DECLS;
1347    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1348    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1349    struct test_memio_ctx test_ctx;
1350    unsigned char readBuf[50];
1351    int ret;
1352
1353    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1354
1355    /* Setup DTLS contexts */
1356    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1357                    wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method),
1358        0);
1359
1360    /* Complete handshake */
1361    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
1362
1363    /* write a message from client */
1364    ExpectIntEQ(wolfSSL_write(ssl_c, "bad", 3), 3);
1365
1366    /* check that the message is written in the buffer */
1367    ExpectIntGT(test_ctx.s_len, 14);
1368    /* modify the length field to be bigger than the content */
1369    test_ctx.s_buff[12] = 0xff;
1370
1371    /* Try to read the malformed record */
1372    wolfSSL_SetLoggingPrefix("server");
1373    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
1374    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
1375    ExpectIntEQ(test_ctx.s_len, 0);
1376
1377    ExpectIntEQ(test_dtls_communication(ssl_s, ssl_c), TEST_SUCCESS);
1378    ret = test_dtls_shutdown(ssl_s, ssl_c, ctx_c, ctx_s);
1379    ExpectIntEQ(ret, TEST_SUCCESS);
1380
1381    return EXPECT_RESULT();
1382}
1383
1384int test_dtls_record_cross_boundaries(void)
1385{
1386    EXPECT_DECLS;
1387    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1388    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1389    struct test_memio_ctx test_ctx;
1390    unsigned char readBuf[256];
1391    int rec0_len, rec1_len;
1392
1393    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1394
1395    /* Setup DTLS contexts */
1396    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1397                    wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method),
1398        0);
1399
1400    /* Complete handshake */
1401    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
1402
1403    /* create a first record in the buffer */
1404    wolfSSL_SetLoggingPrefix("client");
1405    ExpectIntEQ(wolfSSL_write(ssl_c, "test0", 5), 5);
1406    rec0_len = test_ctx.s_msg_sizes[0];
1407
1408    /* create a second record in the buffer */
1409    ExpectIntEQ(wolfSSL_write(ssl_c, "test1", 5), 5);
1410    rec1_len = test_ctx.s_msg_sizes[1];
1411
1412    ExpectIntLE(rec0_len + rec1_len, sizeof(readBuf));
1413    if (EXPECT_SUCCESS())
1414        XMEMCPY(readBuf, test_ctx.s_buff, rec0_len + rec1_len);
1415
1416    /* clear buffer */
1417    test_memio_clear_buffer(&test_ctx, 0);
1418
1419    /* inject first record + 1 bytes of second record */
1420    ExpectIntEQ(test_memio_inject_message(&test_ctx, 0, (const char*)readBuf,
1421                    rec0_len + 1),
1422        0);
1423
1424    /* inject second record */
1425    ExpectIntEQ(test_memio_inject_message(&test_ctx, 0,
1426                    (const char*)readBuf + rec0_len + 1, rec1_len - 1),
1427        0);
1428    ExpectIntEQ(test_ctx.s_len, rec0_len + rec1_len);
1429
1430    /* reading the record should return just the first message*/
1431    wolfSSL_SetLoggingPrefix("server");
1432    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), 5);
1433    ExpectBufEQ(readBuf, "test0", 5);
1434
1435    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)),
1436        WOLFSSL_FATAL_ERROR);
1437    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
1438
1439    /* cleanup */
1440    wolfSSL_free(ssl_s);
1441    wolfSSL_free(ssl_c);
1442    wolfSSL_CTX_free(ctx_s);
1443    wolfSSL_CTX_free(ctx_c);
1444
1445    return EXPECT_RESULT();
1446}
1447#else
1448int test_dtls12_record_length_mismatch(void)
1449{
1450    return TEST_SKIPPED;
1451}
1452int test_dtls_record_cross_boundaries(void)
1453{
1454    return TEST_SKIPPED;
1455}
1456#endif /* !defined(WOLFSSL_DTLS_RECORDS_CAN_SPAN_DATAGRAMS) */
1457
1458int test_dtls_short_ciphertext(void)
1459{
1460    EXPECT_DECLS;
1461    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1462    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1463    struct test_memio_ctx test_ctx;
1464    unsigned char readBuf[50];
1465    int ret;
1466
1467    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1468
1469    /* Setup DTLS contexts */
1470    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1471                    wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method),
1472        0);
1473
1474    /* Complete handshake */
1475    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
1476
1477    /* Create a message, that looks encrypted but shorter than minimum ciphertext length */
1478    /* create the data in the buffer */
1479    ExpectIntEQ(wolfSSL_write(ssl_c, "bad", 3), 3);
1480
1481    /* check client wrote the record */
1482    ExpectIntGT(test_ctx.s_len, 14);
1483
1484    /* modify the length field to be smaller than the content */
1485    test_ctx.s_buff[11] = 0x00;
1486    test_ctx.s_buff[12] = 0x02;
1487    /* modify the amount of data to send */
1488    ExpectIntEQ(test_memio_modify_message_len(&test_ctx, 0, 0, 15), 0);
1489
1490    /* Try to read the malformed record */
1491    wolfSSL_SetLoggingPrefix("server");
1492    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), -1);
1493    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
1494    ExpectIntEQ(test_ctx.s_len, 0);
1495
1496    ExpectIntEQ(test_dtls_communication(ssl_s, ssl_c), TEST_SUCCESS);
1497
1498    ret = test_dtls_shutdown(ssl_s, ssl_c, ctx_c, ctx_s);
1499    ExpectIntEQ(ret, TEST_SUCCESS);
1500
1501    return EXPECT_RESULT();
1502}
1503#else
1504int test_dtls_short_ciphertext(void)
1505{
1506    return TEST_SKIPPED;
1507}
1508int test_dtls12_record_length_mismatch(void)
1509{
1510    return TEST_SKIPPED;
1511}
1512int test_dtls12_short_read(void)
1513{
1514    return TEST_SKIPPED;
1515}
1516int test_dtls13_short_read(void)
1517{
1518    return TEST_SKIPPED;
1519}
1520int test_dtls13_longer_length(void)
1521{
1522    return TEST_SKIPPED;
1523}
1524int test_dtls_record_cross_boundaries(void)
1525{
1526    return TEST_SKIPPED;
1527}
1528#endif /* defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS) */
1529
1530#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
1531    !defined(WOLFSSL_NO_TLS12) && !defined(NO_SHA256)
1532/* This test that the DTLS record boundary check doesn't interfere with TLS
1533 * records processing */
1534int test_records_span_network_boundaries(void)
1535{
1536    EXPECT_DECLS;
1537    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1538    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1539    struct test_memio_ctx test_ctx;
1540    unsigned char readBuf[256];
1541    int record_len;
1542
1543    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1544
1545    /* Setup DTLS contexts */
1546    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1547                    wolfTLSv1_2_client_method, wolfTLSv1_2_server_method),
1548        0);
1549
1550    /* Complete handshake */
1551    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
1552
1553    /* create a good record in the buffer */
1554    wolfSSL_SetLoggingPrefix("client");
1555    ExpectIntEQ(wolfSSL_write(ssl_c, "test", 4), 4);
1556    ExpectIntLE(test_ctx.s_len, sizeof(readBuf));
1557    ExpectIntGT(test_ctx.s_len, 10);
1558    record_len = test_ctx.s_len;
1559    if (EXPECT_SUCCESS())
1560        XMEMCPY(readBuf, test_ctx.s_buff, record_len);
1561
1562    /* drop record and simulate a split write */
1563    ExpectIntEQ(test_memio_drop_message(&test_ctx, 0, 0), 0);
1564    ExpectIntEQ(test_ctx.s_msg_count, 0);
1565
1566    /* inject first record header */
1567    ExpectIntEQ(
1568        test_memio_inject_message(&test_ctx, 0, (const char*)readBuf, 5), 0);
1569    ExpectIntEQ(test_ctx.s_msg_count, 1);
1570    ExpectIntEQ(test_ctx.s_msg_sizes[0], 5);
1571
1572    /* inject another 5 bytes of the record */
1573    ExpectIntEQ(
1574        test_memio_inject_message(&test_ctx, 0, (const char*)readBuf + 5, 5),
1575        0);
1576    ExpectIntEQ(test_ctx.s_msg_count, 2);
1577    ExpectIntEQ(test_ctx.s_msg_sizes[1], 5);
1578
1579    /* inject the rest of the record */
1580    ExpectIntEQ(test_memio_inject_message(&test_ctx, 0,
1581                    (const char*)readBuf + 10, record_len - 10),
1582        0);
1583    ExpectIntEQ(test_ctx.s_msg_count, 3);
1584    ExpectIntEQ(test_ctx.s_msg_sizes[2], record_len - 10);
1585
1586    /* read the record */
1587    wolfSSL_SetLoggingPrefix("server");
1588    ExpectIntEQ(wolfSSL_read(ssl_s, readBuf, sizeof(readBuf)), 4);
1589    ExpectIntEQ(test_ctx.s_len, 0);
1590
1591    ExpectBufEQ(readBuf, "test", 4);
1592
1593    wolfSSL_free(ssl_s);
1594    wolfSSL_free(ssl_c);
1595    wolfSSL_CTX_free(ctx_s);
1596    wolfSSL_CTX_free(ctx_c);
1597
1598    return EXPECT_RESULT();
1599}
1600#else
1601int test_records_span_network_boundaries(void)
1602{
1603    return TEST_SKIPPED;
1604}
1605#endif /* defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) &&                     \
1606          !defined(WOLFSSL_NO_TLS12) */
1607
1608int test_dtls_mtu_fragment_headroom(void)
1609{
1610#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) &&                           \
1611    defined(WOLFSSL_DTLS_MTU) && defined(HAVE_AESGCM) && defined(HAVE_ECC) &&  \
1612    !defined(WOLFSSL_NO_DTLS_SIZE_CHECK)
1613    EXPECT_DECLS;
1614    struct {
1615        method_provider client_meth;
1616        method_provider server_meth;
1617        const char* cipher;
1618        int use_cid;
1619    } params[] = {
1620#if defined(WOLFSSL_DTLS13) && defined(WOLFSSL_TLS13)
1621        { wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method,
1622          "TLS13-AES128-GCM-SHA256", 0 },
1623#ifdef WOLFSSL_DTLS_CID
1624        { wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method,
1625          "TLS13-AES128-GCM-SHA256", 1 },
1626#endif
1627#endif
1628#if defined(WOLFSSL_DTLS) && !defined(WOLFSSL_NO_TLS12)
1629        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method,
1630          "ECDHE-RSA-AES128-GCM-SHA256", 0 },
1631#ifdef WOLFSSL_DTLS_CID
1632        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method,
1633          "ECDHE-RSA-AES128-GCM-SHA256", 1 },
1634#endif
1635#if !defined(WOLFSSL_AEAD_ONLY) && !defined(NO_AES) && !defined(NO_SHA)
1636        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method,
1637          "ECDHE-RSA-AES128-SHA", 0 },
1638#ifdef WOLFSSL_DTLS_CID
1639        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method,
1640          "ECDHE-RSA-AES128-SHA", 1 },
1641#endif
1642#endif
1643#endif
1644    };
1645    size_t i;
1646
1647    for (i = 0; i < XELEM_CNT(params) && EXPECT_SUCCESS(); i++) {
1648        WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1649        WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1650        struct test_memio_ctx test_ctx;
1651        unsigned char payload[33];
1652        word16 mtu;
1653        int recordLen;
1654        int overhead;
1655        int ret;
1656
1657        XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1658        XMEMSET(payload, 'A', sizeof(payload));
1659
1660        ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1661                        params[i].client_meth, params[i].server_meth),
1662            0);
1663
1664        ExpectIntEQ(wolfSSL_set_cipher_list(ssl_c, params[i].cipher), 1);
1665        ExpectIntEQ(wolfSSL_set_cipher_list(ssl_s, params[i].cipher), 1);
1666
1667#ifdef WOLFSSL_DTLS_CID
1668        if (params[i].use_cid) {
1669            unsigned char cid_c[] = { 0,1,2,3 };
1670            unsigned char cid_s[] = { 4,5,6,7,8,9 };
1671            ExpectIntEQ(wolfSSL_dtls_cid_use(ssl_c), 1);
1672            ExpectIntEQ(wolfSSL_dtls_cid_use(ssl_s), 1);
1673            ExpectIntEQ(wolfSSL_dtls_cid_set(ssl_c, cid_s, (int)sizeof(cid_s)),
1674                1);
1675            ExpectIntEQ(wolfSSL_dtls_cid_set(ssl_s, cid_c, (int)sizeof(cid_c)),
1676                1);
1677        }
1678#endif
1679
1680        /* Complete handshake and clear any leftover records. */
1681        ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
1682        test_memio_clear_buffer(&test_ctx, 1);
1683        test_memio_clear_buffer(&test_ctx, 0);
1684
1685        /* Measure application-data record overhead. */
1686        ExpectIntEQ(wolfSSL_write(ssl_c, payload, 32), 32);
1687        ExpectIntEQ(test_ctx.s_msg_count, 1);
1688        recordLen = test_ctx.s_len;
1689        ExpectIntGT(recordLen, 32);
1690        overhead = recordLen - 32;
1691
1692        /* Reset buffers before MTU-limited send. */
1693        test_memio_clear_buffer(&test_ctx, 0);
1694        test_memio_clear_buffer(&test_ctx, 1);
1695
1696        /* Set MTU to overhead + 32 bytes of payload. */
1697        mtu = (word16)(overhead + 32);
1698        ExpectIntEQ(wolfSSL_dtls_set_mtu(ssl_c, mtu), WOLFSSL_SUCCESS);
1699        ExpectIntEQ(wolfSSL_dtls_set_mtu(ssl_s, mtu), WOLFSSL_SUCCESS);
1700
1701        /* With the tightened MTU, we should still be able to send 32 bytes. */
1702        ExpectIntEQ(wolfSSL_write(ssl_c, payload, 32), 32);
1703        ExpectIntEQ(test_ctx.s_msg_count, 1);
1704        recordLen = test_ctx.s_len;
1705        ExpectIntEQ(recordLen, overhead + 32);
1706        ExpectIntLE(recordLen, mtu);
1707
1708        /* Underestimation: drop MTU by 1 and expect DTLS_SIZE_ERROR. */
1709        test_memio_clear_buffer(&test_ctx, 0);
1710        test_memio_clear_buffer(&test_ctx, 1);
1711        ExpectIntEQ(wolfSSL_dtls_set_mtu(ssl_c, mtu - 1), WOLFSSL_SUCCESS);
1712        ret = wolfSSL_write(ssl_c, payload, 32);
1713        ExpectIntNE(ret, 32);
1714        ExpectIntEQ(wolfSSL_get_error(ssl_c, ret), DTLS_SIZE_ERROR);
1715
1716        wolfSSL_free(ssl_c);
1717        wolfSSL_CTX_free(ctx_c);
1718        wolfSSL_free(ssl_s);
1719        wolfSSL_CTX_free(ctx_s);
1720    }
1721    return EXPECT_RESULT();
1722#else
1723    return TEST_SKIPPED;
1724#endif
1725}
1726
1727int test_dtls_rtx_across_epoch_change(void)
1728{
1729    EXPECT_DECLS;
1730#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) &&                           \
1731    defined(WOLFSSL_DTLS13) && defined(WOLFSSL_DTLS)
1732    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1733    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1734    struct test_memio_ctx test_ctx;
1735#if defined(WOLFSSL_HAVE_MLKEM)
1736    /* When ML-KEM is used in the key share, the hello messages are fragmented
1737     *into two messages */
1738    int helloMsgCount = 2;
1739    int groups[2] = {
1740    #if defined(HAVE_CURVE25519) && defined(WOLFSSL_PQC_HYBRIDS) && \
1741        !defined(WOLFSSL_NO_ML_KEM) && !defined(WOLFSSL_NO_ML_KEM_768)
1742        WOLFSSL_X25519MLKEM768,
1743    #elif defined(HAVE_ECC) && defined(WOLFSSL_PQC_HYBRIDS) && \
1744        !defined(WOLFSSL_NO_ML_KEM) && !defined(WOLFSSL_NO_ML_KEM_768)
1745        WOLFSSL_SECP256R1MLKEM768,
1746    #elif defined(HAVE_ECC) && defined(WOLFSSL_PQC_HYBRIDS) && \
1747        !defined(WOLFSSL_NO_ML_KEM) && !defined(WOLFSSL_NO_ML_KEM_1024)
1748        WOLFSSL_SECP384R1MLKEM1024,
1749    #elif !defined(WOLFSSL_NO_ML_KEM_1024) && !defined(WOLFSSL_NO_ML_KEM) && \
1750                                       !defined(WOLFSSL_TLS_NO_MLKEM_STANDALONE)
1751        WOLFSSL_ML_KEM_1024,
1752    #elif !defined(WOLFSSL_NO_ML_KEM_768) && !defined(WOLFSSL_NO_ML_KEM) && \
1753                                       !defined(WOLFSSL_TLS_NO_MLKEM_STANDALONE)
1754        WOLFSSL_ML_KEM_768,
1755    #elif !defined(WOLFSSL_NO_ML_KEM_512) && \
1756                                       !defined(WOLFSSL_TLS_NO_MLKEM_STANDALONE)
1757        WOLFSSL_ML_KEM_512,
1758    #elif defined(WOLFSSL_MLKEM_KYBER) && !defined(WOLFSSL_NO_KYBER1024)
1759        WOLFSSL_KYBER_LEVEL5,
1760    #elif defined(WOLFSSL_MLKEM_KYBER) && !defined(WOLFSSL_NO_KYBER768)
1761        WOLFSSL_KYBER_LEVEL3,
1762    #elif defined(WOLFSSL_MLKEM_KYBER) && !defined(WOLFSSL_NO_KYBER512)
1763        WOLFSSL_KYBER_LEVEL1,
1764    #endif
1765        WOLFSSL_ECC_SECP256R1,
1766    };
1767#else
1768    /* When ECC is used in the key share, the hello messages are not
1769     * fragmented */
1770    int helloMsgCount = 1;
1771#endif
1772
1773    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1774
1775    /* Setup DTLS contexts */
1776    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1777                    wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method),
1778        0);
1779
1780#if defined(WOLFSSL_HAVE_MLKEM)
1781    ExpectIntEQ(wolfSSL_set_groups(ssl_c, groups, 2), WOLFSSL_SUCCESS);
1782    ExpectIntEQ(wolfSSL_set_groups(ssl_s, groups, 2), WOLFSSL_SUCCESS);
1783#endif
1784
1785    /* CH0 */
1786    wolfSSL_SetLoggingPrefix("client:");
1787    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
1788    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), SSL_ERROR_WANT_READ);
1789
1790    /* HRR */
1791    wolfSSL_SetLoggingPrefix("server:");
1792    ExpectIntEQ(wolfSSL_accept(ssl_s), -1);
1793    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), SSL_ERROR_WANT_READ);
1794
1795    /* CH1 */
1796    wolfSSL_SetLoggingPrefix("client:");
1797    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
1798    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), SSL_ERROR_WANT_READ);
1799
1800    /* SH ... FINISHED */
1801    wolfSSL_SetLoggingPrefix("server:");
1802    ExpectIntEQ(wolfSSL_accept(ssl_s), -1);
1803    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), SSL_ERROR_WANT_READ);
1804
1805    /* we should have now SH ... FINISHED messages in the buffer*/
1806    ExpectIntGE(test_ctx.c_msg_count, 2);
1807
1808    /* drop everything but the SH */
1809    while (test_ctx.c_msg_count > helloMsgCount && EXPECT_SUCCESS()) {
1810        ExpectIntEQ(test_memio_drop_message(&test_ctx, 1, test_ctx.c_msg_count - 1), 0);
1811    }
1812
1813    /* Read the SH */
1814    wolfSSL_SetLoggingPrefix("client:");
1815    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
1816    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), SSL_ERROR_WANT_READ);
1817
1818    /* trigger client timeout */
1819    ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), WOLFSSL_SUCCESS);
1820    /* this should have triggered a rtx */
1821    ExpectIntGT(test_ctx.s_msg_count, 0);
1822
1823    /* finish the handshake */
1824    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
1825
1826    /* Test communication works correctly */
1827    ExpectIntEQ(test_dtls_communication(ssl_s, ssl_c), TEST_SUCCESS);
1828
1829    /* Cleanup */
1830    wolfSSL_free(ssl_c);
1831    wolfSSL_CTX_free(ctx_c);
1832    wolfSSL_free(ssl_s);
1833    wolfSSL_CTX_free(ctx_s);
1834#endif /* defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) &&                     \
1835          defined(WOLFSSL_DTLS13) */
1836    return EXPECT_RESULT();
1837}
1838
1839#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) &&                           \
1840    defined(WOLFSSL_DTLS13) && defined(WOLFSSL_DTLS)
1841static int test_dtls13_get_message_seq(const char* msg, int msgSz,
1842    word16* msgSeq)
1843{
1844    int hsOff = DTLS_RECORD_HEADER_SZ;
1845
1846    if (msg == NULL || msgSeq == NULL ||
1847            msgSz < DTLS_RECORD_HEADER_SZ + DTLS_HANDSHAKE_HEADER_SZ) {
1848        return BAD_FUNC_ARG;
1849    }
1850
1851    *msgSeq = ((word16)(byte)msg[hsOff + 4] << 8) |
1852              (word16)(byte)msg[hsOff + 5];
1853
1854    return WOLFSSL_SUCCESS;
1855}
1856#endif
1857
1858int test_dtls13_ch2_rtx_no_ch1(void)
1859{
1860    EXPECT_DECLS;
1861#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) &&                           \
1862    defined(WOLFSSL_DTLS13) && defined(WOLFSSL_DTLS)
1863    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1864    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1865    struct test_memio_ctx test_ctx;
1866    const char* msg = NULL;
1867    int msgSz = 0;
1868    word16 ch1Seq = 0;
1869    int i;
1870    int foundCh1Seq = 0;
1871
1872    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1873
1874    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1875                    wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method),
1876        0);
1877
1878    /* To force HRR */
1879    ExpectIntEQ(wolfSSL_NoKeyShares(ssl_c), WOLFSSL_SUCCESS);
1880
1881    /* CH1 */
1882    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
1883    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
1884    ExpectIntEQ(test_memio_get_message(&test_ctx, 0, &msg, &msgSz, 0), 0);
1885    ExpectIntGE(msgSz, DTLS_RECORD_HEADER_SZ + DTLS_HANDSHAKE_HEADER_SZ);
1886    ExpectIntEQ(test_dtls13_get_message_seq(msg, msgSz, &ch1Seq),
1887        WOLFSSL_SUCCESS);
1888
1889    /* HRR */
1890    ExpectIntEQ(wolfSSL_accept(ssl_s), -1);
1891    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
1892    ExpectIntGT(test_ctx.c_msg_count, 0);
1893
1894    /* CH2 */
1895    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
1896    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
1897    ExpectIntGT(test_ctx.s_msg_count, 0);
1898
1899    /* Drop CH2 and trigger the client retransmission timeout. */
1900    test_memio_clear_buffer(&test_ctx, 0);
1901    if (wolfSSL_dtls13_use_quick_timeout(ssl_c))
1902        ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), WOLFSSL_SUCCESS);
1903    ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), WOLFSSL_SUCCESS);
1904    ExpectIntGT(test_ctx.s_msg_count, 0);
1905
1906    for (i = 0; i < test_ctx.s_msg_count && EXPECT_SUCCESS(); i++) {
1907        int hsOff = DTLS_RECORD_HEADER_SZ;
1908        word16 msgSeq = 0;
1909
1910        ExpectIntEQ(test_memio_get_message(&test_ctx, 0, &msg, &msgSz, i), 0);
1911        /* memio stores one DTLS record per message in this handshake path. */
1912        if (msgSz >= DTLS_RECORD_HEADER_SZ + DTLS_HANDSHAKE_HEADER_SZ &&
1913                (byte)msg[0] == handshake && msg[hsOff] == client_hello) {
1914            ExpectIntEQ(test_dtls13_get_message_seq(msg, msgSz, &msgSeq),
1915                WOLFSSL_SUCCESS);
1916            if (msgSeq == ch1Seq)
1917                foundCh1Seq = 1;
1918        }
1919    }
1920
1921    ExpectIntEQ(foundCh1Seq, 0);
1922
1923    wolfSSL_free(ssl_c);
1924    wolfSSL_CTX_free(ctx_c);
1925    wolfSSL_free(ssl_s);
1926    wolfSSL_CTX_free(ctx_s);
1927#endif
1928    return EXPECT_RESULT();
1929}
1930
1931int test_dtls13_frag_ch2_with_ch1_rtx(void)
1932{
1933    EXPECT_DECLS;
1934#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) &&                           \
1935    defined(WOLFSSL_DTLS13) && defined(WOLFSSL_DTLS) &&                        \
1936    defined(WOLFSSL_DTLS_MTU) && defined(WOLFSSL_DTLS_CH_FRAG) &&              \
1937    (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0))
1938    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
1939    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
1940    struct test_memio_ctx test_ctx;
1941    char hrr[TEST_MEMIO_BUF_SZ];
1942    int hrrSz = (int)sizeof(hrr);
1943    char ch1Rtx[TEST_MEMIO_BUF_SZ];
1944    int ch1RtxSz = (int)sizeof(ch1Rtx);
1945    char ch2[TEST_MEMIO_BUF_SZ];
1946    int ch2Sz = 0;
1947    int ch2MsgCount = 0;
1948    int ch2MsgSizes[TEST_MEMIO_MAX_MSGS] = {0};
1949    /* The DTLS record sequence number occupies the last 8 bytes of the
1950     * record header. */
1951    int recordSeqOff = DTLS_RECORD_HEADER_SZ - 8;
1952    int ch2Seq = 0;
1953    int ch1RtxSeq = 0;
1954    int off;
1955    int i;
1956
1957    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1958
1959    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1960                    wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method),
1961        0);
1962
1963    /* To force HRR */
1964    ExpectIntEQ(wolfSSL_NoKeyShares(ssl_c), WOLFSSL_SUCCESS);
1965    ExpectIntEQ(wolfSSL_dtls13_allow_ch_frag(ssl_s, 1), WOLFSSL_SUCCESS);
1966
1967    /* CH1 */
1968    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
1969    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
1970
1971    /* HRR */
1972    ExpectIntEQ(wolfSSL_accept(ssl_s), -1);
1973    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
1974    ExpectIntEQ(test_memio_copy_message(&test_ctx, 1, hrr, &hrrSz, 0), 0);
1975
1976    /* Drop HRR, trigger CH1 retransmission, copy and drop it */
1977    test_memio_clear_buffer(&test_ctx, 1);
1978    if (wolfSSL_dtls13_use_quick_timeout(ssl_c))
1979        ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), WOLFSSL_SUCCESS);
1980    ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), WOLFSSL_SUCCESS);
1981    ExpectIntEQ(test_memio_copy_message(&test_ctx, 0, ch1Rtx, &ch1RtxSz, 0), 0);
1982    test_memio_clear_buffer(&test_ctx, 0);
1983
1984    /* Force CH2 fragmentation. MTU must be small enough to fragment but large
1985     * enough that the cookie extension lands in the first fragment, otherwise
1986     * the server can't validate it statelessly and the test scenario (server
1987     * stateful after frag 1) does not hold. With --enable-all (PQ groups in
1988     * supported_groups), the cookie extension can sit ~400 bytes into CH2; 600
1989     * gives margin while still producing multiple fragments (CH2 is ~2KB). */
1990    ExpectIntEQ(wolfSSL_dtls_set_mtu(ssl_c, 600), WOLFSSL_SUCCESS);
1991
1992    /* Forward HRR and let the client create fragmented CH2 */
1993    ExpectIntEQ(test_memio_inject_message(&test_ctx, 1, hrr, hrrSz), 0);
1994    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
1995    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
1996
1997    ExpectIntGT(test_ctx.s_msg_count, 1);
1998    ExpectIntLE(test_ctx.s_msg_count, TEST_MEMIO_MAX_MSGS);
1999    ExpectIntLE(test_ctx.s_len, (int)sizeof(ch2));
2000    if (EXPECT_SUCCESS()) {
2001        ch2Sz = test_ctx.s_len;
2002        ch2MsgCount = test_ctx.s_msg_count;
2003        XMEMCPY(ch2, test_ctx.s_buff, ch2Sz);
2004        XMEMCPY(ch2MsgSizes, test_ctx.s_msg_sizes,
2005            sizeof(ch2MsgSizes[0]) * (size_t)ch2MsgCount);
2006
2007        ch2Seq = ((byte)ch2[recordSeqOff + 4] << 8) |
2008                 (byte)ch2[recordSeqOff + 5];
2009        ch1RtxSeq = ch2Seq + ch2MsgCount;
2010
2011        /* Synthesize a CH1 retransmission that can pass the replay window after
2012         * the first CH2 fragment makes the server stateful. The handshake
2013         * message_seq remains the original CH1 value; only the DTLS record
2014         * sequence is moved past the fragmented CH2 flight */
2015        ch1Rtx[recordSeqOff + 0] = 0;
2016        ch1Rtx[recordSeqOff + 1] = 0;
2017        ch1Rtx[recordSeqOff + 2] = 0;
2018        ch1Rtx[recordSeqOff + 3] = 0;
2019        ch1Rtx[recordSeqOff + 4] = (byte)(ch1RtxSeq >> 8);
2020        ch1Rtx[recordSeqOff + 5] = (byte)ch1RtxSeq;
2021    }
2022
2023    test_memio_clear_buffer(&test_ctx, 0);
2024
2025    /* Deliver CH2 first fragment only. Now server is stateful */
2026    ExpectIntEQ(test_memio_inject_message(&test_ctx, 0, ch2, ch2MsgSizes[0]), 0);
2027    ExpectIntEQ(wolfSSL_accept(ssl_s), -1);
2028    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
2029
2030    /* Deliver the retransmitted CH1 between CH2 fragments, it should be
2031     * discarded as rtx */
2032    ExpectIntEQ(test_memio_inject_message(&test_ctx, 0, ch1Rtx, ch1RtxSz), 0);
2033    ExpectIntEQ(wolfSSL_accept(ssl_s), -1);
2034    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
2035    test_memio_clear_buffer(&test_ctx, 1);
2036
2037    /* Deliver the rest of CH2 */
2038    off = ch2MsgSizes[0];
2039    for (i = 1; i < ch2MsgCount && EXPECT_SUCCESS(); i++) {
2040        ExpectIntEQ(test_memio_inject_message(&test_ctx, 0, ch2 + off,
2041            ch2MsgSizes[i]), 0);
2042        off += ch2MsgSizes[i];
2043    }
2044
2045    /* Restore MTU so the client's input buffer can hold the full server
2046     * flight (e.g. an SH carrying a hybrid PQC key share). */
2047    ExpectIntEQ(wolfSSL_dtls_set_mtu(ssl_c, 1500), WOLFSSL_SUCCESS);
2048
2049    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
2050
2051    wolfSSL_free(ssl_c);
2052    wolfSSL_CTX_free(ctx_c);
2053    wolfSSL_free(ssl_s);
2054    wolfSSL_CTX_free(ctx_s);
2055#endif
2056    return EXPECT_RESULT();
2057}
2058
2059int test_dtls_drop_client_ack(void)
2060{
2061    EXPECT_DECLS;
2062#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) &&                           \
2063    defined(WOLFSSL_DTLS13) && defined(WOLFSSL_DTLS)
2064    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
2065    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
2066    struct test_memio_ctx test_ctx;
2067    char data[32];
2068
2069    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
2070
2071    /* Setup DTLS contexts */
2072    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
2073                    wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method),
2074        0);
2075
2076    /* disable new session ticket to simplify testing */
2077    ExpectIntEQ(wolfSSL_no_ticket_TLSv13(ssl_s), 0);
2078
2079    /* CH0 */
2080    wolfSSL_SetLoggingPrefix("client:");
2081    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
2082    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
2083
2084    /* HRR */
2085    wolfSSL_SetLoggingPrefix("server:");
2086    ExpectIntEQ(wolfSSL_accept(ssl_s), -1);
2087    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
2088
2089    /* CH1 */
2090    wolfSSL_SetLoggingPrefix("client:");
2091    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
2092    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
2093
2094    /* SH ... FINISHED */
2095    wolfSSL_SetLoggingPrefix("server:");
2096    ExpectIntEQ(wolfSSL_accept(ssl_s), -1);
2097    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
2098
2099    /* ... FINISHED */
2100    wolfSSL_SetLoggingPrefix("client:");
2101    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
2102    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
2103
2104    /* init is finished should return false at this point */
2105    ExpectFalse(wolfSSL_is_init_finished(ssl_c));
2106
2107    /* ACK */
2108    ExpectIntEQ(wolfSSL_accept(ssl_s), WOLFSSL_SUCCESS);
2109    /* Drop the ack */
2110    test_memio_clear_buffer(&test_ctx, 1);
2111
2112    /* trigger client timeout, finished should be rtx */
2113    ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), WOLFSSL_SUCCESS);
2114    ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), WOLFSSL_SUCCESS);
2115    /* this should have triggered a rtx */
2116    ExpectIntGT(test_ctx.s_msg_count, 0);
2117
2118    /* this should re-send the ack immediately */
2119    ExpectIntEQ(wolfSSL_read(ssl_s, data, 32), -1);
2120    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
2121    ExpectIntEQ(test_ctx.c_msg_count, 1);
2122
2123    /* This should advance the connection on the client */
2124    ExpectIntEQ(wolfSSL_negotiate(ssl_c), WOLFSSL_SUCCESS);
2125
2126    /* Test communication works correctly */
2127    ExpectIntEQ(test_dtls_communication(ssl_s, ssl_c), TEST_SUCCESS);
2128
2129    /* Cleanup */
2130    wolfSSL_free(ssl_c);
2131    wolfSSL_CTX_free(ctx_c);
2132    wolfSSL_free(ssl_s);
2133    wolfSSL_CTX_free(ctx_s);
2134#endif /* defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) &&                     \
2135          defined(WOLFSSL_DTLS13) */
2136    return EXPECT_RESULT();
2137}
2138
2139int test_dtls_bogus_finished_epoch_zero(void)
2140{
2141    EXPECT_DECLS;
2142#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS) && \
2143    !defined(WOLFSSL_NO_TLS12) && defined(HAVE_AES_CBC) && \
2144    defined(WOLFSSL_AES_128) && !defined(NO_SHA256)
2145    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
2146    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
2147    struct test_memio_ctx test_ctx;
2148    int error;
2149
2150    /* bogus Finished message bytes from the original bug report (epoch 0)
2151     * https://github.com/wolfSSL/wolfssl/issues/9188 */
2152    static const unsigned char bogus_finished[] = {
2153        0x16, 0xfe, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2154        0x18, 0x14, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2155        0x0c, 0xd9, 0xc6, 0xe3, 0x01, 0x59, 0xf2, 0xc2, 0x4f, 0xfa, 0xfd, 0x20,
2156        0xd7
2157    };
2158
2159    /* serverHelloDone message bytes */
2160    static const unsigned char server_hello_done_message[] = {
2161        0x16, 0xfe, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
2162        0x0c, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
2163        0x00
2164    };
2165
2166    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
2167
2168    /* setting up dtls 1.2 contexts */
2169    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
2170            wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method), 0);
2171
2172    /* start handshake, send first ClientHelloDone */
2173    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
2174    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
2175
2176    /* clearing server buffer to inject the wrong Finished packet */
2177    test_memio_clear_buffer(&test_ctx, 1);
2178    ExpectIntEQ(test_memio_inject_message(&test_ctx, 1,
2179            (const char*)bogus_finished, sizeof(bogus_finished)), 0);
2180
2181    /* continue client handshake to process it */
2182    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
2183
2184    /* client should terminate with dtls sequence error */
2185    error = wolfSSL_get_error(ssl_c, -1);
2186
2187    /* check if the error is SEQUENCE_ERROR, handshake should not
2188     * expect a finished packet in that moment, in particular should not
2189     * be in epoch = 0 (should be epoch = 1) */
2190    ExpectTrue(error == WC_NO_ERR_TRACE(SEQUENCE_ERROR) ||
2191               error == WC_NO_ERR_TRACE(WOLFSSL_ERROR_WANT_READ));
2192
2193    /* forcing injection ServerHelloDone to test if client would replay
2194     * ClientHello */
2195    test_memio_clear_buffer(&test_ctx, 0);
2196    ExpectIntEQ(test_memio_inject_message(&test_ctx, 1,
2197            (const char*)server_hello_done_message, sizeof(server_hello_done_message)), 0);
2198    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
2199
2200    /* verifying no ClientHello replay occurred,
2201     * buffer should empty since we exit early on
2202     * because of the bogus finished packet */
2203    ExpectIntLE(test_ctx.s_len, 0);
2204
2205    wolfSSL_free(ssl_c);
2206    wolfSSL_CTX_free(ctx_c);
2207    wolfSSL_free(ssl_s);
2208    wolfSSL_CTX_free(ctx_s);
2209#endif
2210    return EXPECT_RESULT();
2211}
2212
2213int test_dtls_replay(void)
2214{
2215    EXPECT_DECLS;
2216#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS)
2217    size_t i;
2218    struct {
2219        method_provider client_meth;
2220        method_provider server_meth;
2221        const char* tls_version;
2222    } params[] = {
2223#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_DTLS13)
2224        { wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method, "DTLSv1_3" },
2225#endif
2226#if !defined(WOLFSSL_NO_TLS12) && defined(WOLFSSL_DTLS)
2227        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method, "DTLSv1_2" },
2228#endif
2229#if !defined(NO_OLD_TLS) && defined(WOLFSSL_DTLS)
2230        { wolfDTLSv1_client_method, wolfDTLSv1_server_method, "DTLSv1_0" },
2231#endif
2232    };
2233    for (i = 0; i < XELEM_CNT(params) && !EXPECT_FAIL(); i++) {
2234        WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
2235        WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
2236        struct test_memio_ctx test_ctx;
2237
2238        char msg_buf[256];
2239        int msg_len = sizeof(msg_buf);
2240        byte app_data[8];
2241
2242        XMEMSET(&test_ctx, 0, sizeof(test_ctx));
2243
2244        /* Setup DTLS contexts */
2245        ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
2246                params[i].client_meth, params[i].server_meth), 0);
2247        ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
2248
2249        ExpectIntEQ(wolfSSL_write(ssl_c, "test", 4), 4);
2250        ExpectIntEQ(test_memio_copy_message(&test_ctx, 0, msg_buf, &msg_len, 0), 0);
2251        ExpectIntEQ(wolfSSL_read(ssl_s, app_data, sizeof(app_data)), 4);
2252        ExpectIntEQ(test_memio_inject_message(&test_ctx, 0, msg_buf, msg_len), 0);
2253        ExpectIntEQ(wolfSSL_read(ssl_s, app_data, sizeof(app_data)), -1);
2254        ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
2255
2256        wolfSSL_free(ssl_c);
2257        wolfSSL_CTX_free(ctx_c);
2258        wolfSSL_free(ssl_s);
2259        wolfSSL_CTX_free(ctx_s);
2260    }
2261#endif
2262    return EXPECT_RESULT();
2263}
2264
2265#if defined(WOLFSSL_DTLS13) && defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) && \
2266    defined(WOLFSSL_SRTP)
2267static int test_dtls_srtp_ctx_ready(WOLFSSL_CTX* ctx)
2268{
2269    EXPECT_DECLS;
2270    ExpectIntEQ(wolfSSL_CTX_set_tlsext_use_srtp(ctx, "SRTP_AEAD_AES_256_GCM:"
2271         "SRTP_AEAD_AES_128_GCM:SRTP_AES128_CM_SHA1_80:SRTP_AES128_CM_SHA1_32"),
2272          0);
2273    return EXPECT_RESULT();
2274}
2275
2276int test_dtls_srtp(void)
2277{
2278    EXPECT_DECLS;
2279    test_ssl_cbf client_cbf;
2280    test_ssl_cbf server_cbf;
2281
2282    XMEMSET(&client_cbf, 0, sizeof(client_cbf));
2283    XMEMSET(&server_cbf, 0, sizeof(server_cbf));
2284
2285    client_cbf.method = wolfDTLSv1_3_client_method;
2286    client_cbf.ctx_ready = test_dtls_srtp_ctx_ready;
2287    server_cbf.method = wolfDTLSv1_3_server_method;
2288    server_cbf.ctx_ready = test_dtls_srtp_ctx_ready;
2289
2290    ExpectIntEQ(test_wolfSSL_client_server_nofail_memio(&client_cbf,
2291        &server_cbf, NULL), TEST_SUCCESS);
2292
2293    return EXPECT_RESULT();
2294}
2295#else
2296int test_dtls_srtp(void)
2297{
2298    EXPECT_DECLS;
2299    return EXPECT_RESULT();
2300}
2301#endif
2302
2303int test_dtls_timeout(void)
2304{
2305    EXPECT_DECLS;
2306#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS)
2307    size_t i;
2308    struct {
2309        method_provider client_meth;
2310        method_provider server_meth;
2311    } params[] = {
2312#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_DTLS13)
2313        { wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method },
2314#endif
2315#if !defined(WOLFSSL_NO_TLS12) && defined(WOLFSSL_DTLS)
2316        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method },
2317#endif
2318#if !defined(NO_OLD_TLS) && defined(WOLFSSL_DTLS)
2319        { wolfDTLSv1_client_method, wolfDTLSv1_server_method },
2320#endif
2321    };
2322
2323    for (i = 0; i < XELEM_CNT(params) && !EXPECT_FAIL(); i++) {
2324        WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
2325        WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
2326        struct test_memio_ctx test_ctx;
2327
2328        XMEMSET(&test_ctx, 0, sizeof(test_ctx));
2329
2330        ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
2331                params[i].client_meth, params[i].server_meth), 0);
2332        ExpectIntEQ(wolfSSL_dtls_set_timeout_max(ssl_c, 2), WOLFSSL_SUCCESS);
2333        ExpectIntEQ(wolfSSL_negotiate(ssl_c), -1);
2334        ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
2335#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_DTLS13)
2336        /* will return 0 when not 1.3 */
2337        if (wolfSSL_dtls13_use_quick_timeout(ssl_c))
2338            ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), WOLFSSL_SUCCESS);
2339#endif
2340        ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), WOLFSSL_SUCCESS);
2341        ExpectIntEQ(wolfSSL_dtls_get_current_timeout(ssl_c), 2);
2342        ExpectIntEQ(wolfSSL_negotiate(ssl_s), -1);
2343        ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
2344        ExpectIntEQ(wolfSSL_negotiate(ssl_c), -1);
2345        ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
2346        ExpectIntEQ(wolfSSL_dtls_get_current_timeout(ssl_c), 1);
2347#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_DTLS13)
2348        /* will return 0 when not 1.3 */
2349        if (wolfSSL_dtls13_use_quick_timeout(ssl_c))
2350            ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), WOLFSSL_SUCCESS);
2351#endif
2352        ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), WOLFSSL_SUCCESS);
2353        ExpectIntEQ(wolfSSL_dtls_get_current_timeout(ssl_c), 2);
2354        ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
2355
2356        wolfSSL_free(ssl_s);
2357        wolfSSL_free(ssl_c);
2358        wolfSSL_CTX_free(ctx_s);
2359        wolfSSL_CTX_free(ctx_c);
2360    }
2361#endif
2362    return EXPECT_RESULT();
2363}
2364
2365int test_dtls_certreq_order(void)
2366{
2367    EXPECT_DECLS;
2368#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS) && \
2369    !defined(WOLFSSL_NO_TLS12) && defined(HAVE_AESGCM) && \
2370    defined(WOLFSSL_AES_128) && !defined(NO_SHA256) && !defined(NO_RSA) && \
2371    !defined(NO_DH)
2372    /* This test checks that a certificate request message
2373     * received before server certificate message is properly detected.
2374     * The binary is taken from https://github.com/wolfSSL/wolfssl/issues/9198
2375     */
2376    static const unsigned char certreq_before_cert_bin[] = {
2377      0x16, 0xfe, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2378      0x39, 0x02, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2379      0x2d, 0xfe, 0xfd, 0x48, 0xc0, 0xd5, 0xf2, 0x60, 0xb4, 0x20, 0xbb, 0x38,
2380      0x51, 0xd9, 0xd4, 0x7a, 0xcb, 0x93, 0x3d, 0xbe, 0x70, 0x39, 0x9b, 0xf6,
2381      0xc9, 0x2d, 0xa3, 0x3a, 0xf0, 0x1d, 0x4f, 0xb7, 0x70, 0xe9, 0x8c, 0x00,
2382      0x00, 0x9e, 0x00, 0x00, 0x05, 0x00, 0x0f, 0x00, 0x01, 0x01, 0x16, 0xfe,
2383      0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x3a, 0x0d,
2384      0x00, 0x00, 0x2e, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x01,
2385      0x01, 0x00, 0x28, 0x02, 0x02, 0x03, 0x02, 0x04, 0x02, 0x05, 0x02, 0x06,
2386      0x02, 0x01, 0x01, 0x02, 0x01, 0x03, 0x01, 0x04, 0x01, 0x05, 0x01, 0x06,
2387      0x01, 0x02, 0x03, 0x03, 0x03, 0x04, 0x03, 0x05, 0x03, 0x06, 0x03, 0x08,
2388      0x04, 0x08, 0x05, 0x08, 0x06, 0x07, 0x08, 0x00, 0x00, 0x16, 0xfe, 0xfd,
2389      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x2b, 0x0b, 0x00,
2390      0x03, 0x1f, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x03, 0x1f, 0x00, 0x03,
2391      0x1c, 0x00, 0x03, 0x19, 0x30, 0x82, 0x03, 0x15, 0x30, 0x82, 0x01, 0xfd,
2392      0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x14, 0x40, 0xe7, 0x6e, 0x85, 0x66,
2393      0x7c, 0x3f, 0x04, 0x87, 0x4c, 0x3f, 0x94, 0x21, 0x6d, 0x21, 0x65, 0xa5,
2394      0x28, 0xa7, 0x38, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
2395      0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x1a, 0x31, 0x18, 0x30, 0x16,
2396      0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0f, 0x64, 0x74, 0x6c, 0x73, 0x2d,
2397      0x66, 0x75, 0x7a, 0x7a, 0x65, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x1e,
2398      0x17, 0x0d, 0x32, 0x34, 0x30, 0x36, 0x30, 0x36, 0x31, 0x32, 0x31, 0x33,
2399      0x30, 0x33, 0x5a, 0x17, 0x0d, 0x33, 0x38, 0x30, 0x32, 0x31, 0x33, 0x31,
2400      0x32, 0x31, 0x33, 0x30, 0x33, 0x5a, 0x30, 0x1a, 0x31, 0x18, 0x30, 0x16,
2401      0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0f, 0x64, 0x74, 0x6c, 0x73, 0x2d,
2402      0x66, 0x75, 0x7a, 0x7a, 0x65, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x82,
2403      0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
2404      0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82,
2405      0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xbb, 0x2a, 0x06, 0xfa, 0xaf,
2406      0x9c, 0xb7, 0xeb, 0x33, 0xce, 0xde, 0xf6, 0xb6, 0x0a, 0x93, 0xb3, 0x97,
2407      0x7a, 0x36, 0x55, 0x89, 0xc2, 0xf5, 0x45, 0x84, 0x6d, 0x45, 0x25, 0x5c,
2408      0x4f, 0xa8, 0x8a, 0x41, 0x29, 0x5b, 0x71, 0x98, 0x6c, 0x63, 0xe7, 0xcf,
2409      0x7f, 0xb4, 0x9d, 0x06, 0x76, 0x60, 0x8c, 0x6a, 0x26, 0x47, 0x65, 0x5d,
2410      0x74, 0x7a, 0xb5, 0x40, 0x33, 0x61, 0xe0, 0x28, 0xed, 0xa6, 0x66, 0x6a,
2411      0x4b, 0x97, 0xaf, 0xae, 0x6c, 0xa1, 0xf2, 0xfc, 0xd0, 0xf1, 0x61, 0x98,
2412      0x05, 0x2a, 0x02, 0x42, 0x13, 0x06, 0x7c, 0x4a, 0x7e, 0x53, 0x01, 0x87,
2413      0x27, 0x6c, 0x41, 0xe8, 0xed, 0x6e, 0xb2, 0x45, 0x90, 0xe8, 0x93, 0xc0,
2414      0x20, 0xff, 0x64, 0xdf, 0x48, 0x57, 0xb9, 0x62, 0x8c, 0x14, 0x88, 0xc9,
2415      0x4a, 0x56, 0x3f, 0x5d, 0x9f, 0xeb, 0x1d, 0x79, 0x75, 0xfd, 0x24, 0xad,
2416      0xb6, 0x65, 0x1d, 0x53, 0x81, 0x5c, 0x67, 0xbe, 0x3a, 0x9d, 0xcd, 0xe1,
2417      0x47, 0xab, 0x8d, 0xd4, 0xa5, 0xbd, 0xa6, 0xd7, 0x60, 0xf9, 0x5c, 0x32,
2418      0x51, 0x65, 0x7e, 0x8b, 0xd6, 0xa1, 0x5b, 0xa2, 0xf5, 0x60, 0xaf, 0x29,
2419      0xff, 0x9f, 0x3a, 0xa4, 0xd0, 0x5d, 0x6e, 0x96, 0x09, 0xe8, 0xcf, 0xc3,
2420      0xe1, 0xe8, 0x5a, 0x82, 0xce, 0x9a, 0x3c, 0xc6, 0xbb, 0xe5, 0x4c, 0xa8,
2421      0xa4, 0xb0, 0xfd, 0x86, 0x06, 0x8b, 0x3f, 0x7e, 0x38, 0xe4, 0x06, 0xdf,
2422      0xf7, 0x9c, 0xc6, 0x8b, 0x1d, 0xb5, 0xad, 0x7a, 0x91, 0x5f, 0x64, 0xa5,
2423      0x69, 0xc8, 0x7b, 0x77, 0x32, 0x71, 0x8f, 0x73, 0x82, 0xd2, 0x21, 0xe8,
2424      0xa8, 0x81, 0xfe, 0x76, 0x7f, 0x20, 0xd1, 0xb6, 0x42, 0x9e, 0xaf, 0x60,
2425      0x85, 0x47, 0xf5, 0xfe, 0x9f, 0x85, 0xbf, 0xb0, 0x11, 0xb7, 0xf7, 0x83,
2426      0x0d, 0x80, 0x63, 0xa0, 0xf7, 0x0c, 0x2c, 0x83, 0x12, 0xa9, 0x0f, 0x02,
2427      0x03, 0x01, 0x00, 0x01, 0xa3, 0x53, 0x30, 0x51, 0x30, 0x1d, 0x06, 0x03,
2428      0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x2a, 0xb5, 0x00, 0x45, 0x06,
2429      0x08, 0xef, 0xe5, 0xfa, 0x78, 0x19, 0x47, 0x5b, 0x04, 0x40, 0x18, 0xf3,
2430      0xeb, 0xab, 0x99, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18,
2431      0x30, 0x16, 0x80, 0x14, 0x2a, 0xb5, 0x00, 0x45, 0x06, 0x08, 0xef, 0xe5,
2432      0xfa, 0x78, 0x19, 0x47, 0x5b, 0x04, 0x40, 0x18, 0xf3, 0xeb, 0xab, 0x99,
2433      0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05,
2434      0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48,
2435      0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01,
2436      0x00, 0xa7, 0x58, 0x65, 0xfc, 0x60, 0x3e, 0xb7, 0x34, 0x82, 0xde, 0x04,
2437      0x06, 0x3d, 0x69, 0x62, 0x8a, 0x4c, 0xcc, 0xd6, 0x54, 0x72, 0x81, 0xcb,
2438      0x31, 0xdf, 0x63, 0xaf, 0x84, 0x27, 0x62, 0xbf, 0xe8, 0x6b, 0xf9, 0x81,
2439      0xd4, 0x5a, 0x98, 0x88, 0xae, 0x05, 0x5b, 0x2c, 0xa3, 0xf8, 0xb0, 0xde,
2440      0x9b, 0x44, 0xc7, 0x1d, 0x19, 0x52, 0x02, 0x02, 0xd9, 0x0e, 0x66, 0x7b,
2441      0x25, 0xdf, 0x95, 0x03, 0x5e, 0x4b, 0x15, 0xef, 0xda, 0x86, 0x2e, 0x8b,
2442      0xc4, 0xe7, 0x2d, 0x3f, 0x5f, 0xea, 0x1f, 0x13, 0x81, 0x2e, 0x6e, 0xf8,
2443      0x7f, 0x0b, 0x3b, 0x95, 0x4f, 0xb6, 0xb3, 0x91, 0xcf, 0x89, 0x52, 0xdb,
2444      0xb7, 0xb1, 0x5d, 0x79, 0xdf, 0x3a, 0xf3, 0xe2, 0x46, 0xc4, 0x04, 0xf3,
2445      0xf4, 0xf1, 0xc3, 0xf3, 0xa4, 0x98, 0x47, 0xae, 0x46, 0x99, 0x43, 0x4b,
2446      0x20, 0xba, 0x33, 0xaa, 0x7e, 0x2e, 0x80, 0x88, 0x25, 0x84, 0x73, 0x6d,
2447      0x44, 0x5f, 0x48, 0x57, 0x0a, 0xc4, 0x4a, 0x4d, 0xc4, 0xd1, 0x47, 0x5f,
2448      0x4f, 0xd5, 0xdb, 0x3e, 0x90, 0xbd, 0xe1, 0x6a, 0xcb, 0xe4, 0xf3, 0xe6,
2449      0x64, 0x26, 0xbd, 0xb6, 0x0b, 0x95, 0x6f, 0x4e, 0x1b, 0x09, 0x25, 0x68,
2450      0x93, 0xb6, 0xd0, 0xc2, 0xfc, 0xce, 0x8f, 0x64, 0xf5, 0x75, 0x50, 0x58,
2451      0xe5, 0x3e, 0x00, 0x01, 0xfd, 0x62, 0x37, 0xe1, 0x37, 0x1e, 0x9f, 0x97,
2452      0x88, 0xb1, 0xa9, 0x6f, 0xad, 0x93, 0x41, 0x01, 0xfb, 0x38, 0x24, 0xc8,
2453      0x08, 0xa0, 0x68, 0x4b, 0x34, 0x8b, 0x76, 0xea, 0x01, 0x62, 0x9d, 0xfa,
2454      0xdc, 0x91, 0x50, 0x47, 0x98, 0xec, 0x0c, 0x44, 0x58, 0xb6, 0x16, 0xa0,
2455      0x05, 0xf2, 0x94, 0x34, 0x6d, 0xcb, 0xbc, 0xe4, 0x58, 0xd6, 0x97, 0x9d,
2456      0x57, 0xa5, 0x5a, 0x65, 0xfa, 0xab, 0x94, 0x24, 0xbf, 0x06, 0x64, 0xc0,
2457      0xe5, 0x89, 0xe4, 0x2e, 0x46, 0x16, 0xfe, 0xfd, 0x00, 0x00, 0x00, 0x00,
2458      0x00, 0x00, 0x00, 0x03, 0x03, 0x17, 0x0c, 0x00, 0x03, 0x0b, 0x00, 0x03,
2459      0x00, 0x00, 0x00, 0x00, 0x03, 0x0b, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff,
2460      0xff, 0xff, 0xff, 0xff, 0xad, 0xf8, 0x54, 0x58, 0xa2, 0xbb, 0x4a, 0x9a,
2461      0xaf, 0xdc, 0x56, 0x20, 0x27, 0x3d, 0x3c, 0xf1, 0xd8, 0xb9, 0xc5, 0x83,
2462      0xce, 0x2d, 0x36, 0x95, 0xa9, 0xe1, 0x36, 0x41, 0x14, 0x64, 0x33, 0xfb,
2463      0xcc, 0x93, 0x9d, 0xce, 0x24, 0x9b, 0x3e, 0xf9, 0x7d, 0x2f, 0xe3, 0x63,
2464      0x63, 0x0c, 0x75, 0xd8, 0xf6, 0x81, 0xb2, 0x02, 0xae, 0xc4, 0x61, 0x7a,
2465      0xd3, 0xdf, 0x1e, 0xd5, 0xd5, 0xfd, 0x65, 0x61, 0x24, 0x33, 0xf5, 0x1f,
2466      0x5f, 0x06, 0x6e, 0xd0, 0x85, 0x63, 0x65, 0x55, 0x3d, 0xed, 0x1a, 0xf3,
2467      0xb5, 0x57, 0x13, 0x5e, 0x7f, 0x57, 0xc9, 0x35, 0x98, 0x4f, 0x0c, 0x70,
2468      0xe0, 0xe6, 0x8b, 0x77, 0xe2, 0xa6, 0x89, 0xda, 0xf3, 0xef, 0xe8, 0x72,
2469      0x1d, 0xf1, 0x58, 0xa1, 0x36, 0xad, 0xe7, 0x35, 0x30, 0xac, 0xca, 0x4f,
2470      0x48, 0x3a, 0x79, 0x7a, 0xbc, 0x0a, 0xb1, 0x82, 0xb3, 0x24, 0xfb, 0x61,
2471      0xd1, 0x08, 0xa9, 0x4b, 0xb2, 0xc8, 0xe3, 0xfb, 0xb9, 0x6a, 0xda, 0xb7,
2472      0x60, 0xd7, 0xf4, 0x68, 0x1d, 0x4f, 0x42, 0xa3, 0xde, 0x39, 0x4d, 0xf4,
2473      0xae, 0x56, 0xed, 0xe7, 0x63, 0x72, 0xbb, 0x19, 0x0b, 0x07, 0xa7, 0xc8,
2474      0xee, 0x0a, 0x6d, 0x70, 0x9e, 0x02, 0xfc, 0xe1, 0xcd, 0xf7, 0xe2, 0xec,
2475      0xc0, 0x34, 0x04, 0xcd, 0x28, 0x34, 0x2f, 0x61, 0x91, 0x72, 0xfe, 0x9c,
2476      0xe9, 0x85, 0x83, 0xff, 0x8e, 0x4f, 0x12, 0x32, 0xee, 0xf2, 0x81, 0x83,
2477      0xc3, 0xfe, 0x3b, 0x1b, 0x4c, 0x6f, 0xad, 0x73, 0x3b, 0xb5, 0xfc, 0xbc,
2478      0x2e, 0xc2, 0x20, 0x05, 0xc5, 0x8e, 0xf1, 0x83, 0x7d, 0x16, 0x83, 0xb2,
2479      0xc6, 0xf3, 0x4a, 0x26, 0xc1, 0xb2, 0xef, 0xfa, 0x88, 0x6b, 0x42, 0x38,
2480      0x61, 0x28, 0x5c, 0x97, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
2481      0x00, 0x01, 0x02, 0x01, 0x00, 0xea, 0x10, 0x0e, 0xb8, 0xc4, 0xc9, 0xc9,
2482      0x9a, 0x8c, 0x03, 0x04, 0x56, 0x4f, 0x3d, 0x2d, 0x64, 0x51, 0xc9, 0x1e,
2483      0xf7, 0x63, 0x06, 0x81, 0xca, 0x89, 0x5c, 0x81, 0xb9, 0x78, 0xe0, 0xf5,
2484      0x43, 0xe4, 0x47, 0x40, 0x8f, 0x0e, 0xab, 0x0e, 0xd0, 0xb4, 0x43, 0x92,
2485      0x2a, 0x03, 0x4a, 0x1f, 0x69, 0x7b, 0xc3, 0x0c, 0x13, 0x0d, 0xf3, 0xd8,
2486      0xaa, 0xd7, 0x1e, 0x0e, 0xf5, 0x09, 0x7d, 0xda, 0xc9, 0x7c, 0x16, 0xfd,
2487      0xe6, 0xbb, 0x2d, 0xc1, 0x12, 0x20, 0xad, 0x8f, 0x1b, 0x64, 0x79, 0xb9,
2488      0xbc, 0x26, 0x11, 0xec, 0x3d, 0x20, 0xa6, 0x18, 0x6c, 0xb3, 0x27, 0xbe,
2489      0x86, 0xde, 0x0e, 0x49, 0x8f, 0xc2, 0x0e, 0x86, 0x8b, 0x2a, 0xc7, 0x4c,
2490      0xb5, 0x09, 0xed, 0x94, 0x6d, 0xb6, 0x50, 0xfb, 0xc1, 0x8e, 0xd7, 0xce,
2491      0x58, 0xf8, 0xb0, 0x68, 0xbc, 0xcf, 0x28, 0xc5, 0x1c, 0xf3, 0x99, 0x17,
2492      0x22, 0xaa, 0x40, 0x28, 0x90, 0x78, 0x34, 0xe2, 0x0f, 0x28, 0x0d, 0x22,
2493      0xe1, 0x55, 0xcd, 0x90, 0x26, 0x84, 0xa0, 0xd8, 0xea, 0xd9, 0xe8, 0x83,
2494      0x43, 0x24, 0xef, 0x66, 0xa6, 0x7f, 0x9f, 0x56, 0x10, 0x6f, 0xc9, 0x13,
2495      0x2f, 0xb1, 0x00, 0x49, 0xc7, 0x88, 0x8d, 0xec, 0x55, 0xc1, 0xdb, 0x39,
2496      0xa2, 0x5e, 0xbd, 0xde, 0xb6, 0x0a, 0x1c, 0x1f, 0xa4, 0x1a, 0x93, 0xc2,
2497      0xee, 0x9c, 0x63, 0x3b, 0x09, 0xcf, 0xf6, 0x93, 0x83, 0xfe, 0xd7, 0x4d,
2498      0x35, 0xd3, 0x15, 0x74, 0x23, 0x5a, 0x33, 0xdc, 0x64, 0x9d, 0xba, 0x2a,
2499      0xb0, 0x63, 0x26, 0x17, 0x44, 0xe2, 0xfa, 0x41, 0xb1, 0xb2, 0xf2, 0x63,
2500      0xb2, 0x51, 0x50, 0xfc, 0x31, 0xc2, 0xd6, 0xda, 0x01, 0x18, 0xcf, 0xe8,
2501      0x9b, 0xed, 0x4c, 0x69, 0x38, 0xe1, 0xe2, 0x69, 0x53, 0xdc, 0x85, 0x40,
2502      0x4e, 0x9a, 0x1d, 0xe8, 0x2a, 0xe1, 0x27, 0xad, 0x8e, 0x03, 0x01, 0x01,
2503      0x00, 0xad, 0x55, 0xc0, 0xac, 0xbb, 0x32, 0x93, 0x86, 0xc6, 0xdf, 0x5d,
2504      0x58, 0x94, 0xba, 0x35, 0x81, 0x32, 0x54, 0x98, 0xdc, 0x85, 0x6f, 0x1e,
2505      0x41, 0xe4, 0x3d, 0x1e, 0x0d, 0x37, 0x85, 0x05, 0xd1, 0xf7, 0xb2, 0x3a,
2506      0xd5, 0xb1, 0x8c, 0x93, 0x20, 0x8a, 0x42, 0xf0, 0xc9, 0x86, 0xcc, 0xf4,
2507      0xa1, 0x17, 0x8d, 0x65, 0xd0, 0xea, 0x23, 0x9f, 0xf7, 0xcf, 0x3e, 0x7b,
2508      0x51, 0x55, 0xfe, 0x3d, 0x6c, 0x9e, 0x3e, 0x51, 0x39, 0xd8, 0xa0, 0xa0,
2509      0x8a, 0x6b, 0xd8, 0x4d, 0x41, 0x7f, 0x97, 0x5c, 0x8e, 0x25, 0x7b, 0x24,
2510      0x72, 0x1a, 0x46, 0xac, 0x8f, 0x8e, 0xd7, 0xe8, 0xa6, 0x31, 0x1e, 0x7c,
2511      0xd0, 0xa9, 0x31, 0x84, 0xa6, 0x60, 0x73, 0xb3, 0xb9, 0x26, 0xa3, 0x4e,
2512      0xd5, 0x03, 0x3f, 0xef, 0xaa, 0x5a, 0x41, 0x8d, 0x1f, 0x0b, 0xb6, 0x37,
2513      0x63, 0x9b, 0xa1, 0xfe, 0x43, 0x5b, 0x73, 0xa2, 0x5b, 0xce, 0x53, 0x61,
2514      0x05, 0x1f, 0x75, 0x35, 0xf1, 0x71, 0x5b, 0xf6, 0x60, 0x1e, 0xcc, 0x62,
2515      0xae, 0xca, 0xe3, 0x4f, 0xc0, 0xc0, 0xfd, 0xe1, 0x42, 0xc3, 0xbc, 0x29,
2516      0x84, 0x74, 0x30, 0x0a, 0x22, 0x69, 0x10, 0x3d, 0xb6, 0x7c, 0x54, 0xc7,
2517      0x54, 0xe2, 0xaf, 0x3a, 0xee, 0xa3, 0x05, 0xd4, 0x89, 0xa2, 0xc3, 0xa1,
2518      0x51, 0x45, 0x25, 0x8e, 0xc5, 0x5a, 0xc8, 0x75, 0x50, 0xd9, 0x98, 0x67,
2519      0x3c, 0xd2, 0xfa, 0x96, 0x6a, 0xaa, 0x1b, 0x0a, 0x29, 0x15, 0xfe, 0xd0,
2520      0xbb, 0x1a, 0xf5, 0xa4, 0xcd, 0xbe, 0xce, 0xa2, 0x3e, 0x0c, 0x03, 0x9c,
2521      0xab, 0x3a, 0x34, 0xe2, 0x0e, 0x0e, 0xa0, 0xb3, 0x9a, 0x2a, 0x3f, 0xa2,
2522      0x1e, 0xd3, 0x33, 0x38, 0x42, 0x6e, 0x65, 0xf8, 0xda, 0xfa, 0x90, 0x73,
2523      0xa5, 0x66, 0x84, 0xe0, 0xfe, 0x99, 0xe9, 0xc1, 0x94, 0x24, 0x04, 0x7f,
2524      0x05, 0xda, 0xc7, 0xcd, 0xce, 0x16, 0xfe, 0xfd, 0x00, 0x00, 0x00, 0x00,
2525      0x00, 0x00, 0x00, 0x04, 0x00, 0x0c, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x04,
2526      0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2527    };
2528    WOLFSSL_CTX *ctx_c = NULL;
2529    WOLFSSL *ssl_c = NULL;
2530    struct test_memio_ctx test_ctx;
2531
2532    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
2533
2534    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, NULL, &ssl_c, NULL,
2535            wolfDTLSv1_2_client_method, NULL), 0);
2536
2537    /* start handshake, send first ClientHello */
2538    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
2539    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
2540    ExpectIntEQ(test_memio_inject_message(&test_ctx, 1,
2541            (const char*)certreq_before_cert_bin,
2542            sizeof(certreq_before_cert_bin)), 0);
2543    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
2544    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), OUT_OF_ORDER_E);
2545
2546    wolfSSL_free(ssl_c);
2547    wolfSSL_CTX_free(ctx_c);
2548#endif
2549    return EXPECT_RESULT();
2550}
2551
2552#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS)
2553struct {
2554    struct test_memio_ctx* test_ctx;
2555    WOLFSSL* ssl_s;
2556    int fd;
2557    SOCKADDR_S peer_addr;
2558} test_memio_wolfio_ctx;
2559
2560static ssize_t test_memio_wolfio_recvfrom(int sockfd, void* buf,
2561        size_t len, int flags, void* src_addr, void* addrlen)
2562{
2563    int ret;
2564    (void)flags;
2565    if (sockfd != test_memio_wolfio_ctx.fd) {
2566        errno = EINVAL;
2567        return -1;
2568    }
2569    ret = test_memio_read_cb(test_memio_wolfio_ctx.ssl_s,
2570            (char*)buf, (int)len, test_memio_wolfio_ctx.test_ctx);
2571    if (ret <= 0) {
2572        if (ret == WC_NO_ERR_TRACE(WOLFSSL_CBIO_ERR_WANT_READ))
2573            errno = EAGAIN;
2574        else
2575            errno = EINVAL;
2576        return -1;
2577    }
2578    XMEMCPY(src_addr, &test_memio_wolfio_ctx.peer_addr,
2579            MIN(sizeof(test_memio_wolfio_ctx.peer_addr),
2580                *(word32*)addrlen));
2581    *(word32*)addrlen = sizeof(test_memio_wolfio_ctx.peer_addr);
2582    return ret;
2583}
2584
2585static ssize_t test_memio_wolfio_sendto(int sockfd, const void* buf,
2586        size_t len, int flags, const void* dest_addr, word32 addrlen)
2587{
2588    int ret;
2589    (void) flags;
2590    (void) dest_addr;
2591    (void) addrlen;
2592    if (sockfd != test_memio_wolfio_ctx.fd) {
2593        errno = EINVAL;
2594        return -1;
2595    }
2596    if (dest_addr != NULL && addrlen != 0 &&
2597            (sizeof(test_memio_wolfio_ctx.peer_addr) != addrlen ||
2598            XMEMCMP(dest_addr, &test_memio_wolfio_ctx.peer_addr,
2599                    addrlen) != 0)) {
2600        errno = EINVAL;
2601        return -1;
2602    }
2603    ret = test_memio_write_cb(test_memio_wolfio_ctx.ssl_s, (char*)buf,
2604            (int)len, test_memio_wolfio_ctx.test_ctx);
2605    if (ret <= 0) {
2606        if (ret == WC_NO_ERR_TRACE(WOLFSSL_CBIO_ERR_WANT_WRITE))
2607            errno = EAGAIN;
2608        else
2609            errno = EINVAL;
2610        return -1;
2611    }
2612    return ret;
2613}
2614#endif
2615
2616/* Test stateless API with wolfio */
2617int test_dtls_memio_wolfio(void)
2618{
2619    EXPECT_DECLS;
2620#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS)
2621    size_t i;
2622    struct {
2623        method_provider client_meth;
2624        method_provider server_meth;
2625    } params[] = {
2626#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_DTLS13)
2627        { wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method },
2628#endif
2629#if !defined(WOLFSSL_NO_TLS12) && defined(WOLFSSL_DTLS)
2630        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method },
2631#endif
2632#if !defined(NO_OLD_TLS) && defined(WOLFSSL_DTLS)
2633        { wolfDTLSv1_client_method, wolfDTLSv1_server_method },
2634#endif
2635    };
2636    XMEMSET(&test_memio_wolfio_ctx, 0, sizeof(test_memio_wolfio_ctx));
2637    for (i = 0; i < XELEM_CNT(params) && !EXPECT_FAIL(); i++) {
2638        WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
2639        WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
2640        struct test_memio_ctx test_ctx;
2641
2642        XMEMSET(&test_ctx, 0, sizeof(test_ctx));
2643
2644        ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
2645                params[i].client_meth, params[i].server_meth), 0);
2646
2647        test_memio_wolfio_ctx.test_ctx = &test_ctx;
2648        test_memio_wolfio_ctx.ssl_s = ssl_s;
2649        /* Large number to error out if any syscalls are called with it */
2650        test_memio_wolfio_ctx.fd = 6000;
2651        XMEMSET(&test_memio_wolfio_ctx.peer_addr, 0,
2652                sizeof(test_memio_wolfio_ctx.peer_addr));
2653        test_memio_wolfio_ctx.peer_addr.ss_family = AF_INET;
2654
2655        wolfSSL_dtls_set_using_nonblock(ssl_s, 1);
2656        wolfSSL_SetRecvFrom(ssl_s, test_memio_wolfio_recvfrom);
2657        wolfSSL_SetSendTo(ssl_s, test_memio_wolfio_sendto);
2658        /* Restore default functions */
2659        wolfSSL_SSLSetIORecv(ssl_s, EmbedReceiveFrom);
2660        wolfSSL_SSLSetIOSend(ssl_s, EmbedSendTo);
2661        ExpectIntEQ(wolfSSL_set_fd(ssl_s, test_memio_wolfio_ctx.fd),
2662                    WOLFSSL_SUCCESS);
2663
2664        ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
2665
2666        wolfSSL_free(ssl_s);
2667        wolfSSL_free(ssl_c);
2668        wolfSSL_CTX_free(ctx_s);
2669        wolfSSL_CTX_free(ctx_c);
2670    }
2671#endif
2672    return EXPECT_RESULT();
2673}
2674
2675/* DTLS using stateless API handling new addresses with wolfio */
2676int test_dtls_memio_wolfio_stateless(void)
2677{
2678    EXPECT_DECLS;
2679#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS)
2680    size_t i, j;
2681    struct {
2682        method_provider client_meth;
2683        method_provider server_meth;
2684    } params[] = {
2685#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_DTLS13)
2686        { wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method },
2687#endif
2688#if !defined(WOLFSSL_NO_TLS12) && defined(WOLFSSL_DTLS)
2689        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method },
2690#endif
2691#if !defined(NO_OLD_TLS) && defined(WOLFSSL_DTLS)
2692        { wolfDTLSv1_client_method, wolfDTLSv1_server_method },
2693#endif
2694    };
2695    XMEMSET(&test_memio_wolfio_ctx, 0, sizeof(test_memio_wolfio_ctx));
2696    for (i = 0; i < XELEM_CNT(params) && !EXPECT_FAIL(); i++) {
2697        WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
2698        WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
2699        struct test_memio_ctx test_ctx;
2700        char chBuf[1000];
2701        int chSz = sizeof(chBuf);
2702
2703        XMEMSET(&test_ctx, 0, sizeof(test_ctx));
2704
2705        ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
2706                params[i].client_meth, params[i].server_meth), 0);
2707
2708        test_memio_wolfio_ctx.test_ctx = &test_ctx;
2709        test_memio_wolfio_ctx.ssl_s = ssl_s;
2710        /* Large number to error out if any syscalls are called with it */
2711        test_memio_wolfio_ctx.fd = 6000;
2712        XMEMSET(&test_memio_wolfio_ctx.peer_addr, 0,
2713                sizeof(test_memio_wolfio_ctx.peer_addr));
2714        test_memio_wolfio_ctx.peer_addr.ss_family = AF_INET;
2715
2716        wolfSSL_dtls_set_using_nonblock(ssl_s, 1);
2717        wolfSSL_SetRecvFrom(ssl_s, test_memio_wolfio_recvfrom);
2718        /* Restore default functions */
2719        wolfSSL_SSLSetIORecv(ssl_s, EmbedReceiveFrom);
2720        ExpectIntEQ(wolfSSL_set_read_fd(ssl_s, test_memio_wolfio_ctx.fd),
2721                    WOLFSSL_SUCCESS);
2722
2723        /* start handshake, send first ClientHello */
2724        ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
2725        ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
2726        ExpectIntEQ(test_memio_copy_message(&test_ctx, 0, chBuf, &chSz, 0), 0);
2727        ExpectIntGT(chSz, 0);
2728        test_memio_clear_buffer(&test_ctx, 0);
2729
2730        /* Send CH from different addresses */
2731        for (j = 0; j < 10 && !EXPECT_FAIL(); j++,
2732            (((SOCKADDR_IN*)&test_memio_wolfio_ctx.peer_addr))->sin_port++) {
2733            const char* hrrBuf = NULL;
2734            int hrrSz = 0;
2735            ExpectIntEQ(test_memio_inject_message(&test_ctx, 0, chBuf, chSz), 0);
2736            ExpectIntEQ(wolfDTLS_accept_stateless(ssl_s), 0);
2737            ExpectIntEQ(test_memio_get_message(&test_ctx, 1, &hrrBuf, &hrrSz, 0), 0);
2738            ExpectNotNull(hrrBuf);
2739            ExpectIntGT(hrrSz, 0);
2740            test_memio_clear_buffer(&test_ctx, 0);
2741        }
2742        test_memio_clear_buffer(&test_ctx, 1);
2743        ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_c), 1);
2744        ExpectIntEQ(wolfDTLS_accept_stateless(ssl_s), 0);
2745        ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
2746        ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
2747        ExpectIntEQ(wolfDTLS_accept_stateless(ssl_s), 1);
2748
2749        ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
2750
2751        wolfSSL_free(ssl_s);
2752        wolfSSL_free(ssl_c);
2753        wolfSSL_CTX_free(ctx_s);
2754        wolfSSL_CTX_free(ctx_c);
2755    }
2756#endif
2757    return EXPECT_RESULT();
2758}
2759
2760int test_dtls_mtu_split_messages(void)
2761{
2762#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
2763    defined(WOLFSSL_DTLS_MTU) && defined(WOLFSSL_NO_DTLS_SIZE_CHECK) && \
2764    defined(HAVE_AESGCM) && defined(HAVE_ECC)
2765    EXPECT_DECLS;
2766    struct {
2767        method_provider client_meth;
2768        method_provider server_meth;
2769        const char* cipher;
2770    } params[] = {
2771#if defined(WOLFSSL_DTLS13) && defined(WOLFSSL_TLS13)
2772        { wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method,
2773          "TLS13-AES128-GCM-SHA256" },
2774#endif
2775#if defined(WOLFSSL_DTLS) && !defined(WOLFSSL_NO_TLS12)
2776        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method,
2777          "ECDHE-RSA-AES128-GCM-SHA256" },
2778#if !defined(WOLFSSL_AEAD_ONLY) && !defined(NO_AES) && !defined(NO_SHA)
2779        /* Block cipher test */
2780        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method,
2781          "ECDHE-RSA-AES128-SHA" },
2782#endif
2783#endif
2784    };
2785    size_t i;
2786
2787    for (i = 0; i < XELEM_CNT(params) && EXPECT_SUCCESS(); i++) {
2788        WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
2789        WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
2790        struct test_memio_ctx test_ctx;
2791        /* Payload larger than typical MTU to force splitting */
2792        unsigned char payload[200];
2793        unsigned char readBuf[200];
2794        word16 mtu;
2795        int recordLen;
2796        int overhead;
2797        int totalRead;
2798        int ret;
2799        int j;
2800
2801        XMEMSET(&test_ctx, 0, sizeof(test_ctx));
2802        XMEMSET(payload, 'A', sizeof(payload));
2803
2804        ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
2805                        params[i].client_meth, params[i].server_meth),
2806            0);
2807
2808        ExpectIntEQ(wolfSSL_set_cipher_list(ssl_c, params[i].cipher), 1);
2809        ExpectIntEQ(wolfSSL_set_cipher_list(ssl_s, params[i].cipher), 1);
2810
2811        /* Complete handshake and clear any leftover records. */
2812        ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
2813        test_memio_clear_buffer(&test_ctx, 1);
2814        test_memio_clear_buffer(&test_ctx, 0);
2815
2816        /* Measure application-data record overhead with small payload. */
2817        ExpectIntEQ(wolfSSL_write(ssl_c, payload, 32), 32);
2818        ExpectIntEQ(test_ctx.s_msg_count, 1);
2819        recordLen = test_ctx.s_len;
2820        ExpectIntGT(recordLen, 32);
2821        overhead = recordLen - 32;
2822
2823        /* Reset buffers before MTU-limited send. */
2824        test_memio_clear_buffer(&test_ctx, 0);
2825        test_memio_clear_buffer(&test_ctx, 1);
2826
2827        /* Set MTU to allow only ~50 bytes of payload per record.
2828         * This ensures a 200-byte payload must be split into multiple msgs. */
2829        mtu = (word16)(overhead + 50);
2830        ExpectIntEQ(wolfSSL_dtls_set_mtu(ssl_c, mtu), WOLFSSL_SUCCESS);
2831        ExpectIntEQ(wolfSSL_dtls_set_mtu(ssl_s, mtu), WOLFSSL_SUCCESS);
2832
2833        /* Write payload larger than MTU allows in single record.
2834         * With WOLFSSL_NO_DTLS_SIZE_CHECK, this should split into multiple
2835         * messages instead of returning DTLS_SIZE_ERROR. */
2836        ExpectIntEQ(wolfSSL_write(ssl_c, payload, (int)sizeof(payload)),
2837            (int)sizeof(payload));
2838
2839        /* Verify multiple messages were sent */
2840        ExpectIntGT(test_ctx.s_msg_count, 1);
2841
2842        /* Each record should fit within MTU */
2843        for (j = 0; j < test_ctx.s_msg_count && EXPECT_SUCCESS(); j++) {
2844            ExpectIntLE(test_ctx.s_msg_sizes[j], mtu);
2845        }
2846
2847        /* Read all data on server side and verify it matches */
2848        totalRead = 0;
2849        while (totalRead < (int)sizeof(payload) && EXPECT_SUCCESS()) {
2850            ret = wolfSSL_read(ssl_s, readBuf + totalRead,
2851                (int)sizeof(readBuf) - totalRead);
2852            if (ret > 0) {
2853                totalRead += ret;
2854            }
2855            else {
2856                break;
2857            }
2858        }
2859        ExpectIntEQ(totalRead, (int)sizeof(payload));
2860        ExpectIntEQ(XMEMCMP(payload, readBuf, sizeof(payload)), 0);
2861
2862        wolfSSL_free(ssl_c);
2863        wolfSSL_CTX_free(ctx_c);
2864        wolfSSL_free(ssl_s);
2865        wolfSSL_CTX_free(ctx_s);
2866    }
2867    return EXPECT_RESULT();
2868#else
2869    return TEST_SKIPPED;
2870#endif
2871}
2872
2873/* Test DTLS 1.3 minimum retransmission interval. This test calls
2874 * wolfSSL_dtls_got_timeout() to simulate timeouts and verify that
2875 * retransmissions are spaced at least DTLS13_MIN_RTX_INTERVAL apart.
2876 * This tests relies on timing of the retransmission logic so it may be
2877 * flaky on very slow systems.
2878 */
2879int test_dtls13_min_rtx_interval(void)
2880{
2881    EXPECT_DECLS;
2882#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
2883    defined(WOLFSSL_DTLS13) && !defined(DTLS13_MIN_RTX_INTERVAL) && \
2884    !defined(NO_ASN_TIME)
2885    /* We don't want to test when DTLS13_MIN_RTX_INTERVAL is defined because
2886     * it may be too low to trigger reliably in a test. The default value is
2887     * 1 second which is sufficient for testing here. */
2888    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
2889    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
2890    struct test_memio_ctx test_ctx;
2891    int c_msg_count = 0;
2892
2893    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
2894
2895    /* Setup DTLS 1.3 contexts */
2896    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
2897                    wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method), 0);
2898
2899    /* CH0 */
2900    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
2901    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), SSL_ERROR_WANT_READ);
2902
2903    /* HRR */
2904    ExpectIntEQ(wolfSSL_accept(ssl_s), -1);
2905    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), SSL_ERROR_WANT_READ);
2906
2907    /* CH1 */
2908    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
2909    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), SSL_ERROR_WANT_READ);
2910
2911    /* SH ... FINISHED */
2912    ExpectIntEQ(wolfSSL_accept(ssl_s), -1);
2913    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), SSL_ERROR_WANT_READ);
2914
2915    /* We should have SH ... FINISHED messages in the buffer */
2916    ExpectIntGE(test_ctx.c_msg_count, 2);
2917
2918    /* Drop everything */
2919    test_memio_clear_buffer(&test_ctx, 1);
2920
2921    /* First timeout. This one should trigger a retransmission */
2922    if (wolfSSL_dtls13_use_quick_timeout(ssl_s))
2923        ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_s), WOLFSSL_SUCCESS);
2924    ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_s), WOLFSSL_SUCCESS);
2925    /* Save the message count to make sure no new messages are sent */
2926    ExpectIntGE(test_ctx.c_msg_count, 2);
2927    c_msg_count = test_ctx.c_msg_count;
2928
2929    /* Second timeout. This one should not trigger a retransmission */
2930    if (wolfSSL_dtls13_use_quick_timeout(ssl_s))
2931        ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_s), WOLFSSL_SUCCESS);
2932    ExpectIntEQ(wolfSSL_dtls_got_timeout(ssl_s), WOLFSSL_SUCCESS);
2933    /* This is the critical check. The message count should not increase
2934     * after the second timeout. DTLS13_MIN_RTX_INTERVAL should have blocked
2935     * retransmission here. */
2936    ExpectIntEQ(c_msg_count, test_ctx.c_msg_count);
2937
2938    /* Now complete the handshake. We didn't clear the first retransmission
2939     * so the handshake should proceed without issues. */
2940    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
2941
2942    /* Cleanup */
2943    wolfSSL_free(ssl_c);
2944    wolfSSL_CTX_free(ctx_c);
2945    wolfSSL_free(ssl_s);
2946    wolfSSL_CTX_free(ctx_s);
2947#endif
2948    return EXPECT_RESULT();
2949}
2950
2951/* RFC 9147 Section 5.3: DTLS 1.3 ServerHello must have empty
2952 * legacy_session_id_echo, even if the ClientHello had a non-empty
2953 * legacy_session_id. */
2954int test_dtls13_no_session_id_echo(void)
2955{
2956    EXPECT_DECLS;
2957#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS13) && \
2958    defined(HAVE_SESSION_TICKET)
2959    struct test_memio_ctx test_ctx;
2960    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
2961    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
2962    WOLFSSL_SESSION *sess = NULL;
2963    char readBuf[1];
2964    /* Use traditional groups to avoid HRR from PQ key share mismatch */
2965    int groups[] = {
2966        WOLFSSL_ECC_SECP256R1,
2967        WOLFSSL_ECC_SECP384R1,
2968    };
2969
2970    /* First connection: complete a DTLS 1.3 handshake to get a session */
2971    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
2972    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
2973        wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method), 0);
2974    ExpectIntEQ(wolfSSL_set_groups(ssl_c, groups, 2), WOLFSSL_SUCCESS);
2975    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
2976
2977    /* Read to process any NewSessionTicket */
2978    ExpectIntEQ(wolfSSL_read(ssl_c, readBuf, sizeof(readBuf)), -1);
2979    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
2980
2981    ExpectNotNull(sess = wolfSSL_get1_session(ssl_c));
2982
2983    /* Ensure the session has a non-empty session ID so the ClientHello
2984     * will have a populated legacy_session_id field (which is legal per
2985     * RFC 9147). */
2986    if (sess != NULL && sess->sessionIDSz == 0) {
2987        sess->sessionIDSz = ID_LEN;
2988        XMEMSET(sess->sessionID, 0x42, ID_LEN);
2989    }
2990
2991    wolfSSL_free(ssl_c); ssl_c = NULL;
2992    wolfSSL_free(ssl_s); ssl_s = NULL;
2993    wolfSSL_CTX_free(ctx_c); ctx_c = NULL;
2994    wolfSSL_CTX_free(ctx_s); ctx_s = NULL;
2995
2996    /* Second connection: set the session on the client so the ClientHello
2997     * contains a non-empty legacy_session_id. Verify the server does NOT
2998     * echo it in the ServerHello. */
2999    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
3000    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
3001        wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method), 0);
3002    ExpectIntEQ(wolfSSL_set_session(ssl_c, sess), WOLFSSL_SUCCESS);
3003    /* Use traditional groups to avoid HRR from key share mismatch */
3004    ExpectIntEQ(wolfSSL_set_groups(ssl_c, groups, 2), WOLFSSL_SUCCESS);
3005    /* Disable HRR cookie so the server directly sends a ServerHello */
3006    ExpectIntEQ(wolfSSL_disable_hrr_cookie(ssl_s), WOLFSSL_SUCCESS);
3007
3008    /* Client sends ClientHello (with non-empty legacy_session_id) */
3009    ExpectIntEQ(wolfSSL_negotiate(ssl_c), -1);
3010    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
3011
3012    /* Server processes ClientHello and sends ServerHello + flight */
3013    ExpectIntEQ(wolfSSL_negotiate(ssl_s), -1);
3014    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
3015
3016    /* Verify the ServerHello on the wire.
3017     * Layout: DTLS Record Header (13) + DTLS Handshake Header (12) +
3018     *         ProtocolVersion (2) + Random (32) = offset 59 for
3019     *         legacy_session_id_echo length byte. */
3020    ExpectIntGE(test_ctx.c_len, 60);
3021    ExpectIntEQ(test_ctx.c_buff[0], handshake);
3022    ExpectIntEQ(test_ctx.c_buff[DTLS_RECORD_HEADER_SZ], server_hello);
3023    ExpectIntEQ(test_ctx.c_buff[DTLS_RECORD_HEADER_SZ +
3024        DTLS_HANDSHAKE_HEADER_SZ + OPAQUE16_LEN + RAN_LEN], 0);
3025
3026    /* Complete the handshake */
3027    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
3028
3029    wolfSSL_SESSION_free(sess);
3030    wolfSSL_free(ssl_c);
3031    wolfSSL_free(ssl_s);
3032    wolfSSL_CTX_free(ctx_c);
3033    wolfSSL_CTX_free(ctx_s);
3034#endif
3035    return EXPECT_RESULT();
3036}
3037
3038/* Test that a DTLS 1.3 handshake with an oversized certificate chain does
3039 * not crash or cause out-of-bounds access in SendTls13Certificate. */
3040int test_dtls13_oversized_cert_chain(void)
3041{
3042    EXPECT_DECLS;
3043#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_DTLS13) \
3044    && !defined(NO_FILESYSTEM) && !defined(NO_RSA)
3045    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
3046    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
3047    struct test_memio_ctx test_ctx;
3048    XFILE f = XBADFILE;
3049    long sz = 0;
3050    byte *cert = NULL;
3051    byte *chain = NULL;
3052    int copies, off, i;
3053
3054    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
3055
3056    /* Read server cert */
3057    f = XFOPEN(svrCertFile, "rb");
3058    ExpectTrue(f != XBADFILE);
3059    if (EXPECT_SUCCESS()) {
3060        (void)XFSEEK(f, 0, XSEEK_END);
3061        sz = XFTELL(f);
3062        (void)XFSEEK(f, 0, XSEEK_SET);
3063    }
3064    ExpectTrue(sz > 0);
3065    cert = (byte*)XMALLOC((size_t)(sz + 1), NULL, DYNAMIC_TYPE_TMP_BUFFER);
3066    ExpectNotNull(cert);
3067    if (EXPECT_SUCCESS())
3068        ExpectIntEQ((int)XFREAD(cert, 1, (size_t)sz, f), (int)sz);
3069    if (f != XBADFILE)
3070        XFCLOSE(f);
3071
3072    /* Build an oversized chain by duplicating the cert */
3073    copies = EXPECT_SUCCESS() ? (int)(70000 / sz) + 2 : 0;
3074    chain = (byte*)XMALLOC((size_t)(sz * copies + 1), NULL,
3075                            DYNAMIC_TYPE_TMP_BUFFER);
3076    ExpectNotNull(chain);
3077    off = 0;
3078    if (EXPECT_SUCCESS()) {
3079        for (i = 0; i < copies; i++) {
3080            XMEMCPY(chain + off, cert, (size_t)sz);
3081            off += (int)sz;
3082        }
3083    }
3084
3085    /* Server context: load the oversized chain */
3086    ExpectNotNull(ctx_s = wolfSSL_CTX_new(wolfDTLSv1_3_server_method()));
3087    ExpectIntEQ(wolfSSL_CTX_use_certificate_chain_buffer(ctx_s,
3088        chain, (long)off), WOLFSSL_SUCCESS);
3089    ExpectIntEQ(wolfSSL_CTX_use_PrivateKey_file(ctx_s, svrKeyFile,
3090        WOLFSSL_FILETYPE_PEM), WOLFSSL_SUCCESS);
3091    if (EXPECT_SUCCESS()) {
3092        wolfSSL_SetIORecv(ctx_s, test_memio_read_cb);
3093        wolfSSL_SetIOSend(ctx_s, test_memio_write_cb);
3094    }
3095
3096    /* Client context: no verification (chain certs are duplicates) */
3097    ExpectNotNull(ctx_c = wolfSSL_CTX_new(wolfDTLSv1_3_client_method()));
3098    if (EXPECT_SUCCESS()) {
3099        wolfSSL_CTX_set_verify(ctx_c, WOLFSSL_VERIFY_NONE, NULL);
3100        wolfSSL_SetIORecv(ctx_c, test_memio_read_cb);
3101        wolfSSL_SetIOSend(ctx_c, test_memio_write_cb);
3102    }
3103
3104    ExpectNotNull(ssl_s = wolfSSL_new(ctx_s));
3105    if (EXPECT_SUCCESS()) {
3106        wolfSSL_SetIOWriteCtx(ssl_s, &test_ctx);
3107        wolfSSL_SetIOReadCtx(ssl_s, &test_ctx);
3108    }
3109
3110    ExpectNotNull(ssl_c = wolfSSL_new(ctx_c));
3111    if (EXPECT_SUCCESS()) {
3112        wolfSSL_SetIOWriteCtx(ssl_c, &test_ctx);
3113        wolfSSL_SetIOReadCtx(ssl_c, &test_ctx);
3114    }
3115
3116    /* Handshake must not crash. If SendTls13Certificate mishandles the
3117     * oversized chain this will trigger a wild pointer dereference or stack
3118     * overflow resulting with the test failing.
3119     * The correct behaviour either returns BUFFER_E or succeeds
3120     * if the build config truncated the chain during loading. */
3121    (void)test_memio_do_handshake(ssl_c, ssl_s, 10, NULL);
3122
3123    wolfSSL_free(ssl_c);
3124    wolfSSL_free(ssl_s);
3125    wolfSSL_CTX_free(ctx_c);
3126    wolfSSL_CTX_free(ctx_s);
3127    XFREE(cert, NULL, DYNAMIC_TYPE_TMP_BUFFER);
3128    XFREE(chain, NULL, DYNAMIC_TYPE_TMP_BUFFER);
3129#endif
3130    return EXPECT_RESULT();
3131}