ssl.h File Reference

SSL/TLS functions. More...

`#include "mbedtls/config.h"`
`#include "mbedtls/bignum.h"`
`#include "mbedtls/ecp.h"`
`#include "mbedtls/ssl_ciphersuites.h"`
`#include "mbedtls/x509_crt.h"`
`#include "mbedtls/x509_crl.h"`
`#include "mbedtls/dhm.h"`
`#include "mbedtls/ecdh.h"`
`#include "mbedtls/platform_time.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.

## Data Structures

union | mbedtls_ssl_premaster_secret
struct | mbedtls_dtls_srtp_info_t
struct | mbedtls_ssl_session
struct | mbedtls_ssl_config
struct | mbedtls_ssl_context

## Macros

#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_UNKNOWN_CIPHER -0x7300
#define | MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN -0x7380
#define | MBEDTLS_ERR_SSL_NO_RNG -0x7400
#define | MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE -0x7480
#define | MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE -0x7500
#define | MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED -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_PEER_VERIFY_FAILED -0x7800
#define | MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY -0x7880
#define | MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO -0x7900
#define | MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO -0x7980
#define | MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE -0x7A00
#define | MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST -0x7A80
#define | MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE -0x7B00
#define | MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE -0x7B80
#define | MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE -0x7C00
#define | MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP -0x7C80
#define | MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS -0x7D00
#define | MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY -0x7D80
#define | MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC -0x7E00
#define | MBEDTLS_ERR_SSL_BAD_HS_FINISHED -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_COMPRESSION_FAILED -0x6F00
#define | MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION -0x6E80
#define | MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET -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_NO_USABLE_CIPHERSUITE -0x6980
#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_INVALID_VERIFY_HASH -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_CRYPTO_IN_PROGRESS -0x7000
#define | MBEDTLS_ERR_SSL_BAD_CONFIG -0x5E80
#define | MBEDTLS_SSL_MAJOR_VERSION_3 3
#define | MBEDTLS_SSL_MINOR_VERSION_0 0
#define | MBEDTLS_SSL_MINOR_VERSION_1 1
#define | MBEDTLS_SSL_MINOR_VERSION_2 2
#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_IS_NOT_FALLBACK 0
#define | MBEDTLS_SSL_IS_FALLBACK 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_COMPRESS_DEFLATE 1
#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_CBC_RECORD_SPLITTING_DISABLED 0
#define | MBEDTLS_SSL_CBC_RECORD_SPLITTING_ENABLED 1
#define | MBEDTLS_SSL_ARC4_ENABLED 0
#define | MBEDTLS_SSL_ARC4_DISABLED 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_DTLS_SRTP_MKI_UNSUPPORTED 0
#define | MBEDTLS_SSL_DTLS_SRTP_MKI_SUPPORTED 1
#define | MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MIN 1000
#define | MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MAX 60000

## SECTION: Module settings

The configuration options you can set for this module are in this section. Either change them in config.h or define them on the compiler command line.
#define | MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME 86400
#define | MBEDTLS_SSL_MAX_CONTENT_LEN 16384
#define | MBEDTLS_SSL_IN_CONTENT_LEN MBEDTLS_SSL_MAX_CONTENT_LEN
#define | MBEDTLS_SSL_OUT_CONTENT_LEN MBEDTLS_SSL_MAX_CONTENT_LEN
#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_PADDING_GRANULARITY 16
#define | MBEDTLS_SSL_TLS1_3_PADDING_GRANULARITY 1
#define | MBEDTLS_SSL_VERIFY_DATA_MAX_LEN 12
#define | MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO 0xFF
#define | MBEDTLS_SSL_FALLBACK_SCSV_VALUE 0x5600
#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_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_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_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_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_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_SUPPORTED_ELLIPTIC_CURVES 10
#define | MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS 11
#define | MBEDTLS_TLS_EXT_SIG_ALG 13
#define | MBEDTLS_TLS_EXT_USE_SRTP 14
#define | MBEDTLS_TLS_EXT_ALPN 16
#define | MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC 22 /* 0x16 */
#define | MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET 0x0017 /* 23 */
#define | MBEDTLS_TLS_EXT_SESSION_TICKET 35
#define | MBEDTLS_TLS_EXT_CID 254 /* TBD */
#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_TLS_SRTP_MAX_MKI_LENGTH 255
#define | MBEDTLS_TLS_SRTP_MAX_PROFILE_LIST_LENGTH 4
#define | MBEDTLS_TLS_SRTP_AES128_CM_HMAC_SHA1_80 ( (uint16_t) 0x0001)
#define | MBEDTLS_TLS_SRTP_AES128_CM_HMAC_SHA1_32 ( (uint16_t) 0x0002)
#define | MBEDTLS_TLS_SRTP_NULL_HMAC_SHA1_80 ( (uint16_t) 0x0005)
#define | MBEDTLS_TLS_SRTP_NULL_HMAC_SHA1_32 ( (uint16_t) 0x0006)
#define | MBEDTLS_TLS_SRTP_UNSET ( (uint16_t) 0x0000)
#define | MBEDTLS_DEPRECATED __attribute__((deprecated))
#define | MBEDTLS_DEPRECATED __attribute__((deprecated))

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_HANDSHAKE_OVER , MBEDTLS_SSL_SERVER_NEW_SESSION_TICKET , MBEDTLS_SSL_SERVER_HELLO_VERIFY_REQUEST_SENT
}

enum | mbedtls_tls_prf_types { MBEDTLS_SSL_TLS_PRF_NONE , MBEDTLS_SSL_TLS_PRF_SSL3 , MBEDTLS_SSL_TLS_PRF_TLS1 , MBEDTLS_SSL_TLS_PRF_SHA384 , MBEDTLS_SSL_TLS_PRF_SHA256 }
typedef int | mbedtls_ssl_send_t(void *ctx, const unsigned char *buf, size_t len)
| Callback type: send data on the network. More...
typedef int | mbedtls_ssl_recv_t(void *ctx, unsigned char *buf, size_t len)
| Callback type: receive data from the network. More...
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. More...
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. More...
typedef int | mbedtls_ssl_get_timer_t(void *ctx)
| Callback type: get status of timers/delays. More...
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 struct mbedtls_ssl_key_cert | mbedtls_ssl_key_cert
typedef struct mbedtls_ssl_flight_item | mbedtls_ssl_flight_item
typedef uint16_t | mbedtls_ssl_srtp_profile
typedef struct mbedtls_dtls_srtp_info_t | mbedtls_dtls_srtp_info
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. More...
typedef int | mbedtls_ssl_export_keys_t(void *p_expkey, const unsigned char *ms, const unsigned char *kb, size_t maclen, size_t keylen, size_t ivlen)
| Callback type: Export key block and master secret. More...
typedef int | mbedtls_ssl_export_keys_ext_t(void *p_expkey, const unsigned char *ms, const unsigned char *kb, size_t maclen, size_t keylen, size_t ivlen, const unsigned char client_random[32], const unsigned char server_random[32], mbedtls_tls_prf_types tls_prf_type)
| Callback type: Export key block, master secret, handshake randbytes and the tls_prf function used to derive keys. More...
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. More...
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. More...
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. More...
const char * | mbedtls_ssl_get_ciphersuite_name (const int ciphersuite_id)
| Return the name of the ciphersuite associated with the given ID. More...
int | mbedtls_ssl_get_ciphersuite_id (const char *ciphersuite_name)
| Return the ID of the ciphersuite associated with the given name. More...
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() More...
int | mbedtls_ssl_setup (mbedtls_ssl_context *ssl, const mbedtls_ssl_config *conf)
| Set up an SSL context for use. More...
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. More...
void | mbedtls_ssl_conf_endpoint (mbedtls_ssl_config *conf, int endpoint)
| Set the current endpoint type. More...
void | mbedtls_ssl_conf_transport (mbedtls_ssl_config *conf, int transport)
| Set the transport type (TLS or DTLS). Default: TLS. More...
void | mbedtls_ssl_conf_authmode (mbedtls_ssl_config *conf, int authmode)
| Set the certificate verification mode Default: NONE on server, REQUIRED on client. More...
void | mbedtls_ssl_conf_verify (mbedtls_ssl_config *conf, int(*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *), void *p_vrfy)
| Set the verification callback (Optional). More...
void | mbedtls_ssl_conf_rng (mbedtls_ssl_config *conf, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
| Set the random number generator callback. More...
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. More...
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. More...
void | mbedtls_ssl_set_mtu (mbedtls_ssl_context *ssl, uint16_t mtu)
| Set the Maximum Tranport Unit (MTU). Special value: 0 means unset (no limit). This represents the maximum size of a datagram payload handled by the transport layer (usually UDP) as determined by the network link and stack. In practice, this controls the maximum size datagram the DTLS layer will pass to the `f_send()` callback set using `mbedtls_ssl_set_bio()`. More...
void | mbedtls_ssl_set_verify (mbedtls_ssl_context *ssl, int(*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *), void *p_vrfy)
| Set a connection-specific verification callback (optional). More...
void | mbedtls_ssl_conf_read_timeout (mbedtls_ssl_config *conf, uint32_t timeout)
| Set the timeout period for mbedtls_ssl_read() (Default: no timeout.) More...
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). More...
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.) More...
void | mbedtls_ssl_conf_session_tickets_cb (mbedtls_ssl_config *conf, mbedtls_ssl_ticket_write_t *f_ticket_write, mbedtls_ssl_ticket_parse_t *f_ticket_parse, void *p_ticket)
| Configure SSL session ticket callbacks (server only). (Default: none.) More...
void | mbedtls_ssl_conf_export_keys_cb (mbedtls_ssl_config *conf, mbedtls_ssl_export_keys_t *f_export_keys, void *p_export_keys)
| Configure key export callback. (Default: none.) More...
void | mbedtls_ssl_conf_export_keys_ext_cb (mbedtls_ssl_config *conf, mbedtls_ssl_export_keys_ext_t *f_export_keys_ext, void *p_export_keys)
| Configure extended key export callback. (Default: none.) More...
void | mbedtls_ssl_conf_dtls_cookies (mbedtls_ssl_config *conf, mbedtls_ssl_cookie_write_t *f_cookie_write, mbedtls_ssl_cookie_check_t *f_cookie_check, void *p_cookie)
| Register callbacks for DTLS cookies (Server only. DTLS only.) More...
int | mbedtls_ssl_set_client_transport_id (mbedtls_ssl_context *ssl, const unsigned char *info, size_t ilen)
| Set client's transport-level identification info. (Server only. DTLS only.) More...
void | mbedtls_ssl_conf_dtls_anti_replay (mbedtls_ssl_config *conf, char mode)
| Enable or disable anti-replay protection for DTLS. (DTLS only, no effect on TLS.) Default: enabled. More...
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). More...
void | mbedtls_ssl_set_datagram_packing (mbedtls_ssl_context *ssl, unsigned allow_packing)
| Allow or disallow packing of multiple handshake records within a single datagram. More...
void | mbedtls_ssl_conf_handshake_timeout (mbedtls_ssl_config *conf, uint32_t min, uint32_t max)
| Set retransmit timeout values for the DTLS handshake. (DTLS only, no effect on TLS.) More...
void | mbedtls_ssl_conf_session_cache (mbedtls_ssl_config *conf, void *p_cache, int(*f_get_cache)(void *, mbedtls_ssl_session *), int(*f_set_cache)(void *, const mbedtls_ssl_session *))
| Set the session cache callbacks (server-side only) If not set, no session resuming is done (except if session tickets are enabled too). More...
int | mbedtls_ssl_set_session (mbedtls_ssl_context *ssl, const mbedtls_ssl_session *session)
| Request resumption of session (client-side only) Session data is copied from presented session structure. More...
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 mbedstls_ssl_set_session(). On server, this can be used for alternative implementations of session cache or session tickets. More...
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. More...
const mbedtls_ssl_session * | mbedtls_ssl_get_session_pointer (const mbedtls_ssl_context *ssl)
| Get a pointer to the current session structure, for example to serialize it. More...
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. (Overrides all version-specific lists) More...
void | mbedtls_ssl_conf_ciphersuites_for_version (mbedtls_ssl_config *conf, const int *ciphersuites, int major, int minor)
| Set the list of allowed ciphersuites and the preference order for a specific version of the protocol. (Only useful on the server side) More...
void | mbedtls_ssl_conf_cert_profile (mbedtls_ssl_config *conf, const mbedtls_x509_crt_profile *profile)
| Set the X.509 security profile used for verification. More...
void | mbedtls_ssl_conf_ca_chain (mbedtls_ssl_config *conf, mbedtls_x509_crt *ca_chain, mbedtls_x509_crl *ca_crl)
| Set the data required to verify peer certificate. More...
int | mbedtls_ssl_conf_own_cert (mbedtls_ssl_config *conf, mbedtls_x509_crt *own_cert, mbedtls_pk_context *pk_key)
| Set own certificate chain and private key. More...
int | mbedtls_ssl_conf_psk (mbedtls_ssl_config *conf, const unsigned char *psk, size_t psk_len, const unsigned char *psk_identity, size_t psk_identity_len)
| Configure a pre-shared key (PSK) and identity to be used in PSK-based ciphersuites. More...
int | mbedtls_ssl_set_hs_psk (mbedtls_ssl_context *ssl, const unsigned char *psk, size_t psk_len)
| Set the pre-shared Key (PSK) for the current handshake. More...
void | mbedtls_ssl_conf_psk_cb (mbedtls_ssl_config *conf, int(*f_psk)(void *, mbedtls_ssl_context *, const unsigned char *, size_t), void *p_psk)
| Set the PSK callback (server-side only). More...
MBEDTLS_DEPRECATED int | mbedtls_ssl_conf_dh_param (mbedtls_ssl_config *conf, const char *dhm_P, const char *dhm_G)
| Set the Diffie-Hellman public P and G values, read as hexadecimal strings (server-side only) (Default values: MBEDTLS_DHM_RFC3526_MODP_2048_[PG]) More...
int | mbedtls_ssl_conf_dh_param_bin (mbedtls_ssl_config *conf, const unsigned char *dhm_P, size_t P_len, const unsigned char *dhm_G, size_t G_len)
| Set the Diffie-Hellman public P and G values from big-endian binary presentations. (Default values: MBEDTLS_DHM_RFC3526_MODP_2048_[PG]_BIN) More...
int | mbedtls_ssl_conf_dh_param_ctx (mbedtls_ssl_config *conf, mbedtls_dhm_context *dhm_ctx)
| Set the Diffie-Hellman public P and G values, read from existing context (server-side only) More...
void | mbedtls_ssl_conf_dhm_min_bitlen (mbedtls_ssl_config *conf, unsigned int bitlen)
| Set the minimum length for Diffie-Hellman parameters. (Client-side only.) (Default: 1024 bits.) More...
void | mbedtls_ssl_conf_curves (mbedtls_ssl_config *conf, const mbedtls_ecp_group_id *curves)
| Set the allowed curves in order of preference. (Default: all defined curves in order of decreasing size, except that Montgomery curves come last. This order is likely to change in a future version.) More...
void | mbedtls_ssl_conf_sig_hashes (mbedtls_ssl_config *conf, const int *hashes)
| Set the allowed hashes for signatures during the handshake. (Default: all SHA-2 hashes, largest first. Also SHA-1 if the compile-time option `MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_KEY_EXCHANGE` is enabled.) More...
int | mbedtls_ssl_set_hostname (mbedtls_ssl_context *ssl, const char *hostname)
| Set or reset the hostname to check against the received server certificate. It sets the ServerName TLS extension, too, if that extension is enabled. (client-side only) More...
int | mbedtls_ssl_set_hs_own_cert (mbedtls_ssl_context *ssl, mbedtls_x509_crt *own_cert, mbedtls_pk_context *pk_key)
| Set own certificate and key for the current handshake. More...
void | mbedtls_ssl_set_hs_ca_chain (mbedtls_ssl_context *ssl, mbedtls_x509_crt *ca_chain, mbedtls_x509_crl *ca_crl)
| Set the data required to verify peer certificate for the current handshake. More...
void | mbedtls_ssl_set_hs_authmode (mbedtls_ssl_context *ssl, int authmode)
| Set authmode for the current handshake. More...
void | mbedtls_ssl_conf_sni (mbedtls_ssl_config *conf, int(*f_sni)(void *, mbedtls_ssl_context *, const unsigned char *, size_t), void *p_sni)
| Set server side ServerName TLS extension callback (optional, server-side only). More...
int | mbedtls_ssl_conf_alpn_protocols (mbedtls_ssl_config *conf, const char **protos)
| Set the supported Application Layer Protocols. More...
const char * | mbedtls_ssl_get_alpn_protocol (const mbedtls_ssl_context *ssl)
| Get the name of the negotiated Application Layer Protocol. This function should be called after the handshake is completed. More...
static const char * | mbedtls_ssl_get_srtp_profile_as_string (mbedtls_ssl_srtp_profile profile)
void | mbedtls_ssl_conf_srtp_mki_value_supported (mbedtls_ssl_config *conf, int support_mki_value)
| Manage support for mki(master key id) value in use_srtp extension. MKI is an optional part of SRTP used for key management and re-keying. See RFC3711 section 3.1 for details. The default value is MBEDTLS_SSL_DTLS_SRTP_MKI_UNSUPPORTED. More...
int | mbedtls_ssl_conf_dtls_srtp_protection_profiles (mbedtls_ssl_config *conf, const mbedtls_ssl_srtp_profile *profiles)
| Set the supported DTLS-SRTP protection profiles. More...
int | mbedtls_ssl_dtls_srtp_set_mki_value (mbedtls_ssl_context *ssl, unsigned char *mki_value, uint16_t mki_len)
| Set the mki_value for the current DTLS-SRTP session. More...
void | mbedtls_ssl_get_dtls_srtp_negotiation_result (const mbedtls_ssl_context *ssl, mbedtls_dtls_srtp_info *dtls_srtp_info)
| Get the negotiated DTLS-SRTP informations: Protection profile and MKI value. More...
void | 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 (Default: MBEDTLS_SSL_MAX_MAJOR_VERSION, MBEDTLS_SSL_MAX_MINOR_VERSION) More...
void | mbedtls_ssl_conf_min_version (mbedtls_ssl_config *conf, int major, int minor)
| Set the minimum accepted SSL/TLS protocol version (Default: TLS 1.0) More...
void | mbedtls_ssl_conf_fallback (mbedtls_ssl_config *conf, char fallback)
| Set the fallback flag (client-side only). (Default: MBEDTLS_SSL_IS_NOT_FALLBACK). More...
void | mbedtls_ssl_conf_encrypt_then_mac (mbedtls_ssl_config *conf, char etm)
| Enable or disable Encrypt-then-MAC (Default: MBEDTLS_SSL_ETM_ENABLED) More...
void | mbedtls_ssl_conf_extended_master_secret (mbedtls_ssl_config *conf, char ems)
| Enable or disable Extended Master Secret negotiation. (Default: MBEDTLS_SSL_EXTENDED_MS_ENABLED) More...
void | mbedtls_ssl_conf_arc4_support (mbedtls_ssl_config *conf, char arc4)
| Disable or enable support for RC4 (Default: MBEDTLS_SSL_ARC4_DISABLED) More...
void | mbedtls_ssl_conf_cert_req_ca_list (mbedtls_ssl_config *conf, char cert_req_ca_list)
| Whether to send a list of acceptable CAs in CertificateRequest messages. (Default: do send) More...
int | mbedtls_ssl_conf_max_frag_len (mbedtls_ssl_config *conf, unsigned char mfl_code)

Set the maximum fragment length to emit and/or negotiate. (Typical: the smaller of MBEDTLS_SSL_IN_CONTENT_LEN and MBEDTLS_SSL_OUT_CONTENT_LEN, usually `2^14` bytes) (Server: set maximum fragment length to emit, usually negotiated by the client during handshake) (Client: set maximum fragment length to emit and negotiate with the server during handshake) (Default: MBEDTLS_SSL_MAX_FRAG_LEN_NONE) More...

void | mbedtls_ssl_conf_truncated_hmac (mbedtls_ssl_config *conf, int truncate)
| Activate negotiation of truncated HMAC (Default: MBEDTLS_SSL_TRUNC_HMAC_DISABLED) More...
void | mbedtls_ssl_conf_cbc_record_splitting (mbedtls_ssl_config *conf, char split)
| Enable / Disable 1/n-1 record splitting (Default: MBEDTLS_SSL_CBC_RECORD_SPLITTING_ENABLED) More...
void | mbedtls_ssl_conf_session_tickets (mbedtls_ssl_config *conf, int use_tickets)
| Enable / Disable session tickets (client only). (Default: MBEDTLS_SSL_SESSION_TICKETS_ENABLED.) More...
void | mbedtls_ssl_conf_renegotiation (mbedtls_ssl_config *conf, int renegotiation)
| Enable / Disable renegotiation support for connection when initiated by peer (Default: MBEDTLS_SSL_RENEGOTIATION_DISABLED) More...
void | mbedtls_ssl_conf_legacy_renegotiation (mbedtls_ssl_config *conf, int allow_legacy)
| Prevent or allow legacy renegotiation. (Default: MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION) More...
void | mbedtls_ssl_conf_renegotiation_enforced (mbedtls_ssl_config *conf, int max_records)
| Enforce renegotiation requests. (Default: enforced, max_records = 16) More...
void | mbedtls_ssl_conf_renegotiation_period (mbedtls_ssl_config *conf, const unsigned char period[8])
| Set record counter threshold for periodic renegotiation. (Default: 2^48 - 1) More...
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. More...
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. More...
uint32_t | mbedtls_ssl_get_verify_result (const mbedtls_ssl_context *ssl)
| Return the result of the certificate verification. More...
const char * | mbedtls_ssl_get_ciphersuite (const mbedtls_ssl_context *ssl)
| Return the name of the current ciphersuite. More...
const char * | mbedtls_ssl_get_version (const mbedtls_ssl_context *ssl)
| Return the current SSL version (SSLv3/TLSv1/etc) More...
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) More...
size_t | mbedtls_ssl_get_output_max_frag_len (const mbedtls_ssl_context *ssl)
| Return the maximum fragment length (payload, in bytes) for the output buffer. For the client, this is the configured value. For the server, it is the minimum of two - the configured value and the negotiated one. More...
size_t | mbedtls_ssl_get_input_max_frag_len (const mbedtls_ssl_context *ssl)
| Return the maximum fragment length (payload, in bytes) for the input buffer. This is the negotiated maximum fragment length, or, if there is none, MBEDTLS_SSL_MAX_CONTENT_LEN. If it is not defined either, the value is 2^14. This function works as its predecessor, `mbedtls_ssl_get_max_frag_len()`. More...
MBEDTLS_DEPRECATED size_t | mbedtls_ssl_get_max_frag_len (const mbedtls_ssl_context *ssl)
| This function is a deprecated approach to getting the max fragment length. Its an alias for `mbedtls_ssl_get_output_max_frag_len()`, as the behaviour is the same. See `mbedtls_ssl_get_output_max_frag_len()` for more detail. More...
int | mbedtls_ssl_get_max_out_record_payload (const mbedtls_ssl_context *ssl)
| Return the current maximum outgoing record payload in bytes. This takes into account the config.h setting `MBEDTLS_SSL_OUT_CONTENT_LEN`, the configured and negotiated max fragment length extension if used, and for DTLS the path MTU as configured and current record expansion. More...
const mbedtls_x509_crt * | mbedtls_ssl_get_peer_cert (const mbedtls_ssl_context *ssl)
| Return the peer certificate from the current connection. More...
int | mbedtls_ssl_get_session (const mbedtls_ssl_context *ssl, mbedtls_ssl_session *session)
| Save session in order to resume it later (client-side only) Session data is copied to presented session structure. More...
int | mbedtls_ssl_handshake (mbedtls_ssl_context *ssl)
| Perform the SSL handshake. More...
int | mbedtls_ssl_handshake_step (mbedtls_ssl_context *ssl)
| Perform a single step of the SSL handshake. More...
int | mbedtls_ssl_renegotiate (mbedtls_ssl_context *ssl)
| Initiate an SSL renegotiation on the running connection. Client: perform the renegotiation right now. Server: request renegotiation, which will be performed during the next call to mbedtls_ssl_read() if honored by client. More...
int | mbedtls_ssl_read (mbedtls_ssl_context *ssl, unsigned char *buf, size_t len)
| Read at most 'len' application data bytes. More...
int | mbedtls_ssl_write (mbedtls_ssl_context *ssl, const unsigned char *buf, size_t len)
| Try to write exactly 'len' application data bytes. More...
int | mbedtls_ssl_send_alert_message (mbedtls_ssl_context *ssl, unsigned char level, unsigned char message)
| Send an alert message. More...
int | mbedtls_ssl_close_notify (mbedtls_ssl_context *ssl)
| Notify the peer that the connection is being closed. More...
void | mbedtls_ssl_free (mbedtls_ssl_context *ssl)
| Free referenced items in an SSL context and clear memory. More...
int | mbedtls_ssl_context_save (mbedtls_ssl_context *ssl, unsigned char *buf, size_t buf_len, size_t *olen)
| Save an active connection as serialized data in a buffer. This allows the freeing or re-using of the SSL context while still picking up the connection later in a way that it entirely transparent to the peer. More...
int | mbedtls_ssl_context_load (mbedtls_ssl_context *ssl, const unsigned char *buf, size_t len)
| Load serialized connection data to an SSL context. More...
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(). More...
int | mbedtls_ssl_config_defaults (mbedtls_ssl_config *conf, int endpoint, int transport, int preset)
| Load reasonnable default SSL configuration values. (You need to call mbedtls_ssl_config_init() first.) More...
void | mbedtls_ssl_config_free (mbedtls_ssl_config *conf)
| Free an SSL configuration context. More...
void | mbedtls_ssl_session_init (mbedtls_ssl_session *session)
| Initialize SSL session structure. More...
void | mbedtls_ssl_session_free (mbedtls_ssl_session *session)
| Free referenced items in an SSL session including the peer certificate and clear memory. More...
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. More...

## Detailed Description

SSL/TLS functions.

Definition in file ssl.h.

## Macro Definition Documentation

## MBEDTLS_DEPRECATED [1/2]

#define MBEDTLS_DEPRECATED __attribute__((deprecated))

Definition at line 3823 of file ssl.h.

## MBEDTLS_DEPRECATED [2/2]

#define MBEDTLS_DEPRECATED __attribute__((deprecated))

Definition at line 3823 of file ssl.h.

## MBEDTLS_ERR_SSL_ALLOC_FAILED

#define MBEDTLS_ERR_SSL_ALLOC_FAILED -0x7F00

Memory allocation failed

Definition at line 137 of file ssl.h.

## MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS

#define MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS -0x6500

The asynchronous operation is not completed yet.

Definition at line 183 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_CONFIG

#define MBEDTLS_ERR_SSL_BAD_CONFIG -0x5E80

Invalid value in SSL config

Definition at line 193 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE

#define MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE -0x7A00

Processing of the Certificate handshake message failed.

Definition at line 117 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST

#define MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST -0x7A80

Processing of the CertificateRequest handshake message failed.

Definition at line 119 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY

#define MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY -0x7D80

Processing of the CertificateVerify handshake message failed.

Definition at line 131 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC

#define MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC -0x7E00

Processing of the ChangeCipherSpec handshake message failed.

Definition at line 133 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO

#define MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO -0x7900

Processing of the ClientHello handshake message failed.

Definition at line 113 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE

#define MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE -0x7C00

Processing of the ClientKeyExchange handshake message failed.

Definition at line 125 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS

#define MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS -0x7D00

Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Calculate Secret.

Definition at line 129 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP

#define MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP -0x7C80

Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Read Public.

Definition at line 127 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_FINISHED

#define MBEDTLS_ERR_SSL_BAD_HS_FINISHED -0x7E80

Processing of the Finished handshake message failed.

Definition at line 135 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET

#define MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET -0x6E00

Processing of the NewSessionTicket handshake message failed.

Definition at line 147 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION

#define MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION -0x6E80

Handshake protocol not within min/max boundaries

Definition at line 145 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO

#define MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO -0x7980

Processing of the ServerHello handshake message failed.

Definition at line 115 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE

#define MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE -0x7B80

Processing of the ServerHelloDone handshake message failed.

Definition at line 123 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE

#define MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE -0x7B00

Processing of the ServerKeyExchange handshake message failed.

Definition at line 121 of file ssl.h.

## MBEDTLS_ERR_SSL_BAD_INPUT_DATA

#define MBEDTLS_ERR_SSL_BAD_INPUT_DATA -0x7100

Bad input parameters to function.

Definition at line 81 of file ssl.h.

## 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

Definition at line 163 of file ssl.h.

## MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED

#define MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED -0x7680

No CA Chain is set, but required to operate.

Definition at line 103 of file ssl.h.

## MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED

#define MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED -0x7580

The own certificate is not set, but needed by the server.

Definition at line 99 of file ssl.h.

## MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE

#define MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE -0x7500

Our own certificate(s) is/are too large to send in an SSL message.

Definition at line 97 of file ssl.h.

## MBEDTLS_ERR_SSL_CLIENT_RECONNECT

#define MBEDTLS_ERR_SSL_CLIENT_RECONNECT -0x6780

The client initiated a reconnect from the same port.

Definition at line 173 of file ssl.h.

## MBEDTLS_ERR_SSL_COMPRESSION_FAILED

#define MBEDTLS_ERR_SSL_COMPRESSION_FAILED -0x6F00

Processing of the compression / decompression failed

Definition at line 143 of file ssl.h.

## MBEDTLS_ERR_SSL_CONN_EOF

#define MBEDTLS_ERR_SSL_CONN_EOF -0x7280

The connection indicated an EOF.

Definition at line 87 of file ssl.h.

## MBEDTLS_ERR_SSL_CONTINUE_PROCESSING

#define MBEDTLS_ERR_SSL_CONTINUE_PROCESSING -0x6580

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

Definition at line 181 of file ssl.h.

## MBEDTLS_ERR_SSL_COUNTER_WRAPPING

#define MBEDTLS_ERR_SSL_COUNTER_WRAPPING -0x6B80

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

Definition at line 157 of file ssl.h.

## MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS

#define MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS -0x7000

A cryptographic operation is in progress. Try again later.

Definition at line 191 of file ssl.h.

## MBEDTLS_ERR_SSL_EARLY_MESSAGE

#define MBEDTLS_ERR_SSL_EARLY_MESSAGE -0x6480

Internal-only message signaling that a message arrived early.

Definition at line 185 of file ssl.h.

## MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE

#define MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE -0x7780

A fatal alert message was received from our peer.

Definition at line 107 of file ssl.h.

## MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE

#define MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE -0x7080

The requested feature is not available.

Definition at line 79 of file ssl.h.

## MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED

#define MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED -0x6A80

DTLS client must retry for hello verification

Definition at line 161 of file ssl.h.

## MBEDTLS_ERR_SSL_HW_ACCEL_FAILED

#define MBEDTLS_ERR_SSL_HW_ACCEL_FAILED -0x7F80

Hardware acceleration function returned with error

Definition at line 139 of file ssl.h.

## MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH

#define MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH -0x6F80

Hardware acceleration function skipped / left alone data

Definition at line 141 of file ssl.h.

## MBEDTLS_ERR_SSL_INTERNAL_ERROR

#define MBEDTLS_ERR_SSL_INTERNAL_ERROR -0x6C00

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

Definition at line 155 of file ssl.h.

## MBEDTLS_ERR_SSL_INVALID_MAC

#define MBEDTLS_ERR_SSL_INVALID_MAC -0x7180

Verification of the message MAC failed.

Definition at line 83 of file ssl.h.

## MBEDTLS_ERR_SSL_INVALID_RECORD

#define MBEDTLS_ERR_SSL_INVALID_RECORD -0x7200

An invalid SSL record was received.

Definition at line 85 of file ssl.h.

## MBEDTLS_ERR_SSL_INVALID_VERIFY_HASH

#define MBEDTLS_ERR_SSL_INVALID_VERIFY_HASH -0x6600

Couldn't set the hash for verifying CertificateVerify

Definition at line 179 of file ssl.h.

## MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN

#define MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN -0x7380

The server has no ciphersuites in common with the client.

Definition at line 91 of file ssl.h.

## 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.

Definition at line 95 of file ssl.h.

## MBEDTLS_ERR_SSL_NO_RNG

#define MBEDTLS_ERR_SSL_NO_RNG -0x7400

No RNG was provided to the SSL module.

Definition at line 93 of file ssl.h.

## MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE

#define MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE -0x6980

None of the common ciphersuites is usable (eg, no suitable certificate, see debug messages).

Definition at line 165 of file ssl.h.

## MBEDTLS_ERR_SSL_NON_FATAL

#define MBEDTLS_ERR_SSL_NON_FATAL -0x6680

The alert message received indicates a non-fatal error.

Definition at line 177 of file ssl.h.

## 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.

Definition at line 111 of file ssl.h.

## MBEDTLS_ERR_SSL_PEER_VERIFY_FAILED

#define MBEDTLS_ERR_SSL_PEER_VERIFY_FAILED -0x7800

Verification of our peer failed.

Definition at line 109 of file ssl.h.

## 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)

Definition at line 151 of file ssl.h.

## 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.

Definition at line 101 of file ssl.h.

## MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED

#define MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED -0x6D80

Session ticket has expired.

Definition at line 149 of file ssl.h.

## MBEDTLS_ERR_SSL_TIMEOUT

#define MBEDTLS_ERR_SSL_TIMEOUT -0x6800

The operation timed out.

Definition at line 171 of file ssl.h.

## MBEDTLS_ERR_SSL_UNEXPECTED_CID

#define MBEDTLS_ERR_SSL_UNEXPECTED_CID -0x6000

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

Definition at line 187 of file ssl.h.

## MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE

#define MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE -0x7700

An unexpected message was received from our peer.

Definition at line 105 of file ssl.h.

## MBEDTLS_ERR_SSL_UNEXPECTED_RECORD

#define MBEDTLS_ERR_SSL_UNEXPECTED_RECORD -0x6700

Record header looks valid but is not expected.

Definition at line 175 of file ssl.h.

## MBEDTLS_ERR_SSL_UNKNOWN_CIPHER

#define MBEDTLS_ERR_SSL_UNKNOWN_CIPHER -0x7300

An unknown cipher was received.

Definition at line 89 of file ssl.h.

## MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY

#define MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY -0x6C80

Unknown identity received (eg, PSK identity)

Definition at line 153 of file ssl.h.

## MBEDTLS_ERR_SSL_VERSION_MISMATCH

#define MBEDTLS_ERR_SSL_VERSION_MISMATCH -0x5F00

An operation failed due to an unexpected version or configuration.

Definition at line 189 of file ssl.h.

## MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO

#define MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO -0x6B00

Unexpected message at ServerHello in renegotiation.

Definition at line 159 of file ssl.h.

## MBEDTLS_ERR_SSL_WANT_READ

#define MBEDTLS_ERR_SSL_WANT_READ -0x6900

No data of requested type currently available on underlying transport.

Definition at line 167 of file ssl.h.

## MBEDTLS_ERR_SSL_WANT_WRITE

#define MBEDTLS_ERR_SSL_WANT_WRITE -0x6880

Connection requires a write call.

Definition at line 169 of file ssl.h.

## MBEDTLS_PREMASTER_SIZE

#define MBEDTLS_PREMASTER_SIZE sizeof( union mbedtls_ssl_premaster_secret )

Definition at line 527 of file ssl.h.

## MBEDTLS_PSK_MAX_LEN

#define MBEDTLS_PSK_MAX_LEN 32 /* 256 bits */

Definition at line 490 of file ssl.h.

## MBEDTLS_SSL_ALERT_LEVEL_FATAL

#define MBEDTLS_SSL_ALERT_LEVEL_FATAL 2

Definition at line 402 of file ssl.h.

## MBEDTLS_SSL_ALERT_LEVEL_WARNING

#define MBEDTLS_SSL_ALERT_LEVEL_WARNING 1

Definition at line 401 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_ACCESS_DENIED

#define MBEDTLS_SSL_ALERT_MSG_ACCESS_DENIED 49 /* 0x31 */

Definition at line 419 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_BAD_CERT

#define MBEDTLS_SSL_ALERT_MSG_BAD_CERT 42 /* 0x2A */

Definition at line 412 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_BAD_RECORD_MAC

#define MBEDTLS_SSL_ALERT_MSG_BAD_RECORD_MAC 20 /* 0x14 */

Definition at line 406 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_CERT_EXPIRED

#define MBEDTLS_SSL_ALERT_MSG_CERT_EXPIRED 45 /* 0x2D */

Definition at line 415 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_CERT_REVOKED

#define MBEDTLS_SSL_ALERT_MSG_CERT_REVOKED 44 /* 0x2C */

Definition at line 414 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN

#define MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN 46 /* 0x2E */

Definition at line 416 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY

#define MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY 0 /* 0x00 */

Definition at line 404 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR

#define MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR 50 /* 0x32 */

Definition at line 420 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_DECOMPRESSION_FAILURE

#define MBEDTLS_SSL_ALERT_MSG_DECOMPRESSION_FAILURE 30 /* 0x1E */

Definition at line 409 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_DECRYPT_ERROR

#define MBEDTLS_SSL_ALERT_MSG_DECRYPT_ERROR 51 /* 0x33 */

Definition at line 421 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_DECRYPTION_FAILED

#define MBEDTLS_SSL_ALERT_MSG_DECRYPTION_FAILED 21 /* 0x15 */

Definition at line 407 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_EXPORT_RESTRICTION

#define MBEDTLS_SSL_ALERT_MSG_EXPORT_RESTRICTION 60 /* 0x3C */

Definition at line 422 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE

#define MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE 40 /* 0x28 */

Definition at line 410 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER

#define MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER 47 /* 0x2F */

Definition at line 417 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK

#define MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK 86 /* 0x56 */

Definition at line 426 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY

#define MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY 71 /* 0x47 */

Definition at line 424 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR

#define MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR 80 /* 0x50 */

Definition at line 425 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL

#define MBEDTLS_SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL 120 /* 0x78 */

Definition at line 432 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_NO_CERT

#define MBEDTLS_SSL_ALERT_MSG_NO_CERT 41 /* 0x29 */

Definition at line 411 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_NO_RENEGOTIATION

#define MBEDTLS_SSL_ALERT_MSG_NO_RENEGOTIATION 100 /* 0x64 */

Definition at line 428 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION

#define MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION 70 /* 0x46 */

Definition at line 423 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_RECORD_OVERFLOW

#define MBEDTLS_SSL_ALERT_MSG_RECORD_OVERFLOW 22 /* 0x16 */

Definition at line 408 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE

#define MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE 10 /* 0x0A */

Definition at line 405 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA

#define MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA 48 /* 0x30 */

Definition at line 418 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_UNKNOWN_PSK_IDENTITY

#define MBEDTLS_SSL_ALERT_MSG_UNKNOWN_PSK_IDENTITY 115 /* 0x73 */

Definition at line 431 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_UNRECOGNIZED_NAME

#define MBEDTLS_SSL_ALERT_MSG_UNRECOGNIZED_NAME 112 /* 0x70 */

Definition at line 430 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT

#define MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT 43 /* 0x2B */

Definition at line 413 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT

#define MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT 110 /* 0x6E */

Definition at line 429 of file ssl.h.

## MBEDTLS_SSL_ALERT_MSG_USER_CANCELED

#define MBEDTLS_SSL_ALERT_MSG_USER_CANCELED 90 /* 0x5A */

Definition at line 427 of file ssl.h.

## MBEDTLS_SSL_ANTI_REPLAY_DISABLED

#define MBEDTLS_SSL_ANTI_REPLAY_DISABLED 0

Definition at line 251 of file ssl.h.

## MBEDTLS_SSL_ANTI_REPLAY_ENABLED

#define MBEDTLS_SSL_ANTI_REPLAY_ENABLED 1

Definition at line 252 of file ssl.h.

## MBEDTLS_SSL_ARC4_DISABLED

#define MBEDTLS_SSL_ARC4_DISABLED 1

Definition at line 272 of file ssl.h.

## MBEDTLS_SSL_ARC4_ENABLED

#define MBEDTLS_SSL_ARC4_ENABLED 0

Definition at line 271 of file ssl.h.

## MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED

#define MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED 0

Definition at line 268 of file ssl.h.

## MBEDTLS_SSL_CBC_RECORD_SPLITTING_ENABLED

#define MBEDTLS_SSL_CBC_RECORD_SPLITTING_ENABLED 1

Definition at line 269 of file ssl.h.

## MBEDTLS_SSL_CERT_REQ_CA_LIST_DISABLED

#define MBEDTLS_SSL_CERT_REQ_CA_LIST_DISABLED 0

Definition at line 278 of file ssl.h.

## MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED

#define MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED 1

Definition at line 277 of file ssl.h.

## MBEDTLS_SSL_CERT_TYPE_ECDSA_SIGN

#define MBEDTLS_SSL_CERT_TYPE_ECDSA_SIGN 64

Definition at line 390 of file ssl.h.

## MBEDTLS_SSL_CERT_TYPE_RSA_SIGN

#define MBEDTLS_SSL_CERT_TYPE_RSA_SIGN 1

Definition at line 389 of file ssl.h.

## MBEDTLS_SSL_CID_DISABLED

#define MBEDTLS_SSL_CID_DISABLED 0

Definition at line 231 of file ssl.h.

## MBEDTLS_SSL_CID_ENABLED

#define MBEDTLS_SSL_CID_ENABLED 1

Definition at line 232 of file ssl.h.

## MBEDTLS_SSL_CID_IN_LEN_MAX

#define MBEDTLS_SSL_CID_IN_LEN_MAX 32

The maximum length of CIDs used for incoming DTLS messages.

Definition at line 337 of file ssl.h.

## MBEDTLS_SSL_CID_OUT_LEN_MAX

#define MBEDTLS_SSL_CID_OUT_LEN_MAX 32

The maximum length of CIDs used for outgoing DTLS messages.

Definition at line 341 of file ssl.h.

## MBEDTLS_SSL_CID_PADDING_GRANULARITY

#define MBEDTLS_SSL_CID_PADDING_GRANULARITY 16

This option controls the use of record plaintext padding 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.

Definition at line 345 of file ssl.h.

## MBEDTLS_SSL_COMPRESS_DEFLATE

#define MBEDTLS_SSL_COMPRESS_DEFLATE 1

Definition at line 238 of file ssl.h.

## MBEDTLS_SSL_COMPRESS_NULL

#define MBEDTLS_SSL_COMPRESS_NULL 0

Definition at line 237 of file ssl.h.

## MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME

#define MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME 86400

Lifetime of session tickets (if enabled)

Definition at line 299 of file ssl.h.

## 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.

Definition at line 330 of file ssl.h.

## MBEDTLS_SSL_DTLS_SRTP_MKI_SUPPORTED

#define MBEDTLS_SSL_DTLS_SRTP_MKI_SUPPORTED 1

Definition at line 281 of file ssl.h.

## MBEDTLS_SSL_DTLS_SRTP_MKI_UNSUPPORTED

#define MBEDTLS_SSL_DTLS_SRTP_MKI_UNSUPPORTED 0

Definition at line 280 of file ssl.h.

## MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MAX

#define MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MAX 60000

Definition at line 288 of file ssl.h.

## MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MIN

#define MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MIN 1000

Definition at line 287 of file ssl.h.

## MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO

#define MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO 0xFF

renegotiation info ext

Definition at line 366 of file ssl.h.

## MBEDTLS_SSL_ETM_DISABLED

#define MBEDTLS_SSL_ETM_DISABLED 0

Definition at line 234 of file ssl.h.

## MBEDTLS_SSL_ETM_ENABLED

#define MBEDTLS_SSL_ETM_ENABLED 1

Definition at line 235 of file ssl.h.

## MBEDTLS_SSL_EXTENDED_MS_DISABLED

#define MBEDTLS_SSL_EXTENDED_MS_DISABLED 0

Definition at line 228 of file ssl.h.

## MBEDTLS_SSL_EXTENDED_MS_ENABLED

#define MBEDTLS_SSL_EXTENDED_MS_ENABLED 1

Definition at line 229 of file ssl.h.

## MBEDTLS_SSL_FALLBACK_SCSV_VALUE

#define MBEDTLS_SSL_FALLBACK_SCSV_VALUE 0x5600

RFC 7507 section 2

Definition at line 367 of file ssl.h.

## MBEDTLS_SSL_HASH_MD5

#define MBEDTLS_SSL_HASH_MD5 1

Definition at line 374 of file ssl.h.

## MBEDTLS_SSL_HASH_NONE

#define MBEDTLS_SSL_HASH_NONE 0

Definition at line 373 of file ssl.h.

## MBEDTLS_SSL_HASH_SHA1

#define MBEDTLS_SSL_HASH_SHA1 2

Definition at line 375 of file ssl.h.

## MBEDTLS_SSL_HASH_SHA224

#define MBEDTLS_SSL_HASH_SHA224 3

Definition at line 376 of file ssl.h.

## MBEDTLS_SSL_HASH_SHA256

#define MBEDTLS_SSL_HASH_SHA256 4

Definition at line 377 of file ssl.h.

## MBEDTLS_SSL_HASH_SHA384

#define MBEDTLS_SSL_HASH_SHA384 5

Definition at line 378 of file ssl.h.

## MBEDTLS_SSL_HASH_SHA512

#define MBEDTLS_SSL_HASH_SHA512 6

Definition at line 379 of file ssl.h.

## MBEDTLS_SSL_HS_CERTIFICATE

#define MBEDTLS_SSL_HS_CERTIFICATE 11

Definition at line 439 of file ssl.h.

## MBEDTLS_SSL_HS_CERTIFICATE_REQUEST

#define MBEDTLS_SSL_HS_CERTIFICATE_REQUEST 13

Definition at line 441 of file ssl.h.

## MBEDTLS_SSL_HS_CERTIFICATE_VERIFY

#define MBEDTLS_SSL_HS_CERTIFICATE_VERIFY 15

Definition at line 443 of file ssl.h.

## MBEDTLS_SSL_HS_CLIENT_HELLO

#define MBEDTLS_SSL_HS_CLIENT_HELLO 1

Definition at line 435 of file ssl.h.

## MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE

#define MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE 16

Definition at line 444 of file ssl.h.

## MBEDTLS_SSL_HS_FINISHED

#define MBEDTLS_SSL_HS_FINISHED 20

Definition at line 445 of file ssl.h.

## MBEDTLS_SSL_HS_HELLO_REQUEST

#define MBEDTLS_SSL_HS_HELLO_REQUEST 0

Definition at line 434 of file ssl.h.

## MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST

#define MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST 3

Definition at line 437 of file ssl.h.

## MBEDTLS_SSL_HS_NEW_SESSION_TICKET

#define MBEDTLS_SSL_HS_NEW_SESSION_TICKET 4

Definition at line 438 of file ssl.h.

## MBEDTLS_SSL_HS_SERVER_HELLO

#define MBEDTLS_SSL_HS_SERVER_HELLO 2

Definition at line 436 of file ssl.h.

## MBEDTLS_SSL_HS_SERVER_HELLO_DONE

#define MBEDTLS_SSL_HS_SERVER_HELLO_DONE 14

Definition at line 442 of file ssl.h.

## MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE

#define MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE 12

Definition at line 440 of file ssl.h.

## MBEDTLS_SSL_IN_CONTENT_LEN

#define MBEDTLS_SSL_IN_CONTENT_LEN MBEDTLS_SSL_MAX_CONTENT_LEN

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.

If this option is undefined, it inherits its value from MBEDTLS_SSL_MAX_CONTENT_LEN.

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 independently of the outgoing I/O buffer.

Definition at line 318 of file ssl.h.

## MBEDTLS_SSL_IS_CLIENT

#define MBEDTLS_SSL_IS_CLIENT 0

Definition at line 222 of file ssl.h.

## MBEDTLS_SSL_IS_FALLBACK

#define MBEDTLS_SSL_IS_FALLBACK 1

Definition at line 226 of file ssl.h.

## MBEDTLS_SSL_IS_NOT_FALLBACK

#define MBEDTLS_SSL_IS_NOT_FALLBACK 0

Definition at line 225 of file ssl.h.

## MBEDTLS_SSL_IS_SERVER

#define MBEDTLS_SSL_IS_SERVER 1

Definition at line 223 of file ssl.h.

## MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION

#define MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION 1

Definition at line 258 of file ssl.h.

## MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE

#define MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE 2

Definition at line 259 of file ssl.h.

## MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION

#define MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION 0

Definition at line 257 of file ssl.h.

## MBEDTLS_SSL_LEGACY_RENEGOTIATION

#define MBEDTLS_SSL_LEGACY_RENEGOTIATION 0

Definition at line 245 of file ssl.h.

## MBEDTLS_SSL_MAJOR_VERSION_3

#define MBEDTLS_SSL_MAJOR_VERSION_3 3

Definition at line 198 of file ssl.h.

## 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

Definition at line 211 of file ssl.h.

## 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

Definition at line 209 of file ssl.h.

## MBEDTLS_SSL_MAX_CONTENT_LEN

#define MBEDTLS_SSL_MAX_CONTENT_LEN 16384

Maximum length (in bytes) of incoming and outgoing plaintext fragments.

This determines the size of both the incoming and outgoing TLS I/O buffers in such a way that both are capable of holding the specified amount of plaintext data, regardless of the protection mechanism used.

To configure incoming and outgoing I/O buffers separately, use MBEDTLS_SSL_IN_CONTENT_LEN and MBEDTLS_SSL_OUT_CONTENT_LEN, which overwrite the value set by this option.

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 both incoming and outgoing I/O buffers.

Size of the input / output buffer

Definition at line 314 of file ssl.h.

## MBEDTLS_SSL_MAX_FRAG_LEN_1024

#define MBEDTLS_SSL_MAX_FRAG_LEN_1024 2

MaxFragmentLength 2^10

Definition at line 217 of file ssl.h.

## MBEDTLS_SSL_MAX_FRAG_LEN_2048

#define MBEDTLS_SSL_MAX_FRAG_LEN_2048 3

MaxFragmentLength 2^11

Definition at line 218 of file ssl.h.

## MBEDTLS_SSL_MAX_FRAG_LEN_4096

#define MBEDTLS_SSL_MAX_FRAG_LEN_4096 4

MaxFragmentLength 2^12

Definition at line 219 of file ssl.h.

## MBEDTLS_SSL_MAX_FRAG_LEN_512

#define MBEDTLS_SSL_MAX_FRAG_LEN_512 1

MaxFragmentLength 2^9

Definition at line 216 of file ssl.h.

## MBEDTLS_SSL_MAX_FRAG_LEN_INVALID

#define MBEDTLS_SSL_MAX_FRAG_LEN_INVALID 5

first invalid value

Definition at line 220 of file ssl.h.

## MBEDTLS_SSL_MAX_FRAG_LEN_NONE

#define MBEDTLS_SSL_MAX_FRAG_LEN_NONE 0

don't use this extension

Definition at line 215 of file ssl.h.

## MBEDTLS_SSL_MAX_HOST_NAME_LEN

#define MBEDTLS_SSL_MAX_HOST_NAME_LEN 255

Maximum host name defined in RFC 1035

Definition at line 208 of file ssl.h.

## MBEDTLS_SSL_MINOR_VERSION_0

#define MBEDTLS_SSL_MINOR_VERSION_0 0

SSL v3.0

Definition at line 199 of file ssl.h.

## MBEDTLS_SSL_MINOR_VERSION_1

#define MBEDTLS_SSL_MINOR_VERSION_1 1

TLS v1.0

Definition at line 200 of file ssl.h.

## MBEDTLS_SSL_MINOR_VERSION_2

#define MBEDTLS_SSL_MINOR_VERSION_2 2

TLS v1.1

Definition at line 201 of file ssl.h.

## MBEDTLS_SSL_MINOR_VERSION_3

#define MBEDTLS_SSL_MINOR_VERSION_3 3

TLS v1.2

Definition at line 202 of file ssl.h.

## MBEDTLS_SSL_MINOR_VERSION_4

#define MBEDTLS_SSL_MINOR_VERSION_4 4

TLS v1.3 (experimental)

Definition at line 203 of file ssl.h.

## MBEDTLS_SSL_MSG_ALERT

#define MBEDTLS_SSL_MSG_ALERT 21

Definition at line 396 of file ssl.h.

## MBEDTLS_SSL_MSG_APPLICATION_DATA

#define MBEDTLS_SSL_MSG_APPLICATION_DATA 23

Definition at line 398 of file ssl.h.

## MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC

#define MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC 20

Definition at line 395 of file ssl.h.

## MBEDTLS_SSL_MSG_CID

#define MBEDTLS_SSL_MSG_CID 25

Definition at line 399 of file ssl.h.

## MBEDTLS_SSL_MSG_HANDSHAKE

#define MBEDTLS_SSL_MSG_HANDSHAKE 22

Definition at line 397 of file ssl.h.

## MBEDTLS_SSL_OUT_CONTENT_LEN

#define MBEDTLS_SSL_OUT_CONTENT_LEN MBEDTLS_SSL_MAX_CONTENT_LEN

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.

If this option undefined, it inherits its value from MBEDTLS_SSL_MAX_CONTENT_LEN.

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 independently of the incoming I/O buffer.

Definition at line 322 of file ssl.h.

## MBEDTLS_SSL_PRESET_DEFAULT

#define MBEDTLS_SSL_PRESET_DEFAULT 0

Definition at line 274 of file ssl.h.

## MBEDTLS_SSL_PRESET_SUITEB

#define MBEDTLS_SSL_PRESET_SUITEB 2

Definition at line 275 of file ssl.h.

## MBEDTLS_SSL_RENEGO_MAX_RECORDS_DEFAULT

#define MBEDTLS_SSL_RENEGO_MAX_RECORDS_DEFAULT 16

Definition at line 255 of file ssl.h.

## MBEDTLS_SSL_RENEGOTIATION_DISABLED

#define MBEDTLS_SSL_RENEGOTIATION_DISABLED 0

Definition at line 248 of file ssl.h.

## MBEDTLS_SSL_RENEGOTIATION_ENABLED

#define MBEDTLS_SSL_RENEGOTIATION_ENABLED 1

Definition at line 249 of file ssl.h.

## MBEDTLS_SSL_RENEGOTIATION_NOT_ENFORCED

#define MBEDTLS_SSL_RENEGOTIATION_NOT_ENFORCED -1

Definition at line 254 of file ssl.h.

## MBEDTLS_SSL_SECURE_RENEGOTIATION

#define MBEDTLS_SSL_SECURE_RENEGOTIATION 1

Definition at line 246 of file ssl.h.

## MBEDTLS_SSL_SESSION_TICKETS_DISABLED

#define MBEDTLS_SSL_SESSION_TICKETS_DISABLED 0

Definition at line 265 of file ssl.h.

## MBEDTLS_SSL_SESSION_TICKETS_ENABLED

#define MBEDTLS_SSL_SESSION_TICKETS_ENABLED 1

Definition at line 266 of file ssl.h.

## MBEDTLS_SSL_SIG_ANON

#define MBEDTLS_SSL_SIG_ANON 0

Definition at line 381 of file ssl.h.

## MBEDTLS_SSL_SIG_ECDSA

#define MBEDTLS_SSL_SIG_ECDSA 3

Definition at line 383 of file ssl.h.

## MBEDTLS_SSL_SIG_RSA

#define MBEDTLS_SSL_SIG_RSA 1

Definition at line 382 of file ssl.h.

## MBEDTLS_SSL_TLS1_3_PADDING_GRANULARITY

#define MBEDTLS_SSL_TLS1_3_PADDING_GRANULARITY 1

This option controls the use of record plaintext padding in TLS 1.3.

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.

Definition at line 349 of file ssl.h.

## MBEDTLS_SSL_TRANSPORT_DATAGRAM

#define MBEDTLS_SSL_TRANSPORT_DATAGRAM 1

DTLS

Definition at line 206 of file ssl.h.

## MBEDTLS_SSL_TRANSPORT_STREAM

#define MBEDTLS_SSL_TRANSPORT_STREAM 0

TLS

Definition at line 205 of file ssl.h.

## MBEDTLS_SSL_TRUNC_HMAC_DISABLED

#define MBEDTLS_SSL_TRUNC_HMAC_DISABLED 0

Definition at line 261 of file ssl.h.

## MBEDTLS_SSL_TRUNC_HMAC_ENABLED

#define MBEDTLS_SSL_TRUNC_HMAC_ENABLED 1

Definition at line 262 of file ssl.h.

## MBEDTLS_SSL_TRUNCATED_HMAC_LEN

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

Definition at line 263 of file ssl.h.

## MBEDTLS_SSL_VERIFY_DATA_MAX_LEN

#define MBEDTLS_SSL_VERIFY_DATA_MAX_LEN 12

Definition at line 360 of file ssl.h.

## MBEDTLS_SSL_VERIFY_NONE

#define MBEDTLS_SSL_VERIFY_NONE 0

Definition at line 240 of file ssl.h.

## MBEDTLS_SSL_VERIFY_OPTIONAL

#define MBEDTLS_SSL_VERIFY_OPTIONAL 1

Definition at line 241 of file ssl.h.

## MBEDTLS_SSL_VERIFY_REQUIRED

#define MBEDTLS_SSL_VERIFY_REQUIRED 2

Definition at line 242 of file ssl.h.

## MBEDTLS_SSL_VERIFY_UNSET

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

Definition at line 243 of file ssl.h.

## MBEDTLS_TLS_EXT_ALPN

#define MBEDTLS_TLS_EXT_ALPN 16

Definition at line 464 of file ssl.h.

## MBEDTLS_TLS_EXT_CID

#define MBEDTLS_TLS_EXT_CID 254 /* TBD */

At the time of writing, the CID extension has not been assigned its final value. Set this configuration option to make Mbed TLS use a different value.

A future minor revision of Mbed TLS may change the default value of this option to match evolving standards and usage.

Definition at line 479 of file ssl.h.

## MBEDTLS_TLS_EXT_ECJPAKE_KKPP

#define MBEDTLS_TLS_EXT_ECJPAKE_KKPP 256 /* experimental */

Definition at line 482 of file ssl.h.

## MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC

#define MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC 22 /* 0x16 */

Definition at line 466 of file ssl.h.

## MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET

#define MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET 0x0017 /* 23 */

Definition at line 467 of file ssl.h.

## MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH

#define MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH 1

Definition at line 453 of file ssl.h.

## MBEDTLS_TLS_EXT_RENEGOTIATION_INFO

#define MBEDTLS_TLS_EXT_RENEGOTIATION_INFO 0xFF01

Definition at line 484 of file ssl.h.

## MBEDTLS_TLS_EXT_SERVERNAME

#define MBEDTLS_TLS_EXT_SERVERNAME 0

Definition at line 450 of file ssl.h.

## MBEDTLS_TLS_EXT_SERVERNAME_HOSTNAME

#define MBEDTLS_TLS_EXT_SERVERNAME_HOSTNAME 0

Definition at line 451 of file ssl.h.

## MBEDTLS_TLS_EXT_SESSION_TICKET

#define MBEDTLS_TLS_EXT_SESSION_TICKET 35

Definition at line 469 of file ssl.h.

## MBEDTLS_TLS_EXT_SIG_ALG

#define MBEDTLS_TLS_EXT_SIG_ALG 13

Definition at line 460 of file ssl.h.

## MBEDTLS_TLS_EXT_SUPPORTED_ELLIPTIC_CURVES

#define MBEDTLS_TLS_EXT_SUPPORTED_ELLIPTIC_CURVES 10

Definition at line 457 of file ssl.h.

## MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS

#define MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS 11

Definition at line 458 of file ssl.h.

## MBEDTLS_TLS_EXT_TRUNCATED_HMAC

#define MBEDTLS_TLS_EXT_TRUNCATED_HMAC 4

Definition at line 455 of file ssl.h.

## MBEDTLS_TLS_EXT_USE_SRTP

#define MBEDTLS_TLS_EXT_USE_SRTP 14

Definition at line 462 of file ssl.h.

## MBEDTLS_TLS_SRTP_AES128_CM_HMAC_SHA1_32

#define MBEDTLS_TLS_SRTP_AES128_CM_HMAC_SHA1_32 ( (uint16_t) 0x0002)

Definition at line 943 of file ssl.h.

## MBEDTLS_TLS_SRTP_AES128_CM_HMAC_SHA1_80

#define MBEDTLS_TLS_SRTP_AES128_CM_HMAC_SHA1_80 ( (uint16_t) 0x0001)

Definition at line 942 of file ssl.h.

## MBEDTLS_TLS_SRTP_MAX_MKI_LENGTH

#define MBEDTLS_TLS_SRTP_MAX_MKI_LENGTH 255

Definition at line 931 of file ssl.h.

## MBEDTLS_TLS_SRTP_MAX_PROFILE_LIST_LENGTH

#define MBEDTLS_TLS_SRTP_MAX_PROFILE_LIST_LENGTH 4

Definition at line 932 of file ssl.h.

## MBEDTLS_TLS_SRTP_NULL_HMAC_SHA1_32

#define MBEDTLS_TLS_SRTP_NULL_HMAC_SHA1_32 ( (uint16_t) 0x0006)

Definition at line 945 of file ssl.h.

## MBEDTLS_TLS_SRTP_NULL_HMAC_SHA1_80

#define MBEDTLS_TLS_SRTP_NULL_HMAC_SHA1_80 ( (uint16_t) 0x0005)

Definition at line 944 of file ssl.h.

## MBEDTLS_TLS_SRTP_UNSET

#define MBEDTLS_TLS_SRTP_UNSET ( (uint16_t) 0x0000)

Definition at line 947 of file ssl.h.

## Typedef Documentation

## mbedtls_dtls_srtp_info

typedef struct mbedtls_dtls_srtp_info_t mbedtls_dtls_srtp_info

## mbedtls_ssl_config

typedef struct mbedtls_ssl_config mbedtls_ssl_config

Definition at line 680 of file ssl.h.

## mbedtls_ssl_context

typedef struct mbedtls_ssl_context mbedtls_ssl_context

Definition at line 680 of file ssl.h.

## 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.

Definition at line 2291 of file ssl.h.

## 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.

Definition at line 2274 of file ssl.h.

## mbedtls_ssl_export_keys_ext_t

typedef int mbedtls_ssl_export_keys_ext_t(void *p_expkey, const unsigned char *ms, const unsigned char *kb, size_t maclen, size_t keylen, size_t ivlen, const unsigned char client_random[32], const unsigned char server_random[32], mbedtls_tls_prf_types tls_prf_type)

Callback type: Export key block, master secret, handshake randbytes and the tls_prf function used to derive keys.

Note
  This is required for certain uses of TLS, e.g. EAP-TLS (RFC 5216) and Thread. The key pointers are ephemeral and therefore must not be stored. The master secret and keys should not be used directly except as an input to a key derivation function.

Parameters

  p_expkey | Context for the callback.
  ms | Pointer to master secret (fixed length: 48 bytes).
  kb | Pointer to key block, see RFC 5246 section 6.3. (variable length: 2 * maclen + 2 * keylen + 2 * ivlen).
  maclen | MAC length.
  keylen | Key length.
  ivlen | IV length.
  client_random | The client random bytes.
  server_random | The server random bytes.
  tls_prf_type | The tls_prf enum type.

Returns
  0 if successful, or a specific MBEDTLS_ERR_XXX code.

Definition at line 2089 of file ssl.h.

## mbedtls_ssl_export_keys_t

typedef int mbedtls_ssl_export_keys_t(void *p_expkey, const unsigned char *ms, const unsigned char *kb, size_t maclen, size_t keylen, size_t ivlen)

Callback type: Export key block and master secret.

Note
  This is required for certain uses of TLS, e.g. EAP-TLS (RFC 5216) and Thread. The key pointers are ephemeral and therefore must not be stored. The master secret and keys should not be used directly except as an input to a key derivation function.

Parameters

  p_expkey | Context for the callback
  ms | Pointer to master secret (fixed length: 48 bytes)
  kb | Pointer to key block, see RFC 5246 section 6.3 (variable length: 2 * maclen + 2 * keylen + 2 * ivlen).
  maclen | MAC length
  keylen | Key length
  ivlen | IV length

Returns
  0 if successful, or a specific MBEDTLS_ERR_XXX code.

Definition at line 2057 of file ssl.h.

## mbedtls_ssl_flight_item

typedef struct mbedtls_ssl_flight_item mbedtls_ssl_flight_item

Definition at line 680 of file ssl.h.

## 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.

Definition at line 680 of file ssl.h.

## mbedtls_ssl_handshake_params

typedef struct mbedtls_ssl_handshake_params mbedtls_ssl_handshake_params

Definition at line 680 of file ssl.h.

## mbedtls_ssl_key_cert

typedef struct mbedtls_ssl_key_cert mbedtls_ssl_key_cert

Definition at line 680 of file ssl.h.

## 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.

Definition at line 613 of file ssl.h.

## 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 nomber of millisecondes 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.

Definition at line 639 of file ssl.h.

## 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.

Definition at line 589 of file ssl.h.

## mbedtls_ssl_session

typedef struct mbedtls_ssl_session mbedtls_ssl_session

Definition at line 680 of file ssl.h.

## 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 a 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.

Definition at line 665 of file ssl.h.

## mbedtls_ssl_sig_hash_set_t

typedef struct mbedtls_ssl_sig_hash_set_t mbedtls_ssl_sig_hash_set_t

Definition at line 680 of file ssl.h.

## mbedtls_ssl_srtp_profile

typedef uint16_t mbedtls_ssl_srtp_profile

Definition at line 949 of file ssl.h.

## 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.

Definition at line 2123 of file ssl.h.

## 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.

Definition at line 2029 of file ssl.h.

## mbedtls_ssl_transform

typedef struct mbedtls_ssl_transform mbedtls_ssl_transform

Definition at line 680 of file ssl.h.

## Enumeration Type Documentation

## 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_HANDSHAKE_OVER |
MBEDTLS_SSL_SERVER_NEW_SESSION_TICKET |
MBEDTLS_SSL_SERVER_HELLO_VERIFY_REQUEST_SENT |

Definition at line 536 of file ssl.h.

## mbedtls_tls_prf_types

enum mbedtls_tls_prf_types

Enumerator
MBEDTLS_SSL_TLS_PRF_NONE |
MBEDTLS_SSL_TLS_PRF_SSL3 |
MBEDTLS_SSL_TLS_PRF_TLS1 |
MBEDTLS_SSL_TLS_PRF_SHA384 |
MBEDTLS_SSL_TLS_PRF_SHA256 |

Definition at line 563 of file ssl.h.

## 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_alpn_protocols()

int mbedtls_ssl_conf_alpn_protocols | ( | mbedtls_ssl_config * | conf,
|  | const char ** | protos
| ) |  |

Set the supported Application Layer Protocols.

Parameters

  conf | SSL configuration
  protos | Pointer to a NULL-terminated list of supported protocols, in decreasing preference order. The pointer to the list is recorded by the library for later reference as required, so the lifetime of the table must be atleast as long as the lifetime of the SSL configuration structure.

Returns
  0 on success, or MBEDTLS_ERR_SSL_BAD_INPUT_DATA.

## mbedtls_ssl_conf_arc4_support()

void mbedtls_ssl_conf_arc4_support | ( | mbedtls_ssl_config * | conf,
|  | char | arc4
| ) |  |

Disable or enable support for RC4 (Default: MBEDTLS_SSL_ARC4_DISABLED)

Warning
  Use of RC4 in DTLS/TLS has been prohibited by RFC 7465 for security reasons. Use at your own risk.

Note
  This function is deprecated and will be removed in a future version of the library. RC4 is disabled by default at compile time and needs to be actively enabled for use with legacy systems.

Parameters

  conf | SSL configuration
  arc4 | MBEDTLS_SSL_ARC4_ENABLED or MBEDTLS_SSL_ARC4_DISABLED

## 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_ca_chain()

void mbedtls_ssl_conf_ca_chain | ( | mbedtls_ssl_config * | conf,
|  | mbedtls_x509_crt * | ca_chain,
|  | mbedtls_x509_crl * | ca_crl
| ) |  |

Set the data required to verify peer certificate.

Note
  See `mbedtls_x509_crt_verify()` for notes regarding the parameters ca_chain (maps to trust_ca for that function) and ca_crl.

Parameters

  conf | SSL configuration
  ca_chain | trusted CA chain (meaning all fully trusted top-level CAs)
  ca_crl | trusted CA CRLs

## mbedtls_ssl_conf_cbc_record_splitting()

void mbedtls_ssl_conf_cbc_record_splitting | ( | mbedtls_ssl_config * | conf,
|  | char | split
| ) |  |

Enable / Disable 1/n-1 record splitting (Default: MBEDTLS_SSL_CBC_RECORD_SPLITTING_ENABLED)

Note
  Only affects SSLv3 and TLS 1.0, not higher versions. Does not affect non-CBC ciphersuites in any version.

Parameters

  conf | SSL configuration
  split | MBEDTLS_SSL_CBC_RECORD_SPLITTING_ENABLED or MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED

## mbedtls_ssl_conf_cert_profile()

void mbedtls_ssl_conf_cert_profile | ( | mbedtls_ssl_config * | conf,
|  | const mbedtls_x509_crt_profile * | profile
| ) |  |

Set the X.509 security profile used for verification.

Note
  The restrictions are enforced for all certificates in the chain. However, signatures in the handshake are not covered by this setting but by mbedtls_ssl_conf_sig_hashes().

Parameters

  conf | SSL configuration
  profile | Profile to use

## mbedtls_ssl_conf_cert_req_ca_list()

void mbedtls_ssl_conf_cert_req_ca_list | ( | mbedtls_ssl_config * | conf,
|  | char | cert_req_ca_list
| ) |  |

Whether to send a list of acceptable CAs in CertificateRequest messages. (Default: do send)

Parameters

  conf | SSL configuration
  cert_req_ca_list | MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED or MBEDTLS_SSL_CERT_REQ_CA_LIST_DISABLED

## 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. (Overrides all version-specific lists)

The ciphersuites array is not copied, and must remain valid for the lifetime of the ssl_config.

Note: The server uses its own preferences over the preference of the client unless MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE is defined!

Parameters

  conf | SSL configuration
  ciphersuites | 0-terminated list of allowed ciphersuites

## mbedtls_ssl_conf_ciphersuites_for_version()

void mbedtls_ssl_conf_ciphersuites_for_version | ( | mbedtls_ssl_config * | conf,
|  | const int * | ciphersuites,
|  | int | major,
|  | int | minor
| ) |  |

Set the list of allowed ciphersuites and the preference order for a specific version of the protocol. (Only useful on the server side)

The ciphersuites array is not copied, and must remain valid for the lifetime of the ssl_config.

Parameters

  conf | SSL configuration
  ciphersuites | 0-terminated list of allowed ciphersuites
  major | Major version number (only MBEDTLS_SSL_MAJOR_VERSION_3 supported)
  minor | Minor version number (MBEDTLS_SSL_MINOR_VERSION_0, MBEDTLS_SSL_MINOR_VERSION_1 and MBEDTLS_SSL_MINOR_VERSION_2, MBEDTLS_SSL_MINOR_VERSION_3 supported)

Note
  With DTLS, use MBEDTLS_SSL_MINOR_VERSION_2 for DTLS 1.0 and MBEDTLS_SSL_MINOR_VERSION_3 for DTLS 1.2

## mbedtls_ssl_conf_curves()

void mbedtls_ssl_conf_curves | ( | mbedtls_ssl_config * | conf,
|  | const mbedtls_ecp_group_id * | curves
| ) |  |

Set the allowed curves in order of preference. (Default: all defined curves in order of decreasing size, except that Montgomery curves come last. This order is likely to change in a future version.)

On server: this only affects selection of the ECDHE curve; the curves used for ECDH and ECDSA are determined by the list of available certificates instead.

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

Both sides: limits the set of curves accepted for use in ECDHE and in the peer's end-entity certificate.

Note
  This has no influence on which curves are allowed inside the certificate chains, see `mbedtls_ssl_conf_cert_profile()` for that. For the end-entity certificate however, the key will be accepted only if it is allowed both by this list and by the cert profile.
  This list should be ordered by decreasing preference (preferred curve first).

Parameters

  conf | SSL configuration
  curves | Ordered list of allowed curves, terminated by MBEDTLS_ECP_DP_NONE.

## 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_dh_param()

MBEDTLS_DEPRECATED int mbedtls_ssl_conf_dh_param | ( | mbedtls_ssl_config * | conf,
|  | const char * | dhm_P,
|  | const char * | dhm_G
| ) |  |

Set the Diffie-Hellman public P and G values, read as hexadecimal strings (server-side only) (Default values: MBEDTLS_DHM_RFC3526_MODP_2048_[PG])

Parameters

  conf | SSL configuration
  dhm_P | Diffie-Hellman-Merkle modulus
  dhm_G | Diffie-Hellman-Merkle generator

Deprecated:
  Superseded by `mbedtls_ssl_conf_dh_param_bin`.

Returns
  0 if successful

## mbedtls_ssl_conf_dh_param_bin()

int mbedtls_ssl_conf_dh_param_bin | ( | mbedtls_ssl_config * | conf,
|  | const unsigned char * | dhm_P,
|  | size_t | P_len,
|  | const unsigned char * | dhm_G,
|  | size_t | G_len
| ) |  |

Set the Diffie-Hellman public P and G values from big-endian binary presentations. (Default values: MBEDTLS_DHM_RFC3526_MODP_2048_[PG]_BIN)

Parameters

  conf | SSL configuration
  dhm_P | Diffie-Hellman-Merkle modulus in big-endian binary form
  P_len | Length of DHM modulus
  dhm_G | Diffie-Hellman-Merkle generator in big-endian binary form
  G_len | Length of DHM generator

Returns
  0 if successful

## mbedtls_ssl_conf_dh_param_ctx()

int mbedtls_ssl_conf_dh_param_ctx | ( | mbedtls_ssl_config * | conf,
|  | mbedtls_dhm_context * | dhm_ctx
| ) |  |

Set the Diffie-Hellman public P and G values, read from existing context (server-side only)

Parameters

  conf | SSL configuration
  dhm_ctx | Diffie-Hellman-Merkle context

Returns
  0 if successful

## mbedtls_ssl_conf_dhm_min_bitlen()

void mbedtls_ssl_conf_dhm_min_bitlen | ( | mbedtls_ssl_config * | conf,
|  | unsigned int | bitlen
| ) |  |

Set the minimum length for Diffie-Hellman parameters. (Client-side only.) (Default: 1024 bits.)

Parameters

  conf | SSL configuration
  bitlen | Minimum bit length of the DHM prime

## mbedtls_ssl_conf_dtls_anti_replay()

void mbedtls_ssl_conf_dtls_anti_replay | ( | mbedtls_ssl_config * | conf,
|  | char | mode
| ) |  |

Enable or disable anti-replay protection for DTLS. (DTLS only, no effect on TLS.) Default: enabled.

Parameters

  conf | SSL configuration
  mode | MBEDTLS_SSL_ANTI_REPLAY_ENABLED or MBEDTLS_SSL_ANTI_REPLAY_DISABLED.

Warning
  Disabling this is a security risk unless the application protocol handles duplicated packets in a safe way. You should not disable this without careful consideration. However, if your application already detects duplicated packets and needs information about them to adjust its transmission strategy, then you'll want to disable this.

## 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 ot 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_dtls_cookies()

void mbedtls_ssl_conf_dtls_cookies | ( | mbedtls_ssl_config * | conf,
|  | mbedtls_ssl_cookie_write_t * | f_cookie_write,
|  | mbedtls_ssl_cookie_check_t * | f_cookie_check,
|  | void * | p_cookie
| ) |  |

Register callbacks for DTLS cookies (Server only. DTLS only.)

Default: dummy callbacks that fail, in order to force you to register working callbacks (and initialize their context).

To disable HelloVerifyRequest, register NULL callbacks.

Warning
  Disabling hello verification allows your server to be used for amplification in DoS attacks against other hosts. Only disable if you known this can't happen in your particular environment.

Note
  See comments on `mbedtls_ssl_handshake()` about handling the MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED that is expected on the first handshake attempt when this is enabled.
  This is also necessary to handle client reconnection from the same port as described in RFC 6347 section 4.2.8 (only the variant with cookies is supported currently). See comments on `mbedtls_ssl_read()` for details.

Parameters

  conf | SSL configuration
  f_cookie_write | Cookie write callback
  f_cookie_check | Cookie check callback
  p_cookie | Context for both callbacks

## mbedtls_ssl_conf_dtls_srtp_protection_profiles()

int mbedtls_ssl_conf_dtls_srtp_protection_profiles | ( | mbedtls_ssl_config * | conf,
|  | const mbedtls_ssl_srtp_profile * | profiles
| ) |  |

Set the supported DTLS-SRTP protection profiles.

Parameters

  conf | SSL configuration

  profiles

  Pointer to a List of MBEDTLS_TLS_SRTP_UNSET terminated supported protection profiles in decreasing preference order. The pointer to the list is recorded by the library for later reference as required, so the lifetime of the table must be at least as long as the lifetime of the SSL configuration structure. The list must not hold more than MBEDTLS_TLS_SRTP_MAX_PROFILE_LIST_LENGTH elements (excluding the terminating MBEDTLS_TLS_SRTP_UNSET).

Returns
  0 on success
  MBEDTLS_ERR_SSL_BAD_INPUT_DATA when the list of protection profiles is incorrect.

## mbedtls_ssl_conf_encrypt_then_mac()

void mbedtls_ssl_conf_encrypt_then_mac | ( | mbedtls_ssl_config * | conf,
|  | char | etm
| ) |  |

Enable or disable Encrypt-then-MAC (Default: MBEDTLS_SSL_ETM_ENABLED)

Note
  This should always be enabled, it is a security improvement, and should not cause any interoperability issue (used only if the peer supports it too).

Parameters

  conf | SSL configuration
  etm | MBEDTLS_SSL_ETM_ENABLED or MBEDTLS_SSL_ETM_DISABLED

## 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_export_keys_cb()

void mbedtls_ssl_conf_export_keys_cb | ( | mbedtls_ssl_config * | conf,
|  | mbedtls_ssl_export_keys_t * | f_export_keys,
|  | void * | p_export_keys
| ) |  |

Configure key export callback. (Default: none.)

Note
  See `mbedtls_ssl_export_keys_t`.

Parameters

  conf | SSL configuration context
  f_export_keys | Callback for exporting keys
  p_export_keys | Context for the callback

## mbedtls_ssl_conf_export_keys_ext_cb()

void mbedtls_ssl_conf_export_keys_ext_cb | ( | mbedtls_ssl_config * | conf,
|  | mbedtls_ssl_export_keys_ext_t * | f_export_keys_ext,
|  | void * | p_export_keys
| ) |  |

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

Note
  See `mbedtls_ssl_export_keys_ext_t`.

Warning
  Exported key material must not be used for any purpose before the (D)TLS handshake is completed

Parameters

  conf | SSL configuration context
  f_export_keys_ext | Callback for exporting keys
  p_export_keys | Context for the callback

## mbedtls_ssl_conf_extended_master_secret()

void mbedtls_ssl_conf_extended_master_secret | ( | mbedtls_ssl_config * | conf,
|  | char | ems
| ) |  |

Enable or disable Extended Master Secret negotiation. (Default: MBEDTLS_SSL_EXTENDED_MS_ENABLED)

Note
  This should always be enabled, it is a security fix to the protocol, and should not cause any interoperability issue (used only if the peer supports it too).

Parameters

  conf | SSL configuration
  ems | MBEDTLS_SSL_EXTENDED_MS_ENABLED or MBEDTLS_SSL_EXTENDED_MS_DISABLED

## mbedtls_ssl_conf_fallback()

void mbedtls_ssl_conf_fallback | ( | mbedtls_ssl_config * | conf,
|  | char | fallback
| ) |  |

Set the fallback flag (client-side only). (Default: MBEDTLS_SSL_IS_NOT_FALLBACK).

Note
  Set to MBEDTLS_SSL_IS_FALLBACK when preparing a fallback connection, that is a connection with max_version set to a lower value than the value you're willing to use. Such fallback connections are not recommended but are sometimes necessary to interoperate with buggy (version-intolerant) servers.

Warning
  You should NOT set this to MBEDTLS_SSL_IS_FALLBACK for non-fallback connections! This would appear to work for a while, then cause failures when the server is upgraded to support a newer TLS version.

Parameters

  conf | SSL configuration
  fallback | MBEDTLS_SSL_IS_NOT_FALLBACK or MBEDTLS_SSL_IS_FALLBACK

## mbedtls_ssl_conf_handshake_timeout()

void mbedtls_ssl_conf_handshake_timeout | ( | mbedtls_ssl_config * | conf,
|  | uint32_t | min,
|  | uint32_t | max
| ) |  |

Set retransmit timeout values for the DTLS handshake. (DTLS only, no effect on TLS.)

Parameters

  conf | SSL configuration
  min | Initial timeout value in milliseconds. Default: 1000 (1 second).
  max | Maximum timeout value in milliseconds. Default: 60000 (60 seconds).

Note
  Default values are from RFC 6347 section 4.2.4.1.
  The 'min' value should typically be slightly above the expected round-trip time to your peer, plus whatever time it takes for the peer to process the message. For example, if your RTT is about 600ms and you peer needs up to 1s to do the cryptographic operations in the handshake, then you should set 'min' slightly above 1600. Lower values of 'min' might cause spurious resends which waste network resources, while larger value of 'min' will increase overall latency on unreliable network links.
  The more unreliable your network connection is, the larger your max / min ratio needs to be in order to achieve reliable handshakes.
  Messages are retransmitted up to log2(ceil(max/min)) times. For example, if min = 1s and max = 5s, the retransmit plan goes: send ... 1s -> resend ... 2s -> resend ... 4s -> resend ... 5s -> give up and return a timeout error.

## 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_frag_len()

int mbedtls_ssl_conf_max_frag_len | ( | mbedtls_ssl_config * | conf,
|  | unsigned char | mfl_code
| ) |  |

Set the maximum fragment length to emit and/or negotiate. (Typical: the smaller of MBEDTLS_SSL_IN_CONTENT_LEN and MBEDTLS_SSL_OUT_CONTENT_LEN, usually `2^14` bytes) (Server: set maximum fragment length to emit, usually negotiated by the client during handshake) (Client: set maximum fragment length to emit and negotiate with the server during handshake) (Default: MBEDTLS_SSL_MAX_FRAG_LEN_NONE)

Note
  On the client side, the maximum fragment length extension will not be used, unless the maximum fragment length has been set via this function to a value different than MBEDTLS_SSL_MAX_FRAG_LEN_NONE.
  With TLS, this currently only affects ApplicationData (sent with `mbedtls_ssl_read()`), not handshake messages. With DTLS, this affects both ApplicationData and handshake.
  This sets the maximum length for a record's payload, excluding record overhead that will be added to it, see `mbedtls_ssl_get_record_expansion()`.
  For DTLS, it is also possible to set a limit for the total size of daragrams passed to the transport layer, including record overhead, see `mbedtls_ssl_set_mtu()`.

Parameters

  conf | SSL configuration
  mfl_code | Code for maximum fragment length (allowed values: MBEDTLS_SSL_MAX_FRAG_LEN_512, MBEDTLS_SSL_MAX_FRAG_LEN_1024, MBEDTLS_SSL_MAX_FRAG_LEN_2048, MBEDTLS_SSL_MAX_FRAG_LEN_4096)

Returns
  0 if successful or MBEDTLS_ERR_SSL_BAD_INPUT_DATA

## mbedtls_ssl_conf_max_version()

void 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 (Default: MBEDTLS_SSL_MAX_MAJOR_VERSION, MBEDTLS_SSL_MAX_MINOR_VERSION)

Note
  This ignores ciphersuites from higher versions.
  With DTLS, use MBEDTLS_SSL_MINOR_VERSION_2 for DTLS 1.0 and MBEDTLS_SSL_MINOR_VERSION_3 for DTLS 1.2

Parameters

  conf | SSL configuration
  major | Major version number (only MBEDTLS_SSL_MAJOR_VERSION_3 supported)
  minor | Minor version number (MBEDTLS_SSL_MINOR_VERSION_0, MBEDTLS_SSL_MINOR_VERSION_1 and MBEDTLS_SSL_MINOR_VERSION_2, MBEDTLS_SSL_MINOR_VERSION_3 supported)

## mbedtls_ssl_conf_min_version()

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

Set the minimum accepted SSL/TLS protocol version (Default: TLS 1.0)

Note
  Input outside of the SSL_MAX_XXXXX_VERSION and SSL_MIN_XXXXX_VERSION range is ignored.
  MBEDTLS_SSL_MINOR_VERSION_0 (SSL v3) should be avoided.
  With DTLS, use MBEDTLS_SSL_MINOR_VERSION_2 for DTLS 1.0 and MBEDTLS_SSL_MINOR_VERSION_3 for DTLS 1.2

Parameters

  conf | SSL configuration
  major | Major version number (only MBEDTLS_SSL_MAJOR_VERSION_3 supported)
  minor | Minor version number (MBEDTLS_SSL_MINOR_VERSION_0, MBEDTLS_SSL_MINOR_VERSION_1 and MBEDTLS_SSL_MINOR_VERSION_2, MBEDTLS_SSL_MINOR_VERSION_3 supported)

## mbedtls_ssl_conf_own_cert()

int mbedtls_ssl_conf_own_cert | ( | mbedtls_ssl_config * | conf,
|  | mbedtls_x509_crt * | own_cert,
|  | mbedtls_pk_context * | pk_key
| ) |  |

Set own certificate chain and private key.

Note
  own_cert should contain in order from the bottom up your certificate chain. The top certificate (self-signed) can be omitted.
  On server, this function can be called multiple times to provision more than one cert/key pair (eg one ECDSA, one RSA with SHA-256, one RSA with SHA-1). An adequate certificate will be selected according to the client's advertised capabilities. In case multiple certificates are adequate, preference is given to the one set by the first call to this function, then second, etc.
  On client, only the first call has any effect. That is, only one client certificate can be provisioned. The server's preferences in its CertficateRequest message will be ignored and our only cert will be sent regardless of whether it matches those preferences - the server can then decide what it wants to do with it.
  The provided `pk_key` needs to match the public key in the first certificate in `own_cert`, or all handshakes using that certificate will fail. It is your responsibility to ensure that; this function will not perform any check. You may use mbedtls_pk_check_pair() in order to perform this check yourself, but be aware that this function can be computationally expensive on some key types.

Parameters

  conf | SSL configuration
  own_cert | own public certificate chain
  pk_key | own private key

Returns
  0 on success or MBEDTLS_ERR_SSL_ALLOC_FAILED

## mbedtls_ssl_conf_psk()

int mbedtls_ssl_conf_psk | ( | mbedtls_ssl_config * | conf,
|  | const unsigned char * | psk,
|  | size_t | psk_len,
|  | const unsigned char * | psk_identity,
|  | size_t | psk_identity_len
| ) |  |

Configure a pre-shared key (PSK) and identity to be used in PSK-based ciphersuites.

Note
  This is mainly useful for clients. Servers will usually want to use `mbedtls_ssl_conf_psk_cb()` instead.
  A PSK set by `mbedtls_ssl_set_hs_psk()` in the PSK callback takes precedence over a PSK configured by this function.

Warning
  Currently, clients can only register a single pre-shared key. Calling this function or mbedtls_ssl_conf_psk_opaque() more than once will overwrite values configured in previous calls. Support for setting multiple PSKs on clients and selecting one based on the identity hint is not a planned feature, but feedback is welcomed.

Parameters

  conf | The SSL configuration to register the PSK with.
  psk | The pointer to the pre-shared key to use.
  psk_len | The length of the pre-shared key in bytes.
  psk_identity | The pointer to the pre-shared key identity.
  psk_identity_len | The length of the pre-shared key identity in bytes.

Note
  The PSK and its identity are copied internally and hence need not be preserved by the caller for the lifetime of the SSL configuration.

Returns
  `0` if successful.
  An `MBEDTLS_ERR_SSL_XXX` error code on failure.

## mbedtls_ssl_conf_psk_cb()

void mbedtls_ssl_conf_psk_cb | ( | mbedtls_ssl_config * | conf,
|  | int(*)(void *, mbedtls_ssl_context *, const unsigned char *, size_t) | f_psk,
|  | void * | p_psk
| ) |  |

Set the PSK callback (server-side only).

                If set, the PSK callback is called for each
                handshake where a PSK-based ciphersuite was negotiated.
                The caller provides the identity received and wants to
                receive the actual PSK data and length.

                The callback has the following parameters:
                - \c void*: The opaque pointer \p p_psk.
                - \c mbedtls_ssl_context*: The SSL context to which
                                           the operation applies.
                - \c const unsigned char*: The PSK identity
                                           selected by the client.
                - \c size_t: The length of the PSK identity
                             selected by the client.

                If a valid PSK identity is found, the callback should use
                \c mbedtls_ssl_set_hs_psk() or
                \c mbedtls_ssl_set_hs_psk_opaque()
                on the SSL context to set the correct PSK and return \c 0.
                Any other return value will result in a denied PSK identity.

Note
  A dynamic PSK (i.e. set by the PSK callback) takes precedence over a static PSK (i.e. set by `mbedtls_ssl_conf_psk()` or `mbedtls_ssl_conf_psk_opaque()`). This means that if you set a PSK callback using this function, you don't need to set a PSK using `mbedtls_ssl_conf_psk()` or `mbedtls_ssl_conf_psk_opaque()`).

Parameters

  conf | The SSL configuration to register the callback with.
  f_psk | The callback for selecting and setting the PSK based in the PSK identity chosen by the client.
  p_psk | A pointer to an opaque structure to be passed to the callback, for example a PSK store.

## 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_renegotiation()

void mbedtls_ssl_conf_renegotiation | ( | mbedtls_ssl_config * | conf,
|  | int | renegotiation
| ) |  |

Enable / Disable renegotiation support for connection when initiated by peer (Default: MBEDTLS_SSL_RENEGOTIATION_DISABLED)

Warning
  It is recommended to always disable renegotation unless you know you need it and you know what you're doing. In the past, there have been several issues associated with renegotiation or a poor understanding of its properties.

Note
  Server-side, enabling renegotiation also makes the server susceptible to a resource DoS by a malicious client.

Parameters

  conf | SSL configuration
  renegotiation | Enable or disable (MBEDTLS_SSL_RENEGOTIATION_ENABLED or MBEDTLS_SSL_RENEGOTIATION_DISABLED)

## mbedtls_ssl_conf_renegotiation_enforced()

void mbedtls_ssl_conf_renegotiation_enforced | ( | mbedtls_ssl_config * | conf,
|  | int | max_records
| ) |  |

Enforce renegotiation requests. (Default: enforced, max_records = 16)

When we request a renegotiation, the peer can comply or ignore the request. This function allows us to decide whether to enforce our renegotiation requests by closing the connection if the peer doesn't comply.

However, records could already be in transit from the peer when the request is emitted. In order to increase reliability, we can accept a number of records before the expected handshake records.

The optimal value is highly dependent on the specific usage scenario.

Note
  With DTLS and server-initiated renegotiation, the HelloRequest is retransmited every time mbedtls_ssl_read() times out or receives Application Data, until:
  - max_records records have beens seen, if it is >= 0, or
  - the number of retransmits that would happen during an actual handshake has been reached. Please remember the request might be lost a few times if you consider setting max_records to a really low value.

Warning
  On client, the grace period can only happen during mbedtls_ssl_read(), as opposed to mbedtls_ssl_write() and mbedtls_ssl_renegotiate() which always behave as if max_record was 0. The reason is, if we receive application data from the server, we need a place to write it, which only happens during mbedtls_ssl_read().

Parameters

  conf | SSL configuration
  max_records | Use MBEDTLS_SSL_RENEGOTIATION_NOT_ENFORCED if you don't want to enforce renegotiation, or a non-negative value to enforce it but allow for a grace period of max_records records.

## mbedtls_ssl_conf_renegotiation_period()

void mbedtls_ssl_conf_renegotiation_period | ( | mbedtls_ssl_config * | conf,
|  | const unsigned char | period[8]
| ) |  |

Set record counter threshold for periodic renegotiation. (Default: 2^48 - 1)

Renegotiation is automatically triggered when a record counter (outgoing or incoming) crosses the defined threshold. The default value is meant to prevent the connection from being closed when the counter is about to reached its maximal value (it is not allowed to wrap).

Lower values can be used to enforce policies such as "keys must be refreshed every N packets with cipher X".

The renegotiation period can be disabled by setting conf->disable_renegotiation to MBEDTLS_SSL_RENEGOTIATION_DISABLED.

Note
  When the configured transport is MBEDTLS_SSL_TRANSPORT_DATAGRAM the maximum renegotiation period is 2^48 - 1, and for MBEDTLS_SSL_TRANSPORT_STREAM, the maximum renegotiation period is 2^64 - 1.

Parameters

  conf | SSL configuration
  period | The threshold value: a big-endian 64-bit number.

## mbedtls_ssl_conf_rng()

void mbedtls_ssl_conf_rng | ( | mbedtls_ssl_config * | conf,
|  | int(*)(void *, unsigned char *, size_t) | f_rng,
|  | void * | p_rng
| ) |  |

Set the random number generator callback.

Parameters

  conf | SSL configuration
  f_rng | RNG function
  p_rng | RNG parameter

## mbedtls_ssl_conf_session_cache()

void mbedtls_ssl_conf_session_cache | ( | mbedtls_ssl_config * | conf,
|  | void * | p_cache,
|  | int(*)(void *, mbedtls_ssl_session *) | f_get_cache,
|  | int(*)(void *, const mbedtls_ssl_session *) | f_set_cache
| ) |  |

Set the session cache callbacks (server-side only) If not set, no session resuming is done (except if session tickets are enabled too).

The session cache has the responsibility to check for stale entries based on timeout. See RFC 5246 for recommendations.

Warning: session.peer_cert is cleared by the SSL/TLS layer on connection shutdown, so do not cache the pointer! Either set it to NULL or make a full copy of the certificate.

The get callback is called once during the initial handshake to enable session resuming. The get function has the following parameters: (void *parameter, mbedtls_ssl_session *session) If a valid entry is found, it should fill the master of the session object with the cached values and return 0, return 1 otherwise. Optionally peer_cert can be set as well if it is properly present in cache entry.

The set callback is called once during the initial handshake to enable session resuming after the entire handshake has been finished. The set function has the following parameters: (void *parameter, const mbedtls_ssl_session *session). The function should create a cache entry for future retrieval based on the data in the session structure and should keep in mind that the mbedtls_ssl_session object presented (and all its referenced data) is cleared by the SSL/TLS layer when the connection is terminated. It is recommended to add metadata to determine if an entry is still valid in the future. Return 0 if successfully cached, return 1 otherwise.

Parameters

  conf | SSL configuration
  p_cache | parmater (context) for both callbacks
  f_get_cache | session get callback
  f_set_cache | session set callback

## mbedtls_ssl_conf_session_tickets()

void mbedtls_ssl_conf_session_tickets | ( | mbedtls_ssl_config * | conf,
|  | int | use_tickets
| ) |  |

Enable / Disable session tickets (client only). (Default: MBEDTLS_SSL_SESSION_TICKETS_ENABLED.)

Note
  On server, use `mbedtls_ssl_conf_session_tickets_cb()`.

Parameters

  conf | SSL configuration
  use_tickets | Enable or disable (MBEDTLS_SSL_SESSION_TICKETS_ENABLED or MBEDTLS_SSL_SESSION_TICKETS_DISABLED)

## mbedtls_ssl_conf_session_tickets_cb()

void mbedtls_ssl_conf_session_tickets_cb | ( | mbedtls_ssl_config * | conf,
|  | mbedtls_ssl_ticket_write_t * | f_ticket_write,
|  | mbedtls_ssl_ticket_parse_t * | f_ticket_parse,
|  | void * | p_ticket
| ) |  |

Configure SSL session ticket callbacks (server only). (Default: none.)

Note
  On server, session tickets are enabled by providing non-NULL callbacks.
  On client, use `mbedtls_ssl_conf_session_tickets()`.

Parameters

  conf | SSL configuration context
  f_ticket_write | Callback for writing a ticket
  f_ticket_parse | Callback for parsing a ticket
  p_ticket | Context shared by the two callbacks

## mbedtls_ssl_conf_sig_hashes()

void mbedtls_ssl_conf_sig_hashes | ( | mbedtls_ssl_config * | conf,
|  | const int * | hashes
| ) |  |

Set the allowed hashes for signatures during the handshake. (Default: all SHA-2 hashes, largest first. Also SHA-1 if the compile-time option `MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_KEY_EXCHANGE` is enabled.)

Note
  This only affects which hashes are offered and can be used for signatures during the handshake. Hashes for message authentication and the TLS PRF are controlled by the ciphersuite, see `mbedtls_ssl_conf_ciphersuites()`. Hashes used for certificate signature are controlled by the verification profile, see `mbedtls_ssl_conf_cert_profile()`.
  This list should be ordered by decreasing preference (preferred hash first).

Parameters

  conf | SSL configuration
  hashes | Ordered list of allowed signature hashes, terminated by `MBEDTLS_MD_NONE`.

## mbedtls_ssl_conf_sni()

void mbedtls_ssl_conf_sni | ( | mbedtls_ssl_config * | conf,
|  | int(*)(void *, mbedtls_ssl_context *, const unsigned char *, size_t) | f_sni,
|  | void * | p_sni
| ) |  |

Set server side ServerName TLS extension callback (optional, server-side only).

If set, the ServerName callback is called whenever the server receives a ServerName TLS extension from the client during a handshake. The ServerName callback has the following parameters: (void *parameter, mbedtls_ssl_context *ssl, const unsigned char *hostname, size_t len). If a suitable certificate is found, the callback must set the certificate(s) and key(s) to use with `mbedtls_ssl_set_hs_own_cert()` (can be called repeatedly), and may optionally adjust the CA and associated CRL with `mbedtls_ssl_set_hs_ca_chain()` as well as the client authentication mode with `mbedtls_ssl_set_hs_authmode()`, then must return 0. If no matching name is found, the callback must either set a default cert, or return non-zero to abort the handshake at this point.

Parameters

  conf | SSL configuration
  f_sni | verification function
  p_sni | verification parameter

## mbedtls_ssl_conf_srtp_mki_value_supported()

void mbedtls_ssl_conf_srtp_mki_value_supported | ( | mbedtls_ssl_config * | conf,
|  | int | support_mki_value
| ) |  |

Manage support for mki(master key id) value in use_srtp extension. MKI is an optional part of SRTP used for key management and re-keying. See RFC3711 section 3.1 for details. The default value is MBEDTLS_SSL_DTLS_SRTP_MKI_UNSUPPORTED.

Parameters

  conf | The SSL configuration to manage mki support.
  support_mki_value | Enable or disable mki usage. Values are MBEDTLS_SSL_DTLS_SRTP_MKI_UNSUPPORTED or MBEDTLS_SSL_DTLS_SRTP_MKI_SUPPORTED.

## 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_conf_truncated_hmac()

void mbedtls_ssl_conf_truncated_hmac | ( | mbedtls_ssl_config * | conf,
|  | int | truncate
| ) |  |

Activate negotiation of truncated HMAC (Default: MBEDTLS_SSL_TRUNC_HMAC_DISABLED)

Parameters

  conf | SSL configuration
  truncate | Enable or disable (MBEDTLS_SSL_TRUNC_HMAC_ENABLED or MBEDTLS_SSL_TRUNC_HMAC_DISABLED)

## mbedtls_ssl_conf_verify()

void mbedtls_ssl_conf_verify | ( | mbedtls_ssl_config * | conf,
|  | int(*)(void *, mbedtls_x509_crt *, int, uint32_t *) | f_vrfy,
|  | void * | p_vrfy
| ) |  |

Set the verification callback (Optional).

                If set, the provided verify callback is called for each
                certificate in the peer's CRT chain, including the trusted
                root. For more information, please see the documentation of
                \c mbedtls_x509_crt_verify().

Note
  For per context callbacks and contexts, please use mbedtls_ssl_set_verify() instead.

Parameters

  conf | The SSL configuration to use.
  f_vrfy | The verification callback to use during CRT verification.
  p_vrfy | The opaque context to be passed to the callback.

## mbedtls_ssl_config_defaults()

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

Load reasonnable 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_context_load()

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

Load serialized connection data to an SSL context.

See also
  mbedtls_ssl_context_save()

Warning
  The same serialized data must never be loaded into more that one context. In order to ensure that, after successfully loading serialized data to an SSL context, you should immediately destroy or invalidate all copies of the serialized data that was loaded. Loading the same data in more than one context would cause severe security failures including but not limited to loss of confidentiality.

Note
  Before calling this function, the SSL context must be prepared in one of the two following ways. The first way is to take a context freshly initialised with mbedtls_ssl_init() and call mbedtls_ssl_setup() on it with the same mbedtls_ssl_config structure that was used in the original connection. The second way is to call mbedtls_ssl_session_reset() on a context that was previously prepared as above but used in the meantime. Either way, you must not use the context to perform a handshake between calling mbedtls_ssl_setup() or mbedtls_ssl_session_reset() and calling this function. You may however call other setter functions in that time frame as indicated in the note below.
  Before or after calling this function successfully, you also need to configure some connection-specific callbacks and settings before you can use the connection again (unless they were already set before calling mbedtls_ssl_session_reset() and the values are suitable for the present connection). Specifically, you want to call at least mbedtls_ssl_set_bio() and mbedtls_ssl_set_timer_cb(). All other SSL setter functions are not necessary to call, either because they're only used in handshakes, or because the setting is already saved. You might choose to call them anyway, for example in order to share code between the cases of establishing a new connection and the case of loading an already-established connection.
  If you have new information about the path MTU, you want to call mbedtls_ssl_set_mtu() after calling this function, as otherwise this function would overwrite your newly-configured value with the value that was active when the context was saved.
  When this function returns an error code, it calls mbedtls_ssl_free() on `ssl`. In this case, you need to prepare the context with the usual sequence starting with a call to mbedtls_ssl_init() if you want to use it again.

Parameters

  ssl | The SSL context structure to be populated. It must have been prepared as described in the note above.
  buf | The buffer holding the serialized connection 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_VERSION_MISMATCH if the serialized data comes from a different Mbed TLS version or build.
  MBEDTLS_ERR_SSL_BAD_INPUT_DATA if input data is invalid.

## mbedtls_ssl_context_save()

int mbedtls_ssl_context_save | ( | mbedtls_ssl_context * | ssl,
|  | unsigned char * | buf,
|  | size_t | buf_len,
|  | size_t * | olen
| ) |  |

Save an active connection as serialized data in a buffer. This allows the freeing or re-using of the SSL context while still picking up the connection later in a way that it entirely transparent to the peer.

See also
  mbedtls_ssl_context_load()

Note
  This feature is currently only available under certain conditions, see the documentation of the return value MBEDTLS_ERR_SSL_BAD_INPUT_DATA for details.
  When this function succeeds, it calls mbedtls_ssl_session_reset() on `ssl` which as a result is no longer associated with the connection that has been serialized. This avoids creating copies of the connection state. You're then free to either re-use the context structure for a different connection, or call mbedtls_ssl_free() on it. See the documentation of mbedtls_ssl_session_reset() for more details.

Parameters

  ssl | The SSL context to save. On success, it is no longer associated with the connection that has been serialized.
  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`. However, the value of `olen` is only guaranteed to be correct when the function returns MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL or `0`. If the return value is different, then the value of `olen` is undefined.

