ssl_internal.h 25 KB

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