SSL/TLS functions. More...

#include "mbedtls/platform_util.h"
#include "mbedtls/private_access.h"
#include "mbedtls/build_info.h"
#include "mbedtls/bignum.h"
#include "mbedtls/ecp.h"
#include "mbedtls/ssl_ciphersuites.h"
#include "mbedtls/md.h"
#include "psa/crypto.h"

Include dependency graph for ssl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
union	mbedtls_ssl_premaster_secret

struct	mbedtls_ssl_tls13_application_secrets

struct	mbedtls_ssl_session

union	mbedtls_ssl_user_data_t

struct	mbedtls_ssl_config

struct	mbedtls_ssl_context

Macros
#define	MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS -0x7000

#define	MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE -0x7080

#define	MBEDTLS_ERR_SSL_BAD_INPUT_DATA -0x7100

#define	MBEDTLS_ERR_SSL_INVALID_MAC -0x7180

#define	MBEDTLS_ERR_SSL_INVALID_RECORD -0x7200

#define	MBEDTLS_ERR_SSL_CONN_EOF -0x7280

#define	MBEDTLS_ERR_SSL_DECODE_ERROR -0x7300

#define	MBEDTLS_ERR_SSL_NO_RNG -0x7400

#define	MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE -0x7480

#define	MBEDTLS_ERR_SSL_UNSUPPORTED_EXTENSION -0x7500

#define	MBEDTLS_ERR_SSL_NO_APPLICATION_PROTOCOL -0x7580

#define	MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED -0x7600

#define	MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED -0x7680

#define	MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE -0x7700

#define	MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE -0x7780

#define	MBEDTLS_ERR_SSL_UNRECOGNIZED_NAME -0x7800

#define	MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY -0x7880

#define	MBEDTLS_ERR_SSL_BAD_CERTIFICATE -0x7A00

#define	MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET -0x7B00

#define	MBEDTLS_ERR_SSL_CANNOT_READ_EARLY_DATA -0x7B80

#define	MBEDTLS_ERR_SSL_RECEIVED_EARLY_DATA -0x7C00

#define	MBEDTLS_ERR_SSL_CANNOT_WRITE_EARLY_DATA -0x7C80

#define	MBEDTLS_ERR_SSL_CACHE_ENTRY_NOT_FOUND -0x7E80

#define	MBEDTLS_ERR_SSL_ALLOC_FAILED -0x7F00

#define	MBEDTLS_ERR_SSL_HW_ACCEL_FAILED -0x7F80

#define	MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH -0x6F80

#define	MBEDTLS_ERR_SSL_BAD_PROTOCOL_VERSION -0x6E80

#define	MBEDTLS_ERR_SSL_HANDSHAKE_FAILURE -0x6E00

#define	MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED -0x6D80

#define	MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH -0x6D00

#define	MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY -0x6C80

#define	MBEDTLS_ERR_SSL_INTERNAL_ERROR -0x6C00

#define	MBEDTLS_ERR_SSL_COUNTER_WRAPPING -0x6B80

#define	MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO -0x6B00

#define	MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED -0x6A80

#define	MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL -0x6A00

#define	MBEDTLS_ERR_SSL_WANT_READ -0x6900

#define	MBEDTLS_ERR_SSL_WANT_WRITE -0x6880

#define	MBEDTLS_ERR_SSL_TIMEOUT -0x6800

#define	MBEDTLS_ERR_SSL_CLIENT_RECONNECT -0x6780

#define	MBEDTLS_ERR_SSL_UNEXPECTED_RECORD -0x6700

#define	MBEDTLS_ERR_SSL_NON_FATAL -0x6680

#define	MBEDTLS_ERR_SSL_ILLEGAL_PARAMETER -0x6600

#define	MBEDTLS_ERR_SSL_CONTINUE_PROCESSING -0x6580

#define	MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS -0x6500

#define	MBEDTLS_ERR_SSL_EARLY_MESSAGE -0x6480

#define	MBEDTLS_ERR_SSL_UNEXPECTED_CID -0x6000

#define	MBEDTLS_ERR_SSL_VERSION_MISMATCH -0x5F00

#define	MBEDTLS_ERR_SSL_BAD_CONFIG -0x5E80

#define	MBEDTLS_ERR_SSL_CERTIFICATE_VERIFICATION_WITHOUT_HOSTNAME -0x5D80

#define	MBEDTLS_SSL_TLS1_3_PSK_MODE_PURE 0 /* Pure PSK-based exchange */

#define	MBEDTLS_SSL_TLS1_3_PSK_MODE_ECDHE 1 /* PSK+ECDHE-based exchange */

#define	MBEDTLS_SSL_IANA_TLS_GROUP_NONE 0

#define	MBEDTLS_SSL_IANA_TLS_GROUP_SECP192K1 0x0012

#define	MBEDTLS_SSL_IANA_TLS_GROUP_SECP192R1 0x0013

#define	MBEDTLS_SSL_IANA_TLS_GROUP_SECP224K1 0x0014

#define	MBEDTLS_SSL_IANA_TLS_GROUP_SECP224R1 0x0015

#define	MBEDTLS_SSL_IANA_TLS_GROUP_SECP256K1 0x0016

#define	MBEDTLS_SSL_IANA_TLS_GROUP_SECP256R1 0x0017

#define	MBEDTLS_SSL_IANA_TLS_GROUP_SECP384R1 0x0018

#define	MBEDTLS_SSL_IANA_TLS_GROUP_SECP521R1 0x0019

#define	MBEDTLS_SSL_IANA_TLS_GROUP_BP256R1 0x001A

#define	MBEDTLS_SSL_IANA_TLS_GROUP_BP384R1 0x001B

#define	MBEDTLS_SSL_IANA_TLS_GROUP_BP512R1 0x001C

#define	MBEDTLS_SSL_IANA_TLS_GROUP_X25519 0x001D

#define	MBEDTLS_SSL_IANA_TLS_GROUP_X448 0x001E

#define	MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE2048 0x0100

#define	MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE3072 0x0101

#define	MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE4096 0x0102

#define	MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE6144 0x0103

#define	MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE8192 0x0104

#define	MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK (1u << 0)

#define	MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL (1u << 1)

#define	MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_EPHEMERAL (1u << 2)

#define	MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_ALL

#define	MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_ALL

#define	MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ALL

#define	MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_NONE (0)

#define	MBEDTLS_SSL_MAJOR_VERSION_3 3

#define	MBEDTLS_SSL_MINOR_VERSION_3 3

#define	MBEDTLS_SSL_MINOR_VERSION_4 4

#define	MBEDTLS_SSL_TRANSPORT_STREAM 0

#define	MBEDTLS_SSL_TRANSPORT_DATAGRAM 1

#define	MBEDTLS_SSL_MAX_HOST_NAME_LEN 255

#define	MBEDTLS_SSL_MAX_ALPN_NAME_LEN 255

#define	MBEDTLS_SSL_MAX_ALPN_LIST_LEN 65535

#define	MBEDTLS_SSL_MAX_FRAG_LEN_NONE 0

#define	MBEDTLS_SSL_MAX_FRAG_LEN_512 1

#define	MBEDTLS_SSL_MAX_FRAG_LEN_1024 2

#define	MBEDTLS_SSL_MAX_FRAG_LEN_2048 3

#define	MBEDTLS_SSL_MAX_FRAG_LEN_4096 4

#define	MBEDTLS_SSL_MAX_FRAG_LEN_INVALID 5

#define	MBEDTLS_SSL_IS_CLIENT 0

#define	MBEDTLS_SSL_IS_SERVER 1

#define	MBEDTLS_SSL_EXTENDED_MS_DISABLED 0

#define	MBEDTLS_SSL_EXTENDED_MS_ENABLED 1

#define	MBEDTLS_SSL_CID_DISABLED 0

#define	MBEDTLS_SSL_CID_ENABLED 1

#define	MBEDTLS_SSL_ETM_DISABLED 0

#define	MBEDTLS_SSL_ETM_ENABLED 1

#define	MBEDTLS_SSL_COMPRESS_NULL 0

#define	MBEDTLS_SSL_VERIFY_NONE 0

#define	MBEDTLS_SSL_VERIFY_OPTIONAL 1

#define	MBEDTLS_SSL_VERIFY_REQUIRED 2

#define	MBEDTLS_SSL_VERIFY_UNSET 3 /* Used only for sni_authmode */

#define	MBEDTLS_SSL_LEGACY_RENEGOTIATION 0

#define	MBEDTLS_SSL_SECURE_RENEGOTIATION 1

#define	MBEDTLS_SSL_RENEGOTIATION_DISABLED 0

#define	MBEDTLS_SSL_RENEGOTIATION_ENABLED 1

#define	MBEDTLS_SSL_ANTI_REPLAY_DISABLED 0

#define	MBEDTLS_SSL_ANTI_REPLAY_ENABLED 1

#define	MBEDTLS_SSL_RENEGOTIATION_NOT_ENFORCED -1

#define	MBEDTLS_SSL_RENEGO_MAX_RECORDS_DEFAULT 16

#define	MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION 0

#define	MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION 1

#define	MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE 2

#define	MBEDTLS_SSL_TRUNC_HMAC_DISABLED 0

#define	MBEDTLS_SSL_TRUNC_HMAC_ENABLED 1

#define	MBEDTLS_SSL_TRUNCATED_HMAC_LEN 10 /* 80 bits, rfc 6066 section 7 */

#define	MBEDTLS_SSL_SESSION_TICKETS_DISABLED 0

#define	MBEDTLS_SSL_SESSION_TICKETS_ENABLED 1

#define	MBEDTLS_SSL_TLS1_3_SIGNAL_NEW_SESSION_TICKETS_DISABLED 0

#define	MBEDTLS_SSL_TLS1_3_SIGNAL_NEW_SESSION_TICKETS_ENABLED 1

#define	MBEDTLS_SSL_PRESET_DEFAULT 0

#define	MBEDTLS_SSL_PRESET_SUITEB 2

#define	MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED 1

#define	MBEDTLS_SSL_CERT_REQ_CA_LIST_DISABLED 0

#define	MBEDTLS_SSL_EARLY_DATA_DISABLED 0

#define	MBEDTLS_SSL_EARLY_DATA_ENABLED 1

#define	MBEDTLS_SSL_DTLS_SRTP_MKI_UNSUPPORTED 0

#define	MBEDTLS_SSL_DTLS_SRTP_MKI_SUPPORTED 1

#define	MBEDTLS_SSL_SRV_CIPHERSUITE_ORDER_CLIENT 1

#define	MBEDTLS_SSL_SRV_CIPHERSUITE_ORDER_SERVER 0

#define	MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MIN 1000

#define	MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MAX 60000

#define	MBEDTLS_SSL_EARLY_DATA_NO_DISCARD 0

#define	MBEDTLS_SSL_EARLY_DATA_TRY_TO_DEPROTECT_AND_DISCARD 1

#define	MBEDTLS_SSL_EARLY_DATA_DISCARD 2

#define	MBEDTLS_SSL_VERIFY_DATA_MAX_LEN 12

#define	MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO 0xFF

#define	MBEDTLS_SSL_HASH_NONE 0

#define	MBEDTLS_SSL_HASH_MD5 1

#define	MBEDTLS_SSL_HASH_SHA1 2

#define	MBEDTLS_SSL_HASH_SHA224 3

#define	MBEDTLS_SSL_HASH_SHA256 4

#define	MBEDTLS_SSL_HASH_SHA384 5

#define	MBEDTLS_SSL_HASH_SHA512 6

#define	MBEDTLS_SSL_SIG_ANON 0

#define	MBEDTLS_SSL_SIG_RSA 1

#define	MBEDTLS_SSL_SIG_ECDSA 3

#define	MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA256 0x0401

#define	MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA384 0x0501

#define	MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA512 0x0601

#define	MBEDTLS_TLS1_3_SIG_ECDSA_SECP256R1_SHA256 0x0403

#define	MBEDTLS_TLS1_3_SIG_ECDSA_SECP384R1_SHA384 0x0503

#define	MBEDTLS_TLS1_3_SIG_ECDSA_SECP521R1_SHA512 0x0603

#define	MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA256 0x0804

#define	MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA384 0x0805

#define	MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA512 0x0806

#define	MBEDTLS_TLS1_3_SIG_ED25519 0x0807

#define	MBEDTLS_TLS1_3_SIG_ED448 0x0808

#define	MBEDTLS_TLS1_3_SIG_RSA_PSS_PSS_SHA256 0x0809

#define	MBEDTLS_TLS1_3_SIG_RSA_PSS_PSS_SHA384 0x080A

#define	MBEDTLS_TLS1_3_SIG_RSA_PSS_PSS_SHA512 0x080B

#define	MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA1 0x0201

#define	MBEDTLS_TLS1_3_SIG_ECDSA_SHA1 0x0203

#define	MBEDTLS_TLS1_3_SIG_NONE 0x0

#define	MBEDTLS_SSL_CERT_TYPE_RSA_SIGN 1

#define	MBEDTLS_SSL_CERT_TYPE_ECDSA_SIGN 64

#define	MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC 20

#define	MBEDTLS_SSL_MSG_ALERT 21

#define	MBEDTLS_SSL_MSG_HANDSHAKE 22

#define	MBEDTLS_SSL_MSG_APPLICATION_DATA 23

#define	MBEDTLS_SSL_MSG_CID 25

#define	MBEDTLS_SSL_ALERT_LEVEL_WARNING 1

#define	MBEDTLS_SSL_ALERT_LEVEL_FATAL 2

#define	MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY 0 /* 0x00 */

#define	MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE 10 /* 0x0A */

#define	MBEDTLS_SSL_ALERT_MSG_BAD_RECORD_MAC 20 /* 0x14 */

#define	MBEDTLS_SSL_ALERT_MSG_DECRYPTION_FAILED 21 /* 0x15 */

#define	MBEDTLS_SSL_ALERT_MSG_RECORD_OVERFLOW 22 /* 0x16 */

#define	MBEDTLS_SSL_ALERT_MSG_DECOMPRESSION_FAILURE 30 /* 0x1E */

#define	MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE 40 /* 0x28 */

#define	MBEDTLS_SSL_ALERT_MSG_NO_CERT 41 /* 0x29 */

#define	MBEDTLS_SSL_ALERT_MSG_BAD_CERT 42 /* 0x2A */

#define	MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT 43 /* 0x2B */

#define	MBEDTLS_SSL_ALERT_MSG_CERT_REVOKED 44 /* 0x2C */

#define	MBEDTLS_SSL_ALERT_MSG_CERT_EXPIRED 45 /* 0x2D */

#define	MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN 46 /* 0x2E */

#define	MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER 47 /* 0x2F */

#define	MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA 48 /* 0x30 */

#define	MBEDTLS_SSL_ALERT_MSG_ACCESS_DENIED 49 /* 0x31 */

#define	MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR 50 /* 0x32 */

#define	MBEDTLS_SSL_ALERT_MSG_DECRYPT_ERROR 51 /* 0x33 */

#define	MBEDTLS_SSL_ALERT_MSG_EXPORT_RESTRICTION 60 /* 0x3C */

#define	MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION 70 /* 0x46 */

#define	MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY 71 /* 0x47 */

#define	MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR 80 /* 0x50 */

#define	MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK 86 /* 0x56 */

#define	MBEDTLS_SSL_ALERT_MSG_USER_CANCELED 90 /* 0x5A */

#define	MBEDTLS_SSL_ALERT_MSG_NO_RENEGOTIATION 100 /* 0x64 */

#define	MBEDTLS_SSL_ALERT_MSG_MISSING_EXTENSION 109 /* 0x6d -- new in TLS 1.3 */

#define	MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT 110 /* 0x6E */

#define	MBEDTLS_SSL_ALERT_MSG_UNRECOGNIZED_NAME 112 /* 0x70 */

#define	MBEDTLS_SSL_ALERT_MSG_UNKNOWN_PSK_IDENTITY 115 /* 0x73 */

#define	MBEDTLS_SSL_ALERT_MSG_CERT_REQUIRED 116 /* 0x74 */

#define	MBEDTLS_SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL 120 /* 0x78 */

#define	MBEDTLS_SSL_HS_HELLO_REQUEST 0

#define	MBEDTLS_SSL_HS_CLIENT_HELLO 1

#define	MBEDTLS_SSL_HS_SERVER_HELLO 2

#define	MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST 3

#define	MBEDTLS_SSL_HS_NEW_SESSION_TICKET 4

#define	MBEDTLS_SSL_HS_END_OF_EARLY_DATA 5

#define	MBEDTLS_SSL_HS_ENCRYPTED_EXTENSIONS 8

#define	MBEDTLS_SSL_HS_CERTIFICATE 11

#define	MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE 12

#define	MBEDTLS_SSL_HS_CERTIFICATE_REQUEST 13

#define	MBEDTLS_SSL_HS_SERVER_HELLO_DONE 14

#define	MBEDTLS_SSL_HS_CERTIFICATE_VERIFY 15

#define	MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE 16

#define	MBEDTLS_SSL_HS_FINISHED 20

#define	MBEDTLS_SSL_HS_MESSAGE_HASH 254

#define	MBEDTLS_TLS_EXT_SERVERNAME 0

#define	MBEDTLS_TLS_EXT_SERVERNAME_HOSTNAME 0

#define	MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH 1

#define	MBEDTLS_TLS_EXT_TRUNCATED_HMAC 4

