library/ssl_tls.c

/*
 *  TLS shared functions
 *
 *  Copyright The Mbed TLS Contributors
 *  SPDX-License-Identifier: Apache-2.0
 *
 *  Licensed under the Apache License, Version 2.0 (the "License"); you may
 *  not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/*
 *  http://www.ietf.org/rfc/rfc2246.txt
 *  http://www.ietf.org/rfc/rfc4346.txt
 */

#include "common.h"

#if defined(MBEDTLS_SSL_TLS_C)

#    if defined(MBEDTLS_PLATFORM_C)
#        include "mbedtls/platform.h"
#    else
#        include <stdlib.h>
#        define mbedtls_calloc calloc
#        define mbedtls_free   free
#    endif

#    include "mbedtls/ssl.h"
#    include "ssl_misc.h"
#    include "mbedtls/debug.h"
#    include "mbedtls/error.h"
#    include "mbedtls/platform_util.h"
#    include "mbedtls/version.h"

#    include <string.h>

#    if defined(MBEDTLS_USE_PSA_CRYPTO)
#        include "mbedtls/psa_util.h"
#        include "psa/crypto.h"
#    endif

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
#        include "mbedtls/oid.h"
#    endif

#    if defined(MBEDTLS_SSL_PROTO_DTLS)

#        if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
/* Top-level Connection ID API */

int mbedtls_ssl_conf_cid(mbedtls_ssl_config *conf,
                         size_t len,
                         int ignore_other_cid)
{
    if (len > MBEDTLS_SSL_CID_IN_LEN_MAX)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    if (ignore_other_cid != MBEDTLS_SSL_UNEXPECTED_CID_FAIL &&
        ignore_other_cid != MBEDTLS_SSL_UNEXPECTED_CID_IGNORE) {
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    conf->ignore_unexpected_cid = ignore_other_cid;
    conf->cid_len = len;
    return 0;
}

int mbedtls_ssl_set_cid(mbedtls_ssl_context *ssl,
                        int enable,
                        unsigned char const *own_cid,
                        size_t own_cid_len)
{
    if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    ssl->negotiate_cid = enable;
    if (enable == MBEDTLS_SSL_CID_DISABLED) {
        MBEDTLS_SSL_DEBUG_MSG(3, ("Disable use of CID extension."));
        return 0;
    }
    MBEDTLS_SSL_DEBUG_MSG(3, ("Enable use of CID extension."));
    MBEDTLS_SSL_DEBUG_BUF(3, "Own CID", own_cid, own_cid_len);

    if (own_cid_len != ssl->conf->cid_len) {
        MBEDTLS_SSL_DEBUG_MSG(
            3, ("CID length %u does not match CID length %u in config",
                (unsigned)own_cid_len, (unsigned)ssl->conf->cid_len));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    memcpy(ssl->own_cid, own_cid, own_cid_len);
    /* Truncation is not an issue here because
     * MBEDTLS_SSL_CID_IN_LEN_MAX at most 255. */
    ssl->own_cid_len = (uint8_t)own_cid_len;

    return 0;
}

int mbedtls_ssl_get_peer_cid(mbedtls_ssl_context *ssl,
                             int *enabled,
                             unsigned char peer_cid[MBEDTLS_SSL_CID_OUT_LEN_MAX],
                             size_t *peer_cid_len)
{
    *enabled = MBEDTLS_SSL_CID_DISABLED;

    if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM ||
        ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER) {
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    /* We report MBEDTLS_SSL_CID_DISABLED in case the CID extensions
     * were used, but client and server requested the empty CID.
     * This is indistinguishable from not using the CID extension
     * in the first place. */
    if (ssl->transform_in->in_cid_len == 0 &&
        ssl->transform_in->out_cid_len == 0) {
        return 0;
    }

    if (peer_cid_len != NULL) {
        *peer_cid_len = ssl->transform_in->out_cid_len;
        if (peer_cid != NULL) {
            memcpy(peer_cid, ssl->transform_in->out_cid,
                   ssl->transform_in->out_cid_len);
        }
    }

    *enabled = MBEDTLS_SSL_CID_ENABLED;

    return 0;
}
#        endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */

#    endif /* MBEDTLS_SSL_PROTO_DTLS */

#    if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
/*
 * Convert max_fragment_length codes to length.
 * RFC 6066 says:
 *    enum{
 *        2^9(1), 2^10(2), 2^11(3), 2^12(4), (255)
 *    } MaxFragmentLength;
 * and we add 0 -> extension unused
 */
static unsigned int ssl_mfl_code_to_length(int mfl)
{
    switch (mfl) {
        case MBEDTLS_SSL_MAX_FRAG_LEN_NONE:
            return MBEDTLS_TLS_EXT_ADV_CONTENT_LEN;
        case MBEDTLS_SSL_MAX_FRAG_LEN_512:
            return 512;
        case MBEDTLS_SSL_MAX_FRAG_LEN_1024:
            return 1024;
        case MBEDTLS_SSL_MAX_FRAG_LEN_2048:
            return 2048;
        case MBEDTLS_SSL_MAX_FRAG_LEN_4096:
            return 4096;
        default:
            return MBEDTLS_TLS_EXT_ADV_CONTENT_LEN;
    }
}
#    endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */

int mbedtls_ssl_session_copy(mbedtls_ssl_session *dst,
                             const mbedtls_ssl_session *src)
{
    mbedtls_ssl_session_free(dst);
    memcpy(dst, src, sizeof(mbedtls_ssl_session));

#    if defined(MBEDTLS_X509_CRT_PARSE_C)

#        if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
    if (src->peer_cert != NULL) {
        int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

        dst->peer_cert = mbedtls_calloc(1, sizeof(mbedtls_x509_crt));
        if (dst->peer_cert == NULL)
            return MBEDTLS_ERR_SSL_ALLOC_FAILED;

        mbedtls_x509_crt_init(dst->peer_cert);

        if ((ret = mbedtls_x509_crt_parse_der(dst->peer_cert,
                                              src->peer_cert->raw.p,
                                              src->peer_cert->raw.len)) != 0) {
            mbedtls_free(dst->peer_cert);
            dst->peer_cert = NULL;
            return ret;
        }
    }
#        else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
    if (src->peer_cert_digest != NULL) {
        dst->peer_cert_digest = mbedtls_calloc(1, src->peer_cert_digest_len);
        if (dst->peer_cert_digest == NULL)
            return MBEDTLS_ERR_SSL_ALLOC_FAILED;

        memcpy(dst->peer_cert_digest, src->peer_cert_digest,
               src->peer_cert_digest_len);
        dst->peer_cert_digest_type = src->peer_cert_digest_type;
        dst->peer_cert_digest_len = src->peer_cert_digest_len;
    }
#        endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */

#    endif /* MBEDTLS_X509_CRT_PARSE_C */

#    if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
    if (src->ticket != NULL) {
        dst->ticket = mbedtls_calloc(1, src->ticket_len);
        if (dst->ticket == NULL)
            return MBEDTLS_ERR_SSL_ALLOC_FAILED;

        memcpy(dst->ticket, src->ticket, src->ticket_len);
    }
#    endif /* MBEDTLS_SSL_SESSION_TICKETS && MBEDTLS_SSL_CLI_C */

    return 0;
}

#    if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
static int
resize_buffer(unsigned char **buffer, size_t len_new, size_t *len_old)
{
    unsigned char *resized_buffer = mbedtls_calloc(1, len_new);
    if (resized_buffer == NULL)
        return -1;

    /* We want to copy len_new bytes when downsizing the buffer, and
     * len_old bytes when upsizing, so we choose the smaller of two sizes,
     * to fit one buffer into another. Size checks, ensuring that no data is
     * lost, are done outside of this function. */
    memcpy(resized_buffer, *buffer, (len_new < *len_old) ? len_new : *len_old);
    mbedtls_platform_zeroize(*buffer, *len_old);
    mbedtls_free(*buffer);

    *buffer = resized_buffer;
    *len_old = len_new;

    return 0;
}

static void handle_buffer_resizing(mbedtls_ssl_context *ssl,
                                   int downsizing,
                                   size_t in_buf_new_len,
                                   size_t out_buf_new_len)
{
    int modified = 0;
    size_t written_in = 0, iv_offset_in = 0, len_offset_in = 0;
    size_t written_out = 0, iv_offset_out = 0, len_offset_out = 0;
    if (ssl->in_buf != NULL) {
        written_in = ssl->in_msg - ssl->in_buf;
        iv_offset_in = ssl->in_iv - ssl->in_buf;
        len_offset_in = ssl->in_len - ssl->in_buf;
        if (downsizing ? ssl->in_buf_len > in_buf_new_len &&
                             ssl->in_left < in_buf_new_len :
                         ssl->in_buf_len < in_buf_new_len) {
            if (resize_buffer(&ssl->in_buf, in_buf_new_len, &ssl->in_buf_len) !=
                0) {
                MBEDTLS_SSL_DEBUG_MSG(
                    1, ("input buffer resizing failed - out of memory"));
            } else {
                MBEDTLS_SSL_DEBUG_MSG(
                    2, ("Reallocating in_buf to %" MBEDTLS_PRINTF_SIZET,
                        in_buf_new_len));
                modified = 1;
            }
        }
    }

    if (ssl->out_buf != NULL) {
        written_out = ssl->out_msg - ssl->out_buf;
        iv_offset_out = ssl->out_iv - ssl->out_buf;
        len_offset_out = ssl->out_len - ssl->out_buf;
        if (downsizing ? ssl->out_buf_len > out_buf_new_len &&
                             ssl->out_left < out_buf_new_len :
                         ssl->out_buf_len < out_buf_new_len) {
            if (resize_buffer(&ssl->out_buf, out_buf_new_len,
                              &ssl->out_buf_len) != 0) {
                MBEDTLS_SSL_DEBUG_MSG(
                    1, ("output buffer resizing failed - out of memory"));
            } else {
                MBEDTLS_SSL_DEBUG_MSG(
                    2, ("Reallocating out_buf to %" MBEDTLS_PRINTF_SIZET,
                        out_buf_new_len));
                modified = 1;
            }
        }
    }
    if (modified) {
        /* Update pointers here to avoid doing it twice. */
        mbedtls_ssl_reset_in_out_pointers(ssl);
        /* Fields below might not be properly updated with record
         * splitting or with CID, so they are manually updated here. */
        ssl->out_msg = ssl->out_buf + written_out;
        ssl->out_len = ssl->out_buf + len_offset_out;
        ssl->out_iv = ssl->out_buf + iv_offset_out;

        ssl->in_msg = ssl->in_buf + written_in;
        ssl->in_len = ssl->in_buf + len_offset_in;
        ssl->in_iv = ssl->in_buf + iv_offset_in;
    }
}
#    endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#        if defined(MBEDTLS_USE_PSA_CRYPTO)

static psa_status_t
setup_psa_key_derivation(psa_key_derivation_operation_t *derivation,
                         psa_key_id_t key,
                         psa_algorithm_t alg,
                         const unsigned char *seed,
                         size_t seed_length,
                         const unsigned char *label,
                         size_t label_length,
                         size_t capacity)
{
    psa_status_t status;

    status = psa_key_derivation_setup(derivation, alg);
    if (status != PSA_SUCCESS)
        return status;

    if (PSA_ALG_IS_TLS12_PRF(alg) || PSA_ALG_IS_TLS12_PSK_TO_MS(alg)) {
        status = psa_key_derivation_input_bytes(
            derivation, PSA_KEY_DERIVATION_INPUT_SEED, seed, seed_length);
        if (status != PSA_SUCCESS)
            return status;

        if (mbedtls_svc_key_id_is_null(key)) {
            status = psa_key_derivation_input_bytes(
                derivation, PSA_KEY_DERIVATION_INPUT_SECRET, NULL, 0);
        } else {
            status = psa_key_derivation_input_key(
                derivation, PSA_KEY_DERIVATION_INPUT_SECRET, key);
        }
        if (status != PSA_SUCCESS)
            return status;

        status = psa_key_derivation_input_bytes(
            derivation, PSA_KEY_DERIVATION_INPUT_LABEL, label, label_length);
        if (status != PSA_SUCCESS)
            return status;
    } else {
        return PSA_ERROR_NOT_SUPPORTED;
    }

    status = psa_key_derivation_set_capacity(derivation, capacity);
    if (status != PSA_SUCCESS)
        return status;

    return PSA_SUCCESS;
}

static int tls_prf_generic(mbedtls_md_type_t md_type,
                           const unsigned char *secret,
                           size_t slen,
                           const char *label,
                           const unsigned char *random,
                           size_t rlen,
                           unsigned char *dstbuf,
                           size_t dlen)
{
    psa_status_t status;
    psa_algorithm_t alg;
    psa_key_id_t master_key = MBEDTLS_SVC_KEY_ID_INIT;
    psa_key_derivation_operation_t derivation =
        PSA_KEY_DERIVATION_OPERATION_INIT;

    if (md_type == MBEDTLS_MD_SHA384)
        alg = PSA_ALG_TLS12_PRF(PSA_ALG_SHA_384);
    else
        alg = PSA_ALG_TLS12_PRF(PSA_ALG_SHA_256);

    /* Normally a "secret" should be long enough to be impossible to
     * find by brute force, and in particular should not be empty. But
     * this PRF is also used to derive an IV, in particular in EAP-TLS,
     * and for this use case it makes sense to have a 0-length "secret".
     * Since the key API doesn't allow importing a key of length 0,
     * keep master_key=0, which setup_psa_key_derivation() understands
     * to mean a 0-length "secret" input. */
    if (slen != 0) {
        psa_key_attributes_t key_attributes = psa_key_attributes_init();
        psa_set_key_usage_flags(&key_attributes, PSA_KEY_USAGE_DERIVE);
        psa_set_key_algorithm(&key_attributes, alg);
        psa_set_key_type(&key_attributes, PSA_KEY_TYPE_DERIVE);

        status = psa_import_key(&key_attributes, secret, slen, &master_key);
        if (status != PSA_SUCCESS)
            return MBEDTLS_ERR_SSL_HW_ACCEL_FAILED;
    }

    status = setup_psa_key_derivation(&derivation, master_key, alg, random,
                                      rlen, (unsigned char const *)label,
                                      (size_t)strlen(label), dlen);
    if (status != PSA_SUCCESS) {
        psa_key_derivation_abort(&derivation);
        psa_destroy_key(master_key);
        return MBEDTLS_ERR_SSL_HW_ACCEL_FAILED;
    }

    status = psa_key_derivation_output_bytes(&derivation, dstbuf, dlen);
    if (status != PSA_SUCCESS) {
        psa_key_derivation_abort(&derivation);
        psa_destroy_key(master_key);
        return MBEDTLS_ERR_SSL_HW_ACCEL_FAILED;
    }

    status = psa_key_derivation_abort(&derivation);
    if (status != PSA_SUCCESS) {
        psa_destroy_key(master_key);
        return MBEDTLS_ERR_SSL_HW_ACCEL_FAILED;
    }

    if (!mbedtls_svc_key_id_is_null(master_key))
        status = psa_destroy_key(master_key);
    if (status != PSA_SUCCESS)
        return MBEDTLS_ERR_SSL_HW_ACCEL_FAILED;

    return 0;
}

#        else /* MBEDTLS_USE_PSA_CRYPTO */

static int tls_prf_generic(mbedtls_md_type_t md_type,
                           const unsigned char *secret,
                           size_t slen,
                           const char *label,
                           const unsigned char *random,
                           size_t rlen,
                           unsigned char *dstbuf,
                           size_t dlen)
{
    size_t nb;
    size_t i, j, k, md_len;
    unsigned char *tmp;
    size_t tmp_len = 0;
    unsigned char h_i[MBEDTLS_MD_MAX_SIZE];
    const mbedtls_md_info_t *md_info;
    mbedtls_md_context_t md_ctx;
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

    mbedtls_md_init(&md_ctx);

    if ((md_info = mbedtls_md_info_from_type(md_type)) == NULL)
        return MBEDTLS_ERR_SSL_INTERNAL_ERROR;

    md_len = mbedtls_md_get_size(md_info);

    tmp_len = md_len + strlen(label) + rlen;
    tmp = mbedtls_calloc(1, tmp_len);
    if (tmp == NULL) {
        ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
        goto exit;
    }

    nb = strlen(label);
    memcpy(tmp + md_len, label, nb);
    memcpy(tmp + md_len + nb, random, rlen);
    nb += rlen;

    /*
     * Compute P_<hash>(secret, label + random)[0..dlen]
     */
    if ((ret = mbedtls_md_setup(&md_ctx, md_info, 1)) != 0)
        goto exit;

    mbedtls_md_hmac_starts(&md_ctx, secret, slen);
    mbedtls_md_hmac_update(&md_ctx, tmp + md_len, nb);
    mbedtls_md_hmac_finish(&md_ctx, tmp);

    for (i = 0; i < dlen; i += md_len) {
        mbedtls_md_hmac_reset(&md_ctx);
        mbedtls_md_hmac_update(&md_ctx, tmp, md_len + nb);
        mbedtls_md_hmac_finish(&md_ctx, h_i);

        mbedtls_md_hmac_reset(&md_ctx);
        mbedtls_md_hmac_update(&md_ctx, tmp, md_len);
        mbedtls_md_hmac_finish(&md_ctx, tmp);

        k = (i + md_len > dlen) ? dlen % md_len : md_len;

        for (j = 0; j < k; j++)
            dstbuf[i + j] = h_i[j];
    }

exit:
    mbedtls_md_free(&md_ctx);

    mbedtls_platform_zeroize(tmp, tmp_len);
    mbedtls_platform_zeroize(h_i, sizeof(h_i));

    mbedtls_free(tmp);

    return ret;
}
#        endif /* MBEDTLS_USE_PSA_CRYPTO */
#        if defined(MBEDTLS_SHA256_C)
static int tls_prf_sha256(const unsigned char *secret,
                          size_t slen,
                          const char *label,
                          const unsigned char *random,
                          size_t rlen,
                          unsigned char *dstbuf,
                          size_t dlen)
{
    return (tls_prf_generic(MBEDTLS_MD_SHA256, secret, slen, label, random,
                            rlen, dstbuf, dlen));
}
#        endif /* MBEDTLS_SHA256_C */

#        if defined(MBEDTLS_SHA384_C)
static int tls_prf_sha384(const unsigned char *secret,
                          size_t slen,
                          const char *label,
                          const unsigned char *random,
                          size_t rlen,
                          unsigned char *dstbuf,
                          size_t dlen)
{
    return (tls_prf_generic(MBEDTLS_MD_SHA384, secret, slen, label, random,
                            rlen, dstbuf, dlen));
}
#        endif /* MBEDTLS_SHA384_C */
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

static void
ssl_update_checksum_start(mbedtls_ssl_context *, const unsigned char *, size_t);

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#        if defined(MBEDTLS_SHA256_C)
static void ssl_update_checksum_sha256(mbedtls_ssl_context *,
                                       const unsigned char *,
                                       size_t);
static void ssl_calc_verify_tls_sha256(const mbedtls_ssl_context *,
                                       unsigned char *,
                                       size_t *);
static void
ssl_calc_finished_tls_sha256(mbedtls_ssl_context *, unsigned char *, int);
#        endif

#        if defined(MBEDTLS_SHA384_C)
static void ssl_update_checksum_sha384(mbedtls_ssl_context *,
                                       const unsigned char *,
                                       size_t);
static void ssl_calc_verify_tls_sha384(const mbedtls_ssl_context *,
                                       unsigned char *,
                                       size_t *);
static void
ssl_calc_finished_tls_sha384(mbedtls_ssl_context *, unsigned char *, int);
#        endif
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

#    if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED) && \
        defined(MBEDTLS_USE_PSA_CRYPTO)
static int ssl_use_opaque_psk(mbedtls_ssl_context const *ssl)
{
    if (ssl->conf->f_psk != NULL) {
        /* If we've used a callback to select the PSK,
         * the static configuration is irrelevant. */
        if (!mbedtls_svc_key_id_is_null(ssl->handshake->psk_opaque))
            return 1;

        return 0;
    }

    if (!mbedtls_svc_key_id_is_null(ssl->conf->psk_opaque))
        return 1;

    return 0;
}
#    endif /* MBEDTLS_USE_PSA_CRYPTO && \
              MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */

#    if defined(MBEDTLS_SSL_EXPORT_KEYS)
static mbedtls_tls_prf_types tls_prf_get_type(mbedtls_ssl_tls_prf_cb *tls_prf)
{
#        if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#            if defined(MBEDTLS_SHA384_C)
    if (tls_prf == tls_prf_sha384) {
        return MBEDTLS_SSL_TLS_PRF_SHA384;
    } else
#            endif
#            if defined(MBEDTLS_SHA256_C)
        if (tls_prf == tls_prf_sha256) {
        return MBEDTLS_SSL_TLS_PRF_SHA256;
    } else
#            endif
#        endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
        return MBEDTLS_SSL_TLS_PRF_NONE;
}
#    endif /* MBEDTLS_SSL_EXPORT_KEYS */

int mbedtls_ssl_tls_prf(const mbedtls_tls_prf_types prf,
                        const unsigned char *secret,
                        size_t slen,
                        const char *label,
                        const unsigned char *random,
                        size_t rlen,
                        unsigned char *dstbuf,
                        size_t dlen)
{
    mbedtls_ssl_tls_prf_cb *tls_prf = NULL;

    switch (prf) {
#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#        if defined(MBEDTLS_SHA384_C)
        case MBEDTLS_SSL_TLS_PRF_SHA384:
            tls_prf = tls_prf_sha384;
            break;
#        endif /* MBEDTLS_SHA384_C */
#        if defined(MBEDTLS_SHA256_C)
        case MBEDTLS_SSL_TLS_PRF_SHA256:
            tls_prf = tls_prf_sha256;
            break;
#        endif /* MBEDTLS_SHA256_C */
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
        default:
            return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
    }

    return tls_prf(secret, slen, label, random, rlen, dstbuf, dlen);
}

/* Type for the TLS PRF */
typedef int ssl_tls_prf_t(const unsigned char *,
                          size_t,
                          const char *,
                          const unsigned char *,
                          size_t,
                          unsigned char *,
                          size_t);

/*
 * Populate a transform structure with session keys and all the other
 * necessary information.
 *
 * Parameters:
 * - [in/out]: transform: structure to populate
 *      [in] must be just initialised with mbedtls_ssl_transform_init()
 *      [out] fully populated, ready for use by mbedtls_ssl_{en,de}crypt_buf()
 * - [in] ciphersuite
 * - [in] master
 * - [in] encrypt_then_mac
 * - [in] compression
 * - [in] tls_prf: pointer to PRF to use for key derivation
 * - [in] randbytes: buffer holding ServerHello.random + ClientHello.random
 * - [in] minor_ver: SSL/TLS minor version
 * - [in] endpoint: client or server
 * - [in] ssl: optionally used for:
 *        - MBEDTLS_SSL_EXPORT_KEYS: ssl->conf->{f,p}_export_keys
 *        - MBEDTLS_DEBUG_C: ssl->conf->{f,p}_dbg
 */
static int ssl_populate_transform(mbedtls_ssl_transform *transform,
                                  int ciphersuite,
                                  const unsigned char master[48],
#    if defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
#        if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
                                  int encrypt_then_mac,
#        endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
#    endif /* MBEDTLS_SSL_SOME_SUITES_USE_MAC */
                                  ssl_tls_prf_t tls_prf,
                                  const unsigned char randbytes[64],
                                  int minor_ver,
                                  unsigned endpoint,
                                  const mbedtls_ssl_context *ssl)
{
    int ret = 0;
#    if defined(MBEDTLS_USE_PSA_CRYPTO)
    int psa_fallthrough;
#    endif /* MBEDTLS_USE_PSA_CRYPTO */
    unsigned char keyblk[256];
    unsigned char *key1;
    unsigned char *key2;
    unsigned char *mac_enc;
    unsigned char *mac_dec;
    size_t mac_key_len = 0;
    size_t iv_copy_len;
    unsigned keylen;
    const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
    const mbedtls_cipher_info_t *cipher_info;
    const mbedtls_md_info_t *md_info;

#    if !defined(MBEDTLS_SSL_EXPORT_KEYS) && !defined(MBEDTLS_DEBUG_C)
    ssl = NULL; /* make sure we don't use it except for those cases */
    (void)ssl;
#    endif

    /*
     * Some data just needs copying into the structure
     */
#    if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC) && \
        defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
    transform->encrypt_then_mac = encrypt_then_mac;
#    endif
    transform->minor_ver = minor_ver;

#    if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
    memcpy(transform->randbytes, randbytes, sizeof(transform->randbytes));
#    endif

    /*
     * Get various info structures
     */
    ciphersuite_info = mbedtls_ssl_ciphersuite_from_id(ciphersuite);
    if (ciphersuite_info == NULL) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("ciphersuite info for %d not found",
                                  ciphersuite));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    cipher_info = mbedtls_cipher_info_from_type(ciphersuite_info->cipher);
    if (cipher_info == NULL) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("cipher info for %u not found",
                                  ciphersuite_info->cipher));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    md_info = mbedtls_md_info_from_type(ciphersuite_info->mac);
    if (md_info == NULL) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("mbedtls_md info for %u not found",
                                  (unsigned)ciphersuite_info->mac));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

#    if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
    /* Copy own and peer's CID if the use of the CID
     * extension has been negotiated. */
    if (ssl->handshake->cid_in_use == MBEDTLS_SSL_CID_ENABLED) {
        MBEDTLS_SSL_DEBUG_MSG(3, ("Copy CIDs into SSL transform"));

        transform->in_cid_len = ssl->own_cid_len;
        memcpy(transform->in_cid, ssl->own_cid, ssl->own_cid_len);
        MBEDTLS_SSL_DEBUG_BUF(3, "Incoming CID", transform->in_cid,
                              transform->in_cid_len);

        transform->out_cid_len = ssl->handshake->peer_cid_len;
        memcpy(transform->out_cid, ssl->handshake->peer_cid,
               ssl->handshake->peer_cid_len);
        MBEDTLS_SSL_DEBUG_BUF(3, "Outgoing CID", transform->out_cid,
                              transform->out_cid_len);
    }
#    endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */

    /*
     * Compute key block using the PRF
     */
    ret = tls_prf(master, 48, "key expansion", randbytes, 64, keyblk, 256);
    if (ret != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "prf", ret);
        return ret;
    }

    MBEDTLS_SSL_DEBUG_MSG(3, ("ciphersuite = %s",
                              mbedtls_ssl_get_ciphersuite_name(ciphersuite)));
    MBEDTLS_SSL_DEBUG_BUF(3, "master secret", master, 48);
    MBEDTLS_SSL_DEBUG_BUF(4, "random bytes", randbytes, 64);
    MBEDTLS_SSL_DEBUG_BUF(4, "key block", keyblk, 256);

    /*
     * Determine the appropriate key, IV and MAC length.
     */

    keylen = cipher_info->key_bitlen / 8;

