luna - wolfssl/tests/api/test

   1/* test_tls.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 <tests/utils.h>
  32#include <tests/api/test_tls.h>
  33#include <wolfssl/internal.h>
  34
  35
  36int test_utils_memio_move_message(void)
  37{
  38    EXPECT_DECLS;
  39#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES)
  40    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
  41    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
  42    struct test_memio_ctx test_ctx;
  43
  44    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
  45
  46    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
  47            wolfTLS_client_method, wolfTLS_server_method), 0);
  48    wolfSSL_set_verify(ssl_s, WOLFSSL_VERIFY_PEER, NULL);
  49    ExpectIntEQ(wolfSSL_clear_group_messages(ssl_s), 1);
  50    /* start handshake, send first ClientHello */
  51    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
  52    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
  53    /* send server's flight */
  54    ExpectIntEQ(wolfSSL_accept(ssl_s), -1);
  55    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
  56    /* Move messages around but they should be the same at the end */
  57    ExpectIntEQ(test_memio_move_message(&test_ctx, 1, 1, 2), 0);
  58    ExpectIntEQ(test_memio_move_message(&test_ctx, 1, 2, 1), 0);
  59    ExpectIntEQ(test_memio_move_message(&test_ctx, 1, 1, 3), 0);
  60    ExpectIntEQ(test_memio_move_message(&test_ctx, 1, 3, 1), 0);
  61    ExpectIntEQ(test_memio_move_message(&test_ctx, 1, 0, 2), 0);
  62    ExpectIntEQ(test_memio_move_message(&test_ctx, 1, 2, 0), 0);
  63    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
  64
  65    wolfSSL_free(ssl_c);
  66    wolfSSL_free(ssl_s);
  67    wolfSSL_CTX_free(ctx_c);
  68    wolfSSL_CTX_free(ctx_s);
  69#endif
  70    return EXPECT_RESULT();
  71}
  72
  73int test_tls12_unexpected_ccs(void)
  74{
  75    EXPECT_DECLS;
  76#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && !defined(WOLFSSL_NO_TLS12)
  77    const byte ccs[] = {
  78        0x14, /* ccs type */
  79        0x03, 0x03, /* version */
  80        0x00, 0x01, /* length */
  81        0x01, /* ccs value */
  82    };
  83    const byte badccs[] = {
  84        0x14, /* ccs type */
  85        0x03, 0x03, /* version */
  86        0x00, 0x01, /* length */
  87        0x99, /* wrong ccs value */
  88    };
  89    WOLFSSL_CTX *ctx_s = NULL;
  90    WOLFSSL *ssl_s = NULL;
  91    struct test_memio_ctx test_ctx;
  92
  93    /* ccs in the wrong place */
  94    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
  95    /* inject SH */
  96    ExpectIntEQ(test_memio_inject_message(&test_ctx, 0,
  97            (const char*)ccs, sizeof(ccs)), 0);
  98    ExpectIntEQ(test_memio_setup(&test_ctx, NULL, &ctx_s, NULL, &ssl_s,
  99                    NULL, wolfTLSv1_2_server_method), 0);
 100    ExpectIntEQ(wolfSSL_accept(ssl_s), WOLFSSL_FATAL_ERROR);
 101    ExpectIntEQ(wolfSSL_get_error(ssl_s, WOLFSSL_FATAL_ERROR),
 102            OUT_OF_ORDER_E);
 103    wolfSSL_free(ssl_s);
 104    wolfSSL_CTX_free(ctx_s);
 105    ctx_s = NULL;
 106    ssl_s = NULL;
 107
 108    /* malformed ccs */
 109    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 110    ExpectIntEQ(test_memio_inject_message(&test_ctx, 0,
 111            (const char*)badccs, sizeof(badccs)), 0);
 112    ExpectIntEQ(test_memio_setup(&test_ctx, NULL, &ctx_s, NULL, &ssl_s,
 113                    NULL, wolfTLSv1_2_server_method), 0);
 114    ExpectIntEQ(wolfSSL_accept(ssl_s), WOLFSSL_FATAL_ERROR);
 115    ExpectIntEQ(wolfSSL_get_error(ssl_s, WOLFSSL_FATAL_ERROR),
 116            LENGTH_ERROR);
 117    wolfSSL_free(ssl_s);
 118    wolfSSL_CTX_free(ctx_s);
 119#endif
 120    return EXPECT_RESULT();
 121}
 122
 123int test_tls13_unexpected_ccs(void)
 124{
 125    EXPECT_DECLS;
 126#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(WOLFSSL_TLS13)
 127    const byte ccs[] = {
 128        0x14, /* ccs type */
 129        0x03, 0x03, /* version */
 130        0x00, 0x01, /* length */
 131        0x01, /* ccs value */
 132    };
 133    const byte badccs[] = {
 134        0x14, /* ccs type */
 135        0x03, 0x03, /* version */
 136        0x00, 0x01, /* length */
 137        0x99, /* wrong ccs value */
 138    };
 139    const byte unexpectedAlert[] = {
 140        0x15, /* alert type */
 141        0x03, 0x03, /* version */
 142        0x00, 0x02, /* length */
 143        0x02, /* level: fatal */
 144        0x0a /* protocol version */
 145    };
 146    WOLFSSL_CTX *ctx_s = NULL;
 147    WOLFSSL *ssl_s = NULL;
 148    struct test_memio_ctx test_ctx;
 149
 150    /* ccs can't appear before a CH */
 151    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 152    ExpectIntEQ(test_memio_inject_message(&test_ctx, 0,
 153            (const char*)ccs, sizeof(ccs)), 0);
 154    ExpectIntEQ(test_memio_setup(&test_ctx, NULL, &ctx_s, NULL, &ssl_s,
 155                    NULL, wolfTLSv1_3_server_method), 0);
 156    ExpectIntEQ(wolfSSL_accept(ssl_s), WOLFSSL_FATAL_ERROR);
 157    ExpectIntEQ(wolfSSL_get_error(ssl_s, WOLFSSL_FATAL_ERROR),
 158            UNKNOWN_RECORD_TYPE);
 159    ExpectIntEQ(test_ctx.c_len, sizeof(unexpectedAlert));
 160    ExpectBufEQ(test_ctx.c_buff, unexpectedAlert, sizeof(unexpectedAlert));
 161    wolfSSL_free(ssl_s);
 162    wolfSSL_CTX_free(ctx_s);
 163    ctx_s = NULL;
 164    ssl_s = NULL;
 165
 166    /* malformed ccs */
 167    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 168    ExpectIntEQ(test_memio_inject_message(&test_ctx, 0,
 169            (const char*)badccs, sizeof(badccs)), 0);
 170    ExpectIntEQ(test_memio_setup(&test_ctx, NULL, &ctx_s, NULL, &ssl_s,
 171                    NULL, wolfTLSv1_3_server_method), 0);
 172    ExpectIntEQ(wolfSSL_accept(ssl_s), WOLFSSL_FATAL_ERROR);
 173    ExpectIntEQ(wolfSSL_get_error(ssl_s, WOLFSSL_FATAL_ERROR),
 174            UNKNOWN_RECORD_TYPE);
 175    ExpectIntEQ(test_ctx.c_len, sizeof(unexpectedAlert));
 176    ExpectBufEQ(test_ctx.c_buff, unexpectedAlert, sizeof(unexpectedAlert));
 177    wolfSSL_free(ssl_s);
 178    wolfSSL_CTX_free(ctx_s);
 179#endif
 180    return EXPECT_RESULT();
 181}
 182int test_tls12_curve_intersection(void) {
 183    EXPECT_DECLS;
 184#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
 185    !defined(WOLFSSL_NO_TLS12) && defined(HAVE_ECC) && \
 186    defined(HAVE_CURVE25519)
 187    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
 188    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
 189    struct test_memio_ctx test_ctx;
 190    int ret;
 191    const char* curve_name;
 192    int test1[] = {WOLFSSL_ECC_SECP256R1};
 193    int test2[] = {WOLFSSL_ECC_SECP384R1};
 194    int test3[] = {WOLFSSL_ECC_SECP256R1, WOLFSSL_ECC_SECP384R1};
 195    int test4[] = {WOLFSSL_ECC_SECP384R1, WOLFSSL_ECC_SECP256R1};
 196    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 197    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 198                    wolfTLSv1_2_client_method, wolfTLSv1_2_server_method), 0);
 199    ExpectIntEQ(wolfSSL_set_groups(ssl_c,
 200                    test1, 1), WOLFSSL_SUCCESS);
 201    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 202
 203    /* Fix: Get curve name and compare with string comparison or use curve
 204     * ID function */
 205    curve_name = wolfSSL_get_curve_name(ssl_s);
 206    /* or use appropriate string comparison */
 207    ExpectStrEQ(curve_name, "SECP256R1");
 208    curve_name = wolfSSL_get_curve_name(ssl_c);
 209    ExpectStrEQ(curve_name, "SECP256R1");
 210
 211    wolfSSL_free(ssl_c);
 212    wolfSSL_free(ssl_s);
 213    wolfSSL_CTX_free(ctx_c);
 214    wolfSSL_CTX_free(ctx_s);
 215    ssl_c = NULL;
 216    ssl_s = NULL;
 217    ctx_c = NULL;
 218    ctx_s = NULL;
 219
 220    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 221    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 222                    wolfTLSv1_2_client_method, wolfTLSv1_2_server_method), 0);
 223    ExpectIntEQ(wolfSSL_set_groups(ssl_c,
 224                   test2, 1), WOLFSSL_SUCCESS);
 225    ExpectIntEQ(wolfSSL_set_groups(ssl_s,
 226                    test1, 1), WOLFSSL_SUCCESS);
 227    ExpectIntNE(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 228    ret = wolfSSL_get_error(ssl_s, WOLFSSL_FATAL_ERROR);
 229
 230    /* Fix: Use proper constant or define HANDSHAKE_FAILURE */
 231    ExpectTrue(ret == WC_NO_ERR_TRACE(ECC_CURVE_ERROR));
 232
 233    wolfSSL_free(ssl_c);
 234    wolfSSL_free(ssl_s);
 235    wolfSSL_CTX_free(ctx_c);
 236    wolfSSL_CTX_free(ctx_s);
 237    ssl_c = NULL;
 238    ssl_s = NULL;
 239    ctx_c = NULL;
 240    ctx_s = NULL;
 241
 242    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 243    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 244                    wolfTLSv1_2_client_method, wolfTLSv1_2_server_method), 0);
 245    ExpectIntEQ(wolfSSL_set_groups(ssl_c,
 246                    test3, 2),
 247                    WOLFSSL_SUCCESS);
 248    ExpectIntEQ(wolfSSL_set_groups(ssl_s,
 249                    test4, 2),
 250                    WOLFSSL_SUCCESS);
 251    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 252
 253    curve_name = wolfSSL_get_curve_name(ssl_s);
 254    ExpectStrEQ(curve_name, "SECP256R1");
 255    curve_name = wolfSSL_get_curve_name(ssl_c);
 256    ExpectStrEQ(curve_name, "SECP256R1");
 257
 258    wolfSSL_free(ssl_c);
 259    wolfSSL_free(ssl_s);
 260    wolfSSL_CTX_free(ctx_c);
 261    wolfSSL_CTX_free(ctx_s);
 262#endif
 263    return EXPECT_RESULT();
 264}
 265
 266int test_tls12_dhe_rsa_pss_sigalg(void)
 267{
 268    EXPECT_DECLS;
 269#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
 270    !defined(WOLFSSL_NO_TLS12) && !defined(NO_DH) && !defined(NO_RSA) && \
 271    defined(WC_RSA_PSS) && !defined(NO_SHA256) && defined(HAVE_AESGCM) && \
 272    !defined(WOLFSSL_HARDEN_TLS) && defined(OPENSSL_EXTRA)
 273    /* Regression test for S1: SendServerKeyExchange had an inverted guard
 274     * (#ifndef WC_RSA_PSS) that compiled out the rsa_pss_sa_algo case in the
 275     * server-side signature self-check for the DHE key exchange path. This
 276     * test drives a DHE-RSA handshake restricted to RSA-PSS+SHA256 so the
 277     * server exercises that code path. The bug did not cause the handshake
 278     * to fail, so we verify by asserting the negotiated sig algorithm. */
 279    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
 280    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
 281    struct test_memio_ctx test_ctx;
 282
 283    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 284    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 285                    wolfTLSv1_2_client_method, wolfTLSv1_2_server_method), 0);
 286
 287    ExpectIntEQ(wolfSSL_set_cipher_list(ssl_c, "DHE-RSA-AES128-GCM-SHA256"),
 288                    WOLFSSL_SUCCESS);
 289    ExpectIntEQ(wolfSSL_set_cipher_list(ssl_s, "DHE-RSA-AES128-GCM-SHA256"),
 290                    WOLFSSL_SUCCESS);
 291
 292    ExpectIntEQ(wolfSSL_set1_sigalgs_list(ssl_c, "RSA-PSS+SHA256"), 1);
 293    ExpectIntEQ(wolfSSL_set1_sigalgs_list(ssl_s, "RSA-PSS+SHA256"), 1);
 294
 295    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 296
 297    ExpectIntEQ(ssl_s->options.sigAlgo, rsa_pss_sa_algo);
 298    ExpectIntEQ(ssl_c->options.peerSigAlgo, rsa_pss_sa_algo);
 299
 300    wolfSSL_free(ssl_c);
 301    wolfSSL_free(ssl_s);
 302    wolfSSL_CTX_free(ctx_c);
 303    wolfSSL_CTX_free(ctx_s);
 304#endif
 305    return EXPECT_RESULT();
 306}
 307
 308int test_tls13_curve_intersection(void) {
 309    EXPECT_DECLS;
 310#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
 311    defined(WOLFSSL_TLS13) && defined(HAVE_ECC) && defined(HAVE_CURVE25519)
 312    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
 313    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
 314    struct test_memio_ctx test_ctx;
 315    const char* curve_name;
 316    int test1[] ={WOLFSSL_ECC_SECP256R1};
 317
 318    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 319    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 320                    wolfTLSv1_3_client_method, wolfTLSv1_3_server_method), 0);
 321    ExpectIntEQ(wolfSSL_set_groups(ssl_c,
 322                    test1, 1), WOLFSSL_SUCCESS);
 323    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 324
 325    curve_name = wolfSSL_get_curve_name(ssl_s);
 326    ExpectStrEQ(curve_name, "SECP256R1");
 327    curve_name = wolfSSL_get_curve_name(ssl_c);
 328    ExpectStrEQ(curve_name, "SECP256R1");
 329
 330    wolfSSL_free(ssl_c);
 331    wolfSSL_free(ssl_s);
 332    wolfSSL_CTX_free(ctx_c);
 333    wolfSSL_CTX_free(ctx_s);
 334#endif
 335    return EXPECT_RESULT();
 336}
 337
 338
 339int test_tls_certreq_order(void)
 340{
 341    EXPECT_DECLS;
 342#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
 343    !defined(WOLFSSL_NO_TLS12) && defined(HAVE_AESGCM) && \
 344    defined(WOLFSSL_AES_256) && defined(WOLFSSL_SHA384) && !defined(NO_RSA) && \
 345    defined(HAVE_ECC)
 346    /* This test checks that a certificate request message
 347     * received before server certificate message is properly detected.
 348     */
 349    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
 350    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
 351    struct test_memio_ctx test_ctx;
 352    int i = 0;
 353    const char* msg = NULL;
 354    int msgSz = 0;
 355    int certIdx = 0;
 356    int certReqIdx = 0;
 357
 358    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 359
 360    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 361                    wolfTLSv1_2_client_method, wolfTLSv1_2_server_method), 0);
 362    wolfSSL_set_verify(ssl_s, WOLFSSL_VERIFY_PEER, NULL);
 363    ExpectIntEQ(wolfSSL_clear_group_messages(ssl_s), 1);
 364
 365    /* start handshake, send first ClientHello */
 366    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
 367    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), WOLFSSL_ERROR_WANT_READ);
 368    /* send server's flight */
 369    ExpectIntEQ(wolfSSL_accept(ssl_s), -1);
 370    ExpectIntEQ(wolfSSL_get_error(ssl_s, -1), WOLFSSL_ERROR_WANT_READ);
 371    for (i = 0; test_memio_get_message(&test_ctx, 1, &msg, &msgSz, i) == 0; i++) {
 372        if (msg[5] == 11) /* cert */
 373            certIdx = i;
 374        if (msg[5] == 13) /* certreq */
 375            certReqIdx = i;
 376    }
 377    ExpectIntNE(certIdx, 0);
 378    ExpectIntNE(certReqIdx, 0);
 379    ExpectIntEQ(test_memio_move_message(&test_ctx, 1, certReqIdx, certIdx), 0);
 380    ExpectIntEQ(wolfSSL_connect(ssl_c), -1);
 381    ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), OUT_OF_ORDER_E);
 382
 383    wolfSSL_free(ssl_c);
 384    wolfSSL_free(ssl_s);
 385    wolfSSL_CTX_free(ctx_c);
 386    wolfSSL_CTX_free(ctx_s);
 387#endif
 388    return EXPECT_RESULT();
 389}
 390
 391#if !defined(WOLFSSL_NO_TLS12) && !defined(NO_RSA) && defined(HAVE_ECC) && \
 392    !defined(NO_WOLFSSL_SERVER) && !defined(WOLFSSL_NO_CLIENT_AUTH)
 393/* Called when writing. */
 394static int CsSend(WOLFSSL* ssl, char* buf, int sz, void* ctx)
 395{
 396    (void)ssl;
 397    (void)buf;
 398    (void)ctx;
 399
 400    return sz;
 401}
 402/* Called when reading. */
 403static int CsRecv(WOLFSSL* ssl, char* buf, int sz, void* ctx)
 404{
 405    WOLFSSL_BUFFER_INFO* msg = (WOLFSSL_BUFFER_INFO*)ctx;
 406    int len = (int)msg->length;
 407
 408    (void)ssl;
 409    (void)sz;
 410
 411    /* Pass back as much of message as will fit in buffer. */
 412    if (len > sz)
 413        len = sz;
 414    XMEMCPY(buf, msg->buffer, len);
 415    /* Move over returned data. */
 416    msg->buffer += len;
 417    msg->length -= len;
 418
 419    /* Amount actually copied. */
 420    return len;
 421}
 422#endif
 423
 424int test_tls12_bad_cv_sig_alg(void)
 425{
 426    EXPECT_DECLS;
 427#if !defined(WOLFSSL_NO_TLS12) && !defined(NO_RSA) && defined(HAVE_ECC) && \
 428    !defined(NO_WOLFSSL_SERVER) && !defined(WOLFSSL_NO_CLIENT_AUTH)
 429    byte clientMsgs[] = {
 430        /* Client Hello */
 431        0x16, 0x03, 0x03, 0x00, 0xe7,
 432        0x01, 0x00, 0x00, 0xe3, 0x03, 0x03, 0x65, 0x27,
 433        0x41, 0xdf, 0xd9, 0x17, 0xdb, 0x02, 0x5c, 0x2e,
 434        0xf8, 0x4b, 0x77, 0x86, 0x5a, 0x20, 0x57, 0x7f,
 435        0xc0, 0xe7, 0xef, 0x8f, 0x56, 0xef, 0xfa, 0x71,
 436        0x36, 0xec, 0x55, 0x1d, 0x4e, 0xa2, 0x00, 0x00,
 437        0x64, 0xc0, 0x2c, 0xc0, 0x2b, 0xc0, 0x30, 0xc0,
 438        0x2f, 0x00, 0x9f, 0x00, 0x9e, 0x00, 0xab, 0x00,
 439        0x34, 0x00, 0xa7, 0x00, 0xaa, 0xcc, 0xa9, 0xcc,
 440        0xa8, 0xcc, 0xaa, 0xc0, 0x27, 0xc0, 0x23, 0xc0,
 441        0x28, 0xc0, 0x24, 0xc0, 0x0a, 0xc0, 0x09, 0xc0,
 442        0x07, 0xc0, 0x14, 0xc0, 0x13, 0xc0, 0x11, 0xc0,
 443        0xac, 0xc0, 0xae, 0xc0, 0xaf, 0x00, 0x6b, 0x00,
 444        0x67, 0x00, 0x39, 0x00, 0x33, 0xcc, 0x14, 0xcc,
 445        0x13, 0xcc, 0x15, 0xc0, 0x06, 0x00, 0xb3, 0x00,
 446        0xb2, 0xc0, 0xa6, 0xc0, 0xa7, 0xcc, 0xab, 0xcc,
 447        0xac, 0xcc, 0xad, 0xc0, 0x37, 0xd0, 0x01, 0x00,
 448        0xb5, 0xc0, 0x3a, 0x00, 0xb4, 0x00, 0x45, 0x00,
 449        0x88, 0x00, 0xbe, 0x00, 0xc4, 0x01, 0x00, 0x00,
 450        0x56, 0x00, 0x0d, 0x00, 0x20, 0x00, 0x1e, 0x06,
 451        0x03, 0x05, 0x03, 0x04, 0x03, 0x08, 0x07, 0x08,
 452        0x08, 0x08, 0x06, 0x08, 0x0b, 0x08, 0x05, 0x08,
 453        0x0a, 0x08, 0x04, 0x08, 0x09, 0x06, 0x01, 0x05,
 454        0x01, 0x04, 0x01, 0x03, 0x01, 0x00, 0x0b, 0x00,
 455        0x02, 0x01, 0x00, 0x00, 0x0a, 0x00, 0x1c, 0x00,
 456        0x1a, 0x00, 0x19, 0x00, 0x1c, 0x00, 0x18, 0x00,
 457        0x1b, 0x00, 0x1e, 0x00, 0x17, 0x00, 0x16, 0x00,
 458        0x1a, 0x00, 0x1d, 0x00, 0x15, 0x00, 0x14, 0x01,
 459        0x01, 0x01, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
 460        0x23, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00,
 461        /* Certificate */
 462        0x16, 0x03, 0x03, 0x05, 0x2b,
 463        0x0b, 0x00, 0x05, 0x27, 0x00, 0x05, 0x24, 0x00,
 464        0x05, 0x21, 0x30, 0x82, 0x05, 0x1d, 0x30, 0x82,
 465        0x04, 0x05, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02,
 466        0x14, 0x4f, 0x0d, 0x8c, 0xc5, 0xfa, 0xee, 0xa2,
 467        0x9b, 0xb7, 0x35, 0x9e, 0xe9, 0x4a, 0x17, 0x99,
 468        0xf0, 0xcc, 0x23, 0xf2, 0xec, 0x30, 0x0d, 0x06,
 469        0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01,
 470        0x01, 0x0b, 0x05, 0x00, 0x30, 0x81, 0x9e, 0x31,
 471        0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06,
 472        0x13, 0x02, 0x55, 0x53, 0x31, 0x10, 0x30, 0x0e,
 473        0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x07, 0x4d,
 474        0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x31, 0x10,
 475        0x30, 0x0e, 0x06, 0x03, 0x55, 0x04, 0x07, 0x0c,
 476        0x07, 0x42, 0x6f, 0x7a, 0x65, 0x6d, 0x61, 0x6e,
 477        0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04,
 478        0x0a, 0x0c, 0x0c, 0x77, 0x6f, 0x6c, 0x66, 0x53,
 479        0x53, 0x4c, 0x5f, 0x32, 0x30, 0x34, 0x38, 0x31,
 480        0x19, 0x30, 0x17, 0x06, 0x03, 0x55, 0x04, 0x0b,
 481        0x0c, 0x10, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x61,
 482        0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x2d, 0x32, 0x30,
 483        0x34, 0x38, 0x31, 0x18, 0x30, 0x16, 0x06, 0x03,
 484        0x55, 0x04, 0x03, 0x0c, 0x0f, 0x77, 0x77, 0x77,
 485        0x2e, 0x77, 0x6f, 0x6c, 0x66, 0x73, 0x73, 0x6c,
 486        0x2e, 0x63, 0x6f, 0x6d, 0x31, 0x1f, 0x30, 0x1d,
 487        0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
 488        0x01, 0x09, 0x01, 0x16, 0x10, 0x69, 0x6e, 0x66,
 489        0x6f, 0x40, 0x77, 0x6f, 0x6c, 0x66, 0x73, 0x73,
 490        0x6c, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x1e, 0x17,
 491        0x0d, 0x32, 0x34, 0x31, 0x32, 0x31, 0x38, 0x32,
 492        0x31, 0x32, 0x35, 0x32, 0x39, 0x5a, 0x17, 0x0d,
 493        0x32, 0x37, 0x30, 0x39, 0x31, 0x34, 0x32, 0x31,
 494        0x32, 0x35, 0x32, 0x39, 0x5a, 0x30, 0x81, 0x9e,
 495        0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
 496        0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x10, 0x30,
 497        0x0e, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x07,
 498        0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x31,
 499        0x10, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x04, 0x07,
 500        0x0c, 0x07, 0x42, 0x6f, 0x7a, 0x65, 0x6d, 0x61,
 501        0x6e, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55,
 502        0x04, 0x0a, 0x0c, 0x0c, 0x77, 0x6f, 0x6c, 0x66,
 503        0x53, 0x53, 0x4c, 0x5f, 0x32, 0x30, 0x34, 0x38,
 504        0x31, 0x19, 0x30, 0x17, 0x06, 0x03, 0x55, 0x04,
 505        0x0b, 0x0c, 0x10, 0x50, 0x72, 0x6f, 0x67, 0x72,
 506        0x61, 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x2d, 0x32,
 507        0x30, 0x34, 0x38, 0x31, 0x18, 0x30, 0x16, 0x06,
 508        0x03, 0x55, 0x04, 0x03, 0x0c, 0x0f, 0x77, 0x77,
 509        0x77, 0x2e, 0x77, 0x6f, 0x6c, 0x66, 0x73, 0x73,
 510        0x6c, 0x2e, 0x63, 0x6f, 0x6d, 0x31, 0x1f, 0x30,
 511        0x1d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
 512        0x0d, 0x01, 0x09, 0x01, 0x16, 0x10, 0x69, 0x6e,
 513        0x66, 0x6f, 0x40, 0x77, 0x6f, 0x6c, 0x66, 0x73,
 514        0x73, 0x6c, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x82,
 515        0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86,
 516        0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05,
 517        0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82,
 518        0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xc3,
 519        0x03, 0xd1, 0x2b, 0xfe, 0x39, 0xa4, 0x32, 0x45,
 520        0x3b, 0x53, 0xc8, 0x84, 0x2b, 0x2a, 0x7c, 0x74,
 521        0x9a, 0xbd, 0xaa, 0x2a, 0x52, 0x07, 0x47, 0xd6,
 522        0xa6, 0x36, 0xb2, 0x07, 0x32, 0x8e, 0xd0, 0xba,
 523        0x69, 0x7b, 0xc6, 0xc3, 0x44, 0x9e, 0xd4, 0x81,
 524        0x48, 0xfd, 0x2d, 0x68, 0xa2, 0x8b, 0x67, 0xbb,
 525        0xa1, 0x75, 0xc8, 0x36, 0x2c, 0x4a, 0xd2, 0x1b,
 526        0xf7, 0x8b, 0xba, 0xcf, 0x0d, 0xf9, 0xef, 0xec,
 527        0xf1, 0x81, 0x1e, 0x7b, 0x9b, 0x03, 0x47, 0x9a,
 528        0xbf, 0x65, 0xcc, 0x7f, 0x65, 0x24, 0x69, 0xa6,
 529        0xe8, 0x14, 0x89, 0x5b, 0xe4, 0x34, 0xf7, 0xc5,
 530        0xb0, 0x14, 0x93, 0xf5, 0x67, 0x7b, 0x3a, 0x7a,
 531        0x78, 0xe1, 0x01, 0x56, 0x56, 0x91, 0xa6, 0x13,
 532        0x42, 0x8d, 0xd2, 0x3c, 0x40, 0x9c, 0x4c, 0xef,
 533        0xd1, 0x86, 0xdf, 0x37, 0x51, 0x1b, 0x0c, 0xa1,
 534        0x3b, 0xf5, 0xf1, 0xa3, 0x4a, 0x35, 0xe4, 0xe1,
 535        0xce, 0x96, 0xdf, 0x1b, 0x7e, 0xbf, 0x4e, 0x97,
 536        0xd0, 0x10, 0xe8, 0xa8, 0x08, 0x30, 0x81, 0xaf,
 537        0x20, 0x0b, 0x43, 0x14, 0xc5, 0x74, 0x67, 0xb4,
 538        0x32, 0x82, 0x6f, 0x8d, 0x86, 0xc2, 0x88, 0x40,
 539        0x99, 0x36, 0x83, 0xba, 0x1e, 0x40, 0x72, 0x22,
 540        0x17, 0xd7, 0x52, 0x65, 0x24, 0x73, 0xb0, 0xce,
 541        0xef, 0x19, 0xcd, 0xae, 0xff, 0x78, 0x6c, 0x7b,
 542        0xc0, 0x12, 0x03, 0xd4, 0x4e, 0x72, 0x0d, 0x50,
 543        0x6d, 0x3b, 0xa3, 0x3b, 0xa3, 0x99, 0x5e, 0x9d,
 544        0xc8, 0xd9, 0x0c, 0x85, 0xb3, 0xd9, 0x8a, 0xd9,
 545        0x54, 0x26, 0xdb, 0x6d, 0xfa, 0xac, 0xbb, 0xff,
 546        0x25, 0x4c, 0xc4, 0xd1, 0x79, 0xf4, 0x71, 0xd3,
 547        0x86, 0x40, 0x18, 0x13, 0xb0, 0x63, 0xb5, 0x72,
 548        0x4e, 0x30, 0xc4, 0x97, 0x84, 0x86, 0x2d, 0x56,
 549        0x2f, 0xd7, 0x15, 0xf7, 0x7f, 0xc0, 0xae, 0xf5,
 550        0xfc, 0x5b, 0xe5, 0xfb, 0xa1, 0xba, 0xd3, 0x02,
 551        0x03, 0x01, 0x00, 0x01, 0xa3, 0x82, 0x01, 0x4f,
 552        0x30, 0x82, 0x01, 0x4b, 0x30, 0x1d, 0x06, 0x03,
 553        0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x33,
 554        0xd8, 0x45, 0x66, 0xd7, 0x68, 0x87, 0x18, 0x7e,
 555        0x54, 0x0d, 0x70, 0x27, 0x91, 0xc7, 0x26, 0xd7,
 556        0x85, 0x65, 0xc0, 0x30, 0x81, 0xde, 0x06, 0x03,
 557        0x55, 0x1d, 0x23, 0x04, 0x81, 0xd6, 0x30, 0x81,
 558        0xd3, 0x80, 0x14, 0x33, 0xd8, 0x45, 0x66, 0xd7,
 559        0x68, 0x87, 0x18, 0x7e, 0x54, 0x0d, 0x70, 0x27,
 560        0x91, 0xc7, 0x26, 0xd7, 0x85, 0x65, 0xc0, 0xa1,
 561        0x81, 0xa4, 0xa4, 0x81, 0xa1, 0x30, 0x81, 0x9e,
 562        0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
 563        0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x10, 0x30,
 564        0x0e, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x07,
 565        0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x31,
 566        0x10, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x04, 0x07,
 567        0x0c, 0x07, 0x42, 0x6f, 0x7a, 0x65, 0x6d, 0x61,
 568        0x6e, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55,
 569        0x04, 0x0a, 0x0c, 0x0c, 0x77, 0x6f, 0x6c, 0x66,
 570        0x53, 0x53, 0x4c, 0x5f, 0x32, 0x30, 0x34, 0x38,
 571        0x31, 0x19, 0x30, 0x17, 0x06, 0x03, 0x55, 0x04,
 572        0x0b, 0x0c, 0x10, 0x50, 0x72, 0x6f, 0x67, 0x72,
 573        0x61, 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x2d, 0x32,
 574        0x30, 0x34, 0x38, 0x31, 0x18, 0x30, 0x16, 0x06,
 575        0x03, 0x55, 0x04, 0x03, 0x0c, 0x0f, 0x77, 0x77,
 576        0x77, 0x2e, 0x77, 0x6f, 0x6c, 0x66, 0x73, 0x73,
 577        0x6c, 0x2e, 0x63, 0x6f, 0x6d, 0x31, 0x1f, 0x30,
 578        0x1d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
 579        0x0d, 0x01, 0x09, 0x01, 0x16, 0x10, 0x69, 0x6e,
 580        0x66, 0x6f, 0x40, 0x77, 0x6f, 0x6c, 0x66, 0x73,
 581        0x73, 0x6c, 0x2e, 0x63, 0x6f, 0x6d, 0x82, 0x14,
 582        0x4f, 0x0d, 0x8c, 0xc5, 0xfa, 0xee, 0xa2, 0x9b,
 583        0xb7, 0x35, 0x9e, 0xe9, 0x4a, 0x17, 0x99, 0xf0,
 584        0xcc, 0x23, 0xf2, 0xec, 0x30, 0x0c, 0x06, 0x03,
 585        0x55, 0x1d, 0x13, 0x04, 0x05, 0x30, 0x03, 0x01,
 586        0x01, 0xff, 0x30, 0x1c, 0x06, 0x03, 0x55, 0x1d,
 587        0x11, 0x04, 0x15, 0x30, 0x13, 0x82, 0x0b, 0x65,
 588        0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63,
 589        0x6f, 0x6d, 0x87, 0x04, 0x7f, 0x00, 0x00, 0x01,
 590        0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x04,
 591        0x16, 0x30, 0x14, 0x06, 0x08, 0x2b, 0x06, 0x01,
 592        0x05, 0x05, 0x07, 0x03, 0x01, 0x06, 0x08, 0x2b,
 593        0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x02, 0x30,
 594        0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
 595        0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82,
 596        0x01, 0x01, 0x00, 0x46, 0xab, 0xe4, 0x6d, 0xae,
 597        0x49, 0x5b, 0x6a, 0x0b, 0xa9, 0x87, 0xe1, 0x95,
 598        0x32, 0xa6, 0xd7, 0xae, 0xde, 0x28, 0xdc, 0xc7,
 599        0x99, 0x68, 0xe2, 0x5f, 0xc9, 0x5a, 0x4c, 0x64,
 600        0xb8, 0xf5, 0x28, 0x42, 0x5a, 0xe8, 0x5c, 0x59,
 601        0x32, 0xfe, 0xd0, 0x1f, 0x0b, 0x55, 0x89, 0xdb,
 602        0x67, 0xe7, 0x78, 0xf3, 0x70, 0xcf, 0x18, 0x51,
 603        0x57, 0x8b, 0xf3, 0x2b, 0xa4, 0x66, 0x0b, 0xf6,
 604        0x03, 0x6e, 0x11, 0xac, 0x83, 0x52, 0x16, 0x7e,
 605        0xa2, 0x7c, 0x36, 0x77, 0xf6, 0xbb, 0x13, 0x19,
 606        0x40, 0x2c, 0xb8, 0x8c, 0xca, 0xd6, 0x7e, 0x79,
 607        0x7d, 0xf4, 0x14, 0x8d, 0xb5, 0xa4, 0x09, 0xf6,
 608        0x2d, 0x4c, 0xe7, 0xf9, 0xb8, 0x25, 0x41, 0x15,
 609        0x78, 0xf4, 0xca, 0x80, 0x41, 0xea, 0x3a, 0x05,
 610        0x08, 0xf6, 0xb5, 0x5b, 0xa1, 0x3b, 0x5b, 0x48,
 611        0xa8, 0x4b, 0x8c, 0x19, 0x8d, 0x6c, 0x87, 0x31,
 612        0x76, 0x74, 0x02, 0x16, 0x8b, 0xdd, 0x7f, 0xd1,
 613        0x11, 0x62, 0x27, 0x42, 0x39, 0xe0, 0x9a, 0x63,
 614        0x26, 0x31, 0x19, 0xce, 0x3d, 0x41, 0xd5, 0x24,
 615        0x47, 0x32, 0x0f, 0x76, 0xd6, 0x41, 0x37, 0x44,
 616        0xad, 0x73, 0xf1, 0xb8, 0xec, 0x2b, 0x6e, 0x9c,
 617        0x4f, 0x84, 0xc4, 0x4e, 0xd7, 0x92, 0x10, 0x7e,
 618        0x23, 0x32, 0xa0, 0x75, 0x6a, 0xe7, 0xfe, 0x55,
 619        0x95, 0x9f, 0x0a, 0xad, 0xdf, 0xf9, 0x2a, 0xa2,
 620        0x1a, 0x59, 0xd5, 0x82, 0x63, 0xd6, 0x5d, 0x7d,
 621        0x79, 0xf4, 0xa7, 0x2d, 0xdc, 0x8c, 0x04, 0xcd,
 622        0x98, 0xb0, 0x42, 0x0e, 0x84, 0xfa, 0x86, 0x50,
 623        0x10, 0x61, 0xac, 0x73, 0xcd, 0x79, 0x45, 0x30,
 624        0xe8, 0x42, 0xa1, 0x6a, 0xf6, 0x77, 0x55, 0xec,
 625        0x07, 0xdb, 0x52, 0x29, 0xca, 0x7a, 0xc8, 0xa2,
 626        0xda, 0xe9, 0xf5, 0x98, 0x33, 0x6a, 0xe8, 0xbc,
 627        0x89, 0xed, 0x01, 0xe2, 0xfe, 0x44, 0x86, 0x86,
 628        0x80, 0x39, 0xec,
 629        /* ClientKeyExchange */
 630        0x16, 0x03, 0x03, 0x00, 0x46,
 631        0x10, 0x00, 0x00, 0x42, 0x41, 0x04, 0xc5, 0xb9,
 632        0x0f, 0xbc, 0x84, 0xe6, 0x0c, 0x02, 0xa6, 0x8d,
 633        0x34, 0xa6, 0x3e, 0x1e, 0xb7, 0x88, 0xb8, 0x68,
 634        0x29, 0x2b, 0x85, 0x67, 0xe2, 0x62, 0x4d, 0xd9,
 635        0xa4, 0x38, 0xb3, 0xec, 0x33, 0xa1, 0xe5, 0xe1,
 636        0xae, 0xe9, 0x07, 0xd1, 0xea, 0x1b, 0xec, 0xa6,
 637        0xaf, 0x1f, 0x80, 0x87, 0x7c, 0x53, 0x80, 0x04,
 638        0xee, 0x20, 0xeb, 0x64, 0x0d, 0xa0, 0xf7, 0x62,
 639        0xb1, 0xcc, 0x73, 0x97, 0xf5, 0x80,
 640        /* CertificateVerify */
 641        0x16, 0x03, 0x03, 0x01, 0x08,
 642        /*                            0x04 - sha256, changed to 0x02 - sha1 */
 643        0x0f, 0x00, 0x01, 0x04, 0x08, 0x02, 0x01, 0x00,
 644        0x8b, 0x09, 0xa4, 0x58, 0x8d, 0x68, 0xd9, 0xc9,
 645        0xef, 0xe9, 0xa5, 0x98, 0x7f, 0xa3, 0xa9, 0x7b,
 646        0x56, 0xf7, 0xaa, 0x5f, 0x8f, 0x47, 0x7f, 0xd0,
 647        0x7b, 0xcf, 0x4f, 0x84, 0xe1, 0xa9, 0x0e, 0xa8,
 648        0x83, 0x19, 0xd8, 0xb3, 0x97, 0x23, 0x98, 0xc5,
 649        0x2b, 0x56, 0x82, 0x66, 0x94, 0xcc, 0xd7, 0x23,
 650        0xe6, 0x6e, 0x60, 0x83, 0x78, 0xfb, 0xaf, 0x8e,
 651        0x8b, 0xae, 0x1f, 0x3c, 0x34, 0x96, 0x3b, 0xd5,
 652        0x8d, 0x1e, 0xaf, 0x98, 0x1d, 0x27, 0x86, 0x97,
 653        0x42, 0xd4, 0xfc, 0x62, 0xbc, 0x43, 0x94, 0x98,
 654        0x19, 0x26, 0x87, 0xb0, 0x8c, 0xb5, 0x22, 0xa7,
 655        0x6a, 0x5e, 0x56, 0x73, 0x0a, 0x75, 0xc9, 0xb9,
 656        0x0e, 0xf7, 0x49, 0x4f, 0xa2, 0x0f, 0xfb, 0xdf,
 657        0x3e, 0xe4, 0xc8, 0x31, 0x26, 0xc5, 0x5c, 0x83,
 658        0x9f, 0x13, 0xcb, 0x4c, 0xdc, 0x21, 0xe6, 0x24,
 659        0x2d, 0xd3, 0xe8, 0x18, 0x04, 0xaf, 0x5c, 0x42,
 660        0x03, 0xa3, 0x0a, 0xb5, 0xfc, 0xb9, 0xbc, 0x8e,
 661        0xd3, 0xe0, 0x78, 0xdc, 0xef, 0xb9, 0x91, 0x9f,
 662        0x5b, 0xdc, 0xe3, 0x84, 0xd2, 0xca, 0x32, 0x33,
 663        0x00, 0x7c, 0x13, 0xd3, 0x2d, 0x85, 0x65, 0x00,
 664        0xc0, 0xb0, 0xde, 0x85, 0x37, 0x38, 0x18, 0xd2,
 665        0x81, 0xd4, 0x35, 0xeb, 0xf1, 0xfb, 0x9f, 0x6c,
 666        0x96, 0x95, 0xf5, 0xaa, 0xfd, 0x22, 0xca, 0x20,
 667        0xfd, 0x3b, 0xa9, 0xa7, 0xb6, 0x5a, 0x26, 0x02,
 668        0xb6, 0x0e, 0xdd, 0xaa, 0x0f, 0xa8, 0x96, 0x18,
 669        0xaa, 0xb1, 0x79, 0x9c, 0x17, 0xb0, 0x7e, 0xa7,
 670        0x4f, 0xc0, 0x98, 0x27, 0xbe, 0xac, 0x00, 0xda,
 671        0x3b, 0x2e, 0xd4, 0x11, 0x41, 0x54, 0x34, 0x53,
 672        0x5f, 0xc5, 0xcd, 0x72, 0xd7, 0x36, 0x04, 0xe1,
 673        0x7f, 0xcf, 0x1e, 0x01, 0x97, 0xec, 0xeb, 0xad,
 674        0x1c, 0xc6, 0x7f, 0x2d, 0x8c, 0x68, 0x29, 0xd1,
 675        0x93, 0x47, 0x59, 0xc0, 0xe2, 0x4a, 0x36, 0x6c
 676    };
 677    WOLFSSL_CTX* ctx = NULL;
 678    WOLFSSL* ssl = NULL;
 679    WOLFSSL_BUFFER_INFO msg;
 680
 681    /* Set up wolfSSL context. */
 682    ExpectNotNull(ctx = wolfSSL_CTX_new(wolfTLSv1_2_server_method()));
 683    ExpectTrue(wolfSSL_CTX_use_certificate_file(ctx, svrCertFile,
 684        CERT_FILETYPE));
 685    ExpectTrue(wolfSSL_CTX_use_PrivateKey_file(ctx, svrKeyFile,
 686        CERT_FILETYPE));
 687    if (EXPECT_SUCCESS()) {
 688        wolfSSL_CTX_set_verify(ctx, WOLFSSL_VERIFY_NONE, NULL);
 689    }
 690    /* Read from 'msg'. */
 691    wolfSSL_SetIORecv(ctx, CsRecv);
 692    /* No where to send to - dummy sender. */
 693    wolfSSL_SetIOSend(ctx, CsSend);
 694
 695    ExpectNotNull(ssl = wolfSSL_new(ctx));
 696    msg.buffer = clientMsgs;
 697    msg.length = (unsigned int)sizeof(clientMsgs);
 698    if (EXPECT_SUCCESS()) {
 699        wolfSSL_SetIOReadCtx(ssl, &msg);
 700    }
 701    /* Read all message  include CertificateVerify with invalid signature
 702     * algorithm. */
 703    ExpectIntEQ(wolfSSL_accept(ssl), WC_NO_ERR_TRACE(WOLFSSL_FATAL_ERROR));
 704    /* Expect an invalid parameter error. */
 705    ExpectIntEQ(wolfSSL_get_error(ssl, WOLFSSL_FATAL_ERROR), -425);
 706    wolfSSL_free(ssl);
 707    wolfSSL_CTX_free(ctx);
 708#endif
 709    return EXPECT_RESULT();
 710}
 711
 712int test_tls12_no_null_compression(void)
 713{
 714    EXPECT_DECLS;
 715#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && !defined(WOLFSSL_NO_TLS12)
 716    /* ClientHello with compression list missing the required null method (RFC
 717     * 5246 7.4.1.2: the list MUST include the null compression method). */
 718    const byte badClientHello[] = {
 719        /* record header */
 720        0x16, 0x03, 0x03, 0x00, 0x2d,
 721        /* handshake header: ClientHello, length 41 */
 722        0x01, 0x00, 0x00, 0x29,
 723        /* client version: TLS 1.2 */
 724        0x03, 0x03,
 725        /* random: 32 bytes */
 726        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 727        0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 728        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 729        0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 730        /* session id length: 0 */
 731        0x00,
 732        /* cipher suites length: 2, TLS_RSA_WITH_AES_128_CBC_SHA */
 733        0x00, 0x02, 0x00, 0x2f,
 734        /* compression methods: 1 entry, ZLIB only (null is absent) */
 735        0x01, 0xdd,
 736    };
 737    WOLFSSL_CTX *ctx_s = NULL;
 738    WOLFSSL *ssl_s = NULL;
 739    struct test_memio_ctx test_ctx;
 740
 741    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 742    ExpectIntEQ(test_memio_inject_message(&test_ctx, 0,
 743            (const char*)badClientHello, sizeof(badClientHello)), 0);
 744    ExpectIntEQ(test_memio_setup(&test_ctx, NULL, &ctx_s, NULL, &ssl_s,
 745                    NULL, wolfTLSv1_2_server_method), 0);
 746    ExpectIntEQ(wolfSSL_accept(ssl_s), WOLFSSL_FATAL_ERROR);
 747    ExpectIntEQ(wolfSSL_get_error(ssl_s, WOLFSSL_FATAL_ERROR),
 748            WC_NO_ERR_TRACE(COMPRESSION_ERROR));
 749#ifdef WOLFSSL_EXTRA_ALERTS
 750    {
 751        const byte illegalParamAlert[] = {
 752            0x15,             /* alert content type */
 753            0x03, 0x03,       /* version: TLS 1.2 */
 754            0x00, 0x02,       /* length: 2 */
 755            0x02,             /* level: fatal */
 756            0x2f,             /* description: illegal_parameter (47) */
 757        };
 758        ExpectIntEQ(test_ctx.c_len, (int)sizeof(illegalParamAlert));
 759        ExpectBufEQ(test_ctx.c_buff, illegalParamAlert,
 760                sizeof(illegalParamAlert));
 761    }
 762#endif
 763    wolfSSL_free(ssl_s);
 764    wolfSSL_CTX_free(ctx_s);
 765#endif
 766    return EXPECT_RESULT();
 767}
 768
 769/* Test that set_curves_list correctly resolves ECC curve names that fall
 770 * through the kNistCurves table and reach the wc_ecc_get_curve_idx_from_name
 771 * fallback path.  The kNistCurves lookup uses a case-sensitive XSTRNCMP, so
 772 * uppercase names like "SECP384R1" do not match the lowercase "secp384r1"
 773 * entry; they fall through to the wolfCrypt ECC look-up which uses
 774 * XSTRCASECMP. */
 775/* Regression test for the encrypt-then-MAC silent-disable bug.
 776 *
 777 * Before the fix, when a client sent a 32-byte session ID in its ClientHello
 778 * (so the server set ssl->options.resuming = 1) but the server's session
 779 * cache did not contain that session, DoClientHello would run an
 780 * encrypt_then_mac decision *before* MatchSuite/SetCipherSpecs had populated
 781 * ssl->specs.cipher_type.  Because cipher_type was zero-initialized
 782 * (== stream, not block), the ETM block cleared encThenMac to 0, and the
 783 * post-MatchSuite block could not re-enable it.  The connection then
 784 * silently negotiated MAC-then-encrypt instead of encrypt-then-MAC.
 785 *
 786 * This test forces a stale-resumption ClientHello against a server with an
 787 * empty session cache, using a CBC-mode cipher suite, and asserts that the
 788 * server still negotiates encrypt-then-MAC. */
 789int test_tls12_etm_failed_resumption(void)
 790{
 791    EXPECT_DECLS;
 792#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
 793    !defined(WOLFSSL_NO_TLS12) && defined(HAVE_ENCRYPT_THEN_MAC) && \
 794    !defined(WOLFSSL_AEAD_ONLY) && !defined(NO_RSA) && !defined(NO_AES) && \
 795    defined(HAVE_AES_CBC) && !defined(NO_SHA256) && \
 796    defined(HAVE_SESSION_TICKET) && defined(HAVE_ECC)
 797    /* TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 - a CBC suite, where ETM applies. */
 798    const char* cbcSuite = "ECDHE-RSA-AES128-SHA256";
 799    WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL;
 800    WOLFSSL *ssl_c = NULL, *ssl_s = NULL;
 801    WOLFSSL_SESSION *sess = NULL;
 802    struct test_memio_ctx test_ctx;
 803
 804    /* First handshake: establish a session-ID-based session on the client.
 805     * Disable TLS 1.2 session tickets on both sides so resumption uses the
 806     * session ID path (not tickets), which is the path the bug lives on. */
 807    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 808    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 809                    wolfTLSv1_2_client_method, wolfTLSv1_2_server_method), 0);
 810    ExpectIntEQ(wolfSSL_NoTicketTLSv12(ssl_c), WOLFSSL_SUCCESS);
 811    ExpectIntEQ(wolfSSL_NoTicketTLSv12(ssl_s), WOLFSSL_SUCCESS);
 812    ExpectIntEQ(wolfSSL_set_cipher_list(ssl_c, cbcSuite), WOLFSSL_SUCCESS);
 813    ExpectIntEQ(wolfSSL_set_cipher_list(ssl_s, cbcSuite), WOLFSSL_SUCCESS);
 814    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 815    /* Sanity: the first handshake itself must use ETM. */
 816    ExpectIntEQ(ssl_s->options.encThenMac, 1);
 817    ExpectNotNull(sess = wolfSSL_get1_session(ssl_c));
 818
 819    wolfSSL_free(ssl_c); ssl_c = NULL;
 820    wolfSSL_free(ssl_s); ssl_s = NULL;
 821    wolfSSL_CTX_free(ctx_c); ctx_c = NULL;
 822    wolfSSL_CTX_free(ctx_s); ctx_s = NULL;
 823
 824    /* Second handshake against a *fresh* server context (empty cache).  The
 825     * client offers the saved session, so the server's ClientHello parser
 826     * sets options.resuming = 1, but HandleTlsResumption then fails to find
 827     * the session and clears resuming.  Pre-fix, ETM was silently dropped
 828     * here. */
 829    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
 830    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
 831                    wolfTLSv1_2_client_method, wolfTLSv1_2_server_method), 0);
 832    /* The internal session cache is process-global, so the saved session is
 833     * still findable via the cache.  Disable lookups on this server SSL
 834     * directly so that HandleTlsResumption hits its "session lookup failed"
 835     * path - exactly the scenario the bug fix targets. */
 836    if (ssl_s != NULL)
 837        ssl_s->options.sessionCacheOff = 1;
 838    ExpectIntEQ(wolfSSL_NoTicketTLSv12(ssl_c), WOLFSSL_SUCCESS);
 839    ExpectIntEQ(wolfSSL_NoTicketTLSv12(ssl_s), WOLFSSL_SUCCESS);
 840    ExpectIntEQ(wolfSSL_set_cipher_list(ssl_c, cbcSuite), WOLFSSL_SUCCESS);
 841    ExpectIntEQ(wolfSSL_set_cipher_list(ssl_s, cbcSuite), WOLFSSL_SUCCESS);
 842    ExpectIntEQ(wolfSSL_set_session(ssl_c, sess), WOLFSSL_SUCCESS);
 843    ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0);
 844    if (ssl_s != NULL) {
 845        /* The server should NOT have actually resumed (fresh ctx, empty
 846         * cache). */
 847        ExpectIntEQ(ssl_s->options.resuming, 0);
 848        /* And - the regression check - encrypt-then-MAC must still be
 849         * active. */
 850        ExpectIntEQ(ssl_s->options.encThenMac, 1);
 851    }
 852    if (ssl_c != NULL)
 853        ExpectIntEQ(ssl_c->options.encThenMac, 1);
 854
 855    wolfSSL_SESSION_free(sess);
 856    wolfSSL_free(ssl_c);
 857    wolfSSL_free(ssl_s);
 858    wolfSSL_CTX_free(ctx_c);
 859    wolfSSL_CTX_free(ctx_s);
 860#endif
 861    return EXPECT_RESULT();
 862}
 863
 864int test_tls_set_curves_list_ecc_fallback(void)
 865{
 866    EXPECT_DECLS;
 867#if defined(WOLFSSL_TLS13) && defined(HAVE_ECC) && \
 868    (defined(OPENSSL_EXTRA) || defined(HAVE_CURL)) && \
 869    !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \
 870    (defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)) && \
 871    ECC_MIN_KEY_SZ <= 384
 872#ifndef NO_WOLFSSL_CLIENT
 873    WOLFSSL_CTX* ctx = NULL;
 874    WOLFSSL*     ssl = NULL;
 875
 876    /* "SECP384R1" (uppercase) is NOT in kNistCurves (case-sensitive table),
 877     * so set_curves_list must use the wc_ecc_get_curve_idx_from_name fallback.
 878     */
 879    ExpectNotNull(ctx = wolfSSL_CTX_new(wolfTLSv1_3_client_method()));
 880
 881    /* CTX-level: set single curve via its wolfCrypt name (uppercase) */
 882    ExpectIntEQ(wolfSSL_CTX_set1_curves_list(ctx, "SECP384R1"),
 883                WOLFSSL_SUCCESS);
 884
 885    /* Verify the correct curve was stored, not ecc_sets[0] */
 886    ExpectIntEQ(ctx->numGroups, 1);
 887    ExpectIntEQ(ctx->group[0], WOLFSSL_ECC_SECP384R1);
 888
 889    /* SSL-level: same check via wolfSSL_set1_curves_list */
 890    ExpectNotNull(ssl = wolfSSL_new(ctx));
 891    ExpectIntEQ(wolfSSL_set1_curves_list(ssl, "SECP384R1"), WOLFSSL_SUCCESS);
 892    ExpectIntEQ(ssl->numGroups, 1);
 893    ExpectIntEQ(ssl->group[0], WOLFSSL_ECC_SECP384R1);
 894
 895    wolfSSL_free(ssl);
 896    wolfSSL_CTX_free(ctx);
 897#endif /* NO_WOLFSSL_CLIENT */
 898#endif
 899    return EXPECT_RESULT();
 900}
 901
 902#if !defined(WOLFSSL_NO_TLS12) && \
 903    defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
 904    !defined(NO_WOLFSSL_CLIENT) && !defined(NO_WOLFSSL_SERVER)
 905static int test_tls12_find_client_finished(const struct test_memio_ctx* test_ctx,
 906    int* finishedMsgPos, int* finishedOffInMsg, int* finishedLen)
 907{
 908    int i;
 909    const char* msg = NULL;
 910    int msgSz = 0;
 911    int ccsPos = -1;
 912
 913    *finishedMsgPos = -1;
 914    *finishedOffInMsg = -1;
 915    *finishedLen = 0;
 916
 917    for (i = 0; i < test_ctx->s_msg_count; i++) {
 918        if (test_memio_get_message(test_ctx, 0, &msg, &msgSz, i) != 0 ||
 919                msgSz < RECORD_HEADER_SZ) {
 920            return -1;
 921        }
 922
 923        if ((byte)msg[0] == change_cipher_spec) {
 924            ccsPos = i;
 925            break;
 926        }
 927    }
 928
 929    if (ccsPos >= 0 &&
 930            test_memio_get_message(test_ctx, 0, &msg, &msgSz, ccsPos + 1) == 0 &&
 931            msgSz >= RECORD_HEADER_SZ && (byte)msg[0] == handshake) {
 932        *finishedMsgPos = ccsPos + 1;
 933        *finishedOffInMsg = 0;
 934        *finishedLen = msgSz;
 935        return 0;
 936    }
 937
 938    if (test_ctx->s_msg_count == 1) {
 939        int off = 0;
 940
 941        while (off + RECORD_HEADER_SZ <= test_ctx->s_len) {
 942            word16 recLen;
 943            int totalLen;
 944
 945            ato16(test_ctx->s_buff + off + 3, &recLen);
 946            totalLen = RECORD_HEADER_SZ + recLen;
 947            if (off + totalLen > test_ctx->s_len) {
 948                return -1;
 949            }
 950
 951            if (test_ctx->s_buff[off] == change_cipher_spec) {
 952                int nextOff = off + totalLen;
 953
 954                if (nextOff + RECORD_HEADER_SZ > test_ctx->s_len ||
 955                        test_ctx->s_buff[nextOff] != handshake) {
 956                    return -1;
 957                }
 958
 959                ato16(test_ctx->s_buff + nextOff + 3, &recLen);
 960                totalLen = RECORD_HEADER_SZ + recLen;
 961                if (nextOff + totalLen > test_ctx->s_len) {
 962                    return -1;
 963                }
 964
 965                *finishedMsgPos = 0;
 966                *finishedOffInMsg = nextOff;
 967                *finishedLen = totalLen;
 968                return 0;
 969            }
 970
 971            off += totalLen;
 972        }
 973    }
 974
 975    return -1;
 976}
 977#endif
 978
 979/* Test that a corrupted TLS 1.2 Finished verify_data is properly rejected
 980 * with VERIFY_FINISHED_ERROR. We let the client queue its second flight,
 981 * remove the Finished record from the memio queue, allow the server to
 982 * process up through CCS, then inject a corrupted Finished record. */
 983int test_tls12_corrupted_finished(void)
 984{
 985    EXPECT_DECLS;
 986#if !defined(WOLFSSL_NO_TLS12) && \
 987    defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
 988    !defined(NO_WOLFSSL_CLIENT) && !defined(NO_WOLFSSL_SERVER)
 989    WOLFSSL_CTX *ctx_c = NULL;
 990    WOLFSSL_CTX *ctx_s = NULL;
 991    WOLFSSL *ssl_c = NULL;
 992    WOLFSSL *ssl_s = NULL;
 993    struct test_memio_ctx test_ctx;
 994    char finishedMsg[1024];
 995    int finishedSz = (int)sizeof(finishedMsg);
 996    int finishedMsgPos = -1;
 997    int finishedOffInMsg = -1;
 998    int finishedLen = 0;
 999
1000    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1001    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1002        wolfTLSv1_2_client_method, wolfTLSv1_2_server_method), 0);
1003
1004    /* Step 1: Client sends ClientHello */
1005    ExpectIntNE(wolfSSL_connect(ssl_c), WOLFSSL_SUCCESS);
1006    ExpectIntEQ(wolfSSL_get_error(ssl_c, WOLFSSL_FATAL_ERROR),
1007        WOLFSSL_ERROR_WANT_READ);
1008
1009    /* Step 2: Server sends ServerHello..ServerHelloDone */
1010    ExpectIntNE(wolfSSL_accept(ssl_s), WOLFSSL_SUCCESS);
1011    ExpectIntEQ(wolfSSL_get_error(ssl_s, WOLFSSL_FATAL_ERROR),
1012        WOLFSSL_ERROR_WANT_READ);
1013
1014    /* Step 3: Client processes server flight and queues its second flight. */
1015    ExpectIntNE(wolfSSL_connect(ssl_c), WOLFSSL_SUCCESS);
1016    ExpectIntEQ(wolfSSL_get_error(ssl_c, WOLFSSL_FATAL_ERROR),
1017        WOLFSSL_ERROR_WANT_READ);
1018
1019    if (EXPECT_SUCCESS()) {
1020        ExpectIntEQ(test_tls12_find_client_finished(&test_ctx, &finishedMsgPos,
1021            &finishedOffInMsg, &finishedLen), 0);
1022        ExpectIntGT(finishedLen, 0);
1023
1024        if (finishedOffInMsg == 0) {
1025            ExpectIntEQ(test_memio_copy_message(&test_ctx, 0, finishedMsg,
1026                &finishedSz, finishedMsgPos), 0);
1027            ExpectIntEQ(test_memio_drop_message(&test_ctx, 0, finishedMsgPos), 0);
1028        }
1029        else {
1030            ExpectIntGE(finishedSz, finishedLen);
1031            XMEMCPY(finishedMsg, test_ctx.s_buff + finishedOffInMsg, finishedLen);
1032            finishedSz = finishedLen;
1033            ExpectIntEQ(test_memio_modify_message_len(&test_ctx, 0,
1034                finishedMsgPos, finishedOffInMsg), 0);
1035        }
1036    }
1037
1038    /* Step 4: Server processes up through CCS but blocks waiting for Finished. */
1039    ExpectIntNE(wolfSSL_accept(ssl_s), WOLFSSL_SUCCESS);
1040    ExpectIntEQ(wolfSSL_get_error(ssl_s, WOLFSSL_FATAL_ERROR),
1041        WOLFSSL_ERROR_WANT_READ);
1042
1043    if (EXPECT_SUCCESS()) {
1044        ExpectIntEQ(ssl_s->msgsReceived.got_change_cipher, 1);
1045        ExpectNotNull(ssl_s->hsHashes);
1046        XMEMSET(&ssl_s->hsHashes->verifyHashes, 0xA5,
1047            sizeof(ssl_s->hsHashes->verifyHashes));
1048        ExpectIntEQ(test_memio_inject_message(&test_ctx, 0, finishedMsg,
1049            finishedSz), 0);
1050    }
1051
1052    /* Step 5: Server processes corrupted Finished and must reject it. */
1053    ExpectIntNE(wolfSSL_accept(ssl_s), WOLFSSL_SUCCESS);
1054    ExpectIntEQ(wolfSSL_get_error(ssl_s, WOLFSSL_FATAL_ERROR),
1055        WC_NO_ERR_TRACE(VERIFY_FINISHED_ERROR));
1056
1057    wolfSSL_free(ssl_c);
1058    wolfSSL_CTX_free(ctx_c);
1059    wolfSSL_free(ssl_s);
1060    wolfSSL_CTX_free(ctx_s);
1061#endif
1062    return EXPECT_RESULT();
1063}
1064
1065/* Test the TLS 1.2 peerAuthGood fail-safe checks directly on both sides.
1066 * The client branch sets NO_PEER_VERIFY; the server branch returns a generic
1067 * fatal error from TICKET_SENT before sending its Finished. */
1068int test_tls12_peerauth_failsafe(void)
1069{
1070    EXPECT_DECLS;
1071#if !defined(WOLFSSL_NO_TLS12) && \
1072    defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
1073    !defined(NO_WOLFSSL_CLIENT) && !defined(NO_WOLFSSL_SERVER)
1074    WOLFSSL_CTX *ctx_c = NULL;
1075    WOLFSSL_CTX *ctx_s = NULL;
1076    WOLFSSL *ssl_c = NULL;
1077    WOLFSSL *ssl_s = NULL;
1078    struct test_memio_ctx test_ctx;
1079    int ret;
1080
1081    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1082    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1083        wolfTLSv1_2_client_method, wolfTLSv1_2_server_method), 0);
1084
1085    if (EXPECT_SUCCESS()) {
1086        ssl_c->options.connectState = FIRST_REPLY_SECOND;
1087        ssl_c->options.peerAuthGood = 0;
1088        ssl_c->options.sendVerify = 0;
1089        ret = wolfSSL_connect(ssl_c);
1090        ExpectIntEQ(ret, WOLFSSL_FATAL_ERROR);
1091        ExpectIntEQ(wolfSSL_get_error(ssl_c, ret),
1092            WC_NO_ERR_TRACE(NO_PEER_VERIFY));
1093        ExpectIntEQ(ssl_c->options.connectState, FIRST_REPLY_SECOND);
1094    }
1095
1096    wolfSSL_free(ssl_c);
1097    wolfSSL_CTX_free(ctx_c);
1098    wolfSSL_free(ssl_s);
1099    wolfSSL_CTX_free(ctx_s);
1100
1101    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1102    ctx_c = NULL;
1103    ctx_s = NULL;
1104    ssl_c = NULL;
1105    ssl_s = NULL;
1106    ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
1107        wolfTLSv1_2_client_method, wolfTLSv1_2_server_method), 0);
1108
1109    if (EXPECT_SUCCESS()) {
1110        ssl_s->options.acceptState = TICKET_SENT;
1111        ssl_s->options.peerAuthGood = 0;
1112        ret = wolfSSL_accept(ssl_s);
1113        ExpectIntEQ(ret, WOLFSSL_FATAL_ERROR);
1114        ExpectIntEQ(ssl_s->options.acceptState, TICKET_SENT);
1115    }
1116
1117    wolfSSL_free(ssl_c);
1118    wolfSSL_CTX_free(ctx_c);
1119    wolfSSL_free(ssl_s);
1120    wolfSSL_CTX_free(ctx_s);
1121#endif
1122    return EXPECT_RESULT();
1123}