Returns
  `0` if successful.
  MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL if `buf` is too small.
  MBEDTLS_ERR_SSL_ALLOC_FAILED if memory allocation failed while reseting the context.
  MBEDTLS_ERR_SSL_BAD_INPUT_DATA if a handshake is in progress, or there is pending data for reading or sending, or the connection does not use DTLS 1.2 with an AEAD ciphersuite, or renegotiation is enabled.

## mbedtls_ssl_dtls_srtp_set_mki_value()

int mbedtls_ssl_dtls_srtp_set_mki_value | ( | mbedtls_ssl_context * | ssl,
|  | unsigned char * | mki_value,
|  | uint16_t | mki_len
| ) |  |

Set the mki_value for the current DTLS-SRTP session.

Parameters

  ssl | SSL context to use.
  mki_value | The MKI value to set.
  mki_len | The length of the MKI value.

Note
  This function is relevant on client side only. The server discovers the mki value during handshake. A mki value set on server side using this function is ignored.

Returns
  0 on success
  MBEDTLS_ERR_SSL_BAD_INPUT_DATA
  MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE

## 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_alpn_protocol()

const char* mbedtls_ssl_get_alpn_protocol | ( | const mbedtls_ssl_context * | ssl | ) |

Get the name of the negotiated Application Layer Protocol. This function should be called after the handshake is completed.