#    if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CCM_C) || \
        defined(MBEDTLS_CHACHAPOLY_C)
    if (cipher_info->mode == MBEDTLS_MODE_GCM ||
        cipher_info->mode == MBEDTLS_MODE_CCM ||
        cipher_info->mode == MBEDTLS_MODE_CHACHAPOLY) {
        size_t explicit_ivlen;

        transform->maclen = 0;
        mac_key_len = 0;
        transform->taglen =
            ciphersuite_info->flags & MBEDTLS_CIPHERSUITE_SHORT_TAG ? 8 : 16;

        /* All modes haves 96-bit IVs, but the length of the static parts vary
         * with mode and version:
         * - For GCM and CCM in TLS 1.2, there's a static IV of 4 Bytes
         *   (to be concatenated with a dynamically chosen IV of 8 Bytes)
         * - For ChaChaPoly in TLS 1.2, and all modes in TLS 1.3, there's
         *   a static IV of 12 Bytes (to be XOR'ed with the 8 Byte record
         *   sequence number).
         */
        transform->ivlen = 12;
#        if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
        if (minor_ver == MBEDTLS_SSL_MINOR_VERSION_4) {
            transform->fixed_ivlen = 12;
        } else
#        endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
        {
            if (cipher_info->mode == MBEDTLS_MODE_CHACHAPOLY)
                transform->fixed_ivlen = 12;
            else
                transform->fixed_ivlen = 4;
        }

        /* Minimum length of encrypted record */
        explicit_ivlen = transform->ivlen - transform->fixed_ivlen;
        transform->minlen = explicit_ivlen + transform->taglen;
    } else
#    endif /* MBEDTLS_GCM_C || MBEDTLS_CCM_C || MBEDTLS_CHACHAPOLY_C */
#    if defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
        if (cipher_info->mode == MBEDTLS_MODE_STREAM ||
            cipher_info->mode == MBEDTLS_MODE_CBC) {
        /* Initialize HMAC contexts */
        if ((ret = mbedtls_md_setup(&transform->md_ctx_enc, md_info, 1)) != 0 ||
            (ret = mbedtls_md_setup(&transform->md_ctx_dec, md_info, 1)) != 0) {
            MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_setup", ret);
            goto end;
        }

        /* Get MAC length */
        mac_key_len = mbedtls_md_get_size(md_info);
        transform->maclen = mac_key_len;

        /* IV length */
        transform->ivlen = cipher_info->iv_size;

        /* Minimum length */
        if (cipher_info->mode == MBEDTLS_MODE_STREAM)
            transform->minlen = transform->maclen;
        else {
            /*
             * GenericBlockCipher:
             * 1. if EtM is in use: one block plus MAC
             *    otherwise: * first multiple of blocklen greater than maclen
             * 2. IV
             */
#        if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
            if (encrypt_then_mac == MBEDTLS_SSL_ETM_ENABLED) {
                transform->minlen = transform->maclen + cipher_info->block_size;
            } else
#        endif
            {
                transform->minlen = transform->maclen +
                                    cipher_info->block_size -
                                    transform->maclen % cipher_info->block_size;
            }

#        if defined(MBEDTLS_SSL_PROTO_TLS1_2)
            if (minor_ver == MBEDTLS_SSL_MINOR_VERSION_3) {
                transform->minlen += transform->ivlen;
            } else
#        endif
            {
                MBEDTLS_SSL_DEBUG_MSG(1, ("should never happen"));
                ret = MBEDTLS_ERR_SSL_INTERNAL_ERROR;
                goto end;
            }
        }
    } else
#    endif /* MBEDTLS_SSL_SOME_SUITES_USE_MAC */
    {
        MBEDTLS_SSL_DEBUG_MSG(1, ("should never happen"));
        return MBEDTLS_ERR_SSL_INTERNAL_ERROR;
    }

    MBEDTLS_SSL_DEBUG_MSG(3, ("keylen: %u, minlen: %u, ivlen: %u, maclen: %u",
                              (unsigned)keylen, (unsigned)transform->minlen,
                              (unsigned)transform->ivlen,
                              (unsigned)transform->maclen));

    /*
     * Finally setup the cipher contexts, IVs and MAC secrets.
     */
#    if defined(MBEDTLS_SSL_CLI_C)
    if (endpoint == MBEDTLS_SSL_IS_CLIENT) {
        key1 = keyblk + mac_key_len * 2;
        key2 = keyblk + mac_key_len * 2 + keylen;

        mac_enc = keyblk;
        mac_dec = keyblk + mac_key_len;

        /*
         * This is not used in TLS v1.1.
         */
        iv_copy_len = (transform->fixed_ivlen) ? transform->fixed_ivlen :
                                                 transform->ivlen;
        memcpy(transform->iv_enc, key2 + keylen, iv_copy_len);
        memcpy(transform->iv_dec, key2 + keylen + iv_copy_len, iv_copy_len);
    } else
#    endif /* MBEDTLS_SSL_CLI_C */
#    if defined(MBEDTLS_SSL_SRV_C)
        if (endpoint == MBEDTLS_SSL_IS_SERVER) {
        key1 = keyblk + mac_key_len * 2 + keylen;
        key2 = keyblk + mac_key_len * 2;

        mac_enc = keyblk + mac_key_len;
        mac_dec = keyblk;

        /*
         * This is not used in TLS v1.1.
         */
        iv_copy_len = (transform->fixed_ivlen) ? transform->fixed_ivlen :
                                                 transform->ivlen;
        memcpy(transform->iv_dec, key1 + keylen, iv_copy_len);
        memcpy(transform->iv_enc, key1 + keylen + iv_copy_len, iv_copy_len);
    } else
#    endif /* MBEDTLS_SSL_SRV_C */
    {
        MBEDTLS_SSL_DEBUG_MSG(1, ("should never happen"));
        ret = MBEDTLS_ERR_SSL_INTERNAL_ERROR;
        goto end;
    }

#    if defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
#        if defined(MBEDTLS_SSL_PROTO_TLS1_2)
    /* For HMAC-based ciphersuites, initialize the HMAC transforms.
       For AEAD-based ciphersuites, there is nothing to do here. */
    if (mac_key_len != 0) {
        mbedtls_md_hmac_starts(&transform->md_ctx_enc, mac_enc, mac_key_len);
        mbedtls_md_hmac_starts(&transform->md_ctx_dec, mac_dec, mac_key_len);
    }
#        endif
#    endif /* MBEDTLS_SSL_SOME_SUITES_USE_MAC */

    ((void)mac_dec);
    ((void)mac_enc);

#    if defined(MBEDTLS_SSL_EXPORT_KEYS)
    if (ssl->f_export_keys != NULL) {
        ssl->f_export_keys(ssl->p_export_keys,
                           MBEDTLS_SSL_KEY_EXPORT_TLS12_MASTER_SECRET, master,
                           48, randbytes + 32, randbytes,
                           tls_prf_get_type(tls_prf));
    }
#    endif

#    if defined(MBEDTLS_USE_PSA_CRYPTO)

    /* Only use PSA-based ciphers for TLS-1.2.
     * That's relevant at least for TLS-1.0, where
     * we assume that mbedtls_cipher_crypt() updates
     * the structure field for the IV, which the PSA-based
     * implementation currently doesn't. */
#        if defined(MBEDTLS_SSL_PROTO_TLS1_2)
    if (ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3) {
        ret = mbedtls_cipher_setup_psa(&transform->cipher_ctx_enc, cipher_info,
                                       transform->taglen);
        if (ret != 0 && ret != MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE) {
            MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_setup_psa", ret);
            goto end;
        }

        if (ret == 0) {
            MBEDTLS_SSL_DEBUG_MSG(
                3, ("Successfully setup PSA-based encryption cipher context"));
            psa_fallthrough = 0;
        } else {
            MBEDTLS_SSL_DEBUG_MSG(
                1,
                ("Failed to setup PSA-based cipher context for record encryption - fall through to default setup."));
            psa_fallthrough = 1;
        }
    } else
        psa_fallthrough = 1;
#        else
    psa_fallthrough = 1;
#        endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

    if (psa_fallthrough == 1)
#    endif /* MBEDTLS_USE_PSA_CRYPTO */
        if ((ret = mbedtls_cipher_setup(&transform->cipher_ctx_enc,
                                        cipher_info)) != 0) {
            MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_setup", ret);
            goto end;
        }

#    if defined(MBEDTLS_USE_PSA_CRYPTO)
        /* Only use PSA-based ciphers for TLS-1.2.
         * That's relevant at least for TLS-1.0, where
         * we assume that mbedtls_cipher_crypt() updates
         * the structure field for the IV, which the PSA-based
         * implementation currently doesn't. */
#        if defined(MBEDTLS_SSL_PROTO_TLS1_2)
    if (ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3) {
        ret = mbedtls_cipher_setup_psa(&transform->cipher_ctx_dec, cipher_info,
                                       transform->taglen);
        if (ret != 0 && ret != MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE) {
            MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_setup_psa", ret);
            goto end;
        }

        if (ret == 0) {
            MBEDTLS_SSL_DEBUG_MSG(
                3, ("Successfully setup PSA-based decryption cipher context"));
            psa_fallthrough = 0;
        } else {
            MBEDTLS_SSL_DEBUG_MSG(
                1,
                ("Failed to setup PSA-based cipher context for record decryption - fall through to default setup."));
            psa_fallthrough = 1;
        }
    } else
        psa_fallthrough = 1;
#        else
    psa_fallthrough = 1;
#        endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

    if (psa_fallthrough == 1)
#    endif /* MBEDTLS_USE_PSA_CRYPTO */
        if ((ret = mbedtls_cipher_setup(&transform->cipher_ctx_dec,
                                        cipher_info)) != 0) {
            MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_setup", ret);
            goto end;
        }

    if ((ret = mbedtls_cipher_setkey(&transform->cipher_ctx_enc, key1,
                                     cipher_info->key_bitlen,
                                     MBEDTLS_ENCRYPT)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_setkey", ret);
        goto end;
    }

    if ((ret = mbedtls_cipher_setkey(&transform->cipher_ctx_dec, key2,
                                     cipher_info->key_bitlen,
                                     MBEDTLS_DECRYPT)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_setkey", ret);
        goto end;
    }

#    if defined(MBEDTLS_CIPHER_MODE_CBC)
    if (cipher_info->mode == MBEDTLS_MODE_CBC) {
        if ((ret = mbedtls_cipher_set_padding_mode(
                 &transform->cipher_ctx_enc, MBEDTLS_PADDING_NONE)) != 0) {
            MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_set_padding_mode", ret);
            goto end;
        }

        if ((ret = mbedtls_cipher_set_padding_mode(
                 &transform->cipher_ctx_dec, MBEDTLS_PADDING_NONE)) != 0) {
            MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_set_padding_mode", ret);
            goto end;
        }
    }
#    endif /* MBEDTLS_CIPHER_MODE_CBC */

end:
    mbedtls_platform_zeroize(keyblk, sizeof(keyblk));
    return ret;
}

/*
 * Set appropriate PRF function and other SSL / TLS1.2 functions
 *
 * Inputs:
 * - SSL/TLS minor version
 * - hash associated with the ciphersuite (only used by TLS 1.2)
 *
 * Outputs:
 * - the tls_prf, calc_verify and calc_finished members of handshake structure
 */
static int ssl_set_handshake_prfs(mbedtls_ssl_handshake_params *handshake,
                                  int minor_ver,
                                  mbedtls_md_type_t hash)
{
#    if !defined(MBEDTLS_SSL_PROTO_TLS1_2) || !defined(MBEDTLS_SHA384_C)
    (void)hash;
#    endif

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#        if defined(MBEDTLS_SHA384_C)
    if (minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 && hash == MBEDTLS_MD_SHA384) {
        handshake->tls_prf = tls_prf_sha384;
        handshake->calc_verify = ssl_calc_verify_tls_sha384;
        handshake->calc_finished = ssl_calc_finished_tls_sha384;
    } else
#        endif
#        if defined(MBEDTLS_SHA256_C)
        if (minor_ver == MBEDTLS_SSL_MINOR_VERSION_3) {
        handshake->tls_prf = tls_prf_sha256;
        handshake->calc_verify = ssl_calc_verify_tls_sha256;
        handshake->calc_finished = ssl_calc_finished_tls_sha256;
    } else
#        endif
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
    {
        return MBEDTLS_ERR_SSL_INTERNAL_ERROR;
    }

    return 0;
}

/*
 * Compute master secret if needed
 *
 * Parameters:
 * [in/out] handshake
 *          [in] resume, premaster, extended_ms, calc_verify, tls_prf
 *               (PSA-PSK) ciphersuite_info, psk_opaque
 *          [out] premaster (cleared)
 * [out] master
 * [in] ssl: optionally used for debugging, EMS and PSA-PSK
 *      debug: conf->f_dbg, conf->p_dbg
 *      EMS: passed to calc_verify (debug + session_negotiate)
 *      PSA-PSA: minor_ver, conf
 */
static int ssl_compute_master(mbedtls_ssl_handshake_params *handshake,
                              unsigned char *master,
                              const mbedtls_ssl_context *ssl)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

    /* cf. RFC 5246, Section 8.1:
     * "The master secret is always exactly 48 bytes in length." */
    size_t const master_secret_len = 48;

#    if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
    unsigned char session_hash[48];
#    endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */

    /* The label for the KDF used for key expansion.
     * This is either "master secret" or "extended master secret"
     * depending on whether the Extended Master Secret extension
     * is used. */
    char const *lbl = "master secret";

    /* The salt for the KDF used for key expansion.
     * - If the Extended Master Secret extension is not used,
     *   this is ClientHello.Random + ServerHello.Random
     *   (see Sect. 8.1 in RFC 5246).
     * - If the Extended Master Secret extension is used,
     *   this is the transcript of the handshake so far.
     *   (see Sect. 4 in RFC 7627). */
    unsigned char const *salt = handshake->randbytes;
    size_t salt_len = 64;

#    if !defined(MBEDTLS_DEBUG_C) &&                    \
        !defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET) && \
        !(defined(MBEDTLS_USE_PSA_CRYPTO) &&            \
          defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED))
    ssl = NULL; /* make sure we don't use it except for those cases */
    (void)ssl;
#    endif

    if (handshake->resume != 0) {
        MBEDTLS_SSL_DEBUG_MSG(3, ("no premaster (session resumed)"));
        return 0;
    }

#    if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
    if (handshake->extended_ms == MBEDTLS_SSL_EXTENDED_MS_ENABLED) {
        lbl = "extended master secret";
        salt = session_hash;
        handshake->calc_verify(ssl, session_hash, &salt_len);

        MBEDTLS_SSL_DEBUG_BUF(3, "session hash for extended master secret",
                              session_hash, salt_len);
    }
#    endif /* MBEDTLS_SSL_EXTENDED_MS_ENABLED */

#    if defined(MBEDTLS_USE_PSA_CRYPTO) && \
        defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
    if (handshake->ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK &&
        ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 &&
        ssl_use_opaque_psk(ssl) == 1) {
        /* Perform PSK-to-MS expansion in a single step. */
        psa_status_t status;
        psa_algorithm_t alg;
        psa_key_id_t psk;
        psa_key_derivation_operation_t derivation =
            PSA_KEY_DERIVATION_OPERATION_INIT;
        mbedtls_md_type_t hash_alg = handshake->ciphersuite_info->mac;

        MBEDTLS_SSL_DEBUG_MSG(2, ("perform PSA-based PSK-to-MS expansion"));

        psk = mbedtls_ssl_get_opaque_psk(ssl);

        if (hash_alg == MBEDTLS_MD_SHA384)
            alg = PSA_ALG_TLS12_PSK_TO_MS(PSA_ALG_SHA_384);
        else
            alg = PSA_ALG_TLS12_PSK_TO_MS(PSA_ALG_SHA_256);

        status = setup_psa_key_derivation(&derivation, psk, alg, salt, salt_len,
                                          (unsigned char const *)lbl,
                                          (size_t)strlen(lbl),
                                          master_secret_len);
        if (status != PSA_SUCCESS) {
            psa_key_derivation_abort(&derivation);
            return MBEDTLS_ERR_SSL_HW_ACCEL_FAILED;
        }

        status = psa_key_derivation_output_bytes(&derivation, master,
                                                 master_secret_len);
        if (status != PSA_SUCCESS) {
            psa_key_derivation_abort(&derivation);
            return MBEDTLS_ERR_SSL_HW_ACCEL_FAILED;
        }

        status = psa_key_derivation_abort(&derivation);
        if (status != PSA_SUCCESS)
            return MBEDTLS_ERR_SSL_HW_ACCEL_FAILED;
    } else
#    endif
    {
        ret = handshake->tls_prf(handshake->premaster, handshake->pmslen, lbl,
                                 salt, salt_len, master, master_secret_len);
        if (ret != 0) {
            MBEDTLS_SSL_DEBUG_RET(1, "prf", ret);
            return ret;
        }

        MBEDTLS_SSL_DEBUG_BUF(3, "premaster secret", handshake->premaster,
                              handshake->pmslen);

        mbedtls_platform_zeroize(handshake->premaster,
                                 sizeof(handshake->premaster));
    }

    return 0;
}

int mbedtls_ssl_derive_keys(mbedtls_ssl_context *ssl)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    const mbedtls_ssl_ciphersuite_t *const ciphersuite_info =
        ssl->handshake->ciphersuite_info;

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> derive keys"));

    /* Set PRF, calc_verify and calc_finished function pointers */
    ret = ssl_set_handshake_prfs(ssl->handshake, ssl->minor_ver,
                                 ciphersuite_info->mac);
    if (ret != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "ssl_set_handshake_prfs", ret);
        return ret;
    }

    /* Compute master secret if needed */
    ret =
        ssl_compute_master(ssl->handshake, ssl->session_negotiate->master, ssl);
    if (ret != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "ssl_compute_master", ret);
        return ret;
    }

    /* Swap the client and server random values:
     * - MS derivation wanted client+server (RFC 5246 8.1)
     * - key derivation wants server+client (RFC 5246 6.3) */
    {
        unsigned char tmp[64];
        memcpy(tmp, ssl->handshake->randbytes, 64);
        memcpy(ssl->handshake->randbytes, tmp + 32, 32);
        memcpy(ssl->handshake->randbytes + 32, tmp, 32);
        mbedtls_platform_zeroize(tmp, sizeof(tmp));
    }

    /* Populate transform structure */
    ret = ssl_populate_transform(ssl->transform_negotiate,
                                 ssl->session_negotiate->ciphersuite,
                                 ssl->session_negotiate->master,
#    if defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
#        if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
                                 ssl->session_negotiate->encrypt_then_mac,
#        endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
#    endif /* MBEDTLS_SSL_SOME_SUITES_USE_MAC */
                                 ssl->handshake->tls_prf,
                                 ssl->handshake->randbytes, ssl->minor_ver,
                                 ssl->conf->endpoint, ssl);
    if (ret != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "ssl_populate_transform", ret);
        return ret;
    }

    /* We no longer need Server/ClientHello.random values */
    mbedtls_platform_zeroize(ssl->handshake->randbytes,
                             sizeof(ssl->handshake->randbytes));

    MBEDTLS_SSL_DEBUG_MSG(2, ("<= derive keys"));

    return 0;
}

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#        if defined(MBEDTLS_SHA256_C)
void ssl_calc_verify_tls_sha256(const mbedtls_ssl_context *ssl,
                                unsigned char *hash,
                                size_t *hlen)
{
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    size_t hash_size;
    psa_status_t status;
    psa_hash_operation_t sha256_psa = psa_hash_operation_init();

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> PSA calc verify sha256"));
    status = psa_hash_clone(&ssl->handshake->fin_sha256_psa, &sha256_psa);
    if (status != PSA_SUCCESS) {
        MBEDTLS_SSL_DEBUG_MSG(2, ("PSA hash clone failed"));
        return;
    }

    status = psa_hash_finish(&sha256_psa, hash, 32, &hash_size);
    if (status != PSA_SUCCESS) {
        MBEDTLS_SSL_DEBUG_MSG(2, ("PSA hash finish failed"));
        return;
    }

    *hlen = 32;
    MBEDTLS_SSL_DEBUG_BUF(3, "PSA calculated verify result", hash, *hlen);
    MBEDTLS_SSL_DEBUG_MSG(2, ("<= PSA calc verify"));
#            else
    mbedtls_sha256_context sha256;

    mbedtls_sha256_init(&sha256);

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> calc verify sha256"));

    mbedtls_sha256_clone(&sha256, &ssl->handshake->fin_sha256);
    mbedtls_sha256_finish(&sha256, hash);

    *hlen = 32;

    MBEDTLS_SSL_DEBUG_BUF(3, "calculated verify result", hash, *hlen);
    MBEDTLS_SSL_DEBUG_MSG(2, ("<= calc verify"));

    mbedtls_sha256_free(&sha256);
#            endif /* MBEDTLS_USE_PSA_CRYPTO */
    return;
}
#        endif /* MBEDTLS_SHA256_C */

#        if defined(MBEDTLS_SHA384_C)
void ssl_calc_verify_tls_sha384(const mbedtls_ssl_context *ssl,
                                unsigned char *hash,
                                size_t *hlen)
{
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    size_t hash_size;
    psa_status_t status;
    psa_hash_operation_t sha384_psa = psa_hash_operation_init();

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> PSA calc verify sha384"));
    status = psa_hash_clone(&ssl->handshake->fin_sha384_psa, &sha384_psa);
    if (status != PSA_SUCCESS) {
        MBEDTLS_SSL_DEBUG_MSG(2, ("PSA hash clone failed"));
        return;
    }

    status = psa_hash_finish(&sha384_psa, hash, 48, &hash_size);
    if (status != PSA_SUCCESS) {
        MBEDTLS_SSL_DEBUG_MSG(2, ("PSA hash finish failed"));
        return;
    }

    *hlen = 48;
    MBEDTLS_SSL_DEBUG_BUF(3, "PSA calculated verify result", hash, *hlen);
    MBEDTLS_SSL_DEBUG_MSG(2, ("<= PSA calc verify"));
#            else
    mbedtls_sha512_context sha512;

    mbedtls_sha512_init(&sha512);

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> calc verify sha384"));

    mbedtls_sha512_clone(&sha512, &ssl->handshake->fin_sha512);
    mbedtls_sha512_finish(&sha512, hash);

    *hlen = 48;

    MBEDTLS_SSL_DEBUG_BUF(3, "calculated verify result", hash, *hlen);
    MBEDTLS_SSL_DEBUG_MSG(2, ("<= calc verify"));

    mbedtls_sha512_free(&sha512);
#            endif /* MBEDTLS_USE_PSA_CRYPTO */
    return;
}
#        endif /* MBEDTLS_SHA384_C */
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

#    if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
int mbedtls_ssl_psk_derive_premaster(mbedtls_ssl_context *ssl,
                                     mbedtls_key_exchange_type_t key_ex)
{
    unsigned char *p = ssl->handshake->premaster;
    unsigned char *end = p + sizeof(ssl->handshake->premaster);
    const unsigned char *psk = NULL;
    size_t psk_len = 0;

    if (mbedtls_ssl_get_psk(ssl, &psk, &psk_len) ==
        MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED) {
        /*
         * This should never happen because the existence of a PSK is always
         * checked before calling this function
         */
        MBEDTLS_SSL_DEBUG_MSG(1, ("should never happen"));
        return MBEDTLS_ERR_SSL_INTERNAL_ERROR;
    }

    /*
     * PMS = struct {
     *     opaque other_secret<0..2^16-1>;
     *     opaque psk<0..2^16-1>;
     * };
     * with "other_secret" depending on the particular key exchange
     */
#        if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
    if (key_ex == MBEDTLS_KEY_EXCHANGE_PSK) {
        if (end - p < 2)
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

        *(p++) = (unsigned char)(psk_len >> 8);
        *(p++) = (unsigned char)(psk_len);

        if (end < p || (size_t)(end - p) < psk_len)
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

        memset(p, 0, psk_len);
        p += psk_len;
    } else
#        endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
#        if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
        if (key_ex == MBEDTLS_KEY_EXCHANGE_RSA_PSK) {
        /*
         * other_secret already set by the ClientKeyExchange message,
         * and is 48 bytes long
         */
        if (end - p < 2)
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

        *p++ = 0;
        *p++ = 48;
        p += 48;
    } else
#        endif /* MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
#        if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
        if (key_ex == MBEDTLS_KEY_EXCHANGE_DHE_PSK) {
        int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
        size_t len;

        /* Write length only when we know the actual value */
        if ((ret = mbedtls_dhm_calc_secret(
                 &ssl->handshake->dhm_ctx, p + 2, end - (p + 2), &len,
                 ssl->conf->f_rng, ssl->conf->p_rng)) != 0) {
            MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_dhm_calc_secret", ret);
            return ret;
        }
        *(p++) = (unsigned char)(len >> 8);
        *(p++) = (unsigned char)(len);
        p += len;

        MBEDTLS_SSL_DEBUG_MPI(3, "DHM: K ", &ssl->handshake->dhm_ctx.K);
    } else
#        endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
#        if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
        if (key_ex == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK) {
        int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
        size_t zlen;

        if ((ret = mbedtls_ecdh_calc_secret(
                 &ssl->handshake->ecdh_ctx, &zlen, p + 2, end - (p + 2),
                 ssl->conf->f_rng, ssl->conf->p_rng)) != 0) {
            MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ecdh_calc_secret", ret);
            return ret;
        }

        *(p++) = (unsigned char)(zlen >> 8);
        *(p++) = (unsigned char)(zlen);
        p += zlen;

        MBEDTLS_SSL_DEBUG_ECDH(3, &ssl->handshake->ecdh_ctx,
                               MBEDTLS_DEBUG_ECDH_Z);
    } else
#        endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
    {
        MBEDTLS_SSL_DEBUG_MSG(1, ("should never happen"));
        return MBEDTLS_ERR_SSL_INTERNAL_ERROR;
    }

    /* opaque psk<0..2^16-1>; */
    if (end - p < 2)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    *(p++) = (unsigned char)(psk_len >> 8);
    *(p++) = (unsigned char)(psk_len);

    if (end < p || (size_t)(end - p) < psk_len)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    memcpy(p, psk, psk_len);
    p += psk_len;

    ssl->handshake->pmslen = p - ssl->handshake->premaster;

    return 0;
}
#    endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */

#    if defined(MBEDTLS_SSL_SRV_C) && defined(MBEDTLS_SSL_RENEGOTIATION)
static int ssl_write_hello_request(mbedtls_ssl_context *ssl);

#        if defined(MBEDTLS_SSL_PROTO_DTLS)
int mbedtls_ssl_resend_hello_request(mbedtls_ssl_context *ssl)
{
    /* If renegotiation is not enforced, retransmit until we would reach max
     * timeout if we were using the usual handshake doubling scheme */
    if (ssl->conf->renego_max_records < 0) {
        uint32_t ratio =
            ssl->conf->hs_timeout_max / ssl->conf->hs_timeout_min + 1;
        unsigned char doublings = 1;

        while (ratio != 0) {
            ++doublings;
            ratio >>= 1;
        }

        if (++ssl->renego_records_seen > doublings) {
            MBEDTLS_SSL_DEBUG_MSG(2,
                                  ("no longer retransmitting hello request"));
            return 0;
        }
    }

    return ssl_write_hello_request(ssl);
}
#        endif
#    endif /* MBEDTLS_SSL_SRV_C && MBEDTLS_SSL_RENEGOTIATION */

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
static void ssl_clear_peer_cert(mbedtls_ssl_session *session)
{
#        if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
    if (session->peer_cert != NULL) {
        mbedtls_x509_crt_free(session->peer_cert);
        mbedtls_free(session->peer_cert);
        session->peer_cert = NULL;
    }
#        else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
    if (session->peer_cert_digest != NULL) {
        /* Zeroization is not necessary. */
        mbedtls_free(session->peer_cert_digest);
        session->peer_cert_digest = NULL;
        session->peer_cert_digest_type = MBEDTLS_MD_NONE;
        session->peer_cert_digest_len = 0;
    }
#        endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
}
#    endif /* MBEDTLS_X509_CRT_PARSE_C */

