3a6059beca
Comply with the received Record Size Limit extension
2896 lines
110 KiB
C
2896 lines
110 KiB
C
/**
|
|
* \file ssl_misc.h
|
|
*
|
|
* \brief Internal functions shared by the SSL modules
|
|
*/
|
|
/*
|
|
* Copyright The Mbed TLS Contributors
|
|
* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
|
|
*/
|
|
#ifndef MBEDTLS_SSL_MISC_H
|
|
#define MBEDTLS_SSL_MISC_H
|
|
|
|
#include "mbedtls/build_info.h"
|
|
|
|
#include "mbedtls/error.h"
|
|
|
|
#include "mbedtls/ssl.h"
|
|
#include "mbedtls/cipher.h"
|
|
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO) || defined(MBEDTLS_SSL_PROTO_TLS1_3)
|
|
#include "psa/crypto.h"
|
|
#include "psa_util_internal.h"
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_MD_CAN_MD5)
|
|
#include "mbedtls/md5.h"
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_MD_CAN_SHA1)
|
|
#include "mbedtls/sha1.h"
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_MD_CAN_SHA256)
|
|
#include "mbedtls/sha256.h"
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_MD_CAN_SHA512)
|
|
#include "mbedtls/sha512.h"
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED) && \
|
|
!defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
#include "mbedtls/ecjpake.h"
|
|
#endif
|
|
|
|
#include "mbedtls/pk.h"
|
|
#include "pk_internal.h"
|
|
#include "common.h"
|
|
|
|
/* Shorthand for restartable ECC */
|
|
#if defined(MBEDTLS_ECP_RESTARTABLE) && \
|
|
defined(MBEDTLS_SSL_CLI_C) && \
|
|
defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
|
|
defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
|
|
#define MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED
|
|
#endif
|
|
|
|
#define MBEDTLS_SSL_INITIAL_HANDSHAKE 0
|
|
#define MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS 1 /* In progress */
|
|
#define MBEDTLS_SSL_RENEGOTIATION_DONE 2 /* Done or aborted */
|
|
#define MBEDTLS_SSL_RENEGOTIATION_PENDING 3 /* Requested (server only) */
|
|
|
|
/* Faked handshake message identity for HelloRetryRequest. */
|
|
#define MBEDTLS_SSL_TLS1_3_HS_HELLO_RETRY_REQUEST (-MBEDTLS_SSL_HS_SERVER_HELLO)
|
|
|
|
/*
|
|
* Internal identity of handshake extensions
|
|
*/
|
|
#define MBEDTLS_SSL_EXT_ID_UNRECOGNIZED 0
|
|
#define MBEDTLS_SSL_EXT_ID_SERVERNAME 1
|
|
#define MBEDTLS_SSL_EXT_ID_SERVERNAME_HOSTNAME 1
|
|
#define MBEDTLS_SSL_EXT_ID_MAX_FRAGMENT_LENGTH 2
|
|
#define MBEDTLS_SSL_EXT_ID_STATUS_REQUEST 3
|
|
#define MBEDTLS_SSL_EXT_ID_SUPPORTED_GROUPS 4
|
|
#define MBEDTLS_SSL_EXT_ID_SUPPORTED_ELLIPTIC_CURVES 4
|
|
#define MBEDTLS_SSL_EXT_ID_SIG_ALG 5
|
|
#define MBEDTLS_SSL_EXT_ID_USE_SRTP 6
|
|
#define MBEDTLS_SSL_EXT_ID_HEARTBEAT 7
|
|
#define MBEDTLS_SSL_EXT_ID_ALPN 8
|
|
#define MBEDTLS_SSL_EXT_ID_SCT 9
|
|
#define MBEDTLS_SSL_EXT_ID_CLI_CERT_TYPE 10
|
|
#define MBEDTLS_SSL_EXT_ID_SERV_CERT_TYPE 11
|
|
#define MBEDTLS_SSL_EXT_ID_PADDING 12
|
|
#define MBEDTLS_SSL_EXT_ID_PRE_SHARED_KEY 13
|
|
#define MBEDTLS_SSL_EXT_ID_EARLY_DATA 14
|
|
#define MBEDTLS_SSL_EXT_ID_SUPPORTED_VERSIONS 15
|
|
#define MBEDTLS_SSL_EXT_ID_COOKIE 16
|
|
#define MBEDTLS_SSL_EXT_ID_PSK_KEY_EXCHANGE_MODES 17
|
|
#define MBEDTLS_SSL_EXT_ID_CERT_AUTH 18
|
|
#define MBEDTLS_SSL_EXT_ID_OID_FILTERS 19
|
|
#define MBEDTLS_SSL_EXT_ID_POST_HANDSHAKE_AUTH 20
|
|
#define MBEDTLS_SSL_EXT_ID_SIG_ALG_CERT 21
|
|
#define MBEDTLS_SSL_EXT_ID_KEY_SHARE 22
|
|
#define MBEDTLS_SSL_EXT_ID_TRUNCATED_HMAC 23
|
|
#define MBEDTLS_SSL_EXT_ID_SUPPORTED_POINT_FORMATS 24
|
|
#define MBEDTLS_SSL_EXT_ID_ENCRYPT_THEN_MAC 25
|
|
#define MBEDTLS_SSL_EXT_ID_EXTENDED_MASTER_SECRET 26
|
|
#define MBEDTLS_SSL_EXT_ID_SESSION_TICKET 27
|
|
#define MBEDTLS_SSL_EXT_ID_RECORD_SIZE_LIMIT 28
|
|
|
|
/* Utility for translating IANA extension type. */
|
|
uint32_t mbedtls_ssl_get_extension_id(unsigned int extension_type);
|
|
uint32_t mbedtls_ssl_get_extension_mask(unsigned int extension_type);
|
|
/* Macros used to define mask constants */
|
|
#define MBEDTLS_SSL_EXT_MASK(id) (1ULL << (MBEDTLS_SSL_EXT_ID_##id))
|
|
/* Reset value of extension mask */
|
|
#define MBEDTLS_SSL_EXT_MASK_NONE 0
|
|
|
|
/* In messages containing extension requests, we should ignore unrecognized
|
|
* extensions. In messages containing extension responses, unrecognized
|
|
* extensions should result in handshake abortion. Messages containing
|
|
* extension requests include ClientHello, CertificateRequest and
|
|
* NewSessionTicket. Messages containing extension responses include
|
|
* ServerHello, HelloRetryRequest, EncryptedExtensions and Certificate.
|
|
*
|
|
* RFC 8446 section 4.1.3
|
|
*
|
|
* The ServerHello MUST only include extensions which are required to establish
|
|
* the cryptographic context and negotiate the protocol version.
|
|
*
|
|
* RFC 8446 section 4.2
|
|
*
|
|
* If an implementation receives an extension which it recognizes and which is
|
|
* not specified for the message in which it appears, it MUST abort the handshake
|
|
* with an "illegal_parameter" alert.
|
|
*/
|
|
|
|
/* Extensions that are not recognized by TLS 1.3 */
|
|
#define MBEDTLS_SSL_TLS1_3_EXT_MASK_UNRECOGNIZED \
|
|
(MBEDTLS_SSL_EXT_MASK(SUPPORTED_POINT_FORMATS) | \
|
|
MBEDTLS_SSL_EXT_MASK(ENCRYPT_THEN_MAC) | \
|
|
MBEDTLS_SSL_EXT_MASK(EXTENDED_MASTER_SECRET) | \
|
|
MBEDTLS_SSL_EXT_MASK(SESSION_TICKET) | \
|
|
MBEDTLS_SSL_EXT_MASK(TRUNCATED_HMAC) | \
|
|
MBEDTLS_SSL_EXT_MASK(UNRECOGNIZED))
|
|
|
|
/* RFC 8446 section 4.2. Allowed extensions for ClientHello */
|
|
#define MBEDTLS_SSL_TLS1_3_ALLOWED_EXTS_OF_CH \
|
|
(MBEDTLS_SSL_EXT_MASK(SERVERNAME) | \
|
|
MBEDTLS_SSL_EXT_MASK(MAX_FRAGMENT_LENGTH) | \
|
|
MBEDTLS_SSL_EXT_MASK(STATUS_REQUEST) | \
|
|
MBEDTLS_SSL_EXT_MASK(SUPPORTED_GROUPS) | \
|
|
MBEDTLS_SSL_EXT_MASK(SIG_ALG) | \
|
|
MBEDTLS_SSL_EXT_MASK(USE_SRTP) | \
|
|
MBEDTLS_SSL_EXT_MASK(HEARTBEAT) | \
|
|
MBEDTLS_SSL_EXT_MASK(ALPN) | \
|
|
MBEDTLS_SSL_EXT_MASK(SCT) | \
|
|
MBEDTLS_SSL_EXT_MASK(CLI_CERT_TYPE) | \
|
|
MBEDTLS_SSL_EXT_MASK(SERV_CERT_TYPE) | \
|
|
MBEDTLS_SSL_EXT_MASK(PADDING) | \
|
|
MBEDTLS_SSL_EXT_MASK(KEY_SHARE) | \
|
|
MBEDTLS_SSL_EXT_MASK(PRE_SHARED_KEY) | \
|
|
MBEDTLS_SSL_EXT_MASK(PSK_KEY_EXCHANGE_MODES) | \
|
|
MBEDTLS_SSL_EXT_MASK(EARLY_DATA) | \
|
|
MBEDTLS_SSL_EXT_MASK(COOKIE) | \
|
|
MBEDTLS_SSL_EXT_MASK(SUPPORTED_VERSIONS) | \
|
|
MBEDTLS_SSL_EXT_MASK(CERT_AUTH) | \
|
|
MBEDTLS_SSL_EXT_MASK(POST_HANDSHAKE_AUTH) | \
|
|
MBEDTLS_SSL_EXT_MASK(SIG_ALG_CERT) | \
|
|
MBEDTLS_SSL_EXT_MASK(RECORD_SIZE_LIMIT) | \
|
|
MBEDTLS_SSL_TLS1_3_EXT_MASK_UNRECOGNIZED)
|
|
|
|
/* RFC 8446 section 4.2. Allowed extensions for EncryptedExtensions */
|
|
#define MBEDTLS_SSL_TLS1_3_ALLOWED_EXTS_OF_EE \
|
|
(MBEDTLS_SSL_EXT_MASK(SERVERNAME) | \
|
|
MBEDTLS_SSL_EXT_MASK(MAX_FRAGMENT_LENGTH) | \
|
|
MBEDTLS_SSL_EXT_MASK(SUPPORTED_GROUPS) | \
|
|
MBEDTLS_SSL_EXT_MASK(USE_SRTP) | \
|
|
MBEDTLS_SSL_EXT_MASK(HEARTBEAT) | \
|
|
MBEDTLS_SSL_EXT_MASK(ALPN) | \
|
|
MBEDTLS_SSL_EXT_MASK(CLI_CERT_TYPE) | \
|
|
MBEDTLS_SSL_EXT_MASK(SERV_CERT_TYPE) | \
|
|
MBEDTLS_SSL_EXT_MASK(EARLY_DATA) | \
|
|
MBEDTLS_SSL_EXT_MASK(RECORD_SIZE_LIMIT))
|
|
|
|
/* RFC 8446 section 4.2. Allowed extensions for CertificateRequest */
|
|
#define MBEDTLS_SSL_TLS1_3_ALLOWED_EXTS_OF_CR \
|
|
(MBEDTLS_SSL_EXT_MASK(STATUS_REQUEST) | \
|
|
MBEDTLS_SSL_EXT_MASK(SIG_ALG) | \
|
|
MBEDTLS_SSL_EXT_MASK(SCT) | \
|
|
MBEDTLS_SSL_EXT_MASK(CERT_AUTH) | \
|
|
MBEDTLS_SSL_EXT_MASK(OID_FILTERS) | \
|
|
MBEDTLS_SSL_EXT_MASK(SIG_ALG_CERT) | \
|
|
MBEDTLS_SSL_TLS1_3_EXT_MASK_UNRECOGNIZED)
|
|
|
|
/* RFC 8446 section 4.2. Allowed extensions for Certificate */
|
|
#define MBEDTLS_SSL_TLS1_3_ALLOWED_EXTS_OF_CT \
|
|
(MBEDTLS_SSL_EXT_MASK(STATUS_REQUEST) | \
|
|
MBEDTLS_SSL_EXT_MASK(SCT))
|
|
|
|
/* RFC 8446 section 4.2. Allowed extensions for ServerHello */
|
|
#define MBEDTLS_SSL_TLS1_3_ALLOWED_EXTS_OF_SH \
|
|
(MBEDTLS_SSL_EXT_MASK(KEY_SHARE) | \
|
|
MBEDTLS_SSL_EXT_MASK(PRE_SHARED_KEY) | \
|
|
MBEDTLS_SSL_EXT_MASK(SUPPORTED_VERSIONS))
|
|
|
|
/* RFC 8446 section 4.2. Allowed extensions for HelloRetryRequest */
|
|
#define MBEDTLS_SSL_TLS1_3_ALLOWED_EXTS_OF_HRR \
|
|
(MBEDTLS_SSL_EXT_MASK(KEY_SHARE) | \
|
|
MBEDTLS_SSL_EXT_MASK(COOKIE) | \
|
|
MBEDTLS_SSL_EXT_MASK(SUPPORTED_VERSIONS))
|
|
|
|
/* RFC 8446 section 4.2. Allowed extensions for NewSessionTicket */
|
|
#define MBEDTLS_SSL_TLS1_3_ALLOWED_EXTS_OF_NST \
|
|
(MBEDTLS_SSL_EXT_MASK(EARLY_DATA) | \
|
|
MBEDTLS_SSL_TLS1_3_EXT_MASK_UNRECOGNIZED)
|
|
|
|
/*
|
|
* Helper macros for function call with return check.
|
|
*/
|
|
/*
|
|
* Exit when return non-zero value
|
|
*/
|
|
#define MBEDTLS_SSL_PROC_CHK(f) \
|
|
do { \
|
|
ret = (f); \
|
|
if (ret != 0) \
|
|
{ \
|
|
goto cleanup; \
|
|
} \
|
|
} while (0)
|
|
/*
|
|
* Exit when return negative value
|
|
*/
|
|
#define MBEDTLS_SSL_PROC_CHK_NEG(f) \
|
|
do { \
|
|
ret = (f); \
|
|
if (ret < 0) \
|
|
{ \
|
|
goto cleanup; \
|
|
} \
|
|
} while (0)
|
|
|
|
/*
|
|
* DTLS retransmission states, see RFC 6347 4.2.4
|
|
*
|
|
* The SENDING state is merged in PREPARING for initial sends,
|
|
* but is distinct for resends.
|
|
*
|
|
* Note: initial state is wrong for server, but is not used anyway.
|
|
*/
|
|
#define MBEDTLS_SSL_RETRANS_PREPARING 0
|
|
#define MBEDTLS_SSL_RETRANS_SENDING 1
|
|
#define MBEDTLS_SSL_RETRANS_WAITING 2
|
|
#define MBEDTLS_SSL_RETRANS_FINISHED 3
|
|
|
|
/*
|
|
* Allow extra bytes for record, authentication and encryption overhead:
|
|
* counter (8) + header (5) + IV(16) + MAC (16-48) + padding (0-256).
|
|
*/
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
|
|
|
|
/* This macro determines whether CBC is supported. */
|
|
#if defined(MBEDTLS_SSL_HAVE_CBC) && \
|
|
(defined(MBEDTLS_SSL_HAVE_AES) || \
|
|
defined(MBEDTLS_SSL_HAVE_CAMELLIA) || \
|
|
defined(MBEDTLS_SSL_HAVE_ARIA))
|
|
#define MBEDTLS_SSL_SOME_SUITES_USE_CBC
|
|
#endif
|
|
|
|
/* This macro determines whether a ciphersuite using a
|
|
* stream cipher can be used. */
|
|
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
|
|
#define MBEDTLS_SSL_SOME_SUITES_USE_STREAM
|
|
#endif
|
|
|
|
/* This macro determines whether the CBC construct used in TLS 1.2 is supported. */
|
|
#if defined(MBEDTLS_SSL_SOME_SUITES_USE_CBC) && \
|
|
defined(MBEDTLS_SSL_PROTO_TLS1_2)
|
|
#define MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_SOME_SUITES_USE_STREAM) || \
|
|
defined(MBEDTLS_SSL_SOME_SUITES_USE_CBC)
|
|
#define MBEDTLS_SSL_SOME_SUITES_USE_MAC
|
|
#endif
|
|
|
|
/* This macro determines whether a ciphersuite uses Encrypt-then-MAC with CBC */
|
|
#if defined(MBEDTLS_SSL_SOME_SUITES_USE_CBC) && \
|
|
defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
|
|
#define MBEDTLS_SSL_SOME_SUITES_USE_CBC_ETM
|
|
#endif
|
|
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
|
|
|
|
#if defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
|
|
/* Ciphersuites using HMAC */
|
|
#if defined(MBEDTLS_MD_CAN_SHA384)
|
|
#define MBEDTLS_SSL_MAC_ADD 48 /* SHA-384 used for HMAC */
|
|
#elif defined(MBEDTLS_MD_CAN_SHA256)
|
|
#define MBEDTLS_SSL_MAC_ADD 32 /* SHA-256 used for HMAC */
|
|
#else
|
|
#define MBEDTLS_SSL_MAC_ADD 20 /* SHA-1 used for HMAC */
|
|
#endif
|
|
#else /* MBEDTLS_SSL_SOME_SUITES_USE_MAC */
|
|
/* AEAD ciphersuites: GCM and CCM use a 128 bits tag */
|
|
#define MBEDTLS_SSL_MAC_ADD 16
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_HAVE_CBC)
|
|
#define MBEDTLS_SSL_PADDING_ADD 256
|
|
#else
|
|
#define MBEDTLS_SSL_PADDING_ADD 0
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
|
|
#define MBEDTLS_SSL_MAX_CID_EXPANSION MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY
|
|
#else
|
|
#define MBEDTLS_SSL_MAX_CID_EXPANSION 0
|
|
#endif
|
|
|
|
#define MBEDTLS_SSL_PAYLOAD_OVERHEAD (MBEDTLS_MAX_IV_LENGTH + \
|
|
MBEDTLS_SSL_MAC_ADD + \
|
|
MBEDTLS_SSL_PADDING_ADD + \
|
|
MBEDTLS_SSL_MAX_CID_EXPANSION \
|
|
)
|
|
|
|
#define MBEDTLS_SSL_IN_PAYLOAD_LEN (MBEDTLS_SSL_PAYLOAD_OVERHEAD + \
|
|
(MBEDTLS_SSL_IN_CONTENT_LEN))
|
|
|
|
#define MBEDTLS_SSL_OUT_PAYLOAD_LEN (MBEDTLS_SSL_PAYLOAD_OVERHEAD + \
|
|
(MBEDTLS_SSL_OUT_CONTENT_LEN))
|
|
|
|
/* The maximum number of buffered handshake messages. */
|
|
#define MBEDTLS_SSL_MAX_BUFFERED_HS 4
|
|
|
|
/* Maximum length we can advertise as our max content length for
|
|
RFC 6066 max_fragment_length extension negotiation purposes
|
|
(the lesser of both sizes, if they are unequal.)
|
|
*/
|
|
#define MBEDTLS_TLS_EXT_ADV_CONTENT_LEN ( \
|
|
(MBEDTLS_SSL_IN_CONTENT_LEN > MBEDTLS_SSL_OUT_CONTENT_LEN) \
|
|
? (MBEDTLS_SSL_OUT_CONTENT_LEN) \
|
|
: (MBEDTLS_SSL_IN_CONTENT_LEN) \
|
|
)
|
|
|
|
/* Maximum size in bytes of list in signature algorithms ext., RFC 5246/8446 */
|
|
#define MBEDTLS_SSL_MAX_SIG_ALG_LIST_LEN 65534
|
|
|
|
/* Minimum size in bytes of list in signature algorithms ext., RFC 5246/8446 */
|
|
#define MBEDTLS_SSL_MIN_SIG_ALG_LIST_LEN 2
|
|
|
|
/* Maximum size in bytes of list in supported elliptic curve ext., RFC 4492 */
|
|
#define MBEDTLS_SSL_MAX_CURVE_LIST_LEN 65535
|
|
|
|
#define MBEDTLS_RECEIVED_SIG_ALGS_SIZE 20
|
|
|
|
#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
|
|
|
|
#define MBEDTLS_TLS_SIG_NONE MBEDTLS_TLS1_3_SIG_NONE
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
|
|
#define MBEDTLS_SSL_TLS12_SIG_AND_HASH_ALG(sig, hash) ((hash << 8) | sig)
|
|
#define MBEDTLS_SSL_TLS12_SIG_ALG_FROM_SIG_AND_HASH_ALG(alg) (alg & 0xFF)
|
|
#define MBEDTLS_SSL_TLS12_HASH_ALG_FROM_SIG_AND_HASH_ALG(alg) (alg >> 8)
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
|
|
|
|
#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED */
|
|
|
|
/*
|
|
* Check that we obey the standard's message size bounds
|
|
*/
|
|
|
|
#if MBEDTLS_SSL_IN_CONTENT_LEN > 16384
|
|
#error "Bad configuration - incoming record content too large."
|
|
#endif
|
|
|
|
#if MBEDTLS_SSL_OUT_CONTENT_LEN > 16384
|
|
#error "Bad configuration - outgoing record content too large."
|
|
#endif
|
|
|
|
#if MBEDTLS_SSL_IN_PAYLOAD_LEN > MBEDTLS_SSL_IN_CONTENT_LEN + 2048
|
|
#error "Bad configuration - incoming protected record payload too large."
|
|
#endif
|
|
|
|
#if MBEDTLS_SSL_OUT_PAYLOAD_LEN > MBEDTLS_SSL_OUT_CONTENT_LEN + 2048
|
|
#error "Bad configuration - outgoing protected record payload too large."
|
|
#endif
|
|
|
|
/* Calculate buffer sizes */
|
|
|
|
/* Note: Even though the TLS record header is only 5 bytes
|
|
long, we're internally using 8 bytes to store the
|
|
implicit sequence number. */
|
|
#define MBEDTLS_SSL_HEADER_LEN 13
|
|
|
|
#if !defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
|
|
#define MBEDTLS_SSL_IN_BUFFER_LEN \
|
|
((MBEDTLS_SSL_HEADER_LEN) + (MBEDTLS_SSL_IN_PAYLOAD_LEN))
|
|
#else
|
|
#define MBEDTLS_SSL_IN_BUFFER_LEN \
|
|
((MBEDTLS_SSL_HEADER_LEN) + (MBEDTLS_SSL_IN_PAYLOAD_LEN) \
|
|
+ (MBEDTLS_SSL_CID_IN_LEN_MAX))
|
|
#endif
|
|
|
|
#if !defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
|
|
#define MBEDTLS_SSL_OUT_BUFFER_LEN \
|
|
((MBEDTLS_SSL_HEADER_LEN) + (MBEDTLS_SSL_OUT_PAYLOAD_LEN))
|
|
#else
|
|
#define MBEDTLS_SSL_OUT_BUFFER_LEN \
|
|
((MBEDTLS_SSL_HEADER_LEN) + (MBEDTLS_SSL_OUT_PAYLOAD_LEN) \
|
|
+ (MBEDTLS_SSL_CID_OUT_LEN_MAX))
|
|
#endif
|
|
|
|
#define MBEDTLS_CLIENT_HELLO_RANDOM_LEN 32
|
|
#define MBEDTLS_SERVER_HELLO_RANDOM_LEN 32
|
|
|
|
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
|
|
/**
|
|
* \brief Return the maximum fragment length (payload, in bytes) for
|
|
* the output buffer. For the client, this is the configured
|
|
* value. For the server, it is the minimum of two - the
|
|
* configured value and the negotiated one.
|
|
*
|
|
* \sa mbedtls_ssl_conf_max_frag_len()
|
|
* \sa mbedtls_ssl_get_max_out_record_payload()
|
|
*
|
|
* \param ssl SSL context
|
|
*
|
|
* \return Current maximum fragment length for the output buffer.
|
|
*/
|
|
size_t mbedtls_ssl_get_output_max_frag_len(const mbedtls_ssl_context *ssl);
|
|
|
|
/**
|
|
* \brief Return the maximum fragment length (payload, in bytes) for
|
|
* the input buffer. This is the negotiated maximum fragment
|
|
* length, or, if there is none, MBEDTLS_SSL_IN_CONTENT_LEN.
|
|
* If it is not defined either, the value is 2^14. This function
|
|
* works as its predecessor, \c mbedtls_ssl_get_max_frag_len().
|
|
*
|
|
* \sa mbedtls_ssl_conf_max_frag_len()
|
|
* \sa mbedtls_ssl_get_max_in_record_payload()
|
|
*
|
|
* \param ssl SSL context
|
|
*
|
|
* \return Current maximum fragment length for the output buffer.
|
|
*/
|
|
size_t mbedtls_ssl_get_input_max_frag_len(const mbedtls_ssl_context *ssl);
|
|
#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
|
|
|
|
#if defined(MBEDTLS_SSL_RECORD_SIZE_LIMIT)
|
|
/**
|
|
* \brief Get the size limit in bytes for the protected outgoing records
|
|
* as defined in RFC 8449
|
|
*
|
|
* \param ssl SSL context
|
|
*
|
|
* \return The size limit in bytes for the protected outgoing
|
|
* records as defined in RFC 8449.
|
|
*/
|
|
size_t mbedtls_ssl_get_output_record_size_limit(const mbedtls_ssl_context *ssl);
|
|
#endif /* MBEDTLS_SSL_RECORD_SIZE_LIMIT */
|
|
|
|
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
|
|
static inline size_t mbedtls_ssl_get_output_buflen(const mbedtls_ssl_context *ctx)
|
|
{
|
|
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
|
|
return mbedtls_ssl_get_output_max_frag_len(ctx)
|
|
+ MBEDTLS_SSL_HEADER_LEN + MBEDTLS_SSL_PAYLOAD_OVERHEAD
|
|
+ MBEDTLS_SSL_CID_OUT_LEN_MAX;
|
|
#else
|
|
return mbedtls_ssl_get_output_max_frag_len(ctx)
|
|
+ MBEDTLS_SSL_HEADER_LEN + MBEDTLS_SSL_PAYLOAD_OVERHEAD;
|
|
#endif
|
|
}
|
|
|
|
static inline size_t mbedtls_ssl_get_input_buflen(const mbedtls_ssl_context *ctx)
|
|
{
|
|
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
|
|
return mbedtls_ssl_get_input_max_frag_len(ctx)
|
|
+ MBEDTLS_SSL_HEADER_LEN + MBEDTLS_SSL_PAYLOAD_OVERHEAD
|
|
+ MBEDTLS_SSL_CID_IN_LEN_MAX;
|
|
#else
|
|
return mbedtls_ssl_get_input_max_frag_len(ctx)
|
|
+ MBEDTLS_SSL_HEADER_LEN + MBEDTLS_SSL_PAYLOAD_OVERHEAD;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* TLS extension flags (for extensions with outgoing ServerHello content
|
|
* that need it (e.g. for RENEGOTIATION_INFO the server already knows because
|
|
* of state of the renegotiation flag, so no indicator is required)
|
|
*/
|
|
#define MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS_PRESENT (1 << 0)
|
|
#define MBEDTLS_TLS_EXT_ECJPAKE_KKPP_OK (1 << 1)
|
|
|
|
/**
|
|
* \brief This function checks if the remaining size in a buffer is
|
|
* greater or equal than a needed space.
|
|
*
|
|
* \param cur Pointer to the current position in the buffer.
|
|
* \param end Pointer to one past the end of the buffer.
|
|
* \param need Needed space in bytes.
|
|
*
|
|
* \return Zero if the needed space is available in the buffer, non-zero
|
|
* otherwise.
|
|
*/
|
|
#if !defined(MBEDTLS_TEST_HOOKS)
|
|
static inline int mbedtls_ssl_chk_buf_ptr(const uint8_t *cur,
|
|
const uint8_t *end, size_t need)
|
|
{
|
|
return (cur > end) || (need > (size_t) (end - cur));
|
|
}
|
|
#else
|
|
typedef struct {
|
|
const uint8_t *cur;
|
|
const uint8_t *end;
|
|
size_t need;
|
|
} mbedtls_ssl_chk_buf_ptr_args;
|
|
|
|
void mbedtls_ssl_set_chk_buf_ptr_fail_args(
|
|
const uint8_t *cur, const uint8_t *end, size_t need);
|
|
void mbedtls_ssl_reset_chk_buf_ptr_fail_args(void);
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_cmp_chk_buf_ptr_fail_args(mbedtls_ssl_chk_buf_ptr_args *args);
|
|
|
|
static inline int mbedtls_ssl_chk_buf_ptr(const uint8_t *cur,
|
|
const uint8_t *end, size_t need)
|
|
{
|
|
if ((cur > end) || (need > (size_t) (end - cur))) {
|
|
mbedtls_ssl_set_chk_buf_ptr_fail_args(cur, end, need);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif /* MBEDTLS_TEST_HOOKS */
|
|
|
|
/**
|
|
* \brief This macro checks if the remaining size in a buffer is
|
|
* greater or equal than a needed space. If it is not the case,
|
|
* it returns an SSL_BUFFER_TOO_SMALL error.
|
|
*
|
|
* \param cur Pointer to the current position in the buffer.
|
|
* \param end Pointer to one past the end of the buffer.
|
|
* \param need Needed space in bytes.
|
|
*
|
|
*/
|
|
#define MBEDTLS_SSL_CHK_BUF_PTR(cur, end, need) \
|
|
do { \
|
|
if (mbedtls_ssl_chk_buf_ptr((cur), (end), (need)) != 0) \
|
|
{ \
|
|
return MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL; \
|
|
} \
|
|
} while (0)
|
|
|
|
/**
|
|
* \brief This macro checks if the remaining length in an input buffer is
|
|
* greater or equal than a needed length. If it is not the case, it
|
|
* returns #MBEDTLS_ERR_SSL_DECODE_ERROR error and pends a
|
|
* #MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR alert message.
|
|
*
|
|
* This is a function-like macro. It is guaranteed to evaluate each
|
|
* argument exactly once.
|
|
*
|
|
* \param cur Pointer to the current position in the buffer.
|
|
* \param end Pointer to one past the end of the buffer.
|
|
* \param need Needed length in bytes.
|
|
*
|
|
*/
|
|
#define MBEDTLS_SSL_CHK_BUF_READ_PTR(cur, end, need) \
|
|
do { \
|
|
if (mbedtls_ssl_chk_buf_ptr((cur), (end), (need)) != 0) \
|
|
{ \
|
|
MBEDTLS_SSL_DEBUG_MSG(1, \
|
|
("missing input data in %s", __func__)); \
|
|
MBEDTLS_SSL_PEND_FATAL_ALERT(MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR, \
|
|
MBEDTLS_ERR_SSL_DECODE_ERROR); \
|
|
return MBEDTLS_ERR_SSL_DECODE_ERROR; \
|
|
} \
|
|
} while (0)
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
typedef int mbedtls_ssl_tls_prf_cb(const unsigned char *secret, size_t slen,
|
|
const char *label,
|
|
const unsigned char *random, size_t rlen,
|
|
unsigned char *dstbuf, size_t dlen);
|
|
|
|
/* cipher.h exports the maximum IV, key and block length from
|
|
* all ciphers enabled in the config, regardless of whether those
|
|
* ciphers are actually usable in SSL/TLS. Notably, XTS is enabled
|
|
* in the default configuration and uses 64 Byte keys, but it is
|
|
* not used for record protection in SSL/TLS.
|
|
*
|
|
* In order to prevent unnecessary inflation of key structures,
|
|
* we introduce SSL-specific variants of the max-{key,block,IV}
|
|
* macros here which are meant to only take those ciphers into
|
|
* account which can be negotiated in SSL/TLS.
|
|
*
|
|
* Since the current definitions of MBEDTLS_MAX_{KEY|BLOCK|IV}_LENGTH
|
|
* in cipher.h are rough overapproximations of the real maxima, here
|
|
* we content ourselves with replicating those overapproximations
|
|
* for the maximum block and IV length, and excluding XTS from the
|
|
* computation of the maximum key length. */
|
|
#define MBEDTLS_SSL_MAX_BLOCK_LENGTH 16
|
|
#define MBEDTLS_SSL_MAX_IV_LENGTH 16
|
|
#define MBEDTLS_SSL_MAX_KEY_LENGTH 32
|
|
|
|
/**
|
|
* \brief The data structure holding the cryptographic material (key and IV)
|
|
* used for record protection in TLS 1.3.
|
|
*/
|
|
struct mbedtls_ssl_key_set {
|
|
/*! The key for client->server records. */
|
|
unsigned char client_write_key[MBEDTLS_SSL_MAX_KEY_LENGTH];
|
|
/*! The key for server->client records. */
|
|
unsigned char server_write_key[MBEDTLS_SSL_MAX_KEY_LENGTH];
|
|
/*! The IV for client->server records. */
|
|
unsigned char client_write_iv[MBEDTLS_SSL_MAX_IV_LENGTH];
|
|
/*! The IV for server->client records. */
|
|
unsigned char server_write_iv[MBEDTLS_SSL_MAX_IV_LENGTH];
|
|
|
|
size_t key_len; /*!< The length of client_write_key and
|
|
* server_write_key, in Bytes. */
|
|
size_t iv_len; /*!< The length of client_write_iv and
|
|
* server_write_iv, in Bytes. */
|
|
};
|
|
typedef struct mbedtls_ssl_key_set mbedtls_ssl_key_set;
|
|
|
|
typedef struct {
|
|
unsigned char binder_key[MBEDTLS_TLS1_3_MD_MAX_SIZE];
|
|
unsigned char client_early_traffic_secret[MBEDTLS_TLS1_3_MD_MAX_SIZE];
|
|
unsigned char early_exporter_master_secret[MBEDTLS_TLS1_3_MD_MAX_SIZE];
|
|
} mbedtls_ssl_tls13_early_secrets;
|
|
|
|
typedef struct {
|
|
unsigned char client_handshake_traffic_secret[MBEDTLS_TLS1_3_MD_MAX_SIZE];
|
|
unsigned char server_handshake_traffic_secret[MBEDTLS_TLS1_3_MD_MAX_SIZE];
|
|
} mbedtls_ssl_tls13_handshake_secrets;
|
|
|
|
/*
|
|
* This structure contains the parameters only needed during handshake.
|
|
*/
|
|
struct mbedtls_ssl_handshake_params {
|
|
/* Frequently-used boolean or byte fields (placed early to take
|
|
* advantage of smaller code size for indirect access on Arm Thumb) */
|
|
uint8_t resume; /*!< session resume indicator*/
|
|
uint8_t cli_exts; /*!< client extension presence*/
|
|
|
|
#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
|
|
uint8_t sni_authmode; /*!< authmode from SNI callback */
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_SRV_C)
|
|
/* Flag indicating if a CertificateRequest message has been sent
|
|
* to the client or not. */
|
|
uint8_t certificate_request_sent;
|
|
#endif /* MBEDTLS_SSL_SRV_C */
|
|
|
|
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
|
|
uint8_t new_session_ticket; /*!< use NewSessionTicket? */
|
|
#endif /* MBEDTLS_SSL_SESSION_TICKETS */
|
|
|
|
#if defined(MBEDTLS_SSL_CLI_C)
|
|
/** Minimum TLS version to be negotiated.
|
|
*
|
|
* It is set up in the ClientHello writing preparation stage and used
|
|
* throughout the ClientHello writing. Not relevant anymore as soon as
|
|
* the protocol version has been negotiated thus as soon as the
|
|
* ServerHello is received.
|
|
* For a fresh handshake not linked to any previous handshake, it is
|
|
* equal to the configured minimum minor version to be negotiated. When
|
|
* renegotiating or resuming a session, it is equal to the previously
|
|
* negotiated minor version.
|
|
*
|
|
* There is no maximum TLS version field in this handshake context.
|
|
* From the start of the handshake, we need to define a current protocol
|
|
* version for the record layer which we define as the maximum TLS
|
|
* version to be negotiated. The `tls_version` field of the SSL context is
|
|
* used to store this maximum value until it contains the actual
|
|
* negotiated value.
|
|
*/
|
|
mbedtls_ssl_protocol_version min_tls_version;
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
|
|
uint8_t extended_ms; /*!< use Extended Master Secret? */
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
|
|
uint8_t async_in_progress; /*!< an asynchronous operation is in progress */
|
|
#endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_DTLS)
|
|
unsigned char retransmit_state; /*!< Retransmission state */
|
|
#endif
|
|
|
|
#if !defined(MBEDTLS_DEPRECATED_REMOVED)
|
|
unsigned char group_list_heap_allocated;
|
|
unsigned char sig_algs_heap_allocated;
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
|
|
uint8_t ecrs_enabled; /*!< Handshake supports EC restart? */
|
|
enum { /* this complements ssl->state with info on intra-state operations */
|
|
ssl_ecrs_none = 0, /*!< nothing going on (yet) */
|
|
ssl_ecrs_crt_verify, /*!< Certificate: crt_verify() */
|
|
ssl_ecrs_ske_start_processing, /*!< ServerKeyExchange: pk_verify() */
|
|
ssl_ecrs_cke_ecdh_calc_secret, /*!< ClientKeyExchange: ECDH step 2 */
|
|
ssl_ecrs_crt_vrfy_sign, /*!< CertificateVerify: pk_sign() */
|
|
} ecrs_state; /*!< current (or last) operation */
|
|
mbedtls_x509_crt *ecrs_peer_cert; /*!< The peer's CRT chain. */
|
|
size_t ecrs_n; /*!< place for saving a length */
|
|
#endif
|
|
|
|
mbedtls_ssl_ciphersuite_t const *ciphersuite_info;
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int (*update_checksum)(mbedtls_ssl_context *, const unsigned char *, size_t);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int (*calc_verify)(const mbedtls_ssl_context *, unsigned char *, size_t *);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int (*calc_finished)(mbedtls_ssl_context *, unsigned char *, int);
|
|
mbedtls_ssl_tls_prf_cb *tls_prf;
|
|
|
|
/*
|
|
* Handshake specific crypto variables
|
|
*/
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
|
|
uint8_t key_exchange_mode; /*!< Selected key exchange mode */
|
|
|
|
/** Number of HelloRetryRequest messages received/sent from/to the server. */
|
|
int hello_retry_request_count;
|
|
|
|
#if defined(MBEDTLS_SSL_SRV_C)
|
|
/** selected_group of key_share extension in HelloRetryRequest message. */
|
|
uint16_t hrr_selected_group;
|
|
#if defined(MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_SOME_PSK_ENABLED)
|
|
uint8_t tls13_kex_modes; /*!< Key exchange modes supported by the client */
|
|
#endif
|
|
#if defined(MBEDTLS_SSL_SESSION_TICKETS)
|
|
uint16_t new_session_tickets_count; /*!< number of session tickets */
|
|
#endif
|
|
#endif /* MBEDTLS_SSL_SRV_C */
|
|
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
|
|
|
|
#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
|
|
uint16_t received_sig_algs[MBEDTLS_RECEIVED_SIG_ALGS_SIZE];
|
|
#endif
|
|
|
|
#if !defined(MBEDTLS_DEPRECATED_REMOVED)
|
|
const uint16_t *group_list;
|
|
const uint16_t *sig_algs;
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_DHM_C)
|
|
mbedtls_dhm_context dhm_ctx; /*!< DHM key exchange */
|
|
#endif
|
|
|
|
#if !defined(MBEDTLS_USE_PSA_CRYPTO) && \
|
|
defined(MBEDTLS_KEY_EXCHANGE_SOME_ECDH_OR_ECDHE_1_2_ENABLED)
|
|
mbedtls_ecdh_context ecdh_ctx; /*!< ECDH key exchange */
|
|
#endif /* !MBEDTLS_USE_PSA_CRYPTO &&
|
|
MBEDTLS_KEY_EXCHANGE_SOME_ECDH_OR_ECDHE_1_2_ENABLED */
|
|
|
|
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_XXDH_PSA_ANY_ENABLED)
|
|
psa_key_type_t xxdh_psa_type;
|
|
size_t xxdh_psa_bits;
|
|
mbedtls_svc_key_id_t xxdh_psa_privkey;
|
|
uint8_t xxdh_psa_privkey_is_external;
|
|
unsigned char xxdh_psa_peerkey[PSA_EXPORT_PUBLIC_KEY_MAX_SIZE];
|
|
size_t xxdh_psa_peerkey_len;
|
|
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_XXDH_PSA_ANY_ENABLED */
|
|
|
|
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
psa_pake_operation_t psa_pake_ctx; /*!< EC J-PAKE key exchange */
|
|
mbedtls_svc_key_id_t psa_pake_password;
|
|
uint8_t psa_pake_ctx_is_ok;
|
|
#else
|
|
mbedtls_ecjpake_context ecjpake_ctx; /*!< EC J-PAKE key exchange */
|
|
#endif /* MBEDTLS_USE_PSA_CRYPTO */
|
|
#if defined(MBEDTLS_SSL_CLI_C)
|
|
unsigned char *ecjpake_cache; /*!< Cache for ClientHello ext */
|
|
size_t ecjpake_cache_len; /*!< Length of cached data */
|
|
#endif
|
|
#endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
|
|
|
|
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_ECDH_OR_ECDHE_ANY_ENABLED) || \
|
|
defined(MBEDTLS_KEY_EXCHANGE_ECDSA_CERT_REQ_ANY_ALLOWED_ENABLED) || \
|
|
defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
|
|
uint16_t *curves_tls_id; /*!< List of TLS IDs of supported elliptic curves */
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_PSK_ENABLED)
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
mbedtls_svc_key_id_t psk_opaque; /*!< Opaque PSK from the callback */
|
|
uint8_t psk_opaque_is_internal;
|
|
#else
|
|
unsigned char *psk; /*!< PSK from the callback */
|
|
size_t psk_len; /*!< Length of PSK from callback */
|
|
#endif /* MBEDTLS_USE_PSA_CRYPTO */
|
|
uint16_t selected_identity;
|
|
#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_PSK_ENABLED */
|
|
|
|
#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
|
|
mbedtls_x509_crt_restart_ctx ecrs_ctx; /*!< restart context */
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_X509_CRT_PARSE_C)
|
|
mbedtls_ssl_key_cert *key_cert; /*!< chosen key/cert pair (server) */
|
|
#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
|
|
mbedtls_ssl_key_cert *sni_key_cert; /*!< key/cert list from SNI */
|
|
mbedtls_x509_crt *sni_ca_chain; /*!< trusted CAs from SNI callback */
|
|
mbedtls_x509_crl *sni_ca_crl; /*!< trusted CAs CRLs from SNI */
|
|
#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
|
|
#endif /* MBEDTLS_X509_CRT_PARSE_C */
|
|
|
|
#if defined(MBEDTLS_X509_CRT_PARSE_C) && \
|
|
!defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
|
|
mbedtls_pk_context peer_pubkey; /*!< The public key from the peer. */
|
|
#endif /* MBEDTLS_X509_CRT_PARSE_C && !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
|
|
|
|
struct {
|
|
size_t total_bytes_buffered; /*!< Cumulative size of heap allocated
|
|
* buffers used for message buffering. */
|
|
|
|
uint8_t seen_ccs; /*!< Indicates if a CCS message has
|
|
* been seen in the current flight. */
|
|
|
|
struct mbedtls_ssl_hs_buffer {
|
|
unsigned is_valid : 1;
|
|
unsigned is_fragmented : 1;
|
|
unsigned is_complete : 1;
|
|
unsigned char *data;
|
|
size_t data_len;
|
|
} hs[MBEDTLS_SSL_MAX_BUFFERED_HS];
|
|
|
|
struct {
|
|
unsigned char *data;
|
|
size_t len;
|
|
unsigned epoch;
|
|
} future_record;
|
|
|
|
} buffering;
|
|
|
|
#if defined(MBEDTLS_SSL_CLI_C) && \
|
|
(defined(MBEDTLS_SSL_PROTO_DTLS) || \
|
|
defined(MBEDTLS_SSL_PROTO_TLS1_3))
|
|
unsigned char *cookie; /*!< HelloVerifyRequest cookie for DTLS
|
|
* HelloRetryRequest cookie for TLS 1.3 */
|
|
#if !defined(MBEDTLS_SSL_PROTO_TLS1_3)
|
|
/* RFC 6347 page 15
|
|
...
|
|
opaque cookie<0..2^8-1>;
|
|
...
|
|
*/
|
|
uint8_t cookie_len;
|
|
#else
|
|
/* RFC 8446 page 39
|
|
...
|
|
opaque cookie<0..2^16-1>;
|
|
...
|
|
If TLS1_3 is enabled, the max length is 2^16 - 1
|
|
*/
|
|
uint16_t cookie_len; /*!< DTLS: HelloVerifyRequest cookie length
|
|
* TLS1_3: HelloRetryRequest cookie length */
|
|
#endif
|
|
#endif /* MBEDTLS_SSL_CLI_C &&
|
|
( MBEDTLS_SSL_PROTO_DTLS ||
|
|
MBEDTLS_SSL_PROTO_TLS1_3 ) */
|
|
#if defined(MBEDTLS_SSL_SRV_C) && defined(MBEDTLS_SSL_PROTO_DTLS)
|
|
unsigned char cookie_verify_result; /*!< Srv: flag for sending a cookie */
|
|
#endif /* MBEDTLS_SSL_SRV_C && MBEDTLS_SSL_PROTO_DTLS */
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_DTLS)
|
|
unsigned int out_msg_seq; /*!< Outgoing handshake sequence number */
|
|
unsigned int in_msg_seq; /*!< Incoming handshake sequence number */
|
|
|
|
uint32_t retransmit_timeout; /*!< Current value of timeout */
|
|
mbedtls_ssl_flight_item *flight; /*!< Current outgoing flight */
|
|
mbedtls_ssl_flight_item *cur_msg; /*!< Current message in flight */
|
|
unsigned char *cur_msg_p; /*!< Position in current message */
|
|
unsigned int in_flight_start_seq; /*!< Minimum message sequence in the
|
|
flight being received */
|
|
mbedtls_ssl_transform *alt_transform_out; /*!< Alternative transform for
|
|
resending messages */
|
|
unsigned char alt_out_ctr[MBEDTLS_SSL_SEQUENCE_NUMBER_LEN]; /*!< Alternative record epoch/counter
|
|
for resending messages */
|
|
|
|
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
|
|
/* The state of CID configuration in this handshake. */
|
|
|
|
uint8_t cid_in_use; /*!< This indicates whether the use of the CID extension
|
|
* has been negotiated. Possible values are
|
|
* #MBEDTLS_SSL_CID_ENABLED and
|
|
* #MBEDTLS_SSL_CID_DISABLED. */
|
|
unsigned char peer_cid[MBEDTLS_SSL_CID_OUT_LEN_MAX]; /*! The peer's CID */
|
|
uint8_t peer_cid_len; /*!< The length of
|
|
* \c peer_cid. */
|
|
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
|
|
|
|
uint16_t mtu; /*!< Handshake mtu, used to fragment outgoing messages */
|
|
#endif /* MBEDTLS_SSL_PROTO_DTLS */
|
|
|
|
/*
|
|
* Checksum contexts
|
|
*/
|
|
#if defined(MBEDTLS_MD_CAN_SHA256)
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
psa_hash_operation_t fin_sha256_psa;
|
|
#else
|
|
mbedtls_md_context_t fin_sha256;
|
|
#endif
|
|
#endif
|
|
#if defined(MBEDTLS_MD_CAN_SHA384)
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
psa_hash_operation_t fin_sha384_psa;
|
|
#else
|
|
mbedtls_md_context_t fin_sha384;
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
|
|
uint16_t offered_group_id; /* The NamedGroup value for the group
|
|
* that is being used for ephemeral
|
|
* key exchange.
|
|
*
|
|
* On the client: Defaults to the first
|
|
* entry in the client's group list,
|
|
* but can be overwritten by the HRR. */
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
|
|
|
|
#if defined(MBEDTLS_SSL_CLI_C)
|
|
uint8_t client_auth; /*!< used to check if CertificateRequest has been
|
|
received from server side. If CertificateRequest
|
|
has been received, Certificate and CertificateVerify
|
|
should be sent to server */
|
|
#endif /* MBEDTLS_SSL_CLI_C */
|
|
/*
|
|
* State-local variables used during the processing
|
|
* of a specific handshake state.
|
|
*/
|
|
union {
|
|
/* Outgoing Finished message */
|
|
struct {
|
|
uint8_t preparation_done;
|
|
|
|
/* Buffer holding digest of the handshake up to
|
|
* but excluding the outgoing finished message. */
|
|
unsigned char digest[MBEDTLS_TLS1_3_MD_MAX_SIZE];
|
|
size_t digest_len;
|
|
} finished_out;
|
|
|
|
/* Incoming Finished message */
|
|
struct {
|
|
uint8_t preparation_done;
|
|
|
|
/* Buffer holding digest of the handshake up to but
|
|
* excluding the peer's incoming finished message. */
|
|
unsigned char digest[MBEDTLS_TLS1_3_MD_MAX_SIZE];
|
|
size_t digest_len;
|
|
} finished_in;
|
|
|
|
} state_local;
|
|
|
|
/* End of state-local variables. */
|
|
|
|
unsigned char randbytes[MBEDTLS_CLIENT_HELLO_RANDOM_LEN +
|
|
MBEDTLS_SERVER_HELLO_RANDOM_LEN];
|
|
/*!< random bytes */
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
|
|
unsigned char premaster[MBEDTLS_PREMASTER_SIZE];
|
|
/*!< premaster secret */
|
|
size_t pmslen; /*!< premaster length */
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
|
|
uint32_t sent_extensions; /*!< extensions sent by endpoint */
|
|
uint32_t received_extensions; /*!< extensions received by endpoint */
|
|
|
|
#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
|
|
unsigned char certificate_request_context_len;
|
|
unsigned char *certificate_request_context;
|
|
#endif
|
|
|
|
/** TLS 1.3 transform for encrypted handshake messages. */
|
|
mbedtls_ssl_transform *transform_handshake;
|
|
union {
|
|
unsigned char early[MBEDTLS_TLS1_3_MD_MAX_SIZE];
|
|
unsigned char handshake[MBEDTLS_TLS1_3_MD_MAX_SIZE];
|
|
unsigned char app[MBEDTLS_TLS1_3_MD_MAX_SIZE];
|
|
} tls13_master_secrets;
|
|
|
|
mbedtls_ssl_tls13_handshake_secrets tls13_hs_secrets;
|
|
#if defined(MBEDTLS_SSL_EARLY_DATA)
|
|
/** TLS 1.3 transform for early data and handshake messages. */
|
|
mbedtls_ssl_transform *transform_earlydata;
|
|
#endif
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
|
|
|
|
#if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
|
|
/** Asynchronous operation context. This field is meant for use by the
|
|
* asynchronous operation callbacks (mbedtls_ssl_config::f_async_sign_start,
|
|
* mbedtls_ssl_config::f_async_decrypt_start,
|
|
* mbedtls_ssl_config::f_async_resume, mbedtls_ssl_config::f_async_cancel).
|
|
* The library does not use it internally. */
|
|
void *user_async_ctx;
|
|
#endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
|
|
|
|
#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
|
|
const unsigned char *sni_name; /*!< raw SNI */
|
|
size_t sni_name_len; /*!< raw SNI len */
|
|
#if defined(MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED)
|
|
const mbedtls_x509_crt *dn_hints; /*!< acceptable client cert issuers */
|
|
#endif
|
|
#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
|
|
};
|
|
|
|
typedef struct mbedtls_ssl_hs_buffer mbedtls_ssl_hs_buffer;
|
|
|
|
/*
|
|
* Representation of decryption/encryption transformations on records
|
|
*
|
|
* There are the following general types of record transformations:
|
|
* - Stream transformations (TLS versions == 1.2 only)
|
|
* Transformation adding a MAC and applying a stream-cipher
|
|
* to the authenticated message.
|
|
* - CBC block cipher transformations ([D]TLS versions == 1.2 only)
|
|
* For TLS 1.2, no IV is generated at key extraction time, but every
|
|
* encrypted record is explicitly prefixed by the IV with which it was
|
|
* encrypted.
|
|
* - AEAD transformations ([D]TLS versions == 1.2 only)
|
|
* These come in two fundamentally different versions, the first one
|
|
* used in TLS 1.2, excluding ChaChaPoly ciphersuites, and the second
|
|
* one used for ChaChaPoly ciphersuites in TLS 1.2 as well as for TLS 1.3.
|
|
* In the first transformation, the IV to be used for a record is obtained
|
|
* as the concatenation of an explicit, static 4-byte IV and the 8-byte
|
|
* record sequence number, and explicitly prepending this sequence number
|
|
* to the encrypted record. In contrast, in the second transformation
|
|
* the IV is obtained by XOR'ing a static IV obtained at key extraction
|
|
* time with the 8-byte record sequence number, without prepending the
|
|
* latter to the encrypted record.
|
|
*
|
|
* Additionally, DTLS 1.2 + CID as well as TLS 1.3 use an inner plaintext
|
|
* which allows to add flexible length padding and to hide a record's true
|
|
* content type.
|
|
*
|
|
* In addition to type and version, the following parameters are relevant:
|
|
* - The symmetric cipher algorithm to be used.
|
|
* - The (static) encryption/decryption keys for the cipher.
|
|
* - For stream/CBC, the type of message digest to be used.
|
|
* - For stream/CBC, (static) encryption/decryption keys for the digest.
|
|
* - For AEAD transformations, the size (potentially 0) of an explicit,
|
|
* random initialization vector placed in encrypted records.
|
|
* - For some transformations (currently AEAD) an implicit IV. It is static
|
|
* and (if present) is combined with the explicit IV in a transformation-
|
|
* -dependent way (e.g. appending in TLS 1.2 and XOR'ing in TLS 1.3).
|
|
* - For stream/CBC, a flag determining the order of encryption and MAC.
|
|
* - The details of the transformation depend on the SSL/TLS version.
|
|
* - The length of the authentication tag.
|
|
*
|
|
* The struct below refines this abstract view as follows:
|
|
* - The cipher underlying the transformation is managed in
|
|
* cipher contexts cipher_ctx_{enc/dec}, which must have the
|
|
* same cipher type. The mode of these cipher contexts determines
|
|
* the type of the transformation in the sense above: e.g., if
|
|
* the type is MBEDTLS_CIPHER_AES_256_CBC resp. MBEDTLS_CIPHER_AES_192_GCM
|
|
* then the transformation has type CBC resp. AEAD.
|
|
* - The cipher keys are never stored explicitly but
|
|
* are maintained within cipher_ctx_{enc/dec}.
|
|
* - For stream/CBC transformations, the message digest contexts
|
|
* used for the MAC's are stored in md_ctx_{enc/dec}. These contexts
|
|
* are unused for AEAD transformations.
|
|
* - For stream/CBC transformations, the MAC keys are not stored explicitly
|
|
* but maintained within md_ctx_{enc/dec}.
|
|
* - The mac_enc and mac_dec fields are unused for EAD transformations.
|
|
* - For transformations using an implicit IV maintained within
|
|
* the transformation context, its contents are stored within
|
|
* iv_{enc/dec}.
|
|
* - The value of ivlen indicates the length of the IV.
|
|
* This is redundant in case of stream/CBC transformations
|
|
* which always use 0 resp. the cipher's block length as the
|
|
* IV length, but is needed for AEAD ciphers and may be
|
|
* different from the underlying cipher's block length
|
|
* in this case.
|
|
* - The field fixed_ivlen is nonzero for AEAD transformations only
|
|
* and indicates the length of the static part of the IV which is
|
|
* constant throughout the communication, and which is stored in
|
|
* the first fixed_ivlen bytes of the iv_{enc/dec} arrays.
|
|
* - tls_version denotes the 2-byte TLS version
|
|
* - For stream/CBC transformations, maclen denotes the length of the
|
|
* authentication tag, while taglen is unused and 0.
|
|
* - For AEAD transformations, taglen denotes the length of the
|
|
* authentication tag, while maclen is unused and 0.
|
|
* - For CBC transformations, encrypt_then_mac determines the
|
|
* order of encryption and authentication. This field is unused
|
|
* in other transformations.
|
|
*
|
|
*/
|
|
struct mbedtls_ssl_transform {
|
|
/*
|
|
* Session specific crypto layer
|
|
*/
|
|
size_t minlen; /*!< min. ciphertext length */
|
|
size_t ivlen; /*!< IV length */
|
|
size_t fixed_ivlen; /*!< Fixed part of IV (AEAD) */
|
|
size_t maclen; /*!< MAC(CBC) len */
|
|
size_t taglen; /*!< TAG(AEAD) len */
|
|
|
|
unsigned char iv_enc[16]; /*!< IV (encryption) */
|
|
unsigned char iv_dec[16]; /*!< IV (decryption) */
|
|
|
|
#if defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
|
|
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
mbedtls_svc_key_id_t psa_mac_enc; /*!< MAC (encryption) */
|
|
mbedtls_svc_key_id_t psa_mac_dec; /*!< MAC (decryption) */
|
|
psa_algorithm_t psa_mac_alg; /*!< psa MAC algorithm */
|
|
#else
|
|
mbedtls_md_context_t md_ctx_enc; /*!< MAC (encryption) */
|
|
mbedtls_md_context_t md_ctx_dec; /*!< MAC (decryption) */
|
|
#endif /* MBEDTLS_USE_PSA_CRYPTO */
|
|
|
|
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
|
|
int encrypt_then_mac; /*!< flag for EtM activation */
|
|
#endif
|
|
|
|
#endif /* MBEDTLS_SSL_SOME_SUITES_USE_MAC */
|
|
|
|
mbedtls_ssl_protocol_version tls_version;
|
|
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
mbedtls_svc_key_id_t psa_key_enc; /*!< psa encryption key */
|
|
mbedtls_svc_key_id_t psa_key_dec; /*!< psa decryption key */
|
|
psa_algorithm_t psa_alg; /*!< psa algorithm */
|
|
#else
|
|
mbedtls_cipher_context_t cipher_ctx_enc; /*!< encryption context */
|
|
mbedtls_cipher_context_t cipher_ctx_dec; /*!< decryption context */
|
|
#endif /* MBEDTLS_USE_PSA_CRYPTO */
|
|
|
|
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
|
|
uint8_t in_cid_len;
|
|
uint8_t out_cid_len;
|
|
unsigned char in_cid[MBEDTLS_SSL_CID_IN_LEN_MAX];
|
|
unsigned char out_cid[MBEDTLS_SSL_CID_OUT_LEN_MAX];
|
|
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
|
|
|
|
#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
|
|
/* We need the Hello random bytes in order to re-derive keys from the
|
|
* Master Secret and other session info,
|
|
* see ssl_tls12_populate_transform() */
|
|
unsigned char randbytes[MBEDTLS_SERVER_HELLO_RANDOM_LEN +
|
|
MBEDTLS_CLIENT_HELLO_RANDOM_LEN];
|
|
/*!< ServerHello.random+ClientHello.random */
|
|
#endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
|
|
};
|
|
|
|
/*
|
|
* Return 1 if the transform uses an AEAD cipher, 0 otherwise.
|
|
* Equivalently, return 0 if a separate MAC is used, 1 otherwise.
|
|
*/
|
|
static inline int mbedtls_ssl_transform_uses_aead(
|
|
const mbedtls_ssl_transform *transform)
|
|
{
|
|
#if defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
|
|
return transform->maclen == 0 && transform->taglen != 0;
|
|
#else
|
|
(void) transform;
|
|
return 1;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Internal representation of record frames
|
|
*
|
|
* Instances come in two flavors:
|
|
* (1) Encrypted
|
|
* These always have data_offset = 0
|
|
* (2) Unencrypted
|
|
* These have data_offset set to the amount of
|
|
* pre-expansion during record protection. Concretely,
|
|
* this is the length of the fixed part of the explicit IV
|
|
* used for encryption, or 0 if no explicit IV is used
|
|
* (e.g. for stream ciphers).
|
|
*
|
|
* The reason for the data_offset in the unencrypted case
|
|
* is to allow for in-place conversion of an unencrypted to
|
|
* an encrypted record. If the offset wasn't included, the
|
|
* encrypted content would need to be shifted afterwards to
|
|
* make space for the fixed IV.
|
|
*
|
|
*/
|
|
#if MBEDTLS_SSL_CID_OUT_LEN_MAX > MBEDTLS_SSL_CID_IN_LEN_MAX
|
|
#define MBEDTLS_SSL_CID_LEN_MAX MBEDTLS_SSL_CID_OUT_LEN_MAX
|
|
#else
|
|
#define MBEDTLS_SSL_CID_LEN_MAX MBEDTLS_SSL_CID_IN_LEN_MAX
|
|
#endif
|
|
|
|
typedef struct {
|
|
uint8_t ctr[MBEDTLS_SSL_SEQUENCE_NUMBER_LEN]; /* In TLS: The implicit record sequence number.
|
|
* In DTLS: The 2-byte epoch followed by
|
|
* the 6-byte sequence number.
|
|
* This is stored as a raw big endian byte array
|
|
* as opposed to a uint64_t because we rarely
|
|
* need to perform arithmetic on this, but do
|
|
* need it as a Byte array for the purpose of
|
|
* MAC computations. */
|
|
uint8_t type; /* The record content type. */
|
|
uint8_t ver[2]; /* SSL/TLS version as present on the wire.
|
|
* Convert to internal presentation of versions
|
|
* using mbedtls_ssl_read_version() and
|
|
* mbedtls_ssl_write_version().
|
|
* Keep wire-format for MAC computations. */
|
|
|
|
unsigned char *buf; /* Memory buffer enclosing the record content */
|
|
size_t buf_len; /* Buffer length */
|
|
size_t data_offset; /* Offset of record content */
|
|
size_t data_len; /* Length of record content */
|
|
|
|
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
|
|
uint8_t cid_len; /* Length of the CID (0 if not present) */
|
|
unsigned char cid[MBEDTLS_SSL_CID_LEN_MAX]; /* The CID */
|
|
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
|
|
} mbedtls_record;
|
|
|
|
#if defined(MBEDTLS_X509_CRT_PARSE_C)
|
|
/*
|
|
* List of certificate + private key pairs
|
|
*/
|
|
struct mbedtls_ssl_key_cert {
|
|
mbedtls_x509_crt *cert; /*!< cert */
|
|
mbedtls_pk_context *key; /*!< private key */
|
|
mbedtls_ssl_key_cert *next; /*!< next key/cert pair */
|
|
};
|
|
#endif /* MBEDTLS_X509_CRT_PARSE_C */
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_DTLS)
|
|
/*
|
|
* List of handshake messages kept around for resending
|
|
*/
|
|
struct mbedtls_ssl_flight_item {
|
|
unsigned char *p; /*!< message, including handshake headers */
|
|
size_t len; /*!< length of p */
|
|
unsigned char type; /*!< type of the message: handshake or CCS */
|
|
mbedtls_ssl_flight_item *next; /*!< next handshake message(s) */
|
|
};
|
|
#endif /* MBEDTLS_SSL_PROTO_DTLS */
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
|
|
/**
|
|
* \brief Given an SSL context and its associated configuration, write the TLS
|
|
* 1.2 specific extensions of the ClientHello message.
|
|
*
|
|
* \param[in] ssl SSL context
|
|
* \param[in] buf Base address of the buffer where to write the extensions
|
|
* \param[in] end End address of the buffer where to write the extensions
|
|
* \param uses_ec Whether one proposed ciphersuite uses an elliptic curve
|
|
* (<> 0) or not ( 0 ).
|
|
* \param[out] out_len Length of the data written into the buffer \p buf
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls12_write_client_hello_exts(mbedtls_ssl_context *ssl,
|
|
unsigned char *buf,
|
|
const unsigned char *end,
|
|
int uses_ec,
|
|
size_t *out_len);
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
|
|
defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
|
|
|
|
/**
|
|
* \brief Find the preferred hash for a given signature algorithm.
|
|
*
|
|
* \param[in] ssl SSL context
|
|
* \param[in] sig_alg A signature algorithm identifier as defined in the
|
|
* TLS 1.2 SignatureAlgorithm enumeration.
|
|
*
|
|
* \return The preferred hash algorithm for \p sig_alg. It is a hash algorithm
|
|
* identifier as defined in the TLS 1.2 HashAlgorithm enumeration.
|
|
*/
|
|
unsigned int mbedtls_ssl_tls12_get_preferred_hash_for_sig_alg(
|
|
mbedtls_ssl_context *ssl,
|
|
unsigned int sig_alg);
|
|
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 &&
|
|
MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */
|
|
|
|
/**
|
|
* \brief Free referenced items in an SSL transform context and clear
|
|
* memory
|
|
*
|
|
* \param transform SSL transform context
|
|
*/
|
|
void mbedtls_ssl_transform_free(mbedtls_ssl_transform *transform);
|
|
|
|
/**
|
|
* \brief Free referenced items in an SSL handshake context and clear
|
|
* memory
|
|
*
|
|
* \param ssl SSL context
|
|
*/
|
|
void mbedtls_ssl_handshake_free(mbedtls_ssl_context *ssl);
|
|
|
|
/* set inbound transform of ssl context */
|
|
void mbedtls_ssl_set_inbound_transform(mbedtls_ssl_context *ssl,
|
|
mbedtls_ssl_transform *transform);
|
|
|
|
/* set outbound transform of ssl context */
|
|
void mbedtls_ssl_set_outbound_transform(mbedtls_ssl_context *ssl,
|
|
mbedtls_ssl_transform *transform);
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_handshake_client_step(mbedtls_ssl_context *ssl);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_handshake_server_step(mbedtls_ssl_context *ssl);
|
|
void mbedtls_ssl_handshake_wrapup(mbedtls_ssl_context *ssl);
|
|
static inline void mbedtls_ssl_handshake_set_state(mbedtls_ssl_context *ssl,
|
|
mbedtls_ssl_states state)
|
|
{
|
|
ssl->state = (int) state;
|
|
}
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_send_fatal_handshake_failure(mbedtls_ssl_context *ssl);
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_reset_checksum(mbedtls_ssl_context *ssl);
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_derive_keys(mbedtls_ssl_context *ssl);
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_handle_message_type(mbedtls_ssl_context *ssl);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_prepare_handshake_record(mbedtls_ssl_context *ssl);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_update_handshake_status(mbedtls_ssl_context *ssl);
|
|
|
|
/**
|
|
* \brief Update record layer
|
|
*
|
|
* This function roughly separates the implementation
|
|
* of the logic of (D)TLS from the implementation
|
|
* of the secure transport.
|
|
*
|
|
* \param ssl The SSL context to use.
|
|
* \param update_hs_digest This indicates if the handshake digest
|
|
* should be automatically updated in case
|
|
* a handshake message is found.
|
|
*
|
|
* \return 0 or non-zero error code.
|
|
*
|
|
* \note A clarification on what is called 'record layer' here
|
|
* is in order, as many sensible definitions are possible:
|
|
*
|
|
* The record layer takes as input an untrusted underlying
|
|
* transport (stream or datagram) and transforms it into
|
|
* a serially multiplexed, secure transport, which
|
|
* conceptually provides the following:
|
|
*
|
|
* (1) Three datagram based, content-agnostic transports
|
|
* for handshake, alert and CCS messages.
|
|
* (2) One stream- or datagram-based transport
|
|
* for application data.
|
|
* (3) Functionality for changing the underlying transform
|
|
* securing the contents.
|
|
*
|
|
* The interface to this functionality is given as follows:
|
|
*
|
|
* a Updating
|
|
* [Currently implemented by mbedtls_ssl_read_record]
|
|
*
|
|
* Check if and on which of the four 'ports' data is pending:
|
|
* Nothing, a controlling datagram of type (1), or application
|
|
* data (2). In any case data is present, internal buffers
|
|
* provide access to the data for the user to process it.
|
|
* Consumption of type (1) datagrams is done automatically
|
|
* on the next update, invalidating that the internal buffers
|
|
* for previous datagrams, while consumption of application
|
|
* data (2) is user-controlled.
|
|
*
|
|
* b Reading of application data
|
|
* [Currently manual adaption of ssl->in_offt pointer]
|
|
*
|
|
* As mentioned in the last paragraph, consumption of data
|
|
* is different from the automatic consumption of control
|
|
* datagrams (1) because application data is treated as a stream.
|
|
*
|
|
* c Tracking availability of application data
|
|
* [Currently manually through decreasing ssl->in_msglen]
|
|
*
|
|
* For efficiency and to retain datagram semantics for
|
|
* application data in case of DTLS, the record layer
|
|
* provides functionality for checking how much application
|
|
* data is still available in the internal buffer.
|
|
*
|
|
* d Changing the transformation securing the communication.
|
|
*
|
|
* Given an opaque implementation of the record layer in the
|
|
* above sense, it should be possible to implement the logic
|
|
* of (D)TLS on top of it without the need to know anything
|
|
* about the record layer's internals. This is done e.g.
|
|
* in all the handshake handling functions, and in the
|
|
* application data reading function mbedtls_ssl_read.
|
|
*
|
|
* \note The above tries to give a conceptual picture of the
|
|
* record layer, but the current implementation deviates
|
|
* from it in some places. For example, our implementation of
|
|
* the update functionality through mbedtls_ssl_read_record
|
|
* discards datagrams depending on the current state, which
|
|
* wouldn't fall under the record layer's responsibility
|
|
* following the above definition.
|
|
*
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_read_record(mbedtls_ssl_context *ssl,
|
|
unsigned update_hs_digest);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_fetch_input(mbedtls_ssl_context *ssl, size_t nb_want);
|
|
|
|
/*
|
|
* Write handshake message header
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_start_handshake_msg(mbedtls_ssl_context *ssl, unsigned char hs_type,
|
|
unsigned char **buf, size_t *buf_len);
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_write_handshake_msg_ext(mbedtls_ssl_context *ssl,
|
|
int update_checksum,
|
|
int force_flush);
|
|
static inline int mbedtls_ssl_write_handshake_msg(mbedtls_ssl_context *ssl)
|
|
{
|
|
return mbedtls_ssl_write_handshake_msg_ext(ssl, 1 /* update checksum */, 1 /* force flush */);
|
|
}
|
|
|
|
/*
|
|
* Write handshake message tail
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_finish_handshake_msg(mbedtls_ssl_context *ssl,
|
|
size_t buf_len, size_t msg_len);
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_write_record(mbedtls_ssl_context *ssl, int force_flush);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_flush_output(mbedtls_ssl_context *ssl);
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_parse_certificate(mbedtls_ssl_context *ssl);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_write_certificate(mbedtls_ssl_context *ssl);
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_parse_change_cipher_spec(mbedtls_ssl_context *ssl);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_write_change_cipher_spec(mbedtls_ssl_context *ssl);
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_parse_finished(mbedtls_ssl_context *ssl);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_write_finished(mbedtls_ssl_context *ssl);
|
|
|
|
void mbedtls_ssl_optimize_checksum(mbedtls_ssl_context *ssl,
|
|
const mbedtls_ssl_ciphersuite_t *ciphersuite_info);
|
|
|
|
/*
|
|
* Update checksum of handshake messages.
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_add_hs_msg_to_checksum(mbedtls_ssl_context *ssl,
|
|
unsigned hs_type,
|
|
unsigned char const *msg,
|
|
size_t msg_len);
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_add_hs_hdr_to_checksum(mbedtls_ssl_context *ssl,
|
|
unsigned hs_type,
|
|
size_t total_hs_len);
|
|
|
|
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
|
|
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_psk_derive_premaster(mbedtls_ssl_context *ssl,
|
|
mbedtls_key_exchange_type_t key_ex);
|
|
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
|
|
#endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
|
|
|
|
#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_PSK_ENABLED)
|
|
#if defined(MBEDTLS_SSL_CLI_C)
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_conf_has_static_psk(mbedtls_ssl_config const *conf);
|
|
#endif
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
/**
|
|
* Get the first defined opaque PSK by order of precedence:
|
|
* 1. handshake PSK set by \c mbedtls_ssl_set_hs_psk_opaque() in the PSK
|
|
* callback
|
|
* 2. static PSK configured by \c mbedtls_ssl_conf_psk_opaque()
|
|
* Return an opaque PSK
|
|
*/
|
|
static inline mbedtls_svc_key_id_t mbedtls_ssl_get_opaque_psk(
|
|
const mbedtls_ssl_context *ssl)
|
|
{
|
|
if (!mbedtls_svc_key_id_is_null(ssl->handshake->psk_opaque)) {
|
|
return ssl->handshake->psk_opaque;
|
|
}
|
|
|
|
if (!mbedtls_svc_key_id_is_null(ssl->conf->psk_opaque)) {
|
|
return ssl->conf->psk_opaque;
|
|
}
|
|
|
|
return MBEDTLS_SVC_KEY_ID_INIT;
|
|
}
|
|
#else
|
|
/**
|
|
* Get the first defined PSK by order of precedence:
|
|
* 1. handshake PSK set by \c mbedtls_ssl_set_hs_psk() in the PSK callback
|
|
* 2. static PSK configured by \c mbedtls_ssl_conf_psk()
|
|
* Return a code and update the pair (PSK, PSK length) passed to this function
|
|
*/
|
|
static inline int mbedtls_ssl_get_psk(const mbedtls_ssl_context *ssl,
|
|
const unsigned char **psk, size_t *psk_len)
|
|
{
|
|
if (ssl->handshake->psk != NULL && ssl->handshake->psk_len > 0) {
|
|
*psk = ssl->handshake->psk;
|
|
*psk_len = ssl->handshake->psk_len;
|
|
} else if (ssl->conf->psk != NULL && ssl->conf->psk_len > 0) {
|
|
*psk = ssl->conf->psk;
|
|
*psk_len = ssl->conf->psk_len;
|
|
} else {
|
|
*psk = NULL;
|
|
*psk_len = 0;
|
|
return MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif /* MBEDTLS_USE_PSA_CRYPTO */
|
|
|
|
#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_PSK_ENABLED */
|
|
|
|
#if defined(MBEDTLS_PK_C)
|
|
unsigned char mbedtls_ssl_sig_from_pk(mbedtls_pk_context *pk);
|
|
unsigned char mbedtls_ssl_sig_from_pk_alg(mbedtls_pk_type_t type);
|
|
mbedtls_pk_type_t mbedtls_ssl_pk_alg_from_sig(unsigned char sig);
|
|
#endif
|
|
|
|
mbedtls_md_type_t mbedtls_ssl_md_alg_from_hash(unsigned char hash);
|
|
unsigned char mbedtls_ssl_hash_from_md_alg(int md);
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_set_calc_verify_md(mbedtls_ssl_context *ssl, int md);
|
|
#endif
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_check_curve_tls_id(const mbedtls_ssl_context *ssl, uint16_t tls_id);
|
|
#if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_check_curve(const mbedtls_ssl_context *ssl, mbedtls_ecp_group_id grp_id);
|
|
#endif /* MBEDTLS_PK_HAVE_ECC_KEYS */
|
|
|
|
/**
|
|
* \brief Return PSA EC info for the specified TLS ID.
|
|
*
|
|
* \param tls_id The TLS ID to look for
|
|
* \param type If the TLD ID is supported, then proper \c psa_key_type_t
|
|
* value is returned here. Can be NULL.
|
|
* \param bits If the TLD ID is supported, then proper bit size is returned
|
|
* here. Can be NULL.
|
|
* \return PSA_SUCCESS if the TLS ID is supported,
|
|
* PSA_ERROR_NOT_SUPPORTED otherwise
|
|
*
|
|
* \note If either \c family or \c bits parameters are NULL, then
|
|
* the corresponding value is not returned.
|
|
* The function can be called with both parameters as NULL
|
|
* simply to check if a specific TLS ID is supported.
|
|
*/
|
|
int mbedtls_ssl_get_psa_curve_info_from_tls_id(uint16_t tls_id,
|
|
psa_key_type_t *type,
|
|
size_t *bits);
|
|
|
|
/**
|
|
* \brief Return \c mbedtls_ecp_group_id for the specified TLS ID.
|
|
*
|
|
* \param tls_id The TLS ID to look for
|
|
* \return Proper \c mbedtls_ecp_group_id if the TLS ID is supported,
|
|
* or MBEDTLS_ECP_DP_NONE otherwise
|
|
*/
|
|
mbedtls_ecp_group_id mbedtls_ssl_get_ecp_group_id_from_tls_id(uint16_t tls_id);
|
|
|
|
/**
|
|
* \brief Return TLS ID for the specified \c mbedtls_ecp_group_id.
|
|
*
|
|
* \param grp_id The \c mbedtls_ecp_group_id ID to look for
|
|
* \return Proper TLS ID if the \c mbedtls_ecp_group_id is supported,
|
|
* or 0 otherwise
|
|
*/
|
|
uint16_t mbedtls_ssl_get_tls_id_from_ecp_group_id(mbedtls_ecp_group_id grp_id);
|
|
|
|
#if defined(MBEDTLS_DEBUG_C)
|
|
/**
|
|
* \brief Return EC's name for the specified TLS ID.
|
|
*
|
|
* \param tls_id The TLS ID to look for
|
|
* \return A pointer to a const string with the proper name. If TLS
|
|
* ID is not supported, a NULL pointer is returned instead.
|
|
*/
|
|
const char *mbedtls_ssl_get_curve_name_from_tls_id(uint16_t tls_id);
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_DTLS_SRTP)
|
|
static inline mbedtls_ssl_srtp_profile mbedtls_ssl_check_srtp_profile_value
|
|
(const uint16_t srtp_profile_value)
|
|
{
|
|
switch (srtp_profile_value) {
|
|
case MBEDTLS_TLS_SRTP_AES128_CM_HMAC_SHA1_80:
|
|
case MBEDTLS_TLS_SRTP_AES128_CM_HMAC_SHA1_32:
|
|
case MBEDTLS_TLS_SRTP_NULL_HMAC_SHA1_80:
|
|
case MBEDTLS_TLS_SRTP_NULL_HMAC_SHA1_32:
|
|
return srtp_profile_value;
|
|
default: break;
|
|
}
|
|
return MBEDTLS_TLS_SRTP_UNSET;
|
|
}
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_X509_CRT_PARSE_C)
|
|
static inline mbedtls_pk_context *mbedtls_ssl_own_key(mbedtls_ssl_context *ssl)
|
|
{
|
|
mbedtls_ssl_key_cert *key_cert;
|
|
|
|
if (ssl->handshake != NULL && ssl->handshake->key_cert != NULL) {
|
|
key_cert = ssl->handshake->key_cert;
|
|
} else {
|
|
key_cert = ssl->conf->key_cert;
|
|
}
|
|
|
|
return key_cert == NULL ? NULL : key_cert->key;
|
|
}
|
|
|
|
static inline mbedtls_x509_crt *mbedtls_ssl_own_cert(mbedtls_ssl_context *ssl)
|
|
{
|
|
mbedtls_ssl_key_cert *key_cert;
|
|
|
|
if (ssl->handshake != NULL && ssl->handshake->key_cert != NULL) {
|
|
key_cert = ssl->handshake->key_cert;
|
|
} else {
|
|
key_cert = ssl->conf->key_cert;
|
|
}
|
|
|
|
return key_cert == NULL ? NULL : key_cert->cert;
|
|
}
|
|
|
|
/*
|
|
* Check usage of a certificate wrt extensions:
|
|
* keyUsage, extendedKeyUsage (later), and nSCertType (later).
|
|
*
|
|
* Warning: cert_endpoint is the endpoint of the cert (ie, of our peer when we
|
|
* check a cert we received from them)!
|
|
*
|
|
* Return 0 if everything is OK, -1 if not.
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_check_cert_usage(const mbedtls_x509_crt *cert,
|
|
const mbedtls_ssl_ciphersuite_t *ciphersuite,
|
|
int cert_endpoint,
|
|
uint32_t *flags);
|
|
#endif /* MBEDTLS_X509_CRT_PARSE_C */
|
|
|
|
void mbedtls_ssl_write_version(unsigned char version[2], int transport,
|
|
mbedtls_ssl_protocol_version tls_version);
|
|
uint16_t mbedtls_ssl_read_version(const unsigned char version[2],
|
|
int transport);
|
|
|
|
static inline size_t mbedtls_ssl_in_hdr_len(const mbedtls_ssl_context *ssl)
|
|
{
|
|
#if !defined(MBEDTLS_SSL_PROTO_DTLS)
|
|
((void) ssl);
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_DTLS)
|
|
if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
|
|
return 13;
|
|
} else
|
|
#endif /* MBEDTLS_SSL_PROTO_DTLS */
|
|
{
|
|
return 5;
|
|
}
|
|
}
|
|
|
|
static inline size_t mbedtls_ssl_out_hdr_len(const mbedtls_ssl_context *ssl)
|
|
{
|
|
return (size_t) (ssl->out_iv - ssl->out_hdr);
|
|
}
|
|
|
|
static inline size_t mbedtls_ssl_hs_hdr_len(const mbedtls_ssl_context *ssl)
|
|
{
|
|
#if defined(MBEDTLS_SSL_PROTO_DTLS)
|
|
if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
|
|
return 12;
|
|
}
|
|
#else
|
|
((void) ssl);
|
|
#endif
|
|
return 4;
|
|
}
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_DTLS)
|
|
void mbedtls_ssl_send_flight_completed(mbedtls_ssl_context *ssl);
|
|
void mbedtls_ssl_recv_flight_completed(mbedtls_ssl_context *ssl);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_resend(mbedtls_ssl_context *ssl);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_flight_transmit(mbedtls_ssl_context *ssl);
|
|
#endif
|
|
|
|
/* Visible for testing purposes only */
|
|
#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_dtls_replay_check(mbedtls_ssl_context const *ssl);
|
|
void mbedtls_ssl_dtls_replay_update(mbedtls_ssl_context *ssl);
|
|
#endif
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_session_copy(mbedtls_ssl_session *dst,
|
|
const mbedtls_ssl_session *src);
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
|
|
/* The hash buffer must have at least MBEDTLS_MD_MAX_SIZE bytes of length. */
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
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);
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
void mbedtls_ssl_transform_init(mbedtls_ssl_transform *transform);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_encrypt_buf(mbedtls_ssl_context *ssl,
|
|
mbedtls_ssl_transform *transform,
|
|
mbedtls_record *rec,
|
|
int (*f_rng)(void *, unsigned char *, size_t),
|
|
void *p_rng);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_decrypt_buf(mbedtls_ssl_context const *ssl,
|
|
mbedtls_ssl_transform *transform,
|
|
mbedtls_record *rec);
|
|
|
|
/* Length of the "epoch" field in the record header */
|
|
static inline size_t mbedtls_ssl_ep_len(const mbedtls_ssl_context *ssl)
|
|
{
|
|
#if defined(MBEDTLS_SSL_PROTO_DTLS)
|
|
if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
|
|
return 2;
|
|
}
|
|
#else
|
|
((void) ssl);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_DTLS)
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_resend_hello_request(mbedtls_ssl_context *ssl);
|
|
#endif /* MBEDTLS_SSL_PROTO_DTLS */
|
|
|
|
void mbedtls_ssl_set_timer(mbedtls_ssl_context *ssl, uint32_t millisecs);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_check_timer(mbedtls_ssl_context *ssl);
|
|
|
|
void mbedtls_ssl_reset_in_out_pointers(mbedtls_ssl_context *ssl);
|
|
void mbedtls_ssl_update_out_pointers(mbedtls_ssl_context *ssl,
|
|
mbedtls_ssl_transform *transform);
|
|
void mbedtls_ssl_update_in_pointers(mbedtls_ssl_context *ssl);
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_session_reset_int(mbedtls_ssl_context *ssl, int partial);
|
|
void mbedtls_ssl_session_reset_msg_layer(mbedtls_ssl_context *ssl,
|
|
int partial);
|
|
|
|
/*
|
|
* Send pending alert
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_handle_pending_alert(mbedtls_ssl_context *ssl);
|
|
|
|
/*
|
|
* Set pending fatal alert flag.
|
|
*/
|
|
void mbedtls_ssl_pend_fatal_alert(mbedtls_ssl_context *ssl,
|
|
unsigned char alert_type,
|
|
int alert_reason);
|
|
|
|
/* Alias of mbedtls_ssl_pend_fatal_alert */
|
|
#define MBEDTLS_SSL_PEND_FATAL_ALERT(type, user_return_value) \
|
|
mbedtls_ssl_pend_fatal_alert(ssl, type, user_return_value)
|
|
|
|
#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
|
|
void mbedtls_ssl_dtls_replay_reset(mbedtls_ssl_context *ssl);
|
|
#endif
|
|
|
|
void mbedtls_ssl_handshake_wrapup_free_hs_transform(mbedtls_ssl_context *ssl);
|
|
|
|
#if defined(MBEDTLS_SSL_RENEGOTIATION)
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_start_renegotiation(mbedtls_ssl_context *ssl);
|
|
#endif /* MBEDTLS_SSL_RENEGOTIATION */
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_DTLS)
|
|
size_t mbedtls_ssl_get_current_mtu(const mbedtls_ssl_context *ssl);
|
|
void mbedtls_ssl_buffering_free(mbedtls_ssl_context *ssl);
|
|
void mbedtls_ssl_flight_free(mbedtls_ssl_flight_item *flight);
|
|
#endif /* MBEDTLS_SSL_PROTO_DTLS */
|
|
|
|
/**
|
|
* ssl utils functions for checking configuration.
|
|
*/
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
|
|
static inline int mbedtls_ssl_conf_is_tls13_only(const mbedtls_ssl_config *conf)
|
|
{
|
|
return conf->min_tls_version == MBEDTLS_SSL_VERSION_TLS1_3 &&
|
|
conf->max_tls_version == MBEDTLS_SSL_VERSION_TLS1_3;
|
|
}
|
|
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
|
|
static inline int mbedtls_ssl_conf_is_tls12_only(const mbedtls_ssl_config *conf)
|
|
{
|
|
return conf->min_tls_version == MBEDTLS_SSL_VERSION_TLS1_2 &&
|
|
conf->max_tls_version == MBEDTLS_SSL_VERSION_TLS1_2;
|
|
}
|
|
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
|
|
|
|
static inline int mbedtls_ssl_conf_is_tls13_enabled(const mbedtls_ssl_config *conf)
|
|
{
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
|
|
return conf->min_tls_version <= MBEDTLS_SSL_VERSION_TLS1_3 &&
|
|
conf->max_tls_version >= MBEDTLS_SSL_VERSION_TLS1_3;
|
|
#else
|
|
((void) conf);
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
static inline int mbedtls_ssl_conf_is_tls12_enabled(const mbedtls_ssl_config *conf)
|
|
{
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
|
|
return conf->min_tls_version <= MBEDTLS_SSL_VERSION_TLS1_2 &&
|
|
conf->max_tls_version >= MBEDTLS_SSL_VERSION_TLS1_2;
|
|
#else
|
|
((void) conf);
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && defined(MBEDTLS_SSL_PROTO_TLS1_3)
|
|
static inline int mbedtls_ssl_conf_is_hybrid_tls12_tls13(const mbedtls_ssl_config *conf)
|
|
{
|
|
return conf->min_tls_version == MBEDTLS_SSL_VERSION_TLS1_2 &&
|
|
conf->max_tls_version == MBEDTLS_SSL_VERSION_TLS1_3;
|
|
}
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 && MBEDTLS_SSL_PROTO_TLS1_3 */
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
|
|
extern const uint8_t mbedtls_ssl_tls13_hello_retry_request_magic[
|
|
MBEDTLS_SERVER_HELLO_RANDOM_LEN];
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_process_finished_message(mbedtls_ssl_context *ssl);
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_write_finished_message(mbedtls_ssl_context *ssl);
|
|
void mbedtls_ssl_tls13_handshake_wrapup(mbedtls_ssl_context *ssl);
|
|
|
|
/**
|
|
* \brief Given an SSL context and its associated configuration, write the TLS
|
|
* 1.3 specific extensions of the ClientHello message.
|
|
*
|
|
* \param[in] ssl SSL context
|
|
* \param[in] buf Base address of the buffer where to write the extensions
|
|
* \param[in] end End address of the buffer where to write the extensions
|
|
* \param[out] out_len Length of the data written into the buffer \p buf
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_write_client_hello_exts(mbedtls_ssl_context *ssl,
|
|
unsigned char *buf,
|
|
unsigned char *end,
|
|
size_t *out_len);
|
|
|
|
/**
|
|
* \brief TLS 1.3 client side state machine entry
|
|
*
|
|
* \param ssl SSL context
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_handshake_client_step(mbedtls_ssl_context *ssl);
|
|
|
|
/**
|
|
* \brief TLS 1.3 server side state machine entry
|
|
*
|
|
* \param ssl SSL context
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_handshake_server_step(mbedtls_ssl_context *ssl);
|
|
|
|
|
|
/*
|
|
* Helper functions around key exchange modes.
|
|
*/
|
|
static inline unsigned mbedtls_ssl_conf_tls13_check_kex_modes(mbedtls_ssl_context *ssl,
|
|
int kex_mode_mask)
|
|
{
|
|
return (ssl->conf->tls13_kex_modes & kex_mode_mask) != 0;
|
|
}
|
|
|
|
static inline int mbedtls_ssl_conf_tls13_psk_enabled(mbedtls_ssl_context *ssl)
|
|
{
|
|
return mbedtls_ssl_conf_tls13_check_kex_modes(ssl,
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK);
|
|
}
|
|
|
|
static inline int mbedtls_ssl_conf_tls13_psk_ephemeral_enabled(mbedtls_ssl_context *ssl)
|
|
{
|
|
return mbedtls_ssl_conf_tls13_check_kex_modes(ssl,
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_EPHEMERAL);
|
|
}
|
|
|
|
static inline int mbedtls_ssl_conf_tls13_ephemeral_enabled(mbedtls_ssl_context *ssl)
|
|
{
|
|
return mbedtls_ssl_conf_tls13_check_kex_modes(ssl,
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL);
|
|
}
|
|
|
|
static inline int mbedtls_ssl_conf_tls13_some_ephemeral_enabled(mbedtls_ssl_context *ssl)
|
|
{
|
|
return mbedtls_ssl_conf_tls13_check_kex_modes(ssl,
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ALL);
|
|
}
|
|
|
|
static inline int mbedtls_ssl_conf_tls13_some_psk_enabled(mbedtls_ssl_context *ssl)
|
|
{
|
|
return mbedtls_ssl_conf_tls13_check_kex_modes(ssl,
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_ALL);
|
|
}
|
|
|
|
#if defined(MBEDTLS_SSL_SRV_C) && \
|
|
defined(MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_SOME_PSK_ENABLED)
|
|
/**
|
|
* Given a list of key exchange modes, check if at least one of them is
|
|
* supported.
|
|
*
|
|
* \param[in] ssl SSL context
|
|
* \param kex_modes_mask Mask of the key exchange modes to check
|
|
*
|
|
* \return 0 if at least one of the key exchange modes is supported,
|
|
* !=0 otherwise.
|
|
*/
|
|
static inline unsigned mbedtls_ssl_tls13_check_kex_modes(mbedtls_ssl_context *ssl,
|
|
int kex_modes_mask)
|
|
{
|
|
return (ssl->handshake->tls13_kex_modes & kex_modes_mask) == 0;
|
|
}
|
|
|
|
static inline int mbedtls_ssl_tls13_psk_enabled(mbedtls_ssl_context *ssl)
|
|
{
|
|
return !mbedtls_ssl_tls13_check_kex_modes(ssl,
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK);
|
|
}
|
|
|
|
static inline int mbedtls_ssl_tls13_psk_ephemeral_enabled(
|
|
mbedtls_ssl_context *ssl)
|
|
{
|
|
return !mbedtls_ssl_tls13_check_kex_modes(ssl,
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_EPHEMERAL);
|
|
}
|
|
|
|
static inline int mbedtls_ssl_tls13_ephemeral_enabled(mbedtls_ssl_context *ssl)
|
|
{
|
|
return !mbedtls_ssl_tls13_check_kex_modes(ssl,
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL);
|
|
}
|
|
|
|
static inline int mbedtls_ssl_tls13_some_ephemeral_enabled(mbedtls_ssl_context *ssl)
|
|
{
|
|
return !mbedtls_ssl_tls13_check_kex_modes(ssl,
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ALL);
|
|
}
|
|
|
|
static inline int mbedtls_ssl_tls13_some_psk_enabled(mbedtls_ssl_context *ssl)
|
|
{
|
|
return !mbedtls_ssl_tls13_check_kex_modes(ssl,
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_ALL);
|
|
}
|
|
#endif /* MBEDTLS_SSL_SRV_C &&
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_SOME_PSK_ENABLED */
|
|
|
|
/*
|
|
* Helper functions for extensions checking.
|
|
*/
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_check_received_extension(
|
|
mbedtls_ssl_context *ssl,
|
|
int hs_msg_type,
|
|
unsigned int received_extension_type,
|
|
uint32_t hs_msg_allowed_extensions_mask);
|
|
|
|
static inline void mbedtls_ssl_tls13_set_hs_sent_ext_mask(
|
|
mbedtls_ssl_context *ssl, unsigned int extension_type)
|
|
{
|
|
ssl->handshake->sent_extensions |=
|
|
mbedtls_ssl_get_extension_mask(extension_type);
|
|
}
|
|
|
|
/*
|
|
* Helper functions to check the selected key exchange mode.
|
|
*/
|
|
static inline int mbedtls_ssl_tls13_key_exchange_mode_check(
|
|
mbedtls_ssl_context *ssl, int kex_mask)
|
|
{
|
|
return (ssl->handshake->key_exchange_mode & kex_mask) != 0;
|
|
}
|
|
|
|
static inline int mbedtls_ssl_tls13_key_exchange_mode_with_psk(
|
|
mbedtls_ssl_context *ssl)
|
|
{
|
|
return mbedtls_ssl_tls13_key_exchange_mode_check(ssl,
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_ALL);
|
|
}
|
|
|
|
static inline int mbedtls_ssl_tls13_key_exchange_mode_with_ephemeral(
|
|
mbedtls_ssl_context *ssl)
|
|
{
|
|
return mbedtls_ssl_tls13_key_exchange_mode_check(ssl,
|
|
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ALL);
|
|
}
|
|
|
|
/*
|
|
* Fetch TLS 1.3 handshake message header
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_fetch_handshake_msg(mbedtls_ssl_context *ssl,
|
|
unsigned hs_type,
|
|
unsigned char **buf,
|
|
size_t *buf_len);
|
|
|
|
/**
|
|
* \brief Detect if a list of extensions contains a supported_versions
|
|
* extension or not.
|
|
*
|
|
* \param[in] ssl SSL context
|
|
* \param[in] buf Address of the first byte of the extensions vector.
|
|
* \param[in] end End of the buffer containing the list of extensions.
|
|
* \param[out] supported_versions_data If the extension is present, address of
|
|
* its first byte of data, NULL otherwise.
|
|
* \param[out] supported_versions_data_end If the extension is present, address
|
|
* of the first byte immediately
|
|
* following the extension data, NULL
|
|
* otherwise.
|
|
* \return 0 if the list of extensions does not contain a supported_versions
|
|
* extension.
|
|
* \return 1 if the list of extensions contains a supported_versions
|
|
* extension.
|
|
* \return A negative value if an error occurred while parsing the
|
|
* extensions.
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_is_supported_versions_ext_present_in_exts(
|
|
mbedtls_ssl_context *ssl,
|
|
const unsigned char *buf, const unsigned char *end,
|
|
const unsigned char **supported_versions_data,
|
|
const unsigned char **supported_versions_data_end);
|
|
|
|
/*
|
|
* Handler of TLS 1.3 server certificate message
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_process_certificate(mbedtls_ssl_context *ssl);
|
|
|
|
#if defined(MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ENABLED)
|
|
/*
|
|
* Handler of TLS 1.3 write Certificate message
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_write_certificate(mbedtls_ssl_context *ssl);
|
|
|
|
/*
|
|
* Handler of TLS 1.3 write Certificate Verify message
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_write_certificate_verify(mbedtls_ssl_context *ssl);
|
|
|
|
#endif /* MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ENABLED */
|
|
|
|
/*
|
|
* Generic handler of Certificate Verify
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_process_certificate_verify(mbedtls_ssl_context *ssl);
|
|
|
|
/*
|
|
* Write of dummy-CCS's for middlebox compatibility
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_write_change_cipher_spec(mbedtls_ssl_context *ssl);
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_reset_transcript_for_hrr(mbedtls_ssl_context *ssl);
|
|
|
|
#if defined(PSA_WANT_ALG_ECDH) || defined(PSA_WANT_ALG_FFDH)
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_generate_and_write_xxdh_key_exchange(
|
|
mbedtls_ssl_context *ssl,
|
|
uint16_t named_group,
|
|
unsigned char *buf,
|
|
unsigned char *end,
|
|
size_t *out_len);
|
|
#endif /* PSA_WANT_ALG_ECDH || PSA_WANT_ALG_FFDH */
|
|
|
|
#if defined(MBEDTLS_SSL_EARLY_DATA)
|
|
int mbedtls_ssl_tls13_write_early_data_ext(mbedtls_ssl_context *ssl,
|
|
int in_new_session_ticket,
|
|
unsigned char *buf,
|
|
const unsigned char *end,
|
|
size_t *out_len);
|
|
|
|
#if defined(MBEDTLS_SSL_SRV_C)
|
|
#define MBEDTLS_SSL_EARLY_DATA_STATUS_NOT_RECEIVED \
|
|
MBEDTLS_SSL_EARLY_DATA_STATUS_NOT_SENT
|
|
#endif /* MBEDTLS_SSL_SRV_C */
|
|
|
|
#endif /* MBEDTLS_SSL_EARLY_DATA */
|
|
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
|
|
|
|
#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
|
|
/*
|
|
* Write Signature Algorithm extension
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_write_sig_alg_ext(mbedtls_ssl_context *ssl, unsigned char *buf,
|
|
const unsigned char *end, size_t *out_len);
|
|
/*
|
|
* Parse TLS Signature Algorithm extension
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_parse_sig_alg_ext(mbedtls_ssl_context *ssl,
|
|
const unsigned char *buf,
|
|
const unsigned char *end);
|
|
#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED */
|
|
|
|
/* Get handshake transcript */
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_get_handshake_transcript(mbedtls_ssl_context *ssl,
|
|
const mbedtls_md_type_t md,
|
|
unsigned char *dst,
|
|
size_t dst_len,
|
|
size_t *olen);
|
|
|
|
/*
|
|
* Return supported groups.
|
|
*
|
|
* In future, invocations can be changed to ssl->conf->group_list
|
|
* when mbedtls_ssl_conf_curves() is deleted.
|
|
*
|
|
* ssl->handshake->group_list is either a translation of curve_list to IANA TLS group
|
|
* identifiers when mbedtls_ssl_conf_curves() has been used, or a pointer to
|
|
* ssl->conf->group_list when mbedtls_ssl_conf_groups() has been more recently invoked.
|
|
*
|
|
*/
|
|
static inline const void *mbedtls_ssl_get_groups(const mbedtls_ssl_context *ssl)
|
|
{
|
|
#if defined(MBEDTLS_DEPRECATED_REMOVED) || !defined(MBEDTLS_ECP_C)
|
|
return ssl->conf->group_list;
|
|
#else
|
|
if ((ssl->handshake != NULL) && (ssl->handshake->group_list != NULL)) {
|
|
return ssl->handshake->group_list;
|
|
} else {
|
|
return ssl->conf->group_list;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Helper functions for NamedGroup.
|
|
*/
|
|
static inline int mbedtls_ssl_tls12_named_group_is_ecdhe(uint16_t named_group)
|
|
{
|
|
/*
|
|
* RFC 8422 section 5.1.1
|
|
*/
|
|
return named_group == MBEDTLS_SSL_IANA_TLS_GROUP_X25519 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_BP256R1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_BP384R1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_BP512R1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_X448 ||
|
|
/* Below deprecated curves should be removed with notice to users */
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_SECP192K1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_SECP192R1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_SECP224K1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_SECP224R1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_SECP256K1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_SECP256R1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_SECP384R1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_SECP521R1;
|
|
}
|
|
|
|
static inline int mbedtls_ssl_tls13_named_group_is_ecdhe(uint16_t named_group)
|
|
{
|
|
return named_group == MBEDTLS_SSL_IANA_TLS_GROUP_X25519 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_SECP256R1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_SECP384R1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_SECP521R1 ||
|
|
named_group == MBEDTLS_SSL_IANA_TLS_GROUP_X448;
|
|
}
|
|
|
|
static inline int mbedtls_ssl_tls13_named_group_is_ffdh(uint16_t named_group)
|
|
{
|
|
return named_group >= MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE2048 &&
|
|
named_group <= MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE8192;
|
|
}
|
|
|
|
static inline int mbedtls_ssl_named_group_is_offered(
|
|
const mbedtls_ssl_context *ssl, uint16_t named_group)
|
|
{
|
|
const uint16_t *group_list = mbedtls_ssl_get_groups(ssl);
|
|
|
|
if (group_list == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
for (; *group_list != 0; group_list++) {
|
|
if (*group_list == named_group) {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline int mbedtls_ssl_named_group_is_supported(uint16_t named_group)
|
|
{
|
|
#if defined(PSA_WANT_ALG_ECDH)
|
|
if (mbedtls_ssl_tls13_named_group_is_ecdhe(named_group)) {
|
|
if (mbedtls_ssl_get_ecp_group_id_from_tls_id(named_group) !=
|
|
MBEDTLS_ECP_DP_NONE) {
|
|
return 1;
|
|
}
|
|
}
|
|
#endif
|
|
#if defined(PSA_WANT_ALG_FFDH)
|
|
if (mbedtls_ssl_tls13_named_group_is_ffdh(named_group)) {
|
|
return 1;
|
|
}
|
|
#endif
|
|
#if !defined(PSA_WANT_ALG_ECDH) && !defined(PSA_WANT_ALG_FFDH)
|
|
(void) named_group;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Return supported signature algorithms.
|
|
*
|
|
* In future, invocations can be changed to ssl->conf->sig_algs when
|
|
* mbedtls_ssl_conf_sig_hashes() is deleted.
|
|
*
|
|
* ssl->handshake->sig_algs is either a translation of sig_hashes to IANA TLS
|
|
* signature algorithm identifiers when mbedtls_ssl_conf_sig_hashes() has been
|
|
* used, or a pointer to ssl->conf->sig_algs when mbedtls_ssl_conf_sig_algs() has
|
|
* been more recently invoked.
|
|
*
|
|
*/
|
|
static inline const void *mbedtls_ssl_get_sig_algs(
|
|
const mbedtls_ssl_context *ssl)
|
|
{
|
|
#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
|
|
|
|
#if !defined(MBEDTLS_DEPRECATED_REMOVED)
|
|
if (ssl->handshake != NULL &&
|
|
ssl->handshake->sig_algs_heap_allocated == 1 &&
|
|
ssl->handshake->sig_algs != NULL) {
|
|
return ssl->handshake->sig_algs;
|
|
}
|
|
#endif
|
|
return ssl->conf->sig_algs;
|
|
|
|
#else /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED */
|
|
|
|
((void) ssl);
|
|
return NULL;
|
|
#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED */
|
|
}
|
|
|
|
#if defined(MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ENABLED)
|
|
static inline int mbedtls_ssl_sig_alg_is_received(const mbedtls_ssl_context *ssl,
|
|
uint16_t own_sig_alg)
|
|
{
|
|
const uint16_t *sig_alg = ssl->handshake->received_sig_algs;
|
|
if (sig_alg == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
for (; *sig_alg != MBEDTLS_TLS_SIG_NONE; sig_alg++) {
|
|
if (*sig_alg == own_sig_alg) {
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static inline int mbedtls_ssl_tls13_sig_alg_for_cert_verify_is_supported(
|
|
const uint16_t sig_alg)
|
|
{
|
|
switch (sig_alg) {
|
|
#if defined(MBEDTLS_PK_CAN_ECDSA_SOME)
|
|
#if defined(PSA_WANT_ALG_SHA_256) && defined(PSA_WANT_ECC_SECP_R1_256)
|
|
case MBEDTLS_TLS1_3_SIG_ECDSA_SECP256R1_SHA256:
|
|
break;
|
|
#endif /* PSA_WANT_ALG_SHA_256 && MBEDTLS_ECP_DP_SECP256R1_ENABLED */
|
|
#if defined(PSA_WANT_ALG_SHA_384) && defined(PSA_WANT_ECC_SECP_R1_384)
|
|
case MBEDTLS_TLS1_3_SIG_ECDSA_SECP384R1_SHA384:
|
|
break;
|
|
#endif /* PSA_WANT_ALG_SHA_384 && MBEDTLS_ECP_DP_SECP384R1_ENABLED */
|
|
#if defined(PSA_WANT_ALG_SHA_512) && defined(PSA_WANT_ECC_SECP_R1_521)
|
|
case MBEDTLS_TLS1_3_SIG_ECDSA_SECP521R1_SHA512:
|
|
break;
|
|
#endif /* PSA_WANT_ALG_SHA_512 && MBEDTLS_ECP_DP_SECP521R1_ENABLED */
|
|
#endif /* MBEDTLS_PK_CAN_ECDSA_SOME */
|
|
|
|
#if defined(MBEDTLS_PKCS1_V21)
|
|
#if defined(PSA_WANT_ALG_SHA_256)
|
|
case MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA256:
|
|
break;
|
|
#endif /* PSA_WANT_ALG_SHA_256 */
|
|
#if defined(PSA_WANT_ALG_SHA_384)
|
|
case MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA384:
|
|
break;
|
|
#endif /* PSA_WANT_ALG_SHA_384 */
|
|
#if defined(PSA_WANT_ALG_SHA_512)
|
|
case MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA512:
|
|
break;
|
|
#endif /* PSA_WANT_ALG_SHA_512 */
|
|
#endif /* MBEDTLS_PKCS1_V21 */
|
|
default:
|
|
return 0;
|
|
}
|
|
return 1;
|
|
|
|
}
|
|
|
|
static inline int mbedtls_ssl_tls13_sig_alg_is_supported(
|
|
const uint16_t sig_alg)
|
|
{
|
|
switch (sig_alg) {
|
|
#if defined(MBEDTLS_PKCS1_V15)
|
|
#if defined(MBEDTLS_MD_CAN_SHA256)
|
|
case MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA256:
|
|
break;
|
|
#endif /* MBEDTLS_MD_CAN_SHA256 */
|
|
#if defined(MBEDTLS_MD_CAN_SHA384)
|
|
case MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA384:
|
|
break;
|
|
#endif /* MBEDTLS_MD_CAN_SHA384 */
|
|
#if defined(MBEDTLS_MD_CAN_SHA512)
|
|
case MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA512:
|
|
break;
|
|
#endif /* MBEDTLS_MD_CAN_SHA512 */
|
|
#endif /* MBEDTLS_PKCS1_V15 */
|
|
default:
|
|
return mbedtls_ssl_tls13_sig_alg_for_cert_verify_is_supported(
|
|
sig_alg);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_check_sig_alg_cert_key_match(uint16_t sig_alg,
|
|
mbedtls_pk_context *key);
|
|
#endif /* MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ENABLED */
|
|
|
|
#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED)
|
|
static inline int mbedtls_ssl_sig_alg_is_offered(const mbedtls_ssl_context *ssl,
|
|
uint16_t proposed_sig_alg)
|
|
{
|
|
const uint16_t *sig_alg = mbedtls_ssl_get_sig_algs(ssl);
|
|
if (sig_alg == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
for (; *sig_alg != MBEDTLS_TLS_SIG_NONE; sig_alg++) {
|
|
if (*sig_alg == proposed_sig_alg) {
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static inline int mbedtls_ssl_get_pk_type_and_md_alg_from_sig_alg(
|
|
uint16_t sig_alg, mbedtls_pk_type_t *pk_type, mbedtls_md_type_t *md_alg)
|
|
{
|
|
*pk_type = mbedtls_ssl_pk_alg_from_sig(sig_alg & 0xff);
|
|
*md_alg = mbedtls_ssl_md_alg_from_hash((sig_alg >> 8) & 0xff);
|
|
|
|
if (*pk_type != MBEDTLS_PK_NONE && *md_alg != MBEDTLS_MD_NONE) {
|
|
return 0;
|
|
}
|
|
|
|
switch (sig_alg) {
|
|
#if defined(MBEDTLS_PKCS1_V21)
|
|
#if defined(MBEDTLS_MD_CAN_SHA256)
|
|
case MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA256:
|
|
*md_alg = MBEDTLS_MD_SHA256;
|
|
*pk_type = MBEDTLS_PK_RSASSA_PSS;
|
|
break;
|
|
#endif /* MBEDTLS_MD_CAN_SHA256 */
|
|
#if defined(MBEDTLS_MD_CAN_SHA384)
|
|
case MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA384:
|
|
*md_alg = MBEDTLS_MD_SHA384;
|
|
*pk_type = MBEDTLS_PK_RSASSA_PSS;
|
|
break;
|
|
#endif /* MBEDTLS_MD_CAN_SHA384 */
|
|
#if defined(MBEDTLS_MD_CAN_SHA512)
|
|
case MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA512:
|
|
*md_alg = MBEDTLS_MD_SHA512;
|
|
*pk_type = MBEDTLS_PK_RSASSA_PSS;
|
|
break;
|
|
#endif /* MBEDTLS_MD_CAN_SHA512 */
|
|
#endif /* MBEDTLS_PKCS1_V21 */
|
|
default:
|
|
return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
|
|
static inline int mbedtls_ssl_tls12_sig_alg_is_supported(
|
|
const uint16_t sig_alg)
|
|
{
|
|
/* High byte is hash */
|
|
unsigned char hash = MBEDTLS_BYTE_1(sig_alg);
|
|
unsigned char sig = MBEDTLS_BYTE_0(sig_alg);
|
|
|
|
switch (hash) {
|
|
#if defined(MBEDTLS_MD_CAN_MD5)
|
|
case MBEDTLS_SSL_HASH_MD5:
|
|
break;
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_MD_CAN_SHA1)
|
|
case MBEDTLS_SSL_HASH_SHA1:
|
|
break;
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_MD_CAN_SHA224)
|
|
case MBEDTLS_SSL_HASH_SHA224:
|
|
break;
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_MD_CAN_SHA256)
|
|
case MBEDTLS_SSL_HASH_SHA256:
|
|
break;
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_MD_CAN_SHA384)
|
|
case MBEDTLS_SSL_HASH_SHA384:
|
|
break;
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_MD_CAN_SHA512)
|
|
case MBEDTLS_SSL_HASH_SHA512:
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
switch (sig) {
|
|
#if defined(MBEDTLS_RSA_C)
|
|
case MBEDTLS_SSL_SIG_RSA:
|
|
break;
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_KEY_EXCHANGE_ECDSA_CERT_REQ_ALLOWED_ENABLED)
|
|
case MBEDTLS_SSL_SIG_ECDSA:
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
|
|
|
|
static inline int mbedtls_ssl_sig_alg_is_supported(
|
|
const mbedtls_ssl_context *ssl,
|
|
const uint16_t sig_alg)
|
|
{
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
|
|
if (ssl->tls_version == MBEDTLS_SSL_VERSION_TLS1_2) {
|
|
return mbedtls_ssl_tls12_sig_alg_is_supported(sig_alg);
|
|
}
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
|
|
|
|
#if defined(MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ENABLED)
|
|
if (ssl->tls_version == MBEDTLS_SSL_VERSION_TLS1_3) {
|
|
return mbedtls_ssl_tls13_sig_alg_is_supported(sig_alg);
|
|
}
|
|
#endif
|
|
((void) ssl);
|
|
((void) sig_alg);
|
|
return 0;
|
|
}
|
|
#endif /* MBEDTLS_SSL_HANDSHAKE_WITH_CERT_ENABLED */
|
|
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO) || defined(MBEDTLS_SSL_PROTO_TLS1_3)
|
|
/* Corresponding PSA algorithm for MBEDTLS_CIPHER_NULL.
|
|
* Same value is used for PSA_ALG_CATEGORY_CIPHER, hence it is
|
|
* guaranteed to not be a valid PSA algorithm identifier.
|
|
*/
|
|
#define MBEDTLS_SSL_NULL_CIPHER 0x04000000
|
|
|
|
/**
|
|
* \brief Translate mbedtls cipher type/taglen pair to psa:
|
|
* algorithm, key type and key size.
|
|
*
|
|
* \param mbedtls_cipher_type [in] given mbedtls cipher type
|
|
* \param taglen [in] given tag length
|
|
* 0 - default tag length
|
|
* \param alg [out] corresponding PSA alg
|
|
* There is no corresponding PSA
|
|
* alg for MBEDTLS_CIPHER_NULL, so
|
|
* in this case MBEDTLS_SSL_NULL_CIPHER
|
|
* is returned via this parameter
|
|
* \param key_type [out] corresponding PSA key type
|
|
* \param key_size [out] corresponding PSA key size
|
|
*
|
|
* \return PSA_SUCCESS on success or PSA_ERROR_NOT_SUPPORTED if
|
|
* conversion is not supported.
|
|
*/
|
|
psa_status_t mbedtls_ssl_cipher_to_psa(mbedtls_cipher_type_t mbedtls_cipher_type,
|
|
size_t taglen,
|
|
psa_algorithm_t *alg,
|
|
psa_key_type_t *key_type,
|
|
size_t *key_size);
|
|
|
|
#if !defined(MBEDTLS_DEPRECATED_REMOVED)
|
|
/**
|
|
* \brief Convert given PSA status to mbedtls error code.
|
|
*
|
|
* \param status [in] given PSA status
|
|
*
|
|
* \return corresponding mbedtls error code
|
|
*/
|
|
static inline MBEDTLS_DEPRECATED int psa_ssl_status_to_mbedtls(psa_status_t status)
|
|
{
|
|
switch (status) {
|
|
case PSA_SUCCESS:
|
|
return 0;
|
|
case PSA_ERROR_INSUFFICIENT_MEMORY:
|
|
return MBEDTLS_ERR_SSL_ALLOC_FAILED;
|
|
case PSA_ERROR_NOT_SUPPORTED:
|
|
return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
|
|
case PSA_ERROR_INVALID_SIGNATURE:
|
|
return MBEDTLS_ERR_SSL_INVALID_MAC;
|
|
case PSA_ERROR_INVALID_ARGUMENT:
|
|
return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
|
|
case PSA_ERROR_BAD_STATE:
|
|
return MBEDTLS_ERR_SSL_INTERNAL_ERROR;
|
|
case PSA_ERROR_BUFFER_TOO_SMALL:
|
|
return MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL;
|
|
default:
|
|
return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
|
|
}
|
|
}
|
|
#endif /* !MBEDTLS_DEPRECATED_REMOVED */
|
|
#endif /* MBEDTLS_USE_PSA_CRYPTO || MBEDTLS_SSL_PROTO_TLS1_3 */
|
|
|
|
#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED) && \
|
|
defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
|
|
typedef enum {
|
|
MBEDTLS_ECJPAKE_ROUND_ONE,
|
|
MBEDTLS_ECJPAKE_ROUND_TWO
|
|
} mbedtls_ecjpake_rounds_t;
|
|
|
|
/**
|
|
* \brief Parse the provided input buffer for getting the first round
|
|
* of key exchange. This code is common between server and client
|
|
*
|
|
* \param pake_ctx [in] the PAKE's operation/context structure
|
|
* \param buf [in] input buffer to parse
|
|
* \param len [in] length of the input buffer
|
|
* \param round [in] either MBEDTLS_ECJPAKE_ROUND_ONE or
|
|
* MBEDTLS_ECJPAKE_ROUND_TWO
|
|
*
|
|
* \return 0 on success or a negative error code in case of failure
|
|
*/
|
|
int mbedtls_psa_ecjpake_read_round(
|
|
psa_pake_operation_t *pake_ctx,
|
|
const unsigned char *buf,
|
|
size_t len, mbedtls_ecjpake_rounds_t round);
|
|
|
|
/**
|
|
* \brief Write the first round of key exchange into the provided output
|
|
* buffer. This code is common between server and client
|
|
*
|
|
* \param pake_ctx [in] the PAKE's operation/context structure
|
|
* \param buf [out] the output buffer in which data will be written to
|
|
* \param len [in] length of the output buffer
|
|
* \param olen [out] the length of the data really written on the buffer
|
|
* \param round [in] either MBEDTLS_ECJPAKE_ROUND_ONE or
|
|
* MBEDTLS_ECJPAKE_ROUND_TWO
|
|
*
|
|
* \return 0 on success or a negative error code in case of failure
|
|
*/
|
|
int mbedtls_psa_ecjpake_write_round(
|
|
psa_pake_operation_t *pake_ctx,
|
|
unsigned char *buf,
|
|
size_t len, size_t *olen,
|
|
mbedtls_ecjpake_rounds_t round);
|
|
|
|
#endif //MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED && MBEDTLS_USE_PSA_CRYPTO
|
|
|
|
/**
|
|
* \brief TLS record protection modes
|
|
*/
|
|
typedef enum {
|
|
MBEDTLS_SSL_MODE_STREAM = 0,
|
|
MBEDTLS_SSL_MODE_CBC,
|
|
MBEDTLS_SSL_MODE_CBC_ETM,
|
|
MBEDTLS_SSL_MODE_AEAD
|
|
} mbedtls_ssl_mode_t;
|
|
|
|
mbedtls_ssl_mode_t mbedtls_ssl_get_mode_from_transform(
|
|
const mbedtls_ssl_transform *transform);
|
|
|
|
#if defined(MBEDTLS_SSL_SOME_SUITES_USE_CBC_ETM)
|
|
mbedtls_ssl_mode_t mbedtls_ssl_get_mode_from_ciphersuite(
|
|
int encrypt_then_mac,
|
|
const mbedtls_ssl_ciphersuite_t *suite);
|
|
#else
|
|
mbedtls_ssl_mode_t mbedtls_ssl_get_mode_from_ciphersuite(
|
|
const mbedtls_ssl_ciphersuite_t *suite);
|
|
#endif /* MBEDTLS_SSL_SOME_SUITES_USE_CBC_ETM */
|
|
|
|
#if defined(PSA_WANT_ALG_ECDH) || defined(PSA_WANT_ALG_FFDH)
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_read_public_xxdhe_share(mbedtls_ssl_context *ssl,
|
|
const unsigned char *buf,
|
|
size_t buf_len);
|
|
|
|
#endif /* PSA_WANT_ALG_ECDH || PSA_WANT_ALG_FFDH */
|
|
|
|
static inline int mbedtls_ssl_tls13_cipher_suite_is_offered(
|
|
mbedtls_ssl_context *ssl, int cipher_suite)
|
|
{
|
|
const int *ciphersuite_list = ssl->conf->ciphersuite_list;
|
|
|
|
/* Check whether we have offered this ciphersuite */
|
|
for (size_t i = 0; ciphersuite_list[i] != 0; i++) {
|
|
if (ciphersuite_list[i] == cipher_suite) {
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief Validate cipher suite against config in SSL context.
|
|
*
|
|
* \param ssl SSL context
|
|
* \param suite_info Cipher suite to validate
|
|
* \param min_tls_version Minimal TLS version to accept a cipher suite
|
|
* \param max_tls_version Maximal TLS version to accept a cipher suite
|
|
*
|
|
* \return 0 if valid, negative value otherwise.
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_validate_ciphersuite(
|
|
const mbedtls_ssl_context *ssl,
|
|
const mbedtls_ssl_ciphersuite_t *suite_info,
|
|
mbedtls_ssl_protocol_version min_tls_version,
|
|
mbedtls_ssl_protocol_version max_tls_version);
|
|
|
|
#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_parse_server_name_ext(mbedtls_ssl_context *ssl,
|
|
const unsigned char *buf,
|
|
const unsigned char *end);
|
|
#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
|
|
|
|
#if defined(MBEDTLS_SSL_RECORD_SIZE_LIMIT)
|
|
#define MBEDTLS_SSL_RECORD_SIZE_LIMIT_EXTENSION_DATA_LENGTH (2)
|
|
#define MBEDTLS_SSL_RECORD_SIZE_LIMIT_MIN (64)
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_parse_record_size_limit_ext(mbedtls_ssl_context *ssl,
|
|
const unsigned char *buf,
|
|
const unsigned char *end);
|
|
#endif /* MBEDTLS_SSL_RECORD_SIZE_LIMIT */
|
|
|
|
#if defined(MBEDTLS_SSL_ALPN)
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_parse_alpn_ext(mbedtls_ssl_context *ssl,
|
|
const unsigned char *buf,
|
|
const unsigned char *end);
|
|
|
|
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_write_alpn_ext(mbedtls_ssl_context *ssl,
|
|
unsigned char *buf,
|
|
unsigned char *end,
|
|
size_t *out_len);
|
|
#endif /* MBEDTLS_SSL_ALPN */
|
|
|
|
#if defined(MBEDTLS_TEST_HOOKS)
|
|
int mbedtls_ssl_check_dtls_clihlo_cookie(
|
|
mbedtls_ssl_context *ssl,
|
|
const unsigned char *cli_id, size_t cli_id_len,
|
|
const unsigned char *in, size_t in_len,
|
|
unsigned char *obuf, size_t buf_len, size_t *olen);
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_SOME_PSK_ENABLED)
|
|
/**
|
|
* \brief Given an SSL context and its associated configuration, write the TLS
|
|
* 1.3 specific Pre-Shared key extension.
|
|
*
|
|
* \param[in] ssl SSL context
|
|
* \param[in] buf Base address of the buffer where to write the extension
|
|
* \param[in] end End address of the buffer where to write the extension
|
|
* \param[out] out_len Length in bytes of the Pre-Shared key extension: data
|
|
* written into the buffer \p buf by this function plus
|
|
* the length of the binders to be written.
|
|
* \param[out] binders_len Length of the binders to be written at the end of
|
|
* the extension.
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_write_identities_of_pre_shared_key_ext(
|
|
mbedtls_ssl_context *ssl,
|
|
unsigned char *buf, unsigned char *end,
|
|
size_t *out_len, size_t *binders_len);
|
|
|
|
/**
|
|
* \brief Given an SSL context and its associated configuration, write the TLS
|
|
* 1.3 specific Pre-Shared key extension binders at the end of the
|
|
* ClientHello.
|
|
*
|
|
* \param[in] ssl SSL context
|
|
* \param[in] buf Base address of the buffer where to write the binders
|
|
* \param[in] end End address of the buffer where to write the binders
|
|
*/
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_tls13_write_binders_of_pre_shared_key_ext(
|
|
mbedtls_ssl_context *ssl,
|
|
unsigned char *buf, unsigned char *end);
|
|
#endif /* MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_SOME_PSK_ENABLED */
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_3) && \
|
|
defined(MBEDTLS_SSL_SESSION_TICKETS) && \
|
|
defined(MBEDTLS_SSL_SERVER_NAME_INDICATION) && \
|
|
defined(MBEDTLS_SSL_CLI_C)
|
|
MBEDTLS_CHECK_RETURN_CRITICAL
|
|
int mbedtls_ssl_session_set_hostname(mbedtls_ssl_session *session,
|
|
const char *hostname);
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_SSL_PROTO_TLS1_3) && defined(MBEDTLS_SSL_SESSION_TICKETS)
|
|
|
|
#define MBEDTLS_SSL_TLS1_3_MAX_ALLOWED_TICKET_LIFETIME (604800)
|
|
|
|
static inline unsigned int mbedtls_ssl_session_get_ticket_flags(
|
|
mbedtls_ssl_session *session, unsigned int flags)
|
|
{
|
|
return session->ticket_flags &
|
|
(flags & MBEDTLS_SSL_TLS1_3_TICKET_FLAGS_MASK);
|
|
}
|
|
|
|
static inline unsigned int mbedtls_ssl_session_check_ticket_flags(
|
|
mbedtls_ssl_session *session, unsigned int flags)
|
|
{
|
|
return mbedtls_ssl_session_get_ticket_flags(session, flags) == 0;
|
|
}
|
|
|
|
static inline unsigned int mbedtls_ssl_session_ticket_allow_psk(
|
|
mbedtls_ssl_session *session)
|
|
{
|
|
return !mbedtls_ssl_session_check_ticket_flags(session,
|
|
MBEDTLS_SSL_TLS1_3_TICKET_ALLOW_PSK_RESUMPTION);
|
|
}
|
|
|
|
static inline unsigned int mbedtls_ssl_session_ticket_allow_psk_ephemeral(
|
|
mbedtls_ssl_session *session)
|
|
{
|
|
return !mbedtls_ssl_session_check_ticket_flags(session,
|
|
MBEDTLS_SSL_TLS1_3_TICKET_ALLOW_PSK_EPHEMERAL_RESUMPTION);
|
|
}
|
|
|
|
static inline unsigned int mbedtls_ssl_session_ticket_allow_early_data(
|
|
mbedtls_ssl_session *session)
|
|
{
|
|
return !mbedtls_ssl_session_check_ticket_flags(session,
|
|
MBEDTLS_SSL_TLS1_3_TICKET_ALLOW_EARLY_DATA);
|
|
}
|
|
|
|
static inline void mbedtls_ssl_session_set_ticket_flags(
|
|
mbedtls_ssl_session *session, unsigned int flags)
|
|
{
|
|
session->ticket_flags |= (flags & MBEDTLS_SSL_TLS1_3_TICKET_FLAGS_MASK);
|
|
}
|
|
|
|
static inline void mbedtls_ssl_session_clear_ticket_flags(
|
|
mbedtls_ssl_session *session, unsigned int flags)
|
|
{
|
|
session->ticket_flags &= ~(flags & MBEDTLS_SSL_TLS1_3_TICKET_FLAGS_MASK);
|
|
}
|
|
#endif /* MBEDTLS_SSL_PROTO_TLS1_3 && MBEDTLS_SSL_SESSION_TICKETS */
|
|
|
|
#if defined(MBEDTLS_SSL_CLI_C) && defined(MBEDTLS_SSL_PROTO_TLS1_3)
|
|
int mbedtls_ssl_tls13_finalize_client_hello(mbedtls_ssl_context *ssl);
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_TEST_HOOKS) && defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
|
|
|
|
/** Compute the HMAC of variable-length data with constant flow.
|
|
*
|
|
* This function computes the HMAC of the concatenation of \p add_data and \p
|
|
* data, and does with a code flow and memory access pattern that does not
|
|
* depend on \p data_len_secret, but only on \p min_data_len and \p
|
|
* max_data_len. In particular, this function always reads exactly \p
|
|
* max_data_len bytes from \p data.
|
|
*
|
|
* \param ctx The HMAC context. It must have keys configured
|
|
* with mbedtls_md_hmac_starts() and use one of the
|
|
* following hashes: SHA-384, SHA-256, SHA-1 or MD-5.
|
|
* It is reset using mbedtls_md_hmac_reset() after
|
|
* the computation is complete to prepare for the
|
|
* next computation.
|
|
* \param add_data The first part of the message whose HMAC is being
|
|
* calculated. This must point to a readable buffer
|
|
* of \p add_data_len bytes.
|
|
* \param add_data_len The length of \p add_data in bytes.
|
|
* \param data The buffer containing the second part of the
|
|
* message. This must point to a readable buffer
|
|
* of \p max_data_len bytes.
|
|
* \param data_len_secret The length of the data to process in \p data.
|
|
* This must be no less than \p min_data_len and no
|
|
* greater than \p max_data_len.
|
|
* \param min_data_len The minimal length of the second part of the
|
|
* message, read from \p data.
|
|
* \param max_data_len The maximal length of the second part of the
|
|
* message, read from \p data.
|
|
* \param output The HMAC will be written here. This must point to
|
|
* a writable buffer of sufficient size to hold the
|
|
* HMAC value.
|
|
*
|
|
* \retval 0 on success.
|
|
* \retval #MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED
|
|
* The hardware accelerator failed.
|
|
*/
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
int mbedtls_ct_hmac(mbedtls_svc_key_id_t key,
|
|
psa_algorithm_t mac_alg,
|
|
const unsigned char *add_data,
|
|
size_t add_data_len,
|
|
const unsigned char *data,
|
|
size_t data_len_secret,
|
|
size_t min_data_len,
|
|
size_t max_data_len,
|
|
unsigned char *output);
|
|
#else
|
|
int mbedtls_ct_hmac(mbedtls_md_context_t *ctx,
|
|
const unsigned char *add_data,
|
|
size_t add_data_len,
|
|
const unsigned char *data,
|
|
size_t data_len_secret,
|
|
size_t min_data_len,
|
|
size_t max_data_len,
|
|
unsigned char *output);
|
|
#endif /* defined(MBEDTLS_USE_PSA_CRYPTO) */
|
|
#endif /* MBEDTLS_TEST_HOOKS && defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC) */
|
|
|
|
#endif /* ssl_misc.h */
|