Parameters

  ssl | SSL context

Returns
  Protcol name, or NULL if no protocol was negotiated.

## 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_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_dtls_srtp_negotiation_result()

void mbedtls_ssl_get_dtls_srtp_negotiation_result | ( | const mbedtls_ssl_context * | ssl,
|  | mbedtls_dtls_srtp_info * | dtls_srtp_info
| ) |  |

Get the negotiated DTLS-SRTP informations: Protection profile and MKI value.

Warning
  This function must be called after the handshake is completed. The value returned by this function must not be trusted or acted upon before the handshake completes.

Parameters

  ssl | The SSL context to query.

  dtls_srtp_info

  The negotiated DTLS-SRTP informations:
  - Protection profile in use. A direct mapping of the iana defined value for protection profile on an uint16_t. http://www.iana.org/assignments/srtp-protection/srtp-protection.xhtml MBEDTLS_TLS_SRTP_UNSET if the use of SRTP was not negotiated or peer's Hello packet was not parsed yet.
  - mki size and value( if size is > 0 ).

## mbedtls_ssl_get_input_max_frag_len()

size_t mbedtls_ssl_get_input_max_frag_len | ( | const mbedtls_ssl_context * | ssl | ) |

Return the maximum fragment length (payload, in bytes) for the input buffer. This is the negotiated maximum fragment length, or, if there is none, MBEDTLS_SSL_MAX_CONTENT_LEN. If it is not defined either, the value is 2^14. This function works as its predecessor, `mbedtls_ssl_get_max_frag_len()`.