/*
 * Handshake functions
 */
#    if !defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
/* No certificate support -> dummy functions */
int mbedtls_ssl_write_certificate(mbedtls_ssl_context *ssl)
{
    const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
        ssl->handshake->ciphersuite_info;

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> write certificate"));

    if (!mbedtls_ssl_ciphersuite_uses_srv_cert(ciphersuite_info)) {
        MBEDTLS_SSL_DEBUG_MSG(2, ("<= skip write certificate"));
        ssl->state++;
        return 0;
    }

    MBEDTLS_SSL_DEBUG_MSG(1, ("should never happen"));
    return MBEDTLS_ERR_SSL_INTERNAL_ERROR;
}

int mbedtls_ssl_parse_certificate(mbedtls_ssl_context *ssl)
{
    const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
        ssl->handshake->ciphersuite_info;

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> parse certificate"));

    if (!mbedtls_ssl_ciphersuite_uses_srv_cert(ciphersuite_info)) {
        MBEDTLS_SSL_DEBUG_MSG(2, ("<= skip parse certificate"));
        ssl->state++;
        return 0;
    }

    MBEDTLS_SSL_DEBUG_MSG(1, ("should never happen"));
    return MBEDTLS_ERR_SSL_INTERNAL_ERROR;
}

#    else /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */
/* Some certificate support -> implement write and parse */

int mbedtls_ssl_write_certificate(mbedtls_ssl_context *ssl)
{
    int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
    size_t i, n;
    const mbedtls_x509_crt *crt;
    const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
        ssl->handshake->ciphersuite_info;

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> write certificate"));

    if (!mbedtls_ssl_ciphersuite_uses_srv_cert(ciphersuite_info)) {
        MBEDTLS_SSL_DEBUG_MSG(2, ("<= skip write certificate"));
        ssl->state++;
        return 0;
    }

#        if defined(MBEDTLS_SSL_CLI_C)
    if (ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT) {
        if (ssl->client_auth == 0) {
            MBEDTLS_SSL_DEBUG_MSG(2, ("<= skip write certificate"));
            ssl->state++;
            return 0;
        }
    }
#        endif /* MBEDTLS_SSL_CLI_C */
#        if defined(MBEDTLS_SSL_SRV_C)
    if (ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER) {
        if (mbedtls_ssl_own_cert(ssl) == NULL) {
            /* Should never happen because we shouldn't have picked the
             * ciphersuite if we don't have a certificate. */
            return MBEDTLS_ERR_SSL_INTERNAL_ERROR;
        }
    }
#        endif

    MBEDTLS_SSL_DEBUG_CRT(3, "own certificate", mbedtls_ssl_own_cert(ssl));

    /*
     *     0  .  0    handshake type
     *     1  .  3    handshake length
     *     4  .  6    length of all certs
     *     7  .  9    length of cert. 1
     *    10  . n-1   peer certificate
     *     n  . n+2   length of cert. 2
     *    n+3 . ...   upper level cert, etc.
     */
    i = 7;
    crt = mbedtls_ssl_own_cert(ssl);

    while (crt != NULL) {
        n = crt->raw.len;
        if (n > MBEDTLS_SSL_OUT_CONTENT_LEN - 3 - i) {
            MBEDTLS_SSL_DEBUG_MSG(
                1, ("certificate too large, %" MBEDTLS_PRINTF_SIZET
                    " > %" MBEDTLS_PRINTF_SIZET,
                    i + 3 + n, (size_t)MBEDTLS_SSL_OUT_CONTENT_LEN));
            return MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL;
        }

        ssl->out_msg[i] = (unsigned char)(n >> 16);
        ssl->out_msg[i + 1] = (unsigned char)(n >> 8);
        ssl->out_msg[i + 2] = (unsigned char)(n);

        i += 3;
        memcpy(ssl->out_msg + i, crt->raw.p, n);
        i += n;
        crt = crt->next;
    }

    ssl->out_msg[4] = (unsigned char)((i - 7) >> 16);
    ssl->out_msg[5] = (unsigned char)((i - 7) >> 8);
    ssl->out_msg[6] = (unsigned char)((i - 7));

    ssl->out_msglen = i;
    ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
    ssl->out_msg[0] = MBEDTLS_SSL_HS_CERTIFICATE;

    ssl->state++;

    if ((ret = mbedtls_ssl_write_handshake_msg(ssl)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_handshake_msg", ret);
        return ret;
    }

    MBEDTLS_SSL_DEBUG_MSG(2, ("<= write certificate"));

    return ret;
}

#        if defined(MBEDTLS_SSL_RENEGOTIATION) && defined(MBEDTLS_SSL_CLI_C)

#            if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
static int ssl_check_peer_crt_unchanged(mbedtls_ssl_context *ssl,
                                        unsigned char *crt_buf,
                                        size_t crt_buf_len)
{
    mbedtls_x509_crt const *const peer_crt = ssl->session->peer_cert;

    if (peer_crt == NULL)
        return -1;

    if (peer_crt->raw.len != crt_buf_len)
        return -1;

    return memcmp(peer_crt->raw.p, crt_buf, peer_crt->raw.len);
}
#            else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
static int ssl_check_peer_crt_unchanged(mbedtls_ssl_context *ssl,
                                        unsigned char *crt_buf,
                                        size_t crt_buf_len)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    unsigned char const *const peer_cert_digest =
        ssl->session->peer_cert_digest;
    mbedtls_md_type_t const peer_cert_digest_type =
        ssl->session->peer_cert_digest_type;
    mbedtls_md_info_t const *const digest_info =
        mbedtls_md_info_from_type(peer_cert_digest_type);
    unsigned char tmp_digest[MBEDTLS_SSL_PEER_CERT_DIGEST_MAX_LEN];
    size_t digest_len;

    if (peer_cert_digest == NULL || digest_info == NULL)
        return -1;

    digest_len = mbedtls_md_get_size(digest_info);
    if (digest_len > MBEDTLS_SSL_PEER_CERT_DIGEST_MAX_LEN)
        return -1;

    ret = mbedtls_md(digest_info, crt_buf, crt_buf_len, tmp_digest);
    if (ret != 0)
        return -1;

    return memcmp(tmp_digest, peer_cert_digest, digest_len);
}
#            endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
#        endif /* MBEDTLS_SSL_RENEGOTIATION && MBEDTLS_SSL_CLI_C */

/*
 * Once the certificate message is read, parse it into a cert chain and
 * perform basic checks, but leave actual verification to the caller
 */
static int ssl_parse_certificate_chain(mbedtls_ssl_context *ssl,
                                       mbedtls_x509_crt *chain)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
#        if defined(MBEDTLS_SSL_RENEGOTIATION) && defined(MBEDTLS_SSL_CLI_C)
    int crt_cnt = 0;
#        endif
    size_t i, n;
    uint8_t alert;

    if (ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("bad certificate message"));
        mbedtls_ssl_send_alert_message(
            ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
            MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE);
        return MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE;
    }

    if (ssl->in_msg[0] != MBEDTLS_SSL_HS_CERTIFICATE) {
        mbedtls_ssl_send_alert_message(
            ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
            MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE);
        return MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE;
    }

    if (ssl->in_hslen < mbedtls_ssl_hs_hdr_len(ssl) + 3 + 3) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("bad certificate message"));
        mbedtls_ssl_send_alert_message(ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                                       MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR);
        return MBEDTLS_ERR_SSL_DECODE_ERROR;
    }

    i = mbedtls_ssl_hs_hdr_len(ssl);

    /*
     * Same message structure as in mbedtls_ssl_write_certificate()
     */
    n = (ssl->in_msg[i + 1] << 8) | ssl->in_msg[i + 2];

    if (ssl->in_msg[i] != 0 ||
        ssl->in_hslen != n + 3 + mbedtls_ssl_hs_hdr_len(ssl)) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("bad certificate message"));
        mbedtls_ssl_send_alert_message(ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                                       MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR);
        return MBEDTLS_ERR_SSL_DECODE_ERROR;
    }

    /* Make &ssl->in_msg[i] point to the beginning of the CRT chain. */
    i += 3;

    /* Iterate through and parse the CRTs in the provided chain. */
    while (i < ssl->in_hslen) {
        /* Check that there's room for the next CRT's length fields. */
        if (i + 3 > ssl->in_hslen) {
            MBEDTLS_SSL_DEBUG_MSG(1, ("bad certificate message"));
            mbedtls_ssl_send_alert_message(ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                                           MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR);
            return MBEDTLS_ERR_SSL_DECODE_ERROR;
        }
        /* In theory, the CRT can be up to 2**24 Bytes, but we don't support
         * anything beyond 2**16 ~ 64K. */
        if (ssl->in_msg[i] != 0) {
            MBEDTLS_SSL_DEBUG_MSG(1, ("bad certificate message"));
            mbedtls_ssl_send_alert_message(
                ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT);
            return MBEDTLS_ERR_SSL_BAD_CERTIFICATE;
        }

        /* Read length of the next CRT in the chain. */
        n = ((unsigned int)ssl->in_msg[i + 1] << 8) |
            (unsigned int)ssl->in_msg[i + 2];
        i += 3;

        if (n < 128 || i + n > ssl->in_hslen) {
            MBEDTLS_SSL_DEBUG_MSG(1, ("bad certificate message"));
            mbedtls_ssl_send_alert_message(ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                                           MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR);
            return MBEDTLS_ERR_SSL_DECODE_ERROR;
        }

        /* Check if we're handling the first CRT in the chain. */
#        if defined(MBEDTLS_SSL_RENEGOTIATION) && defined(MBEDTLS_SSL_CLI_C)
        if (crt_cnt++ == 0 && ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT &&
            ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS) {
            /* During client-side renegotiation, check that the server's
             * end-CRTs hasn't changed compared to the initial handshake,
             * mitigating the triple handshake attack. On success, reuse
             * the original end-CRT instead of parsing it again. */
            MBEDTLS_SSL_DEBUG_MSG(
                3, ("Check that peer CRT hasn't changed during renegotiation"));
            if (ssl_check_peer_crt_unchanged(ssl, &ssl->in_msg[i], n) != 0) {
                MBEDTLS_SSL_DEBUG_MSG(1,
                                      ("new server cert during renegotiation"));
                mbedtls_ssl_send_alert_message(
                    ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                    MBEDTLS_SSL_ALERT_MSG_ACCESS_DENIED);
                return MBEDTLS_ERR_SSL_BAD_CERTIFICATE;
            }

            /* Now we can safely free the original chain. */
            ssl_clear_peer_cert(ssl->session);
        }
#        endif /* MBEDTLS_SSL_RENEGOTIATION && MBEDTLS_SSL_CLI_C */

        /* Parse the next certificate in the chain. */
#        if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
        ret = mbedtls_x509_crt_parse_der(chain, ssl->in_msg + i, n);
#        else
        /* If we don't need to store the CRT chain permanently, parse
         * it in-place from the input buffer instead of making a copy. */
        ret = mbedtls_x509_crt_parse_der_nocopy(chain, ssl->in_msg + i, n);
#        endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
        switch (ret) {
            case 0: /*ok*/
            case MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG + MBEDTLS_ERR_OID_NOT_FOUND:
                /* Ignore certificate with an unknown algorithm: maybe a
                   prior certificate was already trusted. */
                break;

            case MBEDTLS_ERR_X509_ALLOC_FAILED:
                alert = MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR;
                goto crt_parse_der_failed;

            case MBEDTLS_ERR_X509_UNKNOWN_VERSION:
                alert = MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT;
                goto crt_parse_der_failed;

            default:
                alert = MBEDTLS_SSL_ALERT_MSG_BAD_CERT;
crt_parse_der_failed:
                mbedtls_ssl_send_alert_message(
                    ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL, alert);
                MBEDTLS_SSL_DEBUG_RET(1, " mbedtls_x509_crt_parse_der", ret);
                return ret;
        }

        i += n;
    }

    MBEDTLS_SSL_DEBUG_CRT(3, "peer certificate", chain);
    return 0;
}

#        if defined(MBEDTLS_SSL_SRV_C)
static int ssl_srv_check_client_no_crt_notification(mbedtls_ssl_context *ssl)
{
    if (ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT)
        return -1;

#            if defined(MBEDTLS_SSL_PROTO_TLS1_2)
    if (ssl->in_hslen == 3 + mbedtls_ssl_hs_hdr_len(ssl) &&
        ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE &&
        ssl->in_msg[0] == MBEDTLS_SSL_HS_CERTIFICATE &&
        memcmp(ssl->in_msg + mbedtls_ssl_hs_hdr_len(ssl), "\0\0\0", 3) == 0) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("TLSv1 client has no certificate"));
        return 0;
    }

    return -1;
#            endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
}
#        endif /* MBEDTLS_SSL_SRV_C */

/* Check if a certificate message is expected.
 * Return either
 * - SSL_CERTIFICATE_EXPECTED, or
 * - SSL_CERTIFICATE_SKIP
 * indicating whether a Certificate message is expected or not.
 */
#        define SSL_CERTIFICATE_EXPECTED 0
#        define SSL_CERTIFICATE_SKIP     1
static int ssl_parse_certificate_coordinate(mbedtls_ssl_context *ssl,
                                            int authmode)
{
    const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
        ssl->handshake->ciphersuite_info;

    if (!mbedtls_ssl_ciphersuite_uses_srv_cert(ciphersuite_info))
        return SSL_CERTIFICATE_SKIP;

#        if defined(MBEDTLS_SSL_SRV_C)
    if (ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER) {
        if (ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK)
            return SSL_CERTIFICATE_SKIP;

        if (authmode == MBEDTLS_SSL_VERIFY_NONE) {
            ssl->session_negotiate->verify_result =
                MBEDTLS_X509_BADCERT_SKIP_VERIFY;
            return SSL_CERTIFICATE_SKIP;
        }
    }
#        else
    ((void)authmode);
#        endif /* MBEDTLS_SSL_SRV_C */

    return SSL_CERTIFICATE_EXPECTED;
}

static int ssl_parse_certificate_verify(mbedtls_ssl_context *ssl,
                                        int authmode,
                                        mbedtls_x509_crt *chain,
                                        void *rs_ctx)
{
    int ret = 0;
    const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
        ssl->handshake->ciphersuite_info;
    int have_ca_chain = 0;

    int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *);
    void *p_vrfy;

    if (authmode == MBEDTLS_SSL_VERIFY_NONE)
        return 0;

    if (ssl->f_vrfy != NULL) {
        MBEDTLS_SSL_DEBUG_MSG(3,
                              ("Use context-specific verification callback"));
        f_vrfy = ssl->f_vrfy;
        p_vrfy = ssl->p_vrfy;
    } else {
        MBEDTLS_SSL_DEBUG_MSG(
            3, ("Use configuration-specific verification callback"));
        f_vrfy = ssl->conf->f_vrfy;
        p_vrfy = ssl->conf->p_vrfy;
    }

    /*
     * Main check: verify certificate
     */
#        if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
    if (ssl->conf->f_ca_cb != NULL) {
        ((void)rs_ctx);
        have_ca_chain = 1;

        MBEDTLS_SSL_DEBUG_MSG(3,
                              ("use CA callback for X.509 CRT verification"));
        ret = mbedtls_x509_crt_verify_with_ca_cb(
            chain, ssl->conf->f_ca_cb, ssl->conf->p_ca_cb,
            ssl->conf->cert_profile, ssl->hostname,
            &ssl->session_negotiate->verify_result, f_vrfy, p_vrfy);
    } else
#        endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
    {
        mbedtls_x509_crt *ca_chain;
        mbedtls_x509_crl *ca_crl;

#        if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
        if (ssl->handshake->sni_ca_chain != NULL) {
            ca_chain = ssl->handshake->sni_ca_chain;
            ca_crl = ssl->handshake->sni_ca_crl;
        } else
#        endif
        {
            ca_chain = ssl->conf->ca_chain;
            ca_crl = ssl->conf->ca_crl;
        }

        if (ca_chain != NULL)
            have_ca_chain = 1;

        ret = mbedtls_x509_crt_verify_restartable(
            chain, ca_chain, ca_crl, ssl->conf->cert_profile, ssl->hostname,
            &ssl->session_negotiate->verify_result, f_vrfy, p_vrfy, rs_ctx);
    }

    if (ret != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "x509_verify_cert", ret);
    }

#        if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
    if (ret == MBEDTLS_ERR_ECP_IN_PROGRESS)
        return MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS;
#        endif

        /*
         * Secondary checks: always done, but change 'ret' only if it was 0
         */

#        if defined(MBEDTLS_ECP_C)
    {
        const mbedtls_pk_context *pk = &chain->pk;

        /* If certificate uses an EC key, make sure the curve is OK */
        if (mbedtls_pk_can_do(pk, MBEDTLS_PK_ECKEY) &&
            mbedtls_ssl_check_curve(ssl, mbedtls_pk_ec(*pk)->grp.id) != 0) {
            ssl->session_negotiate->verify_result |=
                MBEDTLS_X509_BADCERT_BAD_KEY;

            MBEDTLS_SSL_DEBUG_MSG(1, ("bad certificate (EC key curve)"));
            if (ret == 0)
                ret = MBEDTLS_ERR_SSL_BAD_CERTIFICATE;
        }
    }
#        endif /* MBEDTLS_ECP_C */

    if (mbedtls_ssl_check_cert_usage(
            chain, ciphersuite_info, !ssl->conf->endpoint,
            &ssl->session_negotiate->verify_result) != 0) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("bad certificate (usage extensions)"));
        if (ret == 0)
            ret = MBEDTLS_ERR_SSL_BAD_CERTIFICATE;
    }

    /* mbedtls_x509_crt_verify_with_profile is supposed to report a
     * verification failure through MBEDTLS_ERR_X509_CERT_VERIFY_FAILED,
     * with details encoded in the verification flags. All other kinds
     * of error codes, including those from the user provided f_vrfy
     * functions, are treated as fatal and lead to a failure of
     * ssl_parse_certificate even if verification was optional. */
    if (authmode == MBEDTLS_SSL_VERIFY_OPTIONAL &&
        (ret == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED ||
         ret == MBEDTLS_ERR_SSL_BAD_CERTIFICATE)) {
        ret = 0;
    }

    if (have_ca_chain == 0 && authmode == MBEDTLS_SSL_VERIFY_REQUIRED) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("got no CA chain"));
        ret = MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED;
    }

    if (ret != 0) {
        uint8_t alert;

        /* The certificate may have been rejected for several reasons.
           Pick one and send the corresponding alert. Which alert to send
           may be a subject of debate in some cases. */
        if (ssl->session_negotiate->verify_result & MBEDTLS_X509_BADCERT_OTHER)
            alert = MBEDTLS_SSL_ALERT_MSG_ACCESS_DENIED;
        else if (ssl->session_negotiate->verify_result &
                 MBEDTLS_X509_BADCERT_CN_MISMATCH)
            alert = MBEDTLS_SSL_ALERT_MSG_BAD_CERT;
        else if (ssl->session_negotiate->verify_result &
                 MBEDTLS_X509_BADCERT_KEY_USAGE)
            alert = MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT;
        else if (ssl->session_negotiate->verify_result &
                 MBEDTLS_X509_BADCERT_EXT_KEY_USAGE)
            alert = MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT;
        else if (ssl->session_negotiate->verify_result &
                 MBEDTLS_X509_BADCERT_NS_CERT_TYPE)
            alert = MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT;
        else if (ssl->session_negotiate->verify_result &
                 MBEDTLS_X509_BADCERT_BAD_PK)
            alert = MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT;
        else if (ssl->session_negotiate->verify_result &
                 MBEDTLS_X509_BADCERT_BAD_KEY)
            alert = MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT;
        else if (ssl->session_negotiate->verify_result &
                 MBEDTLS_X509_BADCERT_EXPIRED)
            alert = MBEDTLS_SSL_ALERT_MSG_CERT_EXPIRED;
        else if (ssl->session_negotiate->verify_result &
                 MBEDTLS_X509_BADCERT_REVOKED)
            alert = MBEDTLS_SSL_ALERT_MSG_CERT_REVOKED;
        else if (ssl->session_negotiate->verify_result &
                 MBEDTLS_X509_BADCERT_NOT_TRUSTED)
            alert = MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA;
        else
            alert = MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN;
        mbedtls_ssl_send_alert_message(ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                                       alert);
    }

#        if defined(MBEDTLS_DEBUG_C)
    if (ssl->session_negotiate->verify_result != 0) {
        MBEDTLS_SSL_DEBUG_MSG(
            3, ("! Certificate verification flags %08x",
                (unsigned int)ssl->session_negotiate->verify_result));
    } else {
        MBEDTLS_SSL_DEBUG_MSG(3, ("Certificate verification flags clear"));
    }
#        endif /* MBEDTLS_DEBUG_C */

    return ret;
}

#        if !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
static int ssl_remember_peer_crt_digest(mbedtls_ssl_context *ssl,
                                        unsigned char *start,
                                        size_t len)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    /* Remember digest of the peer's end-CRT. */
    ssl->session_negotiate->peer_cert_digest =
        mbedtls_calloc(1, MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN);
    if (ssl->session_negotiate->peer_cert_digest == NULL) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("alloc(%d bytes) failed",
                                  MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN));
        mbedtls_ssl_send_alert_message(ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                                       MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR);

        return MBEDTLS_ERR_SSL_ALLOC_FAILED;
    }

    ret = mbedtls_md(
        mbedtls_md_info_from_type(MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE), start,
        len, ssl->session_negotiate->peer_cert_digest);

    ssl->session_negotiate->peer_cert_digest_type =
        MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE;
    ssl->session_negotiate->peer_cert_digest_len =
        MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN;

    return ret;
}

static int ssl_remember_peer_pubkey(mbedtls_ssl_context *ssl,
                                    unsigned char *start,
                                    size_t len)
{
    unsigned char *end = start + len;
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

    /* Make a copy of the peer's raw public key. */
    mbedtls_pk_init(&ssl->handshake->peer_pubkey);
    ret = mbedtls_pk_parse_subpubkey(&start, end, &ssl->handshake->peer_pubkey);
    if (ret != 0) {
        /* We should have parsed the public key before. */
        return MBEDTLS_ERR_SSL_INTERNAL_ERROR;
    }

    return 0;
}
#        endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */

int mbedtls_ssl_parse_certificate(mbedtls_ssl_context *ssl)
{
    int ret = 0;
    int crt_expected;
#        if defined(MBEDTLS_SSL_SRV_C) && \
            defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
    const int authmode = ssl->handshake->sni_authmode !=
                                 MBEDTLS_SSL_VERIFY_UNSET ?
                             ssl->handshake->sni_authmode :
                             ssl->conf->authmode;
#        else
    const int authmode = ssl->conf->authmode;
#        endif
    void *rs_ctx = NULL;
    mbedtls_x509_crt *chain = NULL;

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> parse certificate"));

    crt_expected = ssl_parse_certificate_coordinate(ssl, authmode);
    if (crt_expected == SSL_CERTIFICATE_SKIP) {
        MBEDTLS_SSL_DEBUG_MSG(2, ("<= skip parse certificate"));
        goto exit;
    }

#        if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
    if (ssl->handshake->ecrs_enabled &&
        ssl->handshake->ecrs_state == ssl_ecrs_crt_verify) {
        chain = ssl->handshake->ecrs_peer_cert;
        ssl->handshake->ecrs_peer_cert = NULL;
        goto crt_verify;
    }
#        endif

    if ((ret = mbedtls_ssl_read_record(ssl, 1)) != 0) {
        /* mbedtls_ssl_read_record may have sent an alert already. We
           let it decide whether to alert. */
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_read_record", ret);
        goto exit;
    }

#        if defined(MBEDTLS_SSL_SRV_C)
    if (ssl_srv_check_client_no_crt_notification(ssl) == 0) {
        ssl->session_negotiate->verify_result = MBEDTLS_X509_BADCERT_MISSING;

        if (authmode != MBEDTLS_SSL_VERIFY_OPTIONAL)
            ret = MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE;

        goto exit;
    }
#        endif /* MBEDTLS_SSL_SRV_C */

    /* Clear existing peer CRT structure in case we tried to
     * reuse a session but it failed, and allocate a new one. */
    ssl_clear_peer_cert(ssl->session_negotiate);

    chain = mbedtls_calloc(1, sizeof(mbedtls_x509_crt));
    if (chain == NULL) {
        MBEDTLS_SSL_DEBUG_MSG(1,
                              ("alloc(%" MBEDTLS_PRINTF_SIZET " bytes) failed",
                               sizeof(mbedtls_x509_crt)));
        mbedtls_ssl_send_alert_message(ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                                       MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR);

        ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
        goto exit;
    }
    mbedtls_x509_crt_init(chain);

    ret = ssl_parse_certificate_chain(ssl, chain);
    if (ret != 0)
        goto exit;

#        if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
    if (ssl->handshake->ecrs_enabled)
        ssl->handshake->ecrs_state = ssl_ecrs_crt_verify;

crt_verify:
    if (ssl->handshake->ecrs_enabled)
        rs_ctx = &ssl->handshake->ecrs_ctx;
#        endif

    ret = ssl_parse_certificate_verify(ssl, authmode, chain, rs_ctx);
    if (ret != 0)
        goto exit;

#        if !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
    {
        unsigned char *crt_start, *pk_start;
        size_t crt_len, pk_len;

        /* We parse the CRT chain without copying, so
         * these pointers point into the input buffer,
         * and are hence still valid after freeing the
         * CRT chain. */

        crt_start = chain->raw.p;
        crt_len = chain->raw.len;

        pk_start = chain->pk_raw.p;
        pk_len = chain->pk_raw.len;

        /* Free the CRT structures before computing
         * digest and copying the peer's public key. */
        mbedtls_x509_crt_free(chain);
        mbedtls_free(chain);
        chain = NULL;

        ret = ssl_remember_peer_crt_digest(ssl, crt_start, crt_len);
        if (ret != 0)
            goto exit;

        ret = ssl_remember_peer_pubkey(ssl, pk_start, pk_len);
        if (ret != 0)
            goto exit;
    }
#        else /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
    /* Pass ownership to session structure. */
    ssl->session_negotiate->peer_cert = chain;
    chain = NULL;
#        endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */

    MBEDTLS_SSL_DEBUG_MSG(2, ("<= parse certificate"));

exit:

    if (ret == 0)
        ssl->state++;

#        if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
    if (ret == MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS) {
        ssl->handshake->ecrs_peer_cert = chain;
        chain = NULL;
    }
#        endif

    if (chain != NULL) {
        mbedtls_x509_crt_free(chain);
        mbedtls_free(chain);
    }

    return ret;
}
#    endif /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */

void mbedtls_ssl_optimize_checksum(
    mbedtls_ssl_context *ssl,
    const mbedtls_ssl_ciphersuite_t *ciphersuite_info)
{
    ((void)ciphersuite_info);

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#        if defined(MBEDTLS_SHA384_C)
    if (ciphersuite_info->mac == MBEDTLS_MD_SHA384)
        ssl->handshake->update_checksum = ssl_update_checksum_sha384;
    else
#        endif
#        if defined(MBEDTLS_SHA256_C)
        if (ciphersuite_info->mac != MBEDTLS_MD_SHA384)
        ssl->handshake->update_checksum = ssl_update_checksum_sha256;
    else
#        endif
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
    {
        MBEDTLS_SSL_DEBUG_MSG(1, ("should never happen"));
        return;
    }
}