#define	MBEDTLS_TLS_EXT_STATUS_REQUEST 5 /* RFC 6066 TLS 1.2 and 1.3 */

#define	MBEDTLS_TLS_EXT_SUPPORTED_ELLIPTIC_CURVES 10

#define	MBEDTLS_TLS_EXT_SUPPORTED_GROUPS 10 /* RFC 8422,7919 TLS 1.2 and 1.3 */

#define	MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS 11

#define	MBEDTLS_TLS_EXT_SIG_ALG 13 /* RFC 8446 TLS 1.3 */

#define	MBEDTLS_TLS_EXT_USE_SRTP 14

#define	MBEDTLS_TLS_EXT_HEARTBEAT 15 /* RFC 6520 TLS 1.2 and 1.3 */

#define	MBEDTLS_TLS_EXT_ALPN 16

#define	MBEDTLS_TLS_EXT_SCT 18 /* RFC 6962 TLS 1.2 and 1.3 */

#define	MBEDTLS_TLS_EXT_CLI_CERT_TYPE 19 /* RFC 7250 TLS 1.2 and 1.3 */

#define	MBEDTLS_TLS_EXT_SERV_CERT_TYPE 20 /* RFC 7250 TLS 1.2 and 1.3 */

#define	MBEDTLS_TLS_EXT_PADDING 21 /* RFC 7685 TLS 1.2 and 1.3 */

#define	MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC 22 /* 0x16 */

#define	MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET 0x0017 /* 23 */

#define	MBEDTLS_TLS_EXT_RECORD_SIZE_LIMIT 28 /* RFC 8449 (implemented for TLS 1.3 only) */

#define	MBEDTLS_TLS_EXT_SESSION_TICKET 35

#define	MBEDTLS_TLS_EXT_PRE_SHARED_KEY 41 /* RFC 8446 TLS 1.3 */

#define	MBEDTLS_TLS_EXT_EARLY_DATA 42 /* RFC 8446 TLS 1.3 */

#define	MBEDTLS_TLS_EXT_SUPPORTED_VERSIONS 43 /* RFC 8446 TLS 1.3 */

#define	MBEDTLS_TLS_EXT_COOKIE 44 /* RFC 8446 TLS 1.3 */

#define	MBEDTLS_TLS_EXT_PSK_KEY_EXCHANGE_MODES 45 /* RFC 8446 TLS 1.3 */

#define	MBEDTLS_TLS_EXT_CERT_AUTH 47 /* RFC 8446 TLS 1.3 */

#define	MBEDTLS_TLS_EXT_OID_FILTERS 48 /* RFC 8446 TLS 1.3 */

#define	MBEDTLS_TLS_EXT_POST_HANDSHAKE_AUTH 49 /* RFC 8446 TLS 1.3 */

#define	MBEDTLS_TLS_EXT_SIG_ALG_CERT 50 /* RFC 8446 TLS 1.3 */

#define	MBEDTLS_TLS_EXT_KEY_SHARE 51 /* RFC 8446 TLS 1.3 */

#define	MBEDTLS_TLS_EXT_CID 54 /* RFC 9146 DTLS 1.2 CID */

#define	MBEDTLS_TLS_EXT_ECJPAKE_KKPP 256 /* experimental */

#define	MBEDTLS_TLS_EXT_RENEGOTIATION_INFO 0xFF01

#define	MBEDTLS_PSK_MAX_LEN 32 /* 256 bits */

#define	MBEDTLS_PREMASTER_SIZE sizeof(union mbedtls_ssl_premaster_secret)

#define	MBEDTLS_TLS1_3_MD_MAX_SIZE PSA_HASH_MAX_SIZE

#define	MBEDTLS_SSL_SEQUENCE_NUMBER_LEN 8

SECTION: Module settings
The configuration options you can set for this module are in this section. Either change them in mbedtls_config.h or define them on the compiler command line.
#define	MBEDTLS_SSL_IN_CONTENT_LEN 16384

#define	MBEDTLS_SSL_OUT_CONTENT_LEN 16384

#define	MBEDTLS_SSL_DTLS_MAX_BUFFERING 32768

#define	MBEDTLS_SSL_CID_IN_LEN_MAX 32

#define	MBEDTLS_SSL_CID_OUT_LEN_MAX 32

#define	MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY 16

#define	MBEDTLS_SSL_MAX_EARLY_DATA_SIZE 1024

#define	MBEDTLS_SSL_TLS1_3_TICKET_AGE_TOLERANCE 6000

#define	MBEDTLS_SSL_TLS1_3_TICKET_NONCE_LENGTH 32

#define	MBEDTLS_SSL_TLS1_3_DEFAULT_NEW_SESSION_TICKETS 1

Typedefs
typedef int	mbedtls_ssl_send_t(void ctx, const unsigned char buf, size_t len)
	Callback type: send data on the network.

typedef int	mbedtls_ssl_recv_t(void ctx, unsigned char buf, size_t len)
	Callback type: receive data from the network.

typedef int	mbedtls_ssl_recv_timeout_t(void ctx, unsigned char buf, size_t len, uint32_t timeout)
	Callback type: receive data from the network, with timeout.

typedef void	mbedtls_ssl_set_timer_t(void *ctx, uint32_t int_ms, uint32_t fin_ms)
	Callback type: set a pair of timers/delays to watch.

typedef int	mbedtls_ssl_get_timer_t(void *ctx)
	Callback type: get status of timers/delays.

typedef struct mbedtls_ssl_session	mbedtls_ssl_session

typedef struct mbedtls_ssl_context	mbedtls_ssl_context

typedef struct mbedtls_ssl_config	mbedtls_ssl_config

typedef struct mbedtls_ssl_transform	mbedtls_ssl_transform

typedef struct mbedtls_ssl_handshake_params	mbedtls_ssl_handshake_params

typedef struct mbedtls_ssl_sig_hash_set_t	mbedtls_ssl_sig_hash_set_t

typedef int	mbedtls_ssl_cache_get_t(void data, unsigned char const session_id, size_t session_id_len, mbedtls_ssl_session *session)
	Callback type: server-side session cache getter.

typedef int	mbedtls_ssl_cache_set_t(void data, unsigned char const session_id, size_t session_id_len, const mbedtls_ssl_session *session)
	Callback type: server-side session cache setter.

typedef void	mbedtls_ssl_export_keys_t(void p_expkey, mbedtls_ssl_key_export_type type, const unsigned char secret, size_t secret_len, const unsigned char client_random[32], const unsigned char server_random[32], mbedtls_tls_prf_types tls_prf_type)
	Callback type: Export key alongside random values for session identification, and PRF for implementation of TLS key exporters.

typedef int	mbedtls_ssl_ticket_write_t(void p_ticket, const mbedtls_ssl_session session, unsigned char start, const unsigned char end, size_t tlen, uint32_t lifetime)
	Callback type: generate and write session ticket.

typedef int	mbedtls_ssl_ticket_parse_t(void p_ticket, mbedtls_ssl_session session, unsigned char *buf, size_t len)
	Callback type: parse and load session ticket.

typedef int	mbedtls_ssl_cookie_write_t(void ctx, unsigned char p, unsigned char end, const unsigned char *info, size_t ilen)
	Callback type: generate a cookie.

typedef int	mbedtls_ssl_cookie_check_t(void ctx, const unsigned char cookie, size_t clen, const unsigned char *info, size_t ilen)
	Callback type: verify a cookie.

Enumerations
enum	mbedtls_ssl_states { MBEDTLS_SSL_HELLO_REQUEST , MBEDTLS_SSL_CLIENT_HELLO , MBEDTLS_SSL_SERVER_HELLO , MBEDTLS_SSL_SERVER_CERTIFICATE , MBEDTLS_SSL_SERVER_KEY_EXCHANGE , MBEDTLS_SSL_CERTIFICATE_REQUEST , MBEDTLS_SSL_SERVER_HELLO_DONE , MBEDTLS_SSL_CLIENT_CERTIFICATE , MBEDTLS_SSL_CLIENT_KEY_EXCHANGE , MBEDTLS_SSL_CERTIFICATE_VERIFY , MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC , MBEDTLS_SSL_CLIENT_FINISHED , MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC , MBEDTLS_SSL_SERVER_FINISHED , MBEDTLS_SSL_FLUSH_BUFFERS , MBEDTLS_SSL_HANDSHAKE_WRAPUP , MBEDTLS_SSL_NEW_SESSION_TICKET , MBEDTLS_SSL_SERVER_HELLO_VERIFY_REQUEST_SENT , MBEDTLS_SSL_HELLO_RETRY_REQUEST , MBEDTLS_SSL_ENCRYPTED_EXTENSIONS , MBEDTLS_SSL_END_OF_EARLY_DATA , MBEDTLS_SSL_CLIENT_CERTIFICATE_VERIFY , MBEDTLS_SSL_CLIENT_CCS_AFTER_SERVER_FINISHED , MBEDTLS_SSL_CLIENT_CCS_BEFORE_2ND_CLIENT_HELLO , MBEDTLS_SSL_SERVER_CCS_AFTER_SERVER_HELLO , MBEDTLS_SSL_CLIENT_CCS_AFTER_CLIENT_HELLO , MBEDTLS_SSL_SERVER_CCS_AFTER_HELLO_RETRY_REQUEST , MBEDTLS_SSL_HANDSHAKE_OVER , MBEDTLS_SSL_TLS1_3_NEW_SESSION_TICKET , MBEDTLS_SSL_TLS1_3_NEW_SESSION_TICKET_FLUSH }

enum	mbedtls_ssl_protocol_version { MBEDTLS_SSL_VERSION_UNKNOWN , MBEDTLS_SSL_VERSION_TLS1_2 = 0x0303 , MBEDTLS_SSL_VERSION_TLS1_3 = 0x0304 }

enum	mbedtls_tls_prf_types { MBEDTLS_SSL_TLS_PRF_NONE , MBEDTLS_SSL_TLS_PRF_SHA384 , MBEDTLS_SSL_TLS_PRF_SHA256 , MBEDTLS_SSL_HKDF_EXPAND_SHA384 , MBEDTLS_SSL_HKDF_EXPAND_SHA256 }

enum	mbedtls_ssl_key_export_type { MBEDTLS_SSL_KEY_EXPORT_TLS12_MASTER_SECRET = 0 }

Functions
const char *	mbedtls_ssl_get_ciphersuite_name (const int ciphersuite_id)
	Return the name of the ciphersuite associated with the given ID.

int	mbedtls_ssl_get_ciphersuite_id (const char *ciphersuite_name)
	Return the ID of the ciphersuite associated with the given name.

void	mbedtls_ssl_init (mbedtls_ssl_context *ssl)
	Initialize an SSL context Just makes the context ready for mbedtls_ssl_setup() or mbedtls_ssl_free()

int	mbedtls_ssl_setup (mbedtls_ssl_context ssl, const mbedtls_ssl_config conf)
	Set up an SSL context for use.

int	mbedtls_ssl_session_reset (mbedtls_ssl_context *ssl)
	Reset an already initialized SSL context for re-use while retaining application-set variables, function pointers and data.

void	mbedtls_ssl_conf_endpoint (mbedtls_ssl_config *conf, int endpoint)
	Set the current endpoint type.

void	mbedtls_ssl_conf_transport (mbedtls_ssl_config *conf, int transport)
	Set the transport type (TLS or DTLS). Default: TLS.

void	mbedtls_ssl_conf_authmode (mbedtls_ssl_config *conf, int authmode)
	Set the certificate verification mode Default: NONE on server, REQUIRED on client.

void	mbedtls_ssl_conf_rng (mbedtls_ssl_config conf, mbedtls_f_rng_t f_rng, void *p_rng)
	Set the random number generator callback.

void	mbedtls_ssl_conf_dbg (mbedtls_ssl_config conf, void(f_dbg)(void , int, const char , int, const char ), void p_dbg)
	Set the debug callback.

void	mbedtls_ssl_set_bio (mbedtls_ssl_context ssl, void p_bio, mbedtls_ssl_send_t f_send, mbedtls_ssl_recv_t f_recv, mbedtls_ssl_recv_timeout_t *f_recv_timeout)
	Set the underlying BIO callbacks for write, read and read-with-timeout.

void	mbedtls_ssl_conf_read_timeout (mbedtls_ssl_config *conf, uint32_t timeout)
	Set the timeout period for mbedtls_ssl_read() (Default: no timeout.)

int	mbedtls_ssl_check_record (mbedtls_ssl_context const ssl, unsigned char buf, size_t buflen)
	Check whether a buffer contains a valid and authentic record that has not been seen before. (DTLS only).

void	mbedtls_ssl_set_timer_cb (mbedtls_ssl_context ssl, void p_timer, mbedtls_ssl_set_timer_t f_set_timer, mbedtls_ssl_get_timer_t f_get_timer)
	Set the timer callbacks (Mandatory for DTLS.)

void	mbedtls_ssl_set_export_keys_cb (mbedtls_ssl_context ssl, mbedtls_ssl_export_keys_t f_export_keys, void *p_export_keys)
	Configure a key export callback. (Default: none.)

void	mbedtls_ssl_conf_dtls_badmac_limit (mbedtls_ssl_config *conf, unsigned limit)
	Set a limit on the number of records with a bad MAC before terminating the connection. (DTLS only, no effect on TLS.) Default: 0 (disabled).

int	mbedtls_ssl_session_load (mbedtls_ssl_session session, const unsigned char buf, size_t len)
	Load serialized session data into a session structure. On client, this can be used for loading saved sessions before resuming them with mbedtls_ssl_set_session(). On server, this can be used for alternative implementations of session cache or session tickets.

int	mbedtls_ssl_session_save (const mbedtls_ssl_session session, unsigned char buf, size_t buf_len, size_t *olen)
	Save session structure as serialized data in a buffer. On client, this can be used for saving session data, potentially in non-volatile storage, for resuming later. On server, this can be used for alternative implementations of session cache or session tickets.

void	mbedtls_ssl_conf_ciphersuites (mbedtls_ssl_config conf, const int ciphersuites)
	Set the list of allowed ciphersuites and the preference order. First in the list has the highest preference.

void	mbedtls_ssl_conf_groups (mbedtls_ssl_config conf, const uint16_t groups)
	Set the allowed groups in order of preference.

void MBEDTLS_DEPRECATED	mbedtls_ssl_conf_max_version (mbedtls_ssl_config *conf, int major, int minor)
	Set the maximum supported version sent from the client side and/or accepted at the server side.

void MBEDTLS_DEPRECATED	mbedtls_ssl_conf_min_version (mbedtls_ssl_config *conf, int major, int minor)
	Set the minimum accepted SSL/TLS protocol version.

void	mbedtls_ssl_conf_legacy_renegotiation (mbedtls_ssl_config *conf, int allow_legacy)
	Prevent or allow legacy renegotiation. (Default: MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION)

int	mbedtls_ssl_check_pending (const mbedtls_ssl_context *ssl)
	Check if there is data already read from the underlying transport but not yet processed.

size_t	mbedtls_ssl_get_bytes_avail (const mbedtls_ssl_context *ssl)
	Return the number of application data bytes remaining to be read from the current record.

uint32_t	mbedtls_ssl_get_verify_result (const mbedtls_ssl_context *ssl)
	Return the result of the certificate verification.

int	mbedtls_ssl_get_ciphersuite_id_from_ssl (const mbedtls_ssl_context *ssl)
	Return the id of the current ciphersuite.

const char *	mbedtls_ssl_get_ciphersuite (const mbedtls_ssl_context *ssl)
	Return the name of the current ciphersuite.

const char *	mbedtls_ssl_get_version (const mbedtls_ssl_context *ssl)
	Return the current TLS version.

int	mbedtls_ssl_get_record_expansion (const mbedtls_ssl_context *ssl)
	Return the (maximum) number of bytes added by the record layer: header + encryption/MAC overhead (inc. padding)

int	mbedtls_ssl_get_max_out_record_payload (const mbedtls_ssl_context *ssl)
	Return the current maximum outgoing record payload in bytes.

int	mbedtls_ssl_get_max_in_record_payload (const mbedtls_ssl_context *ssl)
	Return the current maximum incoming record payload in bytes.

int	mbedtls_ssl_handshake (mbedtls_ssl_context *ssl)
	Perform the SSL handshake.

int	mbedtls_ssl_handshake_step (mbedtls_ssl_context *ssl)
	Perform a single step of the SSL handshake.

int	mbedtls_ssl_read (mbedtls_ssl_context ssl, unsigned char buf, size_t len)
	Read at most 'len' application data bytes.

int	mbedtls_ssl_write (mbedtls_ssl_context ssl, const unsigned char buf, size_t len)
	Try to write exactly 'len' application data bytes.

int	mbedtls_ssl_send_alert_message (mbedtls_ssl_context *ssl, unsigned char level, unsigned char message)
	Send an alert message.

int	mbedtls_ssl_close_notify (mbedtls_ssl_context *ssl)
	Notify the peer that the connection is being closed.

void	mbedtls_ssl_free (mbedtls_ssl_context *ssl)
	Free referenced items in an SSL context and clear memory.

void	mbedtls_ssl_config_init (mbedtls_ssl_config *conf)
	Initialize an SSL configuration context Just makes the context ready for mbedtls_ssl_config_defaults() or mbedtls_ssl_config_free().

int	mbedtls_ssl_config_defaults (mbedtls_ssl_config *conf, int endpoint, int transport, int preset)
	Load reasonable default SSL configuration values. (You need to call mbedtls_ssl_config_init() first.)