See also
  mbedtls_ssl_conf_max_frag_len()
  mbedtls_ssl_get_max_record_payload()

Parameters

  ssl | SSL context

Returns
  Current maximum fragment length for the output buffer.

## mbedtls_ssl_get_max_frag_len()

MBEDTLS_DEPRECATED size_t mbedtls_ssl_get_max_frag_len | ( | const mbedtls_ssl_context * | ssl | ) |

This function is a deprecated approach to getting the max fragment length. Its an alias for `mbedtls_ssl_get_output_max_frag_len()`, as the behaviour is the same. See `mbedtls_ssl_get_output_max_frag_len()` for more detail.

See also
  mbedtls_ssl_get_input_max_frag_len()
  mbedtls_ssl_get_output_max_frag_len()

Parameters

  ssl | SSL context

Returns
  Current maximum fragment length for the output buffer.

## 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. This takes into account the config.h setting `MBEDTLS_SSL_OUT_CONTENT_LEN`, the configured and negotiated max fragment length extension if used, and for DTLS the path MTU as configured and current record expansion.

Note
  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.
  This function is not available (always returns an error) when record compression is enabled.

See also
  mbedtls_ssl_set_mtu()
  mbedtls_ssl_get_output_max_frag_len()
  mbedtls_ssl_get_input_max_frag_len()
  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_output_max_frag_len()