void mbedtls_ssl_reset_checksum(mbedtls_ssl_context *ssl)
{
#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#        if defined(MBEDTLS_SHA256_C)
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    psa_hash_abort(&ssl->handshake->fin_sha256_psa);
    psa_hash_setup(&ssl->handshake->fin_sha256_psa, PSA_ALG_SHA_256);
#            else
    mbedtls_sha256_starts(&ssl->handshake->fin_sha256, 0);
#            endif
#        endif
#        if defined(MBEDTLS_SHA384_C)
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    psa_hash_abort(&ssl->handshake->fin_sha384_psa);
    psa_hash_setup(&ssl->handshake->fin_sha384_psa, PSA_ALG_SHA_384);
#            else
    mbedtls_sha512_starts(&ssl->handshake->fin_sha512, 1);
#            endif
#        endif
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
}

static void ssl_update_checksum_start(mbedtls_ssl_context *ssl,
                                      const unsigned char *buf,
                                      size_t len)
{
#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#        if defined(MBEDTLS_SHA256_C)
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    psa_hash_update(&ssl->handshake->fin_sha256_psa, buf, len);
#            else
    mbedtls_sha256_update(&ssl->handshake->fin_sha256, buf, len);
#            endif
#        endif
#        if defined(MBEDTLS_SHA384_C)
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    psa_hash_update(&ssl->handshake->fin_sha384_psa, buf, len);
#            else
    mbedtls_sha512_update(&ssl->handshake->fin_sha512, buf, len);
#            endif
#        endif
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
}

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#        if defined(MBEDTLS_SHA256_C)
static void ssl_update_checksum_sha256(mbedtls_ssl_context *ssl,
                                       const unsigned char *buf,
                                       size_t len)
{
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    psa_hash_update(&ssl->handshake->fin_sha256_psa, buf, len);
#            else
    mbedtls_sha256_update(&ssl->handshake->fin_sha256, buf, len);
#            endif
}
#        endif

#        if defined(MBEDTLS_SHA384_C)
static void ssl_update_checksum_sha384(mbedtls_ssl_context *ssl,
                                       const unsigned char *buf,
                                       size_t len)
{
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    psa_hash_update(&ssl->handshake->fin_sha384_psa, buf, len);
#            else
    mbedtls_sha512_update(&ssl->handshake->fin_sha512, buf, len);
#            endif
}
#        endif
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#        if defined(MBEDTLS_SHA256_C)
static void ssl_calc_finished_tls_sha256(mbedtls_ssl_context *ssl,
                                         unsigned char *buf,
                                         int from)
{
    int len = 12;
    const char *sender;
    unsigned char padbuf[32];
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    size_t hash_size;
    psa_hash_operation_t sha256_psa = PSA_HASH_OPERATION_INIT;
    psa_status_t status;
#            else
    mbedtls_sha256_context sha256;
#            endif

    mbedtls_ssl_session *session = ssl->session_negotiate;
    if (!session)
        session = ssl->session;

    sender = (from == MBEDTLS_SSL_IS_CLIENT) ? "client finished" :
                                               "server finished";

#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    sha256_psa = psa_hash_operation_init();

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> calc PSA finished tls sha256"));

    status = psa_hash_clone(&ssl->handshake->fin_sha256_psa, &sha256_psa);
    if (status != PSA_SUCCESS) {
        MBEDTLS_SSL_DEBUG_MSG(2, ("PSA hash clone failed"));
        return;
    }

    status = psa_hash_finish(&sha256_psa, padbuf, sizeof(padbuf), &hash_size);
    if (status != PSA_SUCCESS) {
        MBEDTLS_SSL_DEBUG_MSG(2, ("PSA hash finish failed"));
        return;
    }
    MBEDTLS_SSL_DEBUG_BUF(3, "PSA calculated padbuf", padbuf, 32);
#            else

    mbedtls_sha256_init(&sha256);

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> calc  finished tls sha256"));

    mbedtls_sha256_clone(&sha256, &ssl->handshake->fin_sha256);

    /*
     * TLSv1.2:
     *   hash = PRF( master, finished_label,
     *               Hash( handshake ) )[0.11]
     */

#                if !defined(MBEDTLS_SHA256_ALT)
    MBEDTLS_SSL_DEBUG_BUF(4, "finished sha2 state",
                          (unsigned char *)sha256.state, sizeof(sha256.state));
#                endif

    mbedtls_sha256_finish(&sha256, padbuf);
    mbedtls_sha256_free(&sha256);
#            endif /* MBEDTLS_USE_PSA_CRYPTO */

    ssl->handshake->tls_prf(session->master, 48, sender, padbuf, 32, buf, len);

    MBEDTLS_SSL_DEBUG_BUF(3, "calc finished result", buf, len);

    mbedtls_platform_zeroize(padbuf, sizeof(padbuf));

    MBEDTLS_SSL_DEBUG_MSG(2, ("<= calc  finished"));
}
#        endif /* MBEDTLS_SHA256_C */

#        if defined(MBEDTLS_SHA384_C)

static void ssl_calc_finished_tls_sha384(mbedtls_ssl_context *ssl,
                                         unsigned char *buf,
                                         int from)
{
    int len = 12;
    const char *sender;
    unsigned char padbuf[48];
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    size_t hash_size;
    psa_hash_operation_t sha384_psa = PSA_HASH_OPERATION_INIT;
    psa_status_t status;
#            else
    mbedtls_sha512_context sha512;
#            endif

    mbedtls_ssl_session *session = ssl->session_negotiate;
    if (!session)
        session = ssl->session;

    sender = (from == MBEDTLS_SSL_IS_CLIENT) ? "client finished" :
                                               "server finished";

#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    sha384_psa = psa_hash_operation_init();

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> calc PSA finished tls sha384"));

    status = psa_hash_clone(&ssl->handshake->fin_sha384_psa, &sha384_psa);
    if (status != PSA_SUCCESS) {
        MBEDTLS_SSL_DEBUG_MSG(2, ("PSA hash clone failed"));
        return;
    }

    status = psa_hash_finish(&sha384_psa, padbuf, sizeof(padbuf), &hash_size);
    if (status != PSA_SUCCESS) {
        MBEDTLS_SSL_DEBUG_MSG(2, ("PSA hash finish failed"));
        return;
    }
    MBEDTLS_SSL_DEBUG_BUF(3, "PSA calculated padbuf", padbuf, 48);
#            else
    mbedtls_sha512_init(&sha512);

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> calc  finished tls sha384"));

    mbedtls_sha512_clone(&sha512, &ssl->handshake->fin_sha512);

    /*
     * TLSv1.2:
     *   hash = PRF( master, finished_label,
     *               Hash( handshake ) )[0.11]
     */

#                if !defined(MBEDTLS_SHA512_ALT)
    MBEDTLS_SSL_DEBUG_BUF(4, "finished sha512 state",
                          (unsigned char *)sha512.state, sizeof(sha512.state));
#                endif
    mbedtls_sha512_finish(&sha512, padbuf);

    mbedtls_sha512_free(&sha512);
#            endif

    ssl->handshake->tls_prf(session->master, 48, sender, padbuf, 48, buf, len);

    MBEDTLS_SSL_DEBUG_BUF(3, "calc finished result", buf, len);

    mbedtls_platform_zeroize(padbuf, sizeof(padbuf));

    MBEDTLS_SSL_DEBUG_MSG(2, ("<= calc  finished"));
}
#        endif /* MBEDTLS_SHA384_C */
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

void mbedtls_ssl_handshake_wrapup_free_hs_transform(mbedtls_ssl_context *ssl)
{
    MBEDTLS_SSL_DEBUG_MSG(3, ("=> handshake wrapup: final free"));

    /*
     * Free our handshake params
     */
    mbedtls_ssl_handshake_free(ssl);
    mbedtls_free(ssl->handshake);
    ssl->handshake = NULL;

    /*
     * Free the previous transform and swith in the current one
     */
    if (ssl->transform) {
        mbedtls_ssl_transform_free(ssl->transform);
        mbedtls_free(ssl->transform);
    }
    ssl->transform = ssl->transform_negotiate;
    ssl->transform_negotiate = NULL;

    MBEDTLS_SSL_DEBUG_MSG(3, ("<= handshake wrapup: final free"));
}

void mbedtls_ssl_handshake_wrapup(mbedtls_ssl_context *ssl)
{
    int resume = ssl->handshake->resume;

    MBEDTLS_SSL_DEBUG_MSG(3, ("=> handshake wrapup"));

#    if defined(MBEDTLS_SSL_RENEGOTIATION)
    if (ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS) {
        ssl->renego_status = MBEDTLS_SSL_RENEGOTIATION_DONE;
        ssl->renego_records_seen = 0;
    }
#    endif

    /*
     * Free the previous session and switch in the current one
     */
    if (ssl->session) {
#    if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
        /* RFC 7366 3.1: keep the EtM state */
        ssl->session_negotiate->encrypt_then_mac =
            ssl->session->encrypt_then_mac;
#    endif

        mbedtls_ssl_session_free(ssl->session);
        mbedtls_free(ssl->session);
    }
    ssl->session = ssl->session_negotiate;
    ssl->session_negotiate = NULL;

    /*
     * Add cache entry
     */
    if (ssl->conf->f_set_cache != NULL && ssl->session->id_len != 0 &&
        resume == 0) {
        if (ssl->conf->f_set_cache(ssl->conf->p_cache, ssl->session->id,
                                   ssl->session->id_len, ssl->session) != 0)
            MBEDTLS_SSL_DEBUG_MSG(1, ("cache did not store session"));
    }

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
    if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
        ssl->handshake->flight != NULL) {
        /* Cancel handshake timer */
        mbedtls_ssl_set_timer(ssl, 0);

        /* Keep last flight around in case we need to resend it:
         * we need the handshake and transform structures for that */
        MBEDTLS_SSL_DEBUG_MSG(3, ("skip freeing handshake and transform"));
    } else
#    endif
        mbedtls_ssl_handshake_wrapup_free_hs_transform(ssl);

    ssl->state++;

    MBEDTLS_SSL_DEBUG_MSG(3, ("<= handshake wrapup"));
}

int mbedtls_ssl_write_finished(mbedtls_ssl_context *ssl)
{
    int ret, hash_len;

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> write finished"));

    mbedtls_ssl_update_out_pointers(ssl, ssl->transform_negotiate);

    ssl->handshake->calc_finished(ssl, ssl->out_msg + 4, ssl->conf->endpoint);

    /*
     * RFC 5246 7.4.9 (Page 63) says 12 is the default length and ciphersuites
     * may define some other value. Currently (early 2016), no defined
     * ciphersuite does this (and this is unlikely to change as activity has
     * moved to TLS 1.3 now) so we can keep the hardcoded 12 here.
     */
    hash_len = 12;

#    if defined(MBEDTLS_SSL_RENEGOTIATION)
    ssl->verify_data_len = hash_len;
    memcpy(ssl->own_verify_data, ssl->out_msg + 4, hash_len);
#    endif

    ssl->out_msglen = 4 + hash_len;
    ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
    ssl->out_msg[0] = MBEDTLS_SSL_HS_FINISHED;

    /*
     * In case of session resuming, invert the client and server
     * ChangeCipherSpec messages order.
     */
    if (ssl->handshake->resume != 0) {
#    if defined(MBEDTLS_SSL_CLI_C)
        if (ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT)
            ssl->state = MBEDTLS_SSL_HANDSHAKE_WRAPUP;
#    endif
#    if defined(MBEDTLS_SSL_SRV_C)
        if (ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER)
            ssl->state = MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC;
#    endif
    } else
        ssl->state++;

    /*
     * Switch to our negotiated transform and session parameters for outbound
     * data.
     */
    MBEDTLS_SSL_DEBUG_MSG(
        3, ("switching to new transform spec for outbound data"));

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
    if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
        unsigned char i;

        /* Remember current epoch settings for resending */
        ssl->handshake->alt_transform_out = ssl->transform_out;
        memcpy(ssl->handshake->alt_out_ctr, ssl->cur_out_ctr, 8);

        /* Set sequence_number to zero */
        memset(ssl->cur_out_ctr + 2, 0, 6);

        /* Increment epoch */
        for (i = 2; i > 0; i--)
            if (++ssl->cur_out_ctr[i - 1] != 0)
                break;

        /* The loop goes to its end iff the counter is wrapping */
        if (i == 0) {
            MBEDTLS_SSL_DEBUG_MSG(1, ("DTLS epoch would wrap"));
            return MBEDTLS_ERR_SSL_COUNTER_WRAPPING;
        }
    } else
#    endif /* MBEDTLS_SSL_PROTO_DTLS */
        memset(ssl->cur_out_ctr, 0, 8);

    ssl->transform_out = ssl->transform_negotiate;
    ssl->session_out = ssl->session_negotiate;

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
    if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM)
        mbedtls_ssl_send_flight_completed(ssl);
#    endif

    if ((ret = mbedtls_ssl_write_handshake_msg(ssl)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_handshake_msg", ret);
        return ret;
    }

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
    if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
        (ret = mbedtls_ssl_flight_transmit(ssl)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_flight_transmit", ret);
        return ret;
    }
#    endif

    MBEDTLS_SSL_DEBUG_MSG(2, ("<= write finished"));

    return 0;
}

#    define SSL_MAX_HASH_LEN 12

int mbedtls_ssl_parse_finished(mbedtls_ssl_context *ssl)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    unsigned int hash_len;
    unsigned char buf[SSL_MAX_HASH_LEN];

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> parse finished"));

    ssl->handshake->calc_finished(ssl, buf, ssl->conf->endpoint ^ 1);

    if ((ret = mbedtls_ssl_read_record(ssl, 1)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_read_record", ret);
        return ret;
    }

    if (ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("bad finished message"));
        mbedtls_ssl_send_alert_message(
            ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
            MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE);
        return MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE;
    }

    hash_len = 12;

    if (ssl->in_msg[0] != MBEDTLS_SSL_HS_FINISHED) {
        mbedtls_ssl_send_alert_message(
            ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
            MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE);
        return MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE;
    }

    if (ssl->in_hslen != mbedtls_ssl_hs_hdr_len(ssl) + hash_len) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("bad finished message"));
        mbedtls_ssl_send_alert_message(ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                                       MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR);
        return MBEDTLS_ERR_SSL_DECODE_ERROR;
    }

    if (mbedtls_ssl_safer_memcmp(ssl->in_msg + mbedtls_ssl_hs_hdr_len(ssl), buf,
                                 hash_len) != 0) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("bad finished message"));
        mbedtls_ssl_send_alert_message(ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                                       MBEDTLS_SSL_ALERT_MSG_DECRYPT_ERROR);
        return MBEDTLS_ERR_SSL_HANDSHAKE_FAILURE;
    }

#    if defined(MBEDTLS_SSL_RENEGOTIATION)
    ssl->verify_data_len = hash_len;
    memcpy(ssl->peer_verify_data, buf, hash_len);
#    endif

    if (ssl->handshake->resume != 0) {
#    if defined(MBEDTLS_SSL_CLI_C)
        if (ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT)
            ssl->state = MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC;
#    endif
#    if defined(MBEDTLS_SSL_SRV_C)
        if (ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER)
            ssl->state = MBEDTLS_SSL_HANDSHAKE_WRAPUP;
#    endif
    } else
        ssl->state++;

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
    if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM)
        mbedtls_ssl_recv_flight_completed(ssl);
#    endif

    MBEDTLS_SSL_DEBUG_MSG(2, ("<= parse finished"));

    return 0;
}

static void ssl_handshake_params_init(mbedtls_ssl_handshake_params *handshake)
{
    memset(handshake, 0, sizeof(mbedtls_ssl_handshake_params));

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#        if defined(MBEDTLS_SHA256_C)
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    handshake->fin_sha256_psa = psa_hash_operation_init();
    psa_hash_setup(&handshake->fin_sha256_psa, PSA_ALG_SHA_256);
#            else
    mbedtls_sha256_init(&handshake->fin_sha256);
    mbedtls_sha256_starts(&handshake->fin_sha256, 0);
#            endif
#        endif
#        if defined(MBEDTLS_SHA384_C)
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    handshake->fin_sha384_psa = psa_hash_operation_init();
    psa_hash_setup(&handshake->fin_sha384_psa, PSA_ALG_SHA_384);
#            else
    mbedtls_sha512_init(&handshake->fin_sha512);
    mbedtls_sha512_starts(&handshake->fin_sha512, 1);
#            endif
#        endif
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

    handshake->update_checksum = ssl_update_checksum_start;

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
        defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
    mbedtls_ssl_sig_hash_set_init(&handshake->hash_algs);
#    endif

#    if defined(MBEDTLS_DHM_C)
    mbedtls_dhm_init(&handshake->dhm_ctx);
#    endif
#    if defined(MBEDTLS_ECDH_C)
    mbedtls_ecdh_init(&handshake->ecdh_ctx);
#    endif
#    if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
    mbedtls_ecjpake_init(&handshake->ecjpake_ctx);
#        if defined(MBEDTLS_SSL_CLI_C)
    handshake->ecjpake_cache = NULL;
    handshake->ecjpake_cache_len = 0;
#        endif
#    endif

#    if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
    mbedtls_x509_crt_restart_init(&handshake->ecrs_ctx);
#    endif

#    if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
    handshake->sni_authmode = MBEDTLS_SSL_VERIFY_UNSET;
#    endif

#    if defined(MBEDTLS_X509_CRT_PARSE_C) && \
        !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
    mbedtls_pk_init(&handshake->peer_pubkey);
#    endif
}

void mbedtls_ssl_transform_init(mbedtls_ssl_transform *transform)
{
    memset(transform, 0, sizeof(mbedtls_ssl_transform));

    mbedtls_cipher_init(&transform->cipher_ctx_enc);
    mbedtls_cipher_init(&transform->cipher_ctx_dec);

#    if defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
    mbedtls_md_init(&transform->md_ctx_enc);
    mbedtls_md_init(&transform->md_ctx_dec);
#    endif
}

void mbedtls_ssl_session_init(mbedtls_ssl_session *session)
{
    memset(session, 0, sizeof(mbedtls_ssl_session));
}

static int ssl_handshake_init(mbedtls_ssl_context *ssl)
{
    /* Clear old handshake information if present */
    if (ssl->transform_negotiate)
        mbedtls_ssl_transform_free(ssl->transform_negotiate);
    if (ssl->session_negotiate)
        mbedtls_ssl_session_free(ssl->session_negotiate);
    if (ssl->handshake)
        mbedtls_ssl_handshake_free(ssl);

    /*
     * Either the pointers are now NULL or cleared properly and can be freed.
     * Now allocate missing structures.
     */
    if (ssl->transform_negotiate == NULL) {
        ssl->transform_negotiate =
            mbedtls_calloc(1, sizeof(mbedtls_ssl_transform));
    }

    if (ssl->session_negotiate == NULL) {
        ssl->session_negotiate = mbedtls_calloc(1, sizeof(mbedtls_ssl_session));
    }

    if (ssl->handshake == NULL) {
        ssl->handshake =
            mbedtls_calloc(1, sizeof(mbedtls_ssl_handshake_params));
    }
#    if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
    /* If the buffers are too small - reallocate */

    handle_buffer_resizing(ssl, 0, MBEDTLS_SSL_IN_BUFFER_LEN,
                           MBEDTLS_SSL_OUT_BUFFER_LEN);
#    endif

    /* All pointers should exist and can be directly freed without issue */
    if (ssl->handshake == NULL || ssl->transform_negotiate == NULL ||
        ssl->session_negotiate == NULL) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("alloc() of ssl sub-contexts failed"));

        mbedtls_free(ssl->handshake);
        mbedtls_free(ssl->transform_negotiate);
        mbedtls_free(ssl->session_negotiate);

        ssl->handshake = NULL;
        ssl->transform_negotiate = NULL;
        ssl->session_negotiate = NULL;

        return MBEDTLS_ERR_SSL_ALLOC_FAILED;
    }

    /* Initialize structures */
    mbedtls_ssl_session_init(ssl->session_negotiate);
    mbedtls_ssl_transform_init(ssl->transform_negotiate);
    ssl_handshake_params_init(ssl->handshake);

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
    if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
        ssl->handshake->alt_transform_out = ssl->transform_out;

        if (ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT)
            ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_PREPARING;
        else
            ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_WAITING;

        mbedtls_ssl_set_timer(ssl, 0);
    }
#    endif

    return 0;
}

#    if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY) && defined(MBEDTLS_SSL_SRV_C)
/* Dummy cookie callbacks for defaults */
static int ssl_cookie_write_dummy(void *ctx,
                                  unsigned char **p,
                                  unsigned char *end,
                                  const unsigned char *cli_id,
                                  size_t cli_id_len)
{
    ((void)ctx);
    ((void)p);
    ((void)end);
    ((void)cli_id);
    ((void)cli_id_len);

    return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
}

static int ssl_cookie_check_dummy(void *ctx,
                                  const unsigned char *cookie,
                                  size_t cookie_len,
                                  const unsigned char *cli_id,
                                  size_t cli_id_len)
{
    ((void)ctx);
    ((void)cookie);
    ((void)cookie_len);
    ((void)cli_id);
    ((void)cli_id_len);

    return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
}
#    endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY && MBEDTLS_SSL_SRV_C */

/*
 * Initialize an SSL context
 */
void mbedtls_ssl_init(mbedtls_ssl_context *ssl)
{
    memset(ssl, 0, sizeof(mbedtls_ssl_context));
}

/*
 * Setup an SSL context
 */

int mbedtls_ssl_setup(mbedtls_ssl_context *ssl, const mbedtls_ssl_config *conf)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    size_t in_buf_len = MBEDTLS_SSL_IN_BUFFER_LEN;
    size_t out_buf_len = MBEDTLS_SSL_OUT_BUFFER_LEN;

    ssl->conf = conf;

    /*
     * Prepare base structures
     */

    /* Set to NULL in case of an error condition */
    ssl->out_buf = NULL;

#    if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
    ssl->in_buf_len = in_buf_len;
#    endif
    ssl->in_buf = mbedtls_calloc(1, in_buf_len);
    if (ssl->in_buf == NULL) {
        MBEDTLS_SSL_DEBUG_MSG(
            1, ("alloc(%" MBEDTLS_PRINTF_SIZET " bytes) failed", in_buf_len));
        ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
        goto error;
    }

#    if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
    ssl->out_buf_len = out_buf_len;
#    endif
    ssl->out_buf = mbedtls_calloc(1, out_buf_len);
    if (ssl->out_buf == NULL) {
        MBEDTLS_SSL_DEBUG_MSG(
            1, ("alloc(%" MBEDTLS_PRINTF_SIZET " bytes) failed", out_buf_len));
        ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
        goto error;
    }

    mbedtls_ssl_reset_in_out_pointers(ssl);

#    if defined(MBEDTLS_SSL_DTLS_SRTP)
    memset(&ssl->dtls_srtp_info, 0, sizeof(ssl->dtls_srtp_info));
#    endif

    if ((ret = ssl_handshake_init(ssl)) != 0)
        goto error;

    return 0;

error:
    mbedtls_free(ssl->in_buf);
    mbedtls_free(ssl->out_buf);

    ssl->conf = NULL;

#    if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
    ssl->in_buf_len = 0;
    ssl->out_buf_len = 0;
#    endif
    ssl->in_buf = NULL;
    ssl->out_buf = NULL;

    ssl->in_hdr = NULL;
    ssl->in_ctr = NULL;
    ssl->in_len = NULL;
    ssl->in_iv = NULL;
    ssl->in_msg = NULL;

    ssl->out_hdr = NULL;
    ssl->out_ctr = NULL;
    ssl->out_len = NULL;
    ssl->out_iv = NULL;
    ssl->out_msg = NULL;

    return ret;
}

/*
 * Reset an initialized and used SSL context for re-use while retaining
 * all application-set variables, function pointers and data.
 *
 * If partial is non-zero, keep data in the input buffer and client ID.
 * (Use when a DTLS client reconnects from the same port.)
 */
int mbedtls_ssl_session_reset_int(mbedtls_ssl_context *ssl, int partial)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
#    if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
    size_t in_buf_len = ssl->in_buf_len;
    size_t out_buf_len = ssl->out_buf_len;
#    else
    size_t in_buf_len = MBEDTLS_SSL_IN_BUFFER_LEN;
    size_t out_buf_len = MBEDTLS_SSL_OUT_BUFFER_LEN;
#    endif

#    if !defined(MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE) || \
        !defined(MBEDTLS_SSL_SRV_C)
    ((void)partial);
#    endif

    ssl->state = MBEDTLS_SSL_HELLO_REQUEST;

    /* Cancel any possibly running timer */
    mbedtls_ssl_set_timer(ssl, 0);

#    if defined(MBEDTLS_SSL_RENEGOTIATION)
    ssl->renego_status = MBEDTLS_SSL_INITIAL_HANDSHAKE;
    ssl->renego_records_seen = 0;

    ssl->verify_data_len = 0;
    memset(ssl->own_verify_data, 0, MBEDTLS_SSL_VERIFY_DATA_MAX_LEN);
    memset(ssl->peer_verify_data, 0, MBEDTLS_SSL_VERIFY_DATA_MAX_LEN);
#    endif
    ssl->secure_renegotiation = MBEDTLS_SSL_LEGACY_RENEGOTIATION;

    ssl->in_offt = NULL;
    mbedtls_ssl_reset_in_out_pointers(ssl);

    ssl->in_msgtype = 0;
    ssl->in_msglen = 0;
#    if defined(MBEDTLS_SSL_PROTO_DTLS)
    ssl->next_record_offset = 0;
    ssl->in_epoch = 0;
#    endif
#    if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
    mbedtls_ssl_dtls_replay_reset(ssl);
#    endif

    ssl->in_hslen = 0;
    ssl->nb_zero = 0;

    ssl->keep_current_message = 0;

    ssl->out_msgtype = 0;
    ssl->out_msglen = 0;
    ssl->out_left = 0;

    memset(ssl->cur_out_ctr, 0, sizeof(ssl->cur_out_ctr));

    ssl->transform_in = NULL;
    ssl->transform_out = NULL;

    ssl->session_in = NULL;
    ssl->session_out = NULL;

    memset(ssl->out_buf, 0, out_buf_len);

#    if defined(MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE) && \
        defined(MBEDTLS_SSL_SRV_C)
    if (partial == 0)
#    endif /* MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE && MBEDTLS_SSL_SRV_C */
    {
        ssl->in_left = 0;
        memset(ssl->in_buf, 0, in_buf_len);
    }

    if (ssl->transform) {
        mbedtls_ssl_transform_free(ssl->transform);
        mbedtls_free(ssl->transform);
        ssl->transform = NULL;
    }

    if (ssl->session) {
        mbedtls_ssl_session_free(ssl->session);
        mbedtls_free(ssl->session);
        ssl->session = NULL;
    }

#    if defined(MBEDTLS_SSL_ALPN)
    ssl->alpn_chosen = NULL;
#    endif

#    if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY) && defined(MBEDTLS_SSL_SRV_C)
#        if defined(MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE)
    if (partial == 0)
#        endif
    {
        mbedtls_free(ssl->cli_id);
        ssl->cli_id = NULL;
        ssl->cli_id_len = 0;
    }
#    endif

    if ((ret = ssl_handshake_init(ssl)) != 0)
        return ret;

    return 0;
}