void	mbedtls_ssl_config_free (mbedtls_ssl_config *conf)
	Free an SSL configuration context.

void	mbedtls_ssl_session_init (mbedtls_ssl_session *session)
	Initialize SSL session structure.

void	mbedtls_ssl_session_free (mbedtls_ssl_session *session)
	Free referenced items in an SSL session including the peer certificate and clear memory.

int	mbedtls_ssl_tls_prf (const mbedtls_tls_prf_types prf, const unsigned char secret, size_t slen, const char label, const unsigned char random, size_t rlen, unsigned char dstbuf, size_t dlen)
	TLS-PRF function for key derivation.

Detailed Description

SSL/TLS functions.

Macro Definition Documentation

◆ MBEDTLS_ERR_SSL_ALLOC_FAILED

#define MBEDTLS_ERR_SSL_ALLOC_FAILED -0x7F00

Memory allocation failed

◆ MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS

#define MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS -0x6500

The asynchronous operation is not completed yet.

◆ MBEDTLS_ERR_SSL_BAD_CERTIFICATE

#define MBEDTLS_ERR_SSL_BAD_CERTIFICATE -0x7A00

Processing of the Certificate handshake message failed.

◆ MBEDTLS_ERR_SSL_BAD_CONFIG

#define MBEDTLS_ERR_SSL_BAD_CONFIG -0x5E80

Invalid value in SSL config

◆ MBEDTLS_ERR_SSL_BAD_INPUT_DATA

#define MBEDTLS_ERR_SSL_BAD_INPUT_DATA -0x7100

Bad input parameters to function.

◆ MBEDTLS_ERR_SSL_BAD_PROTOCOL_VERSION

#define MBEDTLS_ERR_SSL_BAD_PROTOCOL_VERSION -0x6E80

Handshake protocol not within min/max boundaries

◆ MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL

#define MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL -0x6A00

A buffer is too small to receive or write a message

◆ MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED

#define MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED -0x7680

No CA Chain is set, but required to operate.

◆ MBEDTLS_ERR_SSL_CACHE_ENTRY_NOT_FOUND

#define MBEDTLS_ERR_SSL_CACHE_ENTRY_NOT_FOUND -0x7E80

Cache entry not found

◆ MBEDTLS_ERR_SSL_CANNOT_READ_EARLY_DATA

#define MBEDTLS_ERR_SSL_CANNOT_READ_EARLY_DATA -0x7B80

Not possible to read early data

◆ MBEDTLS_ERR_SSL_CANNOT_WRITE_EARLY_DATA

#define MBEDTLS_ERR_SSL_CANNOT_WRITE_EARLY_DATA -0x7C80

Not possible to write early data

◆ MBEDTLS_ERR_SSL_CERTIFICATE_VERIFICATION_WITHOUT_HOSTNAME

#define MBEDTLS_ERR_SSL_CERTIFICATE_VERIFICATION_WITHOUT_HOSTNAME -0x5D80

Attempt to verify a certificate without an expected hostname. This is usually insecure.

In TLS clients, when a client authenticates a server through its certificate, the client normally checks three things:

the certificate chain must be valid;
the chain must start from a trusted CA;
the certificate must cover the server name that is expected by the client.

Omitting any of these checks is generally insecure, and can allow a malicious server to impersonate a legitimate server.

The third check may be safely skipped in some unusual scenarios, such as networks where eavesdropping is a risk but not active attacks, or a private PKI where the client equally trusts all servers that are accredited by the root CA.

You should call mbedtls_ssl_set_hostname() with the expected server name before starting a TLS handshake on a client (unless the client is set up to only use PSK-based authentication, which does not rely on the host name). If you have determined that server name verification is not required for security in your scenario, call mbedtls_ssl_set_hostname() with NULL as the server name.

This error is raised if all of the following conditions are met:

A TLS client is configured with the authentication mode MBEDTLS_SSL_VERIFY_REQUIRED (default).
Certificate authentication is enabled.
The client does not call mbedtls_ssl_set_hostname().
The configuration option MBEDTLS_SSL_CLI_ALLOW_WEAK_CERTIFICATE_VERIFICATION_WITHOUT_HOSTNAME is not enabled.

◆ MBEDTLS_ERR_SSL_CLIENT_RECONNECT

#define MBEDTLS_ERR_SSL_CLIENT_RECONNECT -0x6780

The client initiated a reconnect from the same port.

◆ MBEDTLS_ERR_SSL_CONN_EOF

#define MBEDTLS_ERR_SSL_CONN_EOF -0x7280

The connection indicated an EOF.

◆ MBEDTLS_ERR_SSL_CONTINUE_PROCESSING

#define MBEDTLS_ERR_SSL_CONTINUE_PROCESSING -0x6580

Internal-only message signaling that further message-processing should be done

◆ MBEDTLS_ERR_SSL_COUNTER_WRAPPING

#define MBEDTLS_ERR_SSL_COUNTER_WRAPPING -0x6B80

A counter would wrap (eg, too many messages exchanged).

◆ MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS

#define MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS -0x7000

A cryptographic operation is in progress. Try again later.

◆ MBEDTLS_ERR_SSL_DECODE_ERROR

#define MBEDTLS_ERR_SSL_DECODE_ERROR -0x7300

A message could not be parsed due to a syntactic error.

◆ MBEDTLS_ERR_SSL_EARLY_MESSAGE

#define MBEDTLS_ERR_SSL_EARLY_MESSAGE -0x6480

Internal-only message signaling that a message arrived early.

◆ MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE

#define MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE -0x7780

A fatal alert message was received from our peer.

◆ MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE

#define MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE -0x7080

The requested feature is not available.

◆ MBEDTLS_ERR_SSL_HANDSHAKE_FAILURE

#define MBEDTLS_ERR_SSL_HANDSHAKE_FAILURE -0x6E00

The handshake negotiation failed.

◆ MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED

#define MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED -0x6A80

DTLS client must retry for hello verification

◆ MBEDTLS_ERR_SSL_HW_ACCEL_FAILED

#define MBEDTLS_ERR_SSL_HW_ACCEL_FAILED -0x7F80

Hardware acceleration function returned with error

◆ MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH

#define MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH -0x6F80

Hardware acceleration function skipped / left alone data

◆ MBEDTLS_ERR_SSL_ILLEGAL_PARAMETER

#define MBEDTLS_ERR_SSL_ILLEGAL_PARAMETER -0x6600

A field in a message was incorrect or inconsistent with other fields.

◆ MBEDTLS_ERR_SSL_INTERNAL_ERROR

#define MBEDTLS_ERR_SSL_INTERNAL_ERROR -0x6C00

Internal error (eg, unexpected failure in lower-level module)

◆ MBEDTLS_ERR_SSL_INVALID_MAC

#define MBEDTLS_ERR_SSL_INVALID_MAC -0x7180

Verification of the message MAC failed.

◆ MBEDTLS_ERR_SSL_INVALID_RECORD

#define MBEDTLS_ERR_SSL_INVALID_RECORD -0x7200

An invalid SSL record was received.

◆ MBEDTLS_ERR_SSL_NO_APPLICATION_PROTOCOL

#define MBEDTLS_ERR_SSL_NO_APPLICATION_PROTOCOL -0x7580

No ALPN protocols supported that the client advertises

◆ MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE

#define MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE -0x7480

No client certification received from the client, but required by the authentication mode.

◆ MBEDTLS_ERR_SSL_NO_RNG

#define MBEDTLS_ERR_SSL_NO_RNG -0x7400

No RNG was provided to the SSL module.

◆ MBEDTLS_ERR_SSL_NON_FATAL

#define MBEDTLS_ERR_SSL_NON_FATAL -0x6680

The alert message received indicates a non-fatal error.

◆ MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY

#define MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY -0x7880

The peer notified us that the connection is going to be closed.

◆ MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH

#define MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH -0x6D00

Public key type mismatch (eg, asked for RSA key exchange and presented EC key)

◆ MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED

#define MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED -0x7600

The own private key or pre-shared key is not set, but needed.

◆ MBEDTLS_ERR_SSL_RECEIVED_EARLY_DATA

#define MBEDTLS_ERR_SSL_RECEIVED_EARLY_DATA -0x7C00

Early data has been received as part of an on-going handshake. This error code can be returned only on server side if and only if early data has been enabled by means of the mbedtls_ssl_conf_early_data() API. This error code can then be returned by mbedtls_ssl_handshake(), mbedtls_ssl_handshake_step(), mbedtls_ssl_read() or mbedtls_ssl_write() if early data has been received as part of the handshake sequence they triggered. To read the early data, call mbedtls_ssl_read_early_data().

◆ MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET

#define MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET -0x7B00

A TLS 1.3 NewSessionTicket message has been received.

◆ MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED

#define MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED -0x6D80

Session ticket has expired.

◆ MBEDTLS_ERR_SSL_TIMEOUT

#define MBEDTLS_ERR_SSL_TIMEOUT -0x6800

The operation timed out.

◆ MBEDTLS_ERR_SSL_UNEXPECTED_CID

#define MBEDTLS_ERR_SSL_UNEXPECTED_CID -0x6000

An encrypted DTLS-frame with an unexpected CID was received.

◆ MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE

#define MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE -0x7700

An unexpected message was received from our peer.

◆ MBEDTLS_ERR_SSL_UNEXPECTED_RECORD

#define MBEDTLS_ERR_SSL_UNEXPECTED_RECORD -0x6700

Record header looks valid but is not expected.

◆ MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY

#define MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY -0x6C80

Unknown identity received (eg, PSK identity)

◆ MBEDTLS_ERR_SSL_UNRECOGNIZED_NAME

#define MBEDTLS_ERR_SSL_UNRECOGNIZED_NAME -0x7800

No server could be identified matching the client's SNI.

◆ MBEDTLS_ERR_SSL_UNSUPPORTED_EXTENSION

#define MBEDTLS_ERR_SSL_UNSUPPORTED_EXTENSION -0x7500

Client received an extended server hello containing an unsupported extension

◆ MBEDTLS_ERR_SSL_VERSION_MISMATCH

#define MBEDTLS_ERR_SSL_VERSION_MISMATCH -0x5F00

An operation failed due to an unexpected version or configuration.

◆ MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO

#define MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO -0x6B00

Unexpected message at ServerHello in renegotiation.

◆ MBEDTLS_ERR_SSL_WANT_READ

#define MBEDTLS_ERR_SSL_WANT_READ -0x6900

No data of requested type currently available on underlying transport.

◆ MBEDTLS_ERR_SSL_WANT_WRITE

#define MBEDTLS_ERR_SSL_WANT_WRITE -0x6880

Connection requires a write call.

◆ MBEDTLS_PREMASTER_SIZE

#define MBEDTLS_PREMASTER_SIZE sizeof(union mbedtls_ssl_premaster_secret)

◆ MBEDTLS_PSK_MAX_LEN

#define MBEDTLS_PSK_MAX_LEN 32 /* 256 bits */

◆ MBEDTLS_SSL_ALERT_LEVEL_FATAL

#define MBEDTLS_SSL_ALERT_LEVEL_FATAL 2

◆ MBEDTLS_SSL_ALERT_LEVEL_WARNING

#define MBEDTLS_SSL_ALERT_LEVEL_WARNING 1

◆ MBEDTLS_SSL_ALERT_MSG_ACCESS_DENIED

#define MBEDTLS_SSL_ALERT_MSG_ACCESS_DENIED 49 /* 0x31 */

◆ MBEDTLS_SSL_ALERT_MSG_BAD_CERT

#define MBEDTLS_SSL_ALERT_MSG_BAD_CERT 42 /* 0x2A */

◆ MBEDTLS_SSL_ALERT_MSG_BAD_RECORD_MAC

#define MBEDTLS_SSL_ALERT_MSG_BAD_RECORD_MAC 20 /* 0x14 */

◆ MBEDTLS_SSL_ALERT_MSG_CERT_EXPIRED

#define MBEDTLS_SSL_ALERT_MSG_CERT_EXPIRED 45 /* 0x2D */

◆ MBEDTLS_SSL_ALERT_MSG_CERT_REQUIRED

#define MBEDTLS_SSL_ALERT_MSG_CERT_REQUIRED 116 /* 0x74 */

◆ MBEDTLS_SSL_ALERT_MSG_CERT_REVOKED

#define MBEDTLS_SSL_ALERT_MSG_CERT_REVOKED 44 /* 0x2C */

◆ MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN

#define MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN 46 /* 0x2E */

◆ MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY

#define MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY 0 /* 0x00 */

◆ MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR

#define MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR 50 /* 0x32 */

◆ MBEDTLS_SSL_ALERT_MSG_DECOMPRESSION_FAILURE

#define MBEDTLS_SSL_ALERT_MSG_DECOMPRESSION_FAILURE 30 /* 0x1E */

◆ MBEDTLS_SSL_ALERT_MSG_DECRYPT_ERROR

#define MBEDTLS_SSL_ALERT_MSG_DECRYPT_ERROR 51 /* 0x33 */

◆ MBEDTLS_SSL_ALERT_MSG_DECRYPTION_FAILED

#define MBEDTLS_SSL_ALERT_MSG_DECRYPTION_FAILED 21 /* 0x15 */

◆ MBEDTLS_SSL_ALERT_MSG_EXPORT_RESTRICTION

#define MBEDTLS_SSL_ALERT_MSG_EXPORT_RESTRICTION 60 /* 0x3C */

◆ MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE

#define MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE 40 /* 0x28 */

◆ MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER

#define MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER 47 /* 0x2F */

◆ MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK

#define MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK 86 /* 0x56 */

◆ MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY

#define MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY 71 /* 0x47 */

◆ MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR

#define MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR 80 /* 0x50 */

◆ MBEDTLS_SSL_ALERT_MSG_MISSING_EXTENSION

#define MBEDTLS_SSL_ALERT_MSG_MISSING_EXTENSION 109 /* 0x6d -- new in TLS 1.3 */

◆ MBEDTLS_SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL

#define MBEDTLS_SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL 120 /* 0x78 */

◆ MBEDTLS_SSL_ALERT_MSG_NO_CERT

#define MBEDTLS_SSL_ALERT_MSG_NO_CERT 41 /* 0x29 */

◆ MBEDTLS_SSL_ALERT_MSG_NO_RENEGOTIATION

#define MBEDTLS_SSL_ALERT_MSG_NO_RENEGOTIATION 100 /* 0x64 */

◆ MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION

#define MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION 70 /* 0x46 */

◆ MBEDTLS_SSL_ALERT_MSG_RECORD_OVERFLOW

#define MBEDTLS_SSL_ALERT_MSG_RECORD_OVERFLOW 22 /* 0x16 */

◆ MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE

#define MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE 10 /* 0x0A */

◆ MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA

#define MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA 48 /* 0x30 */

◆ MBEDTLS_SSL_ALERT_MSG_UNKNOWN_PSK_IDENTITY

#define MBEDTLS_SSL_ALERT_MSG_UNKNOWN_PSK_IDENTITY 115 /* 0x73 */

◆ MBEDTLS_SSL_ALERT_MSG_UNRECOGNIZED_NAME

#define MBEDTLS_SSL_ALERT_MSG_UNRECOGNIZED_NAME 112 /* 0x70 */

◆ MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT

#define MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT 43 /* 0x2B */

◆ MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT

#define MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT 110 /* 0x6E */

◆ MBEDTLS_SSL_ALERT_MSG_USER_CANCELED

#define MBEDTLS_SSL_ALERT_MSG_USER_CANCELED 90 /* 0x5A */

◆ MBEDTLS_SSL_ANTI_REPLAY_DISABLED

#define MBEDTLS_SSL_ANTI_REPLAY_DISABLED 0

◆ MBEDTLS_SSL_ANTI_REPLAY_ENABLED

#define MBEDTLS_SSL_ANTI_REPLAY_ENABLED 1

◆ MBEDTLS_SSL_CERT_REQ_CA_LIST_DISABLED

#define MBEDTLS_SSL_CERT_REQ_CA_LIST_DISABLED 0

◆ MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED

#define MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED 1

◆ MBEDTLS_SSL_CERT_TYPE_ECDSA_SIGN

#define MBEDTLS_SSL_CERT_TYPE_ECDSA_SIGN 64

◆ MBEDTLS_SSL_CERT_TYPE_RSA_SIGN

#define MBEDTLS_SSL_CERT_TYPE_RSA_SIGN 1

◆ MBEDTLS_SSL_CID_DISABLED

#define MBEDTLS_SSL_CID_DISABLED 0

◆ MBEDTLS_SSL_CID_ENABLED

#define MBEDTLS_SSL_CID_ENABLED 1

◆ MBEDTLS_SSL_CID_IN_LEN_MAX

#define MBEDTLS_SSL_CID_IN_LEN_MAX 32

The maximum length of CIDs used for incoming DTLS messages.

◆ MBEDTLS_SSL_CID_OUT_LEN_MAX

#define MBEDTLS_SSL_CID_OUT_LEN_MAX 32

The maximum length of CIDs used for outgoing DTLS messages.

◆ MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY

#define MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY 16

This option controls the use of record plaintext padding in TLS 1.3 and when using the Connection ID extension in DTLS 1.2.

The padding will always be chosen so that the length of the padded plaintext is a multiple of the value of this option.

