diff --git a/doc/dox_comments/header_files/ssl.h b/doc/dox_comments/header_files/ssl.h index 4a1d0e0f51a..920183f4e1a 100644 --- a/doc/dox_comments/header_files/ssl.h +++ b/doc/dox_comments/header_files/ssl.h @@ -14613,9 +14613,9 @@ int wolfSSL_get_SessionTicket(WOLFSSL* ssl, unsigned char* buf, word32* bufSz); The function returned without errors. \return BAD_FUNC_ARG returned if the WOLFSSL structure is NULL. This will also be thrown if the buf argument is NULL but the bufSz argument - is not zero. + is not zero, or if bufSz is larger than 65535. \return MEMORY_ERROR will be returned when the ticket cannot be - allocated. + allocated. The previous ticket is kept. \param ssl a pointer to a WOLFSSL structure, created using wolfSSL_new(). \param buf a byte pointer that gets loaded into the ticket member diff --git a/src/internal.c b/src/internal.c index f51b9f4bacb..b031b687067 100644 --- a/src/internal.c +++ b/src/internal.c @@ -21828,21 +21828,14 @@ int DoFinished(WOLFSSL* ssl, const byte* input, word32* inOutIdx, word32 size, if (ConstantCompare(input + *inOutIdx, (const byte*)&ssl->hsHashes->verifyHashes, (int)size) != 0) { WOLFSSL_MSG("Verify finished error on hashes"); -#ifdef HAVE_SESSION_TICKET +#if defined(HAVE_SESSION_TICKET) && !defined(NO_WOLFSSL_CLIENT) /* Drop the unverified ticket (SetTicket() made the session * unique, so this cannot clear one shared with the app). */ if (ssl->options.side == WOLFSSL_CLIENT_END && ssl->msgsReceived.got_session_ticket && /* no ticket was stored when ECH is rejected */ !EchRejected(ssl)) { - ForceZero(ssl->session->ticket, ssl->session->ticketLen); - if (ssl->session->ticketLenAlloc > 0) { - XFREE(ssl->session->ticket, ssl->session->heap, - DYNAMIC_TYPE_SESSION_TICK); - ssl->session->ticket = ssl->session->staticTicket; - ssl->session->ticketLenAlloc = 0; - } - ssl->session->ticketLen = 0; + (void)SetSessionTicket(ssl->session, NULL, 0); } #endif WOLFSSL_ERROR_VERBOSE(VERIFY_FINISHED_ERROR); @@ -41390,9 +41383,69 @@ int SendCertificateVerify(WOLFSSL* ssl) #ifdef HAVE_SESSION_TICKET +/* Replace the session's ticket. The session is unchanged on failure. + * A dynamic buffer that is large enough is reused. + * + * @param [in, out] session Session to update. + * @param [in] ticket Ticket data, may be NULL when length is 0. + * @param [in] length Length of ticket data in bytes. + * @return 0 on success. + * @return MEMORY_ERROR when allocating the ticket buffer fails. + */ +int SetSessionTicket(WOLFSSL_SESSION* session, const byte* ticket, + word16 length) +{ + byte* buf = session->staticTicket; + word16 allocSz = 0; + word16 staticUsed = length; + + if (length > sizeof(session->staticTicket)) { + staticUsed = 0; + if ((session->ticket != session->staticTicket) && + (session->ticket != NULL) && + (session->ticketLenAlloc >= length)) { + buf = session->ticket; + allocSz = session->ticketLenAlloc; + } + else { + buf = (byte*)XMALLOC(length, session->heap, + DYNAMIC_TYPE_SESSION_TICK); + if (buf == NULL) + return MEMORY_ERROR; + allocSz = length; + } + } + + /* Copy first, ticket may point at the current ticket. */ + if (length > 0) { + XMEMMOVE(buf, ticket, length); + } + + if ((session->ticket != session->staticTicket) && + (session->ticket != buf)) { + if (session->ticket != NULL) { + ForceZero(session->ticket, + min(session->ticketLen, session->ticketLenAlloc)); + } + XFREE(session->ticket, session->heap, DYNAMIC_TYPE_SESSION_TICK); + } + if (allocSz > length) { + ForceZero(buf + length, (word32)(allocSz - length)); + } + ForceZero(session->staticTicket + staticUsed, + sizeof(session->staticTicket) - staticUsed); + + session->ticket = buf; + session->ticketLen = length; + session->ticketLenAlloc = allocSz; + + return 0; +} + int SetTicket(WOLFSSL* ssl, const byte* ticket, word32 length) { word32 sessIdLen = ID_LEN; + int ret; if (length > WOLFSSL_MAX_16BIT) return BUFFER_ERROR; @@ -41400,38 +41453,13 @@ int SetTicket(WOLFSSL* ssl, const byte* ticket, word32 length) if (!HaveUniqueSessionObj(ssl)) return MEMORY_ERROR; - /* Free old dynamic ticket if we already had one */ - if (ssl->session->ticketLenAlloc > 0) { - XFREE(ssl->session->ticket, ssl->session->heap, - DYNAMIC_TYPE_SESSION_TICK); - ssl->session->ticket = ssl->session->staticTicket; - ssl->session->ticketLenAlloc = 0; - } - - if (length > sizeof(ssl->session->staticTicket)) { - byte* sessionTicket = (byte*)XMALLOC(length, ssl->session->heap, - DYNAMIC_TYPE_SESSION_TICK); - if (sessionTicket == NULL) { - /* The old ticket is gone; its length is not valid for the static - * buffer */ - ssl->session->ticketLen = 0; - return MEMORY_E; - } - ssl->session->ticket = sessionTicket; - ssl->session->ticketLenAlloc = (word16)length; - } - ssl->session->ticketLen = (word16)length; + ret = SetSessionTicket(ssl->session, ticket, (word16)length); + if (ret != 0) + return ret; if (length > 0) { if (length < ID_LEN) sessIdLen = length; - XMEMCPY(ssl->session->ticket, ticket, length); - if (ssl->session_ticket_cb != NULL) { - ssl->session_ticket_cb(ssl, - ssl->session->ticket, - ssl->session->ticketLen, - ssl->session_ticket_ctx); - } /* Create a fake sessionID based on the ticket, this will * supersede the existing session cache info. */ ssl->options.haveSessionId = 1; @@ -41460,6 +41488,13 @@ int SetTicket(WOLFSSL* ssl, const byte* ticket, word32 length) sessIdLen); ssl->arrays->sessionIDSz = ID_LEN; } + /* Invoke callback at the end, after ticket is fully processed. */ + if (ssl->session_ticket_cb != NULL) { + ssl->session_ticket_cb(ssl, + ssl->session->ticket, + ssl->session->ticketLen, + ssl->session_ticket_ctx); + } } return 0; diff --git a/src/ssl_api_ext.c b/src/ssl_api_ext.c index 412babadbea..89f442536f2 100644 --- a/src/ssl_api_ext.c +++ b/src/ssl_api_ext.c @@ -1611,56 +1611,21 @@ int wolfSSL_get_SessionTicket(WOLFSSL* ssl, byte* buf, word32* bufSz) * @param [in] buf Ticket data, may be NULL when bufSz is 0. * @param [in] bufSz Length of ticket data in bytes. * @return WOLFSSL_SUCCESS on success. - * @return BAD_FUNC_ARG when ssl is NULL or buf is NULL with bufSz > 0. - * @return MEMORY_ERROR on allocation failure. + * @return BAD_FUNC_ARG when ssl is NULL, buf is NULL with bufSz > 0 or + * bufSz is larger than 65535. + * @return MEMORY_ERROR on allocation failure. The previous ticket is kept. */ int wolfSSL_set_SessionTicket(WOLFSSL* ssl, const byte* buf, word32 bufSz) { int ret = WOLFSSL_SUCCESS; - if ((ssl == NULL) || ((buf == NULL) && (bufSz > 0))) { + if ((ssl == NULL) || ((buf == NULL) && (bufSz > 0)) || + (bufSz > WOLFSSL_MAX_16BIT)) { ret = BAD_FUNC_ARG; } - - if ((ret == WOLFSSL_SUCCESS) && (bufSz > 0)) { - /* Ticket will fit into static ticket */ - if (bufSz <= sizeof(ssl->session->staticTicket)) { - if (ssl->session->ticketLenAlloc > 0) { - XFREE(ssl->session->ticket, ssl->session->heap, - DYNAMIC_TYPE_SESSION_TICK); - ssl->session->ticketLenAlloc = 0; - ssl->session->ticket = ssl->session->staticTicket; - } - } - else { /* Ticket requires dynamic ticket storage */ - /* is dyn buffer big enough */ - if (ssl->session->ticketLenAlloc < bufSz) { - if (ssl->session->ticketLenAlloc > 0) { - XFREE(ssl->session->ticket, ssl->session->heap, - DYNAMIC_TYPE_SESSION_TICK); - } - ssl->session->ticket = (byte*)XMALLOC(bufSz, ssl->session->heap, - DYNAMIC_TYPE_SESSION_TICK); - if (ssl->session->ticket == NULL) { - ssl->session->ticket = ssl->session->staticTicket; - ssl->session->ticketLenAlloc = 0; - ssl->session->ticketLen = 0; - ret = MEMORY_ERROR; - } - else { - ssl->session->ticketLenAlloc = (word16)bufSz; - } - } - } - - if (ret == WOLFSSL_SUCCESS) { - XMEMCPY(ssl->session->ticket, buf, bufSz); - } - } - - if (ret == WOLFSSL_SUCCESS) { - ssl->session->ticketLen = (word16)bufSz; + else if (SetSessionTicket(ssl->session, buf, (word16)bufSz) != 0) { + ret = MEMORY_ERROR; } return ret; diff --git a/tests/api.c b/tests/api.c index f570d405bbe..ecd607a4aad 100644 --- a/tests/api.c +++ b/tests/api.c @@ -12759,8 +12759,9 @@ static int test_tls_ext_word16_overflow(void) /* Build an oversized SessionTicket extension directly on the ssl * extension list. Going via the public API is not enough here because - * wolfSSL_set_SessionTicket clamps to word16 without creating the - * TLSX entry; the TLSX path is what exercises the accumulator. */ + * wolfSSL_set_SessionTicket rejects lengths over 16 bits and does not + * create the TLSX entry; the TLSX path is what exercises the + * accumulator. */ if (EXPECT_SUCCESS()) { ticket = TLSX_SessionTicket_Create(0, big, bigSz, ssl->heap); ExpectNotNull(ticket); diff --git a/tests/api/test_ssl_ext.c b/tests/api/test_ssl_ext.c index 8a1e25dc796..42b3dd363f8 100644 --- a/tests/api/test_ssl_ext.c +++ b/tests/api/test_ssl_ext.c @@ -1112,6 +1112,251 @@ int test_wolfSSL_SessionTicket_inval_ext(void) return EXPECT_RESULT(); } +#if defined(HAVE_SESSION_TICKET) && !defined(NO_WOLFSSL_CLIENT) && \ + !defined(NO_TLS) && defined(USE_WOLFSSL_MEMORY) && \ + !defined(WOLFSSL_NO_MALLOC) && !defined(WOLFSSL_STATIC_MEMORY) + +/* Makes every allocation fail while set. */ +static int ticketOomFailAll = 0; + +#ifdef WOLFSSL_DEBUG_MEMORY +static void* ticketOomMalloc(size_t size, const char* func, unsigned int line) +{ + (void)func; + (void)line; +#else +static void* ticketOomMalloc(size_t size) +{ +#endif + if (ticketOomFailAll) { + return NULL; + } + return malloc(size); +} + +#ifdef WOLFSSL_DEBUG_MEMORY +static void ticketOomFree(void* ptr, const char* func, unsigned int line) +{ + (void)func; + (void)line; +#else +static void ticketOomFree(void* ptr) +{ +#endif + free(ptr); +} + +#ifdef WOLFSSL_DEBUG_MEMORY +static void* ticketOomRealloc(void* ptr, size_t size, const char* func, + unsigned int line) +{ + (void)func; + (void)line; +#else +static void* ticketOomRealloc(void* ptr, size_t size) +{ +#endif + if (ticketOomFailAll) { + return NULL; + } + return realloc(ptr, size); +} + +/* Check that the ticket in ssl matches the first sz bytes of expected. */ +static int test_SessionTicket_check(WOLFSSL* ssl, const byte* expected, + word32 sz) +{ + EXPECT_DECLS; + byte out[SESSION_TICKET_STATIC_LEN + 3]; + word32 outSz = (word32)sizeof(out); + + ExpectIntEQ(wolfSSL_get_SessionTicket(ssl, out, &outSz), WOLFSSL_SUCCESS); + ExpectIntEQ(outSz, sz); + ExpectBufEQ(out, expected, sz); + return EXPECT_RESULT(); +} +#endif + +/* Test that a failed wolfSSL_set_SessionTicket() keeps the previous ticket. + * + * @return TEST_SUCCESS on success. + */ +int test_wolfSSL_SessionTicket_alloc_fail_ext(void) +{ + EXPECT_DECLS; +#if defined(HAVE_SESSION_TICKET) && !defined(NO_WOLFSSL_CLIENT) && \ + !defined(NO_TLS) && defined(USE_WOLFSSL_MEMORY) && \ + !defined(WOLFSSL_NO_MALLOC) && !defined(WOLFSSL_STATIC_MEMORY) + wolfSSL_Malloc_cb prevM = NULL; + wolfSSL_Free_cb prevF = NULL; + wolfSSL_Realloc_cb prevR = NULL; + WOLFSSL_CTX* ctx = NULL; + WOLFSSL* ssl = NULL; + byte big[SESSION_TICKET_STATIC_LEN + 3]; + const word32 lens[] = { SESSION_TICKET_STATIC_LEN + 1, + SESSION_TICKET_STATIC_LEN }; + int i; + + /* A static buffer this size holds every ticket, none are allocated. */ + if (SESSION_TICKET_STATIC_LEN + 3 > WOLFSSL_MAX_16BIT) { + return TEST_SKIPPED; + } + + XMEMSET(big, 0x5a, sizeof(big)); + + ExpectNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_client_method())); + ExpectNotNull(ssl = wolfSSL_new(ctx)); + + ExpectIntEQ(wolfSSL_set_SessionTicket(ssl, big, + SESSION_TICKET_STATIC_LEN + 2), WOLFSSL_SUCCESS); + + ExpectIntEQ(wolfSSL_GetAllocators(&prevM, &prevF, &prevR), 0); + if (EXPECT_SUCCESS()) { + ExpectIntEQ(wolfSSL_SetAllocators(ticketOomMalloc, ticketOomFree, + ticketOomRealloc), 0); + ticketOomFailAll = 1; + /* A longer ticket needs a new buffer, the previous one is kept. */ + ExpectIntEQ(wolfSSL_set_SessionTicket(ssl, big, + SESSION_TICKET_STATIC_LEN + 3), WC_NO_ERR_TRACE(MEMORY_ERROR)); + ExpectIntEQ(test_SessionTicket_check(ssl, big, + SESSION_TICKET_STATIC_LEN + 2), TEST_SUCCESS); + /* A shorter ticket is stored in the current buffer. */ + ExpectIntEQ(wolfSSL_set_SessionTicket(ssl, big, + SESSION_TICKET_STATIC_LEN + 1), WOLFSSL_SUCCESS); + ExpectIntEQ(test_SessionTicket_check(ssl, big, + SESSION_TICKET_STATIC_LEN + 1), TEST_SUCCESS); + ticketOomFailAll = 0; + (void)wolfSSL_SetAllocators(prevM, prevF, prevR); + } + + /* The rest of the reused buffer is cleared. */ + if (EXPECT_SUCCESS()) { + ExpectIntEQ(ssl->session->ticketLenAlloc, + SESSION_TICKET_STATIC_LEN + 2); + ExpectIntEQ(ssl->session->ticket[SESSION_TICKET_STATIC_LEN + 1], 0); + } + + /* Setting the current ticket again keeps it, dynamic and static. */ + for (i = 0; i < (int)XELEM_CNT(lens) && EXPECT_SUCCESS(); i++) { + ExpectIntEQ(wolfSSL_set_SessionTicket(ssl, big, lens[i]), + WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_set_SessionTicket(ssl, ssl->session->ticket, + ssl->session->ticketLen), WOLFSSL_SUCCESS); + ExpectIntEQ(test_SessionTicket_check(ssl, big, lens[i]), + TEST_SUCCESS); + } + + /* Clearing the ticket leaves nothing to read. */ + ExpectIntEQ(wolfSSL_set_SessionTicket(ssl, NULL, 0), WOLFSSL_SUCCESS); + ExpectIntEQ(test_SessionTicket_check(ssl, big, 0), TEST_SUCCESS); + + /* A length over 16 bits is rejected before the buffer is read. */ + ExpectIntEQ(wolfSSL_set_SessionTicket(ssl, big, WOLFSSL_MAX_16BIT + 1), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + wolfSSL_free(ssl); + wolfSSL_CTX_free(ctx); +#endif + return EXPECT_RESULT(); +} + +#if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \ + defined(HAVE_SESSION_TICKET) && !defined(WOLFSSL_NO_DEF_TICKET_ENC_CB) +#define TEST_TICKET_CB_REPLACE + +/* Ticket the client was issued. */ +struct test_ssl_ext_ticket_seen { + byte ticket[SESSION_TICKET_LEN]; + word32 ticketSz; +}; + +/* Save the ticket received, then replace it with a shorter one. + * + * @param [in] ssl SSL/TLS object. + * @param [in] ticket Ticket received. + * @param [in] ticketSz Length of ticket in bytes. + * @param [in] ctx Where to save the ticket. + * @return 0 always - the caller does not use the return value. + */ +static int test_ssl_ext_ticket_replace_cb(WOLFSSL* ssl, + const unsigned char* ticket, int ticketSz, void* ctx) +{ + struct test_ssl_ext_ticket_seen* seen = + (struct test_ssl_ext_ticket_seen*)ctx; + static const byte shortTicket[1] = { 0x01 }; + + if ((ticketSz > 0) && ((word32)ticketSz <= sizeof(seen->ticket))) { + XMEMCPY(seen->ticket, ticket, (size_t)ticketSz); + seen->ticketSz = (word32)ticketSz; + } + (void)wolfSSL_set_SessionTicket(ssl, shortTicket, sizeof(shortTicket)); + + return 0; +} +#endif /* TEST_TICKET_CB_REPLACE */ + +/* Test that the session ID is made from the ticket received, even when the + * session ticket callback replaces the ticket. + * + * @return TEST_SUCCESS on success. + */ +int test_wolfSSL_SessionTicket_cb_replace_ext(void) +{ + EXPECT_DECLS; +#ifdef TEST_TICKET_CB_REPLACE + struct { + method_provider client_meth; + method_provider server_meth; + int tls13; + } params[] = { +#ifdef WOLFSSL_TLS13 + { wolfTLSv1_3_client_method, wolfTLSv1_3_server_method, 1 }, +#endif +#ifndef WOLFSSL_NO_TLS12 + { wolfTLSv1_2_client_method, wolfTLSv1_2_server_method, 0 }, +#endif + }; + size_t i; + + for (i = 0; i < XELEM_CNT(params) && !EXPECT_FAIL(); i++) { + struct test_memio_ctx test_ctx; + struct test_ssl_ext_ticket_seen seen; + WOLFSSL_CTX *ctx_c = NULL, *ctx_s = NULL; + WOLFSSL *ssl_c = NULL, *ssl_s = NULL; + const byte* id; + char buf[64]; + + XMEMSET(&test_ctx, 0, sizeof(test_ctx)); + XMEMSET(&seen, 0, sizeof(seen)); + ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, + &ssl_s, params[i].client_meth, params[i].server_meth), 0); + ExpectIntEQ(wolfSSL_UseSessionTicket(ssl_c), WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_set_SessionTicket_cb(ssl_c, + test_ssl_ext_ticket_replace_cb, &seen), WOLFSSL_SUCCESS); + /* TLS 1.2 keeps the session ID made from the ticket in arrays. */ + wolfSSL_KeepArrays(ssl_c); + + ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), 0); + /* Process a TLS 1.3 NewSessionTicket. */ + (void)wolfSSL_read(ssl_c, buf, sizeof(buf)); + + ExpectIntGE(seen.ticketSz, ID_LEN); + if (EXPECT_SUCCESS()) { + ExpectIntEQ(ssl_c->session->ticketLen, 1); + id = params[i].tls13 ? ssl_c->session->sessionID : + ssl_c->arrays->sessionID; + ExpectBufEQ(id, seen.ticket + seen.ticketSz - ID_LEN, ID_LEN); + } + + wolfSSL_free(ssl_c); + wolfSSL_free(ssl_s); + wolfSSL_CTX_free(ctx_c); + wolfSSL_CTX_free(ctx_s); + } +#endif + return EXPECT_RESULT(); +} + /* Test that wolfSSL_CTX_set_servername_arg() rejects bad arguments. * * @return TEST_SUCCESS on success. diff --git a/tests/api/test_ssl_ext.h b/tests/api/test_ssl_ext.h index dd8092b002f..d5f66198ae3 100644 --- a/tests/api/test_ssl_ext.h +++ b/tests/api/test_ssl_ext.h @@ -61,6 +61,8 @@ int test_wolfSSL_UseALPN_inval_ext(void); int test_wolfSSL_ALPN_GetPeerProtocol_inval_ext(void); int test_wolfSSL_CTX_set_TicketEncCb_inval_ext(void); int test_wolfSSL_SessionTicket_inval_ext(void); +int test_wolfSSL_SessionTicket_alloc_fail_ext(void); +int test_wolfSSL_SessionTicket_cb_replace_ext(void); int test_wolfSSL_CTX_set_servername_arg_inval_ext(void); int test_wolfSSL_CTX_set_alpn_protos_inval_ext(void); int test_wolfSSL_dual_alg_cks_parse_ext(void); @@ -111,6 +113,10 @@ int test_wolfSSL_ticket_key_cb_renew_ext(void); TEST_DECL_GROUP("ssl_ext", \ test_wolfSSL_CTX_set_TicketEncCb_inval_ext), \ TEST_DECL_GROUP("ssl_ext", test_wolfSSL_SessionTicket_inval_ext), \ + TEST_DECL_GROUP("ssl_ext", \ + test_wolfSSL_SessionTicket_alloc_fail_ext), \ + TEST_DECL_GROUP("ssl_ext", \ + test_wolfSSL_SessionTicket_cb_replace_ext), \ TEST_DECL_GROUP("ssl_ext", \ test_wolfSSL_CTX_set_servername_arg_inval_ext), \ TEST_DECL_GROUP("ssl_ext", \ diff --git a/tests/api/test_tls13.c b/tests/api/test_tls13.c index 4a740f607f1..98addb20f13 100644 --- a/tests/api/test_tls13.c +++ b/tests/api/test_tls13.c @@ -13312,9 +13312,8 @@ static void* ticket_alloc_fail_realloc(void* ptr, size_t size) } #endif -/* A client that holds a ticket in a dynamic buffer and fails to allocate the - * buffer for a new one is left without a ticket, not with the old length on - * the static buffer. */ +/* A client that holds a ticket in a dynamic buffer and fails to allocate a + * larger buffer for a new one keeps the old ticket. */ int test_tls13_ticket_set_alloc_fail(void) { EXPECT_DECLS; @@ -13333,6 +13332,9 @@ int test_tls13_ticket_set_alloc_fail(void) wolfSSL_Free_cb prevF = NULL; wolfSSL_Realloc_cb prevR = NULL; char readBuf[64]; + byte shortTicket[SESSION_TICKET_STATIC_LEN + 1]; + byte* ticket = NULL; + word16 ticketLen = 0; /* With client authentication the ticket carries the client certificate * and needs a dynamic buffer */ @@ -13357,13 +13359,21 @@ int test_tls13_ticket_set_alloc_fail(void) ExpectIntGT(ssl_c->session->ticketLen, sizeof(ssl_c->session->staticTicket)); ExpectIntGT(ssl_c->session->ticketLenAlloc, 0); + ticketLen = ssl_c->session->ticketLen; } - /* A second ticket of the same length, whose buffer cannot be + /* A shorter dynamic ticket, so the next one needs a larger buffer */ + XMEMSET(shortTicket, 0x5a, sizeof(shortTicket)); + ExpectIntEQ(wolfSSL_set_SessionTicket(ssl_c, NULL, 0), WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_set_SessionTicket(ssl_c, shortTicket, + sizeof(shortTicket)), WOLFSSL_SUCCESS); + + /* A second ticket of the first length, whose buffer cannot be * allocated */ ExpectIntEQ(wolfSSL_send_SessionTicket(ssl_s), WOLFSSL_SUCCESS); if (EXPECT_SUCCESS()) { - ticket_alloc_fail_sz = ssl_c->session->ticketLen; + ticket = ssl_c->session->ticket; + ticket_alloc_fail_sz = ticketLen; ExpectIntEQ(wolfSSL_GetAllocators(&prevM, &prevF, &prevR), 0); ExpectIntEQ(wolfSSL_SetAllocators(ticket_alloc_fail_malloc, ticket_alloc_fail_free, ticket_alloc_fail_realloc), 0); @@ -13371,12 +13381,13 @@ int test_tls13_ticket_set_alloc_fail(void) ticket_alloc_fail_sz = 0; (void)wolfSSL_SetAllocators(prevM, prevF, prevR); ExpectIntEQ(wolfSSL_get_error(ssl_c, -1), - WC_NO_ERR_TRACE(MEMORY_E)); + WC_NO_ERR_TRACE(MEMORY_ERROR)); } if (EXPECT_SUCCESS()) { - ExpectPtrEq(ssl_c->session->ticket, ssl_c->session->staticTicket); - ExpectIntEQ(ssl_c->session->ticketLenAlloc, 0); - ExpectIntEQ(ssl_c->session->ticketLen, 0); + ExpectPtrEq(ssl_c->session->ticket, ticket); + ExpectIntEQ(ssl_c->session->ticketLen, sizeof(shortTicket)); + ExpectIntEQ(ssl_c->session->ticketLenAlloc, sizeof(shortTicket)); + ExpectBufEQ(ssl_c->session->ticket, shortTicket, sizeof(shortTicket)); } wolfSSL_free(ssl_c); diff --git a/wolfssl/internal.h b/wolfssl/internal.h index 41f730462d8..1a7b206379d 100644 --- a/wolfssl/internal.h +++ b/wolfssl/internal.h @@ -7960,6 +7960,8 @@ WOLFSSL_LOCAL int CipherRequires(byte first, byte second, int requirement); WOLFSSL_LOCAL int VerifyClientSuite(word16 havePSK, byte cipherSuite0, byte cipherSuite); +WOLFSSL_LOCAL int SetSessionTicket(WOLFSSL_SESSION* session, + const byte* ticket, word16 length); WOLFSSL_LOCAL int SetTicket(WOLFSSL* ssl, const byte* ticket, word32 length); WOLFSSL_TEST_VIS int wolfssl_local_GetRecordSize(WOLFSSL *ssl, int payloadSz, int isEncrypted);