/*
 * Reset an initialized and used SSL context for re-use while retaining
 * all application-set variables, function pointers and data.
 */
int mbedtls_ssl_session_reset(mbedtls_ssl_context *ssl)
{
    return mbedtls_ssl_session_reset_int(ssl, 0);
}

/*
 * SSL set accessors
 */
void mbedtls_ssl_conf_endpoint(mbedtls_ssl_config *conf, int endpoint)
{
    conf->endpoint = endpoint;
}

void mbedtls_ssl_conf_transport(mbedtls_ssl_config *conf, int transport)
{
    conf->transport = transport;
}

#    if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
void mbedtls_ssl_conf_dtls_anti_replay(mbedtls_ssl_config *conf, char mode)
{
    conf->anti_replay = mode;
}
#    endif

void mbedtls_ssl_conf_dtls_badmac_limit(mbedtls_ssl_config *conf,
                                        unsigned limit)
{
    conf->badmac_limit = limit;
}

#    if defined(MBEDTLS_SSL_PROTO_DTLS)

void mbedtls_ssl_set_datagram_packing(mbedtls_ssl_context *ssl,
                                      unsigned allow_packing)
{
    ssl->disable_datagram_packing = !allow_packing;
}

void mbedtls_ssl_conf_handshake_timeout(mbedtls_ssl_config *conf,
                                        uint32_t min,
                                        uint32_t max)
{
    conf->hs_timeout_min = min;
    conf->hs_timeout_max = max;
}
#    endif

void mbedtls_ssl_conf_authmode(mbedtls_ssl_config *conf, int authmode)
{
    conf->authmode = authmode;
}

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
void mbedtls_ssl_conf_verify(
    mbedtls_ssl_config *conf,
    int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
    void *p_vrfy)
{
    conf->f_vrfy = f_vrfy;
    conf->p_vrfy = p_vrfy;
}
#    endif /* MBEDTLS_X509_CRT_PARSE_C */

void mbedtls_ssl_conf_rng(mbedtls_ssl_config *conf,
                          int (*f_rng)(void *, unsigned char *, size_t),
                          void *p_rng)
{
    conf->f_rng = f_rng;
    conf->p_rng = p_rng;
}

void mbedtls_ssl_conf_dbg(
    mbedtls_ssl_config *conf,
    void (*f_dbg)(void *, int, const char *, int, const char *),
    void *p_dbg)
{
    conf->f_dbg = f_dbg;
    conf->p_dbg = p_dbg;
}

void mbedtls_ssl_set_bio(mbedtls_ssl_context *ssl,
                         void *p_bio,
                         mbedtls_ssl_send_t *f_send,
                         mbedtls_ssl_recv_t *f_recv,
                         mbedtls_ssl_recv_timeout_t *f_recv_timeout)
{
    ssl->p_bio = p_bio;
    ssl->f_send = f_send;
    ssl->f_recv = f_recv;
    ssl->f_recv_timeout = f_recv_timeout;
}

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
void mbedtls_ssl_set_mtu(mbedtls_ssl_context *ssl, uint16_t mtu)
{
    ssl->mtu = mtu;
}
#    endif

void mbedtls_ssl_conf_read_timeout(mbedtls_ssl_config *conf, uint32_t timeout)
{
    conf->read_timeout = timeout;
}

void mbedtls_ssl_set_timer_cb(mbedtls_ssl_context *ssl,
                              void *p_timer,
                              mbedtls_ssl_set_timer_t *f_set_timer,
                              mbedtls_ssl_get_timer_t *f_get_timer)
{
    ssl->p_timer = p_timer;
    ssl->f_set_timer = f_set_timer;
    ssl->f_get_timer = f_get_timer;

    /* Make sure we start with no timer running */
    mbedtls_ssl_set_timer(ssl, 0);
}

#    if defined(MBEDTLS_SSL_SRV_C)
void mbedtls_ssl_conf_session_cache(mbedtls_ssl_config *conf,
                                    void *p_cache,
                                    mbedtls_ssl_cache_get_t *f_get_cache,
                                    mbedtls_ssl_cache_set_t *f_set_cache)
{
    conf->p_cache = p_cache;
    conf->f_get_cache = f_get_cache;
    conf->f_set_cache = f_set_cache;
}
#    endif /* MBEDTLS_SSL_SRV_C */

#    if defined(MBEDTLS_SSL_CLI_C)
int mbedtls_ssl_set_session(mbedtls_ssl_context *ssl,
                            const mbedtls_ssl_session *session)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

    if (ssl == NULL || session == NULL || ssl->session_negotiate == NULL ||
        ssl->conf->endpoint != MBEDTLS_SSL_IS_CLIENT) {
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    if (ssl->handshake->resume == 1)
        return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;

    if ((ret = mbedtls_ssl_session_copy(ssl->session_negotiate, session)) != 0)
        return ret;

    ssl->handshake->resume = 1;

    return 0;
}
#    endif /* MBEDTLS_SSL_CLI_C */

void mbedtls_ssl_conf_ciphersuites(mbedtls_ssl_config *conf,
                                   const int *ciphersuites)
{
    conf->ciphersuite_list = ciphersuites;
}

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
void mbedtls_ssl_conf_cert_profile(mbedtls_ssl_config *conf,
                                   const mbedtls_x509_crt_profile *profile)
{
    conf->cert_profile = profile;
}

/* Append a new keycert entry to a (possibly empty) list */
static int ssl_append_key_cert(mbedtls_ssl_key_cert **head,
                               mbedtls_x509_crt *cert,
                               mbedtls_pk_context *key)
{
    mbedtls_ssl_key_cert *new_cert;

    new_cert = mbedtls_calloc(1, sizeof(mbedtls_ssl_key_cert));
    if (new_cert == NULL)
        return MBEDTLS_ERR_SSL_ALLOC_FAILED;

    new_cert->cert = cert;
    new_cert->key = key;
    new_cert->next = NULL;

    /* Update head is the list was null, else add to the end */
    if (*head == NULL) {
        *head = new_cert;
    } else {
        mbedtls_ssl_key_cert *cur = *head;
        while (cur->next != NULL)
            cur = cur->next;
        cur->next = new_cert;
    }

    return 0;
}

int mbedtls_ssl_conf_own_cert(mbedtls_ssl_config *conf,
                              mbedtls_x509_crt *own_cert,
                              mbedtls_pk_context *pk_key)
{
    return ssl_append_key_cert(&conf->key_cert, own_cert, pk_key);
}

void mbedtls_ssl_conf_ca_chain(mbedtls_ssl_config *conf,
                               mbedtls_x509_crt *ca_chain,
                               mbedtls_x509_crl *ca_crl)
{
    conf->ca_chain = ca_chain;
    conf->ca_crl = ca_crl;

#        if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
    /* mbedtls_ssl_conf_ca_chain() and mbedtls_ssl_conf_ca_cb()
     * cannot be used together. */
    conf->f_ca_cb = NULL;
    conf->p_ca_cb = NULL;
#        endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
}

#        if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
void mbedtls_ssl_conf_ca_cb(mbedtls_ssl_config *conf,
                            mbedtls_x509_crt_ca_cb_t f_ca_cb,
                            void *p_ca_cb)
{
    conf->f_ca_cb = f_ca_cb;
    conf->p_ca_cb = p_ca_cb;

    /* mbedtls_ssl_conf_ca_chain() and mbedtls_ssl_conf_ca_cb()
     * cannot be used together. */
    conf->ca_chain = NULL;
    conf->ca_crl = NULL;
}
#        endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
#    endif /* MBEDTLS_X509_CRT_PARSE_C */

#    if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
int mbedtls_ssl_set_hs_own_cert(mbedtls_ssl_context *ssl,
                                mbedtls_x509_crt *own_cert,
                                mbedtls_pk_context *pk_key)
{
    return (
        ssl_append_key_cert(&ssl->handshake->sni_key_cert, own_cert, pk_key));
}

void mbedtls_ssl_set_hs_ca_chain(mbedtls_ssl_context *ssl,
                                 mbedtls_x509_crt *ca_chain,
                                 mbedtls_x509_crl *ca_crl)
{
    ssl->handshake->sni_ca_chain = ca_chain;
    ssl->handshake->sni_ca_crl = ca_crl;
}

void mbedtls_ssl_set_hs_authmode(mbedtls_ssl_context *ssl, int authmode)
{
    ssl->handshake->sni_authmode = authmode;
}
#    endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
void mbedtls_ssl_set_verify(
    mbedtls_ssl_context *ssl,
    int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
    void *p_vrfy)
{
    ssl->f_vrfy = f_vrfy;
    ssl->p_vrfy = p_vrfy;
}
#    endif

#    if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
/*
 * Set EC J-PAKE password for current handshake
 */
int mbedtls_ssl_set_hs_ecjpake_password(mbedtls_ssl_context *ssl,
                                        const unsigned char *pw,
                                        size_t pw_len)
{
    mbedtls_ecjpake_role role;

    if (ssl->handshake == NULL || ssl->conf == NULL)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    if (ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER)
        role = MBEDTLS_ECJPAKE_SERVER;
    else
        role = MBEDTLS_ECJPAKE_CLIENT;

    return (mbedtls_ecjpake_setup(&ssl->handshake->ecjpake_ctx, role,
                                  MBEDTLS_MD_SHA256, MBEDTLS_ECP_DP_SECP256R1,
                                  pw, pw_len));
}
#    endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */

#    if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)

static int ssl_conf_psk_is_configured(mbedtls_ssl_config const *conf)
{
#        if defined(MBEDTLS_USE_PSA_CRYPTO)
    if (!mbedtls_svc_key_id_is_null(conf->psk_opaque))
        return 1;
#        endif /* MBEDTLS_USE_PSA_CRYPTO */

    if (conf->psk != NULL)
        return 1;

    return 0;
}

static void ssl_conf_remove_psk(mbedtls_ssl_config *conf)
{
    /* Remove reference to existing PSK, if any. */
#        if defined(MBEDTLS_USE_PSA_CRYPTO)
    if (!mbedtls_svc_key_id_is_null(conf->psk_opaque)) {
        /* The maintenance of the PSK key slot is the
         * user's responsibility. */
        conf->psk_opaque = MBEDTLS_SVC_KEY_ID_INIT;
    }
    /* This and the following branch should never
     * be taken simultaenously as we maintain the
     * invariant that raw and opaque PSKs are never
     * configured simultaneously. As a safeguard,
     * though, `else` is omitted here. */
#        endif /* MBEDTLS_USE_PSA_CRYPTO */
    if (conf->psk != NULL) {
        mbedtls_platform_zeroize(conf->psk, conf->psk_len);

        mbedtls_free(conf->psk);
        conf->psk = NULL;
        conf->psk_len = 0;
    }

    /* Remove reference to PSK identity, if any. */
    if (conf->psk_identity != NULL) {
        mbedtls_free(conf->psk_identity);
        conf->psk_identity = NULL;
        conf->psk_identity_len = 0;
    }
}

/* This function assumes that PSK identity in the SSL config is unset.
 * It checks that the provided identity is well-formed and attempts
 * to make a copy of it in the SSL config.
 * On failure, the PSK identity in the config remains unset. */
static int ssl_conf_set_psk_identity(mbedtls_ssl_config *conf,
                                     unsigned char const *psk_identity,
                                     size_t psk_identity_len)
{
    /* Identity len will be encoded on two bytes */
    if (psk_identity == NULL || (psk_identity_len >> 16) != 0 ||
        psk_identity_len > MBEDTLS_SSL_OUT_CONTENT_LEN) {
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    conf->psk_identity = mbedtls_calloc(1, psk_identity_len);
    if (conf->psk_identity == NULL)
        return MBEDTLS_ERR_SSL_ALLOC_FAILED;

    conf->psk_identity_len = psk_identity_len;
    memcpy(conf->psk_identity, psk_identity, conf->psk_identity_len);

    return 0;
}

int mbedtls_ssl_conf_psk(mbedtls_ssl_config *conf,
                         const unsigned char *psk,
                         size_t psk_len,
                         const unsigned char *psk_identity,
                         size_t psk_identity_len)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

    /* We currently only support one PSK, raw or opaque. */
    if (ssl_conf_psk_is_configured(conf))
        return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;

    /* Check and set raw PSK */
    if (psk == NULL)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    if (psk_len == 0)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    if (psk_len > MBEDTLS_PSK_MAX_LEN)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    if ((conf->psk = mbedtls_calloc(1, psk_len)) == NULL)
        return MBEDTLS_ERR_SSL_ALLOC_FAILED;
    conf->psk_len = psk_len;
    memcpy(conf->psk, psk, conf->psk_len);

    /* Check and set PSK Identity */
    ret = ssl_conf_set_psk_identity(conf, psk_identity, psk_identity_len);
    if (ret != 0)
        ssl_conf_remove_psk(conf);

    return ret;
}

static void ssl_remove_psk(mbedtls_ssl_context *ssl)
{
#        if defined(MBEDTLS_USE_PSA_CRYPTO)
    if (!mbedtls_svc_key_id_is_null(ssl->handshake->psk_opaque)) {
        ssl->handshake->psk_opaque = MBEDTLS_SVC_KEY_ID_INIT;
    } else
#        endif /* MBEDTLS_USE_PSA_CRYPTO */
        if (ssl->handshake->psk != NULL) {
        mbedtls_platform_zeroize(ssl->handshake->psk, ssl->handshake->psk_len);
        mbedtls_free(ssl->handshake->psk);
        ssl->handshake->psk_len = 0;
    }
}

int mbedtls_ssl_set_hs_psk(mbedtls_ssl_context *ssl,
                           const unsigned char *psk,
                           size_t psk_len)
{
    if (psk == NULL || ssl->handshake == NULL)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    if (psk_len > MBEDTLS_PSK_MAX_LEN)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    ssl_remove_psk(ssl);

    if ((ssl->handshake->psk = mbedtls_calloc(1, psk_len)) == NULL)
        return MBEDTLS_ERR_SSL_ALLOC_FAILED;

    ssl->handshake->psk_len = psk_len;
    memcpy(ssl->handshake->psk, psk, ssl->handshake->psk_len);

    return 0;
}

#        if defined(MBEDTLS_USE_PSA_CRYPTO)
int mbedtls_ssl_conf_psk_opaque(mbedtls_ssl_config *conf,
                                psa_key_id_t psk,
                                const unsigned char *psk_identity,
                                size_t psk_identity_len)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

    /* We currently only support one PSK, raw or opaque. */
    if (ssl_conf_psk_is_configured(conf))
        return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;

    /* Check and set opaque PSK */
    if (mbedtls_svc_key_id_is_null(psk))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    conf->psk_opaque = psk;

    /* Check and set PSK Identity */
    ret = ssl_conf_set_psk_identity(conf, psk_identity, psk_identity_len);
    if (ret != 0)
        ssl_conf_remove_psk(conf);

    return ret;
}

int mbedtls_ssl_set_hs_psk_opaque(mbedtls_ssl_context *ssl, psa_key_id_t psk)
{
    if ((mbedtls_svc_key_id_is_null(psk)) || (ssl->handshake == NULL))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    ssl_remove_psk(ssl);
    ssl->handshake->psk_opaque = psk;
    return 0;
}
#        endif /* MBEDTLS_USE_PSA_CRYPTO */

void mbedtls_ssl_conf_psk_cb(
    mbedtls_ssl_config *conf,
    int (*f_psk)(void *, mbedtls_ssl_context *, const unsigned char *, size_t),
    void *p_psk)
{
    conf->f_psk = f_psk;
    conf->p_psk = p_psk;
}
#    endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */

#    if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_SSL_SRV_C)
int mbedtls_ssl_conf_dh_param_bin(mbedtls_ssl_config *conf,
                                  const unsigned char *dhm_P,
                                  size_t P_len,
                                  const unsigned char *dhm_G,
                                  size_t G_len)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

    if ((ret = mbedtls_mpi_read_binary(&conf->dhm_P, dhm_P, P_len)) != 0 ||
        (ret = mbedtls_mpi_read_binary(&conf->dhm_G, dhm_G, G_len)) != 0) {
        mbedtls_mpi_free(&conf->dhm_P);
        mbedtls_mpi_free(&conf->dhm_G);
        return ret;
    }

    return 0;
}

int mbedtls_ssl_conf_dh_param_ctx(mbedtls_ssl_config *conf,
                                  mbedtls_dhm_context *dhm_ctx)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

    if ((ret = mbedtls_dhm_get_value(dhm_ctx, MBEDTLS_DHM_PARAM_P,
                                     &conf->dhm_P)) != 0 ||
        (ret = mbedtls_dhm_get_value(dhm_ctx, MBEDTLS_DHM_PARAM_G,
                                     &conf->dhm_G)) != 0) {
        mbedtls_mpi_free(&conf->dhm_P);
        mbedtls_mpi_free(&conf->dhm_G);
        return ret;
    }

    return 0;
}
#    endif /* MBEDTLS_DHM_C && MBEDTLS_SSL_SRV_C */

#    if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_SSL_CLI_C)
/*
 * Set the minimum length for Diffie-Hellman parameters
 */
void mbedtls_ssl_conf_dhm_min_bitlen(mbedtls_ssl_config *conf,
                                     unsigned int bitlen)
{
    conf->dhm_min_bitlen = bitlen;
}
#    endif /* MBEDTLS_DHM_C && MBEDTLS_SSL_CLI_C */

#    if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
/*
 * Set allowed/preferred hashes for handshake signatures
 */
void mbedtls_ssl_conf_sig_hashes(mbedtls_ssl_config *conf, const int *hashes)
{
    conf->sig_hashes = hashes;
}
#    endif /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */

#    if defined(MBEDTLS_ECP_C)
/*
 * Set the allowed elliptic curves
 */