size_t mbedtls_ssl_get_output_max_frag_len | ( | const mbedtls_ssl_context * | ssl | ) |

Return the maximum fragment length (payload, in bytes) for the output buffer. For the client, this is the configured value. For the server, it is the minimum of two - the configured value and the negotiated one.

See also
  mbedtls_ssl_conf_max_frag_len()
  mbedtls_ssl_get_max_record_payload()

Parameters

  ssl | SSL context

Returns
  Current maximum fragment length for the output buffer.

## mbedtls_ssl_get_peer_cert()

const mbedtls_x509_crt* mbedtls_ssl_get_peer_cert | ( | const mbedtls_ssl_context * | ssl | ) |

Return the peer certificate from the current connection.

Parameters

  ssl | The SSL context to use. This must be initialized and setup.

Returns
  The current peer certificate, if available. The returned certificate is owned by the SSL context and is valid only until the next call to the SSL API.
  `NULL` if no peer certificate is available. This might be because the chosen ciphersuite doesn't use CRTs (PSK-based ciphersuites, for example), or because MBEDTLS_SSL_KEEP_PEER_CERTIFICATE has been disabled, allowing the stack to free the peer's CRT to save memory.

Note
  For one-time inspection of the peer's certificate during the handshake, consider registering an X.509 CRT verification callback through mbedtls_ssl_conf_verify() instead of calling this function. Using mbedtls_ssl_conf_verify() also comes at the benefit of allowing you to influence the verification process, for example by masking expected and tolerated verification failures.