Note: A value of 1 means that no padding will be used for outgoing records.

Note: On systems lacking division instructions, a power of two should be preferred.

◆ MBEDTLS_SSL_COMPRESS_NULL

#define MBEDTLS_SSL_COMPRESS_NULL 0

◆ MBEDTLS_SSL_DTLS_MAX_BUFFERING

#define MBEDTLS_SSL_DTLS_MAX_BUFFERING 32768

Maximum number of heap-allocated bytes for the purpose of DTLS handshake message reassembly and future message buffering.

This should be at least 9/8 * MBEDTLS_SSL_IN_CONTENT_LEN to account for a reassembled handshake message of maximum size, together with its reassembly bitmap.

A value of 2 * MBEDTLS_SSL_IN_CONTENT_LEN (32768 by default) should be sufficient for all practical situations as it allows to reassembly a large handshake message (such as a certificate) while buffering multiple smaller handshake messages.

◆ MBEDTLS_SSL_DTLS_SRTP_MKI_SUPPORTED

#define MBEDTLS_SSL_DTLS_SRTP_MKI_SUPPORTED 1

◆ MBEDTLS_SSL_DTLS_SRTP_MKI_UNSUPPORTED

#define MBEDTLS_SSL_DTLS_SRTP_MKI_UNSUPPORTED 0

◆ MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MAX

#define MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MAX 60000

◆ MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MIN

#define MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MIN 1000

◆ MBEDTLS_SSL_EARLY_DATA_DISABLED

#define MBEDTLS_SSL_EARLY_DATA_DISABLED 0

◆ MBEDTLS_SSL_EARLY_DATA_DISCARD

#define MBEDTLS_SSL_EARLY_DATA_DISCARD 2

◆ MBEDTLS_SSL_EARLY_DATA_ENABLED

#define MBEDTLS_SSL_EARLY_DATA_ENABLED 1

◆ MBEDTLS_SSL_EARLY_DATA_NO_DISCARD

#define MBEDTLS_SSL_EARLY_DATA_NO_DISCARD 0

◆ MBEDTLS_SSL_EARLY_DATA_TRY_TO_DEPROTECT_AND_DISCARD

#define MBEDTLS_SSL_EARLY_DATA_TRY_TO_DEPROTECT_AND_DISCARD 1

◆ MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO

#define MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO 0xFF

renegotiation info ext

◆ MBEDTLS_SSL_ETM_DISABLED

#define MBEDTLS_SSL_ETM_DISABLED 0

◆ MBEDTLS_SSL_ETM_ENABLED

#define MBEDTLS_SSL_ETM_ENABLED 1

◆ MBEDTLS_SSL_EXTENDED_MS_DISABLED

#define MBEDTLS_SSL_EXTENDED_MS_DISABLED 0

◆ MBEDTLS_SSL_EXTENDED_MS_ENABLED

#define MBEDTLS_SSL_EXTENDED_MS_ENABLED 1

◆ MBEDTLS_SSL_HASH_MD5

#define MBEDTLS_SSL_HASH_MD5 1

◆ MBEDTLS_SSL_HASH_NONE

#define MBEDTLS_SSL_HASH_NONE 0

◆ MBEDTLS_SSL_HASH_SHA1

#define MBEDTLS_SSL_HASH_SHA1 2

◆ MBEDTLS_SSL_HASH_SHA224

#define MBEDTLS_SSL_HASH_SHA224 3

◆ MBEDTLS_SSL_HASH_SHA256

#define MBEDTLS_SSL_HASH_SHA256 4

◆ MBEDTLS_SSL_HASH_SHA384

#define MBEDTLS_SSL_HASH_SHA384 5

◆ MBEDTLS_SSL_HASH_SHA512

#define MBEDTLS_SSL_HASH_SHA512 6

◆ MBEDTLS_SSL_HS_CERTIFICATE

#define MBEDTLS_SSL_HS_CERTIFICATE 11

◆ MBEDTLS_SSL_HS_CERTIFICATE_REQUEST

#define MBEDTLS_SSL_HS_CERTIFICATE_REQUEST 13

◆ MBEDTLS_SSL_HS_CERTIFICATE_VERIFY

#define MBEDTLS_SSL_HS_CERTIFICATE_VERIFY 15

◆ MBEDTLS_SSL_HS_CLIENT_HELLO

#define MBEDTLS_SSL_HS_CLIENT_HELLO 1

◆ MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE

#define MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE 16

◆ MBEDTLS_SSL_HS_ENCRYPTED_EXTENSIONS

#define MBEDTLS_SSL_HS_ENCRYPTED_EXTENSIONS 8

◆ MBEDTLS_SSL_HS_END_OF_EARLY_DATA

#define MBEDTLS_SSL_HS_END_OF_EARLY_DATA 5

◆ MBEDTLS_SSL_HS_FINISHED

#define MBEDTLS_SSL_HS_FINISHED 20

◆ MBEDTLS_SSL_HS_HELLO_REQUEST

#define MBEDTLS_SSL_HS_HELLO_REQUEST 0

◆ MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST

#define MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST 3

◆ MBEDTLS_SSL_HS_MESSAGE_HASH

#define MBEDTLS_SSL_HS_MESSAGE_HASH 254

◆ MBEDTLS_SSL_HS_NEW_SESSION_TICKET

#define MBEDTLS_SSL_HS_NEW_SESSION_TICKET 4

◆ MBEDTLS_SSL_HS_SERVER_HELLO

#define MBEDTLS_SSL_HS_SERVER_HELLO 2

◆ MBEDTLS_SSL_HS_SERVER_HELLO_DONE

#define MBEDTLS_SSL_HS_SERVER_HELLO_DONE 14

◆ MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE

#define MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE 12

◆ MBEDTLS_SSL_IANA_TLS_GROUP_BP256R1

#define MBEDTLS_SSL_IANA_TLS_GROUP_BP256R1 0x001A

◆ MBEDTLS_SSL_IANA_TLS_GROUP_BP384R1

#define MBEDTLS_SSL_IANA_TLS_GROUP_BP384R1 0x001B

◆ MBEDTLS_SSL_IANA_TLS_GROUP_BP512R1

#define MBEDTLS_SSL_IANA_TLS_GROUP_BP512R1 0x001C

◆ MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE2048

#define MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE2048 0x0100

◆ MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE3072

#define MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE3072 0x0101

◆ MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE4096

#define MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE4096 0x0102

◆ MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE6144

#define MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE6144 0x0103

◆ MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE8192

#define MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE8192 0x0104

◆ MBEDTLS_SSL_IANA_TLS_GROUP_NONE

#define MBEDTLS_SSL_IANA_TLS_GROUP_NONE 0

◆ MBEDTLS_SSL_IANA_TLS_GROUP_SECP192K1

#define MBEDTLS_SSL_IANA_TLS_GROUP_SECP192K1 0x0012

◆ MBEDTLS_SSL_IANA_TLS_GROUP_SECP192R1

#define MBEDTLS_SSL_IANA_TLS_GROUP_SECP192R1 0x0013

◆ MBEDTLS_SSL_IANA_TLS_GROUP_SECP224K1

#define MBEDTLS_SSL_IANA_TLS_GROUP_SECP224K1 0x0014

◆ MBEDTLS_SSL_IANA_TLS_GROUP_SECP224R1

#define MBEDTLS_SSL_IANA_TLS_GROUP_SECP224R1 0x0015

◆ MBEDTLS_SSL_IANA_TLS_GROUP_SECP256K1

#define MBEDTLS_SSL_IANA_TLS_GROUP_SECP256K1 0x0016

◆ MBEDTLS_SSL_IANA_TLS_GROUP_SECP256R1

#define MBEDTLS_SSL_IANA_TLS_GROUP_SECP256R1 0x0017

◆ MBEDTLS_SSL_IANA_TLS_GROUP_SECP384R1

#define MBEDTLS_SSL_IANA_TLS_GROUP_SECP384R1 0x0018

◆ MBEDTLS_SSL_IANA_TLS_GROUP_SECP521R1

#define MBEDTLS_SSL_IANA_TLS_GROUP_SECP521R1 0x0019

◆ MBEDTLS_SSL_IANA_TLS_GROUP_X25519

#define MBEDTLS_SSL_IANA_TLS_GROUP_X25519 0x001D

◆ MBEDTLS_SSL_IANA_TLS_GROUP_X448

#define MBEDTLS_SSL_IANA_TLS_GROUP_X448 0x001E

◆ MBEDTLS_SSL_IN_CONTENT_LEN

#define MBEDTLS_SSL_IN_CONTENT_LEN 16384

Maximum length (in bytes) of incoming plaintext fragments.

This determines the size of the incoming TLS I/O buffer in such a way that it is capable of holding the specified amount of plaintext data, regardless of the protection mechanism used.

Note: When using a value less than the default of 16KB on the client, it is recommended to use the Maximum Fragment Length (MFL) extension to inform the server about this limitation. On the server, there is no supported, standardized way of informing the client about restriction on the maximum size of incoming messages, and unless the limitation has been communicated by other means, it is recommended to only change the outgoing buffer size MBEDTLS_SSL_OUT_CONTENT_LEN while keeping the default value of 16KB for the incoming buffer.

Uncomment to set the maximum plaintext size of the incoming I/O buffer.

◆ MBEDTLS_SSL_IS_CLIENT

#define MBEDTLS_SSL_IS_CLIENT 0

◆ MBEDTLS_SSL_IS_SERVER

#define MBEDTLS_SSL_IS_SERVER 1

◆ MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION

#define MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION 1

◆ MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE

#define MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE 2

◆ MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION

#define MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION 0

◆ MBEDTLS_SSL_LEGACY_RENEGOTIATION

#define MBEDTLS_SSL_LEGACY_RENEGOTIATION 0

◆ MBEDTLS_SSL_MAJOR_VERSION_3

#define MBEDTLS_SSL_MAJOR_VERSION_3 3

◆ MBEDTLS_SSL_MAX_ALPN_LIST_LEN

#define MBEDTLS_SSL_MAX_ALPN_LIST_LEN 65535

Maximum size in bytes of list in alpn ext., RFC 7301

◆ MBEDTLS_SSL_MAX_ALPN_NAME_LEN

#define MBEDTLS_SSL_MAX_ALPN_NAME_LEN 255

Maximum size in bytes of a protocol name in alpn ext., RFC 7301

◆ MBEDTLS_SSL_MAX_EARLY_DATA_SIZE

#define MBEDTLS_SSL_MAX_EARLY_DATA_SIZE 1024

Complete list of ciphersuites to use, in order of preference.

Warning: No dependency checking is done on that field! This option can only be used to restrict the set of available ciphersuites. It is your responsibility to make sure the needed modules are active.

Use this to save a few hundred bytes of ROM (default ordering of all available ciphersuites) and a few to a few hundred bytes of RAM.

The value below is only an example, not the default.

The default maximum amount of 0-RTT data. See the documentation of mbedtls_ssl_conf_max_early_data_size() for more information.

It must be positive and smaller than UINT32_MAX.

If MBEDTLS_SSL_EARLY_DATA is not defined, this default value does not have any impact on the build.

◆ MBEDTLS_SSL_MAX_FRAG_LEN_1024

#define MBEDTLS_SSL_MAX_FRAG_LEN_1024 2

MaxFragmentLength 2^10

◆ MBEDTLS_SSL_MAX_FRAG_LEN_2048

#define MBEDTLS_SSL_MAX_FRAG_LEN_2048 3

MaxFragmentLength 2^11

◆ MBEDTLS_SSL_MAX_FRAG_LEN_4096

#define MBEDTLS_SSL_MAX_FRAG_LEN_4096 4

MaxFragmentLength 2^12

◆ MBEDTLS_SSL_MAX_FRAG_LEN_512

#define MBEDTLS_SSL_MAX_FRAG_LEN_512 1

MaxFragmentLength 2^9

◆ MBEDTLS_SSL_MAX_FRAG_LEN_INVALID

#define MBEDTLS_SSL_MAX_FRAG_LEN_INVALID 5

first invalid value

◆ MBEDTLS_SSL_MAX_FRAG_LEN_NONE

#define MBEDTLS_SSL_MAX_FRAG_LEN_NONE 0

don't use this extension

◆ MBEDTLS_SSL_MAX_HOST_NAME_LEN

#define MBEDTLS_SSL_MAX_HOST_NAME_LEN 255

Maximum host name defined in RFC 1035

◆ MBEDTLS_SSL_MINOR_VERSION_3

#define MBEDTLS_SSL_MINOR_VERSION_3 3

TLS v1.2

◆ MBEDTLS_SSL_MINOR_VERSION_4

#define MBEDTLS_SSL_MINOR_VERSION_4 4

TLS v1.3

◆ MBEDTLS_SSL_MSG_ALERT

#define MBEDTLS_SSL_MSG_ALERT 21

◆ MBEDTLS_SSL_MSG_APPLICATION_DATA

#define MBEDTLS_SSL_MSG_APPLICATION_DATA 23

◆ MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC

#define MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC 20

◆ MBEDTLS_SSL_MSG_CID

#define MBEDTLS_SSL_MSG_CID 25

◆ MBEDTLS_SSL_MSG_HANDSHAKE

#define MBEDTLS_SSL_MSG_HANDSHAKE 22

◆ MBEDTLS_SSL_OUT_CONTENT_LEN

#define MBEDTLS_SSL_OUT_CONTENT_LEN 16384

Maximum length (in bytes) of outgoing plaintext fragments.

This determines the size of the outgoing TLS I/O buffer in such a way that it is capable of holding the specified amount of plaintext data, regardless of the protection mechanism used.

It is possible to save RAM by setting a smaller outward buffer, while keeping the default inward 16384 byte buffer to conform to the TLS specification.

The minimum required outward buffer size is determined by the handshake protocol's usage. Handshaking will fail if the outward buffer is too small. The specific size requirement depends on the configured ciphers and any certificate data which is sent during the handshake.

Uncomment to set the maximum plaintext size of the outgoing I/O buffer.

◆ MBEDTLS_SSL_PRESET_DEFAULT

#define MBEDTLS_SSL_PRESET_DEFAULT 0

◆ MBEDTLS_SSL_PRESET_SUITEB

#define MBEDTLS_SSL_PRESET_SUITEB 2

◆ MBEDTLS_SSL_RENEGO_MAX_RECORDS_DEFAULT

#define MBEDTLS_SSL_RENEGO_MAX_RECORDS_DEFAULT 16

◆ MBEDTLS_SSL_RENEGOTIATION_DISABLED

#define MBEDTLS_SSL_RENEGOTIATION_DISABLED 0

◆ MBEDTLS_SSL_RENEGOTIATION_ENABLED

#define MBEDTLS_SSL_RENEGOTIATION_ENABLED 1

◆ MBEDTLS_SSL_RENEGOTIATION_NOT_ENFORCED

#define MBEDTLS_SSL_RENEGOTIATION_NOT_ENFORCED -1

◆ MBEDTLS_SSL_SECURE_RENEGOTIATION

#define MBEDTLS_SSL_SECURE_RENEGOTIATION 1

◆ MBEDTLS_SSL_SEQUENCE_NUMBER_LEN

#define MBEDTLS_SSL_SEQUENCE_NUMBER_LEN 8

◆ MBEDTLS_SSL_SESSION_TICKETS_DISABLED

#define MBEDTLS_SSL_SESSION_TICKETS_DISABLED 0

◆ MBEDTLS_SSL_SESSION_TICKETS_ENABLED

#define MBEDTLS_SSL_SESSION_TICKETS_ENABLED 1

◆ MBEDTLS_SSL_SIG_ANON

#define MBEDTLS_SSL_SIG_ANON 0

◆ MBEDTLS_SSL_SIG_ECDSA

#define MBEDTLS_SSL_SIG_ECDSA 3

◆ MBEDTLS_SSL_SIG_RSA

#define MBEDTLS_SSL_SIG_RSA 1

◆ MBEDTLS_SSL_SRV_CIPHERSUITE_ORDER_CLIENT

#define MBEDTLS_SSL_SRV_CIPHERSUITE_ORDER_CLIENT 1

◆ MBEDTLS_SSL_SRV_CIPHERSUITE_ORDER_SERVER

#define MBEDTLS_SSL_SRV_CIPHERSUITE_ORDER_SERVER 0

◆ MBEDTLS_SSL_TLS1_3_DEFAULT_NEW_SESSION_TICKETS

#define MBEDTLS_SSL_TLS1_3_DEFAULT_NEW_SESSION_TICKETS 1

Default number of NewSessionTicket messages to be sent by a TLS 1.3 server after handshake completion. This is not used in TLS 1.2 and relevant only if the MBEDTLS_SSL_SESSION_TICKETS option is enabled.

◆ MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_ALL

#define MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_ALL

Value:

    (MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK              |            \
     MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_EPHEMERAL    |            \
     MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL)

All TLS 1.3 key exchanges

◆ MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL

#define MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL (1u << 1)

Pure-Ephemeral TLS 1.3 key exchanges, including for example ECDHE and DHE key exchanges.

◆ MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ALL

#define MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ALL

Value:

(MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL | \

MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_EPHEMERAL)

All ephemeral TLS 1.3 key exchanges

◆ MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_NONE

#define MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_NONE (0)

◆ MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK

#define MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK (1u << 0)

Pure-PSK TLS 1.3 key exchange, encompassing both externally agreed PSKs as well as resumption PSKs.

◆ MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_ALL