void mbedtls_ssl_conf_curves(mbedtls_ssl_config *conf,
                             const mbedtls_ecp_group_id *curve_list)
{
    conf->curve_list = curve_list;
}
#    endif /* MBEDTLS_ECP_C */

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
int mbedtls_ssl_set_hostname(mbedtls_ssl_context *ssl, const char *hostname)
{
    /* Initialize to suppress unnecessary compiler warning */
    size_t hostname_len = 0;

    /* Check if new hostname is valid before
     * making any change to current one */
    if (hostname != NULL) {
        hostname_len = strlen(hostname);

        if (hostname_len > MBEDTLS_SSL_MAX_HOST_NAME_LEN)
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    /* Now it's clear that we will overwrite the old hostname,
     * so we can free it safely */

    if (ssl->hostname != NULL) {
        mbedtls_platform_zeroize(ssl->hostname, strlen(ssl->hostname));
        mbedtls_free(ssl->hostname);
    }

    /* Passing NULL as hostname shall clear the old one */

    if (hostname == NULL) {
        ssl->hostname = NULL;
    } else {
        ssl->hostname = mbedtls_calloc(1, hostname_len + 1);
        if (ssl->hostname == NULL)
            return MBEDTLS_ERR_SSL_ALLOC_FAILED;

        memcpy(ssl->hostname, hostname, hostname_len);

        ssl->hostname[hostname_len] = '\0';
    }

    return 0;
}
#    endif /* MBEDTLS_X509_CRT_PARSE_C */

#    if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
void mbedtls_ssl_conf_sni(
    mbedtls_ssl_config *conf,
    int (*f_sni)(void *, mbedtls_ssl_context *, const unsigned char *, size_t),
    void *p_sni)
{
    conf->f_sni = f_sni;
    conf->p_sni = p_sni;
}
#    endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */

#    if defined(MBEDTLS_SSL_ALPN)
int mbedtls_ssl_conf_alpn_protocols(mbedtls_ssl_config *conf,
                                    const char **protos)
{
    size_t cur_len, tot_len;
    const char **p;

    /*
     * RFC 7301 3.1: "Empty strings MUST NOT be included and byte strings
     * MUST NOT be truncated."
     * We check lengths now rather than later.
     */
    tot_len = 0;
    for (p = protos; *p != NULL; p++) {
        cur_len = strlen(*p);
        tot_len += cur_len;

        if ((cur_len == 0) || (cur_len > MBEDTLS_SSL_MAX_ALPN_NAME_LEN) ||
            (tot_len > MBEDTLS_SSL_MAX_ALPN_LIST_LEN))
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    conf->alpn_list = protos;

    return 0;
}

const char *mbedtls_ssl_get_alpn_protocol(const mbedtls_ssl_context *ssl)
{
    return ssl->alpn_chosen;
}
#    endif /* MBEDTLS_SSL_ALPN */

#    if defined(MBEDTLS_SSL_DTLS_SRTP)
void mbedtls_ssl_conf_srtp_mki_value_supported(mbedtls_ssl_config *conf,
                                               int support_mki_value)
{
    conf->dtls_srtp_mki_support = support_mki_value;
}

int mbedtls_ssl_dtls_srtp_set_mki_value(mbedtls_ssl_context *ssl,
                                        unsigned char *mki_value,
                                        uint16_t mki_len)
{
    if (mki_len > MBEDTLS_TLS_SRTP_MAX_MKI_LENGTH) {
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    if (ssl->conf->dtls_srtp_mki_support ==
        MBEDTLS_SSL_DTLS_SRTP_MKI_UNSUPPORTED) {
        return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
    }

    memcpy(ssl->dtls_srtp_info.mki_value, mki_value, mki_len);
    ssl->dtls_srtp_info.mki_len = mki_len;
    return 0;
}

int mbedtls_ssl_conf_dtls_srtp_protection_profiles(
    mbedtls_ssl_config *conf,
    const mbedtls_ssl_srtp_profile *profiles)
{
    const mbedtls_ssl_srtp_profile *p;
    size_t list_size = 0;

    /* check the profiles list: all entry must be valid,
     * its size cannot be more than the total number of supported profiles,
     * currently 4 */
    for (p = profiles; *p != MBEDTLS_TLS_SRTP_UNSET &&
                       list_size <= MBEDTLS_TLS_SRTP_MAX_PROFILE_LIST_LENGTH;
         p++) {
        if (mbedtls_ssl_check_srtp_profile_value(*p) !=
            MBEDTLS_TLS_SRTP_UNSET) {
            list_size++;
        } else {
            /* unsupported value, stop parsing and set the size to an error
             * value */
            list_size = MBEDTLS_TLS_SRTP_MAX_PROFILE_LIST_LENGTH + 1;
        }
    }

    if (list_size > MBEDTLS_TLS_SRTP_MAX_PROFILE_LIST_LENGTH) {
        conf->dtls_srtp_profile_list = NULL;
        conf->dtls_srtp_profile_list_len = 0;
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    conf->dtls_srtp_profile_list = profiles;
    conf->dtls_srtp_profile_list_len = list_size;

    return 0;
}

void mbedtls_ssl_get_dtls_srtp_negotiation_result(
    const mbedtls_ssl_context *ssl,
    mbedtls_dtls_srtp_info *dtls_srtp_info)
{
    dtls_srtp_info->chosen_dtls_srtp_profile =
        ssl->dtls_srtp_info.chosen_dtls_srtp_profile;
    /* do not copy the mki value if there is no chosen profile */
    if (dtls_srtp_info->chosen_dtls_srtp_profile == MBEDTLS_TLS_SRTP_UNSET) {
        dtls_srtp_info->mki_len = 0;
    } else {
        dtls_srtp_info->mki_len = ssl->dtls_srtp_info.mki_len;
        memcpy(dtls_srtp_info->mki_value, ssl->dtls_srtp_info.mki_value,
               ssl->dtls_srtp_info.mki_len);
    }
}
#    endif /* MBEDTLS_SSL_DTLS_SRTP */

void mbedtls_ssl_conf_max_version(mbedtls_ssl_config *conf,
                                  int major,
                                  int minor)
{
    conf->max_major_ver = major;
    conf->max_minor_ver = minor;
}

void mbedtls_ssl_conf_min_version(mbedtls_ssl_config *conf,
                                  int major,
                                  int minor)
{
    conf->min_major_ver = major;
    conf->min_minor_ver = minor;
}

#    if defined(MBEDTLS_SSL_SRV_C)
void mbedtls_ssl_conf_cert_req_ca_list(mbedtls_ssl_config *conf,
                                       char cert_req_ca_list)
{
    conf->cert_req_ca_list = cert_req_ca_list;
}
#    endif

#    if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
void mbedtls_ssl_conf_encrypt_then_mac(mbedtls_ssl_config *conf, char etm)
{
    conf->encrypt_then_mac = etm;
}
#    endif

#    if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
void mbedtls_ssl_conf_extended_master_secret(mbedtls_ssl_config *conf, char ems)
{
    conf->extended_ms = ems;
}
#    endif

#    if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
int mbedtls_ssl_conf_max_frag_len(mbedtls_ssl_config *conf,
                                  unsigned char mfl_code)
{
    if (mfl_code >= MBEDTLS_SSL_MAX_FRAG_LEN_INVALID ||
        ssl_mfl_code_to_length(mfl_code) > MBEDTLS_TLS_EXT_ADV_CONTENT_LEN) {
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    conf->mfl_code = mfl_code;

    return 0;
}
#    endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */

void mbedtls_ssl_conf_legacy_renegotiation(mbedtls_ssl_config *conf,
                                           int allow_legacy)
{
    conf->allow_legacy_renegotiation = allow_legacy;
}

#    if defined(MBEDTLS_SSL_RENEGOTIATION)
void mbedtls_ssl_conf_renegotiation(mbedtls_ssl_config *conf, int renegotiation)
{
    conf->disable_renegotiation = renegotiation;
}

void mbedtls_ssl_conf_renegotiation_enforced(mbedtls_ssl_config *conf,
                                             int max_records)
{
    conf->renego_max_records = max_records;
}

void mbedtls_ssl_conf_renegotiation_period(mbedtls_ssl_config *conf,
                                           const unsigned char period[8])
{
    memcpy(conf->renego_period, period, 8);
}
#    endif /* MBEDTLS_SSL_RENEGOTIATION */

#    if defined(MBEDTLS_SSL_SESSION_TICKETS)
#        if defined(MBEDTLS_SSL_CLI_C)
void mbedtls_ssl_conf_session_tickets(mbedtls_ssl_config *conf, int use_tickets)
{
    conf->session_tickets = use_tickets;
}
#        endif

#        if defined(MBEDTLS_SSL_SRV_C)
void mbedtls_ssl_conf_session_tickets_cb(
    mbedtls_ssl_config *conf,
    mbedtls_ssl_ticket_write_t *f_ticket_write,
    mbedtls_ssl_ticket_parse_t *f_ticket_parse,
    void *p_ticket)
{
    conf->f_ticket_write = f_ticket_write;
    conf->f_ticket_parse = f_ticket_parse;
    conf->p_ticket = p_ticket;
}
#        endif
#    endif /* MBEDTLS_SSL_SESSION_TICKETS */

#    if defined(MBEDTLS_SSL_EXPORT_KEYS)
void mbedtls_ssl_set_export_keys_cb(mbedtls_ssl_context *ssl,
                                    mbedtls_ssl_export_keys_t *f_export_keys,
                                    void *p_export_keys)
{
    ssl->f_export_keys = f_export_keys;
    ssl->p_export_keys = p_export_keys;
}
#    endif

#    if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
void mbedtls_ssl_conf_async_private_cb(
    mbedtls_ssl_config *conf,
    mbedtls_ssl_async_sign_t *f_async_sign,
    mbedtls_ssl_async_decrypt_t *f_async_decrypt,
    mbedtls_ssl_async_resume_t *f_async_resume,
    mbedtls_ssl_async_cancel_t *f_async_cancel,
    void *async_config_data)
{
    conf->f_async_sign_start = f_async_sign;
    conf->f_async_decrypt_start = f_async_decrypt;
    conf->f_async_resume = f_async_resume;
    conf->f_async_cancel = f_async_cancel;
    conf->p_async_config_data = async_config_data;
}

void *mbedtls_ssl_conf_get_async_config_data(const mbedtls_ssl_config *conf)
{
    return conf->p_async_config_data;
}

void *mbedtls_ssl_get_async_operation_data(const mbedtls_ssl_context *ssl)
{
    if (ssl->handshake == NULL)
        return NULL;
    else
        return ssl->handshake->user_async_ctx;
}

void mbedtls_ssl_set_async_operation_data(mbedtls_ssl_context *ssl, void *ctx)
{
    if (ssl->handshake != NULL)
        ssl->handshake->user_async_ctx = ctx;
}
#    endif /* MBEDTLS_SSL_ASYNC_PRIVATE */

/*
 * SSL get accessors
 */
uint32_t mbedtls_ssl_get_verify_result(const mbedtls_ssl_context *ssl)
{
    if (ssl->session != NULL)
        return ssl->session->verify_result;

    if (ssl->session_negotiate != NULL)
        return ssl->session_negotiate->verify_result;

    return 0xFFFFFFFF;
}

const char *mbedtls_ssl_get_ciphersuite(const mbedtls_ssl_context *ssl)
{
    if (ssl == NULL || ssl->session == NULL)
        return NULL;

    return mbedtls_ssl_get_ciphersuite_name(ssl->session->ciphersuite);
}

const char *mbedtls_ssl_get_version(const mbedtls_ssl_context *ssl)
{
#    if defined(MBEDTLS_SSL_PROTO_DTLS)
    if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
        switch (ssl->minor_ver) {
            case MBEDTLS_SSL_MINOR_VERSION_3:
                return "DTLSv1.2";

            default:
                return "unknown (DTLS)";
        }
    }
#    endif

    switch (ssl->minor_ver) {
        case MBEDTLS_SSL_MINOR_VERSION_3:
            return "TLSv1.2";

        default:
            return "unknown";
    }
}

#    if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
size_t mbedtls_ssl_get_input_max_frag_len(const mbedtls_ssl_context *ssl)
{
    size_t max_len = MBEDTLS_SSL_IN_CONTENT_LEN;
    size_t read_mfl;

    /* Use the configured MFL for the client if we're past SERVER_HELLO_DONE */
    if (ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT &&
        ssl->state >= MBEDTLS_SSL_SERVER_HELLO_DONE) {
        return ssl_mfl_code_to_length(ssl->conf->mfl_code);
    }

    /* Check if a smaller max length was negotiated */
    if (ssl->session_out != NULL) {
        read_mfl = ssl_mfl_code_to_length(ssl->session_out->mfl_code);
        if (read_mfl < max_len) {
            max_len = read_mfl;
        }
    }

    // During a handshake, use the value being negotiated
    if (ssl->session_negotiate != NULL) {
        read_mfl = ssl_mfl_code_to_length(ssl->session_negotiate->mfl_code);
        if (read_mfl < max_len) {
            max_len = read_mfl;
        }
    }

    return max_len;
}

size_t mbedtls_ssl_get_output_max_frag_len(const mbedtls_ssl_context *ssl)
{
    size_t max_len;

    /*
     * Assume mfl_code is correct since it was checked when set
     */
    max_len = ssl_mfl_code_to_length(ssl->conf->mfl_code);

    /* Check if a smaller max length was negotiated */
    if (ssl->session_out != NULL &&
        ssl_mfl_code_to_length(ssl->session_out->mfl_code) < max_len) {
        max_len = ssl_mfl_code_to_length(ssl->session_out->mfl_code);
    }

    /* During a handshake, use the value being negotiated */
    if (ssl->session_negotiate != NULL &&
        ssl_mfl_code_to_length(ssl->session_negotiate->mfl_code) < max_len) {
        max_len = ssl_mfl_code_to_length(ssl->session_negotiate->mfl_code);
    }

    return max_len;
}
#    endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
size_t mbedtls_ssl_get_current_mtu(const mbedtls_ssl_context *ssl)
{
    /* Return unlimited mtu for client hello messages to avoid fragmentation. */
    if (ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT &&
        (ssl->state == MBEDTLS_SSL_CLIENT_HELLO ||
         ssl->state == MBEDTLS_SSL_SERVER_HELLO))
        return 0;

    if (ssl->handshake == NULL || ssl->handshake->mtu == 0)
        return ssl->mtu;

    if (ssl->mtu == 0)
        return ssl->handshake->mtu;

    return (ssl->mtu < ssl->handshake->mtu ? ssl->mtu : ssl->handshake->mtu);
}
#    endif /* MBEDTLS_SSL_PROTO_DTLS */

int mbedtls_ssl_get_max_out_record_payload(const mbedtls_ssl_context *ssl)
{
    size_t max_len = MBEDTLS_SSL_OUT_CONTENT_LEN;

#    if !defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH) && \
        !defined(MBEDTLS_SSL_PROTO_DTLS)
    (void)ssl;
#    endif

#    if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
    const size_t mfl = mbedtls_ssl_get_output_max_frag_len(ssl);

    if (max_len > mfl)
        max_len = mfl;
#    endif

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
    if (mbedtls_ssl_get_current_mtu(ssl) != 0) {
        const size_t mtu = mbedtls_ssl_get_current_mtu(ssl);
        const int ret = mbedtls_ssl_get_record_expansion(ssl);
        const size_t overhead = (size_t)ret;

        if (ret < 0)
            return ret;

        if (mtu <= overhead) {
            MBEDTLS_SSL_DEBUG_MSG(1, ("MTU too low for record expansion"));
            return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
        }

        if (max_len > mtu - overhead)
            max_len = mtu - overhead;
    }
#    endif /* MBEDTLS_SSL_PROTO_DTLS */

#    if !defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH) && \
        !defined(MBEDTLS_SSL_PROTO_DTLS)
    ((void)ssl);
#    endif

    return (int)max_len;
}

int mbedtls_ssl_get_max_in_record_payload(const mbedtls_ssl_context *ssl)
{
    size_t max_len = MBEDTLS_SSL_IN_CONTENT_LEN;

#    if !defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
    (void)ssl;
#    endif

#    if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
    const size_t mfl = mbedtls_ssl_get_input_max_frag_len(ssl);

    if (max_len > mfl)
        max_len = mfl;
#    endif

    return (int)max_len;
}

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
const mbedtls_x509_crt *
mbedtls_ssl_get_peer_cert(const mbedtls_ssl_context *ssl)
{
    if (ssl == NULL || ssl->session == NULL)
        return NULL;

#        if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
    return ssl->session->peer_cert;
#        else
    return NULL;
#        endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
}
#    endif /* MBEDTLS_X509_CRT_PARSE_C */

#    if defined(MBEDTLS_SSL_CLI_C)
int mbedtls_ssl_get_session(const mbedtls_ssl_context *ssl,
                            mbedtls_ssl_session *dst)
{
    int ret;

    if (ssl == NULL || dst == NULL || ssl->session == NULL ||
        ssl->conf->endpoint != MBEDTLS_SSL_IS_CLIENT) {
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    /* Since Mbed TLS 3.0, mbedtls_ssl_get_session() is no longer
     * idempotent: Each session can only be exported once.
     *
     * (This is in preparation for TLS 1.3 support where we will
     * need the ability to export multiple sessions (aka tickets),
     * which will be achieved by calling mbedtls_ssl_get_session()
     * multiple times until it fails.)
     *
     * Check whether we have already exported the current session,
     * and fail if so.
     */
    if (ssl->session->exported == 1)
        return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;

    ret = mbedtls_ssl_session_copy(dst, ssl->session);
    if (ret != 0)
        return ret;

    /* Remember that we've exported the session. */
    ssl->session->exported = 1;
    return 0;
}
#    endif /* MBEDTLS_SSL_CLI_C */

/*
 * Define ticket header determining Mbed TLS version
 * and structure of the ticket.
 */

/*
 * Define bitflag determining compile-time settings influencing
 * structure of serialized SSL sessions.
 */

#    if defined(MBEDTLS_HAVE_TIME)
#        define SSL_SERIALIZED_SESSION_CONFIG_TIME 1
#    else
#        define SSL_SERIALIZED_SESSION_CONFIG_TIME 0
#    endif /* MBEDTLS_HAVE_TIME */

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
#        define SSL_SERIALIZED_SESSION_CONFIG_CRT 1
#    else
#        define SSL_SERIALIZED_SESSION_CONFIG_CRT 0
#    endif /* MBEDTLS_X509_CRT_PARSE_C */

#    if defined(MBEDTLS_SSL_CLI_C) && defined(MBEDTLS_SSL_SESSION_TICKETS)
#        define SSL_SERIALIZED_SESSION_CONFIG_CLIENT_TICKET 1
#    else
#        define SSL_SERIALIZED_SESSION_CONFIG_CLIENT_TICKET 0
#    endif /* MBEDTLS_SSL_CLI_C && MBEDTLS_SSL_SESSION_TICKETS */

#    if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
#        define SSL_SERIALIZED_SESSION_CONFIG_MFL 1
#    else
#        define SSL_SERIALIZED_SESSION_CONFIG_MFL 0
#    endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */

#    if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
#        define SSL_SERIALIZED_SESSION_CONFIG_ETM 1
#    else
#        define SSL_SERIALIZED_SESSION_CONFIG_ETM 0
#    endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */

#    if defined(MBEDTLS_SSL_SESSION_TICKETS)
#        define SSL_SERIALIZED_SESSION_CONFIG_TICKET 1
#    else
#        define SSL_SERIALIZED_SESSION_CONFIG_TICKET 0
#    endif /* MBEDTLS_SSL_SESSION_TICKETS */

#    define SSL_SERIALIZED_SESSION_CONFIG_TIME_BIT          0
#    define SSL_SERIALIZED_SESSION_CONFIG_CRT_BIT           1
#    define SSL_SERIALIZED_SESSION_CONFIG_CLIENT_TICKET_BIT 2
#    define SSL_SERIALIZED_SESSION_CONFIG_MFL_BIT           3
#    define SSL_SERIALIZED_SESSION_CONFIG_ETM_BIT           4
#    define SSL_SERIALIZED_SESSION_CONFIG_TICKET_BIT        5

#    define SSL_SERIALIZED_SESSION_CONFIG_BITFLAG                          \
        ((uint16_t)((SSL_SERIALIZED_SESSION_CONFIG_TIME                    \
                     << SSL_SERIALIZED_SESSION_CONFIG_TIME_BIT) |          \
                    (SSL_SERIALIZED_SESSION_CONFIG_CRT                     \
                     << SSL_SERIALIZED_SESSION_CONFIG_CRT_BIT) |           \
                    (SSL_SERIALIZED_SESSION_CONFIG_CLIENT_TICKET           \
                     << SSL_SERIALIZED_SESSION_CONFIG_CLIENT_TICKET_BIT) | \
                    (SSL_SERIALIZED_SESSION_CONFIG_MFL                     \
                     << SSL_SERIALIZED_SESSION_CONFIG_MFL_BIT) |           \
                    (SSL_SERIALIZED_SESSION_CONFIG_ETM                     \
                     << SSL_SERIALIZED_SESSION_CONFIG_ETM_BIT) |           \
                    (SSL_SERIALIZED_SESSION_CONFIG_TICKET                  \
                     << SSL_SERIALIZED_SESSION_CONFIG_TICKET_BIT)))

static unsigned char ssl_serialized_session_header[] = {
    MBEDTLS_VERSION_MAJOR,
    MBEDTLS_VERSION_MINOR,
    MBEDTLS_VERSION_PATCH,
    (SSL_SERIALIZED_SESSION_CONFIG_BITFLAG >> 8) & 0xFF,
    (SSL_SERIALIZED_SESSION_CONFIG_BITFLAG >> 0) & 0xFF,
};

/*
 * Serialize a session in the following format:
 * (in the presentation language of TLS, RFC 8446 section 3)
 *
 *  struct {
 *
 *    opaque mbedtls_version[3];   // library version: major, minor, patch
 *    opaque session_format[2];    // library-version specific 16-bit field
 *                                 // determining the format of the remaining
 *                                 // serialized data.
 *
 *          Note: When updating the format, remember to keep
 *          these version+format bytes.
 *
 *                                 // In this version, `session_format` determines
 *                                 // the setting of those compile-time
 *                                 // configuration options which influence
 *                                 // the structure of mbedtls_ssl_session.
 *
 *    uint8_t minor_ver;           // Protocol-version. Possible values:
 *                                 // - TLS 1.2 (MBEDTLS_SSL_MINOR_VERSION_3)
 *
 *    select (serialized_session.minor_ver) {
 *
 *      case MBEDTLS_SSL_MINOR_VERSION_3: // TLS 1.2
 *        serialized_session_tls12 data;
 *
 *   };
 *
 * } serialized_session;
 *
 */

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
/* Serialization of TLS 1.2 sessions:
 *
 * struct {
 *    uint64 start_time;
 *    uint8 ciphersuite[2];           // defined by the standard
 *    uint8 compression;              // 0 or 1
 *    uint8 session_id_len;           // at most 32
 *    opaque session_id[32];
 *    opaque master[48];              // fixed length in the standard
 *    uint32 verify_result;
 *    opaque peer_cert<0..2^24-1>;    // length 0 means no peer cert
 *    opaque ticket<0..2^24-1>;       // length 0 means no ticket
 *    uint32 ticket_lifetime;
 *    uint8 mfl_code;                 // up to 255 according to standard
 *    uint8 encrypt_then_mac;         // 0 or 1
 * } serialized_session_tls12;
 *
 */
static size_t ssl_session_save_tls12(const mbedtls_ssl_session *session,
                                     unsigned char *buf,
                                     size_t buf_len)
{
    unsigned char *p = buf;
    size_t used = 0;

#        if defined(MBEDTLS_HAVE_TIME)
    uint64_t start;
#        endif
#        if defined(MBEDTLS_X509_CRT_PARSE_C)
#            if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
    size_t cert_len;
#            endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
#        endif /* MBEDTLS_X509_CRT_PARSE_C */

    /*
     * Time
     */
#        if defined(MBEDTLS_HAVE_TIME)
    used += 8;

    if (used <= buf_len) {
        start = (uint64_t)session->start;

        *p++ = (unsigned char)((start >> 56) & 0xFF);
        *p++ = (unsigned char)((start >> 48) & 0xFF);
        *p++ = (unsigned char)((start >> 40) & 0xFF);
        *p++ = (unsigned char)((start >> 32) & 0xFF);
        *p++ = (unsigned char)((start >> 24) & 0xFF);
        *p++ = (unsigned char)((start >> 16) & 0xFF);
        *p++ = (unsigned char)((start >> 8) & 0xFF);
        *p++ = (unsigned char)((start)&0xFF);
    }
#        endif /* MBEDTLS_HAVE_TIME */

    /*
     * Basic mandatory fields
     */
    used += 2 /* ciphersuite */
            + 1 /* compression */
            + 1 /* id_len */
            + sizeof(session->id) + sizeof(session->master) +
            4; /* verify_result
                */

    if (used <= buf_len) {
        *p++ = (unsigned char)((session->ciphersuite >> 8) & 0xFF);
        *p++ = (unsigned char)((session->ciphersuite) & 0xFF);

        *p++ = (unsigned char)(session->compression & 0xFF);

        *p++ = (unsigned char)(session->id_len & 0xFF);
        memcpy(p, session->id, 32);
        p += 32;

        memcpy(p, session->master, 48);
        p += 48;

        *p++ = (unsigned char)((session->verify_result >> 24) & 0xFF);
        *p++ = (unsigned char)((session->verify_result >> 16) & 0xFF);
        *p++ = (unsigned char)((session->verify_result >> 8) & 0xFF);
        *p++ = (unsigned char)((session->verify_result) & 0xFF);
    }

    /*
     * Peer's end-entity certificate
     */
#        if defined(MBEDTLS_X509_CRT_PARSE_C)
#            if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
    if (session->peer_cert == NULL)
        cert_len = 0;
    else
        cert_len = session->peer_cert->raw.len;

    used += 3 + cert_len;

    if (used <= buf_len) {
        *p++ = (unsigned char)((cert_len >> 16) & 0xFF);
        *p++ = (unsigned char)((cert_len >> 8) & 0xFF);
        *p++ = (unsigned char)((cert_len)&0xFF);

        if (session->peer_cert != NULL) {
            memcpy(p, session->peer_cert->raw.p, cert_len);
            p += cert_len;
        }
    }
#            else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
    if (session->peer_cert_digest != NULL) {
        used += 1 /* type */ + 1 /* length */ + session->peer_cert_digest_len;
        if (used <= buf_len) {
            *p++ = (unsigned char)session->peer_cert_digest_type;
            *p++ = (unsigned char)session->peer_cert_digest_len;
            memcpy(p, session->peer_cert_digest, session->peer_cert_digest_len);
            p += session->peer_cert_digest_len;
        }
    } else {
        used += 2;
        if (used <= buf_len) {
            *p++ = (unsigned char)MBEDTLS_MD_NONE;
            *p++ = 0;
        }
    }
#            endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
#        endif /* MBEDTLS_X509_CRT_PARSE_C */

    /*
     * Session ticket if any, plus associated data
     */
#        if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
    used += 3 + session->ticket_len + 4; /* len + ticket + lifetime */

    if (used <= buf_len) {
        *p++ = (unsigned char)((session->ticket_len >> 16) & 0xFF);
        *p++ = (unsigned char)((session->ticket_len >> 8) & 0xFF);
        *p++ = (unsigned char)((session->ticket_len) & 0xFF);

        if (session->ticket != NULL) {
            memcpy(p, session->ticket, session->ticket_len);
            p += session->ticket_len;
        }

        *p++ = (unsigned char)((session->ticket_lifetime >> 24) & 0xFF);
        *p++ = (unsigned char)((session->ticket_lifetime >> 16) & 0xFF);
        *p++ = (unsigned char)((session->ticket_lifetime >> 8) & 0xFF);
        *p++ = (unsigned char)((session->ticket_lifetime) & 0xFF);
    }
#        endif /* MBEDTLS_SSL_SESSION_TICKETS && MBEDTLS_SSL_CLI_C */

    /*
     * Misc extension-related info
     */
#        if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
    used += 1;

    if (used <= buf_len)
        *p++ = session->mfl_code;
#        endif

#        if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
    used += 1;

    if (used <= buf_len)
        *p++ = (unsigned char)((session->encrypt_then_mac) & 0xFF);
#        endif

    return used;
}
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

static int ssl_session_save(const mbedtls_ssl_session *session,
                            unsigned char omit_header,
                            unsigned char *buf,
                            size_t buf_len,
                            size_t *olen)
{
    unsigned char *p = buf;
    size_t used = 0;

    if (!omit_header) {
        /*
         * Add Mbed TLS version identifier
         */

        used += sizeof(ssl_serialized_session_header);

        if (used <= buf_len) {
            memcpy(p, ssl_serialized_session_header,
                   sizeof(ssl_serialized_session_header));
            p += sizeof(ssl_serialized_session_header);
        }
    }

    /*
     * TLS version identifier
     */
    used += 1;
    if (used <= buf_len) {
        *p++ = session->minor_ver;
    }

    /* Forward to version-specific serialization routine. */
    switch (session->minor_ver) {
#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
        case MBEDTLS_SSL_MINOR_VERSION_3:
            {
                size_t remaining_len = used <= buf_len ? buf_len - used : 0;
                used += ssl_session_save_tls12(session, p, remaining_len);
                break;
            }
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

        default:
            return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
    }

    *olen = used;
    if (used > buf_len)
        return MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL;

    return 0;
}

/*
 * Public wrapper for ssl_session_save()
 */
int mbedtls_ssl_session_save(const mbedtls_ssl_session *session,
                             unsigned char *buf,
                             size_t buf_len,
                             size_t *olen)
{
    return ssl_session_save(session, 0, buf, buf_len, olen);
}

/*
 * Deserialize session, see mbedtls_ssl_session_save() for format.
 *
 * This internal version is wrapped by a public function that cleans up in
 * case of error, and has an extra option omit_header.
 */
static int ssl_session_load_tls12(mbedtls_ssl_session *session,
                                  const unsigned char *buf,
                                  size_t len)
{
#    if defined(MBEDTLS_HAVE_TIME)
    uint64_t start;
#    endif
#    if defined(MBEDTLS_X509_CRT_PARSE_C)
#        if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
    size_t cert_len;
#        endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
#    endif /* MBEDTLS_X509_CRT_PARSE_C */

    const unsigned char *p = buf;
    const unsigned char *const end = buf + len;

    /*
     * Time
     */
#    if defined(MBEDTLS_HAVE_TIME)
    if (8 > (size_t)(end - p))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    start = ((uint64_t)p[0] << 56) | ((uint64_t)p[1] << 48) |
            ((uint64_t)p[2] << 40) | ((uint64_t)p[3] << 32) |
            ((uint64_t)p[4] << 24) | ((uint64_t)p[5] << 16) |
            ((uint64_t)p[6] << 8) | ((uint64_t)p[7]);
    p += 8;

    session->start = (time_t)start;
#    endif /* MBEDTLS_HAVE_TIME */

    /*
     * Basic mandatory fields
     */
    if (2 + 1 + 1 + 32 + 48 + 4 > (size_t)(end - p))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    session->ciphersuite = (p[0] << 8) | p[1];
    p += 2;

    session->compression = *p++;

    session->id_len = *p++;
    memcpy(session->id, p, 32);
    p += 32;

    memcpy(session->master, p, 48);
    p += 48;

    session->verify_result = ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
                             ((uint32_t)p[2] << 8) | ((uint32_t)p[3]);
    p += 4;

    /* Immediately clear invalid pointer values that have been read, in case
     * we exit early before we replaced them with valid ones. */
#    if defined(MBEDTLS_X509_CRT_PARSE_C)
#        if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
    session->peer_cert = NULL;
#        else
    session->peer_cert_digest = NULL;
#        endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
#    endif /* MBEDTLS_X509_CRT_PARSE_C */
#    if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
    session->ticket = NULL;
#    endif /* MBEDTLS_SSL_SESSION_TICKETS && MBEDTLS_SSL_CLI_C */

    /*
     * Peer certificate
     */
#    if defined(MBEDTLS_X509_CRT_PARSE_C)
#        if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
    /* Deserialize CRT from the end of the ticket. */
    if (3 > (size_t)(end - p))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    cert_len = (p[0] << 16) | (p[1] << 8) | p[2];
    p += 3;

    if (cert_len != 0) {
        int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

        if (cert_len > (size_t)(end - p))
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

        session->peer_cert = mbedtls_calloc(1, sizeof(mbedtls_x509_crt));

        if (session->peer_cert == NULL)
            return MBEDTLS_ERR_SSL_ALLOC_FAILED;

        mbedtls_x509_crt_init(session->peer_cert);

        if ((ret = mbedtls_x509_crt_parse_der(session->peer_cert, p,
                                              cert_len)) != 0) {
            mbedtls_x509_crt_free(session->peer_cert);
            mbedtls_free(session->peer_cert);
            session->peer_cert = NULL;
            return ret;
        }

        p += cert_len;
    }
#        else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
    /* Deserialize CRT digest from the end of the ticket. */
    if (2 > (size_t)(end - p))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    session->peer_cert_digest_type = (mbedtls_md_type_t)*p++;
    session->peer_cert_digest_len = (size_t)*p++;

    if (session->peer_cert_digest_len != 0) {
        const mbedtls_md_info_t *md_info =
            mbedtls_md_info_from_type(session->peer_cert_digest_type);
        if (md_info == NULL)
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
        if (session->peer_cert_digest_len != mbedtls_md_get_size(md_info))
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

        if (session->peer_cert_digest_len > (size_t)(end - p))
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

        session->peer_cert_digest =
            mbedtls_calloc(1, session->peer_cert_digest_len);
        if (session->peer_cert_digest == NULL)
            return MBEDTLS_ERR_SSL_ALLOC_FAILED;

        memcpy(session->peer_cert_digest, p, session->peer_cert_digest_len);
        p += session->peer_cert_digest_len;
    }
#        endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
#    endif /* MBEDTLS_X509_CRT_PARSE_C */

    /*
     * Session ticket and associated data
     */
#    if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
    if (3 > (size_t)(end - p))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    session->ticket_len = (p[0] << 16) | (p[1] << 8) | p[2];
    p += 3;

    if (session->ticket_len != 0) {
        if (session->ticket_len > (size_t)(end - p))
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

        session->ticket = mbedtls_calloc(1, session->ticket_len);
        if (session->ticket == NULL)
            return MBEDTLS_ERR_SSL_ALLOC_FAILED;

        memcpy(session->ticket, p, session->ticket_len);
        p += session->ticket_len;
    }

    if (4 > (size_t)(end - p))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    session->ticket_lifetime = ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
                               ((uint32_t)p[2] << 8) | ((uint32_t)p[3]);
    p += 4;
#    endif /* MBEDTLS_SSL_SESSION_TICKETS && MBEDTLS_SSL_CLI_C */

    /*
     * Misc extension-related info
     */
#    if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
    if (1 > (size_t)(end - p))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    session->mfl_code = *p++;
#    endif

#    if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
    if (1 > (size_t)(end - p))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    session->encrypt_then_mac = *p++;
#    endif

    /* Done, should have consumed entire buffer */
    if (p != end)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    return 0;
}

static int ssl_session_load(mbedtls_ssl_session *session,
                            unsigned char omit_header,
                            const unsigned char *buf,
                            size_t len)
{
    const unsigned char *p = buf;
    const unsigned char *const end = buf + len;

    if (!omit_header) {
        /*
         * Check Mbed TLS version identifier
         */

        if ((size_t)(end - p) < sizeof(ssl_serialized_session_header))
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

        if (memcmp(p, ssl_serialized_session_header,
                   sizeof(ssl_serialized_session_header)) != 0) {
            return MBEDTLS_ERR_SSL_VERSION_MISMATCH;
        }
        p += sizeof(ssl_serialized_session_header);
    }

    /*
     * TLS version identifier
     */
    if (1 > (size_t)(end - p))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    session->minor_ver = *p++;

    /* Dispatch according to TLS version. */
    switch (session->minor_ver) {
#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
        case MBEDTLS_SSL_MINOR_VERSION_3: /* TLS 1.2 */
            {
                size_t remaining_len = (end - p);
                return ssl_session_load_tls12(session, p, remaining_len);
            }
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

        default:
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }
}

/*
 * Deserialize session: public wrapper for error cleaning
 */
int mbedtls_ssl_session_load(mbedtls_ssl_session *session,
                             const unsigned char *buf,
                             size_t len)
{
    int ret = ssl_session_load(session, 0, buf, len);

    if (ret != 0)
        mbedtls_ssl_session_free(session);

    return ret;
}

/*
 * Perform a single step of the SSL handshake
 */
int mbedtls_ssl_handshake_step(mbedtls_ssl_context *ssl)
{
    int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;

    if (ssl == NULL || ssl->conf == NULL)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

#    if defined(MBEDTLS_SSL_CLI_C)
    if (ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT)
        ret = mbedtls_ssl_handshake_client_step(ssl);
#    endif
#    if defined(MBEDTLS_SSL_SRV_C)
    if (ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER)
        ret = mbedtls_ssl_handshake_server_step(ssl);
#    endif

    return ret;
}

/*
 * Perform the SSL handshake
 */
int mbedtls_ssl_handshake(mbedtls_ssl_context *ssl)
{
    int ret = 0;

    /* Sanity checks */

    if (ssl == NULL || ssl->conf == NULL)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
    if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
        (ssl->f_set_timer == NULL || ssl->f_get_timer == NULL)) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("You must use "
                                  "mbedtls_ssl_set_timer_cb() for DTLS"));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }
#    endif /* MBEDTLS_SSL_PROTO_DTLS */

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> handshake"));

    /* Main handshake loop */
    while (ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER) {
        ret = mbedtls_ssl_handshake_step(ssl);

        if (ret != 0)
            break;
    }

    MBEDTLS_SSL_DEBUG_MSG(2, ("<= handshake"));

    return ret;
}

#    if defined(MBEDTLS_SSL_RENEGOTIATION)
#        if defined(MBEDTLS_SSL_SRV_C)
/*
 * Write HelloRequest to request renegotiation on server
 */
static int ssl_write_hello_request(mbedtls_ssl_context *ssl)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> write hello request"));

    ssl->out_msglen = 4;
    ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
    ssl->out_msg[0] = MBEDTLS_SSL_HS_HELLO_REQUEST;

    if ((ret = mbedtls_ssl_write_handshake_msg(ssl)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_handshake_msg", ret);
        return ret;
    }

    MBEDTLS_SSL_DEBUG_MSG(2, ("<= write hello request"));

    return 0;
}
#        endif /* MBEDTLS_SSL_SRV_C */

/*
 * Actually renegotiate current connection, triggered by either:
 * - any side: calling mbedtls_ssl_renegotiate(),
 * - client: receiving a HelloRequest during mbedtls_ssl_read(),
 * - server: receiving any handshake message on server during mbedtls_ssl_read()
 * after the initial handshake is completed. If the handshake doesn't complete
 * due to waiting for I/O, it will continue during the next calls to
 * mbedtls_ssl_renegotiate() or mbedtls_ssl_read() respectively.
 */
int mbedtls_ssl_start_renegotiation(mbedtls_ssl_context *ssl)
{
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> renegotiate"));

    if ((ret = ssl_handshake_init(ssl)) != 0)
        return ret;

        /* RFC 6347 4.2.2: "[...] the HelloRequest will have message_seq = 0 and
         * the ServerHello will have message_seq = 1" */
#        if defined(MBEDTLS_SSL_PROTO_DTLS)
    if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
        ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING) {
        if (ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER)
            ssl->handshake->out_msg_seq = 1;
        else
            ssl->handshake->in_msg_seq = 1;
    }
#        endif

    ssl->state = MBEDTLS_SSL_HELLO_REQUEST;
    ssl->renego_status = MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS;

    if ((ret = mbedtls_ssl_handshake(ssl)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_handshake", ret);
        return ret;
    }

    MBEDTLS_SSL_DEBUG_MSG(2, ("<= renegotiate"));

    return 0;
}

/*
 * Renegotiate current connection on client,
 * or request renegotiation on server
 */
int mbedtls_ssl_renegotiate(mbedtls_ssl_context *ssl)
{
    int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;

    if (ssl == NULL || ssl->conf == NULL)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

#        if defined(MBEDTLS_SSL_SRV_C)
    /* On server, just send the request */
    if (ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER) {
        if (ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER)
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

        ssl->renego_status = MBEDTLS_SSL_RENEGOTIATION_PENDING;

        /* Did we already try/start sending HelloRequest? */
        if (ssl->out_left != 0)
            return mbedtls_ssl_flush_output(ssl);

        return ssl_write_hello_request(ssl);
    }
#        endif /* MBEDTLS_SSL_SRV_C */

#        if defined(MBEDTLS_SSL_CLI_C)
    /*
     * On client, either start the renegotiation process or,
     * if already in progress, continue the handshake
     */
    if (ssl->renego_status != MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS) {
        if (ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER)
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

        if ((ret = mbedtls_ssl_start_renegotiation(ssl)) != 0) {
            MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_start_renegotiation", ret);
            return ret;
        }
    } else {
        if ((ret = mbedtls_ssl_handshake(ssl)) != 0) {
            MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_handshake", ret);
            return ret;
        }
    }
#        endif /* MBEDTLS_SSL_CLI_C */

    return ret;
}
#    endif /* MBEDTLS_SSL_RENEGOTIATION */

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
static void ssl_key_cert_free(mbedtls_ssl_key_cert *key_cert)
{
    mbedtls_ssl_key_cert *cur = key_cert, *next;

    while (cur != NULL) {
        next = cur->next;
        mbedtls_free(cur);
        cur = next;
    }
}
#    endif /* MBEDTLS_X509_CRT_PARSE_C */

void mbedtls_ssl_handshake_free(mbedtls_ssl_context *ssl)
{
    mbedtls_ssl_handshake_params *handshake = ssl->handshake;

    if (handshake == NULL)
        return;

#    if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
    if (ssl->conf->f_async_cancel != NULL &&
        handshake->async_in_progress != 0) {
        ssl->conf->f_async_cancel(ssl);
        handshake->async_in_progress = 0;
    }
#    endif /* MBEDTLS_SSL_ASYNC_PRIVATE */

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
#        if defined(MBEDTLS_SHA256_C)
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    psa_hash_abort(&handshake->fin_sha256_psa);
#            else
    mbedtls_sha256_free(&handshake->fin_sha256);
#            endif
#        endif
#        if defined(MBEDTLS_SHA384_C)
#            if defined(MBEDTLS_USE_PSA_CRYPTO)
    psa_hash_abort(&handshake->fin_sha384_psa);
#            else
    mbedtls_sha512_free(&handshake->fin_sha512);
#            endif
#        endif
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

#    if defined(MBEDTLS_DHM_C)
    mbedtls_dhm_free(&handshake->dhm_ctx);
#    endif
#    if defined(MBEDTLS_ECDH_C)
    mbedtls_ecdh_free(&handshake->ecdh_ctx);
#    endif
#    if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
    mbedtls_ecjpake_free(&handshake->ecjpake_ctx);
#        if defined(MBEDTLS_SSL_CLI_C)
    mbedtls_free(handshake->ecjpake_cache);
    handshake->ecjpake_cache = NULL;
    handshake->ecjpake_cache_len = 0;
#        endif
#    endif

#    if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
        defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
    /* explicit void pointer cast for buggy MS compiler */
    mbedtls_free((void *)handshake->curves);
#    endif

#    if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
    if (handshake->psk != NULL) {
        mbedtls_platform_zeroize(handshake->psk, handshake->psk_len);
        mbedtls_free(handshake->psk);
    }
#    endif

#    if defined(MBEDTLS_X509_CRT_PARSE_C) && \
        defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
    /*
     * Free only the linked list wrapper, not the keys themselves
     * since the belong to the SNI callback
     */
    if (handshake->sni_key_cert != NULL) {
        mbedtls_ssl_key_cert *cur = handshake->sni_key_cert, *next;

        while (cur != NULL) {
            next = cur->next;
            mbedtls_free(cur);
            cur = next;
        }
    }
#    endif /* MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_SSL_SERVER_NAME_INDICATION \
            */

#    if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
    mbedtls_x509_crt_restart_free(&handshake->ecrs_ctx);
    if (handshake->ecrs_peer_cert != NULL) {
        mbedtls_x509_crt_free(handshake->ecrs_peer_cert);
        mbedtls_free(handshake->ecrs_peer_cert);
    }
#    endif

#    if defined(MBEDTLS_X509_CRT_PARSE_C) && \
        !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
    mbedtls_pk_free(&handshake->peer_pubkey);
#    endif /* MBEDTLS_X509_CRT_PARSE_C && !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE \
            */

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
    mbedtls_free(handshake->verify_cookie);
    mbedtls_ssl_flight_free(handshake->flight);
    mbedtls_ssl_buffering_free(ssl);
#    endif

#    if defined(MBEDTLS_ECDH_C) && defined(MBEDTLS_USE_PSA_CRYPTO)
    psa_destroy_key(handshake->ecdh_psa_privkey);
#    endif /* MBEDTLS_ECDH_C && MBEDTLS_USE_PSA_CRYPTO */

    mbedtls_platform_zeroize(handshake, sizeof(mbedtls_ssl_handshake_params));

#    if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
    /* If the buffers are too big - reallocate. Because of the way Mbed TLS
     * processes datagrams and the fact that a datagram is allowed to have
     * several records in it, it is possible that the I/O buffers are not
     * empty at this stage */
    handle_buffer_resizing(ssl, 1, mbedtls_ssl_get_input_buflen(ssl),
                           mbedtls_ssl_get_output_buflen(ssl));
#    endif
}

void mbedtls_ssl_session_free(mbedtls_ssl_session *session)
{
    if (session == NULL)
        return;

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
    ssl_clear_peer_cert(session);
#    endif

#    if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
    mbedtls_free(session->ticket);
#    endif

    mbedtls_platform_zeroize(session, sizeof(mbedtls_ssl_session));
}

#    if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)

#        if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
#            define SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_CONNECTION_ID 1u
#        else
#            define SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_CONNECTION_ID 0u
#        endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */

#        define SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_BADMAC_LIMIT 1u

#        if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
#            define SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_ANTI_REPLAY 1u
#        else
#            define SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_ANTI_REPLAY 0u
#        endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */

#        if defined(MBEDTLS_SSL_ALPN)
#            define SSL_SERIALIZED_CONTEXT_CONFIG_ALPN 1u
#        else
#            define SSL_SERIALIZED_CONTEXT_CONFIG_ALPN 0u
#        endif /* MBEDTLS_SSL_ALPN */

#        define SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_CONNECTION_ID_BIT 0
#        define SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_BADMAC_LIMIT_BIT  1
#        define SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_ANTI_REPLAY_BIT   2
#        define SSL_SERIALIZED_CONTEXT_CONFIG_ALPN_BIT               3

#        define SSL_SERIALIZED_CONTEXT_CONFIG_BITFLAG                               \
            ((uint32_t)((SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_CONNECTION_ID           \
                         << SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_CONNECTION_ID_BIT) | \
                        (SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_BADMAC_LIMIT            \
                         << SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_BADMAC_LIMIT_BIT) |  \
                        (SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_ANTI_REPLAY             \
                         << SSL_SERIALIZED_CONTEXT_CONFIG_DTLS_ANTI_REPLAY_BIT) |   \
                        (SSL_SERIALIZED_CONTEXT_CONFIG_ALPN                         \
                         << SSL_SERIALIZED_CONTEXT_CONFIG_ALPN_BIT) |               \
                        0u))

static unsigned char ssl_serialized_context_header[] = {
    MBEDTLS_VERSION_MAJOR,
    MBEDTLS_VERSION_MINOR,
    MBEDTLS_VERSION_PATCH,
    (SSL_SERIALIZED_SESSION_CONFIG_BITFLAG >> 8) & 0xFF,
    (SSL_SERIALIZED_SESSION_CONFIG_BITFLAG >> 0) & 0xFF,
    (SSL_SERIALIZED_CONTEXT_CONFIG_BITFLAG >> 16) & 0xFF,
    (SSL_SERIALIZED_CONTEXT_CONFIG_BITFLAG >> 8) & 0xFF,
    (SSL_SERIALIZED_CONTEXT_CONFIG_BITFLAG >> 0) & 0xFF,
};

/*
 * Serialize a full SSL context
 *
 * The format of the serialized data is:
 * (in the presentation language of TLS, RFC 8446 section 3)
 *
 *  // header
 *  opaque mbedtls_version[3];   // major, minor, patch
 *  opaque context_format[5];    // version-specific field determining
 *                               // the format of the remaining
 *                               // serialized data.
 *  Note: When updating the format, remember to keep these
 *        version+format bytes. (We may make their size part of the API.)
 *
 *  // session sub-structure
 *  opaque session<1..2^32-1>;  // see mbedtls_ssl_session_save()
 *  // transform sub-structure
 *  uint8 random[64];           // ServerHello.random+ClientHello.random
 *  uint8 in_cid<0..2^8-1>      // Connection ID: expected incoming value
 *  uint8 out_cid<0..2^8-1>     // Connection ID: outgoing value to use
 *  // fields from ssl_context
 *  uint32 badmac_seen;         // DTLS: number of records with failing MAC
 *  uint64 in_window_top;       // DTLS: last validated record seq_num
 *  uint64 in_window;           // DTLS: bitmask for replay protection
 *  uint8 disable_datagram_packing; // DTLS: only one record per datagram
 *  uint64 cur_out_ctr;         // Record layer: outgoing sequence number
 *  uint16 mtu;                 // DTLS: path mtu (max outgoing fragment size)
 *  uint8 alpn_chosen<0..2^8-1> // ALPN: negotiated application protocol
 *
 * Note that many fields of the ssl_context or sub-structures are not
 * serialized, as they fall in one of the following categories:
 *
 *  1. forced value (eg in_left must be 0)
 *  2. pointer to dynamically-allocated memory (eg session, transform)
 *  3. value can be re-derived from other data (eg session keys from MS)
 *  4. value was temporary (eg content of input buffer)
 *  5. value will be provided by the user again (eg I/O callbacks and context)
 */
int mbedtls_ssl_context_save(mbedtls_ssl_context *ssl,
                             unsigned char *buf,
                             size_t buf_len,
                             size_t *olen)
{
    unsigned char *p = buf;
    size_t used = 0;
    size_t session_len;
    int ret = 0;

    /*
     * Enforce usage restrictions, see "return BAD_INPUT_DATA" in
     * this function's documentation.
     *
     * These are due to assumptions/limitations in the implementation. Some of
     * them are likely to stay (no handshake in progress) some might go away
     * (only DTLS) but are currently used to simplify the implementation.
     */
    /* The initial handshake must be over */
    if (ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("Initial handshake isn't over"));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }
    if (ssl->handshake != NULL) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("Handshake isn't completed"));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }
    /* Double-check that sub-structures are indeed ready */
    if (ssl->transform == NULL || ssl->session == NULL) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("Serialised structures aren't ready"));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }
    /* There must be no pending incoming or outgoing data */
    if (mbedtls_ssl_check_pending(ssl) != 0) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("There is pending incoming data"));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }
    if (ssl->out_left != 0) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("There is pending outgoing data"));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }
    /* Protocol must be DLTS, not TLS */
    if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("Only DTLS is supported"));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }
    /* Version must be 1.2 */
    if (ssl->major_ver != MBEDTLS_SSL_MAJOR_VERSION_3) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("Only version 1.2 supported"));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }
    if (ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_3) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("Only version 1.2 supported"));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }
    /* We must be using an AEAD ciphersuite */
    if (mbedtls_ssl_transform_uses_aead(ssl->transform) != 1) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("Only AEAD ciphersuites supported"));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }
    /* Renegotiation must not be enabled */
