ssl_internal.h 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617
  1. /**
  2. * \file ssl_ticket.h
  3. *
  4. * \brief Internal functions shared by the SSL modules
  5. *
  6. * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
  7. * SPDX-License-Identifier: Apache-2.0
  8. *
  9. * Licensed under the Apache License, Version 2.0 (the "License"); you may
  10. * not use this file except in compliance with the License.
  11. * You may obtain a copy of the License at
  12. *
  13. * http://www.apache.org/licenses/LICENSE-2.0
  14. *
  15. * Unless required by applicable law or agreed to in writing, software
  16. * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  17. * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18. * See the License for the specific language governing permissions and
  19. * limitations under the License.
  20. *
  21. * This file is part of mbed TLS (https://tls.mbed.org)
  22. */
  23. #ifndef MBEDTLS_SSL_INTERNAL_H
  24. #define MBEDTLS_SSL_INTERNAL_H
  25. #include "ssl.h"
  26. #if defined(MBEDTLS_MD5_C)
  27. #include "md5.h"
  28. #endif
  29. #if defined(MBEDTLS_SHA1_C)
  30. #include "sha1.h"
  31. #endif
  32. #if defined(MBEDTLS_SHA256_C)
  33. #include "sha256.h"
  34. #endif
  35. #if defined(MBEDTLS_SHA512_C)
  36. #include "sha512.h"
  37. #endif
  38. #if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
  39. #include "ecjpake.h"
  40. #endif
  41. #if ( defined(__ARMCC_VERSION) || defined(_MSC_VER) ) && \
  42. !defined(inline) && !defined(__cplusplus)
  43. #define inline __inline
  44. #endif
  45. /* Determine minimum supported version */
  46. #define MBEDTLS_SSL_MIN_MAJOR_VERSION MBEDTLS_SSL_MAJOR_VERSION_3
  47. #if defined(MBEDTLS_SSL_PROTO_SSL3)
  48. #define MBEDTLS_SSL_MIN_MINOR_VERSION MBEDTLS_SSL_MINOR_VERSION_0
  49. #else
  50. #if defined(MBEDTLS_SSL_PROTO_TLS1)
  51. #define MBEDTLS_SSL_MIN_MINOR_VERSION MBEDTLS_SSL_MINOR_VERSION_1
  52. #else
  53. #if defined(MBEDTLS_SSL_PROTO_TLS1_1)
  54. #define MBEDTLS_SSL_MIN_MINOR_VERSION MBEDTLS_SSL_MINOR_VERSION_2
  55. #else
  56. #if defined(MBEDTLS_SSL_PROTO_TLS1_2)
  57. #define MBEDTLS_SSL_MIN_MINOR_VERSION MBEDTLS_SSL_MINOR_VERSION_3
  58. #endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
  59. #endif /* MBEDTLS_SSL_PROTO_TLS1_1 */
  60. #endif /* MBEDTLS_SSL_PROTO_TLS1 */
  61. #endif /* MBEDTLS_SSL_PROTO_SSL3 */
  62. /* Determine maximum supported version */
  63. #define MBEDTLS_SSL_MAX_MAJOR_VERSION MBEDTLS_SSL_MAJOR_VERSION_3
  64. #if defined(MBEDTLS_SSL_PROTO_TLS1_2)
  65. #define MBEDTLS_SSL_MAX_MINOR_VERSION MBEDTLS_SSL_MINOR_VERSION_3
  66. #else
  67. #if defined(MBEDTLS_SSL_PROTO_TLS1_1)
  68. #define MBEDTLS_SSL_MAX_MINOR_VERSION MBEDTLS_SSL_MINOR_VERSION_2
  69. #else
  70. #if defined(MBEDTLS_SSL_PROTO_TLS1)
  71. #define MBEDTLS_SSL_MAX_MINOR_VERSION MBEDTLS_SSL_MINOR_VERSION_1
  72. #else
  73. #if defined(MBEDTLS_SSL_PROTO_SSL3)
  74. #define MBEDTLS_SSL_MAX_MINOR_VERSION MBEDTLS_SSL_MINOR_VERSION_0
  75. #endif /* MBEDTLS_SSL_PROTO_SSL3 */
  76. #endif /* MBEDTLS_SSL_PROTO_TLS1 */
  77. #endif /* MBEDTLS_SSL_PROTO_TLS1_1 */
  78. #endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
  79. #define MBEDTLS_SSL_INITIAL_HANDSHAKE 0
  80. #define MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS 1 /* In progress */
  81. #define MBEDTLS_SSL_RENEGOTIATION_DONE 2 /* Done or aborted */
  82. #define MBEDTLS_SSL_RENEGOTIATION_PENDING 3 /* Requested (server only) */
  83. /*
  84. * DTLS retransmission states, see RFC 6347 4.2.4
  85. *
  86. * The SENDING state is merged in PREPARING for initial sends,
  87. * but is distinct for resends.
  88. *
  89. * Note: initial state is wrong for server, but is not used anyway.
  90. */
  91. #define MBEDTLS_SSL_RETRANS_PREPARING 0
  92. #define MBEDTLS_SSL_RETRANS_SENDING 1
  93. #define MBEDTLS_SSL_RETRANS_WAITING 2
  94. #define MBEDTLS_SSL_RETRANS_FINISHED 3
  95. /*
  96. * Allow extra bytes for record, authentication and encryption overhead:
  97. * counter (8) + header (5) + IV(16) + MAC (16-48) + padding (0-256)
  98. * and allow for a maximum of 1024 of compression expansion if
  99. * enabled.
  100. */
  101. #if defined(MBEDTLS_ZLIB_SUPPORT)
  102. #define MBEDTLS_SSL_COMPRESSION_ADD 1024
  103. #else
  104. #define MBEDTLS_SSL_COMPRESSION_ADD 0
  105. #endif
  106. #if defined(MBEDTLS_ARC4_C) || defined(MBEDTLS_CIPHER_MODE_CBC)
  107. /* Ciphersuites using HMAC */
  108. #if defined(MBEDTLS_SHA512_C)
  109. #define MBEDTLS_SSL_MAC_ADD 48 /* SHA-384 used for HMAC */
  110. #elif defined(MBEDTLS_SHA256_C)
  111. #define MBEDTLS_SSL_MAC_ADD 32 /* SHA-256 used for HMAC */
  112. #else
  113. #define MBEDTLS_SSL_MAC_ADD 20 /* SHA-1 used for HMAC */
  114. #endif
  115. #else
  116. /* AEAD ciphersuites: GCM and CCM use a 128 bits tag */
  117. #define MBEDTLS_SSL_MAC_ADD 16
  118. #endif
  119. #if defined(MBEDTLS_CIPHER_MODE_CBC)
  120. #define MBEDTLS_SSL_PADDING_ADD 256
  121. #else
  122. #define MBEDTLS_SSL_PADDING_ADD 0
  123. #endif
  124. #define MBEDTLS_SSL_BUFFER_LEN ( MBEDTLS_SSL_MAX_CONTENT_LEN \
  125. + MBEDTLS_SSL_COMPRESSION_ADD \
  126. + 29 /* counter + header + IV */ \
  127. + MBEDTLS_SSL_MAC_ADD \
  128. + MBEDTLS_SSL_PADDING_ADD \
  129. )
  130. /*
  131. * TLS extension flags (for extensions with outgoing ServerHello content
  132. * that need it (e.g. for RENEGOTIATION_INFO the server already knows because
  133. * of state of the renegotiation flag, so no indicator is required)
  134. */
  135. #define MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS_PRESENT (1 << 0)
  136. #define MBEDTLS_TLS_EXT_ECJPAKE_KKPP_OK (1 << 1)
  137. #ifdef __cplusplus
  138. extern "C" {
  139. #endif
  140. #if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
  141. defined(MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED)
  142. /*
  143. * Abstraction for a grid of allowed signature-hash-algorithm pairs.
  144. */
  145. struct mbedtls_ssl_sig_hash_set_t
  146. {
  147. /* At the moment, we only need to remember a single suitable
  148. * hash algorithm per signature algorithm. As long as that's
  149. * the case - and we don't need a general lookup function -
  150. * we can implement the sig-hash-set as a map from signatures
  151. * to hash algorithms. */
  152. mbedtls_md_type_t rsa;
  153. mbedtls_md_type_t ecdsa;
  154. };
  155. #endif /* MBEDTLS_SSL_PROTO_TLS1_2 &&
  156. MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED */
  157. /*
  158. * This structure contains the parameters only needed during handshake.
  159. */
  160. struct mbedtls_ssl_handshake_params
  161. {
  162. /*
  163. * Handshake specific crypto variables
  164. */
  165. #if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
  166. defined(MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED)
  167. mbedtls_ssl_sig_hash_set_t hash_algs; /*!< Set of suitable sig-hash pairs */
  168. #endif
  169. #if defined(MBEDTLS_DHM_C)
  170. mbedtls_dhm_context dhm_ctx; /*!< DHM key exchange */
  171. #endif
  172. #if defined(MBEDTLS_ECDH_C)
  173. mbedtls_ecdh_context ecdh_ctx; /*!< ECDH key exchange */
  174. #endif
  175. #if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
  176. mbedtls_ecjpake_context ecjpake_ctx; /*!< EC J-PAKE key exchange */
  177. #if defined(MBEDTLS_SSL_CLI_C)
  178. unsigned char *ecjpake_cache; /*!< Cache for ClientHello ext */
  179. size_t ecjpake_cache_len; /*!< Length of cached data */
  180. #endif
  181. #endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
  182. #if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
  183. defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
  184. const mbedtls_ecp_curve_info **curves; /*!< Supported elliptic curves */
  185. #endif
  186. #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
  187. unsigned char *psk; /*!< PSK from the callback */
  188. size_t psk_len; /*!< Length of PSK from callback */
  189. #endif
  190. #if defined(MBEDTLS_X509_CRT_PARSE_C)
  191. mbedtls_ssl_key_cert *key_cert; /*!< chosen key/cert pair (server) */
  192. #if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
  193. int sni_authmode; /*!< authmode from SNI callback */
  194. mbedtls_ssl_key_cert *sni_key_cert; /*!< key/cert list from SNI */
  195. mbedtls_x509_crt *sni_ca_chain; /*!< trusted CAs from SNI callback */
  196. mbedtls_x509_crl *sni_ca_crl; /*!< trusted CAs CRLs from SNI */
  197. #endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
  198. #endif /* MBEDTLS_X509_CRT_PARSE_C */
  199. #if defined(MBEDTLS_SSL_PROTO_DTLS)
  200. unsigned int out_msg_seq; /*!< Outgoing handshake sequence number */
  201. unsigned int in_msg_seq; /*!< Incoming handshake sequence number */
  202. unsigned char *verify_cookie; /*!< Cli: HelloVerifyRequest cookie
  203. Srv: unused */
  204. unsigned char verify_cookie_len; /*!< Cli: cookie length
  205. Srv: flag for sending a cookie */
  206. unsigned char *hs_msg; /*!< Reassembled handshake message */
  207. uint32_t retransmit_timeout; /*!< Current value of timeout */
  208. unsigned char retransmit_state; /*!< Retransmission state */
  209. mbedtls_ssl_flight_item *flight; /*!< Current outgoing flight */
  210. mbedtls_ssl_flight_item *cur_msg; /*!< Current message in flight */
  211. unsigned int in_flight_start_seq; /*!< Minimum message sequence in the
  212. flight being received */
  213. mbedtls_ssl_transform *alt_transform_out; /*!< Alternative transform for
  214. resending messages */
  215. unsigned char alt_out_ctr[8]; /*!< Alternative record epoch/counter
  216. for resending messages */
  217. #endif /* MBEDTLS_SSL_PROTO_DTLS */
  218. /*
  219. * Checksum contexts
  220. */
  221. #if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
  222. defined(MBEDTLS_SSL_PROTO_TLS1_1)
  223. mbedtls_md5_context fin_md5;
  224. mbedtls_sha1_context fin_sha1;
  225. #endif
  226. #if defined(MBEDTLS_SSL_PROTO_TLS1_2)
  227. #if defined(MBEDTLS_SHA256_C)
  228. mbedtls_sha256_context fin_sha256;
  229. #endif
  230. #if defined(MBEDTLS_SHA512_C)
  231. mbedtls_sha512_context fin_sha512;
  232. #endif
  233. #endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
  234. void (*update_checksum)(mbedtls_ssl_context *, const unsigned char *, size_t);
  235. void (*calc_verify)(mbedtls_ssl_context *, unsigned char *);
  236. void (*calc_finished)(mbedtls_ssl_context *, unsigned char *, int);
  237. int (*tls_prf)(const unsigned char *, size_t, const char *,
  238. const unsigned char *, size_t,
  239. unsigned char *, size_t);
  240. size_t pmslen; /*!< premaster length */
  241. unsigned char randbytes[64]; /*!< random bytes */
  242. unsigned char premaster[MBEDTLS_PREMASTER_SIZE];
  243. /*!< premaster secret */
  244. int resume; /*!< session resume indicator*/
  245. int max_major_ver; /*!< max. major version client*/
  246. int max_minor_ver; /*!< max. minor version client*/
  247. int cli_exts; /*!< client extension presence*/
  248. #if defined(MBEDTLS_SSL_SESSION_TICKETS)
  249. int new_session_ticket; /*!< use NewSessionTicket? */
  250. #endif /* MBEDTLS_SSL_SESSION_TICKETS */
  251. #if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
  252. int extended_ms; /*!< use Extended Master Secret? */
  253. #endif
  254. };
  255. /*
  256. * This structure contains a full set of runtime transform parameters
  257. * either in negotiation or active.
  258. */
  259. struct mbedtls_ssl_transform
  260. {
  261. /*
  262. * Session specific crypto layer
  263. */
  264. const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
  265. /*!< Chosen cipersuite_info */
  266. unsigned int keylen; /*!< symmetric key length (bytes) */
  267. size_t minlen; /*!< min. ciphertext length */
  268. size_t ivlen; /*!< IV length */
  269. size_t fixed_ivlen; /*!< Fixed part of IV (AEAD) */
  270. size_t maclen; /*!< MAC length */
  271. unsigned char iv_enc[16]; /*!< IV (encryption) */
  272. unsigned char iv_dec[16]; /*!< IV (decryption) */
  273. #if defined(MBEDTLS_SSL_PROTO_SSL3)
  274. /* Needed only for SSL v3.0 secret */
  275. unsigned char mac_enc[20]; /*!< SSL v3.0 secret (enc) */
  276. unsigned char mac_dec[20]; /*!< SSL v3.0 secret (dec) */
  277. #endif /* MBEDTLS_SSL_PROTO_SSL3 */
  278. mbedtls_md_context_t md_ctx_enc; /*!< MAC (encryption) */
  279. mbedtls_md_context_t md_ctx_dec; /*!< MAC (decryption) */
  280. mbedtls_cipher_context_t cipher_ctx_enc; /*!< encryption context */
  281. mbedtls_cipher_context_t cipher_ctx_dec; /*!< decryption context */
  282. /*
  283. * Session specific compression layer
  284. */
  285. #if defined(MBEDTLS_ZLIB_SUPPORT)
  286. z_stream ctx_deflate; /*!< compression context */
  287. z_stream ctx_inflate; /*!< decompression context */
  288. #endif
  289. };
  290. #if defined(MBEDTLS_X509_CRT_PARSE_C)
  291. /*
  292. * List of certificate + private key pairs
  293. */
  294. struct mbedtls_ssl_key_cert
  295. {
  296. mbedtls_x509_crt *cert; /*!< cert */
  297. mbedtls_pk_context *key; /*!< private key */
  298. mbedtls_ssl_key_cert *next; /*!< next key/cert pair */
  299. };
  300. #endif /* MBEDTLS_X509_CRT_PARSE_C */
  301. #if defined(MBEDTLS_SSL_PROTO_DTLS)
  302. /*
  303. * List of handshake messages kept around for resending
  304. */
  305. struct mbedtls_ssl_flight_item
  306. {
  307. unsigned char *p; /*!< message, including handshake headers */
  308. size_t len; /*!< length of p */
  309. unsigned char type; /*!< type of the message: handshake or CCS */
  310. mbedtls_ssl_flight_item *next; /*!< next handshake message(s) */
  311. };
  312. #endif /* MBEDTLS_SSL_PROTO_DTLS */
  313. #if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
  314. defined(MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED)
  315. /* Find an entry in a signature-hash set matching a given hash algorithm. */
  316. mbedtls_md_type_t mbedtls_ssl_sig_hash_set_find( mbedtls_ssl_sig_hash_set_t *set,
  317. mbedtls_pk_type_t sig_alg );
  318. /* Add a signature-hash-pair to a signature-hash set */
  319. void mbedtls_ssl_sig_hash_set_add( mbedtls_ssl_sig_hash_set_t *set,
  320. mbedtls_pk_type_t sig_alg,
  321. mbedtls_md_type_t md_alg );
  322. /* Allow exactly one hash algorithm for each signature. */
  323. void mbedtls_ssl_sig_hash_set_const_hash( mbedtls_ssl_sig_hash_set_t *set,
  324. mbedtls_md_type_t md_alg );
  325. /* Setup an empty signature-hash set */
  326. static inline void mbedtls_ssl_sig_hash_set_init( mbedtls_ssl_sig_hash_set_t *set )
  327. {
  328. mbedtls_ssl_sig_hash_set_const_hash( set, MBEDTLS_MD_NONE );
  329. }
  330. #endif /* MBEDTLS_SSL_PROTO_TLS1_2) &&
  331. MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED */
  332. /**
  333. * \brief Free referenced items in an SSL transform context and clear
  334. * memory
  335. *
  336. * \param transform SSL transform context
  337. */
  338. void mbedtls_ssl_transform_free( mbedtls_ssl_transform *transform );
  339. /**
  340. * \brief Free referenced items in an SSL handshake context and clear
  341. * memory
  342. *
  343. * \param handshake SSL handshake context
  344. */
  345. void mbedtls_ssl_handshake_free( mbedtls_ssl_handshake_params *handshake );
  346. int mbedtls_ssl_handshake_client_step( mbedtls_ssl_context *ssl );
  347. int mbedtls_ssl_handshake_server_step( mbedtls_ssl_context *ssl );
  348. void mbedtls_ssl_handshake_wrapup( mbedtls_ssl_context *ssl );
  349. int mbedtls_ssl_send_fatal_handshake_failure( mbedtls_ssl_context *ssl );
  350. void mbedtls_ssl_reset_checksum( mbedtls_ssl_context *ssl );
  351. int mbedtls_ssl_derive_keys( mbedtls_ssl_context *ssl );
  352. int mbedtls_ssl_read_record_layer( mbedtls_ssl_context *ssl );
  353. int mbedtls_ssl_handle_message_type( mbedtls_ssl_context *ssl );
  354. int mbedtls_ssl_prepare_handshake_record( mbedtls_ssl_context *ssl );
  355. void mbedtls_ssl_update_handshake_status( mbedtls_ssl_context *ssl );
  356. /**
  357. * \brief Update record layer
  358. *
  359. * This function roughly separates the implementation
  360. * of the logic of (D)TLS from the implementation
  361. * of the secure transport.
  362. *
  363. * \param ssl SSL context to use
  364. *
  365. * \return 0 or non-zero error code.
  366. *
  367. * \note A clarification on what is called 'record layer' here
  368. * is in order, as many sensible definitions are possible:
  369. *
  370. * The record layer takes as input an untrusted underlying
  371. * transport (stream or datagram) and transforms it into
  372. * a serially multiplexed, secure transport, which
  373. * conceptually provides the following:
  374. *
  375. * (1) Three datagram based, content-agnostic transports
  376. * for handshake, alert and CCS messages.
  377. * (2) One stream- or datagram-based transport
  378. * for application data.
  379. * (3) Functionality for changing the underlying transform
  380. * securing the contents.
  381. *
  382. * The interface to this functionality is given as follows:
  383. *
  384. * a Updating
  385. * [Currently implemented by mbedtls_ssl_read_record]
  386. *
  387. * Check if and on which of the four 'ports' data is pending:
  388. * Nothing, a controlling datagram of type (1), or application
  389. * data (2). In any case data is present, internal buffers
  390. * provide access to the data for the user to process it.
  391. * Consumption of type (1) datagrams is done automatically
  392. * on the next update, invalidating that the internal buffers
  393. * for previous datagrams, while consumption of application
  394. * data (2) is user-controlled.
  395. *
  396. * b Reading of application data
  397. * [Currently manual adaption of ssl->in_offt pointer]
  398. *
  399. * As mentioned in the last paragraph, consumption of data
  400. * is different from the automatic consumption of control
  401. * datagrams (1) because application data is treated as a stream.
  402. *
  403. * c Tracking availability of application data
  404. * [Currently manually through decreasing ssl->in_msglen]
  405. *
  406. * For efficiency and to retain datagram semantics for
  407. * application data in case of DTLS, the record layer
  408. * provides functionality for checking how much application
  409. * data is still available in the internal buffer.
  410. *
  411. * d Changing the transformation securing the communication.
  412. *
  413. * Given an opaque implementation of the record layer in the
  414. * above sense, it should be possible to implement the logic
  415. * of (D)TLS on top of it without the need to know anything
  416. * about the record layer's internals. This is done e.g.
  417. * in all the handshake handling functions, and in the
  418. * application data reading function mbedtls_ssl_read.
  419. *
  420. * \note The above tries to give a conceptual picture of the
  421. * record layer, but the current implementation deviates
  422. * from it in some places. For example, our implementation of
  423. * the update functionality through mbedtls_ssl_read_record
  424. * discards datagrams depending on the current state, which
  425. * wouldn't fall under the record layer's responsibility
  426. * following the above definition.
  427. *
  428. */
  429. int mbedtls_ssl_read_record( mbedtls_ssl_context *ssl );
  430. int mbedtls_ssl_fetch_input( mbedtls_ssl_context *ssl, size_t nb_want );
  431. int mbedtls_ssl_write_record( mbedtls_ssl_context *ssl );
  432. int mbedtls_ssl_flush_output( mbedtls_ssl_context *ssl );
  433. int mbedtls_ssl_parse_certificate( mbedtls_ssl_context *ssl );
  434. int mbedtls_ssl_write_certificate( mbedtls_ssl_context *ssl );
  435. int mbedtls_ssl_parse_change_cipher_spec( mbedtls_ssl_context *ssl );
  436. int mbedtls_ssl_write_change_cipher_spec( mbedtls_ssl_context *ssl );
  437. int mbedtls_ssl_parse_finished( mbedtls_ssl_context *ssl );
  438. int mbedtls_ssl_write_finished( mbedtls_ssl_context *ssl );
  439. void mbedtls_ssl_optimize_checksum( mbedtls_ssl_context *ssl,
  440. const mbedtls_ssl_ciphersuite_t *ciphersuite_info );
  441. #if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
  442. int mbedtls_ssl_psk_derive_premaster( mbedtls_ssl_context *ssl, mbedtls_key_exchange_type_t key_ex );
  443. #endif
  444. #if defined(MBEDTLS_PK_C)
  445. unsigned char mbedtls_ssl_sig_from_pk( mbedtls_pk_context *pk );
  446. unsigned char mbedtls_ssl_sig_from_pk_alg( mbedtls_pk_type_t type );
  447. mbedtls_pk_type_t mbedtls_ssl_pk_alg_from_sig( unsigned char sig );
  448. #endif
  449. mbedtls_md_type_t mbedtls_ssl_md_alg_from_hash( unsigned char hash );
  450. unsigned char mbedtls_ssl_hash_from_md_alg( int md );
  451. int mbedtls_ssl_set_calc_verify_md( mbedtls_ssl_context *ssl, int md );
  452. #if defined(MBEDTLS_ECP_C)
  453. int mbedtls_ssl_check_curve( const mbedtls_ssl_context *ssl, mbedtls_ecp_group_id grp_id );
  454. #endif
  455. #if defined(MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED)
  456. int mbedtls_ssl_check_sig_hash( const mbedtls_ssl_context *ssl,
  457. mbedtls_md_type_t md );
  458. #endif
  459. #if defined(MBEDTLS_X509_CRT_PARSE_C)
  460. static inline mbedtls_pk_context *mbedtls_ssl_own_key( mbedtls_ssl_context *ssl )
  461. {
  462. mbedtls_ssl_key_cert *key_cert;
  463. if( ssl->handshake != NULL && ssl->handshake->key_cert != NULL )
  464. key_cert = ssl->handshake->key_cert;
  465. else
  466. key_cert = ssl->conf->key_cert;
  467. return( key_cert == NULL ? NULL : key_cert->key );
  468. }
  469. static inline mbedtls_x509_crt *mbedtls_ssl_own_cert( mbedtls_ssl_context *ssl )
  470. {
  471. mbedtls_ssl_key_cert *key_cert;
  472. if( ssl->handshake != NULL && ssl->handshake->key_cert != NULL )
  473. key_cert = ssl->handshake->key_cert;
  474. else
  475. key_cert = ssl->conf->key_cert;
  476. return( key_cert == NULL ? NULL : key_cert->cert );
  477. }
  478. /*
  479. * Check usage of a certificate wrt extensions:
  480. * keyUsage, extendedKeyUsage (later), and nSCertType (later).
  481. *
  482. * Warning: cert_endpoint is the endpoint of the cert (ie, of our peer when we
  483. * check a cert we received from them)!
  484. *
  485. * Return 0 if everything is OK, -1 if not.
  486. */
  487. int mbedtls_ssl_check_cert_usage( const mbedtls_x509_crt *cert,
  488. const mbedtls_ssl_ciphersuite_t *ciphersuite,
  489. int cert_endpoint,
  490. uint32_t *flags );
  491. #endif /* MBEDTLS_X509_CRT_PARSE_C */
  492. void mbedtls_ssl_write_version( int major, int minor, int transport,
  493. unsigned char ver[2] );
  494. void mbedtls_ssl_read_version( int *major, int *minor, int transport,
  495. const unsigned char ver[2] );
  496. static inline size_t mbedtls_ssl_hdr_len( const mbedtls_ssl_context *ssl )
  497. {
  498. #if defined(MBEDTLS_SSL_PROTO_DTLS)
  499. if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
  500. return( 13 );
  501. #else
  502. ((void) ssl);
  503. #endif
  504. return( 5 );
  505. }
  506. static inline size_t mbedtls_ssl_hs_hdr_len( const mbedtls_ssl_context *ssl )
  507. {
  508. #if defined(MBEDTLS_SSL_PROTO_DTLS)
  509. if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
  510. return( 12 );
  511. #else
  512. ((void) ssl);
  513. #endif
  514. return( 4 );
  515. }
  516. #if defined(MBEDTLS_SSL_PROTO_DTLS)
  517. void mbedtls_ssl_send_flight_completed( mbedtls_ssl_context *ssl );
  518. void mbedtls_ssl_recv_flight_completed( mbedtls_ssl_context *ssl );
  519. int mbedtls_ssl_resend( mbedtls_ssl_context *ssl );
  520. #endif
  521. /* Visible for testing purposes only */
  522. #if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
  523. int mbedtls_ssl_dtls_replay_check( mbedtls_ssl_context *ssl );
  524. void mbedtls_ssl_dtls_replay_update( mbedtls_ssl_context *ssl );
  525. #endif
  526. /* constant-time buffer comparison */
  527. static inline int mbedtls_ssl_safer_memcmp( const void *a, const void *b, size_t n )
  528. {
  529. size_t i;
  530. const unsigned char *A = (const unsigned char *) a;
  531. const unsigned char *B = (const unsigned char *) b;
  532. unsigned char diff = 0;
  533. for( i = 0; i < n; i++ )
  534. diff |= A[i] ^ B[i];
  535. return( diff );
  536. }
  537. #ifdef __cplusplus
  538. }
  539. #endif
  540. #endif /* ssl_internal.h */