#define MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_ALL

Value:

(MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK | \

MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_EPHEMERAL)

All PSK-based TLS 1.3 key exchanges

◆ MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_EPHEMERAL

#define MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_EPHEMERAL (1u << 2)

PSK-Ephemeral TLS 1.3 key exchanges, using both a PSK and an ephemeral key exchange.

◆ MBEDTLS_SSL_TLS1_3_PSK_MODE_ECDHE

#define MBEDTLS_SSL_TLS1_3_PSK_MODE_ECDHE 1 /* PSK+ECDHE-based exchange */

◆ MBEDTLS_SSL_TLS1_3_PSK_MODE_PURE

#define MBEDTLS_SSL_TLS1_3_PSK_MODE_PURE 0 /* Pure PSK-based exchange */

◆ MBEDTLS_SSL_TLS1_3_SIGNAL_NEW_SESSION_TICKETS_DISABLED

#define MBEDTLS_SSL_TLS1_3_SIGNAL_NEW_SESSION_TICKETS_DISABLED 0

◆ MBEDTLS_SSL_TLS1_3_SIGNAL_NEW_SESSION_TICKETS_ENABLED

#define MBEDTLS_SSL_TLS1_3_SIGNAL_NEW_SESSION_TICKETS_ENABLED 1

◆ MBEDTLS_SSL_TLS1_3_TICKET_AGE_TOLERANCE

#define MBEDTLS_SSL_TLS1_3_TICKET_AGE_TOLERANCE 6000

Maximum allowed ticket age difference in milliseconds tolerated between server and client. Default value is 6000. This is not used in TLS 1.2.

The client ticket age is the time difference between the time when the client proposes to the server to use the ticket and the time the client received the ticket from the server.
The server ticket age is the time difference between the time when the server receives a proposition from the client to use the ticket and the time when the ticket was created by the server.

The ages might be different due to the client and server clocks not running at the same pace. The typical accuracy of an RTC crystal is ±100 to ±20 parts per million (360 to 72 milliseconds per hour). Default tolerance window is 6s, thus in the worst case clients and servers must sync up their system time every 6000/360/2~=8 hours.

See section 8.3 of the TLS 1.3 specification(RFC 8446) for more information.

◆ MBEDTLS_SSL_TLS1_3_TICKET_NONCE_LENGTH

#define MBEDTLS_SSL_TLS1_3_TICKET_NONCE_LENGTH 32

Size in bytes of a ticket nonce. This is not used in TLS 1.2.

This must be less than 256.

◆ MBEDTLS_SSL_TRANSPORT_DATAGRAM

#define MBEDTLS_SSL_TRANSPORT_DATAGRAM 1

DTLS

◆ MBEDTLS_SSL_TRANSPORT_STREAM

#define MBEDTLS_SSL_TRANSPORT_STREAM 0

TLS

◆ MBEDTLS_SSL_TRUNC_HMAC_DISABLED

#define MBEDTLS_SSL_TRUNC_HMAC_DISABLED 0

◆ MBEDTLS_SSL_TRUNC_HMAC_ENABLED

#define MBEDTLS_SSL_TRUNC_HMAC_ENABLED 1

◆ MBEDTLS_SSL_TRUNCATED_HMAC_LEN

#define MBEDTLS_SSL_TRUNCATED_HMAC_LEN 10 /* 80 bits, rfc 6066 section 7 */

◆ MBEDTLS_SSL_VERIFY_DATA_MAX_LEN

#define MBEDTLS_SSL_VERIFY_DATA_MAX_LEN 12

◆ MBEDTLS_SSL_VERIFY_NONE

#define MBEDTLS_SSL_VERIFY_NONE 0

◆ MBEDTLS_SSL_VERIFY_OPTIONAL

#define MBEDTLS_SSL_VERIFY_OPTIONAL 1

◆ MBEDTLS_SSL_VERIFY_REQUIRED

#define MBEDTLS_SSL_VERIFY_REQUIRED 2

◆ MBEDTLS_SSL_VERIFY_UNSET

#define MBEDTLS_SSL_VERIFY_UNSET 3 /* Used only for sni_authmode */

◆ MBEDTLS_TLS1_3_MD_MAX_SIZE

#define MBEDTLS_TLS1_3_MD_MAX_SIZE PSA_HASH_MAX_SIZE

◆ MBEDTLS_TLS1_3_SIG_ECDSA_SECP256R1_SHA256

#define MBEDTLS_TLS1_3_SIG_ECDSA_SECP256R1_SHA256 0x0403

◆ MBEDTLS_TLS1_3_SIG_ECDSA_SECP384R1_SHA384

#define MBEDTLS_TLS1_3_SIG_ECDSA_SECP384R1_SHA384 0x0503

◆ MBEDTLS_TLS1_3_SIG_ECDSA_SECP521R1_SHA512

#define MBEDTLS_TLS1_3_SIG_ECDSA_SECP521R1_SHA512 0x0603

◆ MBEDTLS_TLS1_3_SIG_ECDSA_SHA1

#define MBEDTLS_TLS1_3_SIG_ECDSA_SHA1 0x0203

◆ MBEDTLS_TLS1_3_SIG_ED25519

#define MBEDTLS_TLS1_3_SIG_ED25519 0x0807

◆ MBEDTLS_TLS1_3_SIG_ED448

#define MBEDTLS_TLS1_3_SIG_ED448 0x0808

◆ MBEDTLS_TLS1_3_SIG_NONE

#define MBEDTLS_TLS1_3_SIG_NONE 0x0

◆ MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA1

#define MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA1 0x0201

◆ MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA256

#define MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA256 0x0401

◆ MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA384

#define MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA384 0x0501

◆ MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA512

#define MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA512 0x0601

◆ MBEDTLS_TLS1_3_SIG_RSA_PSS_PSS_SHA256

#define MBEDTLS_TLS1_3_SIG_RSA_PSS_PSS_SHA256 0x0809

◆ MBEDTLS_TLS1_3_SIG_RSA_PSS_PSS_SHA384

#define MBEDTLS_TLS1_3_SIG_RSA_PSS_PSS_SHA384 0x080A

◆ MBEDTLS_TLS1_3_SIG_RSA_PSS_PSS_SHA512

#define MBEDTLS_TLS1_3_SIG_RSA_PSS_PSS_SHA512 0x080B

◆ MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA256

#define MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA256 0x0804

◆ MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA384

#define MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA384 0x0805

◆ MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA512

#define MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA512 0x0806

◆ MBEDTLS_TLS_EXT_ALPN

#define MBEDTLS_TLS_EXT_ALPN 16

◆ MBEDTLS_TLS_EXT_CERT_AUTH

#define MBEDTLS_TLS_EXT_CERT_AUTH 47 /* RFC 8446 TLS 1.3 */

◆ MBEDTLS_TLS_EXT_CID

#define MBEDTLS_TLS_EXT_CID 54 /* RFC 9146 DTLS 1.2 CID */

◆ MBEDTLS_TLS_EXT_CLI_CERT_TYPE

#define MBEDTLS_TLS_EXT_CLI_CERT_TYPE 19 /* RFC 7250 TLS 1.2 and 1.3 */

◆ MBEDTLS_TLS_EXT_COOKIE

#define MBEDTLS_TLS_EXT_COOKIE 44 /* RFC 8446 TLS 1.3 */

◆ MBEDTLS_TLS_EXT_EARLY_DATA

#define MBEDTLS_TLS_EXT_EARLY_DATA 42 /* RFC 8446 TLS 1.3 */

◆ MBEDTLS_TLS_EXT_ECJPAKE_KKPP

#define MBEDTLS_TLS_EXT_ECJPAKE_KKPP 256 /* experimental */

◆ MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC

#define MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC 22 /* 0x16 */

◆ MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET

#define MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET 0x0017 /* 23 */

◆ MBEDTLS_TLS_EXT_HEARTBEAT

#define MBEDTLS_TLS_EXT_HEARTBEAT 15 /* RFC 6520 TLS 1.2 and 1.3 */

◆ MBEDTLS_TLS_EXT_KEY_SHARE

#define MBEDTLS_TLS_EXT_KEY_SHARE 51 /* RFC 8446 TLS 1.3 */

◆ MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH

#define MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH 1

◆ MBEDTLS_TLS_EXT_OID_FILTERS

#define MBEDTLS_TLS_EXT_OID_FILTERS 48 /* RFC 8446 TLS 1.3 */

◆ MBEDTLS_TLS_EXT_PADDING

#define MBEDTLS_TLS_EXT_PADDING 21 /* RFC 7685 TLS 1.2 and 1.3 */

◆ MBEDTLS_TLS_EXT_POST_HANDSHAKE_AUTH

#define MBEDTLS_TLS_EXT_POST_HANDSHAKE_AUTH 49 /* RFC 8446 TLS 1.3 */

◆ MBEDTLS_TLS_EXT_PRE_SHARED_KEY

#define MBEDTLS_TLS_EXT_PRE_SHARED_KEY 41 /* RFC 8446 TLS 1.3 */

◆ MBEDTLS_TLS_EXT_PSK_KEY_EXCHANGE_MODES

#define MBEDTLS_TLS_EXT_PSK_KEY_EXCHANGE_MODES 45 /* RFC 8446 TLS 1.3 */

◆ MBEDTLS_TLS_EXT_RECORD_SIZE_LIMIT

#define MBEDTLS_TLS_EXT_RECORD_SIZE_LIMIT 28 /* RFC 8449 (implemented for TLS 1.3 only) */

◆ MBEDTLS_TLS_EXT_RENEGOTIATION_INFO

#define MBEDTLS_TLS_EXT_RENEGOTIATION_INFO 0xFF01

◆ MBEDTLS_TLS_EXT_SCT

#define MBEDTLS_TLS_EXT_SCT 18 /* RFC 6962 TLS 1.2 and 1.3 */

◆ MBEDTLS_TLS_EXT_SERV_CERT_TYPE

#define MBEDTLS_TLS_EXT_SERV_CERT_TYPE 20 /* RFC 7250 TLS 1.2 and 1.3 */

◆ MBEDTLS_TLS_EXT_SERVERNAME

#define MBEDTLS_TLS_EXT_SERVERNAME 0

◆ MBEDTLS_TLS_EXT_SERVERNAME_HOSTNAME

#define MBEDTLS_TLS_EXT_SERVERNAME_HOSTNAME 0

◆ MBEDTLS_TLS_EXT_SESSION_TICKET

#define MBEDTLS_TLS_EXT_SESSION_TICKET 35

◆ MBEDTLS_TLS_EXT_SIG_ALG

#define MBEDTLS_TLS_EXT_SIG_ALG 13 /* RFC 8446 TLS 1.3 */

◆ MBEDTLS_TLS_EXT_SIG_ALG_CERT

#define MBEDTLS_TLS_EXT_SIG_ALG_CERT 50 /* RFC 8446 TLS 1.3 */

◆ MBEDTLS_TLS_EXT_STATUS_REQUEST

#define MBEDTLS_TLS_EXT_STATUS_REQUEST 5 /* RFC 6066 TLS 1.2 and 1.3 */

◆ MBEDTLS_TLS_EXT_SUPPORTED_ELLIPTIC_CURVES

#define MBEDTLS_TLS_EXT_SUPPORTED_ELLIPTIC_CURVES 10

◆ MBEDTLS_TLS_EXT_SUPPORTED_GROUPS

#define MBEDTLS_TLS_EXT_SUPPORTED_GROUPS 10 /* RFC 8422,7919 TLS 1.2 and 1.3 */

◆ MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS

#define MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS 11

◆ MBEDTLS_TLS_EXT_SUPPORTED_VERSIONS

#define MBEDTLS_TLS_EXT_SUPPORTED_VERSIONS 43 /* RFC 8446 TLS 1.3 */

◆ MBEDTLS_TLS_EXT_TRUNCATED_HMAC

#define MBEDTLS_TLS_EXT_TRUNCATED_HMAC 4

◆ MBEDTLS_TLS_EXT_USE_SRTP

#define MBEDTLS_TLS_EXT_USE_SRTP 14

Typedef Documentation

◆ mbedtls_ssl_cache_get_t

typedef int mbedtls_ssl_cache_get_t(void *data, unsigned char const *session_id, size_t session_id_len, mbedtls_ssl_session *session)

Callback type: server-side session cache getter.

            The session cache is logically a key value store, with
            keys being session IDs and values being instances of
            mbedtls_ssl_session.

            This callback retrieves an entry in this key-value store.

Parameters

data	The address of the session cache structure to query.
session_id	The buffer holding the session ID to query.
session_id_len	The length of `session_id` in Bytes.
session	The address of the session structure to populate. It is initialized with mbdtls_ssl_session_init(), and the callback must always leave it in a state where it can safely be freed via mbedtls_ssl_session_free() independent of the return code of this function.

Returns: 0 on success; A non-zero return value on failure.

◆ mbedtls_ssl_cache_set_t

typedef int mbedtls_ssl_cache_set_t(void *data, unsigned char const *session_id, size_t session_id_len, const mbedtls_ssl_session *session)

Callback type: server-side session cache setter.

            The session cache is logically a key value store, with
            keys being session IDs and values being instances of
            mbedtls_ssl_session.

            This callback sets an entry in this key-value store.

Parameters

data	The address of the session cache structure to modify.
session_id	The buffer holding the session ID to query.
session_id_len	The length of `session_id` in Bytes.
session	The address of the session to be stored in the session cache.

Returns: 0 on success; A non-zero return value on failure.

◆ mbedtls_ssl_config

typedef struct mbedtls_ssl_config mbedtls_ssl_config

◆ mbedtls_ssl_context

typedef struct mbedtls_ssl_context mbedtls_ssl_context

◆ mbedtls_ssl_cookie_check_t

typedef int mbedtls_ssl_cookie_check_t(void *ctx, const unsigned char *cookie, size_t clen, const unsigned char *info, size_t ilen)

Callback type: verify a cookie.

Parameters

ctx	Context for the callback
cookie	Cookie to verify
clen	Length of cookie
info	Client ID info that was passed to `mbedtls_ssl_set_client_transport_id()`
ilen	Length of info in bytes

Returns: The callback must return 0 if cookie is valid, or a negative error code.

◆ mbedtls_ssl_cookie_write_t

typedef int mbedtls_ssl_cookie_write_t(void *ctx, unsigned char **p, unsigned char *end, const unsigned char *info, size_t ilen)

Callback type: generate a cookie.

Parameters

ctx	Context for the callback
p	Buffer to write to, must be updated to point right after the cookie
end	Pointer to one past the end of the output buffer
info	Client ID info that was passed to `mbedtls_ssl_set_client_transport_id()`
ilen	Length of info in bytes

Returns: The callback must return 0 on success, or a negative error code.

◆ mbedtls_ssl_export_keys_t

typedef void mbedtls_ssl_export_keys_t(void *p_expkey, mbedtls_ssl_key_export_type type, const unsigned char *secret, size_t secret_len, const unsigned char client_random[32], const unsigned char server_random[32], mbedtls_tls_prf_types tls_prf_type)

Callback type: Export key alongside random values for session identification, and PRF for implementation of TLS key exporters.

Parameters

p_expkey	Context for the callback.
type	The type of the key that is being exported.
secret	The address of the buffer holding the secret that's being exporterd.
secret_len	The length of `secret` in bytes.
client_random	The client random bytes.
server_random	The server random bytes.
tls_prf_type	The identifier for the PRF used in the handshake to which the key belongs.

◆ mbedtls_ssl_get_timer_t

typedef int mbedtls_ssl_get_timer_t(void *ctx)

Callback type: get status of timers/delays.

Parameters

ctx	Context pointer

Returns: This callback must return: -1 if cancelled (fin_ms == 0), 0 if none of the delays have passed, 1 if only the intermediate delay has passed, 2 if the final delay has passed.

◆ mbedtls_ssl_handshake_params

typedef struct mbedtls_ssl_handshake_params mbedtls_ssl_handshake_params

◆ mbedtls_ssl_recv_t

typedef int mbedtls_ssl_recv_t(void *ctx, unsigned char *buf, size_t len)

Callback type: receive data from the network.

Note: That callback may be either blocking or non-blocking.

Parameters

ctx	Context for the receive callback (typically a file descriptor)
buf	Buffer to write the received data to
len	Length of the receive buffer

Returns: If data has been received, the positive number of bytes received.; 0 if the connection has been closed.; If performing non-blocking I/O, MBEDTLS_ERR_SSL_WANT_READ must be returned when the operation would block.; Another negative error code on other kinds of failures.

Note: The callback may receive fewer bytes than the length of the buffer. It must always return the number of bytes actually received and written to the buffer.

◆ mbedtls_ssl_recv_timeout_t

typedef int mbedtls_ssl_recv_timeout_t(void *ctx, unsigned char *buf, size_t len, uint32_t timeout)

Callback type: receive data from the network, with timeout.

Note: That callback must block until data is received, or the timeout delay expires, or the operation is interrupted by a signal.

Parameters

ctx	Context for the receive callback (typically a file descriptor)
buf	Buffer to write the received data to
len	Length of the receive buffer
timeout	Maximum number of milliseconds to wait for data 0 means no timeout (potentially waiting forever)

Returns: The callback must return the number of bytes received, or a non-zero error code: MBEDTLS_ERR_SSL_TIMEOUT if the operation timed out, MBEDTLS_ERR_SSL_WANT_READ if interrupted by a signal.