#        if defined(MBEDTLS_SSL_RENEGOTIATION)
    if (ssl->conf->disable_renegotiation !=
        MBEDTLS_SSL_RENEGOTIATION_DISABLED) {
        MBEDTLS_SSL_DEBUG_MSG(1, ("Renegotiation must not be enabled"));
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }
#        endif

    /*
     * Version and format identifier
     */
    used += sizeof(ssl_serialized_context_header);

    if (used <= buf_len) {
        memcpy(p, ssl_serialized_context_header,
               sizeof(ssl_serialized_context_header));
        p += sizeof(ssl_serialized_context_header);
    }

    /*
     * Session (length + data)
     */
    ret = ssl_session_save(ssl->session, 1, NULL, 0, &session_len);
    if (ret != MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL)
        return ret;

    used += 4 + session_len;
    if (used <= buf_len) {
        *p++ = (unsigned char)((session_len >> 24) & 0xFF);
        *p++ = (unsigned char)((session_len >> 16) & 0xFF);
        *p++ = (unsigned char)((session_len >> 8) & 0xFF);
        *p++ = (unsigned char)((session_len)&0xFF);

        ret = ssl_session_save(ssl->session, 1, p, session_len, &session_len);
        if (ret != 0)
            return ret;

        p += session_len;
    }

    /*
     * Transform
     */
    used += sizeof(ssl->transform->randbytes);
    if (used <= buf_len) {
        memcpy(p, ssl->transform->randbytes, sizeof(ssl->transform->randbytes));
        p += sizeof(ssl->transform->randbytes);
    }

#        if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
    used += 2 + ssl->transform->in_cid_len + ssl->transform->out_cid_len;
    if (used <= buf_len) {
        *p++ = ssl->transform->in_cid_len;
        memcpy(p, ssl->transform->in_cid, ssl->transform->in_cid_len);
        p += ssl->transform->in_cid_len;

        *p++ = ssl->transform->out_cid_len;
        memcpy(p, ssl->transform->out_cid, ssl->transform->out_cid_len);
        p += ssl->transform->out_cid_len;
    }
#        endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */

    /*
     * Saved fields from top-level ssl_context structure
     */
    used += 4;
    if (used <= buf_len) {
        *p++ = (unsigned char)((ssl->badmac_seen >> 24) & 0xFF);
        *p++ = (unsigned char)((ssl->badmac_seen >> 16) & 0xFF);
        *p++ = (unsigned char)((ssl->badmac_seen >> 8) & 0xFF);
        *p++ = (unsigned char)((ssl->badmac_seen) & 0xFF);
    }

#        if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
    used += 16;
    if (used <= buf_len) {
        *p++ = (unsigned char)((ssl->in_window_top >> 56) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window_top >> 48) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window_top >> 40) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window_top >> 32) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window_top >> 24) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window_top >> 16) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window_top >> 8) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window_top) & 0xFF);

        *p++ = (unsigned char)((ssl->in_window >> 56) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window >> 48) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window >> 40) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window >> 32) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window >> 24) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window >> 16) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window >> 8) & 0xFF);
        *p++ = (unsigned char)((ssl->in_window) & 0xFF);
    }
#        endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */

#        if defined(MBEDTLS_SSL_PROTO_DTLS)
    used += 1;
    if (used <= buf_len) {
        *p++ = ssl->disable_datagram_packing;
    }
#        endif /* MBEDTLS_SSL_PROTO_DTLS */

    used += 8;
    if (used <= buf_len) {
        memcpy(p, ssl->cur_out_ctr, 8);
        p += 8;
    }

#        if defined(MBEDTLS_SSL_PROTO_DTLS)
    used += 2;
    if (used <= buf_len) {
        *p++ = (unsigned char)((ssl->mtu >> 8) & 0xFF);
        *p++ = (unsigned char)((ssl->mtu) & 0xFF);
    }
#        endif /* MBEDTLS_SSL_PROTO_DTLS */

#        if defined(MBEDTLS_SSL_ALPN)
    {
        const uint8_t alpn_len =
            ssl->alpn_chosen ? (uint8_t)strlen(ssl->alpn_chosen) : 0;

        used += 1 + alpn_len;
        if (used <= buf_len) {
            *p++ = alpn_len;

            if (ssl->alpn_chosen != NULL) {
                memcpy(p, ssl->alpn_chosen, alpn_len);
                p += alpn_len;
            }
        }
    }
#        endif /* MBEDTLS_SSL_ALPN */

    /*
     * Done
     */
    *olen = used;

    if (used > buf_len)
        return MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL;

    MBEDTLS_SSL_DEBUG_BUF(4, "saved context", buf, used);

    return mbedtls_ssl_session_reset_int(ssl, 0);
}

/*
 * Helper to get TLS 1.2 PRF from ciphersuite
 * (Duplicates bits of logic from ssl_set_handshake_prfs().)
 */
typedef int (*tls_prf_fn)(const unsigned char *secret,
                          size_t slen,
                          const char *label,
                          const unsigned char *random,
                          size_t rlen,
                          unsigned char *dstbuf,
                          size_t dlen);
static tls_prf_fn ssl_tls12prf_from_cs(int ciphersuite_id)
{
#        if defined(MBEDTLS_SHA384_C)
    const mbedtls_ssl_ciphersuite_t *const ciphersuite_info =
        mbedtls_ssl_ciphersuite_from_id(ciphersuite_id);

    if (ciphersuite_info->mac == MBEDTLS_MD_SHA384)
        return tls_prf_sha384;
#        else
    (void)ciphersuite_id;
#        endif
    return tls_prf_sha256;
}

/*
 * Deserialize context, see mbedtls_ssl_context_save() for format.
 *
 * This internal version is wrapped by a public function that cleans up in
 * case of error.
 */