Warning
  You must not use the pointer returned by this function after any further call to the SSL API, including mbedtls_ssl_read() and mbedtls_ssl_write(); this is because the pointer might change during renegotiation, which happens transparently to the user. If you want to use the certificate across API calls, you must make a copy.

## 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)

Note
  This function is not available (always returns an error) when record compression is enabled.

Parameters

  ssl | SSL context

Returns
  Current maximum record expansion in bytes, or MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE if compression is enabled, which makes expansion much less predictable

## mbedtls_ssl_get_session()

int mbedtls_ssl_get_session | ( | const mbedtls_ssl_context * | ssl,
|  | mbedtls_ssl_session * | session
| ) |  |

Save session in order to resume it later (client-side only) Session data is copied to presented session structure.

Parameters

  ssl | SSL context
  session | session context

Returns
  0 if successful, MBEDTLS_ERR_SSL_ALLOC_FAILED if memory allocation failed, MBEDTLS_ERR_SSL_BAD_INPUT_DATA if used server-side or arguments are otherwise invalid.

Note
  Only the server certificate is copied, and not the full chain, so you should not attempt to validate the certificate again by calling `mbedtls_x509_crt_verify()` on it. Instead, you should use the results from the verification in the original handshake by calling `mbedtls_ssl_get_verify_result()` after loading the session again into a new SSL context using `mbedtls_ssl_set_session()`.
  Once the session object is not needed anymore, you should free it by calling `mbedtls_ssl_session_free()`.