Note: The callback may receive fewer bytes than the length of the buffer. It must always return the number of bytes actually received and written to the buffer.

◆ mbedtls_ssl_send_t

typedef int mbedtls_ssl_send_t(void *ctx, const unsigned char *buf, size_t len)

Callback type: send data on the network.

Note: That callback may be either blocking or non-blocking.

Parameters

ctx	Context for the send callback (typically a file descriptor)
buf	Buffer holding the data to send
len	Length of the data to send

Returns: The callback must return the number of bytes sent if any, or a non-zero error code. If performing non-blocking I/O, MBEDTLS_ERR_SSL_WANT_WRITE must be returned when the operation would block.

Note: The callback is allowed to send fewer bytes than requested. It must always return the number of bytes actually sent.

◆ mbedtls_ssl_session

typedef struct mbedtls_ssl_session mbedtls_ssl_session

◆ mbedtls_ssl_set_timer_t

typedef void mbedtls_ssl_set_timer_t(void *ctx, uint32_t int_ms, uint32_t fin_ms)

Callback type: set a pair of timers/delays to watch.

Parameters

ctx	Context pointer
int_ms	Intermediate delay in milliseconds
fin_ms	Final delay in milliseconds 0 cancels the current timer.

Note: This callback must at least store the necessary information for the associated mbedtls_ssl_get_timer_t callback to return correct information.; If using an event-driven style of programming, an event must be generated when the final delay is passed. The event must cause a call to mbedtls_ssl_handshake() with the proper SSL context to be scheduled. Care must be taken to ensure that at most one such call happens at a time.; Only one timer at a time must be running. Calling this function while a timer is running must cancel it. Cancelled timers must not generate any event.

◆ mbedtls_ssl_sig_hash_set_t

typedef struct mbedtls_ssl_sig_hash_set_t mbedtls_ssl_sig_hash_set_t

◆ mbedtls_ssl_ticket_parse_t

typedef int mbedtls_ssl_ticket_parse_t(void *p_ticket, mbedtls_ssl_session *session, unsigned char *buf, size_t len)

Callback type: parse and load session ticket.

Note: This describes what a callback implementation should do. This callback should parse a session ticket as generated by the corresponding mbedtls_ssl_ticket_write_t function, and, if the ticket is authentic and valid, load the session.; The implementation is allowed to modify the first len bytes of the input buffer, eg to use it as a temporary area for the decrypted ticket contents.

Parameters

p_ticket	Context for the callback
session	SSL session to be loaded
buf	Start of the buffer containing the ticket
len	Length of the ticket.

Returns: 0 if successful, or MBEDTLS_ERR_SSL_INVALID_MAC if not authentic, or MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED if expired, or any other non-zero code for other failures.

◆ mbedtls_ssl_ticket_write_t

typedef int mbedtls_ssl_ticket_write_t(void *p_ticket, const mbedtls_ssl_session *session, unsigned char *start, const unsigned char *end, size_t *tlen, uint32_t *lifetime)

Callback type: generate and write session ticket.

Note: This describes what a callback implementation should do. This callback should generate an encrypted and authenticated ticket for the session and write it to the output buffer. Here, ticket means the opaque ticket part of the NewSessionTicket structure of RFC 5077.

Parameters

p_ticket	Context for the callback
session	SSL session to be written in the ticket
start	Start of the output buffer
end	End of the output buffer
tlen	On exit, holds the length written
lifetime	On exit, holds the lifetime of the ticket in seconds

Returns: 0 if successful, or a specific MBEDTLS_ERR_XXX code.

◆ mbedtls_ssl_transform

typedef struct mbedtls_ssl_transform mbedtls_ssl_transform

Enumeration Type Documentation

◆ mbedtls_ssl_key_export_type

enum mbedtls_ssl_key_export_type

Enumerator
MBEDTLS_SSL_KEY_EXPORT_TLS12_MASTER_SECRET

◆ mbedtls_ssl_protocol_version

enum mbedtls_ssl_protocol_version

Human-friendly representation of the (D)TLS protocol version.

Enumerator
MBEDTLS_SSL_VERSION_UNKNOWN	Context not in use or version not yet negotiated.
MBEDTLS_SSL_VERSION_TLS1_2	(D)TLS 1.2
MBEDTLS_SSL_VERSION_TLS1_3	(D)TLS 1.3

◆ mbedtls_ssl_states

enum mbedtls_ssl_states

Enumerator
MBEDTLS_SSL_HELLO_REQUEST
MBEDTLS_SSL_CLIENT_HELLO
MBEDTLS_SSL_SERVER_HELLO
MBEDTLS_SSL_SERVER_CERTIFICATE
MBEDTLS_SSL_SERVER_KEY_EXCHANGE
MBEDTLS_SSL_CERTIFICATE_REQUEST
MBEDTLS_SSL_SERVER_HELLO_DONE
MBEDTLS_SSL_CLIENT_CERTIFICATE
MBEDTLS_SSL_CLIENT_KEY_EXCHANGE
MBEDTLS_SSL_CERTIFICATE_VERIFY
MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC
MBEDTLS_SSL_CLIENT_FINISHED
MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC
MBEDTLS_SSL_SERVER_FINISHED
MBEDTLS_SSL_FLUSH_BUFFERS
MBEDTLS_SSL_HANDSHAKE_WRAPUP
MBEDTLS_SSL_NEW_SESSION_TICKET
MBEDTLS_SSL_SERVER_HELLO_VERIFY_REQUEST_SENT
MBEDTLS_SSL_HELLO_RETRY_REQUEST
MBEDTLS_SSL_ENCRYPTED_EXTENSIONS
MBEDTLS_SSL_END_OF_EARLY_DATA
MBEDTLS_SSL_CLIENT_CERTIFICATE_VERIFY
MBEDTLS_SSL_CLIENT_CCS_AFTER_SERVER_FINISHED
MBEDTLS_SSL_CLIENT_CCS_BEFORE_2ND_CLIENT_HELLO
MBEDTLS_SSL_SERVER_CCS_AFTER_SERVER_HELLO
MBEDTLS_SSL_CLIENT_CCS_AFTER_CLIENT_HELLO
MBEDTLS_SSL_SERVER_CCS_AFTER_HELLO_RETRY_REQUEST
MBEDTLS_SSL_HANDSHAKE_OVER
MBEDTLS_SSL_TLS1_3_NEW_SESSION_TICKET
MBEDTLS_SSL_TLS1_3_NEW_SESSION_TICKET_FLUSH

◆ mbedtls_tls_prf_types

enum mbedtls_tls_prf_types

Enumerator
MBEDTLS_SSL_TLS_PRF_NONE
MBEDTLS_SSL_TLS_PRF_SHA384
MBEDTLS_SSL_TLS_PRF_SHA256
MBEDTLS_SSL_HKDF_EXPAND_SHA384
MBEDTLS_SSL_HKDF_EXPAND_SHA256

Function Documentation

◆ mbedtls_ssl_check_pending()

int mbedtls_ssl_check_pending ( const mbedtls_ssl_context * ssl )

Check if there is data already read from the underlying transport but not yet processed.

Parameters

ssl	SSL context

Returns: 0 if nothing's pending, 1 otherwise.

Note: This is different in purpose and behaviour from mbedtls_ssl_get_bytes_avail in that it considers any kind of unprocessed data, not only unread application data. If mbedtls_ssl_get_bytes returns a non-zero value, this function will also signal pending data, but the converse does not hold. For example, in DTLS there might be further records waiting to be processed from the current underlying transport's datagram.; If this function returns 1 (data pending), this does not imply that a subsequent call to mbedtls_ssl_read will provide any data; e.g., the unprocessed data might turn out to be an alert or a handshake message.; This function is useful in the following situation: If the SSL/TLS module successfully returns from an operation - e.g. a handshake or an application record read - and you're awaiting incoming data next, you must not immediately idle on the underlying transport to have data ready, but you need to check the value of this function first. The reason is that the desired data might already be read but not yet processed. If, in contrast, a previous call to the SSL/TLS module returned MBEDTLS_ERR_SSL_WANT_READ, it is not necessary to call this function, as the latter error code entails that all internal data has been processed.

◆ mbedtls_ssl_check_record()

int mbedtls_ssl_check_record	(	mbedtls_ssl_context const *	ssl,
		unsigned char *	buf,
		size_t	buflen
	)

Check whether a buffer contains a valid and authentic record that has not been seen before. (DTLS only).

This function does not change the user-visible state of the SSL context. Its sole purpose is to provide an indication of the legitimacy of an incoming record.

This can be useful e.g. in distributed server environments using the DTLS Connection ID feature, in which connections might need to be passed between service instances on a change of peer address, but where such disruptive operations should only happen after the validity of incoming records has been confirmed.

Parameters

ssl	The SSL context to use.
buf	The address of the buffer holding the record to be checked. This must be a read/write buffer of length `buflen` Bytes.
buflen	The length of `buf` in Bytes.

Note: This routine only checks whether the provided buffer begins with a valid and authentic record that has not been seen before, but does not check potential data following the initial record. In particular, it is possible to pass DTLS datagrams containing multiple records, in which case only the first record is checked.; This function modifies the input buffer buf. If you need to preserve the original record, you have to maintain a copy.

Returns: 0 if the record is valid and authentic and has not been seen before.; MBEDTLS_ERR_SSL_INVALID_MAC if the check completed successfully but the record was found to be not authentic.; MBEDTLS_ERR_SSL_INVALID_RECORD if the check completed successfully but the record was found to be invalid for a reason different from authenticity checking.; MBEDTLS_ERR_SSL_UNEXPECTED_RECORD if the check completed successfully but the record was found to be unexpected in the state of the SSL context, including replayed records.; Another negative error code on different kinds of failure. In this case, the SSL context becomes unusable and needs to be freed or reset before reuse.

◆ mbedtls_ssl_close_notify()

int mbedtls_ssl_close_notify ( mbedtls_ssl_context * ssl )

Notify the peer that the connection is being closed.

Parameters

ssl	SSL context

Returns: 0 if successful, or a specific SSL error code.

Note: If this function returns something other than 0 or MBEDTLS_ERR_SSL_WANT_READ/WRITE, you must stop using the SSL context for reading or writing, and either free it or call mbedtls_ssl_session_reset() on it before re-using it for a new connection; the current connection must be closed.

◆ mbedtls_ssl_conf_authmode()

void mbedtls_ssl_conf_authmode	(	mbedtls_ssl_config *	conf,
		int	authmode
	)

Set the certificate verification mode Default: NONE on server, REQUIRED on client.

Parameters

conf	SSL configuration
authmode	can be:

MBEDTLS_SSL_VERIFY_NONE: peer certificate is not checked (default on server) (insecure on client)

MBEDTLS_SSL_VERIFY_OPTIONAL: peer certificate is checked, however the handshake continues even if verification failed; mbedtls_ssl_get_verify_result() can be called after the handshake is complete.

MBEDTLS_SSL_VERIFY_REQUIRED: peer must present a valid certificate, handshake is aborted if verification failed. (default on client)

Note: On client, MBEDTLS_SSL_VERIFY_REQUIRED is the recommended mode. With MBEDTLS_SSL_VERIFY_OPTIONAL, the user needs to call mbedtls_ssl_get_verify_result() at the right time(s), which may not be obvious, while REQUIRED always perform the verification as soon as possible. For example, REQUIRED was protecting against the "triple handshake" attack even before it was found.

◆ mbedtls_ssl_conf_ciphersuites()

void mbedtls_ssl_conf_ciphersuites	(	mbedtls_ssl_config *	conf,
		const int *	ciphersuites
	)

Set the list of allowed ciphersuites and the preference order. First in the list has the highest preference.

For TLS 1.2, the notion of ciphersuite determines both the key exchange mechanism and the suite of symmetric algorithms to be used during and after the handshake.

For TLS 1.3 (in development), the notion of ciphersuite only determines the suite of symmetric algorithms to be used during and after the handshake, while key exchange mechanisms are configured separately.

In Mbed TLS, ciphersuites for both TLS 1.2 and TLS 1.3 are configured via this function. For users of TLS 1.3, there will be separate API for the configuration of key exchange mechanisms.

The list of ciphersuites passed to this function may contain a mixture of TLS 1.2 and TLS 1.3 ciphersuite identifiers. This is useful if negotiation of TLS 1.3 should be attempted, but a fallback to TLS 1.2 would be tolerated.

Note: By default, the server chooses its preferred ciphersuite among those that the client supports. If mbedtls_ssl_conf_preference_order() is called to prefer the client's preferences, the server instead chooses the client's preferred ciphersuite among those that the server supports.

Warning: The ciphersuites array ciphersuites is not copied. It must remain valid for the lifetime of the SSL configuration conf.

Parameters

conf	The SSL configuration to modify.
ciphersuites	A 0-terminated list of IANA identifiers of supported ciphersuites, accessible through `MBEDTLS_TLS_XXX` and `MBEDTLS_TLS1_3_XXX` macros defined in ssl_ciphersuites.h.

◆ mbedtls_ssl_conf_dbg()

void mbedtls_ssl_conf_dbg	(	mbedtls_ssl_config *	conf,
		void()(void , int, const char , int, const char )	f_dbg,
		void *	p_dbg
	)

Set the debug callback.

            The callback has the following argument:
            void *           opaque context for the callback
            int              debug level
            const char *     file name
            int              line number
            const char *     message

Parameters

conf	SSL configuration
f_dbg	debug function
p_dbg	debug parameter

◆ mbedtls_ssl_conf_dtls_badmac_limit()

void mbedtls_ssl_conf_dtls_badmac_limit	(	mbedtls_ssl_config *	conf,
		unsigned	limit
	)

Set a limit on the number of records with a bad MAC before terminating the connection. (DTLS only, no effect on TLS.) Default: 0 (disabled).

Parameters

conf	SSL configuration
limit	Limit, or 0 to disable.

Note: If the limit is N, then the connection is terminated when the Nth non-authentic record is seen.; Records with an invalid header are not counted, only the ones going through the authentication-decryption phase.; This is a security trade-off related to the fact that it's often relatively easy for an active attacker to inject UDP datagrams. On one hand, setting a low limit here makes it easier for such an attacker to forcibly terminated a connection. On the other hand, a high limit or no limit might make us waste resources checking authentication on many bogus packets.

◆ mbedtls_ssl_conf_endpoint()

void mbedtls_ssl_conf_endpoint	(	mbedtls_ssl_config *	conf,
		int	endpoint
	)

Set the current endpoint type.

Parameters

conf	SSL configuration
endpoint	must be MBEDTLS_SSL_IS_CLIENT or MBEDTLS_SSL_IS_SERVER

◆ mbedtls_ssl_conf_groups()

void mbedtls_ssl_conf_groups	(	mbedtls_ssl_config *	conf,
		const uint16_t *	groups
	)

Set the allowed groups in order of preference.

            On server: This only affects the choice of key agreement mechanism

            On client: this affects the list of groups offered for any
            use. The server can override our preference order.

            Both sides: limits the set of groups accepted for use in
            key sharing.

Note: This function replaces the deprecated mbedtls_ssl_conf_curves(), which only allows ECP curves to be configured.; The most recent invocation of either mbedtls_ssl_conf_curves() or mbedtls_ssl_conf_groups() nullifies all previous invocations of both.; This list should be ordered by decreasing preference (preferred group first).; When this function is not called, a default list is used, consisting of all supported curves at 255 bits and above, and all supported finite fields at 2048 bits and above. The order favors groups with the lowest resource usage.; New minor versions of Mbed TLS will not remove items from the default list unless serious security concerns require it. New minor versions of Mbed TLS may change the order in keeping with the general principle of favoring the lowest resource usage.

Parameters

conf	SSL configuration
groups	List of allowed groups ordered by preference, terminated by 0. Must contain valid IANA NamedGroup IDs (provided via either an integer or using MBEDTLS_TLS1_3_NAMED_GROUP_XXX macros).

◆ mbedtls_ssl_conf_legacy_renegotiation()

void mbedtls_ssl_conf_legacy_renegotiation	(	mbedtls_ssl_config *	conf,
		int	allow_legacy
	)

Prevent or allow legacy renegotiation. (Default: MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION)

MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION allows connections to be established even if the peer does not support secure renegotiation, but does not allow renegotiation to take place if not secure. (Interoperable and secure option)

MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION allows renegotiations with non-upgraded peers. Allowing legacy renegotiation makes the connection vulnerable to specific man in the middle attacks. (See RFC 5746) (Most interoperable and least secure option)

MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE breaks off connections if peer does not support secure renegotiation. Results in interoperability issues with non-upgraded peers that do not support renegotiation altogether. (Most secure option, interoperability issues)

Parameters

conf	SSL configuration
allow_legacy	Prevent or allow (SSL_NO_LEGACY_RENEGOTIATION, SSL_ALLOW_LEGACY_RENEGOTIATION or MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE)

◆ mbedtls_ssl_conf_max_version()

void MBEDTLS_DEPRECATED mbedtls_ssl_conf_max_version	(	mbedtls_ssl_config *	conf,
		int	major,
		int	minor
	)

Set the maximum supported version sent from the client side and/or accepted at the server side.

See also the documentation of mbedtls_ssl_conf_min_version().

Note: This ignores ciphersuites from higher versions.; This function is deprecated and has been replaced by mbedtls_ssl_conf_max_tls_version().

Parameters