static int
ssl_context_load(mbedtls_ssl_context *ssl, const unsigned char *buf, size_t len)
{
    const unsigned char *p = buf;
    const unsigned char *const end = buf + len;
    size_t session_len;
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;

    /*
     * The context should have been freshly setup or reset.
     * Give the user an error in case of obvious misuse.
     * (Checking session is useful because it won't be NULL if we're
     * renegotiating, or if the user mistakenly loaded a session first.)
     */
    if (ssl->state != MBEDTLS_SSL_HELLO_REQUEST || ssl->session != NULL) {
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    /*
     * We can't check that the config matches the initial one, but we can at
     * least check it matches the requirements for serializing.
     */
    if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM ||
        ssl->conf->max_major_ver < MBEDTLS_SSL_MAJOR_VERSION_3 ||
        ssl->conf->min_major_ver > MBEDTLS_SSL_MAJOR_VERSION_3 ||
        ssl->conf->max_minor_ver < MBEDTLS_SSL_MINOR_VERSION_3 ||
        ssl->conf->min_minor_ver > MBEDTLS_SSL_MINOR_VERSION_3 ||
#        if defined(MBEDTLS_SSL_RENEGOTIATION)
        ssl->conf->disable_renegotiation !=
            MBEDTLS_SSL_RENEGOTIATION_DISABLED ||
#        endif
        0) {
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    MBEDTLS_SSL_DEBUG_BUF(4, "context to load", buf, len);

    /*
     * Check version identifier
     */
    if ((size_t)(end - p) < sizeof(ssl_serialized_context_header))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    if (memcmp(p, ssl_serialized_context_header,
               sizeof(ssl_serialized_context_header)) != 0) {
        return MBEDTLS_ERR_SSL_VERSION_MISMATCH;
    }
    p += sizeof(ssl_serialized_context_header);

    /*
     * Session
     */
    if ((size_t)(end - p) < 4)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    session_len = ((size_t)p[0] << 24) | ((size_t)p[1] << 16) |
                  ((size_t)p[2] << 8) | ((size_t)p[3]);
    p += 4;

    /* This has been allocated by ssl_handshake_init(), called by
     * by either mbedtls_ssl_session_reset_int() or mbedtls_ssl_setup(). */
    ssl->session = ssl->session_negotiate;
    ssl->session_in = ssl->session;
    ssl->session_out = ssl->session;
    ssl->session_negotiate = NULL;

    if ((size_t)(end - p) < session_len)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    ret = ssl_session_load(ssl->session, 1, p, session_len);
    if (ret != 0) {
        mbedtls_ssl_session_free(ssl->session);
        return ret;
    }

    p += session_len;

    /*
     * Transform
     */

    /* This has been allocated by ssl_handshake_init(), called by
     * by either mbedtls_ssl_session_reset_int() or mbedtls_ssl_setup(). */
    ssl->transform = ssl->transform_negotiate;
    ssl->transform_in = ssl->transform;
    ssl->transform_out = ssl->transform;
    ssl->transform_negotiate = NULL;

    /* Read random bytes and populate structure */
    if ((size_t)(end - p) < sizeof(ssl->transform->randbytes))
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    ret = ssl_populate_transform(
        ssl->transform, ssl->session->ciphersuite, ssl->session->master,
#        if defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
#            if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
        ssl->session->encrypt_then_mac,
#            endif
#        endif /* MBEDTLS_SSL_SOME_SUITES_USE_MAC */
        ssl_tls12prf_from_cs(ssl->session->ciphersuite), p, /* currently
                                                               pointing to
                                                               randbytes */
        MBEDTLS_SSL_MINOR_VERSION_3, /* (D)TLS 1.2 is forced */
        ssl->conf->endpoint, ssl);
    if (ret != 0)
        return ret;

    p += sizeof(ssl->transform->randbytes);

#        if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
    /* Read connection IDs and store them */
    if ((size_t)(end - p) < 1)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    ssl->transform->in_cid_len = *p++;

    if ((size_t)(end - p) < ssl->transform->in_cid_len + 1u)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    memcpy(ssl->transform->in_cid, p, ssl->transform->in_cid_len);
    p += ssl->transform->in_cid_len;

    ssl->transform->out_cid_len = *p++;

    if ((size_t)(end - p) < ssl->transform->out_cid_len)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    memcpy(ssl->transform->out_cid, p, ssl->transform->out_cid_len);
    p += ssl->transform->out_cid_len;
#        endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */

    /*
     * Saved fields from top-level ssl_context structure
     */
    if ((size_t)(end - p) < 4)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    ssl->badmac_seen = ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
                       ((uint32_t)p[2] << 8) | ((uint32_t)p[3]);
    p += 4;

#        if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
    if ((size_t)(end - p) < 16)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    ssl->in_window_top = ((uint64_t)p[0] << 56) | ((uint64_t)p[1] << 48) |
                         ((uint64_t)p[2] << 40) | ((uint64_t)p[3] << 32) |
                         ((uint64_t)p[4] << 24) | ((uint64_t)p[5] << 16) |
                         ((uint64_t)p[6] << 8) | ((uint64_t)p[7]);
    p += 8;

    ssl->in_window = ((uint64_t)p[0] << 56) | ((uint64_t)p[1] << 48) |
                     ((uint64_t)p[2] << 40) | ((uint64_t)p[3] << 32) |
                     ((uint64_t)p[4] << 24) | ((uint64_t)p[5] << 16) |
                     ((uint64_t)p[6] << 8) | ((uint64_t)p[7]);
    p += 8;
#        endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */

#        if defined(MBEDTLS_SSL_PROTO_DTLS)
    if ((size_t)(end - p) < 1)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    ssl->disable_datagram_packing = *p++;
#        endif /* MBEDTLS_SSL_PROTO_DTLS */

    if ((size_t)(end - p) < 8)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    memcpy(ssl->cur_out_ctr, p, 8);
    p += 8;

#        if defined(MBEDTLS_SSL_PROTO_DTLS)
    if ((size_t)(end - p) < 2)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    ssl->mtu = (p[0] << 8) | p[1];
    p += 2;
#        endif /* MBEDTLS_SSL_PROTO_DTLS */

#        if defined(MBEDTLS_SSL_ALPN)
    {
        uint8_t alpn_len;
        const char **cur;

        if ((size_t)(end - p) < 1)
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

        alpn_len = *p++;

        if (alpn_len != 0 && ssl->conf->alpn_list != NULL) {
            /* alpn_chosen should point to an item in the configured list */
            for (cur = ssl->conf->alpn_list; *cur != NULL; cur++) {
                if (strlen(*cur) == alpn_len && memcmp(p, cur, alpn_len) == 0) {
                    ssl->alpn_chosen = *cur;
                    break;
                }
            }
        }

        /* can only happen on conf mismatch */
        if (alpn_len != 0 && ssl->alpn_chosen == NULL)
            return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

        p += alpn_len;
    }
#        endif /* MBEDTLS_SSL_ALPN */

    /*
     * Forced fields from top-level ssl_context structure
     *
     * Most of them already set to the correct value by mbedtls_ssl_init() and
     * mbedtls_ssl_reset(), so we only need to set the remaining ones.
     */
    ssl->state = MBEDTLS_SSL_HANDSHAKE_OVER;

    ssl->major_ver = MBEDTLS_SSL_MAJOR_VERSION_3;
    ssl->minor_ver = MBEDTLS_SSL_MINOR_VERSION_3;

    /* Adjust pointers for header fields of outgoing records to
     * the given transform, accounting for explicit IV and CID. */
    mbedtls_ssl_update_out_pointers(ssl, ssl->transform);

#        if defined(MBEDTLS_SSL_PROTO_DTLS)
    ssl->in_epoch = 1;
#        endif

    /* mbedtls_ssl_reset() leaves the handshake sub-structure allocated,
     * which we don't want - otherwise we'd end up freeing the wrong transform
     * by calling mbedtls_ssl_handshake_wrapup_free_hs_transform()
     * inappropriately. */
    if (ssl->handshake != NULL) {
        mbedtls_ssl_handshake_free(ssl);
        mbedtls_free(ssl->handshake);
        ssl->handshake = NULL;
    }

    /*
     * Done - should have consumed entire buffer
     */
    if (p != end)
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;

    return 0;
}

/*
 * Deserialize context: public wrapper for error cleaning
 */
int mbedtls_ssl_context_load(mbedtls_ssl_context *context,
                             const unsigned char *buf,
                             size_t len)
{
    int ret = ssl_context_load(context, buf, len);

    if (ret != 0)
        mbedtls_ssl_free(context);

    return ret;
}
#    endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */

/*
 * Free an SSL context
 */
void mbedtls_ssl_free(mbedtls_ssl_context *ssl)
{
    if (ssl == NULL)
        return;

    MBEDTLS_SSL_DEBUG_MSG(2, ("=> free"));

    if (ssl->out_buf != NULL) {
#    if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
        size_t out_buf_len = ssl->out_buf_len;
#    else
        size_t out_buf_len = MBEDTLS_SSL_OUT_BUFFER_LEN;
#    endif

        mbedtls_platform_zeroize(ssl->out_buf, out_buf_len);
        mbedtls_free(ssl->out_buf);
        ssl->out_buf = NULL;
    }

    if (ssl->in_buf != NULL) {
#    if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
        size_t in_buf_len = ssl->in_buf_len;
#    else
        size_t in_buf_len = MBEDTLS_SSL_IN_BUFFER_LEN;
#    endif

        mbedtls_platform_zeroize(ssl->in_buf, in_buf_len);
        mbedtls_free(ssl->in_buf);
        ssl->in_buf = NULL;
    }

    if (ssl->transform) {
        mbedtls_ssl_transform_free(ssl->transform);
        mbedtls_free(ssl->transform);
    }

    if (ssl->handshake) {
        mbedtls_ssl_handshake_free(ssl);
        mbedtls_ssl_transform_free(ssl->transform_negotiate);
        mbedtls_ssl_session_free(ssl->session_negotiate);

        mbedtls_free(ssl->handshake);
        mbedtls_free(ssl->transform_negotiate);
        mbedtls_free(ssl->session_negotiate);
    }

    if (ssl->session) {
        mbedtls_ssl_session_free(ssl->session);
        mbedtls_free(ssl->session);
    }

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
    if (ssl->hostname != NULL) {
        mbedtls_platform_zeroize(ssl->hostname, strlen(ssl->hostname));
        mbedtls_free(ssl->hostname);
    }
#    endif

#    if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY) && defined(MBEDTLS_SSL_SRV_C)
    mbedtls_free(ssl->cli_id);
#    endif

    MBEDTLS_SSL_DEBUG_MSG(2, ("<= free"));

    /* Actually clear after last debug message */
    mbedtls_platform_zeroize(ssl, sizeof(mbedtls_ssl_context));
}

/*
 * Initialze mbedtls_ssl_config
 */
void mbedtls_ssl_config_init(mbedtls_ssl_config *conf)
{
    memset(conf, 0, sizeof(mbedtls_ssl_config));
}

#    if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
/* The selection should be the same as mbedtls_x509_crt_profile_default in
 * x509_crt.c. Here, the order matters. Currently we favor stronger hashes,
 * for no fundamental reason.
 * See the documentation of mbedtls_ssl_conf_curves() for what we promise
 * about this list. */
static int ssl_preset_default_hashes[] = {
#        if defined(MBEDTLS_SHA512_C)
    MBEDTLS_MD_SHA512,
#        endif
#        if defined(MBEDTLS_SHA384_C)
    MBEDTLS_MD_SHA384,
#        endif
#        if defined(MBEDTLS_SHA256_C)
    MBEDTLS_MD_SHA256,
#        endif
    MBEDTLS_MD_NONE
};
#    endif

#    if defined(MBEDTLS_ECP_C)
/* The selection should be the same as mbedtls_x509_crt_profile_default in
 * x509_crt.c, plus Montgomery curves for ECDHE. Here, the order matters:
 * curves with a lower resource usage come first.
 * See the documentation of mbedtls_ssl_conf_curves() for what we promise
 * about this list.
 */
static mbedtls_ecp_group_id ssl_preset_default_curves[] = {
#        if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
    MBEDTLS_ECP_DP_CURVE25519,
#        endif
#        if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
    MBEDTLS_ECP_DP_SECP256R1,
#        endif
#        if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
    MBEDTLS_ECP_DP_SECP384R1,
#        endif
#        if defined(MBEDTLS_ECP_DP_CURVE448_ENABLED)
    MBEDTLS_ECP_DP_CURVE448,
#        endif
#        if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
    MBEDTLS_ECP_DP_SECP521R1,
#        endif
#        if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
    MBEDTLS_ECP_DP_BP256R1,
#        endif
#        if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
    MBEDTLS_ECP_DP_BP384R1,
#        endif
#        if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
    MBEDTLS_ECP_DP_BP512R1,
#        endif
    MBEDTLS_ECP_DP_NONE
};
#    endif

static int ssl_preset_suiteb_ciphersuites[] = {
    MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
    MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, 0
};

#    if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
static int ssl_preset_suiteb_hashes[] = { MBEDTLS_MD_SHA256, MBEDTLS_MD_SHA384,
                                          MBEDTLS_MD_NONE };
#    endif

#    if defined(MBEDTLS_ECP_C)
static mbedtls_ecp_group_id ssl_preset_suiteb_curves[] = {
#        if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
    MBEDTLS_ECP_DP_SECP256R1,
#        endif
#        if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
    MBEDTLS_ECP_DP_SECP384R1,
#        endif
    MBEDTLS_ECP_DP_NONE
};
#    endif

/*
 * Load default in mbedtls_ssl_config
 */
int mbedtls_ssl_config_defaults(mbedtls_ssl_config *conf,
                                int endpoint,
                                int transport,
                                int preset)
{
#    if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_SSL_SRV_C)
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
#    endif

    /* Use the functions here so that they are covered in tests,
     * but otherwise access member directly for efficiency */
    mbedtls_ssl_conf_endpoint(conf, endpoint);
    mbedtls_ssl_conf_transport(conf, transport);

    /*
     * Things that are common to all presets
     */
#    if defined(MBEDTLS_SSL_CLI_C)
    if (endpoint == MBEDTLS_SSL_IS_CLIENT) {
        conf->authmode = MBEDTLS_SSL_VERIFY_REQUIRED;
#        if defined(MBEDTLS_SSL_SESSION_TICKETS)
        conf->session_tickets = MBEDTLS_SSL_SESSION_TICKETS_ENABLED;
#        endif
    }
#    endif

#    if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
    conf->encrypt_then_mac = MBEDTLS_SSL_ETM_ENABLED;
#    endif

#    if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
    conf->extended_ms = MBEDTLS_SSL_EXTENDED_MS_ENABLED;
#    endif

#    if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY) && defined(MBEDTLS_SSL_SRV_C)
    conf->f_cookie_write = ssl_cookie_write_dummy;
    conf->f_cookie_check = ssl_cookie_check_dummy;
#    endif

#    if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
    conf->anti_replay = MBEDTLS_SSL_ANTI_REPLAY_ENABLED;
#    endif

#    if defined(MBEDTLS_SSL_SRV_C)
    conf->cert_req_ca_list = MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED;
    conf->respect_cli_pref = MBEDTLS_SSL_SRV_CIPHERSUITE_ORDER_SERVER;
#    endif

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
    conf->hs_timeout_min = MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MIN;
    conf->hs_timeout_max = MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MAX;
#    endif

#    if defined(MBEDTLS_SSL_RENEGOTIATION)
    conf->renego_max_records = MBEDTLS_SSL_RENEGO_MAX_RECORDS_DEFAULT;
    memset(conf->renego_period, 0x00, 2);
    memset(conf->renego_period + 2, 0xFF, 6);
#    endif

#    if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_SSL_SRV_C)
    if (endpoint == MBEDTLS_SSL_IS_SERVER) {
        const unsigned char dhm_p[] = MBEDTLS_DHM_RFC3526_MODP_2048_P_BIN;
        const unsigned char dhm_g[] = MBEDTLS_DHM_RFC3526_MODP_2048_G_BIN;

        if ((ret = mbedtls_ssl_conf_dh_param_bin(conf, dhm_p, sizeof(dhm_p),
                                                 dhm_g, sizeof(dhm_g))) != 0) {
            return ret;
        }
    }
#    endif

    /*
     * Preset-specific defaults
     */
    switch (preset) {
        /*
         * NSA Suite B
         */
        case MBEDTLS_SSL_PRESET_SUITEB:
            conf->min_major_ver = MBEDTLS_SSL_MAJOR_VERSION_3;
            conf->min_minor_ver = MBEDTLS_SSL_MINOR_VERSION_3; /* TLS 1.2 */
            conf->max_major_ver = MBEDTLS_SSL_MAX_MAJOR_VERSION;
            conf->max_minor_ver = MBEDTLS_SSL_MAX_MINOR_VERSION;

            conf->ciphersuite_list = ssl_preset_suiteb_ciphersuites;

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
            conf->cert_profile = &mbedtls_x509_crt_profile_suiteb;
#    endif

#    if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
            conf->sig_hashes = ssl_preset_suiteb_hashes;
#    endif

#    if defined(MBEDTLS_ECP_C)
            conf->curve_list = ssl_preset_suiteb_curves;
#    endif
            break;

        /*
         * Default
         */
        default:
            conf->min_major_ver = (MBEDTLS_SSL_MIN_MAJOR_VERSION >
                                   MBEDTLS_SSL_MIN_VALID_MAJOR_VERSION) ?
                                      MBEDTLS_SSL_MIN_MAJOR_VERSION :
                                      MBEDTLS_SSL_MIN_VALID_MAJOR_VERSION;
            conf->min_minor_ver = (MBEDTLS_SSL_MIN_MINOR_VERSION >
                                   MBEDTLS_SSL_MIN_VALID_MINOR_VERSION) ?
                                      MBEDTLS_SSL_MIN_MINOR_VERSION :
                                      MBEDTLS_SSL_MIN_VALID_MINOR_VERSION;
            conf->max_major_ver = MBEDTLS_SSL_MAX_MAJOR_VERSION;
            conf->max_minor_ver = MBEDTLS_SSL_MAX_MINOR_VERSION;

#    if defined(MBEDTLS_SSL_PROTO_DTLS)
            if (transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM)
                conf->min_minor_ver = MBEDTLS_SSL_MINOR_VERSION_3;
#    endif
            conf->ciphersuite_list = mbedtls_ssl_list_ciphersuites();

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
            conf->cert_profile = &mbedtls_x509_crt_profile_default;
#    endif

#    if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
            conf->sig_hashes = ssl_preset_default_hashes;
#    endif

#    if defined(MBEDTLS_ECP_C)
            conf->curve_list = ssl_preset_default_curves;
#    endif

#    if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_SSL_CLI_C)
            conf->dhm_min_bitlen = 1024;
#    endif
    }

    return 0;
}

/*
 * Free mbedtls_ssl_config
 */
void mbedtls_ssl_config_free(mbedtls_ssl_config *conf)
{
#    if defined(MBEDTLS_DHM_C)
    mbedtls_mpi_free(&conf->dhm_P);
    mbedtls_mpi_free(&conf->dhm_G);
#    endif

#    if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
    if (conf->psk != NULL) {
        mbedtls_platform_zeroize(conf->psk, conf->psk_len);
        mbedtls_free(conf->psk);
        conf->psk = NULL;
        conf->psk_len = 0;
    }

    if (conf->psk_identity != NULL) {
        mbedtls_platform_zeroize(conf->psk_identity, conf->psk_identity_len);
        mbedtls_free(conf->psk_identity);
        conf->psk_identity = NULL;
        conf->psk_identity_len = 0;
    }
#    endif

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
    ssl_key_cert_free(conf->key_cert);
#    endif

    mbedtls_platform_zeroize(conf, sizeof(mbedtls_ssl_config));
}

#    if defined(MBEDTLS_PK_C) && \
        (defined(MBEDTLS_RSA_C) || defined(MBEDTLS_ECDSA_C))
/*
 * Convert between MBEDTLS_PK_XXX and SSL_SIG_XXX
 */
unsigned char mbedtls_ssl_sig_from_pk(mbedtls_pk_context *pk)
{
#        if defined(MBEDTLS_RSA_C)
    if (mbedtls_pk_can_do(pk, MBEDTLS_PK_RSA))
        return MBEDTLS_SSL_SIG_RSA;
#        endif
#        if defined(MBEDTLS_ECDSA_C)
    if (mbedtls_pk_can_do(pk, MBEDTLS_PK_ECDSA))
        return MBEDTLS_SSL_SIG_ECDSA;
#        endif
    return MBEDTLS_SSL_SIG_ANON;
}

unsigned char mbedtls_ssl_sig_from_pk_alg(mbedtls_pk_type_t type)
{
    switch (type) {
        case MBEDTLS_PK_RSA:
            return MBEDTLS_SSL_SIG_RSA;
        case MBEDTLS_PK_ECDSA:
        case MBEDTLS_PK_ECKEY:
            return MBEDTLS_SSL_SIG_ECDSA;
        default:
            return MBEDTLS_SSL_SIG_ANON;
    }
}

mbedtls_pk_type_t mbedtls_ssl_pk_alg_from_sig(unsigned char sig)
{
    switch (sig) {
#        if defined(MBEDTLS_RSA_C)
        case MBEDTLS_SSL_SIG_RSA:
            return MBEDTLS_PK_RSA;
#        endif
#        if defined(MBEDTLS_ECDSA_C)
        case MBEDTLS_SSL_SIG_ECDSA:
            return MBEDTLS_PK_ECDSA;
#        endif
        default:
            return MBEDTLS_PK_NONE;
    }
}
#    endif /* MBEDTLS_PK_C && ( MBEDTLS_RSA_C || MBEDTLS_ECDSA_C ) */

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
        defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)

/* Find an entry in a signature-hash set matching a given hash algorithm. */
mbedtls_md_type_t mbedtls_ssl_sig_hash_set_find(mbedtls_ssl_sig_hash_set_t *set,
                                                mbedtls_pk_type_t sig_alg)
{
    switch (sig_alg) {
        case MBEDTLS_PK_RSA:
            return set->rsa;
        case MBEDTLS_PK_ECDSA:
            return set->ecdsa;
        default:
            return MBEDTLS_MD_NONE;
    }
}

/* Add a signature-hash-pair to a signature-hash set */
void mbedtls_ssl_sig_hash_set_add(mbedtls_ssl_sig_hash_set_t *set,
                                  mbedtls_pk_type_t sig_alg,
                                  mbedtls_md_type_t md_alg)
{
    switch (sig_alg) {
        case MBEDTLS_PK_RSA:
            if (set->rsa == MBEDTLS_MD_NONE)
                set->rsa = md_alg;
            break;

        case MBEDTLS_PK_ECDSA:
            if (set->ecdsa == MBEDTLS_MD_NONE)
                set->ecdsa = md_alg;
            break;

        default:
            break;
    }
}

/* Allow exactly one hash algorithm for each signature. */
void mbedtls_ssl_sig_hash_set_const_hash(mbedtls_ssl_sig_hash_set_t *set,
                                         mbedtls_md_type_t md_alg)
{
    set->rsa = md_alg;
    set->ecdsa = md_alg;
}

#    endif /* MBEDTLS_SSL_PROTO_TLS1_2) && \
              MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */

/*
 * Convert from MBEDTLS_SSL_HASH_XXX to MBEDTLS_MD_XXX
 */
mbedtls_md_type_t mbedtls_ssl_md_alg_from_hash(unsigned char hash)
{
    switch (hash) {
#    if defined(MBEDTLS_MD5_C)
        case MBEDTLS_SSL_HASH_MD5:
            return MBEDTLS_MD_MD5;
#    endif
#    if defined(MBEDTLS_SHA1_C)
        case MBEDTLS_SSL_HASH_SHA1:
            return MBEDTLS_MD_SHA1;
#    endif
#    if defined(MBEDTLS_SHA224_C)
        case MBEDTLS_SSL_HASH_SHA224:
            return MBEDTLS_MD_SHA224;
#    endif
#    if defined(MBEDTLS_SHA256_C)
        case MBEDTLS_SSL_HASH_SHA256:
            return MBEDTLS_MD_SHA256;
#    endif
#    if defined(MBEDTLS_SHA384_C)
        case MBEDTLS_SSL_HASH_SHA384:
            return MBEDTLS_MD_SHA384;
#    endif
#    if defined(MBEDTLS_SHA512_C)
        case MBEDTLS_SSL_HASH_SHA512:
            return MBEDTLS_MD_SHA512;
#    endif
        default:
            return MBEDTLS_MD_NONE;
    }
}

/*
 * Convert from MBEDTLS_MD_XXX to MBEDTLS_SSL_HASH_XXX
 */
unsigned char mbedtls_ssl_hash_from_md_alg(int md)
{
    switch (md) {
#    if defined(MBEDTLS_MD5_C)
        case MBEDTLS_MD_MD5:
            return MBEDTLS_SSL_HASH_MD5;
#    endif
#    if defined(MBEDTLS_SHA1_C)
        case MBEDTLS_MD_SHA1:
            return MBEDTLS_SSL_HASH_SHA1;
#    endif
#    if defined(MBEDTLS_SHA224_C)
        case MBEDTLS_MD_SHA224:
            return MBEDTLS_SSL_HASH_SHA224;
#    endif
#    if defined(MBEDTLS_SHA256_C)
        case MBEDTLS_MD_SHA256:
            return MBEDTLS_SSL_HASH_SHA256;
#    endif
#    if defined(MBEDTLS_SHA384_C)
        case MBEDTLS_MD_SHA384:
            return MBEDTLS_SSL_HASH_SHA384;
#    endif
#    if defined(MBEDTLS_SHA512_C)
        case MBEDTLS_MD_SHA512:
            return MBEDTLS_SSL_HASH_SHA512;
#    endif
        default:
            return MBEDTLS_SSL_HASH_NONE;
    }
}

#    if defined(MBEDTLS_ECP_C)
/*
 * Check if a curve proposed by the peer is in our list.
 * Return 0 if we're willing to use it, -1 otherwise.
 */
int mbedtls_ssl_check_curve(const mbedtls_ssl_context *ssl,
                            mbedtls_ecp_group_id grp_id)
{
    const mbedtls_ecp_group_id *gid;

    if (ssl->conf->curve_list == NULL)
        return -1;

    for (gid = ssl->conf->curve_list; *gid != MBEDTLS_ECP_DP_NONE; gid++)
        if (*gid == grp_id)
            return 0;

    return -1;
}
#    endif /* MBEDTLS_ECP_C */

#    if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
/*
 * Check if a hash proposed by the peer is in our list.
 * Return 0 if we're willing to use it, -1 otherwise.
 */
int mbedtls_ssl_check_sig_hash(const mbedtls_ssl_context *ssl,
                               mbedtls_md_type_t md)
{
    const int *cur;

    if (ssl->conf->sig_hashes == NULL)
        return -1;

    for (cur = ssl->conf->sig_hashes; *cur != MBEDTLS_MD_NONE; cur++)
        if (*cur == (int)md)
            return 0;

    return -1;
}
#    endif /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */

#    if defined(MBEDTLS_X509_CRT_PARSE_C)
int mbedtls_ssl_check_cert_usage(const mbedtls_x509_crt *cert,
                                 const mbedtls_ssl_ciphersuite_t *ciphersuite,
                                 int cert_endpoint,
                                 uint32_t *flags)
{
    int ret = 0;
    int usage = 0;
    const char *ext_oid;
    size_t ext_len;

    if (cert_endpoint == MBEDTLS_SSL_IS_SERVER) {
        /* Server part of the key exchange */
        switch (ciphersuite->key_exchange) {
            case MBEDTLS_KEY_EXCHANGE_RSA:
            case MBEDTLS_KEY_EXCHANGE_RSA_PSK:
                usage = MBEDTLS_X509_KU_KEY_ENCIPHERMENT;
                break;

            case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
            case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
            case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
                usage = MBEDTLS_X509_KU_DIGITAL_SIGNATURE;
                break;

            case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
            case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
                usage = MBEDTLS_X509_KU_KEY_AGREEMENT;
                break;

            /* Don't use default: we want warnings when adding new values */
            case MBEDTLS_KEY_EXCHANGE_NONE:
            case MBEDTLS_KEY_EXCHANGE_PSK:
            case MBEDTLS_KEY_EXCHANGE_DHE_PSK:
            case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
            case MBEDTLS_KEY_EXCHANGE_ECJPAKE:
                usage = 0;
        }
    } else {
        /* Client auth: we only implement rsa_sign and mbedtls_ecdsa_sign for
         * now */
        usage = MBEDTLS_X509_KU_DIGITAL_SIGNATURE;
    }

    if (mbedtls_x509_crt_check_key_usage(cert, usage) != 0) {
        *flags |= MBEDTLS_X509_BADCERT_KEY_USAGE;
        ret = -1;
    }

    if (cert_endpoint == MBEDTLS_SSL_IS_SERVER) {
        ext_oid = MBEDTLS_OID_SERVER_AUTH;
        ext_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_SERVER_AUTH);
    } else {
        ext_oid = MBEDTLS_OID_CLIENT_AUTH;
        ext_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_CLIENT_AUTH);
    }

    if (mbedtls_x509_crt_check_extended_key_usage(cert, ext_oid, ext_len) !=
        0) {
        *flags |= MBEDTLS_X509_BADCERT_EXT_KEY_USAGE;
        ret = -1;
    }

    return ret;
}
#    endif /* MBEDTLS_X509_CRT_PARSE_C */

int mbedtls_ssl_set_calc_verify_md(mbedtls_ssl_context *ssl, int md)
{
#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)
    if (ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_3)
        return -1;

    switch (md) {
#        if defined(MBEDTLS_SHA384_C)
        case MBEDTLS_SSL_HASH_SHA384:
            ssl->handshake->calc_verify = ssl_calc_verify_tls_sha384;
            break;
#        endif
#        if defined(MBEDTLS_SHA256_C)
        case MBEDTLS_SSL_HASH_SHA256:
            ssl->handshake->calc_verify = ssl_calc_verify_tls_sha256;
            break;
#        endif
        default:
            return -1;
    }

    return 0;
#    else /* !MBEDTLS_SSL_PROTO_TLS1_2 */
    (void)ssl;
    (void)md;

    return -1;
#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
}

#    if defined(MBEDTLS_SSL_PROTO_TLS1_2)

#        if defined(MBEDTLS_USE_PSA_CRYPTO)
int mbedtls_ssl_get_key_exchange_md_tls1_2(mbedtls_ssl_context *ssl,
                                           unsigned char *hash,
                                           size_t *hashlen,
                                           unsigned char *data,
                                           size_t data_len,
                                           mbedtls_md_type_t md_alg)
{
    psa_status_t status;
    psa_hash_operation_t hash_operation = PSA_HASH_OPERATION_INIT;
    psa_algorithm_t hash_alg = mbedtls_psa_translate_md(md_alg);

    MBEDTLS_SSL_DEBUG_MSG(
        3, ("Perform PSA-based computation of digest of ServerKeyExchange"));

    if ((status = psa_hash_setup(&hash_operation, hash_alg)) != PSA_SUCCESS) {
        MBEDTLS_SSL_DEBUG_RET(1, "psa_hash_setup", status);
        goto exit;
    }

    if ((status = psa_hash_update(&hash_operation, ssl->handshake->randbytes,
                                  64)) != PSA_SUCCESS) {
        MBEDTLS_SSL_DEBUG_RET(1, "psa_hash_update", status);
        goto exit;
    }

    if ((status = psa_hash_update(&hash_operation, data, data_len)) !=
        PSA_SUCCESS) {
        MBEDTLS_SSL_DEBUG_RET(1, "psa_hash_update", status);
        goto exit;
    }

    if ((status = psa_hash_finish(&hash_operation, hash, MBEDTLS_MD_MAX_SIZE,
                                  hashlen)) != PSA_SUCCESS) {
        MBEDTLS_SSL_DEBUG_RET(1, "psa_hash_finish", status);
        goto exit;
    }

exit:
    if (status != PSA_SUCCESS) {
        mbedtls_ssl_send_alert_message(ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                                       MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR);
        switch (status) {
            case PSA_ERROR_NOT_SUPPORTED:
                return MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE;
            case PSA_ERROR_BAD_STATE: /* Intentional fallthrough */
            case PSA_ERROR_BUFFER_TOO_SMALL:
                return MBEDTLS_ERR_MD_BAD_INPUT_DATA;
            case PSA_ERROR_INSUFFICIENT_MEMORY:
                return MBEDTLS_ERR_MD_ALLOC_FAILED;
            default:
                return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
        }
    }
    return 0;
}

#        else

int mbedtls_ssl_get_key_exchange_md_tls1_2(mbedtls_ssl_context *ssl,
                                           unsigned char *hash,
                                           size_t *hashlen,
                                           unsigned char *data,
                                           size_t data_len,
                                           mbedtls_md_type_t md_alg)
{
    int ret = 0;
    mbedtls_md_context_t ctx;
    const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type(md_alg);
    *hashlen = mbedtls_md_get_size(md_info);

    MBEDTLS_SSL_DEBUG_MSG(
        3,
        ("Perform mbedtls-based computation of digest of ServerKeyExchange"));

    mbedtls_md_init(&ctx);

    /*
     * digitally-signed struct {
     *     opaque client_random[32];
     *     opaque server_random[32];
     *     ServerDHParams params;
     * };
     */
    if ((ret = mbedtls_md_setup(&ctx, md_info, 0)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_setup", ret);
        goto exit;
    }
    if ((ret = mbedtls_md_starts(&ctx)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_starts", ret);
        goto exit;
    }
    if ((ret = mbedtls_md_update(&ctx, ssl->handshake->randbytes, 64)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_update", ret);
        goto exit;
    }
    if ((ret = mbedtls_md_update(&ctx, data, data_len)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_update", ret);
        goto exit;
    }
    if ((ret = mbedtls_md_finish(&ctx, hash)) != 0) {
        MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_finish", ret);
        goto exit;
    }

exit:
    mbedtls_md_free(&ctx);

    if (ret != 0)
        mbedtls_ssl_send_alert_message(ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
                                       MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR);

    return ret;
}
#        endif /* MBEDTLS_USE_PSA_CRYPTO */

#    endif /* MBEDTLS_SSL_PROTO_TLS1_2 */

#endif /* MBEDTLS_SSL_TLS_C */