1 /** 2 * \file ssl.h 3 * 4 * \brief SSL/TLS functions. 5 */ 6 /* 7 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved 8 * SPDX-License-Identifier: Apache-2.0 9 * 10 * Licensed under the Apache License, Version 2.0 (the "License"); you may 11 * not use this file except in compliance with the License. 12 * You may obtain a copy of the License at 13 * 14 * http://www.apache.org/licenses/LICENSE-2.0 15 * 16 * Unless required by applicable law or agreed to in writing, software 17 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 18 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 19 * See the License for the specific language governing permissions and 20 * limitations under the License. 21 * 22 * This file is part of mbed TLS (https://tls.mbed.org) 23 */ 24 #ifndef MBEDTLS_SSL_H 25 #define MBEDTLS_SSL_H 26 27 #if !defined(MBEDTLS_CONFIG_FILE) 28 #include "config.h" 29 #else 30 #include MBEDTLS_CONFIG_FILE 31 #endif 32 33 #include "bignum.h" 34 #include "ecp.h" 35 36 #include "ssl_ciphersuites.h" 37 38 #if defined(MBEDTLS_X509_CRT_PARSE_C) 39 #include "x509_crt.h" 40 #include "x509_crl.h" 41 #endif 42 43 #if defined(MBEDTLS_DHM_C) 44 #include "dhm.h" 45 #endif 46 47 #if defined(MBEDTLS_ECDH_C) 48 #include "ecdh.h" 49 #endif 50 51 #if defined(MBEDTLS_ZLIB_SUPPORT) 52 53 #if defined(MBEDTLS_DEPRECATED_WARNING) 54 #warning "Record compression support via MBEDTLS_ZLIB_SUPPORT is deprecated and will be removed in the next major revision of the library" 55 #endif 56 57 #if defined(MBEDTLS_DEPRECATED_REMOVED) 58 #error "Record compression support via MBEDTLS_ZLIB_SUPPORT is deprecated and cannot be used if MBEDTLS_DEPRECATED_REMOVED is set" 59 #endif 60 61 #include "zlib.h" 62 #endif 63 64 #if defined(MBEDTLS_HAVE_TIME) 65 #include "platform_time.h" 66 #endif 67 68 /* 69 * SSL Error codes 70 */ 71 #define MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE -0x7080 /**< The requested feature is not available. */ 72 #define MBEDTLS_ERR_SSL_BAD_INPUT_DATA -0x7100 /**< Bad input parameters to function. */ 73 #define MBEDTLS_ERR_SSL_INVALID_MAC -0x7180 /**< Verification of the message MAC failed. */ 74 #define MBEDTLS_ERR_SSL_INVALID_RECORD -0x7200 /**< An invalid SSL record was received. */ 75 #define MBEDTLS_ERR_SSL_CONN_EOF -0x7280 /**< The connection indicated an EOF. */ 76 #define MBEDTLS_ERR_SSL_UNKNOWN_CIPHER -0x7300 /**< An unknown cipher was received. */ 77 #define MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN -0x7380 /**< The server has no ciphersuites in common with the client. */ 78 #define MBEDTLS_ERR_SSL_NO_RNG -0x7400 /**< No RNG was provided to the SSL module. */ 79 #define MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE -0x7480 /**< No client certification received from the client, but required by the authentication mode. */ 80 #define MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE -0x7500 /**< Our own certificate(s) is/are too large to send in an SSL message. */ 81 #define MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED -0x7580 /**< The own certificate is not set, but needed by the server. */ 82 #define MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED -0x7600 /**< The own private key or pre-shared key is not set, but needed. */ 83 #define MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED -0x7680 /**< No CA Chain is set, but required to operate. */ 84 #define MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE -0x7700 /**< An unexpected message was received from our peer. */ 85 #define MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE -0x7780 /**< A fatal alert message was received from our peer. */ 86 #define MBEDTLS_ERR_SSL_PEER_VERIFY_FAILED -0x7800 /**< Verification of our peer failed. */ 87 #define MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY -0x7880 /**< The peer notified us that the connection is going to be closed. */ 88 #define MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO -0x7900 /**< Processing of the ClientHello handshake message failed. */ 89 #define MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO -0x7980 /**< Processing of the ServerHello handshake message failed. */ 90 #define MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE -0x7A00 /**< Processing of the Certificate handshake message failed. */ 91 #define MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST -0x7A80 /**< Processing of the CertificateRequest handshake message failed. */ 92 #define MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE -0x7B00 /**< Processing of the ServerKeyExchange handshake message failed. */ 93 #define MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE -0x7B80 /**< Processing of the ServerHelloDone handshake message failed. */ 94 #define MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE -0x7C00 /**< Processing of the ClientKeyExchange handshake message failed. */ 95 #define MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP -0x7C80 /**< Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Read Public. */ 96 #define MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS -0x7D00 /**< Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Calculate Secret. */ 97 #define MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY -0x7D80 /**< Processing of the CertificateVerify handshake message failed. */ 98 #define MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC -0x7E00 /**< Processing of the ChangeCipherSpec handshake message failed. */ 99 #define MBEDTLS_ERR_SSL_BAD_HS_FINISHED -0x7E80 /**< Processing of the Finished handshake message failed. */ 100 #define MBEDTLS_ERR_SSL_ALLOC_FAILED -0x7F00 /**< Memory allocation failed */ 101 #define MBEDTLS_ERR_SSL_HW_ACCEL_FAILED -0x7F80 /**< Hardware acceleration function returned with error */ 102 #define MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH -0x6F80 /**< Hardware acceleration function skipped / left alone data */ 103 #define MBEDTLS_ERR_SSL_COMPRESSION_FAILED -0x6F00 /**< Processing of the compression / decompression failed */ 104 #define MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION -0x6E80 /**< Handshake protocol not within min/max boundaries */ 105 #define MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET -0x6E00 /**< Processing of the NewSessionTicket handshake message failed. */ 106 #define MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED -0x6D80 /**< Session ticket has expired. */ 107 #define MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH -0x6D00 /**< Public key type mismatch (eg, asked for RSA key exchange and presented EC key) */ 108 #define MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY -0x6C80 /**< Unknown identity received (eg, PSK identity) */ 109 #define MBEDTLS_ERR_SSL_INTERNAL_ERROR -0x6C00 /**< Internal error (eg, unexpected failure in lower-level module) */ 110 #define MBEDTLS_ERR_SSL_COUNTER_WRAPPING -0x6B80 /**< A counter would wrap (eg, too many messages exchanged). */ 111 #define MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO -0x6B00 /**< Unexpected message at ServerHello in renegotiation. */ 112 #define MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED -0x6A80 /**< DTLS client must retry for hello verification */ 113 #define MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL -0x6A00 /**< A buffer is too small to receive or write a message */ 114 #define MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE -0x6980 /**< None of the common ciphersuites is usable (eg, no suitable certificate, see debug messages). */ 115 #define MBEDTLS_ERR_SSL_WANT_READ -0x6900 /**< No data of requested type currently available on underlying transport. */ 116 #define MBEDTLS_ERR_SSL_WANT_WRITE -0x6880 /**< Connection requires a write call. */ 117 #define MBEDTLS_ERR_SSL_TIMEOUT -0x6800 /**< The operation timed out. */ 118 #define MBEDTLS_ERR_SSL_CLIENT_RECONNECT -0x6780 /**< The client initiated a reconnect from the same port. */ 119 #define MBEDTLS_ERR_SSL_UNEXPECTED_RECORD -0x6700 /**< Record header looks valid but is not expected. */ 120 #define MBEDTLS_ERR_SSL_NON_FATAL -0x6680 /**< The alert message received indicates a non-fatal error. */ 121 #define MBEDTLS_ERR_SSL_INVALID_VERIFY_HASH -0x6600 /**< Couldn't set the hash for verifying CertificateVerify */ 122 #define MBEDTLS_ERR_SSL_CONTINUE_PROCESSING -0x6580 /**< Internal-only message signaling that further message-processing should be done */ 123 #define MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS -0x6500 /**< The asynchronous operation is not completed yet. */ 124 #define MBEDTLS_ERR_SSL_EARLY_MESSAGE -0x6480 /**< Internal-only message signaling that a message arrived early. */ 125 #define MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS -0x7000 /**< A cryptographic operation is in progress. Try again later. */ 126 127 /* 128 * Various constants 129 */ 130 #define MBEDTLS_SSL_MAJOR_VERSION_3 3 131 #define MBEDTLS_SSL_MINOR_VERSION_0 0 /*!< SSL v3.0 */ 132 #define MBEDTLS_SSL_MINOR_VERSION_1 1 /*!< TLS v1.0 */ 133 #define MBEDTLS_SSL_MINOR_VERSION_2 2 /*!< TLS v1.1 */ 134 #define MBEDTLS_SSL_MINOR_VERSION_3 3 /*!< TLS v1.2 */ 135 136 #define MBEDTLS_SSL_TRANSPORT_STREAM 0 /*!< TLS */ 137 #define MBEDTLS_SSL_TRANSPORT_DATAGRAM 1 /*!< DTLS */ 138 139 #define MBEDTLS_SSL_MAX_HOST_NAME_LEN 255 /*!< Maximum host name defined in RFC 1035 */ 140 141 /* RFC 6066 section 4, see also mfl_code_to_length in ssl_tls.c 142 * NONE must be zero so that memset()ing structure to zero works */ 143 #define MBEDTLS_SSL_MAX_FRAG_LEN_NONE 0 /*!< don't use this extension */ 144 #define MBEDTLS_SSL_MAX_FRAG_LEN_512 1 /*!< MaxFragmentLength 2^9 */ 145 #define MBEDTLS_SSL_MAX_FRAG_LEN_1024 2 /*!< MaxFragmentLength 2^10 */ 146 #define MBEDTLS_SSL_MAX_FRAG_LEN_2048 3 /*!< MaxFragmentLength 2^11 */ 147 #define MBEDTLS_SSL_MAX_FRAG_LEN_4096 4 /*!< MaxFragmentLength 2^12 */ 148 #define MBEDTLS_SSL_MAX_FRAG_LEN_INVALID 5 /*!< first invalid value */ 149 150 #define MBEDTLS_SSL_IS_CLIENT 0 151 #define MBEDTLS_SSL_IS_SERVER 1 152 153 #define MBEDTLS_SSL_IS_NOT_FALLBACK 0 154 #define MBEDTLS_SSL_IS_FALLBACK 1 155 156 #define MBEDTLS_SSL_EXTENDED_MS_DISABLED 0 157 #define MBEDTLS_SSL_EXTENDED_MS_ENABLED 1 158 159 #define MBEDTLS_SSL_ETM_DISABLED 0 160 #define MBEDTLS_SSL_ETM_ENABLED 1 161 162 #define MBEDTLS_SSL_COMPRESS_NULL 0 163 #define MBEDTLS_SSL_COMPRESS_DEFLATE 1 164 165 #define MBEDTLS_SSL_VERIFY_NONE 0 166 #define MBEDTLS_SSL_VERIFY_OPTIONAL 1 167 #define MBEDTLS_SSL_VERIFY_REQUIRED 2 168 #define MBEDTLS_SSL_VERIFY_UNSET 3 /* Used only for sni_authmode */ 169 170 #define MBEDTLS_SSL_LEGACY_RENEGOTIATION 0 171 #define MBEDTLS_SSL_SECURE_RENEGOTIATION 1 172 173 #define MBEDTLS_SSL_RENEGOTIATION_DISABLED 0 174 #define MBEDTLS_SSL_RENEGOTIATION_ENABLED 1 175 176 #define MBEDTLS_SSL_ANTI_REPLAY_DISABLED 0 177 #define MBEDTLS_SSL_ANTI_REPLAY_ENABLED 1 178 179 #define MBEDTLS_SSL_RENEGOTIATION_NOT_ENFORCED -1 180 #define MBEDTLS_SSL_RENEGO_MAX_RECORDS_DEFAULT 16 181 182 #define MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION 0 183 #define MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION 1 184 #define MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE 2 185 186 #define MBEDTLS_SSL_TRUNC_HMAC_DISABLED 0 187 #define MBEDTLS_SSL_TRUNC_HMAC_ENABLED 1 188 #define MBEDTLS_SSL_TRUNCATED_HMAC_LEN 10 /* 80 bits, rfc 6066 section 7 */ 189 190 #define MBEDTLS_SSL_SESSION_TICKETS_DISABLED 0 191 #define MBEDTLS_SSL_SESSION_TICKETS_ENABLED 1 192 193 #define MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED 0 194 #define MBEDTLS_SSL_CBC_RECORD_SPLITTING_ENABLED 1 195 196 #define MBEDTLS_SSL_ARC4_ENABLED 0 197 #define MBEDTLS_SSL_ARC4_DISABLED 1 198 199 #define MBEDTLS_SSL_PRESET_DEFAULT 0 200 #define MBEDTLS_SSL_PRESET_SUITEB 2 201 202 #define MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED 1 203 #define MBEDTLS_SSL_CERT_REQ_CA_LIST_DISABLED 0 204 205 /* 206 * Default range for DTLS retransmission timer value, in milliseconds. 207 * RFC 6347 4.2.4.1 says from 1 second to 60 seconds. 208 */ 209 #define MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MIN 1000 210 #define MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MAX 60000 211 212 /** 213 * \name SECTION: Module settings 214 * 215 * The configuration options you can set for this module are in this section. 216 * Either change them in config.h or define them on the compiler command line. 217 * \{ 218 */ 219 220 #if !defined(MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME) 221 #define MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME 86400 /**< Lifetime of session tickets (if enabled) */ 222 #endif 223 224 /* 225 * Maximum fragment length in bytes, 226 * determines the size of each of the two internal I/O buffers. 227 * 228 * Note: the RFC defines the default size of SSL / TLS messages. If you 229 * change the value here, other clients / servers may not be able to 230 * communicate with you anymore. Only change this value if you control 231 * both sides of the connection and have it reduced at both sides, or 232 * if you're using the Max Fragment Length extension and you know all your 233 * peers are using it too! 234 */ 235 #if !defined(MBEDTLS_SSL_MAX_CONTENT_LEN) 236 #define MBEDTLS_SSL_MAX_CONTENT_LEN 16384 /**< Size of the input / output buffer */ 237 #endif 238 239 #if !defined(MBEDTLS_SSL_IN_CONTENT_LEN) 240 #define MBEDTLS_SSL_IN_CONTENT_LEN MBEDTLS_SSL_MAX_CONTENT_LEN 241 #endif 242 243 #if !defined(MBEDTLS_SSL_OUT_CONTENT_LEN) 244 #define MBEDTLS_SSL_OUT_CONTENT_LEN MBEDTLS_SSL_MAX_CONTENT_LEN 245 #endif 246 247 /* 248 * Maximum number of heap-allocated bytes for the purpose of 249 * DTLS handshake message reassembly and future message buffering. 250 */ 251 #if !defined(MBEDTLS_SSL_DTLS_MAX_BUFFERING) 252 #define MBEDTLS_SSL_DTLS_MAX_BUFFERING 32768 253 #endif 254 255 /* \} name SECTION: Module settings */ 256 257 /* 258 * Length of the verify data for secure renegotiation 259 */ 260 #if defined(MBEDTLS_SSL_PROTO_SSL3) 261 #define MBEDTLS_SSL_VERIFY_DATA_MAX_LEN 36 262 #else 263 #define MBEDTLS_SSL_VERIFY_DATA_MAX_LEN 12 264 #endif 265 266 /* 267 * Signaling ciphersuite values (SCSV) 268 */ 269 #define MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO 0xFF /**< renegotiation info ext */ 270 #define MBEDTLS_SSL_FALLBACK_SCSV_VALUE 0x5600 /**< RFC 7507 section 2 */ 271 272 /* 273 * Supported Signature and Hash algorithms (For TLS 1.2) 274 * RFC 5246 section 7.4.1.4.1 275 */ 276 #define MBEDTLS_SSL_HASH_NONE 0 277 #define MBEDTLS_SSL_HASH_MD5 1 278 #define MBEDTLS_SSL_HASH_SHA1 2 279 #define MBEDTLS_SSL_HASH_SHA224 3 280 #define MBEDTLS_SSL_HASH_SHA256 4 281 #define MBEDTLS_SSL_HASH_SHA384 5 282 #define MBEDTLS_SSL_HASH_SHA512 6 283 284 #define MBEDTLS_SSL_SIG_ANON 0 285 #define MBEDTLS_SSL_SIG_RSA 1 286 #define MBEDTLS_SSL_SIG_ECDSA 3 287 288 /* 289 * Client Certificate Types 290 * RFC 5246 section 7.4.4 plus RFC 4492 section 5.5 291 */ 292 #define MBEDTLS_SSL_CERT_TYPE_RSA_SIGN 1 293 #define MBEDTLS_SSL_CERT_TYPE_ECDSA_SIGN 64 294 295 /* 296 * Message, alert and handshake types 297 */ 298 #define MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC 20 299 #define MBEDTLS_SSL_MSG_ALERT 21 300 #define MBEDTLS_SSL_MSG_HANDSHAKE 22 301 #define MBEDTLS_SSL_MSG_APPLICATION_DATA 23 302 303 #define MBEDTLS_SSL_ALERT_LEVEL_WARNING 1 304 #define MBEDTLS_SSL_ALERT_LEVEL_FATAL 2 305 306 #define MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY 0 /* 0x00 */ 307 #define MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE 10 /* 0x0A */ 308 #define MBEDTLS_SSL_ALERT_MSG_BAD_RECORD_MAC 20 /* 0x14 */ 309 #define MBEDTLS_SSL_ALERT_MSG_DECRYPTION_FAILED 21 /* 0x15 */ 310 #define MBEDTLS_SSL_ALERT_MSG_RECORD_OVERFLOW 22 /* 0x16 */ 311 #define MBEDTLS_SSL_ALERT_MSG_DECOMPRESSION_FAILURE 30 /* 0x1E */ 312 #define MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE 40 /* 0x28 */ 313 #define MBEDTLS_SSL_ALERT_MSG_NO_CERT 41 /* 0x29 */ 314 #define MBEDTLS_SSL_ALERT_MSG_BAD_CERT 42 /* 0x2A */ 315 #define MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT 43 /* 0x2B */ 316 #define MBEDTLS_SSL_ALERT_MSG_CERT_REVOKED 44 /* 0x2C */ 317 #define MBEDTLS_SSL_ALERT_MSG_CERT_EXPIRED 45 /* 0x2D */ 318 #define MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN 46 /* 0x2E */ 319 #define MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER 47 /* 0x2F */ 320 #define MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA 48 /* 0x30 */ 321 #define MBEDTLS_SSL_ALERT_MSG_ACCESS_DENIED 49 /* 0x31 */ 322 #define MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR 50 /* 0x32 */ 323 #define MBEDTLS_SSL_ALERT_MSG_DECRYPT_ERROR 51 /* 0x33 */ 324 #define MBEDTLS_SSL_ALERT_MSG_EXPORT_RESTRICTION 60 /* 0x3C */ 325 #define MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION 70 /* 0x46 */ 326 #define MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY 71 /* 0x47 */ 327 #define MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR 80 /* 0x50 */ 328 #define MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK 86 /* 0x56 */ 329 #define MBEDTLS_SSL_ALERT_MSG_USER_CANCELED 90 /* 0x5A */ 330 #define MBEDTLS_SSL_ALERT_MSG_NO_RENEGOTIATION 100 /* 0x64 */ 331 #define MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT 110 /* 0x6E */ 332 #define MBEDTLS_SSL_ALERT_MSG_UNRECOGNIZED_NAME 112 /* 0x70 */ 333 #define MBEDTLS_SSL_ALERT_MSG_UNKNOWN_PSK_IDENTITY 115 /* 0x73 */ 334 #define MBEDTLS_SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL 120 /* 0x78 */ 335 336 #define MBEDTLS_SSL_HS_HELLO_REQUEST 0 337 #define MBEDTLS_SSL_HS_CLIENT_HELLO 1 338 #define MBEDTLS_SSL_HS_SERVER_HELLO 2 339 #define MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST 3 340 #define MBEDTLS_SSL_HS_NEW_SESSION_TICKET 4 341 #define MBEDTLS_SSL_HS_CERTIFICATE 11 342 #define MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE 12 343 #define MBEDTLS_SSL_HS_CERTIFICATE_REQUEST 13 344 #define MBEDTLS_SSL_HS_SERVER_HELLO_DONE 14 345 #define MBEDTLS_SSL_HS_CERTIFICATE_VERIFY 15 346 #define MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE 16 347 #define MBEDTLS_SSL_HS_FINISHED 20 348 349 /* 350 * TLS extensions 351 */ 352 #define MBEDTLS_TLS_EXT_SERVERNAME 0 353 #define MBEDTLS_TLS_EXT_SERVERNAME_HOSTNAME 0 354 355 #define MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH 1 356 357 #define MBEDTLS_TLS_EXT_TRUNCATED_HMAC 4 358 359 #define MBEDTLS_TLS_EXT_SUPPORTED_ELLIPTIC_CURVES 10 360 #define MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS 11 361 362 #define MBEDTLS_TLS_EXT_SIG_ALG 13 363 364 #define MBEDTLS_TLS_EXT_ALPN 16 365 366 #define MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC 22 /* 0x16 */ 367 #define MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET 0x0017 /* 23 */ 368 369 #define MBEDTLS_TLS_EXT_SESSION_TICKET 35 370 371 #define MBEDTLS_TLS_EXT_ECJPAKE_KKPP 256 /* experimental */ 372 373 #define MBEDTLS_TLS_EXT_RENEGOTIATION_INFO 0xFF01 374 375 /* 376 * Size defines 377 */ 378 #if !defined(MBEDTLS_PSK_MAX_LEN) 379 #define MBEDTLS_PSK_MAX_LEN 32 /* 256 bits */ 380 #endif 381 382 /* Dummy type used only for its size */ 383 union mbedtls_ssl_premaster_secret 384 { 385 #if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) 386 unsigned char _pms_rsa[48]; /* RFC 5246 8.1.1 */ 387 #endif 388 #if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) 389 unsigned char _pms_dhm[MBEDTLS_MPI_MAX_SIZE]; /* RFC 5246 8.1.2 */ 390 #endif 391 #if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \ 392 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \ 393 defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \ 394 defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED) 395 unsigned char _pms_ecdh[MBEDTLS_ECP_MAX_BYTES]; /* RFC 4492 5.10 */ 396 #endif 397 #if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED) 398 unsigned char _pms_psk[4 + 2 * MBEDTLS_PSK_MAX_LEN]; /* RFC 4279 2 */ 399 #endif 400 #if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED) 401 unsigned char _pms_dhe_psk[4 + MBEDTLS_MPI_MAX_SIZE 402 + MBEDTLS_PSK_MAX_LEN]; /* RFC 4279 3 */ 403 #endif 404 #if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED) 405 unsigned char _pms_rsa_psk[52 + MBEDTLS_PSK_MAX_LEN]; /* RFC 4279 4 */ 406 #endif 407 #if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) 408 unsigned char _pms_ecdhe_psk[4 + MBEDTLS_ECP_MAX_BYTES 409 + MBEDTLS_PSK_MAX_LEN]; /* RFC 5489 2 */ 410 #endif 411 #if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED) 412 unsigned char _pms_ecjpake[32]; /* Thread spec: SHA-256 output */ 413 #endif 414 }; 415 416 #define MBEDTLS_PREMASTER_SIZE sizeof( union mbedtls_ssl_premaster_secret ) 417 418 #ifdef __cplusplus 419 extern "C" { 420 #endif 421 422 /* 423 * SSL state machine 424 */ 425 typedef enum 426 { 427 MBEDTLS_SSL_HELLO_REQUEST, 428 MBEDTLS_SSL_CLIENT_HELLO, 429 MBEDTLS_SSL_SERVER_HELLO, 430 MBEDTLS_SSL_SERVER_CERTIFICATE, 431 MBEDTLS_SSL_SERVER_KEY_EXCHANGE, 432 MBEDTLS_SSL_CERTIFICATE_REQUEST, 433 MBEDTLS_SSL_SERVER_HELLO_DONE, 434 MBEDTLS_SSL_CLIENT_CERTIFICATE, 435 MBEDTLS_SSL_CLIENT_KEY_EXCHANGE, 436 MBEDTLS_SSL_CERTIFICATE_VERIFY, 437 MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC, 438 MBEDTLS_SSL_CLIENT_FINISHED, 439 MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC, 440 MBEDTLS_SSL_SERVER_FINISHED, 441 MBEDTLS_SSL_FLUSH_BUFFERS, 442 MBEDTLS_SSL_HANDSHAKE_WRAPUP, 443 MBEDTLS_SSL_HANDSHAKE_OVER, 444 MBEDTLS_SSL_SERVER_NEW_SESSION_TICKET, 445 MBEDTLS_SSL_SERVER_HELLO_VERIFY_REQUEST_SENT, 446 } 447 mbedtls_ssl_states; 448 449 /** 450 * \brief Callback type: send data on the network. 451 * 452 * \note That callback may be either blocking or non-blocking. 453 * 454 * \param ctx Context for the send callback (typically a file descriptor) 455 * \param buf Buffer holding the data to send 456 * \param len Length of the data to send 457 * 458 * \return The callback must return the number of bytes sent if any, 459 * or a non-zero error code. 460 * If performing non-blocking I/O, \c MBEDTLS_ERR_SSL_WANT_WRITE 461 * must be returned when the operation would block. 462 * 463 * \note The callback is allowed to send fewer bytes than requested. 464 * It must always return the number of bytes actually sent. 465 */ 466 typedef int mbedtls_ssl_send_t( void *ctx, 467 const unsigned char *buf, 468 size_t len ); 469 470 /** 471 * \brief Callback type: receive data from the network. 472 * 473 * \note That callback may be either blocking or non-blocking. 474 * 475 * \param ctx Context for the receive callback (typically a file 476 * descriptor) 477 * \param buf Buffer to write the received data to 478 * \param len Length of the receive buffer 479 * 480 * \return The callback must return the number of bytes received, 481 * or a non-zero error code. 482 * If performing non-blocking I/O, \c MBEDTLS_ERR_SSL_WANT_READ 483 * must be returned when the operation would block. 484 * 485 * \note The callback may receive fewer bytes than the length of the 486 * buffer. It must always return the number of bytes actually 487 * received and written to the buffer. 488 */ 489 typedef int mbedtls_ssl_recv_t( void *ctx, 490 unsigned char *buf, 491 size_t len ); 492 493 /** 494 * \brief Callback type: receive data from the network, with timeout 495 * 496 * \note That callback must block until data is received, or the 497 * timeout delay expires, or the operation is interrupted by a 498 * signal. 499 * 500 * \param ctx Context for the receive callback (typically a file descriptor) 501 * \param buf Buffer to write the received data to 502 * \param len Length of the receive buffer 503 * \param timeout Maximum nomber of millisecondes to wait for data 504 * 0 means no timeout (potentially waiting forever) 505 * 506 * \return The callback must return the number of bytes received, 507 * or a non-zero error code: 508 * \c MBEDTLS_ERR_SSL_TIMEOUT if the operation timed out, 509 * \c MBEDTLS_ERR_SSL_WANT_READ if interrupted by a signal. 510 * 511 * \note The callback may receive fewer bytes than the length of the 512 * buffer. It must always return the number of bytes actually 513 * received and written to the buffer. 514 */ 515 typedef int mbedtls_ssl_recv_timeout_t( void *ctx, 516 unsigned char *buf, 517 size_t len, 518 uint32_t timeout ); 519 /** 520 * \brief Callback type: set a pair of timers/delays to watch 521 * 522 * \param ctx Context pointer 523 * \param int_ms Intermediate delay in milliseconds 524 * \param fin_ms Final delay in milliseconds 525 * 0 cancels the current timer. 526 * 527 * \note This callback must at least store the necessary information 528 * for the associated \c mbedtls_ssl_get_timer_t callback to 529 * return correct information. 530 * 531 * \note If using a event-driven style of programming, an event must 532 * be generated when the final delay is passed. The event must 533 * cause a call to \c mbedtls_ssl_handshake() with the proper 534 * SSL context to be scheduled. Care must be taken to ensure 535 * that at most one such call happens at a time. 536 * 537 * \note Only one timer at a time must be running. Calling this 538 * function while a timer is running must cancel it. Cancelled 539 * timers must not generate any event. 540 */ 541 typedef void mbedtls_ssl_set_timer_t( void * ctx, 542 uint32_t int_ms, 543 uint32_t fin_ms ); 544 545 /** 546 * \brief Callback type: get status of timers/delays 547 * 548 * \param ctx Context pointer 549 * 550 * \return This callback must return: 551 * -1 if cancelled (fin_ms == 0), 552 * 0 if none of the delays have passed, 553 * 1 if only the intermediate delay has passed, 554 * 2 if the final delay has passed. 555 */ 556 typedef int mbedtls_ssl_get_timer_t( void * ctx ); 557 558 /* Defined below */ 559 typedef struct mbedtls_ssl_session mbedtls_ssl_session; 560 typedef struct mbedtls_ssl_context mbedtls_ssl_context; 561 typedef struct mbedtls_ssl_config mbedtls_ssl_config; 562 563 /* Defined in ssl_internal.h */ 564 typedef struct mbedtls_ssl_transform mbedtls_ssl_transform; 565 typedef struct mbedtls_ssl_handshake_params mbedtls_ssl_handshake_params; 566 typedef struct mbedtls_ssl_sig_hash_set_t mbedtls_ssl_sig_hash_set_t; 567 #if defined(MBEDTLS_X509_CRT_PARSE_C) 568 typedef struct mbedtls_ssl_key_cert mbedtls_ssl_key_cert; 569 #endif 570 #if defined(MBEDTLS_SSL_PROTO_DTLS) 571 typedef struct mbedtls_ssl_flight_item mbedtls_ssl_flight_item; 572 #endif 573 574 #if defined(MBEDTLS_SSL_ASYNC_PRIVATE) 575 #if defined(MBEDTLS_X509_CRT_PARSE_C) 576 /** 577 * \brief Callback type: start external signature operation. 578 * 579 * This callback is called during an SSL handshake to start 580 * a signature decryption operation using an 581 * external processor. The parameter \p cert contains 582 * the public key; it is up to the callback function to 583 * determine how to access the associated private key. 584 * 585 * This function typically sends or enqueues a request, and 586 * does not wait for the operation to complete. This allows 587 * the handshake step to be non-blocking. 588 * 589 * The parameters \p ssl and \p cert are guaranteed to remain 590 * valid throughout the handshake. On the other hand, this 591 * function must save the contents of \p hash if the value 592 * is needed for later processing, because the \p hash buffer 593 * is no longer valid after this function returns. 594 * 595 * This function may call mbedtls_ssl_set_async_operation_data() 596 * to store an operation context for later retrieval 597 * by the resume or cancel callback. 598 * 599 * \note For RSA signatures, this function must produce output 600 * that is consistent with PKCS#1 v1.5 in the same way as 601 * mbedtls_rsa_pkcs1_sign(). Before the private key operation, 602 * apply the padding steps described in RFC 8017, section 9.2 603 * "EMSA-PKCS1-v1_5" as follows. 604 * - If \p md_alg is #MBEDTLS_MD_NONE, apply the PKCS#1 v1.5 605 * encoding, treating \p hash as the DigestInfo to be 606 * padded. In other words, apply EMSA-PKCS1-v1_5 starting 607 * from step 3, with `T = hash` and `tLen = hash_len`. 608 * - If `md_alg != MBEDTLS_MD_NONE`, apply the PKCS#1 v1.5 609 * encoding, treating \p hash as the hash to be encoded and 610 * padded. In other words, apply EMSA-PKCS1-v1_5 starting 611 * from step 2, with `digestAlgorithm` obtained by calling 612 * mbedtls_oid_get_oid_by_md() on \p md_alg. 613 * 614 * \note For ECDSA signatures, the output format is the DER encoding 615 * `Ecdsa-Sig-Value` defined in 616 * [RFC 4492 section 5.4](https://tools.ietf.org/html/rfc4492#section-5.4). 617 * 618 * \param ssl The SSL connection instance. It should not be 619 * modified other than via 620 * mbedtls_ssl_set_async_operation_data(). 621 * \param cert Certificate containing the public key. 622 * In simple cases, this is one of the pointers passed to 623 * mbedtls_ssl_conf_own_cert() when configuring the SSL 624 * connection. However, if other callbacks are used, this 625 * property may not hold. For example, if an SNI callback 626 * is registered with mbedtls_ssl_conf_sni(), then 627 * this callback determines what certificate is used. 628 * \param md_alg Hash algorithm. 629 * \param hash Buffer containing the hash. This buffer is 630 * no longer valid when the function returns. 631 * \param hash_len Size of the \c hash buffer in bytes. 632 * 633 * \return 0 if the operation was started successfully and the SSL 634 * stack should call the resume callback immediately. 635 * \return #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS if the operation 636 * was started successfully and the SSL stack should return 637 * immediately without calling the resume callback yet. 638 * \return #MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH if the external 639 * processor does not support this key. The SSL stack will 640 * use the private key object instead. 641 * \return Any other error indicates a fatal failure and is 642 * propagated up the call chain. The callback should 643 * use \c MBEDTLS_ERR_PK_xxx error codes, and <b>must not</b> 644 * use \c MBEDTLS_ERR_SSL_xxx error codes except as 645 * directed in the documentation of this callback. 646 */ 647 typedef int mbedtls_ssl_async_sign_t( mbedtls_ssl_context *ssl, 648 mbedtls_x509_crt *cert, 649 mbedtls_md_type_t md_alg, 650 const unsigned char *hash, 651 size_t hash_len ); 652 653 /** 654 * \brief Callback type: start external decryption operation. 655 * 656 * This callback is called during an SSL handshake to start 657 * an RSA decryption operation using an 658 * external processor. The parameter \p cert contains 659 * the public key; it is up to the callback function to 660 * determine how to access the associated private key. 661 * 662 * This function typically sends or enqueues a request, and 663 * does not wait for the operation to complete. This allows 664 * the handshake step to be non-blocking. 665 * 666 * The parameters \p ssl and \p cert are guaranteed to remain 667 * valid throughout the handshake. On the other hand, this 668 * function must save the contents of \p input if the value 669 * is needed for later processing, because the \p input buffer 670 * is no longer valid after this function returns. 671 * 672 * This function may call mbedtls_ssl_set_async_operation_data() 673 * to store an operation context for later retrieval 674 * by the resume or cancel callback. 675 * 676 * \warning RSA decryption as used in TLS is subject to a potential 677 * timing side channel attack first discovered by Bleichenbacher 678 * in 1998. This attack can be remotely exploitable 679 * in practice. To avoid this attack, you must ensure that 680 * if the callback performs an RSA decryption, the time it 681 * takes to execute and return the result does not depend 682 * on whether the RSA decryption succeeded or reported 683 * invalid padding. 684 * 685 * \param ssl The SSL connection instance. It should not be 686 * modified other than via 687 * mbedtls_ssl_set_async_operation_data(). 688 * \param cert Certificate containing the public key. 689 * In simple cases, this is one of the pointers passed to 690 * mbedtls_ssl_conf_own_cert() when configuring the SSL 691 * connection. However, if other callbacks are used, this 692 * property may not hold. For example, if an SNI callback 693 * is registered with mbedtls_ssl_conf_sni(), then 694 * this callback determines what certificate is used. 695 * \param input Buffer containing the input ciphertext. This buffer 696 * is no longer valid when the function returns. 697 * \param input_len Size of the \p input buffer in bytes. 698 * 699 * \return 0 if the operation was started successfully and the SSL 700 * stack should call the resume callback immediately. 701 * \return #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS if the operation 702 * was started successfully and the SSL stack should return 703 * immediately without calling the resume callback yet. 704 * \return #MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH if the external 705 * processor does not support this key. The SSL stack will 706 * use the private key object instead. 707 * \return Any other error indicates a fatal failure and is 708 * propagated up the call chain. The callback should 709 * use \c MBEDTLS_ERR_PK_xxx error codes, and <b>must not</b> 710 * use \c MBEDTLS_ERR_SSL_xxx error codes except as 711 * directed in the documentation of this callback. 712 */ 713 typedef int mbedtls_ssl_async_decrypt_t( mbedtls_ssl_context *ssl, 714 mbedtls_x509_crt *cert, 715 const unsigned char *input, 716 size_t input_len ); 717 #endif /* MBEDTLS_X509_CRT_PARSE_C */ 718 719 /** 720 * \brief Callback type: resume external operation. 721 * 722 * This callback is called during an SSL handshake to resume 723 * an external operation started by the 724 * ::mbedtls_ssl_async_sign_t or 725 * ::mbedtls_ssl_async_decrypt_t callback. 726 * 727 * This function typically checks the status of a pending 728 * request or causes the request queue to make progress, and 729 * does not wait for the operation to complete. This allows 730 * the handshake step to be non-blocking. 731 * 732 * This function may call mbedtls_ssl_get_async_operation_data() 733 * to retrieve an operation context set by the start callback. 734 * It may call mbedtls_ssl_set_async_operation_data() to modify 735 * this context. 736 * 737 * Note that when this function returns a status other than 738 * #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS, it must free any 739 * resources associated with the operation. 740 * 741 * \param ssl The SSL connection instance. It should not be 742 * modified other than via 743 * mbedtls_ssl_set_async_operation_data(). 744 * \param output Buffer containing the output (signature or decrypted 745 * data) on success. 746 * \param output_len On success, number of bytes written to \p output. 747 * \param output_size Size of the \p output buffer in bytes. 748 * 749 * \return 0 if output of the operation is available in the 750 * \p output buffer. 751 * \return #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS if the operation 752 * is still in progress. Subsequent requests for progress 753 * on the SSL connection will call the resume callback 754 * again. 755 * \return Any other error means that the operation is aborted. 756 * The SSL handshake is aborted. The callback should 757 * use \c MBEDTLS_ERR_PK_xxx error codes, and <b>must not</b> 758 * use \c MBEDTLS_ERR_SSL_xxx error codes except as 759 * directed in the documentation of this callback. 760 */ 761 typedef int mbedtls_ssl_async_resume_t( mbedtls_ssl_context *ssl, 762 unsigned char *output, 763 size_t *output_len, 764 size_t output_size ); 765 766 /** 767 * \brief Callback type: cancel external operation. 768 * 769 * This callback is called if an SSL connection is closed 770 * while an asynchronous operation is in progress. Note that 771 * this callback is not called if the 772 * ::mbedtls_ssl_async_resume_t callback has run and has 773 * returned a value other than 774 * #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS, since in that case 775 * the asynchronous operation has already completed. 776 * 777 * This function may call mbedtls_ssl_get_async_operation_data() 778 * to retrieve an operation context set by the start callback. 779 * 780 * \param ssl The SSL connection instance. It should not be 781 * modified. 782 */ 783 typedef void mbedtls_ssl_async_cancel_t( mbedtls_ssl_context *ssl ); 784 #endif /* MBEDTLS_SSL_ASYNC_PRIVATE */ 785 786 /* 787 * This structure is used for storing current session data. 788 */ 789 struct mbedtls_ssl_session 790 { 791 #if defined(MBEDTLS_HAVE_TIME) 792 mbedtls_time_t start; /*!< starting time */ 793 #endif 794 int ciphersuite; /*!< chosen ciphersuite */ 795 int compression; /*!< chosen compression */ 796 size_t id_len; /*!< session id length */ 797 unsigned char id[32]; /*!< session identifier */ 798 unsigned char master[48]; /*!< the master secret */ 799 800 #if defined(MBEDTLS_X509_CRT_PARSE_C) 801 mbedtls_x509_crt *peer_cert; /*!< peer X.509 cert chain */ 802 #endif /* MBEDTLS_X509_CRT_PARSE_C */ 803 uint32_t verify_result; /*!< verification result */ 804 805 #if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C) 806 unsigned char *ticket; /*!< RFC 5077 session ticket */ 807 size_t ticket_len; /*!< session ticket length */ 808 uint32_t ticket_lifetime; /*!< ticket lifetime hint */ 809 #endif /* MBEDTLS_SSL_SESSION_TICKETS && MBEDTLS_SSL_CLI_C */ 810 811 #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH) 812 unsigned char mfl_code; /*!< MaxFragmentLength negotiated by peer */ 813 #endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */ 814 815 #if defined(MBEDTLS_SSL_TRUNCATED_HMAC) 816 int trunc_hmac; /*!< flag for truncated hmac activation */ 817 #endif /* MBEDTLS_SSL_TRUNCATED_HMAC */ 818 819 #if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC) 820 int encrypt_then_mac; /*!< flag for EtM activation */ 821 #endif 822 }; 823 824 /** 825 * SSL/TLS configuration to be shared between mbedtls_ssl_context structures. 826 */ 827 struct mbedtls_ssl_config 828 { 829 /* Group items by size (largest first) to minimize padding overhead */ 830 831 /* 832 * Pointers 833 */ 834 835 const int *ciphersuite_list[4]; /*!< allowed ciphersuites per version */ 836 837 /** Callback for printing debug output */ 838 void (*f_dbg)(void *, int, const char *, int, const char *); 839 void *p_dbg; /*!< context for the debug function */ 840 841 /** Callback for getting (pseudo-)random numbers */ 842 int (*f_rng)(void *, unsigned char *, size_t); 843 void *p_rng; /*!< context for the RNG function */ 844 845 /** Callback to retrieve a session from the cache */ 846 int (*f_get_cache)(void *, mbedtls_ssl_session *); 847 /** Callback to store a session into the cache */ 848 int (*f_set_cache)(void *, const mbedtls_ssl_session *); 849 void *p_cache; /*!< context for cache callbacks */ 850 851 #if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION) 852 /** Callback for setting cert according to SNI extension */ 853 int (*f_sni)(void *, mbedtls_ssl_context *, const unsigned char *, size_t); 854 void *p_sni; /*!< context for SNI callback */ 855 #endif 856 857 #if defined(MBEDTLS_X509_CRT_PARSE_C) 858 /** Callback to customize X.509 certificate chain verification */ 859 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *); 860 void *p_vrfy; /*!< context for X.509 verify calllback */ 861 #endif 862 863 #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED) 864 /** Callback to retrieve PSK key from identity */ 865 int (*f_psk)(void *, mbedtls_ssl_context *, const unsigned char *, size_t); 866 void *p_psk; /*!< context for PSK callback */ 867 #endif 868 869 #if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY) && defined(MBEDTLS_SSL_SRV_C) 870 /** Callback to create & write a cookie for ClientHello veirifcation */ 871 int (*f_cookie_write)( void *, unsigned char **, unsigned char *, 872 const unsigned char *, size_t ); 873 /** Callback to verify validity of a ClientHello cookie */ 874 int (*f_cookie_check)( void *, const unsigned char *, size_t, 875 const unsigned char *, size_t ); 876 void *p_cookie; /*!< context for the cookie callbacks */ 877 #endif 878 879 #if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_SRV_C) 880 /** Callback to create & write a session ticket */ 881 int (*f_ticket_write)( void *, const mbedtls_ssl_session *, 882 unsigned char *, const unsigned char *, size_t *, uint32_t * ); 883 /** Callback to parse a session ticket into a session structure */ 884 int (*f_ticket_parse)( void *, mbedtls_ssl_session *, unsigned char *, size_t); 885 void *p_ticket; /*!< context for the ticket callbacks */ 886 #endif /* MBEDTLS_SSL_SESSION_TICKETS && MBEDTLS_SSL_SRV_C */ 887 888 #if defined(MBEDTLS_SSL_EXPORT_KEYS) 889 /** Callback to export key block and master secret */ 890 int (*f_export_keys)( void *, const unsigned char *, 891 const unsigned char *, size_t, size_t, size_t ); 892 void *p_export_keys; /*!< context for key export callback */ 893 #endif 894 895 #if defined(MBEDTLS_X509_CRT_PARSE_C) 896 const mbedtls_x509_crt_profile *cert_profile; /*!< verification profile */ 897 mbedtls_ssl_key_cert *key_cert; /*!< own certificate/key pair(s) */ 898 mbedtls_x509_crt *ca_chain; /*!< trusted CAs */ 899 mbedtls_x509_crl *ca_crl; /*!< trusted CAs CRLs */ 900 #endif /* MBEDTLS_X509_CRT_PARSE_C */ 901 902 #if defined(MBEDTLS_SSL_ASYNC_PRIVATE) 903 #if defined(MBEDTLS_X509_CRT_PARSE_C) 904 mbedtls_ssl_async_sign_t *f_async_sign_start; /*!< start asynchronous signature operation */ 905 mbedtls_ssl_async_decrypt_t *f_async_decrypt_start; /*!< start asynchronous decryption operation */ 906 #endif /* MBEDTLS_X509_CRT_PARSE_C */ 907 mbedtls_ssl_async_resume_t *f_async_resume; /*!< resume asynchronous operation */ 908 mbedtls_ssl_async_cancel_t *f_async_cancel; /*!< cancel asynchronous operation */ 909 void *p_async_config_data; /*!< Configuration data set by mbedtls_ssl_conf_async_private_cb(). */ 910 #endif /* MBEDTLS_SSL_ASYNC_PRIVATE */ 911 912 #if defined(MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED) 913 const int *sig_hashes; /*!< allowed signature hashes */ 914 #endif 915 916 #if defined(MBEDTLS_ECP_C) 917 const mbedtls_ecp_group_id *curve_list; /*!< allowed curves */ 918 #endif 919 920 #if defined(MBEDTLS_DHM_C) 921 mbedtls_mpi dhm_P; /*!< prime modulus for DHM */ 922 mbedtls_mpi dhm_G; /*!< generator for DHM */ 923 #endif 924 925 #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED) 926 unsigned char *psk; /*!< pre-shared key. This field should 927 only be set via 928 mbedtls_ssl_conf_psk() */ 929 size_t psk_len; /*!< length of the pre-shared key. This 930 field should only be set via 931 mbedtls_ssl_conf_psk() */ 932 unsigned char *psk_identity; /*!< identity for PSK negotiation. This 933 field should only be set via 934 mbedtls_ssl_conf_psk() */ 935 size_t psk_identity_len;/*!< length of identity. This field should 936 only be set via 937 mbedtls_ssl_conf_psk() */ 938 #endif 939 940 #if defined(MBEDTLS_SSL_ALPN) 941 const char **alpn_list; /*!< ordered list of protocols */ 942 #endif 943 944 /* 945 * Numerical settings (int then char) 946 */ 947 948 uint32_t read_timeout; /*!< timeout for mbedtls_ssl_read (ms) */ 949 950 #if defined(MBEDTLS_SSL_PROTO_DTLS) 951 uint32_t hs_timeout_min; /*!< initial value of the handshake 952 retransmission timeout (ms) */ 953 uint32_t hs_timeout_max; /*!< maximum value of the handshake 954 retransmission timeout (ms) */ 955 #endif 956 957 #if defined(MBEDTLS_SSL_RENEGOTIATION) 958 int renego_max_records; /*!< grace period for renegotiation */ 959 unsigned char renego_period[8]; /*!< value of the record counters 960 that triggers renegotiation */ 961 #endif 962 963 #if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT) 964 unsigned int badmac_limit; /*!< limit of records with a bad MAC */ 965 #endif 966 967 #if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_SSL_CLI_C) 968 unsigned int dhm_min_bitlen; /*!< min. bit length of the DHM prime */ 969 #endif 970 971 unsigned char max_major_ver; /*!< max. major version used */ 972 unsigned char max_minor_ver; /*!< max. minor version used */ 973 unsigned char min_major_ver; /*!< min. major version used */ 974 unsigned char min_minor_ver; /*!< min. minor version used */ 975 976 /* 977 * Flags (bitfields) 978 */ 979 980 unsigned int endpoint : 1; /*!< 0: client, 1: server */ 981 unsigned int transport : 1; /*!< stream (TLS) or datagram (DTLS) */ 982 unsigned int authmode : 2; /*!< MBEDTLS_SSL_VERIFY_XXX */ 983 /* needed even with renego disabled for LEGACY_BREAK_HANDSHAKE */ 984 unsigned int allow_legacy_renegotiation : 2 ; /*!< MBEDTLS_LEGACY_XXX */ 985 #if defined(MBEDTLS_ARC4_C) 986 unsigned int arc4_disabled : 1; /*!< blacklist RC4 ciphersuites? */ 987 #endif 988 #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH) 989 unsigned int mfl_code : 3; /*!< desired fragment length */ 990 #endif 991 #if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC) 992 unsigned int encrypt_then_mac : 1 ; /*!< negotiate encrypt-then-mac? */ 993 #endif 994 #if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET) 995 unsigned int extended_ms : 1; /*!< negotiate extended master secret? */ 996 #endif 997 #if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY) 998 unsigned int anti_replay : 1; /*!< detect and prevent replay? */ 999 #endif 1000 #if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING) 1001 unsigned int cbc_record_splitting : 1; /*!< do cbc record splitting */ 1002 #endif 1003 #if defined(MBEDTLS_SSL_RENEGOTIATION) 1004 unsigned int disable_renegotiation : 1; /*!< disable renegotiation? */ 1005 #endif 1006 #if defined(MBEDTLS_SSL_TRUNCATED_HMAC) 1007 unsigned int trunc_hmac : 1; /*!< negotiate truncated hmac? */ 1008 #endif 1009 #if defined(MBEDTLS_SSL_SESSION_TICKETS) 1010 unsigned int session_tickets : 1; /*!< use session tickets? */ 1011 #endif 1012 #if defined(MBEDTLS_SSL_FALLBACK_SCSV) && defined(MBEDTLS_SSL_CLI_C) 1013 unsigned int fallback : 1; /*!< is this a fallback? */ 1014 #endif 1015 #if defined(MBEDTLS_SSL_SRV_C) 1016 unsigned int cert_req_ca_list : 1; /*!< enable sending CA list in 1017 Certificate Request messages? */ 1018 #endif 1019 }; 1020 1021 1022 struct mbedtls_ssl_context 1023 { 1024 const mbedtls_ssl_config *conf; /*!< configuration information */ 1025 1026 /* 1027 * Miscellaneous 1028 */ 1029 int state; /*!< SSL handshake: current state */ 1030 #if defined(MBEDTLS_SSL_RENEGOTIATION) 1031 int renego_status; /*!< Initial, in progress, pending? */ 1032 int renego_records_seen; /*!< Records since renego request, or with DTLS, 1033 number of retransmissions of request if 1034 renego_max_records is < 0 */ 1035 #endif /* MBEDTLS_SSL_RENEGOTIATION */ 1036 1037 int major_ver; /*!< equal to MBEDTLS_SSL_MAJOR_VERSION_3 */ 1038 int minor_ver; /*!< either 0 (SSL3) or 1 (TLS1.0) */ 1039 1040 #if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT) 1041 unsigned badmac_seen; /*!< records with a bad MAC received */ 1042 #endif /* MBEDTLS_SSL_DTLS_BADMAC_LIMIT */ 1043 1044 mbedtls_ssl_send_t *f_send; /*!< Callback for network send */ 1045 mbedtls_ssl_recv_t *f_recv; /*!< Callback for network receive */ 1046 mbedtls_ssl_recv_timeout_t *f_recv_timeout; 1047 /*!< Callback for network receive with timeout */ 1048 1049 void *p_bio; /*!< context for I/O operations */ 1050 1051 /* 1052 * Session layer 1053 */ 1054 mbedtls_ssl_session *session_in; /*!< current session data (in) */ 1055 mbedtls_ssl_session *session_out; /*!< current session data (out) */ 1056 mbedtls_ssl_session *session; /*!< negotiated session data */ 1057 mbedtls_ssl_session *session_negotiate; /*!< session data in negotiation */ 1058 1059 mbedtls_ssl_handshake_params *handshake; /*!< params required only during 1060 the handshake process */ 1061 1062 /* 1063 * Record layer transformations 1064 */ 1065 mbedtls_ssl_transform *transform_in; /*!< current transform params (in) */ 1066 mbedtls_ssl_transform *transform_out; /*!< current transform params (in) */ 1067 mbedtls_ssl_transform *transform; /*!< negotiated transform params */ 1068 mbedtls_ssl_transform *transform_negotiate; /*!< transform params in negotiation */ 1069 1070 /* 1071 * Timers 1072 */ 1073 void *p_timer; /*!< context for the timer callbacks */ 1074 1075 mbedtls_ssl_set_timer_t *f_set_timer; /*!< set timer callback */ 1076 mbedtls_ssl_get_timer_t *f_get_timer; /*!< get timer callback */ 1077 1078 /* 1079 * Record layer (incoming data) 1080 */ 1081 unsigned char *in_buf; /*!< input buffer */ 1082 unsigned char *in_ctr; /*!< 64-bit incoming message counter 1083 TLS: maintained by us 1084 DTLS: read from peer */ 1085 unsigned char *in_hdr; /*!< start of record header */ 1086 unsigned char *in_len; /*!< two-bytes message length field */ 1087 unsigned char *in_iv; /*!< ivlen-byte IV */ 1088 unsigned char *in_msg; /*!< message contents (in_iv+ivlen) */ 1089 unsigned char *in_offt; /*!< read offset in application data */ 1090 1091 int in_msgtype; /*!< record header: message type */ 1092 size_t in_msglen; /*!< record header: message length */ 1093 size_t in_left; /*!< amount of data read so far */ 1094 #if defined(MBEDTLS_SSL_PROTO_DTLS) 1095 uint16_t in_epoch; /*!< DTLS epoch for incoming records */ 1096 size_t next_record_offset; /*!< offset of the next record in datagram 1097 (equal to in_left if none) */ 1098 #endif /* MBEDTLS_SSL_PROTO_DTLS */ 1099 #if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY) 1100 uint64_t in_window_top; /*!< last validated record seq_num */ 1101 uint64_t in_window; /*!< bitmask for replay detection */ 1102 #endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */ 1103 1104 size_t in_hslen; /*!< current handshake message length, 1105 including the handshake header */ 1106 int nb_zero; /*!< # of 0-length encrypted messages */ 1107 1108 int keep_current_message; /*!< drop or reuse current message 1109 on next call to record layer? */ 1110 1111 #if defined(MBEDTLS_SSL_PROTO_DTLS) 1112 uint8_t disable_datagram_packing; /*!< Disable packing multiple records 1113 * within a single datagram. */ 1114 #endif /* MBEDTLS_SSL_PROTO_DTLS */ 1115 1116 /* 1117 * Record layer (outgoing data) 1118 */ 1119 unsigned char *out_buf; /*!< output buffer */ 1120 unsigned char *out_ctr; /*!< 64-bit outgoing message counter */ 1121 unsigned char *out_hdr; /*!< start of record header */ 1122 unsigned char *out_len; /*!< two-bytes message length field */ 1123 unsigned char *out_iv; /*!< ivlen-byte IV */ 1124 unsigned char *out_msg; /*!< message contents (out_iv+ivlen) */ 1125 1126 int out_msgtype; /*!< record header: message type */ 1127 size_t out_msglen; /*!< record header: message length */ 1128 size_t out_left; /*!< amount of data not yet written */ 1129 1130 unsigned char cur_out_ctr[8]; /*!< Outgoing record sequence number. */ 1131 1132 #if defined(MBEDTLS_SSL_PROTO_DTLS) 1133 uint16_t mtu; /*!< path mtu, used to fragment outgoing messages */ 1134 #endif /* MBEDTLS_SSL_PROTO_DTLS */ 1135 1136 #if defined(MBEDTLS_ZLIB_SUPPORT) 1137 unsigned char *compress_buf; /*!< zlib data buffer */ 1138 #endif /* MBEDTLS_ZLIB_SUPPORT */ 1139 #if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING) 1140 signed char split_done; /*!< current record already splitted? */ 1141 #endif /* MBEDTLS_SSL_CBC_RECORD_SPLITTING */ 1142 1143 /* 1144 * PKI layer 1145 */ 1146 int client_auth; /*!< flag for client auth. */ 1147 1148 /* 1149 * User settings 1150 */ 1151 #if defined(MBEDTLS_X509_CRT_PARSE_C) 1152 char *hostname; /*!< expected peer CN for verification 1153 (and SNI if available) */ 1154 #endif /* MBEDTLS_X509_CRT_PARSE_C */ 1155 1156 #if defined(MBEDTLS_SSL_ALPN) 1157 const char *alpn_chosen; /*!< negotiated protocol */ 1158 #endif /* MBEDTLS_SSL_ALPN */ 1159 1160 /* 1161 * Information for DTLS hello verify 1162 */ 1163 #if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY) && defined(MBEDTLS_SSL_SRV_C) 1164 unsigned char *cli_id; /*!< transport-level ID of the client */ 1165 size_t cli_id_len; /*!< length of cli_id */ 1166 #endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY && MBEDTLS_SSL_SRV_C */ 1167 1168 /* 1169 * Secure renegotiation 1170 */ 1171 /* needed to know when to send extension on server */ 1172 int secure_renegotiation; /*!< does peer support legacy or 1173 secure renegotiation */ 1174 #if defined(MBEDTLS_SSL_RENEGOTIATION) 1175 size_t verify_data_len; /*!< length of verify data stored */ 1176 char own_verify_data[MBEDTLS_SSL_VERIFY_DATA_MAX_LEN]; /*!< previous handshake verify data */ 1177 char peer_verify_data[MBEDTLS_SSL_VERIFY_DATA_MAX_LEN]; /*!< previous handshake verify data */ 1178 #endif /* MBEDTLS_SSL_RENEGOTIATION */ 1179 }; 1180 1181 #if defined(MBEDTLS_SSL_HW_RECORD_ACCEL) 1182 1183 #define MBEDTLS_SSL_CHANNEL_OUTBOUND 0 1184 #define MBEDTLS_SSL_CHANNEL_INBOUND 1 1185 1186 extern int (*mbedtls_ssl_hw_record_init)(mbedtls_ssl_context *ssl, 1187 const unsigned char *key_enc, const unsigned char *key_dec, 1188 size_t keylen, 1189 const unsigned char *iv_enc, const unsigned char *iv_dec, 1190 size_t ivlen, 1191 const unsigned char *mac_enc, const unsigned char *mac_dec, 1192 size_t maclen); 1193 extern int (*mbedtls_ssl_hw_record_activate)(mbedtls_ssl_context *ssl, int direction); 1194 extern int (*mbedtls_ssl_hw_record_reset)(mbedtls_ssl_context *ssl); 1195 extern int (*mbedtls_ssl_hw_record_write)(mbedtls_ssl_context *ssl); 1196 extern int (*mbedtls_ssl_hw_record_read)(mbedtls_ssl_context *ssl); 1197 extern int (*mbedtls_ssl_hw_record_finish)(mbedtls_ssl_context *ssl); 1198 #endif /* MBEDTLS_SSL_HW_RECORD_ACCEL */ 1199 1200 /** 1201 * \brief Return the name of the ciphersuite associated with the 1202 * given ID 1203 * 1204 * \param ciphersuite_id SSL ciphersuite ID 1205 * 1206 * \return a string containing the ciphersuite name 1207 */ 1208 const char *mbedtls_ssl_get_ciphersuite_name( const int ciphersuite_id ); 1209 1210 /** 1211 * \brief Return the ID of the ciphersuite associated with the 1212 * given name 1213 * 1214 * \param ciphersuite_name SSL ciphersuite name 1215 * 1216 * \return the ID with the ciphersuite or 0 if not found 1217 */ 1218 int mbedtls_ssl_get_ciphersuite_id( const char *ciphersuite_name ); 1219 1220 /** 1221 * \brief Initialize an SSL context 1222 * Just makes the context ready for mbedtls_ssl_setup() or 1223 * mbedtls_ssl_free() 1224 * 1225 * \param ssl SSL context 1226 */ 1227 void mbedtls_ssl_init( mbedtls_ssl_context *ssl ); 1228 1229 /** 1230 * \brief Set up an SSL context for use 1231 * 1232 * \note No copy of the configuration context is made, it can be 1233 * shared by many mbedtls_ssl_context structures. 1234 * 1235 * \warning The conf structure will be accessed during the session. 1236 * It must not be modified or freed as long as the session 1237 * is active. 1238 * 1239 * \warning This function must be called exactly once per context. 1240 * Calling mbedtls_ssl_setup again is not supported, even 1241 * if no session is active. 1242 * 1243 * \param ssl SSL context 1244 * \param conf SSL configuration to use 1245 * 1246 * \return 0 if successful, or MBEDTLS_ERR_SSL_ALLOC_FAILED if 1247 * memory allocation failed 1248 */ 1249 int mbedtls_ssl_setup( mbedtls_ssl_context *ssl, 1250 const mbedtls_ssl_config *conf ); 1251 1252 /** 1253 * \brief Reset an already initialized SSL context for re-use 1254 * while retaining application-set variables, function 1255 * pointers and data. 1256 * 1257 * \param ssl SSL context 1258 * \return 0 if successful, or MBEDTLS_ERR_SSL_ALLOC_FAILED, 1259 MBEDTLS_ERR_SSL_HW_ACCEL_FAILED or 1260 * MBEDTLS_ERR_SSL_COMPRESSION_FAILED 1261 */ 1262 int mbedtls_ssl_session_reset( mbedtls_ssl_context *ssl ); 1263 1264 /** 1265 * \brief Set the current endpoint type 1266 * 1267 * \param conf SSL configuration 1268 * \param endpoint must be MBEDTLS_SSL_IS_CLIENT or MBEDTLS_SSL_IS_SERVER 1269 */ 1270 void mbedtls_ssl_conf_endpoint( mbedtls_ssl_config *conf, int endpoint ); 1271 1272 /** 1273 * \brief Set the transport type (TLS or DTLS). 1274 * Default: TLS 1275 * 1276 * \note For DTLS, you must either provide a recv callback that 1277 * doesn't block, or one that handles timeouts, see 1278 * \c mbedtls_ssl_set_bio(). You also need to provide timer 1279 * callbacks with \c mbedtls_ssl_set_timer_cb(). 1280 * 1281 * \param conf SSL configuration 1282 * \param transport transport type: 1283 * MBEDTLS_SSL_TRANSPORT_STREAM for TLS, 1284 * MBEDTLS_SSL_TRANSPORT_DATAGRAM for DTLS. 1285 */ 1286 void mbedtls_ssl_conf_transport( mbedtls_ssl_config *conf, int transport ); 1287 1288 /** 1289 * \brief Set the certificate verification mode 1290 * Default: NONE on server, REQUIRED on client 1291 * 1292 * \param conf SSL configuration 1293 * \param authmode can be: 1294 * 1295 * MBEDTLS_SSL_VERIFY_NONE: peer certificate is not checked 1296 * (default on server) 1297 * (insecure on client) 1298 * 1299 * MBEDTLS_SSL_VERIFY_OPTIONAL: peer certificate is checked, however the 1300 * handshake continues even if verification failed; 1301 * mbedtls_ssl_get_verify_result() can be called after the 1302 * handshake is complete. 1303 * 1304 * MBEDTLS_SSL_VERIFY_REQUIRED: peer *must* present a valid certificate, 1305 * handshake is aborted if verification failed. 1306 * (default on client) 1307 * 1308 * \note On client, MBEDTLS_SSL_VERIFY_REQUIRED is the recommended mode. 1309 * With MBEDTLS_SSL_VERIFY_OPTIONAL, the user needs to call mbedtls_ssl_get_verify_result() at 1310 * the right time(s), which may not be obvious, while REQUIRED always perform 1311 * the verification as soon as possible. For example, REQUIRED was protecting 1312 * against the "triple handshake" attack even before it was found. 1313 */ 1314 void mbedtls_ssl_conf_authmode( mbedtls_ssl_config *conf, int authmode ); 1315 1316 #if defined(MBEDTLS_X509_CRT_PARSE_C) 1317 /** 1318 * \brief Set the verification callback (Optional). 1319 * 1320 * If set, the verify callback is called for each 1321 * certificate in the chain. For implementation 1322 * information, please see \c mbedtls_x509_crt_verify() 1323 * 1324 * \param conf SSL configuration 1325 * \param f_vrfy verification function 1326 * \param p_vrfy verification parameter 1327 */ 1328 void mbedtls_ssl_conf_verify( mbedtls_ssl_config *conf, 1329 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *), 1330 void *p_vrfy ); 1331 #endif /* MBEDTLS_X509_CRT_PARSE_C */ 1332 1333 /** 1334 * \brief Set the random number generator callback 1335 * 1336 * \param conf SSL configuration 1337 * \param f_rng RNG function 1338 * \param p_rng RNG parameter 1339 */ 1340 void mbedtls_ssl_conf_rng( mbedtls_ssl_config *conf, 1341 int (*f_rng)(void *, unsigned char *, size_t), 1342 void *p_rng ); 1343 1344 /** 1345 * \brief Set the debug callback 1346 * 1347 * The callback has the following argument: 1348 * void * opaque context for the callback 1349 * int debug level 1350 * const char * file name 1351 * int line number 1352 * const char * message 1353 * 1354 * \param conf SSL configuration 1355 * \param f_dbg debug function 1356 * \param p_dbg debug parameter 1357 */ 1358 void mbedtls_ssl_conf_dbg( mbedtls_ssl_config *conf, 1359 void (*f_dbg)(void *, int, const char *, int, const char *), 1360 void *p_dbg ); 1361 1362 /** 1363 * \brief Set the underlying BIO callbacks for write, read and 1364 * read-with-timeout. 1365 * 1366 * \param ssl SSL context 1367 * \param p_bio parameter (context) shared by BIO callbacks 1368 * \param f_send write callback 1369 * \param f_recv read callback 1370 * \param f_recv_timeout blocking read callback with timeout. 1371 * 1372 * \note One of f_recv or f_recv_timeout can be NULL, in which case 1373 * the other is used. If both are non-NULL, f_recv_timeout is 1374 * used and f_recv is ignored (as if it were NULL). 1375 * 1376 * \note The two most common use cases are: 1377 * - non-blocking I/O, f_recv != NULL, f_recv_timeout == NULL 1378 * - blocking I/O, f_recv == NULL, f_recv_timout != NULL 1379 * 1380 * \note For DTLS, you need to provide either a non-NULL 1381 * f_recv_timeout callback, or a f_recv that doesn't block. 1382 * 1383 * \note See the documentations of \c mbedtls_ssl_sent_t, 1384 * \c mbedtls_ssl_recv_t and \c mbedtls_ssl_recv_timeout_t for 1385 * the conventions those callbacks must follow. 1386 * 1387 * \note On some platforms, net_sockets.c provides 1388 * \c mbedtls_net_send(), \c mbedtls_net_recv() and 1389 * \c mbedtls_net_recv_timeout() that are suitable to be used 1390 * here. 1391 */ 1392 void mbedtls_ssl_set_bio( mbedtls_ssl_context *ssl, 1393 void *p_bio, 1394 mbedtls_ssl_send_t *f_send, 1395 mbedtls_ssl_recv_t *f_recv, 1396 mbedtls_ssl_recv_timeout_t *f_recv_timeout ); 1397 1398 #if defined(MBEDTLS_SSL_PROTO_DTLS) 1399 /** 1400 * \brief Set the Maximum Tranport Unit (MTU). 1401 * Special value: 0 means unset (no limit). 1402 * This represents the maximum size of a datagram payload 1403 * handled by the transport layer (usually UDP) as determined 1404 * by the network link and stack. In practice, this controls 1405 * the maximum size datagram the DTLS layer will pass to the 1406 * \c f_send() callback set using \c mbedtls_ssl_set_bio(). 1407 * 1408 * \note The limit on datagram size is converted to a limit on 1409 * record payload by subtracting the current overhead of 1410 * encapsulation and encryption/authentication if any. 1411 * 1412 * \note This can be called at any point during the connection, for 1413 * example when a Path Maximum Transfer Unit (PMTU) 1414 * estimate becomes available from other sources, 1415 * such as lower (or higher) protocol layers. 1416 * 1417 * \note This setting only controls the size of the packets we send, 1418 * and does not restrict the size of the datagrams we're 1419 * willing to receive. Client-side, you can request the 1420 * server to use smaller records with \c 1421 * mbedtls_ssl_conf_max_frag_len(). 1422 * 1423 * \note If both a MTU and a maximum fragment length have been 1424 * configured (or negotiated with the peer), the resulting 1425 * lower limit on record payload (see first note) is used. 1426 * 1427 * \note This can only be used to decrease the maximum size 1428 * of datagrams (hence records, see first note) sent. It 1429 * cannot be used to increase the maximum size of records over 1430 * the limit set by #MBEDTLS_SSL_OUT_CONTENT_LEN. 1431 * 1432 * \note Values lower than the current record layer expansion will 1433 * result in an error when trying to send data. 1434 * 1435 * \note Using record compression together with a non-zero MTU value 1436 * will result in an error when trying to send data. 1437 * 1438 * \param ssl SSL context 1439 * \param mtu Value of the path MTU in bytes 1440 */ 1441 void mbedtls_ssl_set_mtu( mbedtls_ssl_context *ssl, uint16_t mtu ); 1442 #endif /* MBEDTLS_SSL_PROTO_DTLS */ 1443 1444 /** 1445 * \brief Set the timeout period for mbedtls_ssl_read() 1446 * (Default: no timeout.) 1447 * 1448 * \param conf SSL configuration context 1449 * \param timeout Timeout value in milliseconds. 1450 * Use 0 for no timeout (default). 1451 * 1452 * \note With blocking I/O, this will only work if a non-NULL 1453 * \c f_recv_timeout was set with \c mbedtls_ssl_set_bio(). 1454 * With non-blocking I/O, this will only work if timer 1455 * callbacks were set with \c mbedtls_ssl_set_timer_cb(). 1456 * 1457 * \note With non-blocking I/O, you may also skip this function 1458 * altogether and handle timeouts at the application layer. 1459 */ 1460 void mbedtls_ssl_conf_read_timeout( mbedtls_ssl_config *conf, uint32_t timeout ); 1461 1462 /** 1463 * \brief Set the timer callbacks (Mandatory for DTLS.) 1464 * 1465 * \param ssl SSL context 1466 * \param p_timer parameter (context) shared by timer callbacks 1467 * \param f_set_timer set timer callback 1468 * \param f_get_timer get timer callback. Must return: 1469 * 1470 * \note See the documentation of \c mbedtls_ssl_set_timer_t and 1471 * \c mbedtls_ssl_get_timer_t for the conventions this pair of 1472 * callbacks must follow. 1473 * 1474 * \note On some platforms, timing.c provides 1475 * \c mbedtls_timing_set_delay() and 1476 * \c mbedtls_timing_get_delay() that are suitable for using 1477 * here, except if using an event-driven style. 1478 * 1479 * \note See also the "DTLS tutorial" article in our knowledge base. 1480 * https://tls.mbed.org/kb/how-to/dtls-tutorial 1481 */ 1482 void mbedtls_ssl_set_timer_cb( mbedtls_ssl_context *ssl, 1483 void *p_timer, 1484 mbedtls_ssl_set_timer_t *f_set_timer, 1485 mbedtls_ssl_get_timer_t *f_get_timer ); 1486 1487 /** 1488 * \brief Callback type: generate and write session ticket 1489 * 1490 * \note This describes what a callback implementation should do. 1491 * This callback should generate an encrypted and 1492 * authenticated ticket for the session and write it to the 1493 * output buffer. Here, ticket means the opaque ticket part 1494 * of the NewSessionTicket structure of RFC 5077. 1495 * 1496 * \param p_ticket Context for the callback 1497 * \param session SSL session to be written in the ticket 1498 * \param start Start of the output buffer 1499 * \param end End of the output buffer 1500 * \param tlen On exit, holds the length written 1501 * \param lifetime On exit, holds the lifetime of the ticket in seconds 1502 * 1503 * \return 0 if successful, or 1504 * a specific MBEDTLS_ERR_XXX code. 1505 */ 1506 typedef int mbedtls_ssl_ticket_write_t( void *p_ticket, 1507 const mbedtls_ssl_session *session, 1508 unsigned char *start, 1509 const unsigned char *end, 1510 size_t *tlen, 1511 uint32_t *lifetime ); 1512 1513 #if defined(MBEDTLS_SSL_EXPORT_KEYS) 1514 /** 1515 * \brief Callback type: Export key block and master secret 1516 * 1517 * \note This is required for certain uses of TLS, e.g. EAP-TLS 1518 * (RFC 5216) and Thread. The key pointers are ephemeral and 1519 * therefore must not be stored. The master secret and keys 1520 * should not be used directly except as an input to a key 1521 * derivation function. 1522 * 1523 * \param p_expkey Context for the callback 1524 * \param ms Pointer to master secret (fixed length: 48 bytes) 1525 * \param kb Pointer to key block, see RFC 5246 section 6.3 1526 * (variable length: 2 * maclen + 2 * keylen + 2 * ivlen). 1527 * \param maclen MAC length 1528 * \param keylen Key length 1529 * \param ivlen IV length 1530 * 1531 * \return 0 if successful, or 1532 * a specific MBEDTLS_ERR_XXX code. 1533 */ 1534 typedef int mbedtls_ssl_export_keys_t( void *p_expkey, 1535 const unsigned char *ms, 1536 const unsigned char *kb, 1537 size_t maclen, 1538 size_t keylen, 1539 size_t ivlen ); 1540 #endif /* MBEDTLS_SSL_EXPORT_KEYS */ 1541 1542 /** 1543 * \brief Callback type: parse and load session ticket 1544 * 1545 * \note This describes what a callback implementation should do. 1546 * This callback should parse a session ticket as generated 1547 * by the corresponding mbedtls_ssl_ticket_write_t function, 1548 * and, if the ticket is authentic and valid, load the 1549 * session. 1550 * 1551 * \note The implementation is allowed to modify the first len 1552 * bytes of the input buffer, eg to use it as a temporary 1553 * area for the decrypted ticket contents. 1554 * 1555 * \param p_ticket Context for the callback 1556 * \param session SSL session to be loaded 1557 * \param buf Start of the buffer containing the ticket 1558 * \param len Length of the ticket. 1559 * 1560 * \return 0 if successful, or 1561 * MBEDTLS_ERR_SSL_INVALID_MAC if not authentic, or 1562 * MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED if expired, or 1563 * any other non-zero code for other failures. 1564 */ 1565 typedef int mbedtls_ssl_ticket_parse_t( void *p_ticket, 1566 mbedtls_ssl_session *session, 1567 unsigned char *buf, 1568 size_t len ); 1569 1570 #if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_SRV_C) 1571 /** 1572 * \brief Configure SSL session ticket callbacks (server only). 1573 * (Default: none.) 1574 * 1575 * \note On server, session tickets are enabled by providing 1576 * non-NULL callbacks. 1577 * 1578 * \note On client, use \c mbedtls_ssl_conf_session_tickets(). 1579 * 1580 * \param conf SSL configuration context 1581 * \param f_ticket_write Callback for writing a ticket 1582 * \param f_ticket_parse Callback for parsing a ticket 1583 * \param p_ticket Context shared by the two callbacks 1584 */ 1585 void mbedtls_ssl_conf_session_tickets_cb( mbedtls_ssl_config *conf, 1586 mbedtls_ssl_ticket_write_t *f_ticket_write, 1587 mbedtls_ssl_ticket_parse_t *f_ticket_parse, 1588 void *p_ticket ); 1589 #endif /* MBEDTLS_SSL_SESSION_TICKETS && MBEDTLS_SSL_SRV_C */ 1590 1591 #if defined(MBEDTLS_SSL_EXPORT_KEYS) 1592 /** 1593 * \brief Configure key export callback. 1594 * (Default: none.) 1595 * 1596 * \note See \c mbedtls_ssl_export_keys_t. 1597 * 1598 * \param conf SSL configuration context 1599 * \param f_export_keys Callback for exporting keys 1600 * \param p_export_keys Context for the callback 1601 */ 1602 void mbedtls_ssl_conf_export_keys_cb( mbedtls_ssl_config *conf, 1603 mbedtls_ssl_export_keys_t *f_export_keys, 1604 void *p_export_keys ); 1605 #endif /* MBEDTLS_SSL_EXPORT_KEYS */ 1606 1607 #if defined(MBEDTLS_SSL_ASYNC_PRIVATE) 1608 /** 1609 * \brief Configure asynchronous private key operation callbacks. 1610 * 1611 * \param conf SSL configuration context 1612 * \param f_async_sign Callback to start a signature operation. See 1613 * the description of ::mbedtls_ssl_async_sign_t 1614 * for more information. This may be \c NULL if the 1615 * external processor does not support any signature 1616 * operation; in this case the private key object 1617 * associated with the certificate will be used. 1618 * \param f_async_decrypt Callback to start a decryption operation. See 1619 * the description of ::mbedtls_ssl_async_decrypt_t 1620 * for more information. This may be \c NULL if the 1621 * external processor does not support any decryption 1622 * operation; in this case the private key object 1623 * associated with the certificate will be used. 1624 * \param f_async_resume Callback to resume an asynchronous operation. See 1625 * the description of ::mbedtls_ssl_async_resume_t 1626 * for more information. This may not be \c NULL unless 1627 * \p f_async_sign and \p f_async_decrypt are both 1628 * \c NULL. 1629 * \param f_async_cancel Callback to cancel an asynchronous operation. See 1630 * the description of ::mbedtls_ssl_async_cancel_t 1631 * for more information. This may be \c NULL if 1632 * no cleanup is needed. 1633 * \param config_data A pointer to configuration data which can be 1634 * retrieved with 1635 * mbedtls_ssl_conf_get_async_config_data(). The 1636 * library stores this value without dereferencing it. 1637 */ 1638 void mbedtls_ssl_conf_async_private_cb( mbedtls_ssl_config *conf, 1639 mbedtls_ssl_async_sign_t *f_async_sign, 1640 mbedtls_ssl_async_decrypt_t *f_async_decrypt, 1641 mbedtls_ssl_async_resume_t *f_async_resume, 1642 mbedtls_ssl_async_cancel_t *f_async_cancel, 1643 void *config_data ); 1644 1645 /** 1646 * \brief Retrieve the configuration data set by 1647 * mbedtls_ssl_conf_async_private_cb(). 1648 * 1649 * \param conf SSL configuration context 1650 * \return The configuration data set by 1651 * mbedtls_ssl_conf_async_private_cb(). 1652 */ 1653 void *mbedtls_ssl_conf_get_async_config_data( const mbedtls_ssl_config *conf ); 1654 1655 /** 1656 * \brief Retrieve the asynchronous operation user context. 1657 * 1658 * \note This function may only be called while a handshake 1659 * is in progress. 1660 * 1661 * \param ssl The SSL context to access. 1662 * 1663 * \return The asynchronous operation user context that was last 1664 * set during the current handshake. If 1665 * mbedtls_ssl_set_async_operation_data() has not yet been 1666 * called during the current handshake, this function returns 1667 * \c NULL. 1668 */ 1669 void *mbedtls_ssl_get_async_operation_data( const mbedtls_ssl_context *ssl ); 1670 1671 /** 1672 * \brief Retrieve the asynchronous operation user context. 1673 * 1674 * \note This function may only be called while a handshake 1675 * is in progress. 1676 * 1677 * \param ssl The SSL context to access. 1678 * \param ctx The new value of the asynchronous operation user context. 1679 * Call mbedtls_ssl_get_async_operation_data() later during the 1680 * same handshake to retrieve this value. 1681 */ 1682 void mbedtls_ssl_set_async_operation_data( mbedtls_ssl_context *ssl, 1683 void *ctx ); 1684 #endif /* MBEDTLS_SSL_ASYNC_PRIVATE */ 1685 1686 /** 1687 * \brief Callback type: generate a cookie 1688 * 1689 * \param ctx Context for the callback 1690 * \param p Buffer to write to, 1691 * must be updated to point right after the cookie 1692 * \param end Pointer to one past the end of the output buffer 1693 * \param info Client ID info that was passed to 1694 * \c mbedtls_ssl_set_client_transport_id() 1695 * \param ilen Length of info in bytes 1696 * 1697 * \return The callback must return 0 on success, 1698 * or a negative error code. 1699 */ 1700 typedef int mbedtls_ssl_cookie_write_t( void *ctx, 1701 unsigned char **p, unsigned char *end, 1702 const unsigned char *info, size_t ilen ); 1703 1704 /** 1705 * \brief Callback type: verify a cookie 1706 * 1707 * \param ctx Context for the callback 1708 * \param cookie Cookie to verify 1709 * \param clen Length of cookie 1710 * \param info Client ID info that was passed to 1711 * \c mbedtls_ssl_set_client_transport_id() 1712 * \param ilen Length of info in bytes 1713 * 1714 * \return The callback must return 0 if cookie is valid, 1715 * or a negative error code. 1716 */ 1717 typedef int mbedtls_ssl_cookie_check_t( void *ctx, 1718 const unsigned char *cookie, size_t clen, 1719 const unsigned char *info, size_t ilen ); 1720 1721 #if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY) && defined(MBEDTLS_SSL_SRV_C) 1722 /** 1723 * \brief Register callbacks for DTLS cookies 1724 * (Server only. DTLS only.) 1725 * 1726 * Default: dummy callbacks that fail, in order to force you to 1727 * register working callbacks (and initialize their context). 1728 * 1729 * To disable HelloVerifyRequest, register NULL callbacks. 1730 * 1731 * \warning Disabling hello verification allows your server to be used 1732 * for amplification in DoS attacks against other hosts. 1733 * Only disable if you known this can't happen in your 1734 * particular environment. 1735 * 1736 * \note See comments on \c mbedtls_ssl_handshake() about handling 1737 * the MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED that is expected 1738 * on the first handshake attempt when this is enabled. 1739 * 1740 * \note This is also necessary to handle client reconnection from 1741 * the same port as described in RFC 6347 section 4.2.8 (only 1742 * the variant with cookies is supported currently). See 1743 * comments on \c mbedtls_ssl_read() for details. 1744 * 1745 * \param conf SSL configuration 1746 * \param f_cookie_write Cookie write callback 1747 * \param f_cookie_check Cookie check callback 1748 * \param p_cookie Context for both callbacks 1749 */ 1750 void mbedtls_ssl_conf_dtls_cookies( mbedtls_ssl_config *conf, 1751 mbedtls_ssl_cookie_write_t *f_cookie_write, 1752 mbedtls_ssl_cookie_check_t *f_cookie_check, 1753 void *p_cookie ); 1754 1755 /** 1756 * \brief Set client's transport-level identification info. 1757 * (Server only. DTLS only.) 1758 * 1759 * This is usually the IP address (and port), but could be 1760 * anything identify the client depending on the underlying 1761 * network stack. Used for HelloVerifyRequest with DTLS. 1762 * This is *not* used to route the actual packets. 1763 * 1764 * \param ssl SSL context 1765 * \param info Transport-level info identifying the client (eg IP + port) 1766 * \param ilen Length of info in bytes 1767 * 1768 * \note An internal copy is made, so the info buffer can be reused. 1769 * 1770 * \return 0 on success, 1771 * MBEDTLS_ERR_SSL_BAD_INPUT_DATA if used on client, 1772 * MBEDTLS_ERR_SSL_ALLOC_FAILED if out of memory. 1773 */ 1774 int mbedtls_ssl_set_client_transport_id( mbedtls_ssl_context *ssl, 1775 const unsigned char *info, 1776 size_t ilen ); 1777 1778 #endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY && MBEDTLS_SSL_SRV_C */ 1779 1780 #if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY) 1781 /** 1782 * \brief Enable or disable anti-replay protection for DTLS. 1783 * (DTLS only, no effect on TLS.) 1784 * Default: enabled. 1785 * 1786 * \param conf SSL configuration 1787 * \param mode MBEDTLS_SSL_ANTI_REPLAY_ENABLED or MBEDTLS_SSL_ANTI_REPLAY_DISABLED. 1788 * 1789 * \warning Disabling this is a security risk unless the application 1790 * protocol handles duplicated packets in a safe way. You 1791 * should not disable this without careful consideration. 1792 * However, if your application already detects duplicated 1793 * packets and needs information about them to adjust its 1794 * transmission strategy, then you'll want to disable this. 1795 */ 1796 void mbedtls_ssl_conf_dtls_anti_replay( mbedtls_ssl_config *conf, char mode ); 1797 #endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */ 1798 1799 #if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT) 1800 /** 1801 * \brief Set a limit on the number of records with a bad MAC 1802 * before terminating the connection. 1803 * (DTLS only, no effect on TLS.) 1804 * Default: 0 (disabled). 1805 * 1806 * \param conf SSL configuration 1807 * \param limit Limit, or 0 to disable. 1808 * 1809 * \note If the limit is N, then the connection is terminated when 1810 * the Nth non-authentic record is seen. 1811 * 1812 * \note Records with an invalid header are not counted, only the 1813 * ones going through the authentication-decryption phase. 1814 * 1815 * \note This is a security trade-off related to the fact that it's 1816 * often relatively easy for an active attacker ot inject UDP 1817 * datagrams. On one hand, setting a low limit here makes it 1818 * easier for such an attacker to forcibly terminated a 1819 * connection. On the other hand, a high limit or no limit 1820 * might make us waste resources checking authentication on 1821 * many bogus packets. 1822 */ 1823 void mbedtls_ssl_conf_dtls_badmac_limit( mbedtls_ssl_config *conf, unsigned limit ); 1824 #endif /* MBEDTLS_SSL_DTLS_BADMAC_LIMIT */ 1825 1826 #if defined(MBEDTLS_SSL_PROTO_DTLS) 1827 1828 /** 1829 * \brief Allow or disallow packing of multiple handshake records 1830 * within a single datagram. 1831 * 1832 * \param ssl The SSL context to configure. 1833 * \param allow_packing This determines whether datagram packing may 1834 * be used or not. A value of \c 0 means that every 1835 * record will be sent in a separate datagram; a 1836 * value of \c 1 means that, if space permits, 1837 * multiple handshake messages (including CCS) belonging to 1838 * a single flight may be packed within a single datagram. 1839 * 1840 * \note This is enabled by default and should only be disabled 1841 * for test purposes, or if datagram packing causes 1842 * interoperability issues with peers that don't support it. 1843 * 1844 * \note Allowing datagram packing reduces the network load since 1845 * there's less overhead if multiple messages share the same 1846 * datagram. Also, it increases the handshake efficiency 1847 * since messages belonging to a single datagram will not 1848 * be reordered in transit, and so future message buffering 1849 * or flight retransmission (if no buffering is used) as 1850 * means to deal with reordering are needed less frequently. 1851 * 1852 * \note Application records are not affected by this option and 1853 * are currently always sent in separate datagrams. 1854 * 1855 */ 1856 void mbedtls_ssl_set_datagram_packing( mbedtls_ssl_context *ssl, 1857 unsigned allow_packing ); 1858 1859 /** 1860 * \brief Set retransmit timeout values for the DTLS handshake. 1861 * (DTLS only, no effect on TLS.) 1862 * 1863 * \param conf SSL configuration 1864 * \param min Initial timeout value in milliseconds. 1865 * Default: 1000 (1 second). 1866 * \param max Maximum timeout value in milliseconds. 1867 * Default: 60000 (60 seconds). 1868 * 1869 * \note Default values are from RFC 6347 section 4.2.4.1. 1870 * 1871 * \note The 'min' value should typically be slightly above the 1872 * expected round-trip time to your peer, plus whatever time 1873 * it takes for the peer to process the message. For example, 1874 * if your RTT is about 600ms and you peer needs up to 1s to 1875 * do the cryptographic operations in the handshake, then you 1876 * should set 'min' slightly above 1600. Lower values of 'min' 1877 * might cause spurious resends which waste network resources, 1878 * while larger value of 'min' will increase overall latency 1879 * on unreliable network links. 1880 * 1881 * \note The more unreliable your network connection is, the larger 1882 * your max / min ratio needs to be in order to achieve 1883 * reliable handshakes. 1884 * 1885 * \note Messages are retransmitted up to log2(ceil(max/min)) times. 1886 * For example, if min = 1s and max = 5s, the retransmit plan 1887 * goes: send ... 1s -> resend ... 2s -> resend ... 4s -> 1888 * resend ... 5s -> give up and return a timeout error. 1889 */ 1890 void mbedtls_ssl_conf_handshake_timeout( mbedtls_ssl_config *conf, uint32_t min, uint32_t max ); 1891 #endif /* MBEDTLS_SSL_PROTO_DTLS */ 1892 1893 #if defined(MBEDTLS_SSL_SRV_C) 1894 /** 1895 * \brief Set the session cache callbacks (server-side only) 1896 * If not set, no session resuming is done (except if session 1897 * tickets are enabled too). 1898 * 1899 * The session cache has the responsibility to check for stale 1900 * entries based on timeout. See RFC 5246 for recommendations. 1901 * 1902 * Warning: session.peer_cert is cleared by the SSL/TLS layer on 1903 * connection shutdown, so do not cache the pointer! Either set 1904 * it to NULL or make a full copy of the certificate. 1905 * 1906 * The get callback is called once during the initial handshake 1907 * to enable session resuming. The get function has the 1908 * following parameters: (void *parameter, mbedtls_ssl_session *session) 1909 * If a valid entry is found, it should fill the master of 1910 * the session object with the cached values and return 0, 1911 * return 1 otherwise. Optionally peer_cert can be set as well 1912 * if it is properly present in cache entry. 1913 * 1914 * The set callback is called once during the initial handshake 1915 * to enable session resuming after the entire handshake has 1916 * been finished. The set function has the following parameters: 1917 * (void *parameter, const mbedtls_ssl_session *session). The function 1918 * should create a cache entry for future retrieval based on 1919 * the data in the session structure and should keep in mind 1920 * that the mbedtls_ssl_session object presented (and all its referenced 1921 * data) is cleared by the SSL/TLS layer when the connection is 1922 * terminated. It is recommended to add metadata to determine if 1923 * an entry is still valid in the future. Return 0 if 1924 * successfully cached, return 1 otherwise. 1925 * 1926 * \param conf SSL configuration 1927 * \param p_cache parmater (context) for both callbacks 1928 * \param f_get_cache session get callback 1929 * \param f_set_cache session set callback 1930 */ 1931 void mbedtls_ssl_conf_session_cache( mbedtls_ssl_config *conf, 1932 void *p_cache, 1933 int (*f_get_cache)(void *, mbedtls_ssl_session *), 1934 int (*f_set_cache)(void *, const mbedtls_ssl_session *) ); 1935 #endif /* MBEDTLS_SSL_SRV_C */ 1936 1937 #if defined(MBEDTLS_SSL_CLI_C) 1938 /** 1939 * \brief Request resumption of session (client-side only) 1940 * Session data is copied from presented session structure. 1941 * 1942 * \param ssl SSL context 1943 * \param session session context 1944 * 1945 * \return 0 if successful, 1946 * MBEDTLS_ERR_SSL_ALLOC_FAILED if memory allocation failed, 1947 * MBEDTLS_ERR_SSL_BAD_INPUT_DATA if used server-side or 1948 * arguments are otherwise invalid 1949 * 1950 * \sa mbedtls_ssl_get_session() 1951 */ 1952 int mbedtls_ssl_set_session( mbedtls_ssl_context *ssl, const mbedtls_ssl_session *session ); 1953 #endif /* MBEDTLS_SSL_CLI_C */ 1954 1955 /** 1956 * \brief Set the list of allowed ciphersuites and the preference 1957 * order. First in the list has the highest preference. 1958 * (Overrides all version-specific lists) 1959 * 1960 * The ciphersuites array is not copied, and must remain 1961 * valid for the lifetime of the ssl_config. 1962 * 1963 * Note: The server uses its own preferences 1964 * over the preference of the client unless 1965 * MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE is defined! 1966 * 1967 * \param conf SSL configuration 1968 * \param ciphersuites 0-terminated list of allowed ciphersuites 1969 */ 1970 void mbedtls_ssl_conf_ciphersuites( mbedtls_ssl_config *conf, 1971 const int *ciphersuites ); 1972 1973 /** 1974 * \brief Set the list of allowed ciphersuites and the 1975 * preference order for a specific version of the protocol. 1976 * (Only useful on the server side) 1977 * 1978 * The ciphersuites array is not copied, and must remain 1979 * valid for the lifetime of the ssl_config. 1980 * 1981 * \param conf SSL configuration 1982 * \param ciphersuites 0-terminated list of allowed ciphersuites 1983 * \param major Major version number (only MBEDTLS_SSL_MAJOR_VERSION_3 1984 * supported) 1985 * \param minor Minor version number (MBEDTLS_SSL_MINOR_VERSION_0, 1986 * MBEDTLS_SSL_MINOR_VERSION_1 and MBEDTLS_SSL_MINOR_VERSION_2, 1987 * MBEDTLS_SSL_MINOR_VERSION_3 supported) 1988 * 1989 * \note With DTLS, use MBEDTLS_SSL_MINOR_VERSION_2 for DTLS 1.0 1990 * and MBEDTLS_SSL_MINOR_VERSION_3 for DTLS 1.2 1991 */ 1992 void mbedtls_ssl_conf_ciphersuites_for_version( mbedtls_ssl_config *conf, 1993 const int *ciphersuites, 1994 int major, int minor ); 1995 1996 #if defined(MBEDTLS_X509_CRT_PARSE_C) 1997 /** 1998 * \brief Set the X.509 security profile used for verification 1999 * 2000 * \note The restrictions are enforced for all certificates in the 2001 * chain. However, signatures in the handshake are not covered 2002 * by this setting but by \b mbedtls_ssl_conf_sig_hashes(). 2003 * 2004 * \param conf SSL configuration 2005 * \param profile Profile to use 2006 */ 2007 void mbedtls_ssl_conf_cert_profile( mbedtls_ssl_config *conf, 2008 const mbedtls_x509_crt_profile *profile ); 2009 2010 /** 2011 * \brief Set the data required to verify peer certificate 2012 * 2013 * \note See \c mbedtls_x509_crt_verify() for notes regarding the 2014 * parameters ca_chain (maps to trust_ca for that function) 2015 * and ca_crl. 2016 * 2017 * \param conf SSL configuration 2018 * \param ca_chain trusted CA chain (meaning all fully trusted top-level CAs) 2019 * \param ca_crl trusted CA CRLs 2020 */ 2021 void mbedtls_ssl_conf_ca_chain( mbedtls_ssl_config *conf, 2022 mbedtls_x509_crt *ca_chain, 2023 mbedtls_x509_crl *ca_crl ); 2024 2025 /** 2026 * \brief Set own certificate chain and private key 2027 * 2028 * \note own_cert should contain in order from the bottom up your 2029 * certificate chain. The top certificate (self-signed) 2030 * can be omitted. 2031 * 2032 * \note On server, this function can be called multiple times to 2033 * provision more than one cert/key pair (eg one ECDSA, one 2034 * RSA with SHA-256, one RSA with SHA-1). An adequate 2035 * certificate will be selected according to the client's 2036 * advertised capabilities. In case mutliple certificates are 2037 * adequate, preference is given to the one set by the first 2038 * call to this function, then second, etc. 2039 * 2040 * \note On client, only the first call has any effect. That is, 2041 * only one client certificate can be provisioned. The 2042 * server's preferences in its CertficateRequest message will 2043 * be ignored and our only cert will be sent regardless of 2044 * whether it matches those preferences - the server can then 2045 * decide what it wants to do with it. 2046 * 2047 * \note The provided \p pk_key needs to match the public key in the 2048 * first certificate in \p own_cert, or all handshakes using 2049 * that certificate will fail. It is your responsibility 2050 * to ensure that; this function will not perform any check. 2051 * You may use mbedtls_pk_check_pair() in order to perform 2052 * this check yourself, but be aware that this function can 2053 * be computationally expensive on some key types. 2054 * 2055 * \param conf SSL configuration 2056 * \param own_cert own public certificate chain 2057 * \param pk_key own private key 2058 * 2059 * \return 0 on success or MBEDTLS_ERR_SSL_ALLOC_FAILED 2060 */ 2061 int mbedtls_ssl_conf_own_cert( mbedtls_ssl_config *conf, 2062 mbedtls_x509_crt *own_cert, 2063 mbedtls_pk_context *pk_key ); 2064 #endif /* MBEDTLS_X509_CRT_PARSE_C */ 2065 2066 #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED) 2067 /** 2068 * \brief Set the Pre Shared Key (PSK) and the expected identity name 2069 * 2070 * \note This is mainly useful for clients. Servers will usually 2071 * want to use \c mbedtls_ssl_conf_psk_cb() instead. 2072 * 2073 * \note Currently clients can only register one pre-shared key. 2074 * In other words, the servers' identity hint is ignored. 2075 * Support for setting multiple PSKs on clients and selecting 2076 * one based on the identity hint is not a planned feature but 2077 * feedback is welcomed. 2078 * 2079 * \param conf SSL configuration 2080 * \param psk pointer to the pre-shared key 2081 * \param psk_len pre-shared key length 2082 * \param psk_identity pointer to the pre-shared key identity 2083 * \param psk_identity_len identity key length 2084 * 2085 * \return 0 if successful or MBEDTLS_ERR_SSL_ALLOC_FAILED 2086 */ 2087 int mbedtls_ssl_conf_psk( mbedtls_ssl_config *conf, 2088 const unsigned char *psk, size_t psk_len, 2089 const unsigned char *psk_identity, size_t psk_identity_len ); 2090 2091 2092 /** 2093 * \brief Set the Pre Shared Key (PSK) for the current handshake 2094 * 2095 * \note This should only be called inside the PSK callback, 2096 * ie the function passed to \c mbedtls_ssl_conf_psk_cb(). 2097 * 2098 * \param ssl SSL context 2099 * \param psk pointer to the pre-shared key 2100 * \param psk_len pre-shared key length 2101 * 2102 * \return 0 if successful or MBEDTLS_ERR_SSL_ALLOC_FAILED 2103 */ 2104 int mbedtls_ssl_set_hs_psk( mbedtls_ssl_context *ssl, 2105 const unsigned char *psk, size_t psk_len ); 2106 2107 /** 2108 * \brief Set the PSK callback (server-side only). 2109 * 2110 * If set, the PSK callback is called for each 2111 * handshake where a PSK ciphersuite was negotiated. 2112 * The caller provides the identity received and wants to 2113 * receive the actual PSK data and length. 2114 * 2115 * The callback has the following parameters: (void *parameter, 2116 * mbedtls_ssl_context *ssl, const unsigned char *psk_identity, 2117 * size_t identity_len) 2118 * If a valid PSK identity is found, the callback should use 2119 * \c mbedtls_ssl_set_hs_psk() on the ssl context to set the 2120 * correct PSK and return 0. 2121 * Any other return value will result in a denied PSK identity. 2122 * 2123 * \note If you set a PSK callback using this function, then you 2124 * don't need to set a PSK key and identity using 2125 * \c mbedtls_ssl_conf_psk(). 2126 * 2127 * \param conf SSL configuration 2128 * \param f_psk PSK identity function 2129 * \param p_psk PSK identity parameter 2130 */ 2131 void mbedtls_ssl_conf_psk_cb( mbedtls_ssl_config *conf, 2132 int (*f_psk)(void *, mbedtls_ssl_context *, const unsigned char *, 2133 size_t), 2134 void *p_psk ); 2135 #endif /* MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED */ 2136 2137 #if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_SSL_SRV_C) 2138 2139 #if !defined(MBEDTLS_DEPRECATED_REMOVED) 2140 2141 #if defined(MBEDTLS_DEPRECATED_WARNING) 2142 #define MBEDTLS_DEPRECATED __attribute__((deprecated)) 2143 #else 2144 #define MBEDTLS_DEPRECATED 2145 #endif 2146 2147 /** 2148 * \brief Set the Diffie-Hellman public P and G values, 2149 * read as hexadecimal strings (server-side only) 2150 * (Default values: MBEDTLS_DHM_RFC3526_MODP_2048_[PG]) 2151 * 2152 * \param conf SSL configuration 2153 * \param dhm_P Diffie-Hellman-Merkle modulus 2154 * \param dhm_G Diffie-Hellman-Merkle generator 2155 * 2156 * \deprecated Superseded by \c mbedtls_ssl_conf_dh_param_bin. 2157 * 2158 * \return 0 if successful 2159 */ 2160 MBEDTLS_DEPRECATED int mbedtls_ssl_conf_dh_param( mbedtls_ssl_config *conf, 2161 const char *dhm_P, 2162 const char *dhm_G ); 2163 2164 #endif /* MBEDTLS_DEPRECATED_REMOVED */ 2165 2166 /** 2167 * \brief Set the Diffie-Hellman public P and G values 2168 * from big-endian binary presentations. 2169 * (Default values: MBEDTLS_DHM_RFC3526_MODP_2048_[PG]_BIN) 2170 * 2171 * \param conf SSL configuration 2172 * \param dhm_P Diffie-Hellman-Merkle modulus in big-endian binary form 2173 * \param P_len Length of DHM modulus 2174 * \param dhm_G Diffie-Hellman-Merkle generator in big-endian binary form 2175 * \param G_len Length of DHM generator 2176 * 2177 * \return 0 if successful 2178 */ 2179 int mbedtls_ssl_conf_dh_param_bin( mbedtls_ssl_config *conf, 2180 const unsigned char *dhm_P, size_t P_len, 2181 const unsigned char *dhm_G, size_t G_len ); 2182 2183 /** 2184 * \brief Set the Diffie-Hellman public P and G values, 2185 * read from existing context (server-side only) 2186 * 2187 * \param conf SSL configuration 2188 * \param dhm_ctx Diffie-Hellman-Merkle context 2189 * 2190 * \return 0 if successful 2191 */ 2192 int mbedtls_ssl_conf_dh_param_ctx( mbedtls_ssl_config *conf, mbedtls_dhm_context *dhm_ctx ); 2193 #endif /* MBEDTLS_DHM_C && defined(MBEDTLS_SSL_SRV_C) */ 2194 2195 #if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_SSL_CLI_C) 2196 /** 2197 * \brief Set the minimum length for Diffie-Hellman parameters. 2198 * (Client-side only.) 2199 * (Default: 1024 bits.) 2200 * 2201 * \param conf SSL configuration 2202 * \param bitlen Minimum bit length of the DHM prime 2203 */ 2204 void mbedtls_ssl_conf_dhm_min_bitlen( mbedtls_ssl_config *conf, 2205 unsigned int bitlen ); 2206 #endif /* MBEDTLS_DHM_C && MBEDTLS_SSL_CLI_C */ 2207 2208 #if defined(MBEDTLS_ECP_C) 2209 /** 2210 * \brief Set the allowed curves in order of preference. 2211 * (Default: all defined curves.) 2212 * 2213 * On server: this only affects selection of the ECDHE curve; 2214 * the curves used for ECDH and ECDSA are determined by the 2215 * list of available certificates instead. 2216 * 2217 * On client: this affects the list of curves offered for any 2218 * use. The server can override our preference order. 2219 * 2220 * Both sides: limits the set of curves accepted for use in 2221 * ECDHE and in the peer's end-entity certificate. 2222 * 2223 * \note This has no influence on which curves are allowed inside the 2224 * certificate chains, see \c mbedtls_ssl_conf_cert_profile() 2225 * for that. For the end-entity certificate however, the key 2226 * will be accepted only if it is allowed both by this list 2227 * and by the cert profile. 2228 * 2229 * \note This list should be ordered by decreasing preference 2230 * (preferred curve first). 2231 * 2232 * \param conf SSL configuration 2233 * \param curves Ordered list of allowed curves, 2234 * terminated by MBEDTLS_ECP_DP_NONE. 2235 */ 2236 void mbedtls_ssl_conf_curves( mbedtls_ssl_config *conf, 2237 const mbedtls_ecp_group_id *curves ); 2238 #endif /* MBEDTLS_ECP_C */ 2239 2240 #if defined(MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED) 2241 /** 2242 * \brief Set the allowed hashes for signatures during the handshake. 2243 * (Default: all available hashes except MD5.) 2244 * 2245 * \note This only affects which hashes are offered and can be used 2246 * for signatures during the handshake. Hashes for message 2247 * authentication and the TLS PRF are controlled by the 2248 * ciphersuite, see \c mbedtls_ssl_conf_ciphersuites(). Hashes 2249 * used for certificate signature are controlled by the 2250 * verification profile, see \c mbedtls_ssl_conf_cert_profile(). 2251 * 2252 * \note This list should be ordered by decreasing preference 2253 * (preferred hash first). 2254 * 2255 * \param conf SSL configuration 2256 * \param hashes Ordered list of allowed signature hashes, 2257 * terminated by \c MBEDTLS_MD_NONE. 2258 */ 2259 void mbedtls_ssl_conf_sig_hashes( mbedtls_ssl_config *conf, 2260 const int *hashes ); 2261 #endif /* MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED */ 2262 2263 #if defined(MBEDTLS_X509_CRT_PARSE_C) 2264 /** 2265 * \brief Set or reset the hostname to check against the received 2266 * server certificate. It sets the ServerName TLS extension, 2267 * too, if that extension is enabled. (client-side only) 2268 * 2269 * \param ssl SSL context 2270 * \param hostname the server hostname, may be NULL to clear hostname 2271 2272 * \note Maximum hostname length MBEDTLS_SSL_MAX_HOST_NAME_LEN. 2273 * 2274 * \return 0 if successful, MBEDTLS_ERR_SSL_ALLOC_FAILED on 2275 * allocation failure, MBEDTLS_ERR_SSL_BAD_INPUT_DATA on 2276 * too long input hostname. 2277 * 2278 * Hostname set to the one provided on success (cleared 2279 * when NULL). On allocation failure hostname is cleared. 2280 * On too long input failure, old hostname is unchanged. 2281 */ 2282 int mbedtls_ssl_set_hostname( mbedtls_ssl_context *ssl, const char *hostname ); 2283 #endif /* MBEDTLS_X509_CRT_PARSE_C */ 2284 2285 #if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION) 2286 /** 2287 * \brief Set own certificate and key for the current handshake 2288 * 2289 * \note Same as \c mbedtls_ssl_conf_own_cert() but for use within 2290 * the SNI callback. 2291 * 2292 * \param ssl SSL context 2293 * \param own_cert own public certificate chain 2294 * \param pk_key own private key 2295 * 2296 * \return 0 on success or MBEDTLS_ERR_SSL_ALLOC_FAILED 2297 */ 2298 int mbedtls_ssl_set_hs_own_cert( mbedtls_ssl_context *ssl, 2299 mbedtls_x509_crt *own_cert, 2300 mbedtls_pk_context *pk_key ); 2301 2302 /** 2303 * \brief Set the data required to verify peer certificate for the 2304 * current handshake 2305 * 2306 * \note Same as \c mbedtls_ssl_conf_ca_chain() but for use within 2307 * the SNI callback. 2308 * 2309 * \param ssl SSL context 2310 * \param ca_chain trusted CA chain (meaning all fully trusted top-level CAs) 2311 * \param ca_crl trusted CA CRLs 2312 */ 2313 void mbedtls_ssl_set_hs_ca_chain( mbedtls_ssl_context *ssl, 2314 mbedtls_x509_crt *ca_chain, 2315 mbedtls_x509_crl *ca_crl ); 2316 2317 /** 2318 * \brief Set authmode for the current handshake. 2319 * 2320 * \note Same as \c mbedtls_ssl_conf_authmode() but for use within 2321 * the SNI callback. 2322 * 2323 * \param ssl SSL context 2324 * \param authmode MBEDTLS_SSL_VERIFY_NONE, MBEDTLS_SSL_VERIFY_OPTIONAL or 2325 * MBEDTLS_SSL_VERIFY_REQUIRED 2326 */ 2327 void mbedtls_ssl_set_hs_authmode( mbedtls_ssl_context *ssl, 2328 int authmode ); 2329 2330 /** 2331 * \brief Set server side ServerName TLS extension callback 2332 * (optional, server-side only). 2333 * 2334 * If set, the ServerName callback is called whenever the 2335 * server receives a ServerName TLS extension from the client 2336 * during a handshake. The ServerName callback has the 2337 * following parameters: (void *parameter, mbedtls_ssl_context *ssl, 2338 * const unsigned char *hostname, size_t len). If a suitable 2339 * certificate is found, the callback must set the 2340 * certificate(s) and key(s) to use with \c 2341 * mbedtls_ssl_set_hs_own_cert() (can be called repeatedly), 2342 * and may optionally adjust the CA and associated CRL with \c 2343 * mbedtls_ssl_set_hs_ca_chain() as well as the client 2344 * authentication mode with \c mbedtls_ssl_set_hs_authmode(), 2345 * then must return 0. If no matching name is found, the 2346 * callback must either set a default cert, or 2347 * return non-zero to abort the handshake at this point. 2348 * 2349 * \param conf SSL configuration 2350 * \param f_sni verification function 2351 * \param p_sni verification parameter 2352 */ 2353 void mbedtls_ssl_conf_sni( mbedtls_ssl_config *conf, 2354 int (*f_sni)(void *, mbedtls_ssl_context *, const unsigned char *, 2355 size_t), 2356 void *p_sni ); 2357 #endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */ 2358 2359 #if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED) 2360 /** 2361 * \brief Set the EC J-PAKE password for current handshake. 2362 * 2363 * \note An internal copy is made, and destroyed as soon as the 2364 * handshake is completed, or when the SSL context is reset or 2365 * freed. 2366 * 2367 * \note The SSL context needs to be already set up. The right place 2368 * to call this function is between \c mbedtls_ssl_setup() or 2369 * \c mbedtls_ssl_reset() and \c mbedtls_ssl_handshake(). 2370 * 2371 * \param ssl SSL context 2372 * \param pw EC J-PAKE password (pre-shared secret) 2373 * \param pw_len length of pw in bytes 2374 * 2375 * \return 0 on success, or a negative error code. 2376 */ 2377 int mbedtls_ssl_set_hs_ecjpake_password( mbedtls_ssl_context *ssl, 2378 const unsigned char *pw, 2379 size_t pw_len ); 2380 #endif /*MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */ 2381 2382 #if defined(MBEDTLS_SSL_ALPN) 2383 /** 2384 * \brief Set the supported Application Layer Protocols. 2385 * 2386 * \param conf SSL configuration 2387 * \param protos Pointer to a NULL-terminated list of supported protocols, 2388 * in decreasing preference order. The pointer to the list is 2389 * recorded by the library for later reference as required, so 2390 * the lifetime of the table must be atleast as long as the 2391 * lifetime of the SSL configuration structure. 2392 * 2393 * \return 0 on success, or MBEDTLS_ERR_SSL_BAD_INPUT_DATA. 2394 */ 2395 int mbedtls_ssl_conf_alpn_protocols( mbedtls_ssl_config *conf, const char **protos ); 2396 2397 /** 2398 * \brief Get the name of the negotiated Application Layer Protocol. 2399 * This function should be called after the handshake is 2400 * completed. 2401 * 2402 * \param ssl SSL context 2403 * 2404 * \return Protcol name, or NULL if no protocol was negotiated. 2405 */ 2406 const char *mbedtls_ssl_get_alpn_protocol( const mbedtls_ssl_context *ssl ); 2407 #endif /* MBEDTLS_SSL_ALPN */ 2408 2409 /** 2410 * \brief Set the maximum supported version sent from the client side 2411 * and/or accepted at the server side 2412 * (Default: MBEDTLS_SSL_MAX_MAJOR_VERSION, MBEDTLS_SSL_MAX_MINOR_VERSION) 2413 * 2414 * \note This ignores ciphersuites from higher versions. 2415 * 2416 * \note With DTLS, use MBEDTLS_SSL_MINOR_VERSION_2 for DTLS 1.0 and 2417 * MBEDTLS_SSL_MINOR_VERSION_3 for DTLS 1.2 2418 * 2419 * \param conf SSL configuration 2420 * \param major Major version number (only MBEDTLS_SSL_MAJOR_VERSION_3 supported) 2421 * \param minor Minor version number (MBEDTLS_SSL_MINOR_VERSION_0, 2422 * MBEDTLS_SSL_MINOR_VERSION_1 and MBEDTLS_SSL_MINOR_VERSION_2, 2423 * MBEDTLS_SSL_MINOR_VERSION_3 supported) 2424 */ 2425 void mbedtls_ssl_conf_max_version( mbedtls_ssl_config *conf, int major, int minor ); 2426 2427 /** 2428 * \brief Set the minimum accepted SSL/TLS protocol version 2429 * (Default: TLS 1.0) 2430 * 2431 * \note Input outside of the SSL_MAX_XXXXX_VERSION and 2432 * SSL_MIN_XXXXX_VERSION range is ignored. 2433 * 2434 * \note MBEDTLS_SSL_MINOR_VERSION_0 (SSL v3) should be avoided. 2435 * 2436 * \note With DTLS, use MBEDTLS_SSL_MINOR_VERSION_2 for DTLS 1.0 and 2437 * MBEDTLS_SSL_MINOR_VERSION_3 for DTLS 1.2 2438 * 2439 * \param conf SSL configuration 2440 * \param major Major version number (only MBEDTLS_SSL_MAJOR_VERSION_3 supported) 2441 * \param minor Minor version number (MBEDTLS_SSL_MINOR_VERSION_0, 2442 * MBEDTLS_SSL_MINOR_VERSION_1 and MBEDTLS_SSL_MINOR_VERSION_2, 2443 * MBEDTLS_SSL_MINOR_VERSION_3 supported) 2444 */ 2445 void mbedtls_ssl_conf_min_version( mbedtls_ssl_config *conf, int major, int minor ); 2446 2447 #if defined(MBEDTLS_SSL_FALLBACK_SCSV) && defined(MBEDTLS_SSL_CLI_C) 2448 /** 2449 * \brief Set the fallback flag (client-side only). 2450 * (Default: MBEDTLS_SSL_IS_NOT_FALLBACK). 2451 * 2452 * \note Set to MBEDTLS_SSL_IS_FALLBACK when preparing a fallback 2453 * connection, that is a connection with max_version set to a 2454 * lower value than the value you're willing to use. Such 2455 * fallback connections are not recommended but are sometimes 2456 * necessary to interoperate with buggy (version-intolerant) 2457 * servers. 2458 * 2459 * \warning You should NOT set this to MBEDTLS_SSL_IS_FALLBACK for 2460 * non-fallback connections! This would appear to work for a 2461 * while, then cause failures when the server is upgraded to 2462 * support a newer TLS version. 2463 * 2464 * \param conf SSL configuration 2465 * \param fallback MBEDTLS_SSL_IS_NOT_FALLBACK or MBEDTLS_SSL_IS_FALLBACK 2466 */ 2467 void mbedtls_ssl_conf_fallback( mbedtls_ssl_config *conf, char fallback ); 2468 #endif /* MBEDTLS_SSL_FALLBACK_SCSV && MBEDTLS_SSL_CLI_C */ 2469 2470 #if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC) 2471 /** 2472 * \brief Enable or disable Encrypt-then-MAC 2473 * (Default: MBEDTLS_SSL_ETM_ENABLED) 2474 * 2475 * \note This should always be enabled, it is a security 2476 * improvement, and should not cause any interoperability 2477 * issue (used only if the peer supports it too). 2478 * 2479 * \param conf SSL configuration 2480 * \param etm MBEDTLS_SSL_ETM_ENABLED or MBEDTLS_SSL_ETM_DISABLED 2481 */ 2482 void mbedtls_ssl_conf_encrypt_then_mac( mbedtls_ssl_config *conf, char etm ); 2483 #endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */ 2484 2485 #if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET) 2486 /** 2487 * \brief Enable or disable Extended Master Secret negotiation. 2488 * (Default: MBEDTLS_SSL_EXTENDED_MS_ENABLED) 2489 * 2490 * \note This should always be enabled, it is a security fix to the 2491 * protocol, and should not cause any interoperability issue 2492 * (used only if the peer supports it too). 2493 * 2494 * \param conf SSL configuration 2495 * \param ems MBEDTLS_SSL_EXTENDED_MS_ENABLED or MBEDTLS_SSL_EXTENDED_MS_DISABLED 2496 */ 2497 void mbedtls_ssl_conf_extended_master_secret( mbedtls_ssl_config *conf, char ems ); 2498 #endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */ 2499 2500 #if defined(MBEDTLS_ARC4_C) 2501 /** 2502 * \brief Disable or enable support for RC4 2503 * (Default: MBEDTLS_SSL_ARC4_DISABLED) 2504 * 2505 * \warning Use of RC4 in DTLS/TLS has been prohibited by RFC 7465 2506 * for security reasons. Use at your own risk. 2507 * 2508 * \note This function is deprecated and will likely be removed in 2509 * a future version of the library. 2510 * RC4 is disabled by default at compile time and needs to be 2511 * actively enabled for use with legacy systems. 2512 * 2513 * \param conf SSL configuration 2514 * \param arc4 MBEDTLS_SSL_ARC4_ENABLED or MBEDTLS_SSL_ARC4_DISABLED 2515 */ 2516 void mbedtls_ssl_conf_arc4_support( mbedtls_ssl_config *conf, char arc4 ); 2517 #endif /* MBEDTLS_ARC4_C */ 2518 2519 #if defined(MBEDTLS_SSL_SRV_C) 2520 /** 2521 * \brief Whether to send a list of acceptable CAs in 2522 * CertificateRequest messages. 2523 * (Default: do send) 2524 * 2525 * \param conf SSL configuration 2526 * \param cert_req_ca_list MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED or 2527 * MBEDTLS_SSL_CERT_REQ_CA_LIST_DISABLED 2528 */ 2529 void mbedtls_ssl_conf_cert_req_ca_list( mbedtls_ssl_config *conf, 2530 char cert_req_ca_list ); 2531 #endif /* MBEDTLS_SSL_SRV_C */ 2532 2533 #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH) 2534 /** 2535 * \brief Set the maximum fragment length to emit and/or negotiate 2536 * (Default: the smaller of MBEDTLS_SSL_IN_CONTENT_LEN and 2537 * MBEDTLS_SSL_OUT_CONTENT_LEN, usually 2^14 bytes) 2538 * (Server: set maximum fragment length to emit, 2539 * usually negotiated by the client during handshake 2540 * (Client: set maximum fragment length to emit *and* 2541 * negotiate with the server during handshake) 2542 * 2543 * \note With TLS, this currently only affects ApplicationData (sent 2544 * with \c mbedtls_ssl_read()), not handshake messages. 2545 * With DTLS, this affects both ApplicationData and handshake. 2546 * 2547 * \note This sets the maximum length for a record's payload, 2548 * excluding record overhead that will be added to it, see 2549 * \c mbedtls_ssl_get_record_expansion(). 2550 * 2551 * \note For DTLS, it is also possible to set a limit for the total 2552 * size of daragrams passed to the transport layer, including 2553 * record overhead, see \c mbedtls_ssl_set_mtu(). 2554 * 2555 * \param conf SSL configuration 2556 * \param mfl_code Code for maximum fragment length (allowed values: 2557 * MBEDTLS_SSL_MAX_FRAG_LEN_512, MBEDTLS_SSL_MAX_FRAG_LEN_1024, 2558 * MBEDTLS_SSL_MAX_FRAG_LEN_2048, MBEDTLS_SSL_MAX_FRAG_LEN_4096) 2559 * 2560 * \return 0 if successful or MBEDTLS_ERR_SSL_BAD_INPUT_DATA 2561 */ 2562 int mbedtls_ssl_conf_max_frag_len( mbedtls_ssl_config *conf, unsigned char mfl_code ); 2563 #endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */ 2564 2565 #if defined(MBEDTLS_SSL_TRUNCATED_HMAC) 2566 /** 2567 * \brief Activate negotiation of truncated HMAC 2568 * (Default: MBEDTLS_SSL_TRUNC_HMAC_DISABLED) 2569 * 2570 * \param conf SSL configuration 2571 * \param truncate Enable or disable (MBEDTLS_SSL_TRUNC_HMAC_ENABLED or 2572 * MBEDTLS_SSL_TRUNC_HMAC_DISABLED) 2573 */ 2574 void mbedtls_ssl_conf_truncated_hmac( mbedtls_ssl_config *conf, int truncate ); 2575 #endif /* MBEDTLS_SSL_TRUNCATED_HMAC */ 2576 2577 #if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING) 2578 /** 2579 * \brief Enable / Disable 1/n-1 record splitting 2580 * (Default: MBEDTLS_SSL_CBC_RECORD_SPLITTING_ENABLED) 2581 * 2582 * \note Only affects SSLv3 and TLS 1.0, not higher versions. 2583 * Does not affect non-CBC ciphersuites in any version. 2584 * 2585 * \param conf SSL configuration 2586 * \param split MBEDTLS_SSL_CBC_RECORD_SPLITTING_ENABLED or 2587 * MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED 2588 */ 2589 void mbedtls_ssl_conf_cbc_record_splitting( mbedtls_ssl_config *conf, char split ); 2590 #endif /* MBEDTLS_SSL_CBC_RECORD_SPLITTING */ 2591 2592 #if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C) 2593 /** 2594 * \brief Enable / Disable session tickets (client only). 2595 * (Default: MBEDTLS_SSL_SESSION_TICKETS_ENABLED.) 2596 * 2597 * \note On server, use \c mbedtls_ssl_conf_session_tickets_cb(). 2598 * 2599 * \param conf SSL configuration 2600 * \param use_tickets Enable or disable (MBEDTLS_SSL_SESSION_TICKETS_ENABLED or 2601 * MBEDTLS_SSL_SESSION_TICKETS_DISABLED) 2602 */ 2603 void mbedtls_ssl_conf_session_tickets( mbedtls_ssl_config *conf, int use_tickets ); 2604 #endif /* MBEDTLS_SSL_SESSION_TICKETS && MBEDTLS_SSL_CLI_C */ 2605 2606 #if defined(MBEDTLS_SSL_RENEGOTIATION) 2607 /** 2608 * \brief Enable / Disable renegotiation support for connection when 2609 * initiated by peer 2610 * (Default: MBEDTLS_SSL_RENEGOTIATION_DISABLED) 2611 * 2612 * \warning It is recommended to always disable renegotation unless you 2613 * know you need it and you know what you're doing. In the 2614 * past, there have been several issues associated with 2615 * renegotiation or a poor understanding of its properties. 2616 * 2617 * \note Server-side, enabling renegotiation also makes the server 2618 * susceptible to a resource DoS by a malicious client. 2619 * 2620 * \param conf SSL configuration 2621 * \param renegotiation Enable or disable (MBEDTLS_SSL_RENEGOTIATION_ENABLED or 2622 * MBEDTLS_SSL_RENEGOTIATION_DISABLED) 2623 */ 2624 void mbedtls_ssl_conf_renegotiation( mbedtls_ssl_config *conf, int renegotiation ); 2625 #endif /* MBEDTLS_SSL_RENEGOTIATION */ 2626 2627 /** 2628 * \brief Prevent or allow legacy renegotiation. 2629 * (Default: MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION) 2630 * 2631 * MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION allows connections to 2632 * be established even if the peer does not support 2633 * secure renegotiation, but does not allow renegotiation 2634 * to take place if not secure. 2635 * (Interoperable and secure option) 2636 * 2637 * MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION allows renegotiations 2638 * with non-upgraded peers. Allowing legacy renegotiation 2639 * makes the connection vulnerable to specific man in the 2640 * middle attacks. (See RFC 5746) 2641 * (Most interoperable and least secure option) 2642 * 2643 * MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE breaks off connections 2644 * if peer does not support secure renegotiation. Results 2645 * in interoperability issues with non-upgraded peers 2646 * that do not support renegotiation altogether. 2647 * (Most secure option, interoperability issues) 2648 * 2649 * \param conf SSL configuration 2650 * \param allow_legacy Prevent or allow (SSL_NO_LEGACY_RENEGOTIATION, 2651 * SSL_ALLOW_LEGACY_RENEGOTIATION or 2652 * MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE) 2653 */ 2654 void mbedtls_ssl_conf_legacy_renegotiation( mbedtls_ssl_config *conf, int allow_legacy ); 2655 2656 #if defined(MBEDTLS_SSL_RENEGOTIATION) 2657 /** 2658 * \brief Enforce renegotiation requests. 2659 * (Default: enforced, max_records = 16) 2660 * 2661 * When we request a renegotiation, the peer can comply or 2662 * ignore the request. This function allows us to decide 2663 * whether to enforce our renegotiation requests by closing 2664 * the connection if the peer doesn't comply. 2665 * 2666 * However, records could already be in transit from the peer 2667 * when the request is emitted. In order to increase 2668 * reliability, we can accept a number of records before the 2669 * expected handshake records. 2670 * 2671 * The optimal value is highly dependent on the specific usage 2672 * scenario. 2673 * 2674 * \note With DTLS and server-initiated renegotiation, the 2675 * HelloRequest is retransmited every time mbedtls_ssl_read() times 2676 * out or receives Application Data, until: 2677 * - max_records records have beens seen, if it is >= 0, or 2678 * - the number of retransmits that would happen during an 2679 * actual handshake has been reached. 2680 * Please remember the request might be lost a few times 2681 * if you consider setting max_records to a really low value. 2682 * 2683 * \warning On client, the grace period can only happen during 2684 * mbedtls_ssl_read(), as opposed to mbedtls_ssl_write() and mbedtls_ssl_renegotiate() 2685 * which always behave as if max_record was 0. The reason is, 2686 * if we receive application data from the server, we need a 2687 * place to write it, which only happens during mbedtls_ssl_read(). 2688 * 2689 * \param conf SSL configuration 2690 * \param max_records Use MBEDTLS_SSL_RENEGOTIATION_NOT_ENFORCED if you don't want to 2691 * enforce renegotiation, or a non-negative value to enforce 2692 * it but allow for a grace period of max_records records. 2693 */ 2694 void mbedtls_ssl_conf_renegotiation_enforced( mbedtls_ssl_config *conf, int max_records ); 2695 2696 /** 2697 * \brief Set record counter threshold for periodic renegotiation. 2698 * (Default: 2^48 - 1) 2699 * 2700 * Renegotiation is automatically triggered when a record 2701 * counter (outgoing or ingoing) crosses the defined 2702 * threshold. The default value is meant to prevent the 2703 * connection from being closed when the counter is about to 2704 * reached its maximal value (it is not allowed to wrap). 2705 * 2706 * Lower values can be used to enforce policies such as "keys 2707 * must be refreshed every N packets with cipher X". 2708 * 2709 * The renegotiation period can be disabled by setting 2710 * conf->disable_renegotiation to 2711 * MBEDTLS_SSL_RENEGOTIATION_DISABLED. 2712 * 2713 * \note When the configured transport is 2714 * MBEDTLS_SSL_TRANSPORT_DATAGRAM the maximum renegotiation 2715 * period is 2^48 - 1, and for MBEDTLS_SSL_TRANSPORT_STREAM, 2716 * the maximum renegotiation period is 2^64 - 1. 2717 * 2718 * \param conf SSL configuration 2719 * \param period The threshold value: a big-endian 64-bit number. 2720 */ 2721 void mbedtls_ssl_conf_renegotiation_period( mbedtls_ssl_config *conf, 2722 const unsigned char period[8] ); 2723 #endif /* MBEDTLS_SSL_RENEGOTIATION */ 2724 2725 /** 2726 * \brief Check if there is data already read from the 2727 * underlying transport but not yet processed. 2728 * 2729 * \param ssl SSL context 2730 * 2731 * \return 0 if nothing's pending, 1 otherwise. 2732 * 2733 * \note This is different in purpose and behaviour from 2734 * \c mbedtls_ssl_get_bytes_avail in that it considers 2735 * any kind of unprocessed data, not only unread 2736 * application data. If \c mbedtls_ssl_get_bytes 2737 * returns a non-zero value, this function will 2738 * also signal pending data, but the converse does 2739 * not hold. For example, in DTLS there might be 2740 * further records waiting to be processed from 2741 * the current underlying transport's datagram. 2742 * 2743 * \note If this function returns 1 (data pending), this 2744 * does not imply that a subsequent call to 2745 * \c mbedtls_ssl_read will provide any data; 2746 * e.g., the unprocessed data might turn out 2747 * to be an alert or a handshake message. 2748 * 2749 * \note This function is useful in the following situation: 2750 * If the SSL/TLS module successfully returns from an 2751 * operation - e.g. a handshake or an application record 2752 * read - and you're awaiting incoming data next, you 2753 * must not immediately idle on the underlying transport 2754 * to have data ready, but you need to check the value 2755 * of this function first. The reason is that the desired 2756 * data might already be read but not yet processed. 2757 * If, in contrast, a previous call to the SSL/TLS module 2758 * returned MBEDTLS_ERR_SSL_WANT_READ, it is not necessary 2759 * to call this function, as the latter error code entails 2760 * that all internal data has been processed. 2761 * 2762 */ 2763 int mbedtls_ssl_check_pending( const mbedtls_ssl_context *ssl ); 2764 2765 /** 2766 * \brief Return the number of application data bytes 2767 * remaining to be read from the current record. 2768 * 2769 * \param ssl SSL context 2770 * 2771 * \return How many bytes are available in the application 2772 * data record read buffer. 2773 * 2774 * \note When working over a datagram transport, this is 2775 * useful to detect the current datagram's boundary 2776 * in case \c mbedtls_ssl_read has written the maximal 2777 * amount of data fitting into the input buffer. 2778 * 2779 */ 2780 size_t mbedtls_ssl_get_bytes_avail( const mbedtls_ssl_context *ssl ); 2781 2782 /** 2783 * \brief Return the result of the certificate verification 2784 * 2785 * \param ssl The SSL context to use. 2786 * 2787 * \return \c 0 if the certificate verification was successful. 2788 * \return \c -1u if the result is not available. This may happen 2789 * e.g. if the handshake aborts early, or a verification 2790 * callback returned a fatal error. 2791 * \return A bitwise combination of \c MBEDTLS_X509_BADCERT_XXX 2792 * and \c MBEDTLS_X509_BADCRL_XXX failure flags; see x509.h. 2793 */ 2794 uint32_t mbedtls_ssl_get_verify_result( const mbedtls_ssl_context *ssl ); 2795 2796 /** 2797 * \brief Return the name of the current ciphersuite 2798 * 2799 * \param ssl SSL context 2800 * 2801 * \return a string containing the ciphersuite name 2802 */ 2803 const char *mbedtls_ssl_get_ciphersuite( const mbedtls_ssl_context *ssl ); 2804 2805 /** 2806 * \brief Return the current SSL version (SSLv3/TLSv1/etc) 2807 * 2808 * \param ssl SSL context 2809 * 2810 * \return a string containing the SSL version 2811 */ 2812 const char *mbedtls_ssl_get_version( const mbedtls_ssl_context *ssl ); 2813 2814 /** 2815 * \brief Return the (maximum) number of bytes added by the record 2816 * layer: header + encryption/MAC overhead (inc. padding) 2817 * 2818 * \note This function is not available (always returns an error) 2819 * when record compression is enabled. 2820 * 2821 * \param ssl SSL context 2822 * 2823 * \return Current maximum record expansion in bytes, or 2824 * MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE if compression is 2825 * enabled, which makes expansion much less predictable 2826 */ 2827 int mbedtls_ssl_get_record_expansion( const mbedtls_ssl_context *ssl ); 2828 2829 #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH) 2830 /** 2831 * \brief Return the maximum fragment length (payload, in bytes). 2832 * This is the value negotiated with peer if any, 2833 * or the locally configured value. 2834 * 2835 * \sa mbedtls_ssl_conf_max_frag_len() 2836 * \sa mbedtls_ssl_get_max_record_payload() 2837 * 2838 * \param ssl SSL context 2839 * 2840 * \return Current maximum fragment length. 2841 */ 2842 size_t mbedtls_ssl_get_max_frag_len( const mbedtls_ssl_context *ssl ); 2843 #endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */ 2844 2845 /** 2846 * \brief Return the current maximum outgoing record payload in bytes. 2847 * This takes into account the config.h setting \c 2848 * MBEDTLS_SSL_OUT_CONTENT_LEN, the configured and negotiated 2849 * max fragment length extension if used, and for DTLS the 2850 * path MTU as configured and current record expansion. 2851 * 2852 * \note With DTLS, \c mbedtls_ssl_write() will return an error if 2853 * called with a larger length value. 2854 * With TLS, \c mbedtls_ssl_write() will fragment the input if 2855 * necessary and return the number of bytes written; it is up 2856 * to the caller to call \c mbedtls_ssl_write() again in 2857 * order to send the remaining bytes if any. 2858 * 2859 * \note This function is not available (always returns an error) 2860 * when record compression is enabled. 2861 * 2862 * \sa mbedtls_ssl_set_mtu() 2863 * \sa mbedtls_ssl_get_max_frag_len() 2864 * \sa mbedtls_ssl_get_record_expansion() 2865 * 2866 * \param ssl SSL context 2867 * 2868 * \return Current maximum payload for an outgoing record, 2869 * or a negative error code. 2870 */ 2871 int mbedtls_ssl_get_max_out_record_payload( const mbedtls_ssl_context *ssl ); 2872 2873 #if defined(MBEDTLS_X509_CRT_PARSE_C) 2874 /** 2875 * \brief Return the peer certificate from the current connection 2876 * 2877 * Note: Can be NULL in case no certificate was sent during 2878 * the handshake. Different calls for the same connection can 2879 * return the same or different pointers for the same 2880 * certificate and even a different certificate altogether. 2881 * The peer cert CAN change in a single connection if 2882 * renegotiation is performed. 2883 * 2884 * \param ssl SSL context 2885 * 2886 * \return the current peer certificate 2887 */ 2888 const mbedtls_x509_crt *mbedtls_ssl_get_peer_cert( const mbedtls_ssl_context *ssl ); 2889 #endif /* MBEDTLS_X509_CRT_PARSE_C */ 2890 2891 #if defined(MBEDTLS_SSL_CLI_C) 2892 /** 2893 * \brief Save session in order to resume it later (client-side only) 2894 * Session data is copied to presented session structure. 2895 * 2896 * 2897 * \param ssl SSL context 2898 * \param session session context 2899 * 2900 * \return 0 if successful, 2901 * MBEDTLS_ERR_SSL_ALLOC_FAILED if memory allocation failed, 2902 * MBEDTLS_ERR_SSL_BAD_INPUT_DATA if used server-side or 2903 * arguments are otherwise invalid. 2904 * 2905 * \note Only the server certificate is copied, and not the full chain, 2906 * so you should not attempt to validate the certificate again 2907 * by calling \c mbedtls_x509_crt_verify() on it. 2908 * Instead, you should use the results from the verification 2909 * in the original handshake by calling \c mbedtls_ssl_get_verify_result() 2910 * after loading the session again into a new SSL context 2911 * using \c mbedtls_ssl_set_session(). 2912 * 2913 * \note Once the session object is not needed anymore, you should 2914 * free it by calling \c mbedtls_ssl_session_free(). 2915 * 2916 * \sa mbedtls_ssl_set_session() 2917 */ 2918 int mbedtls_ssl_get_session( const mbedtls_ssl_context *ssl, mbedtls_ssl_session *session ); 2919 #endif /* MBEDTLS_SSL_CLI_C */ 2920 2921 /** 2922 * \brief Perform the SSL handshake 2923 * 2924 * \param ssl SSL context 2925 * 2926 * \return \c 0 if successful. 2927 * \return #MBEDTLS_ERR_SSL_WANT_READ or #MBEDTLS_ERR_SSL_WANT_WRITE 2928 * if the handshake is incomplete and waiting for data to 2929 * be available for reading from or writing to the underlying 2930 * transport - in this case you must call this function again 2931 * when the underlying transport is ready for the operation. 2932 * \return #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS if an asynchronous 2933 * operation is in progress (see 2934 * mbedtls_ssl_conf_async_private_cb()) - in this case you 2935 * must call this function again when the operation is ready. 2936 * \return #MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS if a cryptographic 2937 * operation is in progress (see mbedtls_ecp_set_max_ops()) - 2938 * in this case you must call this function again to complete 2939 * the handshake when you're done attending other tasks. 2940 * \return #MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED if DTLS is in use 2941 * and the client did not demonstrate reachability yet - in 2942 * this case you must stop using the context (see below). 2943 * \return Another SSL error code - in this case you must stop using 2944 * the context (see below). 2945 * 2946 * \warning If this function returns something other than 2947 * \c 0, 2948 * #MBEDTLS_ERR_SSL_WANT_READ, 2949 * #MBEDTLS_ERR_SSL_WANT_WRITE, 2950 * #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS or 2951 * #MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS, 2952 * you must stop using the SSL context for reading or writing, 2953 * and either free it or call \c mbedtls_ssl_session_reset() 2954 * on it before re-using it for a new connection; the current 2955 * connection must be closed. 2956 * 2957 * \note If DTLS is in use, then you may choose to handle 2958 * #MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED specially for logging 2959 * purposes, as it is an expected return value rather than an 2960 * actual error, but you still need to reset/free the context. 2961 * 2962 * \note Remarks regarding event-driven DTLS: 2963 * If the function returns #MBEDTLS_ERR_SSL_WANT_READ, no datagram 2964 * from the underlying transport layer is currently being processed, 2965 * and it is safe to idle until the timer or the underlying transport 2966 * signal a new event. This is not true for a successful handshake, 2967 * in which case the datagram of the underlying transport that is 2968 * currently being processed might or might not contain further 2969 * DTLS records. 2970 */ 2971 int mbedtls_ssl_handshake( mbedtls_ssl_context *ssl ); 2972 2973 /** 2974 * \brief Perform a single step of the SSL handshake 2975 * 2976 * \note The state of the context (ssl->state) will be at 2977 * the next state after this function returns \c 0. Do not 2978 * call this function if state is MBEDTLS_SSL_HANDSHAKE_OVER. 2979 * 2980 * \param ssl SSL context 2981 * 2982 * \return See mbedtls_ssl_handshake(). 2983 * 2984 * \warning If this function returns something other than \c 0, 2985 * #MBEDTLS_ERR_SSL_WANT_READ, #MBEDTLS_ERR_SSL_WANT_WRITE, 2986 * #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS or 2987 * #MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS, you must stop using 2988 * the SSL context for reading or writing, and either free it 2989 * or call \c mbedtls_ssl_session_reset() on it before 2990 * re-using it for a new connection; the current connection 2991 * must be closed. 2992 */ 2993 int mbedtls_ssl_handshake_step( mbedtls_ssl_context *ssl ); 2994 2995 #if defined(MBEDTLS_SSL_RENEGOTIATION) 2996 /** 2997 * \brief Initiate an SSL renegotiation on the running connection. 2998 * Client: perform the renegotiation right now. 2999 * Server: request renegotiation, which will be performed 3000 * during the next call to mbedtls_ssl_read() if honored by 3001 * client. 3002 * 3003 * \param ssl SSL context 3004 * 3005 * \return 0 if successful, or any mbedtls_ssl_handshake() return 3006 * value except #MBEDTLS_ERR_SSL_CLIENT_RECONNECT that can't 3007 * happen during a renegotiation. 3008 * 3009 * \warning If this function returns something other than \c 0, 3010 * #MBEDTLS_ERR_SSL_WANT_READ, #MBEDTLS_ERR_SSL_WANT_WRITE, 3011 * #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS or 3012 * #MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS, you must stop using 3013 * the SSL context for reading or writing, and either free it 3014 * or call \c mbedtls_ssl_session_reset() on it before 3015 * re-using it for a new connection; the current connection 3016 * must be closed. 3017 * 3018 */ 3019 int mbedtls_ssl_renegotiate( mbedtls_ssl_context *ssl ); 3020 #endif /* MBEDTLS_SSL_RENEGOTIATION */ 3021 3022 /** 3023 * \brief Read at most 'len' application data bytes 3024 * 3025 * \param ssl SSL context 3026 * \param buf buffer that will hold the data 3027 * \param len maximum number of bytes to read 3028 * 3029 * \return The (positive) number of bytes read if successful. 3030 * \return \c 0 if the read end of the underlying transport was closed 3031 * - in this case you must stop using the context (see below). 3032 * \return #MBEDTLS_ERR_SSL_WANT_READ or #MBEDTLS_ERR_SSL_WANT_WRITE 3033 * if the handshake is incomplete and waiting for data to 3034 * be available for reading from or writing to the underlying 3035 * transport - in this case you must call this function again 3036 * when the underlying transport is ready for the operation. 3037 * \return #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS if an asynchronous 3038 * operation is in progress (see 3039 * mbedtls_ssl_conf_async_private_cb()) - in this case you 3040 * must call this function again when the operation is ready. 3041 * \return #MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS if a cryptographic 3042 * operation is in progress (see mbedtls_ecp_set_max_ops()) - 3043 * in this case you must call this function again to complete 3044 * the handshake when you're done attending other tasks. 3045 * \return #MBEDTLS_ERR_SSL_CLIENT_RECONNECT if we're at the server 3046 * side of a DTLS connection and the client is initiating a 3047 * new connection using the same source port. See below. 3048 * \return Another SSL error code - in this case you must stop using 3049 * the context (see below). 3050 * 3051 * \warning If this function returns something other than 3052 * a positive value, 3053 * #MBEDTLS_ERR_SSL_WANT_READ, 3054 * #MBEDTLS_ERR_SSL_WANT_WRITE, 3055 * #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS, 3056 * #MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS or 3057 * #MBEDTLS_ERR_SSL_CLIENT_RECONNECT, 3058 * you must stop using the SSL context for reading or writing, 3059 * and either free it or call \c mbedtls_ssl_session_reset() 3060 * on it before re-using it for a new connection; the current 3061 * connection must be closed. 3062 * 3063 * \note When this function returns #MBEDTLS_ERR_SSL_CLIENT_RECONNECT 3064 * (which can only happen server-side), it means that a client 3065 * is initiating a new connection using the same source port. 3066 * You can either treat that as a connection close and wait 3067 * for the client to resend a ClientHello, or directly 3068 * continue with \c mbedtls_ssl_handshake() with the same 3069 * context (as it has been reset internally). Either way, you 3070 * must make sure this is seen by the application as a new 3071 * connection: application state, if any, should be reset, and 3072 * most importantly the identity of the client must be checked 3073 * again. WARNING: not validating the identity of the client 3074 * again, or not transmitting the new identity to the 3075 * application layer, would allow authentication bypass! 3076 * 3077 * \note Remarks regarding event-driven DTLS: 3078 * - If the function returns #MBEDTLS_ERR_SSL_WANT_READ, no datagram 3079 * from the underlying transport layer is currently being processed, 3080 * and it is safe to idle until the timer or the underlying transport 3081 * signal a new event. 3082 * - This function may return MBEDTLS_ERR_SSL_WANT_READ even if data was 3083 * initially available on the underlying transport, as this data may have 3084 * been only e.g. duplicated messages or a renegotiation request. 3085 * Therefore, you must be prepared to receive MBEDTLS_ERR_SSL_WANT_READ even 3086 * when reacting to an incoming-data event from the underlying transport. 3087 * - On success, the datagram of the underlying transport that is currently 3088 * being processed may contain further DTLS records. You should call 3089 * \c mbedtls_ssl_check_pending to check for remaining records. 3090 * 3091 */ 3092 int mbedtls_ssl_read( mbedtls_ssl_context *ssl, unsigned char *buf, size_t len ); 3093 3094 /** 3095 * \brief Try to write exactly 'len' application data bytes 3096 * 3097 * \warning This function will do partial writes in some cases. If the 3098 * return value is non-negative but less than length, the 3099 * function must be called again with updated arguments: 3100 * buf + ret, len - ret (if ret is the return value) until 3101 * it returns a value equal to the last 'len' argument. 3102 * 3103 * \param ssl SSL context 3104 * \param buf buffer holding the data 3105 * \param len how many bytes must be written 3106 * 3107 * \return The (non-negative) number of bytes actually written if 3108 * successful (may be less than \p len). 3109 * \return #MBEDTLS_ERR_SSL_WANT_READ or #MBEDTLS_ERR_SSL_WANT_WRITE 3110 * if the handshake is incomplete and waiting for data to 3111 * be available for reading from or writing to the underlying 3112 * transport - in this case you must call this function again 3113 * when the underlying transport is ready for the operation. 3114 * \return #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS if an asynchronous 3115 * operation is in progress (see 3116 * mbedtls_ssl_conf_async_private_cb()) - in this case you 3117 * must call this function again when the operation is ready. 3118 * \return #MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS if a cryptographic 3119 * operation is in progress (see mbedtls_ecp_set_max_ops()) - 3120 * in this case you must call this function again to complete 3121 * the handshake when you're done attending other tasks. 3122 * \return Another SSL error code - in this case you must stop using 3123 * the context (see below). 3124 * 3125 * \warning If this function returns something other than 3126 * a non-negative value, 3127 * #MBEDTLS_ERR_SSL_WANT_READ, 3128 * #MBEDTLS_ERR_SSL_WANT_WRITE, 3129 * #MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS or 3130 * #MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS, 3131 * you must stop using the SSL context for reading or writing, 3132 * and either free it or call \c mbedtls_ssl_session_reset() 3133 * on it before re-using it for a new connection; the current 3134 * connection must be closed. 3135 * 3136 * \note When this function returns #MBEDTLS_ERR_SSL_WANT_WRITE/READ, 3137 * it must be called later with the *same* arguments, 3138 * until it returns a value greater that or equal to 0. When 3139 * the function returns #MBEDTLS_ERR_SSL_WANT_WRITE there may be 3140 * some partial data in the output buffer, however this is not 3141 * yet sent. 3142 * 3143 * \note If the requested length is greater than the maximum 3144 * fragment length (either the built-in limit or the one set 3145 * or negotiated with the peer), then: 3146 * - with TLS, less bytes than requested are written. 3147 * - with DTLS, MBEDTLS_ERR_SSL_BAD_INPUT_DATA is returned. 3148 * \c mbedtls_ssl_get_max_frag_len() may be used to query the 3149 * active maximum fragment length. 3150 * 3151 * \note Attempting to write 0 bytes will result in an empty TLS 3152 * application record being sent. 3153 */ 3154 int mbedtls_ssl_write( mbedtls_ssl_context *ssl, const unsigned char *buf, size_t len ); 3155 3156 /** 3157 * \brief Send an alert message 3158 * 3159 * \param ssl SSL context 3160 * \param level The alert level of the message 3161 * (MBEDTLS_SSL_ALERT_LEVEL_WARNING or MBEDTLS_SSL_ALERT_LEVEL_FATAL) 3162 * \param message The alert message (SSL_ALERT_MSG_*) 3163 * 3164 * \return 0 if successful, or a specific SSL error code. 3165 * 3166 * \note If this function returns something other than 0 or 3167 * MBEDTLS_ERR_SSL_WANT_READ/WRITE, you must stop using 3168 * the SSL context for reading or writing, and either free it or 3169 * call \c mbedtls_ssl_session_reset() on it before re-using it 3170 * for a new connection; the current connection must be closed. 3171 */ 3172 int mbedtls_ssl_send_alert_message( mbedtls_ssl_context *ssl, 3173 unsigned char level, 3174 unsigned char message ); 3175 /** 3176 * \brief Notify the peer that the connection is being closed 3177 * 3178 * \param ssl SSL context 3179 * 3180 * \return 0 if successful, or a specific SSL error code. 3181 * 3182 * \note If this function returns something other than 0 or 3183 * MBEDTLS_ERR_SSL_WANT_READ/WRITE, you must stop using 3184 * the SSL context for reading or writing, and either free it or 3185 * call \c mbedtls_ssl_session_reset() on it before re-using it 3186 * for a new connection; the current connection must be closed. 3187 */ 3188 int mbedtls_ssl_close_notify( mbedtls_ssl_context *ssl ); 3189 3190 /** 3191 * \brief Free referenced items in an SSL context and clear memory 3192 * 3193 * \param ssl SSL context 3194 */ 3195 void mbedtls_ssl_free( mbedtls_ssl_context *ssl ); 3196 3197 /** 3198 * \brief Initialize an SSL configuration context 3199 * Just makes the context ready for 3200 * mbedtls_ssl_config_defaults() or mbedtls_ssl_config_free(). 3201 * 3202 * \note You need to call mbedtls_ssl_config_defaults() unless you 3203 * manually set all of the relevent fields yourself. 3204 * 3205 * \param conf SSL configuration context 3206 */ 3207 void mbedtls_ssl_config_init( mbedtls_ssl_config *conf ); 3208 3209 /** 3210 * \brief Load reasonnable default SSL configuration values. 3211 * (You need to call mbedtls_ssl_config_init() first.) 3212 * 3213 * \param conf SSL configuration context 3214 * \param endpoint MBEDTLS_SSL_IS_CLIENT or MBEDTLS_SSL_IS_SERVER 3215 * \param transport MBEDTLS_SSL_TRANSPORT_STREAM for TLS, or 3216 * MBEDTLS_SSL_TRANSPORT_DATAGRAM for DTLS 3217 * \param preset a MBEDTLS_SSL_PRESET_XXX value 3218 * 3219 * \note See \c mbedtls_ssl_conf_transport() for notes on DTLS. 3220 * 3221 * \return 0 if successful, or 3222 * MBEDTLS_ERR_XXX_ALLOC_FAILED on memory allocation error. 3223 */ 3224 int mbedtls_ssl_config_defaults( mbedtls_ssl_config *conf, 3225 int endpoint, int transport, int preset ); 3226 3227 /** 3228 * \brief Free an SSL configuration context 3229 * 3230 * \param conf SSL configuration context 3231 */ 3232 void mbedtls_ssl_config_free( mbedtls_ssl_config *conf ); 3233 3234 /** 3235 * \brief Initialize SSL session structure 3236 * 3237 * \param session SSL session 3238 */ 3239 void mbedtls_ssl_session_init( mbedtls_ssl_session *session ); 3240 3241 /** 3242 * \brief Free referenced items in an SSL session including the 3243 * peer certificate and clear memory 3244 * 3245 * \note A session object can be freed even if the SSL context 3246 * that was used to retrieve the session is still in use. 3247 * 3248 * \param session SSL session 3249 */ 3250 void mbedtls_ssl_session_free( mbedtls_ssl_session *session ); 3251 3252 #ifdef __cplusplus 3253 } 3254 #endif 3255 3256 #endif /* ssl.h */ 3257