conf	SSL configuration
major	Major version number (MBEDTLS_SSL_MAJOR_VERSION_3)
minor	Minor version number (MBEDTLS_SSL_MINOR_VERSION_3 for (D)TLS 1.2, MBEDTLS_SSL_MINOR_VERSION_4 for TLS 1.3)

◆ mbedtls_ssl_conf_min_version()

void MBEDTLS_DEPRECATED mbedtls_ssl_conf_min_version	(	mbedtls_ssl_config *	conf,
		int	major,
		int	minor
	)

Set the minimum accepted SSL/TLS protocol version.

Note

By default, all supported versions are accepted. Future versions of the library may disable older protocol versions by default if they become deprecated.

The following versions are supported (if enabled at compile time):

(D)TLS 1.2: major = MBEDTLS_SSL_MAJOR_VERSION_3, minor = MBEDTLS_SSL_MINOR_VERSION_3
TLS 1.3: major = MBEDTLS_SSL_MAJOR_VERSION_3, minor = MBEDTLS_SSL_MINOR_VERSION_4

Note that the numbers in the constant names are the TLS internal protocol numbers, and the minor versions differ by one from the human-readable versions!

Note: Input outside of the SSL_MAX_XXXXX_VERSION and SSL_MIN_XXXXX_VERSION range is ignored.; After the handshake, you can call mbedtls_ssl_get_version_number() to see what version was negotiated.; This function is deprecated and has been replaced by mbedtls_ssl_conf_min_tls_version().

Parameters

conf	SSL configuration
major	Major version number (MBEDTLS_SSL_MAJOR_VERSION_3)
minor	Minor version number (MBEDTLS_SSL_MINOR_VERSION_3 for (D)TLS 1.2, MBEDTLS_SSL_MINOR_VERSION_4 for TLS 1.3)

◆ mbedtls_ssl_conf_read_timeout()

void mbedtls_ssl_conf_read_timeout	(	mbedtls_ssl_config *	conf,
		uint32_t	timeout
	)

Set the timeout period for mbedtls_ssl_read() (Default: no timeout.)

Parameters

conf	SSL configuration context
timeout	Timeout value in milliseconds. Use 0 for no timeout (default).

Note: With blocking I/O, this will only work if a non-NULL f_recv_timeout was set with mbedtls_ssl_set_bio(). With non-blocking I/O, this will only work if timer callbacks were set with mbedtls_ssl_set_timer_cb().; With non-blocking I/O, you may also skip this function altogether and handle timeouts at the application layer.

◆ mbedtls_ssl_conf_rng()

void mbedtls_ssl_conf_rng	(	mbedtls_ssl_config *	conf,
		mbedtls_f_rng_t *	f_rng,
		void *	p_rng
	)

Set the random number generator callback.

Note: The callback with its parameter must remain valid as long as there is an SSL context that uses the SSL configuration.

Parameters

conf	SSL configuration
f_rng	RNG function (mandatory)
p_rng	RNG parameter

◆ mbedtls_ssl_conf_transport()

void mbedtls_ssl_conf_transport	(	mbedtls_ssl_config *	conf,
		int	transport
	)

Set the transport type (TLS or DTLS). Default: TLS.

Note: For DTLS, you must either provide a recv callback that doesn't block, or one that handles timeouts, see mbedtls_ssl_set_bio(). You also need to provide timer callbacks with mbedtls_ssl_set_timer_cb().

Parameters

conf	SSL configuration
transport	transport type: MBEDTLS_SSL_TRANSPORT_STREAM for TLS, MBEDTLS_SSL_TRANSPORT_DATAGRAM for DTLS.

◆ mbedtls_ssl_config_defaults()

int mbedtls_ssl_config_defaults	(	mbedtls_ssl_config *	conf,
		int	endpoint,
		int	transport,
		int	preset
	)

Load reasonable default SSL configuration values. (You need to call mbedtls_ssl_config_init() first.)

Parameters

conf	SSL configuration context
endpoint	MBEDTLS_SSL_IS_CLIENT or MBEDTLS_SSL_IS_SERVER
transport	MBEDTLS_SSL_TRANSPORT_STREAM for TLS, or MBEDTLS_SSL_TRANSPORT_DATAGRAM for DTLS
preset	a MBEDTLS_SSL_PRESET_XXX value

Note: See mbedtls_ssl_conf_transport() for notes on DTLS.

Returns: 0 if successful, or MBEDTLS_ERR_XXX_ALLOC_FAILED on memory allocation error.

◆ mbedtls_ssl_config_free()

void mbedtls_ssl_config_free ( mbedtls_ssl_config * conf )

Free an SSL configuration context.

Parameters

conf	SSL configuration context

◆ mbedtls_ssl_config_init()

void mbedtls_ssl_config_init ( mbedtls_ssl_config * conf )

Initialize an SSL configuration context Just makes the context ready for mbedtls_ssl_config_defaults() or mbedtls_ssl_config_free().

Note: You need to call mbedtls_ssl_config_defaults() unless you manually set all of the relevant fields yourself.

Parameters

conf	SSL configuration context

◆ mbedtls_ssl_free()

void mbedtls_ssl_free ( mbedtls_ssl_context * ssl )

Free referenced items in an SSL context and clear memory.

Parameters

ssl	SSL context

◆ mbedtls_ssl_get_bytes_avail()

size_t mbedtls_ssl_get_bytes_avail ( const mbedtls_ssl_context * ssl )

Return the number of application data bytes remaining to be read from the current record.

Parameters

ssl	SSL context

Returns: How many bytes are available in the application data record read buffer.

Note: When working over a datagram transport, this is useful to detect the current datagram's boundary in case mbedtls_ssl_read has written the maximal amount of data fitting into the input buffer.

◆ mbedtls_ssl_get_ciphersuite()

const char * mbedtls_ssl_get_ciphersuite ( const mbedtls_ssl_context * ssl )

Return the name of the current ciphersuite.

Parameters

ssl	SSL context

Returns: a string containing the ciphersuite name

◆ mbedtls_ssl_get_ciphersuite_id()

int mbedtls_ssl_get_ciphersuite_id ( const char * ciphersuite_name )

Return the ID of the ciphersuite associated with the given name.

Parameters

ciphersuite_name SSL ciphersuite name

Returns: the ID with the ciphersuite or 0 if not found

◆ mbedtls_ssl_get_ciphersuite_id_from_ssl()

int mbedtls_ssl_get_ciphersuite_id_from_ssl ( const mbedtls_ssl_context * ssl )

Return the id of the current ciphersuite.

Parameters

ssl	SSL context

Returns: a ciphersuite id

◆ mbedtls_ssl_get_ciphersuite_name()

const char * mbedtls_ssl_get_ciphersuite_name ( const int ciphersuite_id )

Return the name of the ciphersuite associated with the given ID.

Parameters

ciphersuite_id SSL ciphersuite ID

Returns: a string containing the ciphersuite name

◆ mbedtls_ssl_get_max_in_record_payload()

int mbedtls_ssl_get_max_in_record_payload ( const mbedtls_ssl_context * ssl )

Return the current maximum incoming record payload in bytes.

Note: The logic to determine the maximum incoming record payload is version-specific. It takes into account various factors, such as the mbedtls_config.h setting MBEDTLS_SSL_IN_CONTENT_LEN, extensions such as the max fragment length extension or record size limit extension if used, and the current record expansion.

See also: mbedtls_ssl_set_mtu(); mbedtls_ssl_get_max_in_record_payload(); mbedtls_ssl_get_record_expansion()

Parameters

ssl	SSL context

Returns: Current maximum payload for an incoming record, or a negative error code.

◆ mbedtls_ssl_get_max_out_record_payload()

int mbedtls_ssl_get_max_out_record_payload ( const mbedtls_ssl_context * ssl )

Return the current maximum outgoing record payload in bytes.

Note: The logic to determine the maximum outgoing record payload is version-specific. It takes into account various factors, such as the mbedtls_config.h setting MBEDTLS_SSL_OUT_CONTENT_LEN, extensions such as the max fragment length or record size limit extension if used, and for DTLS the path MTU as configured and current record expansion.; With DTLS, mbedtls_ssl_write() will return an error if called with a larger length value. With TLS, mbedtls_ssl_write() will fragment the input if necessary and return the number of bytes written; it is up to the caller to call mbedtls_ssl_write() again in order to send the remaining bytes if any.

See also: mbedtls_ssl_get_max_out_record_payload(); mbedtls_ssl_get_record_expansion()

Parameters

ssl	SSL context

Returns: Current maximum payload for an outgoing record, or a negative error code.

◆ mbedtls_ssl_get_record_expansion()

int mbedtls_ssl_get_record_expansion ( const mbedtls_ssl_context * ssl )

Return the (maximum) number of bytes added by the record layer: header + encryption/MAC overhead (inc. padding)

Parameters

ssl	SSL context

Returns: Current maximum record expansion in bytes

◆ mbedtls_ssl_get_verify_result()

uint32_t mbedtls_ssl_get_verify_result ( const mbedtls_ssl_context * ssl )

Return the result of the certificate verification.

Parameters

ssl	The SSL context to use.

Returns: 0 if the certificate verification was successful.; -1u if the result is not available. This may happen e.g. if the handshake aborts early, or a verification callback returned a fatal error.; A bitwise combination of MBEDTLS_X509_BADCERT_XXX and MBEDTLS_X509_BADCRL_XXX failure flags; see x509.h.

◆ mbedtls_ssl_get_version()

const char * mbedtls_ssl_get_version ( const mbedtls_ssl_context * ssl )

Return the current TLS version.

Parameters

ssl	SSL context

Returns: a string containing the TLS version

◆ mbedtls_ssl_handshake()

int mbedtls_ssl_handshake ( mbedtls_ssl_context * ssl )

Perform the SSL handshake.

Parameters

ssl	SSL context

Returns: 0 if successful.; MBEDTLS_ERR_SSL_WANT_READ or MBEDTLS_ERR_SSL_WANT_WRITE if the handshake is incomplete and waiting for data to be available for reading from or writing to the underlying transport - in this case you must call this function again when the underlying transport is ready for the operation.; MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS if an asynchronous operation is in progress (see mbedtls_ssl_conf_async_private_cb()) - in this case you must call this function again when the operation is ready.; MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS if a cryptographic operation is in progress (see mbedtls_ecp_set_max_ops()) - in this case you must call this function again to complete the handshake when you're done attending other tasks.; MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED if DTLS is in use and the client did not demonstrate reachability yet - in this case you must stop using the context (see below).; MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET if a TLS 1.3 NewSessionTicket message has been received. See the documentation of mbedtls_ssl_read() for more information about this error code.; MBEDTLS_ERR_SSL_RECEIVED_EARLY_DATA if early data, as defined in RFC 8446 (TLS 1.3 specification), has been received as part of the handshake. This is server specific and may occur only if the early data feature has been enabled on server (see mbedtls_ssl_conf_early_data() documentation). You must call mbedtls_ssl_read_early_data() to read the early data before resuming the handshake.; Another SSL error code - in this case you must stop using the context (see below).

Warning: If this function returns something other than 0, MBEDTLS_ERR_SSL_WANT_READ, MBEDTLS_ERR_SSL_WANT_WRITE, MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS or MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS or MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET or MBEDTLS_ERR_SSL_RECEIVED_EARLY_DATA, you must stop using the SSL context for reading or writing, and either free it or call mbedtls_ssl_session_reset() on it before re-using it for a new connection; the current connection must be closed.

Note

If DTLS is in use, then you may choose to handle MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED specially for logging purposes, as it is an expected return value rather than an actual error, but you still need to reset/free the context.

Remarks regarding event-driven DTLS: If the function returns MBEDTLS_ERR_SSL_WANT_READ, no datagram from the underlying transport layer is currently being processed, and it is safe to idle until the timer or the underlying transport signal a new event. This is not true for a successful handshake, in which case the datagram of the underlying transport that is currently being processed might or might not contain further DTLS records.

If MBEDTLS_USE_PSA_CRYPTO is enabled, the PSA crypto subsystem must have been initialized by calling psa_crypto_init() before calling this function. Otherwise, the handshake may call psa_crypto_init() if a negotiation involving TLS 1.3 takes place (this may be the case even if TLS 1.3 is offered but eventually not selected).

In TLS, reception of fragmented handshake messages is supported with some limitations (those limitations do not apply to DTLS, where defragmentation is fully supported):

On an Mbed TLS server that only accepts TLS 1.2, the initial ClientHello message must not be fragmented. A TLS 1.2 ClientHello may be fragmented if the server also accepts TLS 1.3 connections (meaning that MBEDTLS_SSL_PROTO_TLS1_3 enabled, and the accepted versions have not been restricted with mbedtls_ssl_conf_max_tls_version() or the like).
The first fragment of a handshake message must be at least 4 bytes long.
Non-handshake records must not be interleaved between the fragments of a handshake message. (This is permitted in TLS 1.2 but not in TLS 1.3, but Mbed TLS rejects it even in TLS 1.2.)

◆ mbedtls_ssl_handshake_step()

int mbedtls_ssl_handshake_step ( mbedtls_ssl_context * ssl )

Perform a single step of the SSL handshake.

Note: The state of the context (ssl->state) will be at the next state after this function returns 0. Do not call this function if mbedtls_ssl_is_handshake_over() returns 1.

Warning: Whilst in the past you may have used direct access to the context state (ssl->state) in order to ascertain when to stop calling this function and although you can still do so with something like ssl->MBEDTLS_PRIVATE(state) or by defining MBEDTLS_ALLOW_PRIVATE_ACCESS, this is now considered deprecated and could be broken in any future release. If you still find you have good reason for such direct access, then please do contact the team to explain this (raise an issue or post to the mailing list), so that we can add a solution to your problem that will be guaranteed to work in the future.

Parameters

ssl	SSL context

Returns: See mbedtls_ssl_handshake().

Warning: If this function returns something other than 0, MBEDTLS_ERR_SSL_WANT_READ, MBEDTLS_ERR_SSL_WANT_WRITE, MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS, MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS or MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET or MBEDTLS_ERR_SSL_RECEIVED_EARLY_DATA, you must stop using the SSL context for reading or writing, and either free it or call mbedtls_ssl_session_reset() on it before re-using it for a new connection; the current connection must be closed.

◆ mbedtls_ssl_init()

void mbedtls_ssl_init ( mbedtls_ssl_context * ssl )

Initialize an SSL context Just makes the context ready for mbedtls_ssl_setup() or mbedtls_ssl_free()

Parameters

ssl	SSL context

◆ mbedtls_ssl_read()

int mbedtls_ssl_read	(	mbedtls_ssl_context *	ssl,
		unsigned char *	buf,
		size_t	len
	)

Read at most 'len' application data bytes.

Parameters

ssl	SSL context
buf	buffer that will hold the data
len	maximum number of bytes to read

Returns: The (positive) number of bytes read if successful.; 0 if the read end of the underlying transport was closed without sending a CloseNotify beforehand, which might happen because of various reasons (internal error of an underlying stack, non-conformant peer not sending a CloseNotify and such) - in this case you must stop using the context (see below).; MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY if the underlying transport is still functional, but the peer has acknowledged to not send anything anymore.; MBEDTLS_ERR_SSL_WANT_READ or MBEDTLS_ERR_SSL_WANT_WRITE if the handshake is incomplete and waiting for data to be available for reading from or writing to the underlying transport - in this case you must call this function again when the underlying transport is ready for the operation.; MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS if an asynchronous operation is in progress (see mbedtls_ssl_conf_async_private_cb()) - in this case you must call this function again when the operation is ready.; MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS if a cryptographic operation is in progress (see mbedtls_ecp_set_max_ops()) - in this case you must call this function again to complete the handshake when you're done attending other tasks.; MBEDTLS_ERR_SSL_CLIENT_RECONNECT if we're at the server side of a DTLS connection and the client is initiating a new connection using the same source port. See below.; MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET if a TLS 1.3 NewSessionTicket message has been received. This error code is only returned on the client side. It is only returned if handling of TLS 1.3 NewSessionTicket messages has been enabled through mbedtls_ssl_conf_tls13_enable_signal_new_session_tickets(). This error code indicates that a TLS 1.3 NewSessionTicket message has been received and parsed successfully by the client. The ticket data can be retrieved from the SSL context by calling mbedtls_ssl_get_session(). It remains available until the next call to mbedtls_ssl_read().; MBEDTLS_ERR_SSL_RECEIVED_EARLY_DATA if early data, as defined in RFC 8446 (TLS 1.3 specification), has been received as part of the handshake. This is server specific and may occur only if the early data feature has been enabled on server (see mbedtls_ssl_conf_early_data() documentation). You must call mbedtls_ssl_read_early_data() to read the early data before resuming the handshake.; Another SSL error code - in this case you must stop using the context (see below).

Warning: If this function returns something other than a positive value, MBEDTLS_ERR_SSL_WANT_READ, MBEDTLS_ERR_SSL_WANT_WRITE, MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS, MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS, MBEDTLS_ERR_SSL_CLIENT_RECONNECT or MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET or MBEDTLS_ERR_SSL_RECEIVED_EARLY_DATA, you must stop using the SSL context for reading or writing, and either free it or call mbedtls_ssl_session_reset() on it before re-using it for a new connection; the current connection must be closed.

Note