See also
  mbedtls_ssl_set_session()

## mbedtls_ssl_get_session_pointer()

const mbedtls_ssl_session* mbedtls_ssl_get_session_pointer | ( | const mbedtls_ssl_context * | ssl | ) |

Get a pointer to the current session structure, for example to serialize it.

Warning
  Ownership of the session remains with the SSL context, and the returned pointer is only guaranteed to be valid until the next API call operating on the same `ssl` context.

See also
  mbedtls_ssl_session_save()

Parameters

  ssl | The SSL context.

Returns
  A pointer to the current session if successful.
  `NULL` if no session is active.

## mbedtls_ssl_get_srtp_profile_as_string()

static const char* mbedtls_ssl_get_srtp_profile_as_string | ( | mbedtls_ssl_srtp_profile | profile | ) |

inline static

Definition at line 3265 of file ssl.h.

References MBEDTLS_TLS_SRTP_AES128_CM_HMAC_SHA1_32, MBEDTLS_TLS_SRTP_AES128_CM_HMAC_SHA1_80, MBEDTLS_TLS_SRTP_NULL_HMAC_SHA1_32, and MBEDTLS_TLS_SRTP_NULL_HMAC_SHA1_80.

## 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 SSL version (SSLv3/TLSv1/etc)

Parameters

  ssl | SSL context