When this function returns MBEDTLS_ERR_SSL_CLIENT_RECONNECT (which can only happen server-side), it means that a client is initiating a new connection using the same source port. You can either treat that as a connection close and wait for the client to resend a ClientHello, or directly continue with mbedtls_ssl_handshake() with the same context (as it has been reset internally). Either way, you must make sure this is seen by the application as a new connection: application state, if any, should be reset, and most importantly the identity of the client must be checked again. WARNING: not validating the identity of the client again, or not transmitting the new identity to the application layer, would allow authentication bypass!

Remarks regarding event-driven DTLS:

If the function returns MBEDTLS_ERR_SSL_WANT_READ, no datagram from the underlying transport layer is currently being processed, and it is safe to idle until the timer or the underlying transport signal a new event.
This function may return MBEDTLS_ERR_SSL_WANT_READ even if data was initially available on the underlying transport, as this data may have been only e.g. duplicated messages or a renegotiation request. Therefore, you must be prepared to receive MBEDTLS_ERR_SSL_WANT_READ even when reacting to an incoming-data event from the underlying transport.
On success, the datagram of the underlying transport that is currently being processed may contain further DTLS records. You should call mbedtls_ssl_check_pending to check for remaining records.

◆ mbedtls_ssl_send_alert_message()

int mbedtls_ssl_send_alert_message	(	mbedtls_ssl_context *	ssl,
		unsigned char	level,
		unsigned char	message
	)

Send an alert message.

Parameters

ssl	SSL context
level	The alert level of the message (MBEDTLS_SSL_ALERT_LEVEL_WARNING or MBEDTLS_SSL_ALERT_LEVEL_FATAL)
message	The alert message (SSL_ALERT_MSG_*)

Returns: 0 if successful, or a specific SSL error code.

Note: If this function returns something other than 0 or MBEDTLS_ERR_SSL_WANT_READ/WRITE, you must stop using the SSL context for reading or writing, and either free it or call mbedtls_ssl_session_reset() on it before re-using it for a new connection; the current connection must be closed.

◆ mbedtls_ssl_session_free()

void mbedtls_ssl_session_free ( mbedtls_ssl_session * session )

Free referenced items in an SSL session including the peer certificate and clear memory.

Note: A session object can be freed even if the SSL context that was used to retrieve the session is still in use.

Parameters

session SSL session

◆ mbedtls_ssl_session_init()

void mbedtls_ssl_session_init ( mbedtls_ssl_session * session )

Initialize SSL session structure.

Parameters

session SSL session

◆ mbedtls_ssl_session_load()

int mbedtls_ssl_session_load	(	mbedtls_ssl_session *	session,
		const unsigned char *	buf,
		size_t	len
	)

Load serialized session data into a session structure. On client, this can be used for loading saved sessions before resuming them with mbedtls_ssl_set_session(). On server, this can be used for alternative implementations of session cache or session tickets.

Warning: If a peer certificate chain is associated with the session, the serialized state will only contain the peer's end-entity certificate and the result of the chain verification (unless verification was disabled), but not the rest of the chain.

See also: mbedtls_ssl_session_save(); mbedtls_ssl_set_session()

Parameters

session	The session structure to be populated. It must have been initialised with mbedtls_ssl_session_init() but not populated yet.
buf	The buffer holding the serialized session data. It must be a readable buffer of at least `len` bytes.
len	The size of the serialized data in bytes.

Returns: 0 if successful.; MBEDTLS_ERR_SSL_ALLOC_FAILED if memory allocation failed.; MBEDTLS_ERR_SSL_BAD_INPUT_DATA if input data is invalid.; MBEDTLS_ERR_SSL_VERSION_MISMATCH if the serialized data was generated in a different version or configuration of Mbed TLS.; Another negative value for other kinds of errors (for example, unsupported features in the embedded certificate).

◆ mbedtls_ssl_session_reset()

int mbedtls_ssl_session_reset ( mbedtls_ssl_context * ssl )

Reset an already initialized SSL context for re-use while retaining application-set variables, function pointers and data.

Parameters

ssl	SSL context

Returns: 0 if successful, or MBEDTLS_ERR_SSL_ALLOC_FAILED or MBEDTLS_ERR_SSL_HW_ACCEL_FAILED

◆ mbedtls_ssl_session_save()

int mbedtls_ssl_session_save	(	const mbedtls_ssl_session *	session,
		unsigned char *	buf,
		size_t	buf_len,
		size_t *	olen
	)

Save session structure as serialized data in a buffer. On client, this can be used for saving session data, potentially in non-volatile storage, for resuming later. On server, this can be used for alternative implementations of session cache or session tickets.

See also: mbedtls_ssl_session_load()

Parameters

session	The session structure to be saved.
buf	The buffer to write the serialized data to. It must be a writeable buffer of at least `buf_len` bytes, or may be `NULL` if `buf_len` is `0`.
buf_len	The number of bytes available for writing in `buf`.
olen	The size in bytes of the data that has been or would have been written. It must point to a valid `size_t`.

Note: olen is updated to the correct value regardless of whether buf_len was large enough. This makes it possible to determine the necessary size by calling this function with buf set to NULL and buf_len to 0.; For TLS 1.3 sessions, this feature is supported only if the MBEDTLS_SSL_SESSION_TICKETS configuration option is enabled, as in TLS 1.3 session resumption is possible only with tickets.

Returns: 0 if successful.; MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL if buf is too small.; MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE if the MBEDTLS_SSL_SESSION_TICKETS configuration option is disabled and the session is a TLS 1.3 session.

◆ mbedtls_ssl_set_bio()

void mbedtls_ssl_set_bio	(	mbedtls_ssl_context *	ssl,
		void *	p_bio,
		mbedtls_ssl_send_t *	f_send,
		mbedtls_ssl_recv_t *	f_recv,
		mbedtls_ssl_recv_timeout_t *	f_recv_timeout
	)

Set the underlying BIO callbacks for write, read and read-with-timeout.

Parameters

ssl	SSL context
p_bio	parameter (context) shared by BIO callbacks
f_send	write callback
f_recv	read callback
f_recv_timeout	blocking read callback with timeout.

Note

One of f_recv or f_recv_timeout can be NULL, in which case the other is used. If both are non-NULL, f_recv_timeout is used and f_recv is ignored (as if it were NULL).

The two most common use cases are:

non-blocking I/O, f_recv != NULL, f_recv_timeout == NULL
blocking I/O, f_recv == NULL, f_recv_timeout != NULL

For DTLS, you need to provide either a non-NULL f_recv_timeout callback, or a f_recv that doesn't block.

See the documentations of mbedtls_ssl_send_t, mbedtls_ssl_recv_t and mbedtls_ssl_recv_timeout_t for the conventions those callbacks must follow.

On some platforms, net_sockets.c provides mbedtls_net_send(), mbedtls_net_recv() and mbedtls_net_recv_timeout() that are suitable to be used here.

◆ mbedtls_ssl_set_export_keys_cb()

void mbedtls_ssl_set_export_keys_cb	(	mbedtls_ssl_context *	ssl,
		mbedtls_ssl_export_keys_t *	f_export_keys,
		void *	p_export_keys
	)

Configure a key export callback. (Default: none.)

This API can be used for two purposes:

Debugging: Use this API to e.g. generate an NSSKeylog file and use it to inspect encrypted traffic in tools such as Wireshark.
Application-specific export: Use this API to implement key exporters, e.g. for EAP-TLS or DTLS-SRTP.

Parameters

ssl	The SSL context to which the export callback should be attached.
f_export_keys	The callback for the key export.
p_export_keys	The opaque context pointer to be passed to the callback `f_export_keys`.

◆ mbedtls_ssl_set_timer_cb()

void mbedtls_ssl_set_timer_cb	(	mbedtls_ssl_context *	ssl,
		void *	p_timer,
		mbedtls_ssl_set_timer_t *	f_set_timer,
		mbedtls_ssl_get_timer_t *	f_get_timer
	)

Set the timer callbacks (Mandatory for DTLS.)

Parameters

ssl	SSL context
p_timer	parameter (context) shared by timer callbacks
f_set_timer	set timer callback
f_get_timer	get timer callback. Must return:

Note: See the documentation of mbedtls_ssl_set_timer_t and mbedtls_ssl_get_timer_t for the conventions this pair of callbacks must follow.; On some platforms, timing.c provides mbedtls_timing_set_delay() and mbedtls_timing_get_delay() that are suitable for using here, except if using an event-driven style.; See also the "DTLS tutorial" article in our knowledge base. https://mbed-tls.readthedocs.io/en/latest/kb/how-to/dtls-tutorial

◆ mbedtls_ssl_setup()

int mbedtls_ssl_setup	(	mbedtls_ssl_context *	ssl,
		const mbedtls_ssl_config *	conf
	)

Set up an SSL context for use.

Note: No copy of the configuration context is made, it can be shared by many mbedtls_ssl_context structures.

Warning: The conf structure will be accessed during the session. It must not be modified or freed as long as the session is active.; This function must be called exactly once per context. Calling mbedtls_ssl_setup again is not supported, even if no session is active.; After setting up a client context, if certificate-based authentication is enabled, you should call mbedtls_ssl_set_hostname() to specifiy the expected name of the server. Without this, in most scenarios, the TLS connection is insecure. See MBEDTLS_ERR_SSL_CERTIFICATE_VERIFICATION_WITHOUT_HOSTNAME for more information.

Note: If MBEDTLS_USE_PSA_CRYPTO is enabled, the PSA crypto subsystem must have been initialized by calling psa_crypto_init() before calling this function.

Parameters

ssl	SSL context
conf	SSL configuration to use

Returns: 0 if successful, or MBEDTLS_ERR_SSL_ALLOC_FAILED if memory allocation failed

◆ mbedtls_ssl_tls_prf()

int mbedtls_ssl_tls_prf	(	const mbedtls_tls_prf_types	prf,
		const unsigned char *	secret,
		size_t	slen,
		const char *	label,
		const unsigned char *	random,
		size_t	rlen,
		unsigned char *	dstbuf,
		size_t	dlen
	)

TLS-PRF function for key derivation.

Parameters

prf	The tls_prf type function type to be used.
secret	Secret for the key derivation function.
slen	Length of the secret.
label	String label for the key derivation function, terminated with null character.
random	Random bytes.
rlen	Length of the random bytes buffer.
dstbuf	The buffer holding the derived key.
dlen	Length of the output buffer.

Returns: 0 on success. An SSL specific error on failure.

◆ mbedtls_ssl_write()

int mbedtls_ssl_write	(	mbedtls_ssl_context *	ssl,
		const unsigned char *	buf,
		size_t	len
	)

Try to write exactly 'len' application data bytes.

Warning: This function will do partial writes in some cases. If the return value is non-negative but less than length, the function must be called again with updated arguments: buf + ret, len - ret (if ret is the return value) until it returns a value equal to the last 'len' argument.

Parameters

ssl	SSL context
buf	buffer holding the data
len	how many bytes must be written

Returns: The (non-negative) number of bytes actually written if successful (may be less than len).; MBEDTLS_ERR_SSL_WANT_READ or MBEDTLS_ERR_SSL_WANT_WRITE if the handshake is incomplete and waiting for data to be available for reading from or writing to the underlying transport - in this case you must call this function again when the underlying transport is ready for the operation.; MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS if an asynchronous operation is in progress (see mbedtls_ssl_conf_async_private_cb()) - in this case you must call this function again when the operation is ready.; MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS if a cryptographic operation is in progress (see mbedtls_ecp_set_max_ops()) - in this case you must call this function again to complete the handshake when you're done attending other tasks.; MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET if a TLS 1.3 NewSessionTicket message has been received. See the documentation of mbedtls_ssl_read() for more information about this error code.; MBEDTLS_ERR_SSL_RECEIVED_EARLY_DATA if early data, as defined in RFC 8446 (TLS 1.3 specification), has been received as part of the handshake. This is server specific and may occur only if the early data feature has been enabled on server (see mbedtls_ssl_conf_early_data() documentation). You must call mbedtls_ssl_read_early_data() to read the early data before resuming the handshake.; Another SSL error code - in this case you must stop using the context (see below).

Warning: If this function returns something other than a non-negative value, MBEDTLS_ERR_SSL_WANT_READ, MBEDTLS_ERR_SSL_WANT_WRITE, MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS, MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS or MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET or MBEDTLS_ERR_SSL_RECEIVED_EARLY_DATA, you must stop using the SSL context for reading or writing, and either free it or call mbedtls_ssl_session_reset() on it before re-using it for a new connection; the current connection must be closed.

Note

When this function returns MBEDTLS_ERR_SSL_WANT_WRITE/READ, it must be called later with the same arguments, until it returns a value greater than or equal to 0. When the function returns MBEDTLS_ERR_SSL_WANT_WRITE there may be some partial data in the output buffer, however this is not yet sent.

If the requested length is greater than the maximum fragment length (either the built-in limit or the one set or negotiated with the peer), then:

with TLS, less bytes than requested are written.
with DTLS, MBEDTLS_ERR_SSL_BAD_INPUT_DATA is returned. mbedtls_ssl_get_max_out_record_payload() may be used to query the active maximum fragment length.

Attempting to write 0 bytes will result in an empty TLS application record being sent.

Classes

Macros

Typedefs

Enumerations

Functions

Detailed Description

Macro Definition Documentation

◆ MBEDTLS_ERR_SSL_ALLOC_FAILED

◆ MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS

◆ MBEDTLS_ERR_SSL_BAD_CERTIFICATE

◆ MBEDTLS_ERR_SSL_BAD_CONFIG

◆ MBEDTLS_ERR_SSL_BAD_INPUT_DATA

◆ MBEDTLS_ERR_SSL_BAD_PROTOCOL_VERSION

◆ MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL

◆ MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED

◆ MBEDTLS_ERR_SSL_CACHE_ENTRY_NOT_FOUND

◆ MBEDTLS_ERR_SSL_CANNOT_READ_EARLY_DATA

◆ MBEDTLS_ERR_SSL_CANNOT_WRITE_EARLY_DATA

◆ MBEDTLS_ERR_SSL_CERTIFICATE_VERIFICATION_WITHOUT_HOSTNAME

◆ MBEDTLS_ERR_SSL_CLIENT_RECONNECT

◆ MBEDTLS_ERR_SSL_CONN_EOF

◆ MBEDTLS_ERR_SSL_CONTINUE_PROCESSING

◆ MBEDTLS_ERR_SSL_COUNTER_WRAPPING

◆ MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS

◆ MBEDTLS_ERR_SSL_DECODE_ERROR

◆ MBEDTLS_ERR_SSL_EARLY_MESSAGE

◆ MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE

◆ MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE

◆ MBEDTLS_ERR_SSL_HANDSHAKE_FAILURE

◆ MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED

◆ MBEDTLS_ERR_SSL_HW_ACCEL_FAILED

◆ MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH

◆ MBEDTLS_ERR_SSL_ILLEGAL_PARAMETER

◆ MBEDTLS_ERR_SSL_INTERNAL_ERROR

◆ MBEDTLS_ERR_SSL_INVALID_MAC

◆ MBEDTLS_ERR_SSL_INVALID_RECORD

◆ MBEDTLS_ERR_SSL_NO_APPLICATION_PROTOCOL

◆ MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE

◆ MBEDTLS_ERR_SSL_NO_RNG

◆ MBEDTLS_ERR_SSL_NON_FATAL

◆ MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY

◆ MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH

◆ MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED

◆ MBEDTLS_ERR_SSL_RECEIVED_EARLY_DATA

◆ MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET

◆ MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED

◆ MBEDTLS_ERR_SSL_TIMEOUT

◆ MBEDTLS_ERR_SSL_UNEXPECTED_CID

◆ MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE

◆ MBEDTLS_ERR_SSL_UNEXPECTED_RECORD

◆ MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY

◆ MBEDTLS_ERR_SSL_UNRECOGNIZED_NAME

◆ MBEDTLS_ERR_SSL_UNSUPPORTED_EXTENSION

◆ MBEDTLS_ERR_SSL_VERSION_MISMATCH

◆ MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO

◆ MBEDTLS_ERR_SSL_WANT_READ

◆ MBEDTLS_ERR_SSL_WANT_WRITE

◆ MBEDTLS_PREMASTER_SIZE

◆ MBEDTLS_PSK_MAX_LEN

◆ MBEDTLS_SSL_ALERT_LEVEL_FATAL

◆ MBEDTLS_SSL_ALERT_LEVEL_WARNING

◆ MBEDTLS_SSL_ALERT_MSG_ACCESS_DENIED

◆ MBEDTLS_SSL_ALERT_MSG_BAD_CERT

◆ MBEDTLS_SSL_ALERT_MSG_BAD_RECORD_MAC

◆ MBEDTLS_SSL_ALERT_MSG_CERT_EXPIRED

◆ MBEDTLS_SSL_ALERT_MSG_CERT_REQUIRED

◆ MBEDTLS_SSL_ALERT_MSG_CERT_REVOKED

◆ MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN

◆ MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY

◆ MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR

◆ MBEDTLS_SSL_ALERT_MSG_DECOMPRESSION_FAILURE

◆ MBEDTLS_SSL_ALERT_MSG_DECRYPT_ERROR

◆ MBEDTLS_SSL_ALERT_MSG_DECRYPTION_FAILED

◆ MBEDTLS_SSL_ALERT_MSG_EXPORT_RESTRICTION

◆ MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE

◆ MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER

◆ MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK

◆ MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY

◆ MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR

◆ MBEDTLS_SSL_ALERT_MSG_MISSING_EXTENSION