Returns
  a string containing the SSL 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).
  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, 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.

## 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 state is MBEDTLS_SSL_HANDSHAKE_OVER.

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 or MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS, 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.
  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 or MBEDTLS_ERR_SSL_CLIENT_RECONNECT, 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_renegotiate()

int mbedtls_ssl_renegotiate | ( | mbedtls_ssl_context * | ssl | ) |

Initiate an SSL renegotiation on the running connection. Client: perform the renegotiation right now. Server: request renegotiation, which will be performed during the next call to mbedtls_ssl_read() if honored by client.

Parameters

  ssl | SSL context

Returns
  0 if successful, or any mbedtls_ssl_handshake() return value except MBEDTLS_ERR_SSL_CLIENT_RECONNECT that can't happen during a renegotiation.

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, 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_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 mbedstls_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, MBEDTLS_ERR_SSL_HW_ACCEL_FAILED or MBEDTLS_ERR_SSL_COMPRESSION_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()
  mbedtls_ssl_get_session_pointer()

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 `len` bytes, or may be `NULL` if `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`.

Returns
  `0` if successful.
  MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL if `buf` is too small.

## 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_timout != 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_client_transport_id()

int mbedtls_ssl_set_client_transport_id | ( | mbedtls_ssl_context * | ssl,
|  | const unsigned char * | info,
|  | size_t | ilen
| ) |  |

Set client's transport-level identification info. (Server only. DTLS only.)

This is usually the IP address (and port), but could be anything identify the client depending on the underlying network stack. Used for HelloVerifyRequest with DTLS. This is not used to route the actual packets.

Parameters

  ssl | SSL context
  info | Transport-level info identifying the client (eg IP + port)
  ilen | Length of info in bytes

Note
  An internal copy is made, so the info buffer can be reused.

Returns
  0 on success, MBEDTLS_ERR_SSL_BAD_INPUT_DATA if used on client, MBEDTLS_ERR_SSL_ALLOC_FAILED if out of memory.

## mbedtls_ssl_set_datagram_packing()

void mbedtls_ssl_set_datagram_packing | ( | mbedtls_ssl_context * | ssl,
|  | unsigned | allow_packing
| ) |  |

Allow or disallow packing of multiple handshake records within a single datagram.

Parameters

  ssl | The SSL context to configure.
  allow_packing | This determines whether datagram packing may be used or not. A value of `0` means that every record will be sent in a separate datagram; a value of `1` means that, if space permits, multiple handshake messages (including CCS) belonging to a single flight may be packed within a single datagram.

Note
  This is enabled by default and should only be disabled for test purposes, or if datagram packing causes interoperability issues with peers that don't support it.
  Allowing datagram packing reduces the network load since there's less overhead if multiple messages share the same datagram. Also, it increases the handshake efficiency since messages belonging to a single datagram will not be reordered in transit, and so future message buffering or flight retransmission (if no buffering is used) as means to deal with reordering are needed less frequently.
  Application records are not affected by this option and are currently always sent in separate datagrams.

## mbedtls_ssl_set_hostname()

int mbedtls_ssl_set_hostname | ( | mbedtls_ssl_context * | ssl,
|  | const char * | hostname
| ) |  |

Set or reset the hostname to check against the received server certificate. It sets the ServerName TLS extension, too, if that extension is enabled. (client-side only)

Parameters

  ssl | SSL context
  hostname | the server hostname, may be NULL to clear hostname

Note
  Maximum hostname length MBEDTLS_SSL_MAX_HOST_NAME_LEN.

Returns
  0 if successful, MBEDTLS_ERR_SSL_ALLOC_FAILED on allocation failure, MBEDTLS_ERR_SSL_BAD_INPUT_DATA on too long input hostname.

Hostname set to the one provided on success (cleared when NULL). On allocation failure hostname is cleared. On too long input failure, old hostname is unchanged.

## mbedtls_ssl_set_hs_authmode()

void mbedtls_ssl_set_hs_authmode | ( | mbedtls_ssl_context * | ssl,
|  | int | authmode
| ) |  |

Set authmode for the current handshake.

Note
  Same as `mbedtls_ssl_conf_authmode()` but for use within the SNI callback.

Parameters

  ssl | SSL context
  authmode | MBEDTLS_SSL_VERIFY_NONE, MBEDTLS_SSL_VERIFY_OPTIONAL or MBEDTLS_SSL_VERIFY_REQUIRED

## mbedtls_ssl_set_hs_ca_chain()

void mbedtls_ssl_set_hs_ca_chain | ( | mbedtls_ssl_context * | ssl,
|  | mbedtls_x509_crt * | ca_chain,
|  | mbedtls_x509_crl * | ca_crl
| ) |  |

Set the data required to verify peer certificate for the current handshake.

Note
  Same as `mbedtls_ssl_conf_ca_chain()` but for use within the SNI callback.

Parameters

  ssl | SSL context
  ca_chain | trusted CA chain (meaning all fully trusted top-level CAs)
  ca_crl | trusted CA CRLs

## mbedtls_ssl_set_hs_own_cert()

int mbedtls_ssl_set_hs_own_cert | ( | mbedtls_ssl_context * | ssl,
|  | mbedtls_x509_crt * | own_cert,
|  | mbedtls_pk_context * | pk_key
| ) |  |

Set own certificate and key for the current handshake.

Note
  Same as `mbedtls_ssl_conf_own_cert()` but for use within the SNI callback.

Parameters

  ssl | SSL context
  own_cert | own public certificate chain
  pk_key | own private key

Returns
  0 on success or MBEDTLS_ERR_SSL_ALLOC_FAILED

## mbedtls_ssl_set_hs_psk()

int mbedtls_ssl_set_hs_psk | ( | mbedtls_ssl_context * | ssl,
|  | const unsigned char * | psk,
|  | size_t | psk_len
| ) |  |

Set the pre-shared Key (PSK) for the current handshake.

Note
  This should only be called inside the PSK callback, i.e. the function passed to `mbedtls_ssl_conf_psk_cb()`.
  A PSK set by this function takes precedence over a PSK configured by `mbedtls_ssl_conf_psk()`.

Parameters

  ssl | The SSL context to configure a PSK for.
  psk | The pointer to the pre-shared key.
  psk_len | The length of the pre-shared key in bytes.

Returns
  `0` if successful.
  An `MBEDTLS_ERR_SSL_XXX` error code on failure.

## mbedtls_ssl_set_mtu()

void mbedtls_ssl_set_mtu | ( | mbedtls_ssl_context * | ssl,
|  | uint16_t | mtu
| ) |  |

Set the Maximum Tranport Unit (MTU). Special value: 0 means unset (no limit). This represents the maximum size of a datagram payload handled by the transport layer (usually UDP) as determined by the network link and stack. In practice, this controls the maximum size datagram the DTLS layer will pass to the `f_send()` callback set using `mbedtls_ssl_set_bio()`.

Note
  The limit on datagram size is converted to a limit on record payload by subtracting the current overhead of encapsulation and encryption/authentication if any.
  This can be called at any point during the connection, for example when a Path Maximum Transfer Unit (PMTU) estimate becomes available from other sources, such as lower (or higher) protocol layers.
  This setting only controls the size of the packets we send, and does not restrict the size of the datagrams we're willing to receive. Client-side, you can request the server to use smaller records with `mbedtls_ssl_conf_max_frag_len()`.
  If both a MTU and a maximum fragment length have been configured (or negotiated with the peer), the resulting lower limit on record payload (see first note) is used.
  This can only be used to decrease the maximum size of datagrams (hence records, see first note) sent. It cannot be used to increase the maximum size of records over the limit set by MBEDTLS_SSL_OUT_CONTENT_LEN.
  Values lower than the current record layer expansion will result in an error when trying to send data.
  Using record compression together with a non-zero MTU value will result in an error when trying to send data.

Parameters

  ssl | SSL context
  mtu | Value of the path MTU in bytes

## mbedtls_ssl_set_session()

int mbedtls_ssl_set_session | ( | mbedtls_ssl_context * | ssl,
|  | const mbedtls_ssl_session * | session
| ) |  |

Request resumption of session (client-side only) Session data is copied from presented session structure.

Parameters

  ssl | SSL context
  session | session context

Returns
  0 if successful, MBEDTLS_ERR_SSL_ALLOC_FAILED if memory allocation failed, MBEDTLS_ERR_SSL_BAD_INPUT_DATA if used server-side or arguments are otherwise invalid

See also
  mbedtls_ssl_get_session()

## 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://tls.mbed.org/kb/how-to/dtls-tutorial

## mbedtls_ssl_set_verify()

void mbedtls_ssl_set_verify | ( | mbedtls_ssl_context * | ssl,
|  | int(*)(void *, mbedtls_x509_crt *, int, uint32_t *) | f_vrfy,
|  | void * | p_vrfy
| ) |  |

Set a connection-specific verification callback (optional).

                If set, the provided verify callback is called for each
                certificate in the peer's CRT chain, including the trusted
                root. For more information, please see the documentation of
                \c mbedtls_x509_crt_verify().

Note
  This call is analogous to mbedtls_ssl_conf_verify() but binds the verification callback and context to an SSL context as opposed to an SSL configuration. If mbedtls_ssl_conf_verify() and mbedtls_ssl_set_verify() are both used, mbedtls_ssl_set_verify() takes precedence.

Parameters

  ssl | The SSL context to use.
  f_vrfy | The verification callback to use during CRT verification.
  p_vrfy | The opaque context to be passed to the callback.

## 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.

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.
  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 or MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS, 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 that 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_output_max_frag_len()` 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.