blob: ff05273f7fbcf8dc2e3063a55709373483c91fca [file] [log] [blame]
Paul Bakker5121ce52009-01-03 21:22:43 +00001/*
2 * SSLv3/TLSv1 client-side functions
3 *
Bence Szépkúti1e148272020-08-07 13:07:28 +02004 * Copyright The Mbed TLS Contributors
Manuel Pégourié-Gonnard37ff1402015-09-04 14:21:07 +02005 * SPDX-License-Identifier: Apache-2.0
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License"); you may
8 * not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
Paul Bakker5121ce52009-01-03 21:22:43 +000018 */
19
Gilles Peskinedb09ef62020-06-03 01:43:33 +020020#include "common.h"
Paul Bakker5121ce52009-01-03 21:22:43 +000021
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020022#if defined(MBEDTLS_SSL_CLI_C)
Paul Bakker5121ce52009-01-03 21:22:43 +000023
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020024#if defined(MBEDTLS_PLATFORM_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000025#include "mbedtls/platform.h"
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +020026#else
Rich Evans00ab4702015-02-06 13:43:58 +000027#include <stdlib.h>
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +020028#define mbedtls_calloc calloc
SimonBd5800b72016-04-26 07:43:27 +010029#define mbedtls_free free
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +020030#endif
31
SimonBd5800b72016-04-26 07:43:27 +010032#include "mbedtls/ssl.h"
33#include "mbedtls/ssl_internal.h"
Janos Follath73c616b2019-12-18 15:07:04 +000034#include "mbedtls/debug.h"
35#include "mbedtls/error.h"
Gabor Mezeie24dea82021-10-19 12:22:25 +020036#include "mbedtls/constant_time.h"
SimonBd5800b72016-04-26 07:43:27 +010037
Hanno Beckerbb89e272019-01-08 12:54:37 +000038#if defined(MBEDTLS_USE_PSA_CRYPTO)
39#include "mbedtls/psa_util.h"
Ronald Cron3a95d2b2021-10-18 09:47:58 +020040#include "psa/crypto.h"
Hanno Beckerbb89e272019-01-08 12:54:37 +000041#endif /* MBEDTLS_USE_PSA_CRYPTO */
42
SimonBd5800b72016-04-26 07:43:27 +010043#include <string.h>
44
Manuel Pégourié-Gonnard93866642015-06-22 19:21:23 +020045#include <stdint.h>
Paul Bakkerfa9b1002013-07-03 15:31:03 +020046
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020047#if defined(MBEDTLS_HAVE_TIME)
Simon Butcherb5b6af22016-07-13 14:46:18 +010048#include "mbedtls/platform_time.h"
Paul Bakkerfa9b1002013-07-03 15:31:03 +020049#endif
Paul Bakker5121ce52009-01-03 21:22:43 +000050
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020051#if defined(MBEDTLS_SSL_SESSION_TICKETS)
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -050052#include "mbedtls/platform_util.h"
Paul Bakker34617722014-06-13 17:20:13 +020053#endif
54
Gilles Peskineeccd8882020-03-10 12:19:08 +010055#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
Hanno Becker520224e2018-10-26 11:38:07 +010056static int ssl_conf_has_static_psk( mbedtls_ssl_config const *conf )
Hanno Becker2e4f6162018-10-23 11:54:44 +010057{
58 if( conf->psk_identity == NULL ||
59 conf->psk_identity_len == 0 )
60 {
61 return( 0 );
62 }
63
64 if( conf->psk != NULL && conf->psk_len != 0 )
65 return( 1 );
66
67#if defined(MBEDTLS_USE_PSA_CRYPTO)
Ronald Croncf56a0a2020-08-04 09:51:30 +020068 if( ! mbedtls_svc_key_id_is_null( conf->psk_opaque ) )
Hanno Becker2e4f6162018-10-23 11:54:44 +010069 return( 1 );
70#endif /* MBEDTLS_USE_PSA_CRYPTO */
71
72 return( 0 );
73}
Hanno Beckerdfab8e22018-10-23 11:59:34 +010074
75#if defined(MBEDTLS_USE_PSA_CRYPTO)
Hanno Becker520224e2018-10-26 11:38:07 +010076static int ssl_conf_has_static_raw_psk( mbedtls_ssl_config const *conf )
Hanno Beckerdfab8e22018-10-23 11:59:34 +010077{
78 if( conf->psk_identity == NULL ||
79 conf->psk_identity_len == 0 )
80 {
81 return( 0 );
82 }
83
84 if( conf->psk != NULL && conf->psk_len != 0 )
85 return( 1 );
86
87 return( 0 );
88}
89#endif /* MBEDTLS_USE_PSA_CRYPTO */
90
Gilles Peskineeccd8882020-03-10 12:19:08 +010091#endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
Hanno Becker2e4f6162018-10-23 11:54:44 +010092
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020093#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
Hanno Becker261602c2017-04-12 14:54:42 +010094static int ssl_write_hostname_ext( mbedtls_ssl_context *ssl,
95 unsigned char *buf,
96 const unsigned char *end,
97 size_t *olen )
Paul Bakkerd3edc862013-03-20 16:07:17 +010098{
99 unsigned char *p = buf;
Manuel Pégourié-Gonnardba26c242015-05-06 10:47:06 +0100100 size_t hostname_len;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100101
102 *olen = 0;
103
Paul Bakker66d5d072014-06-17 16:39:18 +0200104 if( ssl->hostname == NULL )
Hanno Becker261602c2017-04-12 14:54:42 +0100105 return( 0 );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100106
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100107 MBEDTLS_SSL_DEBUG_MSG( 3,
108 ( "client hello, adding server name extension: %s",
109 ssl->hostname ) );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100110
Manuel Pégourié-Gonnardba26c242015-05-06 10:47:06 +0100111 hostname_len = strlen( ssl->hostname );
112
Hanno Becker261602c2017-04-12 14:54:42 +0100113 MBEDTLS_SSL_CHK_BUF_PTR( p, end, hostname_len + 9 );
Simon Butchered997662015-09-28 02:14:30 +0100114
Paul Bakkerd3edc862013-03-20 16:07:17 +0100115 /*
Hanno Becker1a9a51c2017-04-07 13:02:16 +0100116 * Sect. 3, RFC 6066 (TLS Extensions Definitions)
117 *
118 * In order to provide any of the server names, clients MAY include an
119 * extension of type "server_name" in the (extended) client hello. The
120 * "extension_data" field of this extension SHALL contain
121 * "ServerNameList" where:
122 *
Paul Bakkerd3edc862013-03-20 16:07:17 +0100123 * struct {
124 * NameType name_type;
125 * select (name_type) {
126 * case host_name: HostName;
127 * } name;
128 * } ServerName;
129 *
130 * enum {
131 * host_name(0), (255)
132 * } NameType;
133 *
134 * opaque HostName<1..2^16-1>;
135 *
136 * struct {
137 * ServerName server_name_list<1..2^16-1>
138 * } ServerNameList;
Hanno Becker1a9a51c2017-04-07 13:02:16 +0100139 *
Paul Bakkerd3edc862013-03-20 16:07:17 +0100140 */
Joe Subbiani2f98d792021-08-20 11:44:44 +0100141 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_SERVERNAME, p, 0 );
142 p += 2;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100143
Joe Subbiani2f98d792021-08-20 11:44:44 +0100144 MBEDTLS_PUT_UINT16_BE( hostname_len + 5, p, 0 );
145 p += 2;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100146
Joe Subbiani2f98d792021-08-20 11:44:44 +0100147 MBEDTLS_PUT_UINT16_BE( hostname_len + 3, p, 0 );
148 p += 2;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100149
Joe Subbianic045dc12021-07-14 12:31:31 +0100150 *p++ = MBEDTLS_BYTE_0( MBEDTLS_TLS_EXT_SERVERNAME_HOSTNAME );
Joe Subbiani2f98d792021-08-20 11:44:44 +0100151
152 MBEDTLS_PUT_UINT16_BE( hostname_len, p, 0 );
153 p += 2;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100154
Manuel Pégourié-Gonnardba26c242015-05-06 10:47:06 +0100155 memcpy( p, ssl->hostname, hostname_len );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100156
Manuel Pégourié-Gonnardba26c242015-05-06 10:47:06 +0100157 *olen = hostname_len + 9;
Hanno Becker261602c2017-04-12 14:54:42 +0100158
159 return( 0 );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100160}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200161#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
Paul Bakkerd3edc862013-03-20 16:07:17 +0100162
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200163#if defined(MBEDTLS_SSL_RENEGOTIATION)
Hanno Becker261602c2017-04-12 14:54:42 +0100164static int ssl_write_renegotiation_ext( mbedtls_ssl_context *ssl,
165 unsigned char *buf,
166 const unsigned char *end,
167 size_t *olen )
Paul Bakkerd3edc862013-03-20 16:07:17 +0100168{
169 unsigned char *p = buf;
170
171 *olen = 0;
172
Hanno Becker40f8b512017-10-12 14:58:55 +0100173 /* We're always including an TLS_EMPTY_RENEGOTIATION_INFO_SCSV in the
174 * initial ClientHello, in which case also adding the renegotiation
175 * info extension is NOT RECOMMENDED as per RFC 5746 Section 3.4. */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200176 if( ssl->renego_status != MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
Hanno Becker261602c2017-04-12 14:54:42 +0100177 return( 0 );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100178
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100179 MBEDTLS_SSL_DEBUG_MSG( 3,
180 ( "client hello, adding renegotiation extension" ) );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100181
Hanno Becker261602c2017-04-12 14:54:42 +0100182 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 5 + ssl->verify_data_len );
Simon Butchered997662015-09-28 02:14:30 +0100183
Paul Bakkerd3edc862013-03-20 16:07:17 +0100184 /*
185 * Secure renegotiation
186 */
Joe Subbiani2f98d792021-08-20 11:44:44 +0100187 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_RENEGOTIATION_INFO, p, 0 );
188 p += 2;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100189
190 *p++ = 0x00;
Joe Subbianic045dc12021-07-14 12:31:31 +0100191 *p++ = MBEDTLS_BYTE_0( ssl->verify_data_len + 1 );
192 *p++ = MBEDTLS_BYTE_0( ssl->verify_data_len );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100193
194 memcpy( p, ssl->own_verify_data, ssl->verify_data_len );
195
196 *olen = 5 + ssl->verify_data_len;
Hanno Becker261602c2017-04-12 14:54:42 +0100197
198 return( 0 );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100199}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200200#endif /* MBEDTLS_SSL_RENEGOTIATION */
Paul Bakkerd3edc862013-03-20 16:07:17 +0100201
Manuel Pégourié-Gonnardd9423232014-12-02 11:57:29 +0100202/*
203 * Only if we handle at least one key exchange that needs signatures.
204 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200205#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
Gilles Peskineeccd8882020-03-10 12:19:08 +0100206 defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
Hanno Becker261602c2017-04-12 14:54:42 +0100207static int ssl_write_signature_algorithms_ext( mbedtls_ssl_context *ssl,
208 unsigned char *buf,
209 const unsigned char *end,
210 size_t *olen )
Paul Bakkerd3edc862013-03-20 16:07:17 +0100211{
212 unsigned char *p = buf;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100213 size_t sig_alg_len = 0;
Manuel Pégourié-Gonnard7bfc1222015-06-17 14:34:48 +0200214 const int *md;
Hanno Becker261602c2017-04-12 14:54:42 +0100215
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200216#if defined(MBEDTLS_RSA_C) || defined(MBEDTLS_ECDSA_C)
Manuel Pégourié-Gonnard5bfd9682014-06-24 15:18:11 +0200217 unsigned char *sig_alg_list = buf + 6;
218#endif
Paul Bakkerd3edc862013-03-20 16:07:17 +0100219
220 *olen = 0;
221
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +0200222 if( ssl->conf->max_minor_ver != MBEDTLS_SSL_MINOR_VERSION_3 )
Hanno Becker261602c2017-04-12 14:54:42 +0100223 return( 0 );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100224
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100225 MBEDTLS_SSL_DEBUG_MSG( 3,
226 ( "client hello, adding signature_algorithms extension" ) );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100227
Hanno Beckere131bfe2017-04-12 14:54:42 +0100228 if( ssl->conf->sig_hashes == NULL )
229 return( MBEDTLS_ERR_SSL_BAD_CONFIG );
230
Simon Butchered997662015-09-28 02:14:30 +0100231 for( md = ssl->conf->sig_hashes; *md != MBEDTLS_MD_NONE; md++ )
232 {
233#if defined(MBEDTLS_ECDSA_C)
234 sig_alg_len += 2;
235#endif
236#if defined(MBEDTLS_RSA_C)
237 sig_alg_len += 2;
238#endif
Hanno Beckere131bfe2017-04-12 14:54:42 +0100239 if( sig_alg_len > MBEDTLS_SSL_MAX_SIG_HASH_ALG_LIST_LEN )
240 {
241 MBEDTLS_SSL_DEBUG_MSG( 3,
242 ( "length in bytes of sig-hash-alg extension too big" ) );
243 return( MBEDTLS_ERR_SSL_BAD_CONFIG );
244 }
Simon Butchered997662015-09-28 02:14:30 +0100245 }
246
Hanno Beckere131bfe2017-04-12 14:54:42 +0100247 /* Empty signature algorithms list, this is a configuration error. */
248 if( sig_alg_len == 0 )
249 return( MBEDTLS_ERR_SSL_BAD_CONFIG );
250
Hanno Becker261602c2017-04-12 14:54:42 +0100251 MBEDTLS_SSL_CHK_BUF_PTR( p, end, sig_alg_len + 6 );
Simon Butchered997662015-09-28 02:14:30 +0100252
Paul Bakkerd3edc862013-03-20 16:07:17 +0100253 /*
254 * Prepare signature_algorithms extension (TLS 1.2)
255 */
Simon Butchered997662015-09-28 02:14:30 +0100256 sig_alg_len = 0;
257
Manuel Pégourié-Gonnard7bfc1222015-06-17 14:34:48 +0200258 for( md = ssl->conf->sig_hashes; *md != MBEDTLS_MD_NONE; md++ )
259 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200260#if defined(MBEDTLS_ECDSA_C)
Manuel Pégourié-Gonnard7bfc1222015-06-17 14:34:48 +0200261 sig_alg_list[sig_alg_len++] = mbedtls_ssl_hash_from_md_alg( *md );
262 sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_ECDSA;
Manuel Pégourié-Gonnardd11eb7c2013-08-22 15:57:15 +0200263#endif
Manuel Pégourié-Gonnard7bfc1222015-06-17 14:34:48 +0200264#if defined(MBEDTLS_RSA_C)
265 sig_alg_list[sig_alg_len++] = mbedtls_ssl_hash_from_md_alg( *md );
266 sig_alg_list[sig_alg_len++] = MBEDTLS_SSL_SIG_RSA;
Manuel Pégourié-Gonnardd11eb7c2013-08-22 15:57:15 +0200267#endif
Manuel Pégourié-Gonnard7bfc1222015-06-17 14:34:48 +0200268 }
Paul Bakkerd3edc862013-03-20 16:07:17 +0100269
270 /*
271 * enum {
Manuel Pégourié-Gonnard7bfc1222015-06-17 14:34:48 +0200272 * none(0), md5(1), sha1(2), sha224(3), sha256(4), sha384(5),
273 * sha512(6), (255)
Paul Bakkerd3edc862013-03-20 16:07:17 +0100274 * } HashAlgorithm;
275 *
276 * enum { anonymous(0), rsa(1), dsa(2), ecdsa(3), (255) }
277 * SignatureAlgorithm;
278 *
279 * struct {
280 * HashAlgorithm hash;
281 * SignatureAlgorithm signature;
282 * } SignatureAndHashAlgorithm;
283 *
284 * SignatureAndHashAlgorithm
285 * supported_signature_algorithms<2..2^16-2>;
286 */
Joe Subbiani2f98d792021-08-20 11:44:44 +0100287 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_SIG_ALG, p, 0 );
288 p += 2;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100289
Joe Subbiani2f98d792021-08-20 11:44:44 +0100290 MBEDTLS_PUT_UINT16_BE( sig_alg_len + 2, p, 0 );
291 p += 2;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100292
Joe Subbiani2f98d792021-08-20 11:44:44 +0100293 MBEDTLS_PUT_UINT16_BE( sig_alg_len, p, 0 );
294 p += 2;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100295
Paul Bakkerd3edc862013-03-20 16:07:17 +0100296 *olen = 6 + sig_alg_len;
Hanno Becker261602c2017-04-12 14:54:42 +0100297
298 return( 0 );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100299}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200300#endif /* MBEDTLS_SSL_PROTO_TLS1_2 &&
Gilles Peskineeccd8882020-03-10 12:19:08 +0100301 MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */
Paul Bakkerd3edc862013-03-20 16:07:17 +0100302
Manuel Pégourié-Gonnardf4721792015-09-15 10:53:51 +0200303#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
Robert Cragieae8535d2015-10-06 17:11:18 +0100304 defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
Hanno Becker261602c2017-04-12 14:54:42 +0100305static int ssl_write_supported_elliptic_curves_ext( mbedtls_ssl_context *ssl,
306 unsigned char *buf,
307 const unsigned char *end,
308 size_t *olen )
Paul Bakkerd3edc862013-03-20 16:07:17 +0100309{
310 unsigned char *p = buf;
Manuel Pégourié-Gonnard8e205fc2014-01-23 17:27:10 +0100311 unsigned char *elliptic_curve_list = p + 6;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100312 size_t elliptic_curve_len = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200313 const mbedtls_ecp_curve_info *info;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200314 const mbedtls_ecp_group_id *grp_id;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100315
316 *olen = 0;
317
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100318 MBEDTLS_SSL_DEBUG_MSG( 3,
319 ( "client hello, adding supported_elliptic_curves extension" ) );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100320
Hanno Beckere131bfe2017-04-12 14:54:42 +0100321 if( ssl->conf->curve_list == NULL )
322 return( MBEDTLS_ERR_SSL_BAD_CONFIG );
323
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100324 for( grp_id = ssl->conf->curve_list;
325 *grp_id != MBEDTLS_ECP_DP_NONE;
326 grp_id++ )
Manuel Pégourié-Gonnardcd49f762014-02-04 15:14:13 +0100327 {
Gilles Peskinef9828522017-05-03 12:28:43 +0200328 info = mbedtls_ecp_curve_info_from_grp_id( *grp_id );
Janos Follath8a317052016-04-21 23:37:09 +0100329 if( info == NULL )
330 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100331 MBEDTLS_SSL_DEBUG_MSG( 1,
332 ( "invalid curve in ssl configuration" ) );
Hanno Beckere131bfe2017-04-12 14:54:42 +0100333 return( MBEDTLS_ERR_SSL_BAD_CONFIG );
Janos Follath8a317052016-04-21 23:37:09 +0100334 }
Simon Butchered997662015-09-28 02:14:30 +0100335 elliptic_curve_len += 2;
Hanno Beckere131bfe2017-04-12 14:54:42 +0100336
337 if( elliptic_curve_len > MBEDTLS_SSL_MAX_CURVE_LIST_LEN )
338 {
339 MBEDTLS_SSL_DEBUG_MSG( 3,
340 ( "malformed supported_elliptic_curves extension in config" ) );
341 return( MBEDTLS_ERR_SSL_BAD_CONFIG );
342 }
Simon Butchered997662015-09-28 02:14:30 +0100343 }
344
Hanno Beckere131bfe2017-04-12 14:54:42 +0100345 /* Empty elliptic curve list, this is a configuration error. */
Hanno Becker261602c2017-04-12 14:54:42 +0100346 if( elliptic_curve_len == 0 )
Hanno Beckere131bfe2017-04-12 14:54:42 +0100347 return( MBEDTLS_ERR_SSL_BAD_CONFIG );
Hanno Becker261602c2017-04-12 14:54:42 +0100348
349 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 6 + elliptic_curve_len );
Simon Butchered997662015-09-28 02:14:30 +0100350
351 elliptic_curve_len = 0;
352
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100353 for( grp_id = ssl->conf->curve_list;
354 *grp_id != MBEDTLS_ECP_DP_NONE;
355 grp_id++ )
Simon Butchered997662015-09-28 02:14:30 +0100356 {
Gilles Peskinef9828522017-05-03 12:28:43 +0200357 info = mbedtls_ecp_curve_info_from_grp_id( *grp_id );
Joe Subbianiad1115a2021-07-16 14:27:50 +0100358 elliptic_curve_list[elliptic_curve_len++] = MBEDTLS_BYTE_1( info->tls_id );
359 elliptic_curve_list[elliptic_curve_len++] = MBEDTLS_BYTE_0( info->tls_id );
Manuel Pégourié-Gonnard568c9cf2013-09-16 17:30:04 +0200360 }
Paul Bakker5dc6b5f2013-06-29 23:26:34 +0200361
Joe Subbiani2f98d792021-08-20 11:44:44 +0100362 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_SUPPORTED_ELLIPTIC_CURVES, p, 0 );
363 p += 2;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100364
Joe Subbiani2f98d792021-08-20 11:44:44 +0100365 MBEDTLS_PUT_UINT16_BE( elliptic_curve_len + 2, p, 0 );
366 p += 2;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100367
Joe Subbiani2f98d792021-08-20 11:44:44 +0100368 MBEDTLS_PUT_UINT16_BE( elliptic_curve_len, p, 0 );
369 p += 2;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100370
Paul Bakkerd3edc862013-03-20 16:07:17 +0100371 *olen = 6 + elliptic_curve_len;
Hanno Becker261602c2017-04-12 14:54:42 +0100372
373 return( 0 );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100374}
375
Hanno Becker261602c2017-04-12 14:54:42 +0100376static int ssl_write_supported_point_formats_ext( mbedtls_ssl_context *ssl,
377 unsigned char *buf,
378 const unsigned char *end,
379 size_t *olen )
Paul Bakkerd3edc862013-03-20 16:07:17 +0100380{
381 unsigned char *p = buf;
Hanno Becker261602c2017-04-12 14:54:42 +0100382 (void) ssl; /* ssl used for debugging only */
Paul Bakkerd3edc862013-03-20 16:07:17 +0100383
384 *olen = 0;
385
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100386 MBEDTLS_SSL_DEBUG_MSG( 3,
387 ( "client hello, adding supported_point_formats extension" ) );
Hanno Becker261602c2017-04-12 14:54:42 +0100388 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 6 );
Simon Butchered997662015-09-28 02:14:30 +0100389
Joe Subbiani2f98d792021-08-20 11:44:44 +0100390 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS, p, 0 );
391 p += 2;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100392
393 *p++ = 0x00;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100394 *p++ = 2;
Manuel Pégourié-Gonnard6b8846d2013-08-15 17:42:02 +0200395
396 *p++ = 1;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200397 *p++ = MBEDTLS_ECP_PF_UNCOMPRESSED;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100398
Manuel Pégourié-Gonnard6b8846d2013-08-15 17:42:02 +0200399 *olen = 6;
Hanno Becker261602c2017-04-12 14:54:42 +0100400
401 return( 0 );
Paul Bakkerd3edc862013-03-20 16:07:17 +0100402}
Darryl Green11999bb2018-03-13 15:22:58 +0000403#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C ||
Robert Cragieae8535d2015-10-06 17:11:18 +0100404 MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
Paul Bakkerd3edc862013-03-20 16:07:17 +0100405
Manuel Pégourié-Gonnardeef142d2015-09-16 10:05:04 +0200406#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
Hanno Becker261602c2017-04-12 14:54:42 +0100407static int ssl_write_ecjpake_kkpp_ext( mbedtls_ssl_context *ssl,
408 unsigned char *buf,
409 const unsigned char *end,
410 size_t *olen )
Manuel Pégourié-Gonnard294139b2015-09-15 16:55:05 +0200411{
Janos Follath865b3eb2019-12-16 11:46:15 +0000412 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Manuel Pégourié-Gonnard294139b2015-09-15 16:55:05 +0200413 unsigned char *p = buf;
Manuel Pégourié-Gonnard294139b2015-09-15 16:55:05 +0200414 size_t kkpp_len;
415
416 *olen = 0;
417
418 /* Skip costly extension if we can't use EC J-PAKE anyway */
419 if( mbedtls_ecjpake_check( &ssl->handshake->ecjpake_ctx ) != 0 )
Hanno Becker261602c2017-04-12 14:54:42 +0100420 return( 0 );
Manuel Pégourié-Gonnard294139b2015-09-15 16:55:05 +0200421
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100422 MBEDTLS_SSL_DEBUG_MSG( 3,
423 ( "client hello, adding ecjpake_kkpp extension" ) );
Manuel Pégourié-Gonnard294139b2015-09-15 16:55:05 +0200424
Hanno Becker261602c2017-04-12 14:54:42 +0100425 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 4 );
Manuel Pégourié-Gonnard294139b2015-09-15 16:55:05 +0200426
Joe Subbiani2f98d792021-08-20 11:44:44 +0100427 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_ECJPAKE_KKPP, p, 0 );
428 p += 2;
Manuel Pégourié-Gonnard294139b2015-09-15 16:55:05 +0200429
Manuel Pégourié-Gonnardd0d8cb32015-09-17 14:16:30 +0200430 /*
431 * We may need to send ClientHello multiple times for Hello verification.
432 * We don't want to compute fresh values every time (both for performance
433 * and consistency reasons), so cache the extension content.
434 */
435 if( ssl->handshake->ecjpake_cache == NULL ||
436 ssl->handshake->ecjpake_cache_len == 0 )
Manuel Pégourié-Gonnard294139b2015-09-15 16:55:05 +0200437 {
Manuel Pégourié-Gonnardd0d8cb32015-09-17 14:16:30 +0200438 MBEDTLS_SSL_DEBUG_MSG( 3, ( "generating new ecjpake parameters" ) );
439
Manuel Pégourié-Gonnard5674a972015-10-19 15:14:03 +0200440 ret = mbedtls_ecjpake_write_round_one( &ssl->handshake->ecjpake_ctx,
Hanno Becker261602c2017-04-12 14:54:42 +0100441 p + 2, end - p - 2, &kkpp_len,
442 ssl->conf->f_rng, ssl->conf->p_rng );
Manuel Pégourié-Gonnard5674a972015-10-19 15:14:03 +0200443 if( ret != 0 )
Manuel Pégourié-Gonnardd0d8cb32015-09-17 14:16:30 +0200444 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100445 MBEDTLS_SSL_DEBUG_RET( 1 ,
446 "mbedtls_ecjpake_write_round_one", ret );
Hanno Becker261602c2017-04-12 14:54:42 +0100447 return( ret );
Manuel Pégourié-Gonnardd0d8cb32015-09-17 14:16:30 +0200448 }
449
450 ssl->handshake->ecjpake_cache = mbedtls_calloc( 1, kkpp_len );
451 if( ssl->handshake->ecjpake_cache == NULL )
452 {
453 MBEDTLS_SSL_DEBUG_MSG( 1, ( "allocation failed" ) );
Hanno Becker261602c2017-04-12 14:54:42 +0100454 return( MBEDTLS_ERR_SSL_ALLOC_FAILED );
Manuel Pégourié-Gonnardd0d8cb32015-09-17 14:16:30 +0200455 }
456
457 memcpy( ssl->handshake->ecjpake_cache, p + 2, kkpp_len );
458 ssl->handshake->ecjpake_cache_len = kkpp_len;
459 }
460 else
461 {
462 MBEDTLS_SSL_DEBUG_MSG( 3, ( "re-using cached ecjpake parameters" ) );
463
464 kkpp_len = ssl->handshake->ecjpake_cache_len;
Hanno Becker261602c2017-04-12 14:54:42 +0100465 MBEDTLS_SSL_CHK_BUF_PTR( p + 2, end, kkpp_len );
Manuel Pégourié-Gonnardd0d8cb32015-09-17 14:16:30 +0200466
467 memcpy( p + 2, ssl->handshake->ecjpake_cache, kkpp_len );
Manuel Pégourié-Gonnard294139b2015-09-15 16:55:05 +0200468 }
469
Joe Subbiani2f98d792021-08-20 11:44:44 +0100470 MBEDTLS_PUT_UINT16_BE( kkpp_len, p, 0 );
471 p += 2;
Manuel Pégourié-Gonnard294139b2015-09-15 16:55:05 +0200472
473 *olen = kkpp_len + 4;
Hanno Becker261602c2017-04-12 14:54:42 +0100474
475 return( 0 );
Manuel Pégourié-Gonnard294139b2015-09-15 16:55:05 +0200476}
Manuel Pégourié-Gonnardeef142d2015-09-16 10:05:04 +0200477#endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
Paul Bakkerc3f177a2012-04-11 16:11:49 +0000478
Hanno Beckera0e20d02019-05-15 14:03:01 +0100479#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Becker261602c2017-04-12 14:54:42 +0100480static int ssl_write_cid_ext( mbedtls_ssl_context *ssl,
481 unsigned char *buf,
482 const unsigned char *end,
483 size_t *olen )
Hanno Becker49770ff2019-04-25 16:55:15 +0100484{
485 unsigned char *p = buf;
486 size_t ext_len;
Hanno Becker49770ff2019-04-25 16:55:15 +0100487
488 /*
Hanno Beckerebcc9132019-05-15 10:26:32 +0100489 * Quoting draft-ietf-tls-dtls-connection-id-05
490 * https://tools.ietf.org/html/draft-ietf-tls-dtls-connection-id-05
Hanno Becker49770ff2019-04-25 16:55:15 +0100491 *
492 * struct {
493 * opaque cid<0..2^8-1>;
494 * } ConnectionId;
495 */
496
497 *olen = 0;
498 if( ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM ||
499 ssl->negotiate_cid == MBEDTLS_SSL_CID_DISABLED )
500 {
Hanno Becker261602c2017-04-12 14:54:42 +0100501 return( 0 );
Hanno Becker49770ff2019-04-25 16:55:15 +0100502 }
503 MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding CID extension" ) );
504
505 /* ssl->own_cid_len is at most MBEDTLS_SSL_CID_IN_LEN_MAX
506 * which is at most 255, so the increment cannot overflow. */
Hanno Becker261602c2017-04-12 14:54:42 +0100507 MBEDTLS_SSL_CHK_BUF_PTR( p, end, (unsigned)( ssl->own_cid_len + 5 ) );
Hanno Becker49770ff2019-04-25 16:55:15 +0100508
509 /* Add extension ID + size */
Joe Subbiani2f98d792021-08-20 11:44:44 +0100510 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_CID, p, 0 );
511 p += 2;
Hanno Becker49770ff2019-04-25 16:55:15 +0100512 ext_len = (size_t) ssl->own_cid_len + 1;
Joe Subbiani2f98d792021-08-20 11:44:44 +0100513 MBEDTLS_PUT_UINT16_BE( ext_len, p, 0 );
514 p += 2;
Hanno Becker49770ff2019-04-25 16:55:15 +0100515
516 *p++ = (uint8_t) ssl->own_cid_len;
517 memcpy( p, ssl->own_cid, ssl->own_cid_len );
518
519 *olen = ssl->own_cid_len + 5;
Hanno Becker261602c2017-04-12 14:54:42 +0100520
521 return( 0 );
Hanno Becker49770ff2019-04-25 16:55:15 +0100522}
Hanno Beckera0e20d02019-05-15 14:03:01 +0100523#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Becker49770ff2019-04-25 16:55:15 +0100524
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200525#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
Hanno Becker261602c2017-04-12 14:54:42 +0100526static int ssl_write_max_fragment_length_ext( mbedtls_ssl_context *ssl,
527 unsigned char *buf,
528 const unsigned char *end,
529 size_t *olen )
Manuel Pégourié-Gonnarda0528492013-07-16 17:26:28 +0200530{
531 unsigned char *p = buf;
532
Simon Butcher0fc94e92015-09-28 20:52:04 +0100533 *olen = 0;
534
Hanno Becker261602c2017-04-12 14:54:42 +0100535 if( ssl->conf->mfl_code == MBEDTLS_SSL_MAX_FRAG_LEN_NONE )
536 return( 0 );
Manuel Pégourié-Gonnarda0528492013-07-16 17:26:28 +0200537
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100538 MBEDTLS_SSL_DEBUG_MSG( 3,
539 ( "client hello, adding max_fragment_length extension" ) );
Manuel Pégourié-Gonnarda0528492013-07-16 17:26:28 +0200540
Hanno Becker261602c2017-04-12 14:54:42 +0100541 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 5 );
Simon Butchered997662015-09-28 02:14:30 +0100542
Joe Subbiani2f98d792021-08-20 11:44:44 +0100543 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH, p, 0 );
544 p += 2;
Manuel Pégourié-Gonnarda0528492013-07-16 17:26:28 +0200545
546 *p++ = 0x00;
547 *p++ = 1;
548
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +0200549 *p++ = ssl->conf->mfl_code;
Manuel Pégourié-Gonnarda0528492013-07-16 17:26:28 +0200550
551 *olen = 5;
Hanno Becker261602c2017-04-12 14:54:42 +0100552
553 return( 0 );
Manuel Pégourié-Gonnarda0528492013-07-16 17:26:28 +0200554}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200555#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
Manuel Pégourié-Gonnarda0528492013-07-16 17:26:28 +0200556
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200557#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
Hanno Becker261602c2017-04-12 14:54:42 +0100558static int ssl_write_truncated_hmac_ext( mbedtls_ssl_context *ssl,
559 unsigned char *buf,
560 const unsigned char *end,
561 size_t *olen )
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +0200562{
563 unsigned char *p = buf;
564
Simon Butcher0fc94e92015-09-28 20:52:04 +0100565 *olen = 0;
566
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +0200567 if( ssl->conf->trunc_hmac == MBEDTLS_SSL_TRUNC_HMAC_DISABLED )
Hanno Becker261602c2017-04-12 14:54:42 +0100568 return( 0 );
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +0200569
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100570 MBEDTLS_SSL_DEBUG_MSG( 3,
571 ( "client hello, adding truncated_hmac extension" ) );
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +0200572
Hanno Becker261602c2017-04-12 14:54:42 +0100573 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 4 );
Simon Butchered997662015-09-28 02:14:30 +0100574
Joe Subbiani2f98d792021-08-20 11:44:44 +0100575 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_TRUNCATED_HMAC, p, 0 );
576 p += 2;
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +0200577
578 *p++ = 0x00;
579 *p++ = 0x00;
580
581 *olen = 4;
Hanno Becker261602c2017-04-12 14:54:42 +0100582
583 return( 0 );
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +0200584}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200585#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +0200586
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200587#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
Hanno Becker261602c2017-04-12 14:54:42 +0100588static int ssl_write_encrypt_then_mac_ext( mbedtls_ssl_context *ssl,
589 unsigned char *buf,
590 const unsigned char *end,
591 size_t *olen )
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +0100592{
593 unsigned char *p = buf;
594
Simon Butcher0fc94e92015-09-28 20:52:04 +0100595 *olen = 0;
596
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +0200597 if( ssl->conf->encrypt_then_mac == MBEDTLS_SSL_ETM_DISABLED ||
598 ssl->conf->max_minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
Hanno Becker261602c2017-04-12 14:54:42 +0100599 return( 0 );
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +0100600
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100601 MBEDTLS_SSL_DEBUG_MSG( 3,
602 ( "client hello, adding encrypt_then_mac extension" ) );
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +0100603
Hanno Becker261602c2017-04-12 14:54:42 +0100604 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 4 );
Simon Butchered997662015-09-28 02:14:30 +0100605
Joe Subbiani2f98d792021-08-20 11:44:44 +0100606 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC, p, 0 );
607 p += 2;
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +0100608
609 *p++ = 0x00;
610 *p++ = 0x00;
611
612 *olen = 4;
Hanno Becker261602c2017-04-12 14:54:42 +0100613
614 return( 0 );
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +0100615}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200616#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +0100617
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200618#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
Hanno Becker261602c2017-04-12 14:54:42 +0100619static int ssl_write_extended_ms_ext( mbedtls_ssl_context *ssl,
620 unsigned char *buf,
621 const unsigned char *end,
622 size_t *olen )
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +0200623{
624 unsigned char *p = buf;
625
Simon Butcher0fc94e92015-09-28 20:52:04 +0100626 *olen = 0;
627
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +0200628 if( ssl->conf->extended_ms == MBEDTLS_SSL_EXTENDED_MS_DISABLED ||
629 ssl->conf->max_minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 )
Hanno Becker261602c2017-04-12 14:54:42 +0100630 return( 0 );
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +0200631
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100632 MBEDTLS_SSL_DEBUG_MSG( 3,
633 ( "client hello, adding extended_master_secret extension" ) );
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +0200634
Hanno Becker261602c2017-04-12 14:54:42 +0100635 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 4 );
Simon Butchered997662015-09-28 02:14:30 +0100636
Joe Subbiani2f98d792021-08-20 11:44:44 +0100637 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET, p, 0 );
638 p += 2;
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +0200639
640 *p++ = 0x00;
641 *p++ = 0x00;
642
643 *olen = 4;
Hanno Becker261602c2017-04-12 14:54:42 +0100644
645 return( 0 );
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +0200646}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200647#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +0200648
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200649#if defined(MBEDTLS_SSL_SESSION_TICKETS)
Hanno Becker261602c2017-04-12 14:54:42 +0100650static int ssl_write_session_ticket_ext( mbedtls_ssl_context *ssl,
651 unsigned char *buf,
652 const unsigned char *end,
653 size_t *olen )
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +0200654{
655 unsigned char *p = buf;
656 size_t tlen = ssl->session_negotiate->ticket_len;
657
Simon Butcher0fc94e92015-09-28 20:52:04 +0100658 *olen = 0;
659
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +0200660 if( ssl->conf->session_tickets == MBEDTLS_SSL_SESSION_TICKETS_DISABLED )
Hanno Becker261602c2017-04-12 14:54:42 +0100661 return( 0 );
Manuel Pégourié-Gonnardaa0d4d12013-08-03 13:02:31 +0200662
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100663 MBEDTLS_SSL_DEBUG_MSG( 3,
664 ( "client hello, adding session ticket extension" ) );
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +0200665
Hanno Becker261602c2017-04-12 14:54:42 +0100666 /* The addition is safe here since the ticket length is 16 bit. */
667 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 4 + tlen );
Simon Butchered997662015-09-28 02:14:30 +0100668
Joe Subbiani2f98d792021-08-20 11:44:44 +0100669 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_SESSION_TICKET, p, 0 );
670 p += 2;
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +0200671
Joe Subbiani2f98d792021-08-20 11:44:44 +0100672 MBEDTLS_PUT_UINT16_BE( tlen, p, 0 );
673 p += 2;
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +0200674
675 *olen = 4;
676
Simon Butchered997662015-09-28 02:14:30 +0100677 if( ssl->session_negotiate->ticket == NULL || tlen == 0 )
Hanno Becker261602c2017-04-12 14:54:42 +0100678 return( 0 );
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +0200679
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100680 MBEDTLS_SSL_DEBUG_MSG( 3,
Paul Elliottd48d5c62021-01-07 14:47:05 +0000681 ( "sending session ticket of length %" MBEDTLS_PRINTF_SIZET, tlen ) );
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +0200682
683 memcpy( p, ssl->session_negotiate->ticket, tlen );
684
685 *olen += tlen;
Hanno Becker261602c2017-04-12 14:54:42 +0100686
687 return( 0 );
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +0200688}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200689#endif /* MBEDTLS_SSL_SESSION_TICKETS */
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +0200690
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200691#if defined(MBEDTLS_SSL_ALPN)
Hanno Becker261602c2017-04-12 14:54:42 +0100692static int ssl_write_alpn_ext( mbedtls_ssl_context *ssl,
693 unsigned char *buf,
694 const unsigned char *end,
695 size_t *olen )
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +0200696{
697 unsigned char *p = buf;
Simon Butchered997662015-09-28 02:14:30 +0100698 size_t alpnlen = 0;
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +0200699 const char **cur;
700
Simon Butcher0fc94e92015-09-28 20:52:04 +0100701 *olen = 0;
702
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +0200703 if( ssl->conf->alpn_list == NULL )
Hanno Becker261602c2017-04-12 14:54:42 +0100704 return( 0 );
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +0200705
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200706 MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding alpn extension" ) );
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +0200707
Simon Butchered997662015-09-28 02:14:30 +0100708 for( cur = ssl->conf->alpn_list; *cur != NULL; cur++ )
Hanno Beckere131bfe2017-04-12 14:54:42 +0100709 alpnlen += strlen( *cur ) + 1;
Simon Butchered997662015-09-28 02:14:30 +0100710
Hanno Becker261602c2017-04-12 14:54:42 +0100711 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 6 + alpnlen );
Simon Butchered997662015-09-28 02:14:30 +0100712
Joe Subbiani2f98d792021-08-20 11:44:44 +0100713 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_ALPN, p, 0 );
714 p += 2;
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +0200715
716 /*
717 * opaque ProtocolName<1..2^8-1>;
718 *
719 * struct {
720 * ProtocolName protocol_name_list<2..2^16-1>
721 * } ProtocolNameList;
722 */
723
724 /* Skip writing extension and list length for now */
725 p += 4;
726
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +0200727 for( cur = ssl->conf->alpn_list; *cur != NULL; cur++ )
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +0200728 {
Hanno Beckere131bfe2017-04-12 14:54:42 +0100729 /*
730 * mbedtls_ssl_conf_set_alpn_protocols() checked that the length of
731 * protocol names is less than 255.
732 */
733 *p = (unsigned char)strlen( *cur );
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +0200734 memcpy( p + 1, *cur, *p );
735 p += 1 + *p;
736 }
737
738 *olen = p - buf;
739
740 /* List length = olen - 2 (ext_type) - 2 (ext_len) - 2 (list_len) */
Joe Subbianic54e9082021-07-19 11:56:54 +0100741 MBEDTLS_PUT_UINT16_BE( *olen - 6, buf, 4 );
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +0200742
743 /* Extension length = olen - 2 (ext_type) - 2 (ext_len) */
Joe Subbianic54e9082021-07-19 11:56:54 +0100744 MBEDTLS_PUT_UINT16_BE( *olen - 4, buf, 2 );
Hanno Becker261602c2017-04-12 14:54:42 +0100745
746 return( 0 );
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +0200747}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200748#endif /* MBEDTLS_SSL_ALPN */
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +0200749
Ron Eldora9788042018-12-05 11:04:31 +0200750#if defined(MBEDTLS_SSL_DTLS_SRTP)
Johan Pascal77696ee2020-09-22 21:49:40 +0200751static int ssl_write_use_srtp_ext( mbedtls_ssl_context *ssl,
Johan Pascald387aa02020-09-23 18:47:56 +0200752 unsigned char *buf,
753 const unsigned char *end,
754 size_t *olen )
Johan Pascalb62bb512015-12-03 21:56:45 +0100755{
756 unsigned char *p = buf;
Johan Pascalf6417ec2020-09-22 15:15:19 +0200757 size_t protection_profiles_index = 0, ext_len = 0;
758 uint16_t mki_len = 0, profile_value = 0;
Johan Pascalb62bb512015-12-03 21:56:45 +0100759
760 *olen = 0;
761
Johan Pascalc3ccd982020-10-28 17:18:18 +0100762 if( ( ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM ) ||
763 ( ssl->conf->dtls_srtp_profile_list == NULL ) ||
764 ( ssl->conf->dtls_srtp_profile_list_len == 0 ) )
Johan Pascalb62bb512015-12-03 21:56:45 +0100765 {
Johan Pascal77696ee2020-09-22 21:49:40 +0200766 return( 0 );
Johan Pascalb62bb512015-12-03 21:56:45 +0100767 }
768
Ron Eldora9788042018-12-05 11:04:31 +0200769 /* RFC 5764 section 4.1.1
Johan Pascalb62bb512015-12-03 21:56:45 +0100770 * uint8 SRTPProtectionProfile[2];
771 *
772 * struct {
773 * SRTPProtectionProfiles SRTPProtectionProfiles;
774 * opaque srtp_mki<0..255>;
775 * } UseSRTPData;
Johan Pascalb62bb512015-12-03 21:56:45 +0100776 * SRTPProtectionProfile SRTPProtectionProfiles<2..2^16-1>;
Johan Pascalb62bb512015-12-03 21:56:45 +0100777 */
Johan Pascal9bc97ca2020-09-21 23:44:45 +0200778 if( ssl->conf->dtls_srtp_mki_support == MBEDTLS_SSL_DTLS_SRTP_MKI_SUPPORTED )
Ron Eldor591f1622018-01-22 12:30:04 +0200779 {
780 mki_len = ssl->dtls_srtp_info.mki_len;
781 }
Ron Eldoref72faf2018-07-12 11:54:20 +0300782 /* Extension length = 2 bytes for profiles length,
783 * ssl->conf->dtls_srtp_profile_list_len * 2 (each profile is 2 bytes length ),
784 * 1 byte for srtp_mki vector length and the mki_len value
785 */
Ron Eldor089c9fe2018-12-06 17:12:49 +0200786 ext_len = 2 + 2 * ( ssl->conf->dtls_srtp_profile_list_len ) + 1 + mki_len;
787
Johan Pascal77696ee2020-09-22 21:49:40 +0200788 MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, adding use_srtp extension" ) );
789
790 /* Check there is room in the buffer for the extension + 4 bytes
791 * - the extension tag (2 bytes)
792 * - the extension length (2 bytes)
793 */
794 MBEDTLS_SSL_CHK_BUF_PTR( p, end, ext_len + 4 );
795
Joe Subbiani2f98d792021-08-20 11:44:44 +0100796 MBEDTLS_PUT_UINT16_BE( MBEDTLS_TLS_EXT_USE_SRTP, p, 0 );
797 p += 2;
Johan Pascal77696ee2020-09-22 21:49:40 +0200798
Joe Subbiani2f98d792021-08-20 11:44:44 +0100799 MBEDTLS_PUT_UINT16_BE( ext_len, p, 0 );
800 p += 2;
Johan Pascalb62bb512015-12-03 21:56:45 +0100801
Ron Eldor3adb9922017-12-21 10:15:08 +0200802 /* protection profile length: 2*(ssl->conf->dtls_srtp_profile_list_len) */
Johan Pascalaae4d222020-09-22 21:21:39 +0200803 /* micro-optimization:
804 * the list size is limited to MBEDTLS_TLS_SRTP_MAX_PROFILE_LIST_LENGTH
805 * which is lower than 127, so the upper byte of the length is always 0
806 * For the documentation, the more generic code is left in comments
807 * *p++ = (unsigned char)( ( ( 2 * ssl->conf->dtls_srtp_profile_list_len )
808 * >> 8 ) & 0xFF );
809 */
810 *p++ = 0;
Joe Subbianic045dc12021-07-14 12:31:31 +0100811 *p++ = MBEDTLS_BYTE_0( 2 * ssl->conf->dtls_srtp_profile_list_len );
Johan Pascalb62bb512015-12-03 21:56:45 +0100812
Ron Eldoref72faf2018-07-12 11:54:20 +0300813 for( protection_profiles_index=0;
814 protection_profiles_index < ssl->conf->dtls_srtp_profile_list_len;
815 protection_profiles_index++ )
Johan Pascalb62bb512015-12-03 21:56:45 +0100816 {
Johan Pascal43f94902020-09-22 12:25:52 +0200817 profile_value = mbedtls_ssl_check_srtp_profile_value
Ron Eldor089c9fe2018-12-06 17:12:49 +0200818 ( ssl->conf->dtls_srtp_profile_list[protection_profiles_index] );
Johan Pascal43f94902020-09-22 12:25:52 +0200819 if( profile_value != MBEDTLS_TLS_SRTP_UNSET )
Ron Eldor089c9fe2018-12-06 17:12:49 +0200820 {
821 MBEDTLS_SSL_DEBUG_MSG( 3, ( "ssl_write_use_srtp_ext, add profile: %04x",
822 profile_value ) );
Joe Subbiani2f98d792021-08-20 11:44:44 +0100823 MBEDTLS_PUT_UINT16_BE( profile_value, p, 0 );
824 p += 2;
Ron Eldor089c9fe2018-12-06 17:12:49 +0200825 }
826 else
827 {
828 /*
829 * Note: we shall never arrive here as protection profiles
Johan Pascal76fdf1d2020-10-22 23:31:00 +0200830 * is checked by mbedtls_ssl_conf_dtls_srtp_protection_profiles function
Ron Eldor089c9fe2018-12-06 17:12:49 +0200831 */
Johan Pascale79c1e82020-09-22 15:51:27 +0200832 MBEDTLS_SSL_DEBUG_MSG( 3,
833 ( "client hello, "
Johan Pascal76fdf1d2020-10-22 23:31:00 +0200834 "illegal DTLS-SRTP protection profile %d",
Johan Pascale79c1e82020-09-22 15:51:27 +0200835 ssl->conf->dtls_srtp_profile_list[protection_profiles_index]
836 ) );
Johan Pascal76fdf1d2020-10-22 23:31:00 +0200837 return( MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED );
Johan Pascalb62bb512015-12-03 21:56:45 +0100838 }
839 }
840
Ron Eldor591f1622018-01-22 12:30:04 +0200841 *p++ = mki_len & 0xFF;
842
843 if( mki_len != 0 )
844 {
Ron Eldor75870ec2018-12-06 17:31:55 +0200845 memcpy( p, ssl->dtls_srtp_info.mki_value, mki_len );
Ron Eldor313d7b52018-12-10 14:56:21 +0200846 /*
847 * Increment p to point to the current position.
848 */
849 p += mki_len;
Ron Eldoref72faf2018-07-12 11:54:20 +0300850 MBEDTLS_SSL_DEBUG_BUF( 3, "sending mki", ssl->dtls_srtp_info.mki_value,
851 ssl->dtls_srtp_info.mki_len );
Ron Eldor591f1622018-01-22 12:30:04 +0200852 }
853
Ron Eldoref72faf2018-07-12 11:54:20 +0300854 /*
855 * total extension length: extension type (2 bytes)
856 * + extension length (2 bytes)
857 * + protection profile length (2 bytes)
858 * + 2 * number of protection profiles
859 * + srtp_mki vector length(1 byte)
Ron Eldor313d7b52018-12-10 14:56:21 +0200860 * + mki value
Ron Eldoref72faf2018-07-12 11:54:20 +0300861 */
Ron Eldor313d7b52018-12-10 14:56:21 +0200862 *olen = p - buf;
Johan Pascal77696ee2020-09-22 21:49:40 +0200863
864 return( 0 );
Johan Pascalb62bb512015-12-03 21:56:45 +0100865}
866#endif /* MBEDTLS_SSL_DTLS_SRTP */
867
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +0200868/*
869 * Generate random bytes for ClientHello
870 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200871static int ssl_generate_random( mbedtls_ssl_context *ssl )
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +0200872{
Janos Follath865b3eb2019-12-16 11:46:15 +0000873 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +0200874 unsigned char *p = ssl->handshake->randbytes;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200875#if defined(MBEDTLS_HAVE_TIME)
SimonBd5800b72016-04-26 07:43:27 +0100876 mbedtls_time_t t;
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +0200877#endif
878
Manuel Pégourié-Gonnardfb2d2232014-07-22 15:59:14 +0200879 /*
880 * When responding to a verify request, MUST reuse random (RFC 6347 4.2.1)
881 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200882#if defined(MBEDTLS_SSL_PROTO_DTLS)
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +0200883 if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
Manuel Pégourié-Gonnardfb2d2232014-07-22 15:59:14 +0200884 ssl->handshake->verify_cookie != NULL )
885 {
886 return( 0 );
887 }
888#endif
889
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200890#if defined(MBEDTLS_HAVE_TIME)
SimonBd5800b72016-04-26 07:43:27 +0100891 t = mbedtls_time( NULL );
Joe Subbiani2f98d792021-08-20 11:44:44 +0100892 MBEDTLS_PUT_UINT32_BE( t, p, 0 );
893 p += 4;
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +0200894
Paul Elliottd48d5c62021-01-07 14:47:05 +0000895 MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, current time: %" MBEDTLS_PRINTF_LONGLONG,
896 (long long) t ) );
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +0200897#else
Manuel Pégourié-Gonnard750e4d72015-05-07 12:35:38 +0100898 if( ( ret = ssl->conf->f_rng( ssl->conf->p_rng, p, 4 ) ) != 0 )
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +0200899 return( ret );
900
901 p += 4;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200902#endif /* MBEDTLS_HAVE_TIME */
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +0200903
Manuel Pégourié-Gonnard750e4d72015-05-07 12:35:38 +0100904 if( ( ret = ssl->conf->f_rng( ssl->conf->p_rng, p, 28 ) ) != 0 )
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +0200905 return( ret );
906
907 return( 0 );
908}
909
Mohammad Azim Khan1d3b5082018-04-18 19:35:00 +0100910/**
911 * \brief Validate cipher suite against config in SSL context.
912 *
913 * \param suite_info cipher suite to validate
914 * \param ssl SSL context
Andrzej Kurek03bac442018-04-25 05:06:07 -0400915 * \param min_minor_ver Minimal minor version to accept a cipher suite
916 * \param max_minor_ver Maximal minor version to accept a cipher suite
Mohammad Azim Khan1d3b5082018-04-18 19:35:00 +0100917 *
918 * \return 0 if valid, else 1
919 */
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100920static int ssl_validate_ciphersuite(
921 const mbedtls_ssl_ciphersuite_t * suite_info,
922 const mbedtls_ssl_context * ssl,
923 int min_minor_ver, int max_minor_ver )
Mohammad Azim Khan1d3b5082018-04-18 19:35:00 +0100924{
Andrzej Kurek03bac442018-04-25 05:06:07 -0400925 (void) ssl;
Mohammad Azim Khan1d3b5082018-04-18 19:35:00 +0100926 if( suite_info == NULL )
927 return( 1 );
928
Andrzej Kurek03bac442018-04-25 05:06:07 -0400929 if( suite_info->min_minor_ver > max_minor_ver ||
930 suite_info->max_minor_ver < min_minor_ver )
Mohammad Azim Khan1d3b5082018-04-18 19:35:00 +0100931 return( 1 );
932
933#if defined(MBEDTLS_SSL_PROTO_DTLS)
934 if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
935 ( suite_info->flags & MBEDTLS_CIPHERSUITE_NODTLS ) )
936 return( 1 );
937#endif
938
939#if defined(MBEDTLS_ARC4_C)
940 if( ssl->conf->arc4_disabled == MBEDTLS_SSL_ARC4_DISABLED &&
941 suite_info->cipher == MBEDTLS_CIPHER_ARC4_128 )
942 return( 1 );
943#endif
944
945#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
946 if( suite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECJPAKE &&
947 mbedtls_ecjpake_check( &ssl->handshake->ecjpake_ctx ) != 0 )
948 return( 1 );
949#endif
950
Hanno Becker2e4f6162018-10-23 11:54:44 +0100951 /* Don't suggest PSK-based ciphersuite if no PSK is available. */
Gilles Peskineeccd8882020-03-10 12:19:08 +0100952#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
Hanno Becker2e4f6162018-10-23 11:54:44 +0100953 if( mbedtls_ssl_ciphersuite_uses_psk( suite_info ) &&
Hanno Becker520224e2018-10-26 11:38:07 +0100954 ssl_conf_has_static_psk( ssl->conf ) == 0 )
Hanno Becker2e4f6162018-10-23 11:54:44 +0100955 {
956 return( 1 );
957 }
Gilles Peskineeccd8882020-03-10 12:19:08 +0100958#endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
Hanno Becker2e4f6162018-10-23 11:54:44 +0100959
Mohammad Azim Khan1d3b5082018-04-18 19:35:00 +0100960 return( 0 );
961}
962
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200963static int ssl_write_client_hello( mbedtls_ssl_context *ssl )
Paul Bakker5121ce52009-01-03 21:22:43 +0000964{
Janos Follath865b3eb2019-12-16 11:46:15 +0000965 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Paul Bakkerd3edc862013-03-20 16:07:17 +0100966 size_t i, n, olen, ext_len = 0;
Hanno Becker261602c2017-04-12 14:54:42 +0100967
Paul Bakker5121ce52009-01-03 21:22:43 +0000968 unsigned char *buf;
Paul Bakker2fbefde2013-06-29 16:01:15 +0200969 unsigned char *p, *q;
Hanno Becker261602c2017-04-12 14:54:42 +0100970 const unsigned char *end;
971
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +0200972 unsigned char offer_compress;
Paul Bakker8f4ddae2013-04-15 15:09:54 +0200973 const int *ciphersuites;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200974 const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
Ron Eldor755bb6a2018-02-14 19:30:48 +0200975#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
976 defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
977 int uses_ec = 0;
978#endif
Paul Bakker5121ce52009-01-03 21:22:43 +0000979
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200980 MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write client hello" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +0000981
Manuel Pégourié-Gonnard750e4d72015-05-07 12:35:38 +0100982 if( ssl->conf->f_rng == NULL )
Paul Bakkera9a028e2013-11-21 17:31:06 +0100983 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200984 MBEDTLS_SSL_DEBUG_MSG( 1, ( "no RNG provided") );
985 return( MBEDTLS_ERR_SSL_NO_RNG );
Paul Bakkera9a028e2013-11-21 17:31:06 +0100986 }
987
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200988#if defined(MBEDTLS_SSL_RENEGOTIATION)
989 if( ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE )
Manuel Pégourié-Gonnard615e6772014-11-03 08:23:14 +0100990#endif
Paul Bakker48916f92012-09-16 19:57:18 +0000991 {
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +0200992 ssl->major_ver = ssl->conf->min_major_ver;
993 ssl->minor_ver = ssl->conf->min_minor_ver;
Paul Bakker48916f92012-09-16 19:57:18 +0000994 }
Paul Bakker5121ce52009-01-03 21:22:43 +0000995
Manuel Pégourié-Gonnard1897af92015-05-10 23:27:38 +0200996 if( ssl->conf->max_major_ver == 0 )
Paul Bakker490ecc82011-10-06 13:04:09 +0000997 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +0100998 MBEDTLS_SSL_DEBUG_MSG( 1,
999 ( "configured max major version is invalid, consider using mbedtls_ssl_config_defaults()" ) );
Manuel Pégourié-Gonnard1897af92015-05-10 23:27:38 +02001000 return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
Paul Bakker490ecc82011-10-06 13:04:09 +00001001 }
Paul Bakker5121ce52009-01-03 21:22:43 +00001002
Hanno Becker261602c2017-04-12 14:54:42 +01001003 buf = ssl->out_msg;
1004 end = buf + MBEDTLS_SSL_OUT_CONTENT_LEN;
1005
Paul Bakker5121ce52009-01-03 21:22:43 +00001006 /*
Hanno Becker261602c2017-04-12 14:54:42 +01001007 * Check if there's enough space for the first part of the ClientHello
1008 * consisting of the 38 bytes described below, the session identifier (at
1009 * most 32 bytes) and its length (1 byte).
1010 *
1011 * Use static upper bounds instead of the actual values
1012 * to allow the compiler to optimize this away.
1013 */
1014 MBEDTLS_SSL_CHK_BUF_PTR( buf, end, 38 + 1 + 32 );
1015
1016 /*
1017 * The 38 first bytes of the ClientHello:
1018 * 0 . 0 handshake type (written later)
1019 * 1 . 3 handshake length (written later)
Paul Bakker5121ce52009-01-03 21:22:43 +00001020 * 4 . 5 highest version supported
1021 * 6 . 9 current UNIX time
1022 * 10 . 37 random bytes
Hanno Becker261602c2017-04-12 14:54:42 +01001023 *
1024 * The current UNIX time (4 bytes) and following 28 random bytes are written
1025 * by ssl_generate_random() into ssl->handshake->randbytes buffer and then
1026 * copied from there into the output buffer.
Paul Bakker5121ce52009-01-03 21:22:43 +00001027 */
Paul Bakker5121ce52009-01-03 21:22:43 +00001028
Hanno Becker261602c2017-04-12 14:54:42 +01001029 p = buf + 4;
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001030 mbedtls_ssl_write_version( ssl->conf->max_major_ver,
1031 ssl->conf->max_minor_ver,
1032 ssl->conf->transport, p );
Manuel Pégourié-Gonnardabc7e3b2014-02-11 18:15:03 +01001033 p += 2;
Paul Bakker5121ce52009-01-03 21:22:43 +00001034
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001035 MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, max version: [%d:%d]",
Paul Bakker5121ce52009-01-03 21:22:43 +00001036 buf[4], buf[5] ) );
1037
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +02001038 if( ( ret = ssl_generate_random( ssl ) ) != 0 )
1039 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001040 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_generate_random", ret );
Paul Bakkerfa9b1002013-07-03 15:31:03 +02001041 return( ret );
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +02001042 }
Paul Bakkerfa9b1002013-07-03 15:31:03 +02001043
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +02001044 memcpy( p, ssl->handshake->randbytes, 32 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001045 MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, random bytes", p, 32 );
Manuel Pégourié-Gonnardb760f002014-07-22 15:53:27 +02001046 p += 32;
Paul Bakker5121ce52009-01-03 21:22:43 +00001047
1048 /*
1049 * 38 . 38 session id length
1050 * 39 . 39+n session id
Manuel Pégourié-Gonnard4128aa72014-03-21 09:40:12 +01001051 * 39+n . 39+n DTLS only: cookie length (1 byte)
Hanno Becker261602c2017-04-12 14:54:42 +01001052 * 40+n . .. DTLS only: cookie
Manuel Pégourié-Gonnard4128aa72014-03-21 09:40:12 +01001053 * .. . .. ciphersuitelist length (2 bytes)
1054 * .. . .. ciphersuitelist
1055 * .. . .. compression methods length (1 byte)
Paul Bakkerc3f177a2012-04-11 16:11:49 +00001056 * .. . .. compression methods
Manuel Pégourié-Gonnard4128aa72014-03-21 09:40:12 +01001057 * .. . .. extensions length (2 bytes)
Paul Bakkerc3f177a2012-04-11 16:11:49 +00001058 * .. . .. extensions
Paul Bakker5121ce52009-01-03 21:22:43 +00001059 */
Manuel Pégourié-Gonnard12ad7982015-06-18 15:50:37 +02001060 n = ssl->session_negotiate->id_len;
Paul Bakker5121ce52009-01-03 21:22:43 +00001061
Manuel Pégourié-Gonnard615e6772014-11-03 08:23:14 +01001062 if( n < 16 || n > 32 ||
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001063#if defined(MBEDTLS_SSL_RENEGOTIATION)
1064 ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE ||
Manuel Pégourié-Gonnard615e6772014-11-03 08:23:14 +01001065#endif
Paul Bakker0a597072012-09-25 21:55:46 +00001066 ssl->handshake->resume == 0 )
Manuel Pégourié-Gonnard6377e412013-07-31 16:31:33 +02001067 {
Paul Bakker5121ce52009-01-03 21:22:43 +00001068 n = 0;
Manuel Pégourié-Gonnard6377e412013-07-31 16:31:33 +02001069 }
1070
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001071#if defined(MBEDTLS_SSL_SESSION_TICKETS)
Manuel Pégourié-Gonnard6377e412013-07-31 16:31:33 +02001072 /*
1073 * RFC 5077 section 3.4: "When presenting a ticket, the client MAY
1074 * generate and include a Session ID in the TLS ClientHello."
1075 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001076#if defined(MBEDTLS_SSL_RENEGOTIATION)
1077 if( ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE )
Manuel Pégourié-Gonnard59c6f2e2015-01-22 11:06:40 +00001078#endif
Manuel Pégourié-Gonnardd2b35ec2015-03-10 11:40:43 +00001079 {
Manuel Pégourié-Gonnard59c6f2e2015-01-22 11:06:40 +00001080 if( ssl->session_negotiate->ticket != NULL &&
1081 ssl->session_negotiate->ticket_len != 0 )
1082 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001083 ret = ssl->conf->f_rng( ssl->conf->p_rng,
1084 ssl->session_negotiate->id, 32 );
Manuel Pégourié-Gonnard6377e412013-07-31 16:31:33 +02001085
Manuel Pégourié-Gonnard59c6f2e2015-01-22 11:06:40 +00001086 if( ret != 0 )
1087 return( ret );
Manuel Pégourié-Gonnard6377e412013-07-31 16:31:33 +02001088
Manuel Pégourié-Gonnard12ad7982015-06-18 15:50:37 +02001089 ssl->session_negotiate->id_len = n = 32;
Manuel Pégourié-Gonnard59c6f2e2015-01-22 11:06:40 +00001090 }
Manuel Pégourié-Gonnard6377e412013-07-31 16:31:33 +02001091 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001092#endif /* MBEDTLS_SSL_SESSION_TICKETS */
Paul Bakker5121ce52009-01-03 21:22:43 +00001093
Hanno Becker261602c2017-04-12 14:54:42 +01001094 /*
1095 * The first check of the output buffer size above (
1096 * MBEDTLS_SSL_CHK_BUF_PTR( buf, end, 38 + 1 + 32 );)
1097 * has checked that there is enough space in the output buffer for the
1098 * session identifier length byte and the session identifier (n <= 32).
1099 */
Paul Bakker5121ce52009-01-03 21:22:43 +00001100 *p++ = (unsigned char) n;
1101
1102 for( i = 0; i < n; i++ )
Paul Bakker48916f92012-09-16 19:57:18 +00001103 *p++ = ssl->session_negotiate->id[i];
Paul Bakker5121ce52009-01-03 21:22:43 +00001104
Paul Elliottd48d5c62021-01-07 14:47:05 +00001105 MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, session id len.: %" MBEDTLS_PRINTF_SIZET, n ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001106 MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, session id", buf + 39, n );
Paul Bakker5121ce52009-01-03 21:22:43 +00001107
Manuel Pégourié-Gonnard4128aa72014-03-21 09:40:12 +01001108 /*
Hanno Becker261602c2017-04-12 14:54:42 +01001109 * With 'n' being the length of the session identifier
1110 *
1111 * 39+n . 39+n DTLS only: cookie length (1 byte)
1112 * 40+n . .. DTLS only: cookie
1113 * .. . .. ciphersuitelist length (2 bytes)
1114 * .. . .. ciphersuitelist
1115 * .. . .. compression methods length (1 byte)
1116 * .. . .. compression methods
1117 * .. . .. extensions length (2 bytes)
1118 * .. . .. extensions
1119 */
1120
1121 /*
Manuel Pégourié-Gonnard4128aa72014-03-21 09:40:12 +01001122 * DTLS cookie
1123 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001124#if defined(MBEDTLS_SSL_PROTO_DTLS)
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001125 if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
Manuel Pégourié-Gonnard4128aa72014-03-21 09:40:12 +01001126 {
Hanno Becker261602c2017-04-12 14:54:42 +01001127 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 1 );
1128
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001129 if( ssl->handshake->verify_cookie == NULL )
1130 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001131 MBEDTLS_SSL_DEBUG_MSG( 3, ( "no verify cookie to send" ) );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001132 *p++ = 0;
1133 }
1134 else
1135 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001136 MBEDTLS_SSL_DEBUG_BUF( 3, "client hello, cookie",
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001137 ssl->handshake->verify_cookie,
1138 ssl->handshake->verify_cookie_len );
1139
1140 *p++ = ssl->handshake->verify_cookie_len;
Hanno Becker261602c2017-04-12 14:54:42 +01001141
1142 MBEDTLS_SSL_CHK_BUF_PTR( p, end,
1143 ssl->handshake->verify_cookie_len );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001144 memcpy( p, ssl->handshake->verify_cookie,
1145 ssl->handshake->verify_cookie_len );
1146 p += ssl->handshake->verify_cookie_len;
1147 }
Manuel Pégourié-Gonnard4128aa72014-03-21 09:40:12 +01001148 }
1149#endif
Paul Bakker5121ce52009-01-03 21:22:43 +00001150
Paul Bakker48916f92012-09-16 19:57:18 +00001151 /*
Manuel Pégourié-Gonnard4128aa72014-03-21 09:40:12 +01001152 * Ciphersuite list
Paul Bakker48916f92012-09-16 19:57:18 +00001153 */
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001154 ciphersuites = ssl->conf->ciphersuite_list[ssl->minor_ver];
Manuel Pégourié-Gonnard4128aa72014-03-21 09:40:12 +01001155
1156 /* Skip writing ciphersuite length for now */
1157 n = 0;
1158 q = p;
Hanno Becker261602c2017-04-12 14:54:42 +01001159
1160 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 2 );
Manuel Pégourié-Gonnard4128aa72014-03-21 09:40:12 +01001161 p += 2;
1162
Paul Bakker2fbefde2013-06-29 16:01:15 +02001163 for( i = 0; ciphersuites[i] != 0; i++ )
Paul Bakker5121ce52009-01-03 21:22:43 +00001164 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001165 ciphersuite_info = mbedtls_ssl_ciphersuite_from_id( ciphersuites[i] );
Paul Bakker2fbefde2013-06-29 16:01:15 +02001166
Andrzej Kurek03bac442018-04-25 05:06:07 -04001167 if( ssl_validate_ciphersuite( ciphersuite_info, ssl,
1168 ssl->conf->min_minor_ver,
1169 ssl->conf->max_minor_ver ) != 0 )
Paul Bakker2fbefde2013-06-29 16:01:15 +02001170 continue;
1171
Hanno Becker3c88c652019-01-02 11:17:25 +00001172 MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, add ciphersuite: %#04x (%s)",
Paul Elliott9f352112020-12-09 14:55:45 +00001173 (unsigned int)ciphersuites[i], ciphersuite_info->name ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00001174
Ron Eldor755bb6a2018-02-14 19:30:48 +02001175#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
1176 defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
1177 uses_ec |= mbedtls_ssl_ciphersuite_uses_ec( ciphersuite_info );
1178#endif
1179
Hanno Becker261602c2017-04-12 14:54:42 +01001180 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 2 );
1181
Paul Bakker2fbefde2013-06-29 16:01:15 +02001182 n++;
Joe Subbiani2f98d792021-08-20 11:44:44 +01001183 MBEDTLS_PUT_UINT16_BE( ciphersuites[i], p, 0 );
1184 p += 2;
Paul Bakker5121ce52009-01-03 21:22:43 +00001185 }
1186
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001187 MBEDTLS_SSL_DEBUG_MSG( 3,
Paul Elliottd48d5c62021-01-07 14:47:05 +00001188 ( "client hello, got %" MBEDTLS_PRINTF_SIZET " ciphersuites (excluding SCSVs)", n ) );
Ron Eldor714785d2017-08-28 13:55:55 +03001189
Manuel Pégourié-Gonnard5d9cde22015-01-22 10:49:41 +00001190 /*
1191 * Add TLS_EMPTY_RENEGOTIATION_INFO_SCSV
1192 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001193#if defined(MBEDTLS_SSL_RENEGOTIATION)
1194 if( ssl->renego_status == MBEDTLS_SSL_INITIAL_HANDSHAKE )
Manuel Pégourié-Gonnard5d9cde22015-01-22 10:49:41 +00001195#endif
1196 {
Ron Eldor4a2fb4c2017-09-10 17:03:50 +03001197 MBEDTLS_SSL_DEBUG_MSG( 3, ( "adding EMPTY_RENEGOTIATION_INFO_SCSV" ) );
Hanno Becker261602c2017-04-12 14:54:42 +01001198 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 2 );
Joe Subbiani2f98d792021-08-20 11:44:44 +01001199 MBEDTLS_PUT_UINT16_BE( MBEDTLS_SSL_EMPTY_RENEGOTIATION_INFO, p, 0 );
1200 p += 2;
Manuel Pégourié-Gonnard5d9cde22015-01-22 10:49:41 +00001201 n++;
1202 }
1203
Manuel Pégourié-Gonnard1cbd39d2014-10-20 13:34:59 +02001204 /* Some versions of OpenSSL don't handle it correctly if not at end */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001205#if defined(MBEDTLS_SSL_FALLBACK_SCSV)
Manuel Pégourié-Gonnard684b0592015-05-06 09:27:31 +01001206 if( ssl->conf->fallback == MBEDTLS_SSL_IS_FALLBACK )
Manuel Pégourié-Gonnard1cbd39d2014-10-20 13:34:59 +02001207 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001208 MBEDTLS_SSL_DEBUG_MSG( 3, ( "adding FALLBACK_SCSV" ) );
Hanno Becker261602c2017-04-12 14:54:42 +01001209
1210 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 2 );
Joe Subbiani2f98d792021-08-20 11:44:44 +01001211 MBEDTLS_PUT_UINT16_BE( MBEDTLS_SSL_FALLBACK_SCSV_VALUE, p, 0 );
1212 p += 2;
Manuel Pégourié-Gonnard1cbd39d2014-10-20 13:34:59 +02001213 n++;
1214 }
1215#endif
1216
Paul Bakker2fbefde2013-06-29 16:01:15 +02001217 *q++ = (unsigned char)( n >> 7 );
1218 *q++ = (unsigned char)( n << 1 );
1219
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001220#if defined(MBEDTLS_ZLIB_SUPPORT)
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02001221 offer_compress = 1;
Paul Bakker2770fbd2012-07-03 13:30:23 +00001222#else
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02001223 offer_compress = 0;
1224#endif
Paul Bakker5121ce52009-01-03 21:22:43 +00001225
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02001226 /*
Johannes H4e5d23f2018-01-06 09:46:57 +01001227 * We don't support compression with DTLS right now: if many records come
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02001228 * in the same datagram, uncompressing one could overwrite the next one.
1229 * We don't want to add complexity for handling that case unless there is
1230 * an actual need for it.
1231 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001232#if defined(MBEDTLS_SSL_PROTO_DTLS)
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001233 if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02001234 offer_compress = 0;
1235#endif
1236
1237 if( offer_compress )
1238 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001239 MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, compress len.: %d", 2 ) );
1240 MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, compress alg.: %d %d",
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001241 MBEDTLS_SSL_COMPRESS_DEFLATE,
1242 MBEDTLS_SSL_COMPRESS_NULL ) );
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02001243
Hanno Becker261602c2017-04-12 14:54:42 +01001244 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 3 );
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02001245 *p++ = 2;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001246 *p++ = MBEDTLS_SSL_COMPRESS_DEFLATE;
1247 *p++ = MBEDTLS_SSL_COMPRESS_NULL;
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02001248 }
1249 else
1250 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001251 MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, compress len.: %d", 1 ) );
1252 MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, compress alg.: %d",
1253 MBEDTLS_SSL_COMPRESS_NULL ) );
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02001254
Hanno Becker261602c2017-04-12 14:54:42 +01001255 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 2 );
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02001256 *p++ = 1;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001257 *p++ = MBEDTLS_SSL_COMPRESS_NULL;
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02001258 }
Paul Bakker5121ce52009-01-03 21:22:43 +00001259
Hanno Becker261602c2017-04-12 14:54:42 +01001260 /* First write extensions, then the total length */
1261
1262 MBEDTLS_SSL_CHK_BUF_PTR( p, end, 2 );
1263
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001264#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
Hanno Becker261602c2017-04-12 14:54:42 +01001265 if( ( ret = ssl_write_hostname_ext( ssl, p + 2 + ext_len,
1266 end, &olen ) ) != 0 )
1267 {
1268 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_hostname_ext", ret );
1269 return( ret );
1270 }
Paul Bakkerd3edc862013-03-20 16:07:17 +01001271 ext_len += olen;
Paul Bakker0be444a2013-08-27 21:55:01 +02001272#endif
Paul Bakker5121ce52009-01-03 21:22:43 +00001273
Hanno Becker40f8b512017-10-12 14:58:55 +01001274 /* Note that TLS_EMPTY_RENEGOTIATION_INFO_SCSV is always added
1275 * even if MBEDTLS_SSL_RENEGOTIATION is not defined. */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001276#if defined(MBEDTLS_SSL_RENEGOTIATION)
Hanno Becker261602c2017-04-12 14:54:42 +01001277 if( ( ret = ssl_write_renegotiation_ext( ssl, p + 2 + ext_len,
1278 end, &olen ) ) != 0 )
1279 {
1280 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_renegotiation_ext", ret );
1281 return( ret );
1282 }
Paul Bakkerd3edc862013-03-20 16:07:17 +01001283 ext_len += olen;
Manuel Pégourié-Gonnard615e6772014-11-03 08:23:14 +01001284#endif
Paul Bakkerc3f177a2012-04-11 16:11:49 +00001285
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001286#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && \
Gilles Peskineeccd8882020-03-10 12:19:08 +01001287 defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
Hanno Becker261602c2017-04-12 14:54:42 +01001288 if( ( ret = ssl_write_signature_algorithms_ext( ssl, p + 2 + ext_len,
1289 end, &olen ) ) != 0 )
1290 {
1291 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_signature_algorithms_ext", ret );
1292 return( ret );
1293 }
Paul Bakkerd3edc862013-03-20 16:07:17 +01001294 ext_len += olen;
Paul Bakkerd2f068e2013-08-27 21:19:20 +02001295#endif
Paul Bakkerc3f177a2012-04-11 16:11:49 +00001296
Manuel Pégourié-Gonnardf4721792015-09-15 10:53:51 +02001297#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
Robert Cragieae8535d2015-10-06 17:11:18 +01001298 defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
Ron Eldor755bb6a2018-02-14 19:30:48 +02001299 if( uses_ec )
1300 {
Hanno Becker261602c2017-04-12 14:54:42 +01001301 if( ( ret = ssl_write_supported_elliptic_curves_ext( ssl, p + 2 + ext_len,
1302 end, &olen ) ) != 0 )
1303 {
1304 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_supported_elliptic_curves_ext", ret );
1305 return( ret );
1306 }
Ron Eldor755bb6a2018-02-14 19:30:48 +02001307 ext_len += olen;
Paul Bakker41c83d32013-03-20 14:39:14 +01001308
Hanno Becker261602c2017-04-12 14:54:42 +01001309 if( ( ret = ssl_write_supported_point_formats_ext( ssl, p + 2 + ext_len,
1310 end, &olen ) ) != 0 )
1311 {
1312 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_supported_point_formats_ext", ret );
1313 return( ret );
1314 }
Ron Eldor755bb6a2018-02-14 19:30:48 +02001315 ext_len += olen;
1316 }
Paul Bakker41c83d32013-03-20 14:39:14 +01001317#endif
1318
Manuel Pégourié-Gonnardeef142d2015-09-16 10:05:04 +02001319#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
Hanno Becker261602c2017-04-12 14:54:42 +01001320 if( ( ret = ssl_write_ecjpake_kkpp_ext( ssl, p + 2 + ext_len,
1321 end, &olen ) ) != 0 )
1322 {
1323 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_ecjpake_kkpp_ext", ret );
1324 return( ret );
1325 }
Manuel Pégourié-Gonnard294139b2015-09-15 16:55:05 +02001326 ext_len += olen;
1327#endif
1328
Hanno Beckera0e20d02019-05-15 14:03:01 +01001329#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Becker261602c2017-04-12 14:54:42 +01001330 if( ( ret = ssl_write_cid_ext( ssl, p + 2 + ext_len, end, &olen ) ) != 0 )
1331 {
1332 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_cid_ext", ret );
1333 return( ret );
1334 }
Hanno Becker49770ff2019-04-25 16:55:15 +01001335 ext_len += olen;
Hanno Beckera0e20d02019-05-15 14:03:01 +01001336#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Becker49770ff2019-04-25 16:55:15 +01001337
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001338#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
Hanno Becker261602c2017-04-12 14:54:42 +01001339 if( ( ret = ssl_write_max_fragment_length_ext( ssl, p + 2 + ext_len,
1340 end, &olen ) ) != 0 )
1341 {
1342 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_max_fragment_length_ext", ret );
1343 return( ret );
1344 }
Manuel Pégourié-Gonnarda0528492013-07-16 17:26:28 +02001345 ext_len += olen;
Paul Bakker05decb22013-08-15 13:33:48 +02001346#endif
Manuel Pégourié-Gonnarda0528492013-07-16 17:26:28 +02001347
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001348#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
Hanno Becker261602c2017-04-12 14:54:42 +01001349 if( ( ret = ssl_write_truncated_hmac_ext( ssl, p + 2 + ext_len,
1350 end, &olen ) ) != 0 )
1351 {
1352 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_truncated_hmac_ext", ret );
1353 return( ret );
1354 }
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +02001355 ext_len += olen;
Paul Bakker1f2bc622013-08-15 13:45:55 +02001356#endif
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +02001357
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001358#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
Hanno Becker261602c2017-04-12 14:54:42 +01001359 if( ( ret = ssl_write_encrypt_then_mac_ext( ssl, p + 2 + ext_len,
1360 end, &olen ) ) != 0 )
1361 {
1362 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_encrypt_then_mac_ext", ret );
1363 return( ret );
1364 }
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +01001365 ext_len += olen;
1366#endif
1367
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001368#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
Hanno Becker261602c2017-04-12 14:54:42 +01001369 if( ( ret = ssl_write_extended_ms_ext( ssl, p + 2 + ext_len,
1370 end, &olen ) ) != 0 )
1371 {
1372 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_extended_ms_ext", ret );
1373 return( ret );
1374 }
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +02001375 ext_len += olen;
1376#endif
1377
Simon Butcher5624ec82015-09-29 01:06:06 +01001378#if defined(MBEDTLS_SSL_ALPN)
Hanno Becker261602c2017-04-12 14:54:42 +01001379 if( ( ret = ssl_write_alpn_ext( ssl, p + 2 + ext_len,
1380 end, &olen ) ) != 0 )
1381 {
1382 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_alpn_ext", ret );
1383 return( ret );
1384 }
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +02001385 ext_len += olen;
Paul Bakkera503a632013-08-14 13:48:06 +02001386#endif
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +02001387
Johan Pascalb62bb512015-12-03 21:56:45 +01001388#if defined(MBEDTLS_SSL_DTLS_SRTP)
Johan Pascalc3ccd982020-10-28 17:18:18 +01001389 if( ( ret = ssl_write_use_srtp_ext( ssl, p + 2 + ext_len,
1390 end, &olen ) ) != 0 )
Ron Eldor3adb9922017-12-21 10:15:08 +02001391 {
Johan Pascalc3ccd982020-10-28 17:18:18 +01001392 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_use_srtp_ext", ret );
1393 return( ret );
Ron Eldor3adb9922017-12-21 10:15:08 +02001394 }
Johan Pascalc3ccd982020-10-28 17:18:18 +01001395 ext_len += olen;
Johan Pascalb62bb512015-12-03 21:56:45 +01001396#endif
1397
Simon Butcher5624ec82015-09-29 01:06:06 +01001398#if defined(MBEDTLS_SSL_SESSION_TICKETS)
Hanno Becker261602c2017-04-12 14:54:42 +01001399 if( ( ret = ssl_write_session_ticket_ext( ssl, p + 2 + ext_len,
1400 end, &olen ) ) != 0 )
1401 {
1402 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_write_session_ticket_ext", ret );
1403 return( ret );
1404 }
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +02001405 ext_len += olen;
1406#endif
1407
Manuel Pégourié-Gonnardeaecbd32014-11-06 02:38:02 +01001408 /* olen unused if all extensions are disabled */
1409 ((void) olen);
1410
Paul Elliottd48d5c62021-01-07 14:47:05 +00001411 MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, total extension length: %" MBEDTLS_PRINTF_SIZET,
Hanno Becker261602c2017-04-12 14:54:42 +01001412 ext_len ) );
Paul Bakkerc3f177a2012-04-11 16:11:49 +00001413
Paul Bakkera7036632014-04-30 10:15:38 +02001414 if( ext_len > 0 )
1415 {
Hanno Becker261602c2017-04-12 14:54:42 +01001416 /* No need to check for space here, because the extension
1417 * writing functions already took care of that. */
Joe Subbiani2f98d792021-08-20 11:44:44 +01001418 MBEDTLS_PUT_UINT16_BE( ext_len, p, 0 );
Joe Subbiani24647c52021-08-20 15:56:22 +01001419 p += 2 + ext_len;
Paul Bakkera7036632014-04-30 10:15:38 +02001420 }
Paul Bakker41c83d32013-03-20 14:39:14 +01001421
Paul Bakker5121ce52009-01-03 21:22:43 +00001422 ssl->out_msglen = p - buf;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001423 ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
1424 ssl->out_msg[0] = MBEDTLS_SSL_HS_CLIENT_HELLO;
Paul Bakker5121ce52009-01-03 21:22:43 +00001425
1426 ssl->state++;
1427
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001428#if defined(MBEDTLS_SSL_PROTO_DTLS)
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001429 if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001430 mbedtls_ssl_send_flight_completed( ssl );
Manuel Pégourié-Gonnard7de3c9e2014-09-29 15:29:48 +02001431#endif
1432
Manuel Pégourié-Gonnard31c15862017-09-13 09:38:11 +02001433 if( ( ret = mbedtls_ssl_write_handshake_msg( ssl ) ) != 0 )
Paul Bakker5121ce52009-01-03 21:22:43 +00001434 {
Manuel Pégourié-Gonnard31c15862017-09-13 09:38:11 +02001435 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_handshake_msg", ret );
Paul Bakker5121ce52009-01-03 21:22:43 +00001436 return( ret );
1437 }
1438
Manuel Pégourié-Gonnard87a346f2017-09-13 12:45:21 +02001439#if defined(MBEDTLS_SSL_PROTO_DTLS)
1440 if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
1441 ( ret = mbedtls_ssl_flight_transmit( ssl ) ) != 0 )
1442 {
1443 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_flight_transmit", ret );
1444 return( ret );
1445 }
Hanno Beckerbc2498a2018-08-28 10:13:29 +01001446#endif /* MBEDTLS_SSL_PROTO_DTLS */
Manuel Pégourié-Gonnard87a346f2017-09-13 12:45:21 +02001447
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001448 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write client hello" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00001449
1450 return( 0 );
1451}
1452
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001453static int ssl_parse_renegotiation_info( mbedtls_ssl_context *ssl,
Manuel Pégourié-Gonnarde048b672013-07-19 12:47:00 +02001454 const unsigned char *buf,
Paul Bakker48916f92012-09-16 19:57:18 +00001455 size_t len )
1456{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001457#if defined(MBEDTLS_SSL_RENEGOTIATION)
1458 if( ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE )
Paul Bakker48916f92012-09-16 19:57:18 +00001459 {
Manuel Pégourié-Gonnard31ff1d22013-10-28 13:46:11 +01001460 /* Check verify-data in constant-time. The length OTOH is no secret */
Paul Bakker48916f92012-09-16 19:57:18 +00001461 if( len != 1 + ssl->verify_data_len * 2 ||
1462 buf[0] != ssl->verify_data_len * 2 ||
Gabor Mezei18a44942021-10-20 11:59:27 +02001463 mbedtls_ct_memcmp( buf + 1,
Manuel Pégourié-Gonnard31ff1d22013-10-28 13:46:11 +01001464 ssl->own_verify_data, ssl->verify_data_len ) != 0 ||
Gabor Mezei18a44942021-10-20 11:59:27 +02001465 mbedtls_ct_memcmp( buf + 1 + ssl->verify_data_len,
Manuel Pégourié-Gonnard31ff1d22013-10-28 13:46:11 +01001466 ssl->peer_verify_data, ssl->verify_data_len ) != 0 )
Paul Bakker48916f92012-09-16 19:57:18 +00001467 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001468 MBEDTLS_SSL_DEBUG_MSG( 1, ( "non-matching renegotiation info" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001469 mbedtls_ssl_send_alert_message(
1470 ssl,
1471 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1472 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001473 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Paul Bakker48916f92012-09-16 19:57:18 +00001474 }
1475 }
Manuel Pégourié-Gonnard615e6772014-11-03 08:23:14 +01001476 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001477#endif /* MBEDTLS_SSL_RENEGOTIATION */
Manuel Pégourié-Gonnard615e6772014-11-03 08:23:14 +01001478 {
1479 if( len != 1 || buf[0] != 0x00 )
1480 {
Ronald Cron5ee57072020-06-11 09:34:06 +02001481 MBEDTLS_SSL_DEBUG_MSG( 1,
1482 ( "non-zero length renegotiation info" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001483 mbedtls_ssl_send_alert_message(
1484 ssl,
1485 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1486 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001487 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Manuel Pégourié-Gonnard615e6772014-11-03 08:23:14 +01001488 }
1489
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001490 ssl->secure_renegotiation = MBEDTLS_SSL_SECURE_RENEGOTIATION;
Manuel Pégourié-Gonnard615e6772014-11-03 08:23:14 +01001491 }
Paul Bakker48916f92012-09-16 19:57:18 +00001492
1493 return( 0 );
1494}
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +02001495
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001496#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
1497static int ssl_parse_max_fragment_length_ext( mbedtls_ssl_context *ssl,
Manuel Pégourié-Gonnarde048b672013-07-19 12:47:00 +02001498 const unsigned char *buf,
Manuel Pégourié-Gonnardde600e52013-07-17 10:14:38 +02001499 size_t len )
1500{
1501 /*
1502 * server should use the extension only if we did,
1503 * and if so the server's value should match ours (and len is always 1)
1504 */
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001505 if( ssl->conf->mfl_code == MBEDTLS_SSL_MAX_FRAG_LEN_NONE ||
Manuel Pégourié-Gonnardde600e52013-07-17 10:14:38 +02001506 len != 1 ||
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001507 buf[0] != ssl->conf->mfl_code )
Manuel Pégourié-Gonnardde600e52013-07-17 10:14:38 +02001508 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001509 MBEDTLS_SSL_DEBUG_MSG( 1,
1510 ( "non-matching max fragment length extension" ) );
1511 mbedtls_ssl_send_alert_message(
1512 ssl,
1513 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
Dave Rodgmandd5f6242021-06-28 21:58:56 +01001514 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001515 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Manuel Pégourié-Gonnardde600e52013-07-17 10:14:38 +02001516 }
1517
1518 return( 0 );
1519}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001520#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
Paul Bakker48916f92012-09-16 19:57:18 +00001521
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001522#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
1523static int ssl_parse_truncated_hmac_ext( mbedtls_ssl_context *ssl,
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +02001524 const unsigned char *buf,
1525 size_t len )
1526{
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001527 if( ssl->conf->trunc_hmac == MBEDTLS_SSL_TRUNC_HMAC_DISABLED ||
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +02001528 len != 0 )
1529 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001530 MBEDTLS_SSL_DEBUG_MSG( 1,
1531 ( "non-matching truncated HMAC extension" ) );
1532 mbedtls_ssl_send_alert_message(
1533 ssl,
1534 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1535 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001536 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +02001537 }
1538
1539 ((void) buf);
1540
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001541 ssl->session_negotiate->trunc_hmac = MBEDTLS_SSL_TRUNC_HMAC_ENABLED;
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +02001542
1543 return( 0 );
1544}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001545#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +02001546
Hanno Beckera0e20d02019-05-15 14:03:01 +01001547#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckera8373a12019-04-26 15:37:26 +01001548static int ssl_parse_cid_ext( mbedtls_ssl_context *ssl,
1549 const unsigned char *buf,
1550 size_t len )
1551{
1552 size_t peer_cid_len;
1553
1554 if( /* CID extension only makes sense in DTLS */
1555 ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM ||
1556 /* The server must only send the CID extension if we have offered it. */
Hanno Becker22626482019-05-03 12:46:59 +01001557 ssl->negotiate_cid == MBEDTLS_SSL_CID_DISABLED )
Hanno Beckera8373a12019-04-26 15:37:26 +01001558 {
Hanno Becker22626482019-05-03 12:46:59 +01001559 MBEDTLS_SSL_DEBUG_MSG( 1, ( "CID extension unexpected" ) );
Hanno Beckera8373a12019-04-26 15:37:26 +01001560 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
Dave Rodgman0dfb7db2021-06-29 15:09:58 +01001561 MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT );
Hanno Becker22626482019-05-03 12:46:59 +01001562 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
1563 }
1564
1565 if( len == 0 )
1566 {
1567 MBEDTLS_SSL_DEBUG_MSG( 1, ( "CID extension invalid" ) );
1568 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1569 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
Hanno Beckera8373a12019-04-26 15:37:26 +01001570 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
1571 }
1572
1573 peer_cid_len = *buf++;
1574 len--;
1575
1576 if( peer_cid_len > MBEDTLS_SSL_CID_OUT_LEN_MAX )
1577 {
Hanno Becker22626482019-05-03 12:46:59 +01001578 MBEDTLS_SSL_DEBUG_MSG( 1, ( "CID extension invalid" ) );
Hanno Beckera8373a12019-04-26 15:37:26 +01001579 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
Hanno Becker22626482019-05-03 12:46:59 +01001580 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
Hanno Beckera8373a12019-04-26 15:37:26 +01001581 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
1582 }
1583
1584 if( len != peer_cid_len )
1585 {
Hanno Becker22626482019-05-03 12:46:59 +01001586 MBEDTLS_SSL_DEBUG_MSG( 1, ( "CID extension invalid" ) );
Hanno Beckera8373a12019-04-26 15:37:26 +01001587 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
Hanno Becker22626482019-05-03 12:46:59 +01001588 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Hanno Beckera8373a12019-04-26 15:37:26 +01001589 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
1590 }
1591
Hanno Becker5a299902019-05-03 12:47:49 +01001592 ssl->handshake->cid_in_use = MBEDTLS_SSL_CID_ENABLED;
Hanno Beckera8373a12019-04-26 15:37:26 +01001593 ssl->handshake->peer_cid_len = (uint8_t) peer_cid_len;
1594 memcpy( ssl->handshake->peer_cid, buf, peer_cid_len );
1595
1596 MBEDTLS_SSL_DEBUG_MSG( 3, ( "Use of CID extension negotiated" ) );
1597 MBEDTLS_SSL_DEBUG_BUF( 3, "Server CID", buf, peer_cid_len );
1598
Hanno Beckera8373a12019-04-26 15:37:26 +01001599 return( 0 );
1600}
Hanno Beckera0e20d02019-05-15 14:03:01 +01001601#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckera8373a12019-04-26 15:37:26 +01001602
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001603#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
1604static int ssl_parse_encrypt_then_mac_ext( mbedtls_ssl_context *ssl,
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +01001605 const unsigned char *buf,
1606 size_t len )
1607{
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001608 if( ssl->conf->encrypt_then_mac == MBEDTLS_SSL_ETM_DISABLED ||
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001609 ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 ||
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +01001610 len != 0 )
1611 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001612 MBEDTLS_SSL_DEBUG_MSG( 1,
1613 ( "non-matching encrypt-then-MAC extension" ) );
1614 mbedtls_ssl_send_alert_message(
1615 ssl,
1616 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
Dave Rodgman0dfb7db2021-06-29 15:09:58 +01001617 MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001618 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +01001619 }
1620
1621 ((void) buf);
1622
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001623 ssl->session_negotiate->encrypt_then_mac = MBEDTLS_SSL_ETM_ENABLED;
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +01001624
1625 return( 0 );
1626}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001627#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +01001628
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001629#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
1630static int ssl_parse_extended_ms_ext( mbedtls_ssl_context *ssl,
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +02001631 const unsigned char *buf,
1632 size_t len )
1633{
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001634 if( ssl->conf->extended_ms == MBEDTLS_SSL_EXTENDED_MS_DISABLED ||
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001635 ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 ||
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +02001636 len != 0 )
1637 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001638 MBEDTLS_SSL_DEBUG_MSG( 1,
1639 ( "non-matching extended master secret extension" ) );
1640 mbedtls_ssl_send_alert_message(
1641 ssl,
1642 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
Dave Rodgman0dfb7db2021-06-29 15:09:58 +01001643 MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001644 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +02001645 }
1646
1647 ((void) buf);
1648
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001649 ssl->handshake->extended_ms = MBEDTLS_SSL_EXTENDED_MS_ENABLED;
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +02001650
1651 return( 0 );
1652}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001653#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +02001654
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001655#if defined(MBEDTLS_SSL_SESSION_TICKETS)
1656static int ssl_parse_session_ticket_ext( mbedtls_ssl_context *ssl,
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +02001657 const unsigned char *buf,
1658 size_t len )
1659{
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001660 if( ssl->conf->session_tickets == MBEDTLS_SSL_SESSION_TICKETS_DISABLED ||
Manuel Pégourié-Gonnardaa0d4d12013-08-03 13:02:31 +02001661 len != 0 )
1662 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001663 MBEDTLS_SSL_DEBUG_MSG( 1,
1664 ( "non-matching session ticket extension" ) );
1665 mbedtls_ssl_send_alert_message(
1666 ssl,
1667 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
Dave Rodgman0dfb7db2021-06-29 15:09:58 +01001668 MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001669 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Manuel Pégourié-Gonnardaa0d4d12013-08-03 13:02:31 +02001670 }
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +02001671
1672 ((void) buf);
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02001673
1674 ssl->handshake->new_session_ticket = 1;
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +02001675
1676 return( 0 );
1677}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001678#endif /* MBEDTLS_SSL_SESSION_TICKETS */
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +02001679
Robert Cragie136884c2015-10-02 13:34:31 +01001680#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
Robert Cragieae8535d2015-10-06 17:11:18 +01001681 defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001682static int ssl_parse_supported_point_formats_ext( mbedtls_ssl_context *ssl,
Manuel Pégourié-Gonnard7b19c162013-08-15 18:01:11 +02001683 const unsigned char *buf,
1684 size_t len )
1685{
1686 size_t list_size;
1687 const unsigned char *p;
1688
Philippe Antoine747fd532018-05-30 09:13:21 +02001689 if( len == 0 || (size_t)( buf[0] + 1 ) != len )
Manuel Pégourié-Gonnard7b19c162013-08-15 18:01:11 +02001690 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001691 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02001692 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1693 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001694 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Manuel Pégourié-Gonnard7b19c162013-08-15 18:01:11 +02001695 }
Philippe Antoine747fd532018-05-30 09:13:21 +02001696 list_size = buf[0];
Manuel Pégourié-Gonnard7b19c162013-08-15 18:01:11 +02001697
Manuel Pégourié-Gonnardfd35af12014-06-23 14:10:13 +02001698 p = buf + 1;
Manuel Pégourié-Gonnard7b19c162013-08-15 18:01:11 +02001699 while( list_size > 0 )
1700 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001701 if( p[0] == MBEDTLS_ECP_PF_UNCOMPRESSED ||
1702 p[0] == MBEDTLS_ECP_PF_COMPRESSED )
Manuel Pégourié-Gonnard7b19c162013-08-15 18:01:11 +02001703 {
Robert Cragie136884c2015-10-02 13:34:31 +01001704#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C)
Manuel Pégourié-Gonnard5734b2d2013-08-15 19:04:02 +02001705 ssl->handshake->ecdh_ctx.point_format = p[0];
Gilles Peskine064a85c2017-05-10 10:46:40 +02001706#endif
Robert Cragieae8535d2015-10-06 17:11:18 +01001707#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
Robert Cragie136884c2015-10-02 13:34:31 +01001708 ssl->handshake->ecjpake_ctx.point_format = p[0];
1709#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001710 MBEDTLS_SSL_DEBUG_MSG( 4, ( "point format selected: %d", p[0] ) );
Manuel Pégourié-Gonnard7b19c162013-08-15 18:01:11 +02001711 return( 0 );
1712 }
1713
1714 list_size--;
1715 p++;
1716 }
1717
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001718 MBEDTLS_SSL_DEBUG_MSG( 1, ( "no point format in common" ) );
Gilles Peskinec94f7352017-05-10 16:37:56 +02001719 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1720 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001721 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Manuel Pégourié-Gonnard7b19c162013-08-15 18:01:11 +02001722}
Darryl Green11999bb2018-03-13 15:22:58 +00001723#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C ||
Robert Cragieae8535d2015-10-06 17:11:18 +01001724 MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
Manuel Pégourié-Gonnard7b19c162013-08-15 18:01:11 +02001725
Manuel Pégourié-Gonnard0a1324a2015-09-16 16:01:00 +02001726#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
1727static int ssl_parse_ecjpake_kkpp( mbedtls_ssl_context *ssl,
1728 const unsigned char *buf,
1729 size_t len )
1730{
Janos Follath865b3eb2019-12-16 11:46:15 +00001731 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Manuel Pégourié-Gonnard0a1324a2015-09-16 16:01:00 +02001732
Hanno Beckere694c3e2017-12-27 21:34:08 +00001733 if( ssl->handshake->ciphersuite_info->key_exchange !=
Manuel Pégourié-Gonnard0a1324a2015-09-16 16:01:00 +02001734 MBEDTLS_KEY_EXCHANGE_ECJPAKE )
1735 {
1736 MBEDTLS_SSL_DEBUG_MSG( 3, ( "skip ecjpake kkpp extension" ) );
1737 return( 0 );
1738 }
1739
Manuel Pégourié-Gonnardd0d8cb32015-09-17 14:16:30 +02001740 /* If we got here, we no longer need our cached extension */
1741 mbedtls_free( ssl->handshake->ecjpake_cache );
1742 ssl->handshake->ecjpake_cache = NULL;
1743 ssl->handshake->ecjpake_cache_len = 0;
1744
Manuel Pégourié-Gonnard0a1324a2015-09-16 16:01:00 +02001745 if( ( ret = mbedtls_ecjpake_read_round_one( &ssl->handshake->ecjpake_ctx,
1746 buf, len ) ) != 0 )
1747 {
1748 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecjpake_read_round_one", ret );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001749 mbedtls_ssl_send_alert_message(
1750 ssl,
1751 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1752 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
Manuel Pégourié-Gonnard0a1324a2015-09-16 16:01:00 +02001753 return( ret );
1754 }
1755
1756 return( 0 );
1757}
1758#endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
Paul Bakker5121ce52009-01-03 21:22:43 +00001759
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001760#if defined(MBEDTLS_SSL_ALPN)
1761static int ssl_parse_alpn_ext( mbedtls_ssl_context *ssl,
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +02001762 const unsigned char *buf, size_t len )
1763{
1764 size_t list_len, name_len;
1765 const char **p;
1766
1767 /* If we didn't send it, the server shouldn't send it */
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001768 if( ssl->conf->alpn_list == NULL )
Gilles Peskine1cc8e342017-05-03 16:28:34 +02001769 {
1770 MBEDTLS_SSL_DEBUG_MSG( 1, ( "non-matching ALPN extension" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01001771 mbedtls_ssl_send_alert_message(
1772 ssl,
1773 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
Dave Rodgman0dfb7db2021-06-29 15:09:58 +01001774 MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001775 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02001776 }
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +02001777
1778 /*
1779 * opaque ProtocolName<1..2^8-1>;
1780 *
1781 * struct {
1782 * ProtocolName protocol_name_list<2..2^16-1>
1783 * } ProtocolNameList;
1784 *
1785 * the "ProtocolNameList" MUST contain exactly one "ProtocolName"
1786 */
1787
1788 /* Min length is 2 (list_len) + 1 (name_len) + 1 (name) */
1789 if( len < 4 )
Gilles Peskine1cc8e342017-05-03 16:28:34 +02001790 {
1791 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1792 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001793 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02001794 }
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +02001795
1796 list_len = ( buf[0] << 8 ) | buf[1];
1797 if( list_len != len - 2 )
Gilles Peskine1cc8e342017-05-03 16:28:34 +02001798 {
1799 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1800 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001801 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02001802 }
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +02001803
1804 name_len = buf[2];
1805 if( name_len != list_len - 1 )
Gilles Peskine1cc8e342017-05-03 16:28:34 +02001806 {
1807 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1808 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001809 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02001810 }
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +02001811
1812 /* Check that the server chosen protocol was in our list and save it */
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001813 for( p = ssl->conf->alpn_list; *p != NULL; p++ )
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +02001814 {
1815 if( name_len == strlen( *p ) &&
1816 memcmp( buf + 3, *p, name_len ) == 0 )
1817 {
1818 ssl->alpn_chosen = *p;
1819 return( 0 );
1820 }
1821 }
1822
Gilles Peskine1cc8e342017-05-03 16:28:34 +02001823 MBEDTLS_SSL_DEBUG_MSG( 1, ( "ALPN extension: no matching protocol" ) );
Gilles Peskinec94f7352017-05-10 16:37:56 +02001824 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1825 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001826 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +02001827}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001828#endif /* MBEDTLS_SSL_ALPN */
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +02001829
Johan Pascalb62bb512015-12-03 21:56:45 +01001830#if defined(MBEDTLS_SSL_DTLS_SRTP)
1831static int ssl_parse_use_srtp_ext( mbedtls_ssl_context *ssl,
Ron Eldoref72faf2018-07-12 11:54:20 +03001832 const unsigned char *buf,
1833 size_t len )
Johan Pascalb62bb512015-12-03 21:56:45 +01001834{
Johan Pascal43f94902020-09-22 12:25:52 +02001835 mbedtls_ssl_srtp_profile server_protection = MBEDTLS_TLS_SRTP_UNSET;
Ron Eldor591f1622018-01-22 12:30:04 +02001836 size_t i, mki_len = 0;
Johan Pascalb62bb512015-12-03 21:56:45 +01001837 uint16_t server_protection_profile_value = 0;
1838
1839 /* If use_srtp is not configured, just ignore the extension */
Johan Pascalc3ccd982020-10-28 17:18:18 +01001840 if( ( ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM ) ||
1841 ( ssl->conf->dtls_srtp_profile_list == NULL ) ||
1842 ( ssl->conf->dtls_srtp_profile_list_len == 0 ) )
Johan Pascalb62bb512015-12-03 21:56:45 +01001843 return( 0 );
1844
Ron Eldora9788042018-12-05 11:04:31 +02001845 /* RFC 5764 section 4.1.1
Johan Pascalb62bb512015-12-03 21:56:45 +01001846 * uint8 SRTPProtectionProfile[2];
1847 *
1848 * struct {
1849 * SRTPProtectionProfiles SRTPProtectionProfiles;
1850 * opaque srtp_mki<0..255>;
1851 * } UseSRTPData;
1852
1853 * SRTPProtectionProfile SRTPProtectionProfiles<2..2^16-1>;
1854 *
Johan Pascalb62bb512015-12-03 21:56:45 +01001855 */
Johan Pascalf6417ec2020-09-22 15:15:19 +02001856 if( ssl->conf->dtls_srtp_mki_support == MBEDTLS_SSL_DTLS_SRTP_MKI_SUPPORTED )
Ron Eldor591f1622018-01-22 12:30:04 +02001857 {
1858 mki_len = ssl->dtls_srtp_info.mki_len;
1859 }
Johan Pascalb62bb512015-12-03 21:56:45 +01001860
Ron Eldoref72faf2018-07-12 11:54:20 +03001861 /*
Johan Pascal76fdf1d2020-10-22 23:31:00 +02001862 * Length is 5 + optional mki_value : one protection profile length (2 bytes)
1863 * + protection profile (2 bytes)
1864 * + mki_len(1 byte)
Ron Eldor313d7b52018-12-10 14:56:21 +02001865 * and optional srtp_mki
Ron Eldoref72faf2018-07-12 11:54:20 +03001866 */
Johan Pascaladbd9442020-10-26 21:24:25 +01001867 if( ( len < 5 ) || ( len != ( buf[4] + 5u ) ) )
Johan Pascalb62bb512015-12-03 21:56:45 +01001868 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
1869
1870 /*
1871 * get the server protection profile
1872 */
Ron Eldoref72faf2018-07-12 11:54:20 +03001873
1874 /*
1875 * protection profile length must be 0x0002 as we must have only
1876 * one protection profile in server Hello
1877 */
Ron Eldor089c9fe2018-12-06 17:12:49 +02001878 if( ( buf[0] != 0 ) || ( buf[1] != 2 ) )
Johan Pascalb62bb512015-12-03 21:56:45 +01001879 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Ron Eldor089c9fe2018-12-06 17:12:49 +02001880
1881 server_protection_profile_value = ( buf[2] << 8 ) | buf[3];
Johan Pascal43f94902020-09-22 12:25:52 +02001882 server_protection = mbedtls_ssl_check_srtp_profile_value(
1883 server_protection_profile_value );
1884 if( server_protection != MBEDTLS_TLS_SRTP_UNSET )
Ron Eldoref72faf2018-07-12 11:54:20 +03001885 {
Johan Pascal43f94902020-09-22 12:25:52 +02001886 MBEDTLS_SSL_DEBUG_MSG( 3, ( "found srtp profile: %s",
1887 mbedtls_ssl_get_srtp_profile_as_string(
1888 server_protection ) ) );
Johan Pascalb62bb512015-12-03 21:56:45 +01001889 }
1890
Johan Pascal43f94902020-09-22 12:25:52 +02001891 ssl->dtls_srtp_info.chosen_dtls_srtp_profile = MBEDTLS_TLS_SRTP_UNSET;
Ron Eldor591f1622018-01-22 12:30:04 +02001892
Johan Pascalb62bb512015-12-03 21:56:45 +01001893 /*
1894 * Check we have the server profile in our list
1895 */
Ron Eldor3adb9922017-12-21 10:15:08 +02001896 for( i=0; i < ssl->conf->dtls_srtp_profile_list_len; i++)
Johan Pascalb62bb512015-12-03 21:56:45 +01001897 {
Johan Pascal5ef72d22020-10-28 17:05:47 +01001898 if( server_protection == ssl->conf->dtls_srtp_profile_list[i] )
1899 {
Ron Eldor3adb9922017-12-21 10:15:08 +02001900 ssl->dtls_srtp_info.chosen_dtls_srtp_profile = ssl->conf->dtls_srtp_profile_list[i];
Johan Pascal43f94902020-09-22 12:25:52 +02001901 MBEDTLS_SSL_DEBUG_MSG( 3, ( "selected srtp profile: %s",
1902 mbedtls_ssl_get_srtp_profile_as_string(
1903 server_protection ) ) );
Ron Eldor591f1622018-01-22 12:30:04 +02001904 break;
Johan Pascalb62bb512015-12-03 21:56:45 +01001905 }
1906 }
1907
Ron Eldor591f1622018-01-22 12:30:04 +02001908 /* If no match was found : server problem, it shall never answer with incompatible profile */
Johan Pascal43f94902020-09-22 12:25:52 +02001909 if( ssl->dtls_srtp_info.chosen_dtls_srtp_profile == MBEDTLS_TLS_SRTP_UNSET )
Ron Eldor591f1622018-01-22 12:30:04 +02001910 {
1911 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
Ron Eldoref72faf2018-07-12 11:54:20 +03001912 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
Ron Eldor591f1622018-01-22 12:30:04 +02001913 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
1914 }
Johan Pascal20c7db32020-10-26 22:45:58 +01001915
1916 /* If server does not use mki in its reply, make sure the client won't keep
1917 * one as negotiated */
1918 if( len == 5 )
1919 {
1920 ssl->dtls_srtp_info.mki_len = 0;
1921 }
1922
Ron Eldoref72faf2018-07-12 11:54:20 +03001923 /*
1924 * RFC5764:
Ron Eldor591f1622018-01-22 12:30:04 +02001925 * If the client detects a nonzero-length MKI in the server's response
1926 * that is different than the one the client offered, then the client
1927 * MUST abort the handshake and SHOULD send an invalid_parameter alert.
1928 */
Ron Eldor313d7b52018-12-10 14:56:21 +02001929 if( len > 5 && ( buf[4] != mki_len ||
1930 ( memcmp( ssl->dtls_srtp_info.mki_value, &buf[5], mki_len ) ) ) )
Ron Eldor591f1622018-01-22 12:30:04 +02001931 {
1932 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1933 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
1934 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
1935 }
Ron Eldorb4655392018-07-05 18:25:39 +03001936#if defined (MBEDTLS_DEBUG_C)
Ron Eldoref72faf2018-07-12 11:54:20 +03001937 if( len > 5 )
Ron Eldorb4655392018-07-05 18:25:39 +03001938 {
Ron Eldora9788042018-12-05 11:04:31 +02001939 MBEDTLS_SSL_DEBUG_BUF( 3, "received mki", ssl->dtls_srtp_info.mki_value,
1940 ssl->dtls_srtp_info.mki_len );
Ron Eldorb4655392018-07-05 18:25:39 +03001941 }
1942#endif
Ron Eldora9788042018-12-05 11:04:31 +02001943 return( 0 );
Johan Pascalb62bb512015-12-03 21:56:45 +01001944}
1945#endif /* MBEDTLS_SSL_DTLS_SRTP */
1946
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001947/*
1948 * Parse HelloVerifyRequest. Only called after verifying the HS type.
1949 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001950#if defined(MBEDTLS_SSL_PROTO_DTLS)
1951static int ssl_parse_hello_verify_request( mbedtls_ssl_context *ssl )
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001952{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001953 const unsigned char *p = ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001954 int major_ver, minor_ver;
1955 unsigned char cookie_len;
1956
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001957 MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse hello verify request" ) );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001958
Gilles Peskineb64bf062019-09-27 14:02:44 +02001959 /* Check that there is enough room for:
1960 * - 2 bytes of version
1961 * - 1 byte of cookie_len
1962 */
1963 if( mbedtls_ssl_hs_hdr_len( ssl ) + 3 > ssl->in_msglen )
1964 {
1965 MBEDTLS_SSL_DEBUG_MSG( 1,
1966 ( "incoming HelloVerifyRequest message is too short" ) );
1967 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1968 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
1969 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
1970 }
1971
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001972 /*
1973 * struct {
1974 * ProtocolVersion server_version;
1975 * opaque cookie<0..2^8-1>;
1976 * } HelloVerifyRequest;
1977 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001978 MBEDTLS_SSL_DEBUG_BUF( 3, "server version", p, 2 );
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001979 mbedtls_ssl_read_version( &major_ver, &minor_ver, ssl->conf->transport, p );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001980 p += 2;
1981
Manuel Pégourié-Gonnardb35fe562014-08-09 17:00:46 +02001982 /*
1983 * Since the RFC is not clear on this point, accept DTLS 1.0 (TLS 1.1)
1984 * even is lower than our min version.
1985 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001986 if( major_ver < MBEDTLS_SSL_MAJOR_VERSION_3 ||
1987 minor_ver < MBEDTLS_SSL_MINOR_VERSION_2 ||
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02001988 major_ver > ssl->conf->max_major_ver ||
1989 minor_ver > ssl->conf->max_minor_ver )
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001990 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001991 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server version" ) );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001992
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001993 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1994 MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001995
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001996 return( MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02001997 }
1998
1999 cookie_len = *p++;
Andres AG5a87c932016-09-26 14:53:05 +01002000 if( ( ssl->in_msg + ssl->in_msglen ) - p < cookie_len )
2001 {
2002 MBEDTLS_SSL_DEBUG_MSG( 1,
2003 ( "cookie length does not match incoming message size" ) );
2004 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2005 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
2006 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
2007 }
Gilles Peskineb51130d2019-09-27 14:00:36 +02002008 MBEDTLS_SSL_DEBUG_BUF( 3, "cookie", p, cookie_len );
Andres AG5a87c932016-09-26 14:53:05 +01002009
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002010 mbedtls_free( ssl->handshake->verify_cookie );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02002011
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +02002012 ssl->handshake->verify_cookie = mbedtls_calloc( 1, cookie_len );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02002013 if( ssl->handshake->verify_cookie == NULL )
2014 {
Manuel Pégourié-Gonnardb2a18a22015-05-27 16:29:56 +02002015 MBEDTLS_SSL_DEBUG_MSG( 1, ( "alloc failed (%d bytes)", cookie_len ) );
Manuel Pégourié-Gonnard6a8ca332015-05-28 09:33:39 +02002016 return( MBEDTLS_ERR_SSL_ALLOC_FAILED );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02002017 }
2018
2019 memcpy( ssl->handshake->verify_cookie, p, cookie_len );
2020 ssl->handshake->verify_cookie_len = cookie_len;
2021
Manuel Pégourié-Gonnard67427c02014-07-11 13:45:34 +02002022 /* Start over at ClientHello */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002023 ssl->state = MBEDTLS_SSL_CLIENT_HELLO;
2024 mbedtls_ssl_reset_checksum( ssl );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02002025
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002026 mbedtls_ssl_recv_flight_completed( ssl );
Manuel Pégourié-Gonnard5d8ba532014-09-19 15:09:21 +02002027
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002028 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse hello verify request" ) );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02002029
2030 return( 0 );
2031}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002032#endif /* MBEDTLS_SSL_PROTO_DTLS */
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02002033
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002034static int ssl_parse_server_hello( mbedtls_ssl_context *ssl )
Paul Bakker5121ce52009-01-03 21:22:43 +00002035{
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02002036 int ret, i;
Paul Bakker23986e52011-04-24 08:57:21 +00002037 size_t n;
Manuel Pégourié-Gonnardf7cdbc02014-10-17 17:02:10 +02002038 size_t ext_len;
Paul Bakker48916f92012-09-16 19:57:18 +00002039 unsigned char *buf, *ext;
Manuel Pégourié-Gonnard1cf7b302015-06-24 22:28:19 +02002040 unsigned char comp;
2041#if defined(MBEDTLS_ZLIB_SUPPORT)
2042 int accept_comp;
2043#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002044#if defined(MBEDTLS_SSL_RENEGOTIATION)
Paul Bakker48916f92012-09-16 19:57:18 +00002045 int renegotiation_info_seen = 0;
Manuel Pégourié-Gonnardeaecbd32014-11-06 02:38:02 +01002046#endif
Paul Bakkerd0f6fa72012-09-17 09:18:12 +00002047 int handshake_failure = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002048 const mbedtls_ssl_ciphersuite_t *suite_info;
Paul Bakker5121ce52009-01-03 21:22:43 +00002049
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002050 MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse server hello" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00002051
Hanno Becker327c93b2018-08-15 13:56:18 +01002052 if( ( ret = mbedtls_ssl_read_record( ssl, 1 ) ) != 0 )
Paul Bakker5121ce52009-01-03 21:22:43 +00002053 {
Gilles Peskine1cc8e342017-05-03 16:28:34 +02002054 /* No alert on a read error. */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002055 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
Paul Bakker5121ce52009-01-03 21:22:43 +00002056 return( ret );
2057 }
2058
Hanno Becker79594fd2019-05-08 09:38:41 +01002059 buf = ssl->in_msg;
2060
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002061 if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
Paul Bakker5121ce52009-01-03 21:22:43 +00002062 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002063#if defined(MBEDTLS_SSL_RENEGOTIATION)
2064 if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
Manuel Pégourié-Gonnard65919622014-08-19 12:50:30 +02002065 {
Manuel Pégourié-Gonnard44ade652014-08-19 13:58:40 +02002066 ssl->renego_records_seen++;
2067
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02002068 if( ssl->conf->renego_max_records >= 0 &&
2069 ssl->renego_records_seen > ssl->conf->renego_max_records )
Manuel Pégourié-Gonnard44ade652014-08-19 13:58:40 +02002070 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002071 MBEDTLS_SSL_DEBUG_MSG( 1,
2072 ( "renegotiation requested, but not honored by server" ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002073 return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
Manuel Pégourié-Gonnard44ade652014-08-19 13:58:40 +02002074 }
2075
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002076 MBEDTLS_SSL_DEBUG_MSG( 1,
2077 ( "non-handshake message during renegotiation" ) );
Hanno Beckeraf0665d2017-05-24 09:16:26 +01002078
2079 ssl->keep_current_message = 1;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002080 return( MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO );
Manuel Pégourié-Gonnard65919622014-08-19 12:50:30 +02002081 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002082#endif /* MBEDTLS_SSL_RENEGOTIATION */
Manuel Pégourié-Gonnard65919622014-08-19 12:50:30 +02002083
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002084 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002085 mbedtls_ssl_send_alert_message(
2086 ssl,
2087 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2088 MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002089 return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
Paul Bakker5121ce52009-01-03 21:22:43 +00002090 }
2091
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002092#if defined(MBEDTLS_SSL_PROTO_DTLS)
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02002093 if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02002094 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002095 if( buf[0] == MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST )
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02002096 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002097 MBEDTLS_SSL_DEBUG_MSG( 2, ( "received hello verify request" ) );
2098 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse server hello" ) );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02002099 return( ssl_parse_hello_verify_request( ssl ) );
2100 }
2101 else
2102 {
2103 /* We made it through the verification process */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002104 mbedtls_free( ssl->handshake->verify_cookie );
Manuel Pégourié-Gonnard74848812014-07-11 02:43:49 +02002105 ssl->handshake->verify_cookie = NULL;
2106 ssl->handshake->verify_cookie_len = 0;
2107 }
2108 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002109#endif /* MBEDTLS_SSL_PROTO_DTLS */
Paul Bakker5121ce52009-01-03 21:22:43 +00002110
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002111 if( ssl->in_hslen < 38 + mbedtls_ssl_hs_hdr_len( ssl ) ||
2112 buf[0] != MBEDTLS_SSL_HS_SERVER_HELLO )
Paul Bakker5121ce52009-01-03 21:22:43 +00002113 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002114 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02002115 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2116 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002117 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Paul Bakker5121ce52009-01-03 21:22:43 +00002118 }
2119
Manuel Pégourié-Gonnard0b3400d2014-09-10 21:23:41 +02002120 /*
2121 * 0 . 1 server_version
2122 * 2 . 33 random (maybe including 4 bytes of Unix time)
2123 * 34 . 34 session_id length = n
2124 * 35 . 34+n session_id
2125 * 35+n . 36+n cipher_suite
2126 * 37+n . 37+n compression_method
2127 *
2128 * 38+n . 39+n extensions length (optional)
2129 * 40+n . .. extensions
2130 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002131 buf += mbedtls_ssl_hs_hdr_len( ssl );
Manuel Pégourié-Gonnard0b3400d2014-09-10 21:23:41 +02002132
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002133 MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, version", buf + 0, 2 );
2134 mbedtls_ssl_read_version( &ssl->major_ver, &ssl->minor_ver,
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02002135 ssl->conf->transport, buf + 0 );
Paul Bakker5121ce52009-01-03 21:22:43 +00002136
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02002137 if( ssl->major_ver < ssl->conf->min_major_ver ||
2138 ssl->minor_ver < ssl->conf->min_minor_ver ||
2139 ssl->major_ver > ssl->conf->max_major_ver ||
2140 ssl->minor_ver > ssl->conf->max_minor_ver )
Paul Bakker1d29fb52012-09-28 13:28:45 +00002141 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002142 MBEDTLS_SSL_DEBUG_MSG( 1,
2143 ( "server version out of bounds - min: [%d:%d], server: [%d:%d], max: [%d:%d]",
2144 ssl->conf->min_major_ver,
2145 ssl->conf->min_minor_ver,
2146 ssl->major_ver, ssl->minor_ver,
2147 ssl->conf->max_major_ver,
2148 ssl->conf->max_minor_ver ) );
Paul Bakker1d29fb52012-09-28 13:28:45 +00002149
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002150 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2151 MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION );
Paul Bakker1d29fb52012-09-28 13:28:45 +00002152
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002153 return( MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION );
Paul Bakker1d29fb52012-09-28 13:28:45 +00002154 }
2155
Andres Amaya Garcia6bce9cb2017-09-06 15:33:34 +01002156 MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, current time: %lu",
Paul Elliott9f352112020-12-09 14:55:45 +00002157 ( (unsigned long) buf[2] << 24 ) |
2158 ( (unsigned long) buf[3] << 16 ) |
2159 ( (unsigned long) buf[4] << 8 ) |
2160 ( (unsigned long) buf[5] ) ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00002161
Manuel Pégourié-Gonnard0b3400d2014-09-10 21:23:41 +02002162 memcpy( ssl->handshake->randbytes + 32, buf + 2, 32 );
Paul Bakker5121ce52009-01-03 21:22:43 +00002163
Manuel Pégourié-Gonnard0b3400d2014-09-10 21:23:41 +02002164 n = buf[34];
Paul Bakker5121ce52009-01-03 21:22:43 +00002165
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002166 MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, random bytes", buf + 2, 32 );
Paul Bakker5121ce52009-01-03 21:22:43 +00002167
Paul Bakker48916f92012-09-16 19:57:18 +00002168 if( n > 32 )
2169 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002170 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02002171 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2172 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002173 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Paul Bakker48916f92012-09-16 19:57:18 +00002174 }
2175
Manuel Pégourié-Gonnarda6e5bd52015-07-23 12:14:13 +02002176 if( ssl->in_hslen > mbedtls_ssl_hs_hdr_len( ssl ) + 39 + n )
Paul Bakker5121ce52009-01-03 21:22:43 +00002177 {
Manuel Pégourié-Gonnard0b3400d2014-09-10 21:23:41 +02002178 ext_len = ( ( buf[38 + n] << 8 )
2179 | ( buf[39 + n] ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00002180
Paul Bakker48916f92012-09-16 19:57:18 +00002181 if( ( ext_len > 0 && ext_len < 4 ) ||
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002182 ssl->in_hslen != mbedtls_ssl_hs_hdr_len( ssl ) + 40 + n + ext_len )
Paul Bakker48916f92012-09-16 19:57:18 +00002183 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002184 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002185 mbedtls_ssl_send_alert_message(
2186 ssl,
2187 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2188 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002189 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Paul Bakker48916f92012-09-16 19:57:18 +00002190 }
Paul Bakker5121ce52009-01-03 21:22:43 +00002191 }
Manuel Pégourié-Gonnarda6e5bd52015-07-23 12:14:13 +02002192 else if( ssl->in_hslen == mbedtls_ssl_hs_hdr_len( ssl ) + 38 + n )
Manuel Pégourié-Gonnardf7cdbc02014-10-17 17:02:10 +02002193 {
2194 ext_len = 0;
2195 }
2196 else
2197 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002198 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02002199 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2200 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002201 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Manuel Pégourié-Gonnardf7cdbc02014-10-17 17:02:10 +02002202 }
Paul Bakker5121ce52009-01-03 21:22:43 +00002203
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02002204 /* ciphersuite (used later) */
Manuel Pégourié-Gonnard0b3400d2014-09-10 21:23:41 +02002205 i = ( buf[35 + n] << 8 ) | buf[36 + n];
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02002206
2207 /*
2208 * Read and check compression
2209 */
Manuel Pégourié-Gonnard0b3400d2014-09-10 21:23:41 +02002210 comp = buf[37 + n];
Paul Bakker5121ce52009-01-03 21:22:43 +00002211
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002212#if defined(MBEDTLS_ZLIB_SUPPORT)
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02002213 /* See comments in ssl_write_client_hello() */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002214#if defined(MBEDTLS_SSL_PROTO_DTLS)
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02002215 if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02002216 accept_comp = 0;
Manuel Pégourié-Gonnard1cf7b302015-06-24 22:28:19 +02002217 else
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02002218#endif
Manuel Pégourié-Gonnard1cf7b302015-06-24 22:28:19 +02002219 accept_comp = 1;
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02002220
Manuel Pégourié-Gonnard1cf7b302015-06-24 22:28:19 +02002221 if( comp != MBEDTLS_SSL_COMPRESS_NULL &&
2222 ( comp != MBEDTLS_SSL_COMPRESS_DEFLATE || accept_comp == 0 ) )
2223#else /* MBEDTLS_ZLIB_SUPPORT */
2224 if( comp != MBEDTLS_SSL_COMPRESS_NULL )
2225#endif/* MBEDTLS_ZLIB_SUPPORT */
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02002226 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002227 MBEDTLS_SSL_DEBUG_MSG( 1,
2228 ( "server hello, bad compression: %d", comp ) );
2229 mbedtls_ssl_send_alert_message(
2230 ssl,
2231 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2232 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002233 return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
Manuel Pégourié-Gonnarda0e16322014-07-14 17:38:41 +02002234 }
2235
Paul Bakker380da532012-04-18 16:10:25 +00002236 /*
2237 * Initialize update checksum functions
2238 */
Hanno Beckere694c3e2017-12-27 21:34:08 +00002239 ssl->handshake->ciphersuite_info = mbedtls_ssl_ciphersuite_from_id( i );
2240 if( ssl->handshake->ciphersuite_info == NULL )
Paul Bakker68884e32013-01-07 18:20:04 +01002241 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002242 MBEDTLS_SSL_DEBUG_MSG( 1,
Paul Elliott9f352112020-12-09 14:55:45 +00002243 ( "ciphersuite info for %04x not found", (unsigned int)i ) );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02002244 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2245 MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002246 return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
Paul Bakker68884e32013-01-07 18:20:04 +01002247 }
Paul Bakker380da532012-04-18 16:10:25 +00002248
Hanno Beckere694c3e2017-12-27 21:34:08 +00002249 mbedtls_ssl_optimize_checksum( ssl, ssl->handshake->ciphersuite_info );
Manuel Pégourié-Gonnard3c599f12014-03-10 13:25:07 +01002250
Paul Elliottd48d5c62021-01-07 14:47:05 +00002251 MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, session id len.: %" MBEDTLS_PRINTF_SIZET, n ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002252 MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, session id", buf + 35, n );
Paul Bakker5121ce52009-01-03 21:22:43 +00002253
2254 /*
2255 * Check if the session can be resumed
2256 */
Manuel Pégourié-Gonnard615e6772014-11-03 08:23:14 +01002257 if( ssl->handshake->resume == 0 || n == 0 ||
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002258#if defined(MBEDTLS_SSL_RENEGOTIATION)
2259 ssl->renego_status != MBEDTLS_SSL_INITIAL_HANDSHAKE ||
Manuel Pégourié-Gonnard615e6772014-11-03 08:23:14 +01002260#endif
Paul Bakker48916f92012-09-16 19:57:18 +00002261 ssl->session_negotiate->ciphersuite != i ||
2262 ssl->session_negotiate->compression != comp ||
Manuel Pégourié-Gonnard12ad7982015-06-18 15:50:37 +02002263 ssl->session_negotiate->id_len != n ||
Manuel Pégourié-Gonnard0b3400d2014-09-10 21:23:41 +02002264 memcmp( ssl->session_negotiate->id, buf + 35, n ) != 0 )
Paul Bakker5121ce52009-01-03 21:22:43 +00002265 {
2266 ssl->state++;
Paul Bakker0a597072012-09-25 21:55:46 +00002267 ssl->handshake->resume = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002268#if defined(MBEDTLS_HAVE_TIME)
SimonBd5800b72016-04-26 07:43:27 +01002269 ssl->session_negotiate->start = mbedtls_time( NULL );
Paul Bakkerfa9b1002013-07-03 15:31:03 +02002270#endif
Paul Bakker48916f92012-09-16 19:57:18 +00002271 ssl->session_negotiate->ciphersuite = i;
2272 ssl->session_negotiate->compression = comp;
Manuel Pégourié-Gonnard12ad7982015-06-18 15:50:37 +02002273 ssl->session_negotiate->id_len = n;
Manuel Pégourié-Gonnard0b3400d2014-09-10 21:23:41 +02002274 memcpy( ssl->session_negotiate->id, buf + 35, n );
Paul Bakker5121ce52009-01-03 21:22:43 +00002275 }
2276 else
2277 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002278 ssl->state = MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC;
Paul Bakker5121ce52009-01-03 21:22:43 +00002279 }
2280
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002281 MBEDTLS_SSL_DEBUG_MSG( 3, ( "%s session has been resumed",
Paul Bakker0a597072012-09-25 21:55:46 +00002282 ssl->handshake->resume ? "a" : "no" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00002283
Paul Elliott3891caf2020-12-17 18:42:40 +00002284 MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, chosen ciphersuite: %04x", (unsigned) i ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002285 MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, compress alg.: %d",
2286 buf[37 + n] ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00002287
Andrzej Kurek03bac442018-04-25 05:06:07 -04002288 /*
2289 * Perform cipher suite validation in same way as in ssl_write_client_hello.
Mohammad Azim Khan1d3b5082018-04-18 19:35:00 +01002290 */
Paul Bakker5121ce52009-01-03 21:22:43 +00002291 i = 0;
2292 while( 1 )
2293 {
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02002294 if( ssl->conf->ciphersuite_list[ssl->minor_ver][i] == 0 )
Paul Bakker5121ce52009-01-03 21:22:43 +00002295 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002296 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002297 mbedtls_ssl_send_alert_message(
2298 ssl,
2299 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2300 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002301 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Paul Bakker5121ce52009-01-03 21:22:43 +00002302 }
2303
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02002304 if( ssl->conf->ciphersuite_list[ssl->minor_ver][i++] ==
Paul Bakker8f4ddae2013-04-15 15:09:54 +02002305 ssl->session_negotiate->ciphersuite )
2306 {
Paul Bakker5121ce52009-01-03 21:22:43 +00002307 break;
Paul Bakker8f4ddae2013-04-15 15:09:54 +02002308 }
Paul Bakker5121ce52009-01-03 21:22:43 +00002309 }
2310
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002311 suite_info = mbedtls_ssl_ciphersuite_from_id(
2312 ssl->session_negotiate->ciphersuite );
2313 if( ssl_validate_ciphersuite( suite_info, ssl, ssl->minor_ver,
2314 ssl->minor_ver ) != 0 )
Mohammad Azim Khan1d3b5082018-04-18 19:35:00 +01002315 {
2316 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002317 mbedtls_ssl_send_alert_message(
2318 ssl,
2319 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2320 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Mohammad Azim Khan1d3b5082018-04-18 19:35:00 +01002321 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
2322 }
2323
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002324 MBEDTLS_SSL_DEBUG_MSG( 3,
2325 ( "server hello, chosen ciphersuite: %s", suite_info->name ) );
Mohammad Azim Khan1d3b5082018-04-18 19:35:00 +01002326
Gilles Peskineeccd8882020-03-10 12:19:08 +01002327#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002328 if( suite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA &&
2329 ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
2330 {
2331 ssl->handshake->ecrs_enabled = 1;
2332 }
2333#endif
2334
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002335 if( comp != MBEDTLS_SSL_COMPRESS_NULL
2336#if defined(MBEDTLS_ZLIB_SUPPORT)
2337 && comp != MBEDTLS_SSL_COMPRESS_DEFLATE
Paul Bakker2770fbd2012-07-03 13:30:23 +00002338#endif
2339 )
Paul Bakker5121ce52009-01-03 21:22:43 +00002340 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002341 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002342 mbedtls_ssl_send_alert_message(
2343 ssl,
2344 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2345 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002346 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Paul Bakker5121ce52009-01-03 21:22:43 +00002347 }
Paul Bakker48916f92012-09-16 19:57:18 +00002348 ssl->session_negotiate->compression = comp;
Paul Bakker5121ce52009-01-03 21:22:43 +00002349
Manuel Pégourié-Gonnard0b3400d2014-09-10 21:23:41 +02002350 ext = buf + 40 + n;
Paul Bakker48916f92012-09-16 19:57:18 +00002351
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002352 MBEDTLS_SSL_DEBUG_MSG( 2,
Paul Elliottd48d5c62021-01-07 14:47:05 +00002353 ( "server hello, total extension length: %" MBEDTLS_PRINTF_SIZET, ext_len ) );
Manuel Pégourié-Gonnarda0528492013-07-16 17:26:28 +02002354
Paul Bakker48916f92012-09-16 19:57:18 +00002355 while( ext_len )
2356 {
2357 unsigned int ext_id = ( ( ext[0] << 8 )
2358 | ( ext[1] ) );
2359 unsigned int ext_size = ( ( ext[2] << 8 )
2360 | ( ext[3] ) );
2361
2362 if( ext_size + 4 > ext_len )
2363 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002364 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002365 mbedtls_ssl_send_alert_message(
2366 ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2367 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002368 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Paul Bakker48916f92012-09-16 19:57:18 +00002369 }
2370
2371 switch( ext_id )
2372 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002373 case MBEDTLS_TLS_EXT_RENEGOTIATION_INFO:
2374 MBEDTLS_SSL_DEBUG_MSG( 3, ( "found renegotiation extension" ) );
2375#if defined(MBEDTLS_SSL_RENEGOTIATION)
Paul Bakker48916f92012-09-16 19:57:18 +00002376 renegotiation_info_seen = 1;
Manuel Pégourié-Gonnardeaecbd32014-11-06 02:38:02 +01002377#endif
Paul Bakker48916f92012-09-16 19:57:18 +00002378
Paul Bakkerb9e4e2c2014-05-01 14:18:25 +02002379 if( ( ret = ssl_parse_renegotiation_info( ssl, ext + 4,
2380 ext_size ) ) != 0 )
Paul Bakker48916f92012-09-16 19:57:18 +00002381 return( ret );
2382
2383 break;
2384
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002385#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
2386 case MBEDTLS_TLS_EXT_MAX_FRAGMENT_LENGTH:
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002387 MBEDTLS_SSL_DEBUG_MSG( 3,
2388 ( "found max_fragment_length extension" ) );
Manuel Pégourié-Gonnardde600e52013-07-17 10:14:38 +02002389
2390 if( ( ret = ssl_parse_max_fragment_length_ext( ssl,
2391 ext + 4, ext_size ) ) != 0 )
2392 {
2393 return( ret );
2394 }
2395
2396 break;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002397#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
Manuel Pégourié-Gonnardde600e52013-07-17 10:14:38 +02002398
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002399#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
2400 case MBEDTLS_TLS_EXT_TRUNCATED_HMAC:
2401 MBEDTLS_SSL_DEBUG_MSG( 3, ( "found truncated_hmac extension" ) );
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +02002402
2403 if( ( ret = ssl_parse_truncated_hmac_ext( ssl,
2404 ext + 4, ext_size ) ) != 0 )
2405 {
2406 return( ret );
2407 }
2408
2409 break;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002410#endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
Manuel Pégourié-Gonnard57c28522013-07-19 11:41:43 +02002411
Hanno Beckera0e20d02019-05-15 14:03:01 +01002412#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
Hanno Beckera8373a12019-04-26 15:37:26 +01002413 case MBEDTLS_TLS_EXT_CID:
2414 MBEDTLS_SSL_DEBUG_MSG( 3, ( "found CID extension" ) );
2415
2416 if( ( ret = ssl_parse_cid_ext( ssl,
2417 ext + 4,
2418 ext_size ) ) != 0 )
2419 {
2420 return( ret );
2421 }
2422
2423 break;
Hanno Beckera0e20d02019-05-15 14:03:01 +01002424#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
Hanno Beckera8373a12019-04-26 15:37:26 +01002425
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002426#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
2427 case MBEDTLS_TLS_EXT_ENCRYPT_THEN_MAC:
2428 MBEDTLS_SSL_DEBUG_MSG( 3, ( "found encrypt_then_mac extension" ) );
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +01002429
2430 if( ( ret = ssl_parse_encrypt_then_mac_ext( ssl,
2431 ext + 4, ext_size ) ) != 0 )
2432 {
2433 return( ret );
2434 }
2435
2436 break;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002437#endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
Manuel Pégourié-Gonnard699cafa2014-10-27 13:57:03 +01002438
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002439#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
2440 case MBEDTLS_TLS_EXT_EXTENDED_MASTER_SECRET:
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002441 MBEDTLS_SSL_DEBUG_MSG( 3,
2442 ( "found extended_master_secret extension" ) );
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +02002443
2444 if( ( ret = ssl_parse_extended_ms_ext( ssl,
2445 ext + 4, ext_size ) ) != 0 )
2446 {
2447 return( ret );
2448 }
2449
2450 break;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002451#endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
Manuel Pégourié-Gonnard367381f2014-10-20 18:40:56 +02002452
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002453#if defined(MBEDTLS_SSL_SESSION_TICKETS)
2454 case MBEDTLS_TLS_EXT_SESSION_TICKET:
2455 MBEDTLS_SSL_DEBUG_MSG( 3, ( "found session_ticket extension" ) );
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +02002456
2457 if( ( ret = ssl_parse_session_ticket_ext( ssl,
2458 ext + 4, ext_size ) ) != 0 )
2459 {
2460 return( ret );
2461 }
2462
2463 break;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002464#endif /* MBEDTLS_SSL_SESSION_TICKETS */
Manuel Pégourié-Gonnard60182ef2013-08-02 14:44:54 +02002465
Robert Cragie136884c2015-10-02 13:34:31 +01002466#if defined(MBEDTLS_ECDH_C) || defined(MBEDTLS_ECDSA_C) || \
Robert Cragieae8535d2015-10-06 17:11:18 +01002467 defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002468 case MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS:
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002469 MBEDTLS_SSL_DEBUG_MSG( 3,
2470 ( "found supported_point_formats extension" ) );
Manuel Pégourié-Gonnard7b19c162013-08-15 18:01:11 +02002471
2472 if( ( ret = ssl_parse_supported_point_formats_ext( ssl,
2473 ext + 4, ext_size ) ) != 0 )
2474 {
2475 return( ret );
2476 }
2477
2478 break;
Robert Cragieae8535d2015-10-06 17:11:18 +01002479#endif /* MBEDTLS_ECDH_C || MBEDTLS_ECDSA_C ||
2480 MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
Manuel Pégourié-Gonnard7b19c162013-08-15 18:01:11 +02002481
Manuel Pégourié-Gonnard0a1324a2015-09-16 16:01:00 +02002482#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
2483 case MBEDTLS_TLS_EXT_ECJPAKE_KKPP:
2484 MBEDTLS_SSL_DEBUG_MSG( 3, ( "found ecjpake_kkpp extension" ) );
2485
2486 if( ( ret = ssl_parse_ecjpake_kkpp( ssl,
2487 ext + 4, ext_size ) ) != 0 )
2488 {
2489 return( ret );
2490 }
2491
2492 break;
2493#endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
Paul Bakkerd0f6fa72012-09-17 09:18:12 +00002494
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002495#if defined(MBEDTLS_SSL_ALPN)
2496 case MBEDTLS_TLS_EXT_ALPN:
2497 MBEDTLS_SSL_DEBUG_MSG( 3, ( "found alpn extension" ) );
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +02002498
Johan Pascal275874b2020-10-27 10:43:53 +01002499 if( ( ret = ssl_parse_alpn_ext( ssl, ext + 4, ext_size ) ) != 0 )
2500 return( ret );
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +02002501
2502 break;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002503#endif /* MBEDTLS_SSL_ALPN */
Manuel Pégourié-Gonnard0b874dc2014-04-07 10:57:45 +02002504
Johan Pascalb62bb512015-12-03 21:56:45 +01002505#if defined(MBEDTLS_SSL_DTLS_SRTP)
2506 case MBEDTLS_TLS_EXT_USE_SRTP:
2507 MBEDTLS_SSL_DEBUG_MSG( 3, ( "found use_srtp extension" ) );
2508
Johan Pascalc3ccd982020-10-28 17:18:18 +01002509 if( ( ret = ssl_parse_use_srtp_ext( ssl, ext + 4, ext_size ) ) != 0 )
2510 return( ret );
Johan Pascalb62bb512015-12-03 21:56:45 +01002511
2512 break;
2513#endif /* MBEDTLS_SSL_DTLS_SRTP */
2514
Paul Bakker48916f92012-09-16 19:57:18 +00002515 default:
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002516 MBEDTLS_SSL_DEBUG_MSG( 3,
Paul Elliott9f352112020-12-09 14:55:45 +00002517 ( "unknown extension found: %u (ignoring)", ext_id ) );
Paul Bakker48916f92012-09-16 19:57:18 +00002518 }
2519
2520 ext_len -= 4 + ext_size;
2521 ext += 4 + ext_size;
2522
2523 if( ext_len > 0 && ext_len < 4 )
2524 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002525 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
2526 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Paul Bakker48916f92012-09-16 19:57:18 +00002527 }
2528 }
2529
Andrzej Kurekc87d97b2022-06-14 07:12:33 -04002530 if( ssl->state == MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC )
2531 {
2532 if( ( ret = mbedtls_ssl_derive_keys( ssl ) ) != 0 )
2533 {
2534 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_derive_keys", ret );
2535 mbedtls_ssl_send_alert_message(
2536 ssl,
2537 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2538 MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR );
2539 return( ret );
2540 }
2541 }
2542
Paul Bakker48916f92012-09-16 19:57:18 +00002543 /*
2544 * Renegotiation security checks
2545 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002546 if( ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002547 ssl->conf->allow_legacy_renegotiation ==
2548 MBEDTLS_SSL_LEGACY_BREAK_HANDSHAKE )
Paul Bakker48916f92012-09-16 19:57:18 +00002549 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002550 MBEDTLS_SSL_DEBUG_MSG( 1,
2551 ( "legacy renegotiation, breaking off handshake" ) );
Paul Bakker48916f92012-09-16 19:57:18 +00002552 handshake_failure = 1;
2553 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002554#if defined(MBEDTLS_SSL_RENEGOTIATION)
2555 else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
2556 ssl->secure_renegotiation == MBEDTLS_SSL_SECURE_RENEGOTIATION &&
Paul Bakker48916f92012-09-16 19:57:18 +00002557 renegotiation_info_seen == 0 )
2558 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002559 MBEDTLS_SSL_DEBUG_MSG( 1,
2560 ( "renegotiation_info extension missing (secure)" ) );
Paul Bakker48916f92012-09-16 19:57:18 +00002561 handshake_failure = 1;
2562 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002563 else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
2564 ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002565 ssl->conf->allow_legacy_renegotiation ==
2566 MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION )
Paul Bakker48916f92012-09-16 19:57:18 +00002567 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002568 MBEDTLS_SSL_DEBUG_MSG( 1, ( "legacy renegotiation not allowed" ) );
Paul Bakkerd0f6fa72012-09-17 09:18:12 +00002569 handshake_failure = 1;
2570 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002571 else if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS &&
2572 ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION &&
Paul Bakkerd0f6fa72012-09-17 09:18:12 +00002573 renegotiation_info_seen == 1 )
2574 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002575 MBEDTLS_SSL_DEBUG_MSG( 1,
2576 ( "renegotiation_info extension present (legacy)" ) );
Paul Bakkerd0f6fa72012-09-17 09:18:12 +00002577 handshake_failure = 1;
2578 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002579#endif /* MBEDTLS_SSL_RENEGOTIATION */
Paul Bakkerd0f6fa72012-09-17 09:18:12 +00002580
2581 if( handshake_failure == 1 )
2582 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002583 mbedtls_ssl_send_alert_message(
2584 ssl,
2585 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
2586 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002587 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO );
Paul Bakker48916f92012-09-16 19:57:18 +00002588 }
Paul Bakker5121ce52009-01-03 21:22:43 +00002589
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002590 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse server hello" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00002591
2592 return( 0 );
2593}
2594
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002595#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
2596 defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002597static int ssl_parse_server_dh_params( mbedtls_ssl_context *ssl,
2598 unsigned char **p,
Paul Bakker29e1f122013-04-16 13:07:56 +02002599 unsigned char *end )
2600{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002601 int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
Gilles Peskinee8a2fc82020-12-08 22:46:11 +01002602 size_t dhm_actual_bitlen;
Paul Bakker29e1f122013-04-16 13:07:56 +02002603
Paul Bakker29e1f122013-04-16 13:07:56 +02002604 /*
2605 * Ephemeral DH parameters:
2606 *
2607 * struct {
2608 * opaque dh_p<1..2^16-1>;
2609 * opaque dh_g<1..2^16-1>;
2610 * opaque dh_Ys<1..2^16-1>;
2611 * } ServerDHParams;
2612 */
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002613 if( ( ret = mbedtls_dhm_read_params( &ssl->handshake->dhm_ctx,
2614 p, end ) ) != 0 )
Paul Bakker29e1f122013-04-16 13:07:56 +02002615 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002616 MBEDTLS_SSL_DEBUG_RET( 2, ( "mbedtls_dhm_read_params" ), ret );
Paul Bakker29e1f122013-04-16 13:07:56 +02002617 return( ret );
2618 }
2619
Gilles Peskinee8a2fc82020-12-08 22:46:11 +01002620 dhm_actual_bitlen = mbedtls_mpi_bitlen( &ssl->handshake->dhm_ctx.P );
2621 if( dhm_actual_bitlen < ssl->conf->dhm_min_bitlen )
Paul Bakker29e1f122013-04-16 13:07:56 +02002622 {
Paul Elliottd48d5c62021-01-07 14:47:05 +00002623 MBEDTLS_SSL_DEBUG_MSG( 1, ( "DHM prime too short: %" MBEDTLS_PRINTF_SIZET " < %u",
Gilles Peskinee8a2fc82020-12-08 22:46:11 +01002624 dhm_actual_bitlen,
Manuel Pégourié-Gonnardbd990d62015-06-11 14:49:42 +02002625 ssl->conf->dhm_min_bitlen ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002626 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
Paul Bakker29e1f122013-04-16 13:07:56 +02002627 }
2628
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002629 MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: P ", &ssl->handshake->dhm_ctx.P );
2630 MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: G ", &ssl->handshake->dhm_ctx.G );
2631 MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: GY", &ssl->handshake->dhm_ctx.GY );
Paul Bakker29e1f122013-04-16 13:07:56 +02002632
2633 return( ret );
2634}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002635#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED ||
2636 MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
Paul Bakker29e1f122013-04-16 13:07:56 +02002637
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002638#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
2639 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
2640 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) || \
2641 defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
2642 defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
2643static int ssl_check_server_ecdh_params( const mbedtls_ssl_context *ssl )
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01002644{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002645 const mbedtls_ecp_curve_info *curve_info;
Andrzej Kurekc470b6b2019-01-31 08:20:20 -05002646 mbedtls_ecp_group_id grp_id;
2647#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
2648 grp_id = ssl->handshake->ecdh_ctx.grp.id;
2649#else
2650 grp_id = ssl->handshake->ecdh_ctx.grp_id;
2651#endif
Manuel Pégourié-Gonnardc3f6b62c2014-02-06 10:13:09 +01002652
Andrzej Kurekc470b6b2019-01-31 08:20:20 -05002653 curve_info = mbedtls_ecp_curve_info_from_grp_id( grp_id );
Manuel Pégourié-Gonnardc3f6b62c2014-02-06 10:13:09 +01002654 if( curve_info == NULL )
2655 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002656 MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
2657 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Manuel Pégourié-Gonnardc3f6b62c2014-02-06 10:13:09 +01002658 }
2659
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002660 MBEDTLS_SSL_DEBUG_MSG( 2, ( "ECDH curve: %s", curve_info->name ) );
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01002661
Manuel Pégourié-Gonnardb541da62015-06-17 11:43:30 +02002662#if defined(MBEDTLS_ECP_C)
Andrzej Kurekc470b6b2019-01-31 08:20:20 -05002663 if( mbedtls_ssl_check_curve( ssl, grp_id ) != 0 )
Manuel Pégourié-Gonnardab240102014-02-04 16:18:07 +01002664#else
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01002665 if( ssl->handshake->ecdh_ctx.grp.nbits < 163 ||
2666 ssl->handshake->ecdh_ctx.grp.nbits > 521 )
Manuel Pégourié-Gonnardab240102014-02-04 16:18:07 +01002667#endif
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01002668 return( -1 );
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01002669
Andrzej Kurekc470b6b2019-01-31 08:20:20 -05002670 MBEDTLS_SSL_DEBUG_ECDH( 3, &ssl->handshake->ecdh_ctx,
2671 MBEDTLS_DEBUG_ECDH_QP );
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01002672
2673 return( 0 );
2674}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002675#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
2676 MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
2677 MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED ||
2678 MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
2679 MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01002680
Hanno Beckerbb89e272019-01-08 12:54:37 +00002681#if defined(MBEDTLS_USE_PSA_CRYPTO) && \
2682 ( defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
2683 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) )
2684static int ssl_parse_server_ecdh_params_psa( mbedtls_ssl_context *ssl,
2685 unsigned char **p,
2686 unsigned char *end )
2687{
2688 uint16_t tls_id;
Gilles Peskine42459802019-12-19 13:31:53 +01002689 size_t ecdh_bits = 0;
Hanno Beckerbb89e272019-01-08 12:54:37 +00002690 uint8_t ecpoint_len;
2691 mbedtls_ssl_handshake_params *handshake = ssl->handshake;
2692
2693 /*
2694 * Parse ECC group
2695 */
2696
2697 if( end - *p < 4 )
2698 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
2699
2700 /* First byte is curve_type; only named_curve is handled */
2701 if( *(*p)++ != MBEDTLS_ECP_TLS_NAMED_CURVE )
2702 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
2703
2704 /* Next two bytes are the namedcurve value */
2705 tls_id = *(*p)++;
2706 tls_id <<= 8;
2707 tls_id |= *(*p)++;
2708
Manuel Pégourié-Gonnard01784872022-01-25 11:46:19 +01002709 /* Check it's a curve we offered */
2710 if( mbedtls_ssl_check_curve_tls_id( ssl, tls_id ) != 0 )
2711 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
2712
Hanno Beckerbb89e272019-01-08 12:54:37 +00002713 /* Convert EC group to PSA key type. */
Gilles Peskine42459802019-12-19 13:31:53 +01002714 if( ( handshake->ecdh_psa_type =
2715 mbedtls_psa_parse_tls_ecc_group( tls_id, &ecdh_bits ) ) == 0 )
Hanno Beckerbb89e272019-01-08 12:54:37 +00002716 {
2717 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
2718 }
Gilles Peskine42459802019-12-19 13:31:53 +01002719 if( ecdh_bits > 0xffff )
2720 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
2721 handshake->ecdh_bits = (uint16_t) ecdh_bits;
Hanno Beckerbb89e272019-01-08 12:54:37 +00002722
2723 /*
2724 * Put peer's ECDH public key in the format understood by PSA.
2725 */
2726
2727 ecpoint_len = *(*p)++;
2728 if( (size_t)( end - *p ) < ecpoint_len )
2729 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
2730
Gilles Peskine42459802019-12-19 13:31:53 +01002731 if( mbedtls_psa_tls_ecpoint_to_psa_ec(
Hanno Beckerbb89e272019-01-08 12:54:37 +00002732 *p, ecpoint_len,
2733 handshake->ecdh_psa_peerkey,
2734 sizeof( handshake->ecdh_psa_peerkey ),
2735 &handshake->ecdh_psa_peerkey_len ) != 0 )
2736 {
2737 return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
2738 }
2739
2740 *p += ecpoint_len;
2741 return( 0 );
2742}
2743#endif /* MBEDTLS_USE_PSA_CRYPTO &&
2744 ( MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
2745 MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ) */
2746
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002747#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
2748 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
2749 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
2750static int ssl_parse_server_ecdh_params( mbedtls_ssl_context *ssl,
Paul Bakker29e1f122013-04-16 13:07:56 +02002751 unsigned char **p,
2752 unsigned char *end )
2753{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002754 int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
Paul Bakker29e1f122013-04-16 13:07:56 +02002755
Paul Bakker29e1f122013-04-16 13:07:56 +02002756 /*
2757 * Ephemeral ECDH parameters:
2758 *
2759 * struct {
2760 * ECParameters curve_params;
2761 * ECPoint public;
2762 * } ServerECDHParams;
2763 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002764 if( ( ret = mbedtls_ecdh_read_params( &ssl->handshake->ecdh_ctx,
Paul Bakker29e1f122013-04-16 13:07:56 +02002765 (const unsigned char **) p, end ) ) != 0 )
2766 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002767 MBEDTLS_SSL_DEBUG_RET( 1, ( "mbedtls_ecdh_read_params" ), ret );
Gilles Peskineeccd8882020-03-10 12:19:08 +01002768#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnard1c1c20e2018-09-12 10:34:43 +02002769 if( ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
2770 ret = MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS;
Manuel Pégourié-Gonnard558da9c2018-06-13 12:02:12 +02002771#endif
Paul Bakker29e1f122013-04-16 13:07:56 +02002772 return( ret );
2773 }
2774
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01002775 if( ssl_check_server_ecdh_params( ssl ) != 0 )
Paul Bakker29e1f122013-04-16 13:07:56 +02002776 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002777 MBEDTLS_SSL_DEBUG_MSG( 1,
2778 ( "bad server key exchange message (ECDHE curve)" ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002779 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
Paul Bakker29e1f122013-04-16 13:07:56 +02002780 }
2781
Paul Bakker29e1f122013-04-16 13:07:56 +02002782 return( ret );
2783}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002784#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
2785 MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
2786 MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
Paul Bakker29e1f122013-04-16 13:07:56 +02002787
Gilles Peskineeccd8882020-03-10 12:19:08 +01002788#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002789static int ssl_parse_server_psk_hint( mbedtls_ssl_context *ssl,
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02002790 unsigned char **p,
2791 unsigned char *end )
2792{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002793 int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
irwir6527bd62019-09-21 18:51:25 +03002794 uint16_t len;
Paul Bakkerc5a79cc2013-06-26 15:08:35 +02002795 ((void) ssl);
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02002796
2797 /*
2798 * PSK parameters:
2799 *
2800 * opaque psk_identity_hint<0..2^16-1>;
2801 */
Hanno Becker0c161d12018-10-08 13:40:50 +01002802 if( end - (*p) < 2 )
Krzysztof Stachowiak740b2182018-03-13 11:31:14 +01002803 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002804 MBEDTLS_SSL_DEBUG_MSG( 1,
2805 ( "bad server key exchange message (psk_identity_hint length)" ) );
Krzysztof Stachowiak740b2182018-03-13 11:31:14 +01002806 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
2807 }
Manuel Pégourié-Gonnard59b9fe22013-10-15 11:55:33 +02002808 len = (*p)[0] << 8 | (*p)[1];
Paul Bakker48f7a5d2013-04-19 14:30:58 +02002809 *p += 2;
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02002810
irwir6527bd62019-09-21 18:51:25 +03002811 if( end - (*p) < len )
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02002812 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002813 MBEDTLS_SSL_DEBUG_MSG( 1,
2814 ( "bad server key exchange message (psk_identity_hint length)" ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002815 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02002816 }
2817
Manuel Pégourié-Gonnard9d624122016-02-22 11:10:14 +01002818 /*
2819 * Note: we currently ignore the PKS identity hint, as we only allow one
2820 * PSK to be provisionned on the client. This could be changed later if
2821 * someone needs that feature.
2822 */
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02002823 *p += len;
Paul Bakker48f7a5d2013-04-19 14:30:58 +02002824 ret = 0;
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02002825
2826 return( ret );
2827}
Gilles Peskineeccd8882020-03-10 12:19:08 +01002828#endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02002829
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002830#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) || \
2831 defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002832/*
2833 * Generate a pre-master secret and encrypt it with the server's RSA key
2834 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002835static int ssl_write_encrypted_pms( mbedtls_ssl_context *ssl,
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002836 size_t offset, size_t *olen,
2837 size_t pms_offset )
2838{
Janos Follath865b3eb2019-12-16 11:46:15 +00002839 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002840 size_t len_bytes = ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 ? 0 : 2;
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002841 unsigned char *p = ssl->handshake->premaster + pms_offset;
Hanno Beckerc7d7e292019-02-06 16:49:54 +00002842 mbedtls_pk_context * peer_pk;
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002843
Angus Grattond8213d02016-05-25 20:56:48 +10002844 if( offset + len_bytes > MBEDTLS_SSL_OUT_CONTENT_LEN )
Manuel Pégourié-Gonnardc6b5d832015-08-27 16:37:35 +02002845 {
2846 MBEDTLS_SSL_DEBUG_MSG( 1, ( "buffer too small for encrypted pms" ) );
2847 return( MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
2848 }
2849
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002850 /*
2851 * Generate (part of) the pre-master as
2852 * struct {
2853 * ProtocolVersion client_version;
2854 * opaque random[46];
2855 * } PreMasterSecret;
2856 */
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002857 mbedtls_ssl_write_version( ssl->conf->max_major_ver,
2858 ssl->conf->max_minor_ver,
2859 ssl->conf->transport, p );
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002860
Manuel Pégourié-Gonnard750e4d72015-05-07 12:35:38 +01002861 if( ( ret = ssl->conf->f_rng( ssl->conf->p_rng, p + 2, 46 ) ) != 0 )
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002862 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002863 MBEDTLS_SSL_DEBUG_RET( 1, "f_rng", ret );
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002864 return( ret );
2865 }
2866
2867 ssl->handshake->pmslen = 48;
2868
Hanno Beckerc7d7e292019-02-06 16:49:54 +00002869#if !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
2870 peer_pk = &ssl->handshake->peer_pubkey;
2871#else /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
Manuel Pégourié-Gonnard7f2f0622015-09-03 10:44:32 +02002872 if( ssl->session_negotiate->peer_cert == NULL )
2873 {
Hanno Becker8273df82019-02-06 17:37:32 +00002874 /* Should never happen */
Hanno Becker62d58ed2019-02-26 11:51:06 +00002875 MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
Hanno Becker8273df82019-02-06 17:37:32 +00002876 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Manuel Pégourié-Gonnard7f2f0622015-09-03 10:44:32 +02002877 }
Hanno Beckerc7d7e292019-02-06 16:49:54 +00002878 peer_pk = &ssl->session_negotiate->peer_cert->pk;
2879#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
Manuel Pégourié-Gonnard7f2f0622015-09-03 10:44:32 +02002880
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002881 /*
2882 * Now write it out, encrypted
2883 */
Hanno Beckerc7d7e292019-02-06 16:49:54 +00002884 if( ! mbedtls_pk_can_do( peer_pk, MBEDTLS_PK_RSA ) )
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002885 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002886 MBEDTLS_SSL_DEBUG_MSG( 1, ( "certificate key type mismatch" ) );
2887 return( MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH );
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002888 }
2889
Hanno Beckerc7d7e292019-02-06 16:49:54 +00002890 if( ( ret = mbedtls_pk_encrypt( peer_pk,
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002891 p, ssl->handshake->pmslen,
2892 ssl->out_msg + offset + len_bytes, olen,
Angus Grattond8213d02016-05-25 20:56:48 +10002893 MBEDTLS_SSL_OUT_CONTENT_LEN - offset - len_bytes,
Manuel Pégourié-Gonnard750e4d72015-05-07 12:35:38 +01002894 ssl->conf->f_rng, ssl->conf->p_rng ) ) != 0 )
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002895 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002896 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_rsa_pkcs1_encrypt", ret );
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002897 return( ret );
2898 }
2899
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002900#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
2901 defined(MBEDTLS_SSL_PROTO_TLS1_2)
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002902 if( len_bytes == 2 )
2903 {
Joe Subbianic54e9082021-07-19 11:56:54 +01002904 MBEDTLS_PUT_UINT16_BE( *olen, ssl->out_msg, offset );
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002905 *olen += 2;
2906 }
2907#endif
2908
Hanno Beckerae553dd2019-02-08 14:06:00 +00002909#if !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
2910 /* We don't need the peer's public key anymore. Free it. */
2911 mbedtls_pk_free( peer_pk );
2912#endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02002913 return( 0 );
2914}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002915#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED ||
2916 MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
Paul Bakker29e1f122013-04-16 13:07:56 +02002917
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002918#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
Manuel Pégourié-Gonnard5c2a7ca2015-10-23 08:48:41 +02002919#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
2920 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
2921 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002922static int ssl_parse_signature_algorithm( mbedtls_ssl_context *ssl,
Paul Bakker29e1f122013-04-16 13:07:56 +02002923 unsigned char **p,
2924 unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002925 mbedtls_md_type_t *md_alg,
2926 mbedtls_pk_type_t *pk_alg )
Paul Bakker29e1f122013-04-16 13:07:56 +02002927{
Paul Bakkerc5a79cc2013-06-26 15:08:35 +02002928 ((void) ssl);
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002929 *md_alg = MBEDTLS_MD_NONE;
2930 *pk_alg = MBEDTLS_PK_NONE;
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02002931
2932 /* Only in TLS 1.2 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002933 if( ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_3 )
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02002934 {
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02002935 return( 0 );
2936 }
Paul Bakker29e1f122013-04-16 13:07:56 +02002937
Paul Bakker48f7a5d2013-04-19 14:30:58 +02002938 if( (*p) + 2 > end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002939 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
Paul Bakker29e1f122013-04-16 13:07:56 +02002940
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02002941 /*
2942 * Get hash algorithm
2943 */
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002944 if( ( *md_alg = mbedtls_ssl_md_alg_from_hash( (*p)[0] ) )
2945 == MBEDTLS_MD_NONE )
Paul Bakker29e1f122013-04-16 13:07:56 +02002946 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002947 MBEDTLS_SSL_DEBUG_MSG( 1,
2948 ( "Server used unsupported HashAlgorithm %d", *(p)[0] ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002949 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
Paul Bakker29e1f122013-04-16 13:07:56 +02002950 }
2951
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02002952 /*
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02002953 * Get signature algorithm
2954 */
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002955 if( ( *pk_alg = mbedtls_ssl_pk_alg_from_sig( (*p)[1] ) )
2956 == MBEDTLS_PK_NONE )
Paul Bakker29e1f122013-04-16 13:07:56 +02002957 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002958 MBEDTLS_SSL_DEBUG_MSG( 1,
2959 ( "server used unsupported SignatureAlgorithm %d", (*p)[1] ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002960 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
Paul Bakker29e1f122013-04-16 13:07:56 +02002961 }
2962
Manuel Pégourié-Gonnard7bfc1222015-06-17 14:34:48 +02002963 /*
2964 * Check if the hash is acceptable
2965 */
2966 if( mbedtls_ssl_check_sig_hash( ssl, *md_alg ) != 0 )
2967 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002968 MBEDTLS_SSL_DEBUG_MSG( 1,
2969 ( "server used HashAlgorithm %d that was not offered", *(p)[0] ) );
Manuel Pégourié-Gonnard7bfc1222015-06-17 14:34:48 +02002970 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
2971 }
2972
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01002973 MBEDTLS_SSL_DEBUG_MSG( 2, ( "Server used SignatureAlgorithm %d",
2974 (*p)[1] ) );
2975 MBEDTLS_SSL_DEBUG_MSG( 2, ( "Server used HashAlgorithm %d",
2976 (*p)[0] ) );
Paul Bakker29e1f122013-04-16 13:07:56 +02002977 *p += 2;
2978
2979 return( 0 );
2980}
Manuel Pégourié-Gonnard5c2a7ca2015-10-23 08:48:41 +02002981#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED ||
2982 MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
2983 MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002984#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
Paul Bakker29e1f122013-04-16 13:07:56 +02002985
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002986#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
2987 defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
2988static int ssl_get_ecdh_params_from_cert( mbedtls_ssl_context *ssl )
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01002989{
Janos Follath865b3eb2019-12-16 11:46:15 +00002990 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002991 const mbedtls_ecp_keypair *peer_key;
Hanno Beckerbe7f5082019-02-06 17:44:07 +00002992 mbedtls_pk_context * peer_pk;
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01002993
Hanno Beckerbe7f5082019-02-06 17:44:07 +00002994#if !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
2995 peer_pk = &ssl->handshake->peer_pubkey;
2996#else /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
Manuel Pégourié-Gonnard7f2f0622015-09-03 10:44:32 +02002997 if( ssl->session_negotiate->peer_cert == NULL )
2998 {
Hanno Becker8273df82019-02-06 17:37:32 +00002999 /* Should never happen */
Hanno Beckerbd5580a2019-02-26 12:36:01 +00003000 MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
Hanno Becker8273df82019-02-06 17:37:32 +00003001 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Manuel Pégourié-Gonnard7f2f0622015-09-03 10:44:32 +02003002 }
Hanno Beckerbe7f5082019-02-06 17:44:07 +00003003 peer_pk = &ssl->session_negotiate->peer_cert->pk;
3004#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
Manuel Pégourié-Gonnard7f2f0622015-09-03 10:44:32 +02003005
Hanno Beckerbe7f5082019-02-06 17:44:07 +00003006 if( ! mbedtls_pk_can_do( peer_pk, MBEDTLS_PK_ECKEY ) )
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01003007 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003008 MBEDTLS_SSL_DEBUG_MSG( 1, ( "server key not ECDH capable" ) );
3009 return( MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH );
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01003010 }
3011
Hanno Beckerbe7f5082019-02-06 17:44:07 +00003012 peer_key = mbedtls_pk_ec( *peer_pk );
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01003013
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003014 if( ( ret = mbedtls_ecdh_get_params( &ssl->handshake->ecdh_ctx, peer_key,
3015 MBEDTLS_ECDH_THEIRS ) ) != 0 )
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01003016 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003017 MBEDTLS_SSL_DEBUG_RET( 1, ( "mbedtls_ecdh_get_params" ), ret );
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01003018 return( ret );
3019 }
3020
3021 if( ssl_check_server_ecdh_params( ssl ) != 0 )
3022 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003023 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server certificate (ECDH curve)" ) );
3024 return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE );
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01003025 }
3026
Hanno Beckerae553dd2019-02-08 14:06:00 +00003027#if !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
3028 /* We don't need the peer's public key anymore. Free it,
3029 * so that more RAM is available for upcoming expensive
3030 * operations like ECDHE. */
3031 mbedtls_pk_free( peer_pk );
3032#endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
3033
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01003034 return( ret );
3035}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003036#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) ||
3037 MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01003038
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003039static int ssl_parse_server_key_exchange( mbedtls_ssl_context *ssl )
Paul Bakker41c83d32013-03-20 14:39:14 +01003040{
Janos Follath865b3eb2019-12-16 11:46:15 +00003041 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Hanno Becker0d0cd4b2017-05-11 14:06:43 +01003042 const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
Hanno Beckere694c3e2017-12-27 21:34:08 +00003043 ssl->handshake->ciphersuite_info;
Andres Amaya Garcia53c77cc2017-06-27 16:15:06 +01003044 unsigned char *p = NULL, *end = NULL;
Paul Bakker5121ce52009-01-03 21:22:43 +00003045
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003046 MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse server key exchange" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00003047
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003048#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
3049 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA )
Paul Bakker5121ce52009-01-03 21:22:43 +00003050 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003051 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse server key exchange" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00003052 ssl->state++;
3053 return( 0 );
3054 }
Manuel Pégourié-Gonnardbac0e3b2013-10-15 11:54:47 +02003055 ((void) p);
3056 ((void) end);
3057#endif
Paul Bakker5121ce52009-01-03 21:22:43 +00003058
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003059#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
3060 defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
3061 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_RSA ||
3062 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA )
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01003063 {
Manuel Pégourié-Gonnardab240102014-02-04 16:18:07 +01003064 if( ( ret = ssl_get_ecdh_params_from_cert( ssl ) ) != 0 )
3065 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003066 MBEDTLS_SSL_DEBUG_RET( 1, "ssl_get_ecdh_params_from_cert", ret );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003067 mbedtls_ssl_send_alert_message(
3068 ssl,
3069 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3070 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
Manuel Pégourié-Gonnardab240102014-02-04 16:18:07 +01003071 return( ret );
3072 }
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01003073
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003074 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse server key exchange" ) );
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01003075 ssl->state++;
3076 return( 0 );
3077 }
3078 ((void) p);
3079 ((void) end);
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003080#endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
3081 MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
Manuel Pégourié-Gonnardd18cc572013-12-11 17:45:46 +01003082
Gilles Peskineeccd8882020-03-10 12:19:08 +01003083#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02003084 if( ssl->handshake->ecrs_enabled &&
Manuel Pégourié-Gonnard0b23f162017-08-24 12:08:33 +02003085 ssl->handshake->ecrs_state == ssl_ecrs_ske_start_processing )
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02003086 {
Manuel Pégourié-Gonnard0b23f162017-08-24 12:08:33 +02003087 goto start_processing;
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02003088 }
Manuel Pégourié-Gonnard1f1f2a12017-05-18 11:27:06 +02003089#endif
3090
Hanno Becker327c93b2018-08-15 13:56:18 +01003091 if( ( ret = mbedtls_ssl_read_record( ssl, 1 ) ) != 0 )
Paul Bakker5121ce52009-01-03 21:22:43 +00003092 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003093 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
Paul Bakker5121ce52009-01-03 21:22:43 +00003094 return( ret );
3095 }
3096
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003097 if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
Paul Bakker5121ce52009-01-03 21:22:43 +00003098 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003099 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003100 mbedtls_ssl_send_alert_message(
3101 ssl,
3102 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3103 MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003104 return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
Paul Bakker5121ce52009-01-03 21:22:43 +00003105 }
3106
Manuel Pégourié-Gonnard09258b92013-10-15 10:43:36 +02003107 /*
3108 * ServerKeyExchange may be skipped with PSK and RSA-PSK when the server
3109 * doesn't use a psk_identity_hint
3110 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003111 if( ssl->in_msg[0] != MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE )
Paul Bakker5121ce52009-01-03 21:22:43 +00003112 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003113 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
3114 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
Paul Bakker188c8de2013-04-19 09:13:37 +02003115 {
Hanno Beckeraf0665d2017-05-24 09:16:26 +01003116 /* Current message is probably either
3117 * CertificateRequest or ServerHelloDone */
3118 ssl->keep_current_message = 1;
Paul Bakker188c8de2013-04-19 09:13:37 +02003119 goto exit;
3120 }
3121
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003122 MBEDTLS_SSL_DEBUG_MSG( 1,
3123 ( "server key exchange message must not be skipped" ) );
3124 mbedtls_ssl_send_alert_message(
3125 ssl,
3126 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3127 MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE );
Hanno Beckeraf0665d2017-05-24 09:16:26 +01003128
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003129 return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
Paul Bakker5121ce52009-01-03 21:22:43 +00003130 }
3131
Gilles Peskineeccd8882020-03-10 12:19:08 +01003132#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnard0b23f162017-08-24 12:08:33 +02003133 if( ssl->handshake->ecrs_enabled )
3134 ssl->handshake->ecrs_state = ssl_ecrs_ske_start_processing;
3135
3136start_processing:
3137#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003138 p = ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl );
Paul Bakker3b6a07b2013-03-21 11:56:50 +01003139 end = ssl->in_msg + ssl->in_hslen;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003140 MBEDTLS_SSL_DEBUG_BUF( 3, "server key exchange", p, end - p );
Paul Bakker3b6a07b2013-03-21 11:56:50 +01003141
Gilles Peskineeccd8882020-03-10 12:19:08 +01003142#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003143 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
3144 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK ||
3145 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK ||
3146 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
Manuel Pégourié-Gonnard09258b92013-10-15 10:43:36 +02003147 {
3148 if( ssl_parse_server_psk_hint( ssl, &p, end ) != 0 )
3149 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003150 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003151 mbedtls_ssl_send_alert_message(
3152 ssl,
3153 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3154 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003155 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
Manuel Pégourié-Gonnard09258b92013-10-15 10:43:36 +02003156 }
Shaun Case0e7791f2021-12-20 21:14:10 -08003157 } /* FALLTHROUGH */
Gilles Peskineeccd8882020-03-10 12:19:08 +01003158#endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
Manuel Pégourié-Gonnard09258b92013-10-15 10:43:36 +02003159
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003160#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED) || \
3161 defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
3162 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK ||
3163 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
Manuel Pégourié-Gonnard09258b92013-10-15 10:43:36 +02003164 ; /* nothing more to do */
3165 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003166#endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED ||
3167 MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
3168#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) || \
3169 defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
3170 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_RSA ||
3171 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
Paul Bakker5121ce52009-01-03 21:22:43 +00003172 {
Paul Bakker29e1f122013-04-16 13:07:56 +02003173 if( ssl_parse_server_dh_params( ssl, &p, end ) != 0 )
Paul Bakker41c83d32013-03-20 14:39:14 +01003174 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003175 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003176 mbedtls_ssl_send_alert_message(
3177 ssl,
3178 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3179 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003180 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02003181 }
3182 }
Paul Bakker48f7a5d2013-04-19 14:30:58 +02003183 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003184#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED ||
3185 MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
Hanno Beckerbb89e272019-01-08 12:54:37 +00003186#if defined(MBEDTLS_USE_PSA_CRYPTO) && \
3187 ( defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
3188 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) )
3189 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
3190 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA )
3191 {
3192 if( ssl_parse_server_ecdh_params_psa( ssl, &p, end ) != 0 )
3193 {
3194 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003195 mbedtls_ssl_send_alert_message(
3196 ssl,
3197 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3198 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Hanno Beckerbb89e272019-01-08 12:54:37 +00003199 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
3200 }
3201 }
3202 else
3203#endif /* MBEDTLS_USE_PSA_CRYPTO &&
3204 ( MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
3205 MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ) */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003206#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
3207 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) || \
3208 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
3209 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
3210 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK ||
3211 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA )
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02003212 {
3213 if( ssl_parse_server_ecdh_params( ssl, &p, end ) != 0 )
3214 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003215 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003216 mbedtls_ssl_send_alert_message(
3217 ssl,
3218 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3219 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003220 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
Paul Bakker41c83d32013-03-20 14:39:14 +01003221 }
Paul Bakker1ef83d62012-04-11 12:09:53 +00003222 }
Paul Bakker48f7a5d2013-04-19 14:30:58 +02003223 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003224#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
3225 MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED ||
3226 MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
Manuel Pégourié-Gonnard0f1660a2015-09-16 22:41:06 +02003227#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
3228 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECJPAKE )
3229 {
3230 ret = mbedtls_ecjpake_read_round_two( &ssl->handshake->ecjpake_ctx,
3231 p, end - p );
3232 if( ret != 0 )
3233 {
3234 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecjpake_read_round_two", ret );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003235 mbedtls_ssl_send_alert_message(
3236 ssl,
3237 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3238 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Manuel Pégourié-Gonnard0f1660a2015-09-16 22:41:06 +02003239 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
3240 }
3241 }
3242 else
3243#endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
Paul Bakker41c83d32013-03-20 14:39:14 +01003244 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003245 MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
3246 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Paul Bakker48f7a5d2013-04-19 14:30:58 +02003247 }
Paul Bakker1ef83d62012-04-11 12:09:53 +00003248
Gilles Peskineeccd8882020-03-10 12:19:08 +01003249#if defined(MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED)
Hanno Becker1aa267c2017-04-28 17:08:27 +01003250 if( mbedtls_ssl_ciphersuite_uses_server_signature( ciphersuite_info ) )
Paul Bakker1ef83d62012-04-11 12:09:53 +00003251 {
Manuel Pégourié-Gonnardd92d6a12014-09-10 15:25:02 +00003252 size_t sig_len, hashlen;
Ronald Cron3a95d2b2021-10-18 09:47:58 +02003253#if defined(MBEDTLS_USE_PSA_CRYPTO)
3254 unsigned char hash[PSA_HASH_MAX_SIZE];
3255#else
3256 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
3257#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003258 mbedtls_md_type_t md_alg = MBEDTLS_MD_NONE;
3259 mbedtls_pk_type_t pk_alg = MBEDTLS_PK_NONE;
3260 unsigned char *params = ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl );
Manuel Pégourié-Gonnardd92d6a12014-09-10 15:25:02 +00003261 size_t params_len = p - params;
Manuel Pégourié-Gonnard1f1f2a12017-05-18 11:27:06 +02003262 void *rs_ctx = NULL;
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02003263
Hanno Beckera6899bb2019-02-06 18:26:03 +00003264 mbedtls_pk_context * peer_pk;
3265
Paul Bakker29e1f122013-04-16 13:07:56 +02003266 /*
3267 * Handle the digitally-signed structure
3268 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003269#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
3270 if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
Paul Bakker1ef83d62012-04-11 12:09:53 +00003271 {
Paul Bakker9659dae2013-08-28 16:21:34 +02003272 if( ssl_parse_signature_algorithm( ssl, &p, end,
3273 &md_alg, &pk_alg ) != 0 )
3274 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003275 MBEDTLS_SSL_DEBUG_MSG( 1,
3276 ( "bad server key exchange message" ) );
3277 mbedtls_ssl_send_alert_message(
3278 ssl,
3279 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3280 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003281 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
Paul Bakker9659dae2013-08-28 16:21:34 +02003282 }
Paul Bakker1ef83d62012-04-11 12:09:53 +00003283
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003284 if( pk_alg !=
3285 mbedtls_ssl_get_ciphersuite_sig_pk_alg( ciphersuite_info ) )
Paul Bakker1ef83d62012-04-11 12:09:53 +00003286 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003287 MBEDTLS_SSL_DEBUG_MSG( 1,
3288 ( "bad server key exchange message" ) );
3289 mbedtls_ssl_send_alert_message(
3290 ssl,
3291 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3292 MBEDTLS_SSL_ALERT_MSG_ILLEGAL_PARAMETER );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003293 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
Paul Bakker1ef83d62012-04-11 12:09:53 +00003294 }
3295 }
Manuel Pégourié-Gonnard09edda82013-08-19 13:50:33 +02003296 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003297#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
3298#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
3299 defined(MBEDTLS_SSL_PROTO_TLS1_1)
3300 if( ssl->minor_ver < MBEDTLS_SSL_MINOR_VERSION_3 )
Manuel Pégourié-Gonnard09edda82013-08-19 13:50:33 +02003301 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003302 pk_alg = mbedtls_ssl_get_ciphersuite_sig_pk_alg( ciphersuite_info );
Paul Bakker1ef83d62012-04-11 12:09:53 +00003303
Paul Bakker9659dae2013-08-28 16:21:34 +02003304 /* Default hash for ECDSA is SHA-1 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003305 if( pk_alg == MBEDTLS_PK_ECDSA && md_alg == MBEDTLS_MD_NONE )
3306 md_alg = MBEDTLS_MD_SHA1;
Paul Bakker9659dae2013-08-28 16:21:34 +02003307 }
3308 else
3309#endif
3310 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003311 MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
3312 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Paul Bakker9659dae2013-08-28 16:21:34 +02003313 }
Manuel Pégourié-Gonnard4bd12842013-08-27 13:31:28 +02003314
3315 /*
3316 * Read signature
3317 */
Krzysztof Stachowiaka1098f82018-03-13 11:28:49 +01003318
3319 if( p > end - 2 )
3320 {
3321 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003322 mbedtls_ssl_send_alert_message(
3323 ssl,
3324 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3325 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Krzysztof Stachowiaka1098f82018-03-13 11:28:49 +01003326 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
3327 }
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02003328 sig_len = ( p[0] << 8 ) | p[1];
Paul Bakker1ef83d62012-04-11 12:09:53 +00003329 p += 2;
Paul Bakker1ef83d62012-04-11 12:09:53 +00003330
Krzysztof Stachowiak027f84c2018-03-13 11:29:24 +01003331 if( p != end - sig_len )
Paul Bakker41c83d32013-03-20 14:39:14 +01003332 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003333 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003334 mbedtls_ssl_send_alert_message(
3335 ssl,
3336 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3337 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003338 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
Paul Bakker41c83d32013-03-20 14:39:14 +01003339 }
Paul Bakker5121ce52009-01-03 21:22:43 +00003340
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003341 MBEDTLS_SSL_DEBUG_BUF( 3, "signature", p, sig_len );
Manuel Pégourié-Gonnardff56da32013-07-11 10:46:21 +02003342
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02003343 /*
3344 * Compute the hash that has been signed
3345 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003346#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
3347 defined(MBEDTLS_SSL_PROTO_TLS1_1)
3348 if( md_alg == MBEDTLS_MD_NONE )
Paul Bakkerc3f177a2012-04-11 16:11:49 +00003349 {
Manuel Pégourié-Gonnard4bd12842013-08-27 13:31:28 +02003350 hashlen = 36;
Andres Amaya Garcia46f5a3e2017-07-20 16:17:51 +01003351 ret = mbedtls_ssl_get_key_exchange_md_ssl_tls( ssl, hash, params,
3352 params_len );
3353 if( ret != 0 )
Andres Amaya Garciaf0e521e2017-06-28 12:11:42 +01003354 return( ret );
Paul Bakker29e1f122013-04-16 13:07:56 +02003355 }
3356 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003357#endif /* MBEDTLS_SSL_PROTO_SSL3 || MBEDTLS_SSL_PROTO_TLS1 || \
3358 MBEDTLS_SSL_PROTO_TLS1_1 */
3359#if defined(MBEDTLS_SSL_PROTO_TLS1) || defined(MBEDTLS_SSL_PROTO_TLS1_1) || \
3360 defined(MBEDTLS_SSL_PROTO_TLS1_2)
3361 if( md_alg != MBEDTLS_MD_NONE )
Paul Bakker29e1f122013-04-16 13:07:56 +02003362 {
Gilles Peskineca1d7422018-04-24 11:53:22 +02003363 ret = mbedtls_ssl_get_key_exchange_md_tls1_2( ssl, hash, &hashlen,
3364 params, params_len,
3365 md_alg );
Andres Amaya Garcia46f5a3e2017-07-20 16:17:51 +01003366 if( ret != 0 )
Paul Bakker29e1f122013-04-16 13:07:56 +02003367 return( ret );
Paul Bakker29e1f122013-04-16 13:07:56 +02003368 }
Paul Bakkerd2f068e2013-08-27 21:19:20 +02003369 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003370#endif /* MBEDTLS_SSL_PROTO_TLS1 || MBEDTLS_SSL_PROTO_TLS1_1 || \
3371 MBEDTLS_SSL_PROTO_TLS1_2 */
Paul Bakker29e1f122013-04-16 13:07:56 +02003372 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003373 MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
3374 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Paul Bakker577e0062013-08-28 11:57:20 +02003375 }
Paul Bakker29e1f122013-04-16 13:07:56 +02003376
Gilles Peskineca1d7422018-04-24 11:53:22 +02003377 MBEDTLS_SSL_DEBUG_BUF( 3, "parameters hash", hash, hashlen );
Paul Bakker29e1f122013-04-16 13:07:56 +02003378
Hanno Beckera6899bb2019-02-06 18:26:03 +00003379#if !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
3380 peer_pk = &ssl->handshake->peer_pubkey;
3381#else /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
Manuel Pégourié-Gonnard7f2f0622015-09-03 10:44:32 +02003382 if( ssl->session_negotiate->peer_cert == NULL )
3383 {
Hanno Becker8273df82019-02-06 17:37:32 +00003384 /* Should never happen */
Hanno Beckerbd5580a2019-02-26 12:36:01 +00003385 MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
Hanno Becker8273df82019-02-06 17:37:32 +00003386 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Manuel Pégourié-Gonnard7f2f0622015-09-03 10:44:32 +02003387 }
Hanno Beckera6899bb2019-02-06 18:26:03 +00003388 peer_pk = &ssl->session_negotiate->peer_cert->pk;
3389#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
Manuel Pégourié-Gonnard7f2f0622015-09-03 10:44:32 +02003390
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02003391 /*
3392 * Verify signature
3393 */
Hanno Beckera6899bb2019-02-06 18:26:03 +00003394 if( !mbedtls_pk_can_do( peer_pk, pk_alg ) )
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02003395 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003396 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003397 mbedtls_ssl_send_alert_message(
3398 ssl,
3399 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3400 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003401 return( MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH );
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02003402 }
3403
Gilles Peskineeccd8882020-03-10 12:19:08 +01003404#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02003405 if( ssl->handshake->ecrs_enabled )
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +02003406 rs_ctx = &ssl->handshake->ecrs_ctx.pk;
Manuel Pégourié-Gonnard1f1f2a12017-05-18 11:27:06 +02003407#endif
3408
Hanno Beckera6899bb2019-02-06 18:26:03 +00003409 if( ( ret = mbedtls_pk_verify_restartable( peer_pk,
Manuel Pégourié-Gonnard1f1f2a12017-05-18 11:27:06 +02003410 md_alg, hash, hashlen, p, sig_len, rs_ctx ) ) != 0 )
Manuel Pégourié-Gonnardefebb0a2013-08-19 12:06:38 +02003411 {
Gilles Peskineeccd8882020-03-10 12:19:08 +01003412#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnard1f1f2a12017-05-18 11:27:06 +02003413 if( ret != MBEDTLS_ERR_ECP_IN_PROGRESS )
3414#endif
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003415 mbedtls_ssl_send_alert_message(
3416 ssl,
3417 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3418 MBEDTLS_SSL_ALERT_MSG_DECRYPT_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003419 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_pk_verify", ret );
Gilles Peskineeccd8882020-03-10 12:19:08 +01003420#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnard558da9c2018-06-13 12:02:12 +02003421 if( ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
3422 ret = MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS;
3423#endif
Paul Bakkerc70b9822013-04-07 22:00:46 +02003424 return( ret );
Paul Bakkerc3f177a2012-04-11 16:11:49 +00003425 }
Hanno Beckerae553dd2019-02-08 14:06:00 +00003426
3427#if !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
3428 /* We don't need the peer's public key anymore. Free it,
3429 * so that more RAM is available for upcoming expensive
3430 * operations like ECDHE. */
3431 mbedtls_pk_free( peer_pk );
3432#endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
Paul Bakker5121ce52009-01-03 21:22:43 +00003433 }
Gilles Peskineeccd8882020-03-10 12:19:08 +01003434#endif /* MBEDTLS_KEY_EXCHANGE_WITH_SERVER_SIGNATURE_ENABLED */
Paul Bakker5121ce52009-01-03 21:22:43 +00003435
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02003436exit:
Paul Bakker5121ce52009-01-03 21:22:43 +00003437 ssl->state++;
3438
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003439 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse server key exchange" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00003440
3441 return( 0 );
Paul Bakker5121ce52009-01-03 21:22:43 +00003442}
3443
Gilles Peskineeccd8882020-03-10 12:19:08 +01003444#if ! defined(MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003445static int ssl_parse_certificate_request( mbedtls_ssl_context *ssl )
Manuel Pégourié-Gonnardda1ff382013-11-25 17:38:36 +01003446{
Hanno Becker0d0cd4b2017-05-11 14:06:43 +01003447 const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
Hanno Beckere694c3e2017-12-27 21:34:08 +00003448 ssl->handshake->ciphersuite_info;
Manuel Pégourié-Gonnardda1ff382013-11-25 17:38:36 +01003449
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003450 MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse certificate request" ) );
Manuel Pégourié-Gonnardda1ff382013-11-25 17:38:36 +01003451
Hanno Becker1aa267c2017-04-28 17:08:27 +01003452 if( ! mbedtls_ssl_ciphersuite_cert_req_allowed( ciphersuite_info ) )
Manuel Pégourié-Gonnardda1ff382013-11-25 17:38:36 +01003453 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003454 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate request" ) );
Manuel Pégourié-Gonnardda1ff382013-11-25 17:38:36 +01003455 ssl->state++;
3456 return( 0 );
3457 }
3458
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003459 MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
3460 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Manuel Pégourié-Gonnardda1ff382013-11-25 17:38:36 +01003461}
Gilles Peskineeccd8882020-03-10 12:19:08 +01003462#else /* MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003463static int ssl_parse_certificate_request( mbedtls_ssl_context *ssl )
Paul Bakker5121ce52009-01-03 21:22:43 +00003464{
Janos Follath865b3eb2019-12-16 11:46:15 +00003465 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Manuel Pégourié-Gonnardd1b7f2b2016-02-24 14:13:22 +00003466 unsigned char *buf;
3467 size_t n = 0;
Paul Bakkerd2f068e2013-08-27 21:19:20 +02003468 size_t cert_type_len = 0, dn_len = 0;
Hanno Becker0d0cd4b2017-05-11 14:06:43 +01003469 const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
Hanno Beckere694c3e2017-12-27 21:34:08 +00003470 ssl->handshake->ciphersuite_info;
Paul Bakker5121ce52009-01-03 21:22:43 +00003471
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003472 MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse certificate request" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00003473
Hanno Becker1aa267c2017-04-28 17:08:27 +01003474 if( ! mbedtls_ssl_ciphersuite_cert_req_allowed( ciphersuite_info ) )
Manuel Pégourié-Gonnardda1ff382013-11-25 17:38:36 +01003475 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003476 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip parse certificate request" ) );
Manuel Pégourié-Gonnardda1ff382013-11-25 17:38:36 +01003477 ssl->state++;
3478 return( 0 );
3479 }
3480
Hanno Becker327c93b2018-08-15 13:56:18 +01003481 if( ( ret = mbedtls_ssl_read_record( ssl, 1 ) ) != 0 )
Paul Bakker5121ce52009-01-03 21:22:43 +00003482 {
Hanno Beckeraf0665d2017-05-24 09:16:26 +01003483 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
3484 return( ret );
Paul Bakker5121ce52009-01-03 21:22:43 +00003485 }
3486
Hanno Beckeraf0665d2017-05-24 09:16:26 +01003487 if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
3488 {
3489 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003490 mbedtls_ssl_send_alert_message(
3491 ssl,
3492 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3493 MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE );
Hanno Beckeraf0665d2017-05-24 09:16:26 +01003494 return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
3495 }
Paul Bakker5121ce52009-01-03 21:22:43 +00003496
Hanno Beckeraf0665d2017-05-24 09:16:26 +01003497 ssl->state++;
3498 ssl->client_auth = ( ssl->in_msg[0] == MBEDTLS_SSL_HS_CERTIFICATE_REQUEST );
Paul Bakker5121ce52009-01-03 21:22:43 +00003499
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003500 MBEDTLS_SSL_DEBUG_MSG( 3, ( "got %s certificate request",
Paul Bakker5121ce52009-01-03 21:22:43 +00003501 ssl->client_auth ? "a" : "no" ) );
3502
Paul Bakker926af752012-11-23 13:38:07 +01003503 if( ssl->client_auth == 0 )
Hanno Beckeraf0665d2017-05-24 09:16:26 +01003504 {
Johan Pascala89ca862020-08-25 10:03:19 +02003505 /* Current message is probably the ServerHelloDone */
3506 ssl->keep_current_message = 1;
Paul Bakker926af752012-11-23 13:38:07 +01003507 goto exit;
Hanno Beckeraf0665d2017-05-24 09:16:26 +01003508 }
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02003509
Manuel Pégourié-Gonnard04c1b4e2014-09-10 19:25:43 +02003510 /*
3511 * struct {
3512 * ClientCertificateType certificate_types<1..2^8-1>;
3513 * SignatureAndHashAlgorithm
3514 * supported_signature_algorithms<2^16-1>; -- TLS 1.2 only
3515 * DistinguishedName certificate_authorities<0..2^16-1>;
3516 * } CertificateRequest;
Manuel Pégourié-Gonnardd1b7f2b2016-02-24 14:13:22 +00003517 *
3518 * Since we only support a single certificate on clients, let's just
3519 * ignore all the information that's supposed to help us pick a
3520 * certificate.
3521 *
3522 * We could check that our certificate matches the request, and bail out
3523 * if it doesn't, but it's simpler to just send the certificate anyway,
3524 * and give the server the opportunity to decide if it should terminate
3525 * the connection when it doesn't like our certificate.
3526 *
3527 * Same goes for the hash in TLS 1.2's signature_algorithms: at this
3528 * point we only have one hash available (see comments in
Simon Butcherc0957bd2016-03-01 13:16:57 +00003529 * write_certificate_verify), so let's just use what we have.
Manuel Pégourié-Gonnardd1b7f2b2016-02-24 14:13:22 +00003530 *
3531 * However, we still minimally parse the message to check it is at least
3532 * superficially sane.
Manuel Pégourié-Gonnard04c1b4e2014-09-10 19:25:43 +02003533 */
Paul Bakker926af752012-11-23 13:38:07 +01003534 buf = ssl->in_msg;
Paul Bakkerf7abd422013-04-16 13:15:56 +02003535
Manuel Pégourié-Gonnardd1b7f2b2016-02-24 14:13:22 +00003536 /* certificate_types */
Krzysztof Stachowiak73b183c2018-04-05 10:20:09 +02003537 if( ssl->in_hslen <= mbedtls_ssl_hs_hdr_len( ssl ) )
3538 {
3539 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
3540 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3541 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
3542 return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST );
3543 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003544 cert_type_len = buf[mbedtls_ssl_hs_hdr_len( ssl )];
Paul Bakker926af752012-11-23 13:38:07 +01003545 n = cert_type_len;
3546
Krzysztof Stachowiakbc145f72018-03-20 11:19:50 +01003547 /*
Krzysztof Stachowiak94d49972018-04-05 14:48:55 +02003548 * In the subsequent code there are two paths that read from buf:
Krzysztof Stachowiakbc145f72018-03-20 11:19:50 +01003549 * * the length of the signature algorithms field (if minor version of
3550 * SSL is 3),
3551 * * distinguished name length otherwise.
3552 * Both reach at most the index:
3553 * ...hdr_len + 2 + n,
3554 * therefore the buffer length at this point must be greater than that
3555 * regardless of the actual code path.
3556 */
3557 if( ssl->in_hslen <= mbedtls_ssl_hs_hdr_len( ssl ) + 2 + n )
Paul Bakker926af752012-11-23 13:38:07 +01003558 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003559 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02003560 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3561 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003562 return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST );
Paul Bakker926af752012-11-23 13:38:07 +01003563 }
3564
Manuel Pégourié-Gonnardd1b7f2b2016-02-24 14:13:22 +00003565 /* supported_signature_algorithms */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003566#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
3567 if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
Paul Bakker926af752012-11-23 13:38:07 +01003568 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003569 size_t sig_alg_len =
3570 ( ( buf[mbedtls_ssl_hs_hdr_len( ssl ) + 1 + n] << 8 )
3571 | ( buf[mbedtls_ssl_hs_hdr_len( ssl ) + 2 + n] ) );
Simon Butcher99000142016-10-13 17:21:01 +01003572#if defined(MBEDTLS_DEBUG_C)
Krzysztof Stachowiakbc231cc2018-03-20 14:09:53 +01003573 unsigned char* sig_alg;
Simon Butcher99000142016-10-13 17:21:01 +01003574 size_t i;
Krzysztof Stachowiakbc231cc2018-03-20 14:09:53 +01003575#endif
Simon Butcher99000142016-10-13 17:21:01 +01003576
Krzysztof Stachowiakbc231cc2018-03-20 14:09:53 +01003577 /*
Krzysztof Stachowiak94d49972018-04-05 14:48:55 +02003578 * The furthest access in buf is in the loop few lines below:
Krzysztof Stachowiakbc231cc2018-03-20 14:09:53 +01003579 * sig_alg[i + 1],
3580 * where:
3581 * sig_alg = buf + ...hdr_len + 3 + n,
3582 * max(i) = sig_alg_len - 1.
Krzysztof Stachowiak94d49972018-04-05 14:48:55 +02003583 * Therefore the furthest access is:
Krzysztof Stachowiakbc231cc2018-03-20 14:09:53 +01003584 * buf[...hdr_len + 3 + n + sig_alg_len - 1 + 1],
3585 * which reduces to:
3586 * buf[...hdr_len + 3 + n + sig_alg_len],
3587 * which is one less than we need the buf to be.
3588 */
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003589 if( ssl->in_hslen <= mbedtls_ssl_hs_hdr_len( ssl )
3590 + 3 + n + sig_alg_len )
Krzysztof Stachowiakbc231cc2018-03-20 14:09:53 +01003591 {
3592 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003593 mbedtls_ssl_send_alert_message(
3594 ssl,
3595 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3596 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Krzysztof Stachowiakbc231cc2018-03-20 14:09:53 +01003597 return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST );
3598 }
3599
3600#if defined(MBEDTLS_DEBUG_C)
3601 sig_alg = buf + mbedtls_ssl_hs_hdr_len( ssl ) + 3 + n;
Simon Butcher99000142016-10-13 17:21:01 +01003602 for( i = 0; i < sig_alg_len; i += 2 )
3603 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003604 MBEDTLS_SSL_DEBUG_MSG( 3,
3605 ( "Supported Signature Algorithm found: %d,%d",
3606 sig_alg[i], sig_alg[i + 1] ) );
Simon Butcher99000142016-10-13 17:21:01 +01003607 }
3608#endif
Paul Bakker926af752012-11-23 13:38:07 +01003609
Manuel Pégourié-Gonnardd1b7f2b2016-02-24 14:13:22 +00003610 n += 2 + sig_alg_len;
Paul Bakkerf7abd422013-04-16 13:15:56 +02003611 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003612#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
Paul Bakker926af752012-11-23 13:38:07 +01003613
Manuel Pégourié-Gonnardd1b7f2b2016-02-24 14:13:22 +00003614 /* certificate_authorities */
3615 dn_len = ( ( buf[mbedtls_ssl_hs_hdr_len( ssl ) + 1 + n] << 8 )
3616 | ( buf[mbedtls_ssl_hs_hdr_len( ssl ) + 2 + n] ) );
Paul Bakker926af752012-11-23 13:38:07 +01003617
3618 n += dn_len;
Manuel Pégourié-Gonnardd1b7f2b2016-02-24 14:13:22 +00003619 if( ssl->in_hslen != mbedtls_ssl_hs_hdr_len( ssl ) + 3 + n )
Paul Bakker926af752012-11-23 13:38:07 +01003620 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003621 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02003622 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3623 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003624 return( MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST );
Paul Bakker926af752012-11-23 13:38:07 +01003625 }
3626
3627exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003628 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse certificate request" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00003629
3630 return( 0 );
3631}
Gilles Peskineeccd8882020-03-10 12:19:08 +01003632#endif /* MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED */
Paul Bakker5121ce52009-01-03 21:22:43 +00003633
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003634static int ssl_parse_server_hello_done( mbedtls_ssl_context *ssl )
Paul Bakker5121ce52009-01-03 21:22:43 +00003635{
Janos Follath865b3eb2019-12-16 11:46:15 +00003636 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Paul Bakker5121ce52009-01-03 21:22:43 +00003637
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003638 MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse server hello done" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00003639
Hanno Becker327c93b2018-08-15 13:56:18 +01003640 if( ( ret = mbedtls_ssl_read_record( ssl, 1 ) ) != 0 )
Paul Bakker5121ce52009-01-03 21:22:43 +00003641 {
Hanno Beckeraf0665d2017-05-24 09:16:26 +01003642 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
3643 return( ret );
Paul Bakker5121ce52009-01-03 21:22:43 +00003644 }
Hanno Beckeraf0665d2017-05-24 09:16:26 +01003645
3646 if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
3647 {
3648 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello done message" ) );
3649 return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
3650 }
Paul Bakker5121ce52009-01-03 21:22:43 +00003651
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003652 if( ssl->in_hslen != mbedtls_ssl_hs_hdr_len( ssl ) ||
3653 ssl->in_msg[0] != MBEDTLS_SSL_HS_SERVER_HELLO_DONE )
Paul Bakker5121ce52009-01-03 21:22:43 +00003654 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003655 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad server hello done message" ) );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02003656 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
3657 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003658 return( MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE );
Paul Bakker5121ce52009-01-03 21:22:43 +00003659 }
3660
3661 ssl->state++;
3662
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003663#if defined(MBEDTLS_SSL_PROTO_DTLS)
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02003664 if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003665 mbedtls_ssl_recv_flight_completed( ssl );
Manuel Pégourié-Gonnard5d8ba532014-09-19 15:09:21 +02003666#endif
3667
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003668 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse server hello done" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00003669
3670 return( 0 );
3671}
3672
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003673static int ssl_write_client_key_exchange( mbedtls_ssl_context *ssl )
Paul Bakker5121ce52009-01-03 21:22:43 +00003674{
Janos Follath865b3eb2019-12-16 11:46:15 +00003675 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003676
3677 size_t header_len;
3678 size_t content_len;
Hanno Becker0d0cd4b2017-05-11 14:06:43 +01003679 const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
Hanno Beckere694c3e2017-12-27 21:34:08 +00003680 ssl->handshake->ciphersuite_info;
Paul Bakker5121ce52009-01-03 21:22:43 +00003681
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003682 MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write client key exchange" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00003683
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003684#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
3685 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_RSA )
Paul Bakker5121ce52009-01-03 21:22:43 +00003686 {
Paul Bakker5121ce52009-01-03 21:22:43 +00003687 /*
3688 * DHM key exchange -- send G^X mod P
3689 */
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003690 content_len = ssl->handshake->dhm_ctx.len;
Paul Bakker5121ce52009-01-03 21:22:43 +00003691
Joe Subbianic54e9082021-07-19 11:56:54 +01003692 MBEDTLS_PUT_UINT16_BE( content_len, ssl->out_msg, 4 );
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003693 header_len = 6;
Paul Bakker5121ce52009-01-03 21:22:43 +00003694
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003695 ret = mbedtls_dhm_make_public( &ssl->handshake->dhm_ctx,
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003696 (int) mbedtls_mpi_size( &ssl->handshake->dhm_ctx.P ),
3697 &ssl->out_msg[header_len], content_len,
3698 ssl->conf->f_rng, ssl->conf->p_rng );
Paul Bakker5121ce52009-01-03 21:22:43 +00003699 if( ret != 0 )
3700 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003701 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_make_public", ret );
Paul Bakker5121ce52009-01-03 21:22:43 +00003702 return( ret );
3703 }
3704
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003705 MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: X ", &ssl->handshake->dhm_ctx.X );
3706 MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: GX", &ssl->handshake->dhm_ctx.GX );
Paul Bakker5121ce52009-01-03 21:22:43 +00003707
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003708 if( ( ret = mbedtls_dhm_calc_secret( &ssl->handshake->dhm_ctx,
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003709 ssl->handshake->premaster,
3710 MBEDTLS_PREMASTER_SIZE,
3711 &ssl->handshake->pmslen,
3712 ssl->conf->f_rng, ssl->conf->p_rng ) ) != 0 )
Paul Bakker5121ce52009-01-03 21:22:43 +00003713 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003714 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_calc_secret", ret );
Paul Bakker5121ce52009-01-03 21:22:43 +00003715 return( ret );
3716 }
3717
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003718 MBEDTLS_SSL_DEBUG_MPI( 3, "DHM: K ", &ssl->handshake->dhm_ctx.K );
Paul Bakker5121ce52009-01-03 21:22:43 +00003719 }
3720 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003721#endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
Hanno Becker4a63ed42019-01-08 11:39:35 +00003722#if defined(MBEDTLS_USE_PSA_CRYPTO) && \
3723 ( defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
3724 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) )
3725 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
3726 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA )
3727 {
Andrzej Kurek4b1216b2022-02-24 13:38:48 -05003728 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
3729 psa_status_t destruction_status = PSA_ERROR_CORRUPTION_DETECTED;
Janos Follath53b8ec22019-08-08 10:28:27 +01003730 psa_key_attributes_t key_attributes;
Hanno Becker4a63ed42019-01-08 11:39:35 +00003731
3732 mbedtls_ssl_handshake_params *handshake = ssl->handshake;
3733
3734 unsigned char own_pubkey[MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH];
3735 size_t own_pubkey_len;
3736 unsigned char *own_pubkey_ecpoint;
3737 size_t own_pubkey_ecpoint_len;
3738
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003739 header_len = 4;
Hanno Becker4a63ed42019-01-08 11:39:35 +00003740
Hanno Becker0a94a642019-01-11 14:35:30 +00003741 MBEDTLS_SSL_DEBUG_MSG( 1, ( "Perform PSA-based ECDH computation." ) );
3742
Hanno Becker4a63ed42019-01-08 11:39:35 +00003743 /*
3744 * Generate EC private key for ECDHE exchange.
3745 */
3746
Hanno Becker4a63ed42019-01-08 11:39:35 +00003747 /* The master secret is obtained from the shared ECDH secret by
3748 * applying the TLS 1.2 PRF with a specific salt and label. While
3749 * the PSA Crypto API encourages combining key agreement schemes
3750 * such as ECDH with fixed KDFs such as TLS 1.2 PRF, it does not
3751 * yet support the provisioning of salt + label to the KDF.
3752 * For the time being, we therefore need to split the computation
3753 * of the ECDH secret and the application of the TLS 1.2 PRF. */
Janos Follath53b8ec22019-08-08 10:28:27 +01003754 key_attributes = psa_key_attributes_init();
3755 psa_set_key_usage_flags( &key_attributes, PSA_KEY_USAGE_DERIVE );
Janos Follathdf3b0892019-08-08 11:12:24 +01003756 psa_set_key_algorithm( &key_attributes, PSA_ALG_ECDH );
Gilles Peskine42459802019-12-19 13:31:53 +01003757 psa_set_key_type( &key_attributes, handshake->ecdh_psa_type );
3758 psa_set_key_bits( &key_attributes, handshake->ecdh_bits );
Hanno Becker4a63ed42019-01-08 11:39:35 +00003759
3760 /* Generate ECDH private key. */
Janos Follath53b8ec22019-08-08 10:28:27 +01003761 status = psa_generate_key( &key_attributes,
Janos Follathdf3b0892019-08-08 11:12:24 +01003762 &handshake->ecdh_psa_privkey );
Hanno Becker4a63ed42019-01-08 11:39:35 +00003763 if( status != PSA_SUCCESS )
3764 return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
3765
3766 /* Export the public part of the ECDH private key from PSA
3767 * and convert it to ECPoint format used in ClientKeyExchange. */
3768 status = psa_export_public_key( handshake->ecdh_psa_privkey,
3769 own_pubkey, sizeof( own_pubkey ),
3770 &own_pubkey_len );
3771 if( status != PSA_SUCCESS )
Andrzej Kurek4b1216b2022-02-24 13:38:48 -05003772 {
3773 psa_destroy_key( handshake->ecdh_psa_privkey );
3774 handshake->ecdh_psa_privkey = MBEDTLS_SVC_KEY_ID_INIT;
Hanno Becker4a63ed42019-01-08 11:39:35 +00003775 return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
Andrzej Kurek4b1216b2022-02-24 13:38:48 -05003776 }
Hanno Becker4a63ed42019-01-08 11:39:35 +00003777
3778 if( mbedtls_psa_tls_psa_ec_to_ecpoint( own_pubkey,
3779 own_pubkey_len,
3780 &own_pubkey_ecpoint,
3781 &own_pubkey_ecpoint_len ) != 0 )
3782 {
Andrzej Kurek4b1216b2022-02-24 13:38:48 -05003783 psa_destroy_key( handshake->ecdh_psa_privkey );
3784 handshake->ecdh_psa_privkey = MBEDTLS_SVC_KEY_ID_INIT;
Hanno Becker4a63ed42019-01-08 11:39:35 +00003785 return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
3786 }
3787
3788 /* Copy ECPoint structure to outgoing message buffer. */
Andrzej Kurekade9e282019-05-07 08:19:33 -04003789 ssl->out_msg[header_len] = (unsigned char) own_pubkey_ecpoint_len;
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003790 memcpy( ssl->out_msg + header_len + 1,
3791 own_pubkey_ecpoint, own_pubkey_ecpoint_len );
3792 content_len = own_pubkey_ecpoint_len + 1;
Hanno Becker4a63ed42019-01-08 11:39:35 +00003793
Hanno Becker4a63ed42019-01-08 11:39:35 +00003794 /* The ECDH secret is the premaster secret used for key derivation. */
3795
Janos Follathdf3b0892019-08-08 11:12:24 +01003796 /* Compute ECDH shared secret. */
3797 status = psa_raw_key_agreement( PSA_ALG_ECDH,
3798 handshake->ecdh_psa_privkey,
3799 handshake->ecdh_psa_peerkey,
3800 handshake->ecdh_psa_peerkey_len,
3801 ssl->handshake->premaster,
3802 sizeof( ssl->handshake->premaster ),
3803 &ssl->handshake->pmslen );
Hanno Becker4a63ed42019-01-08 11:39:35 +00003804
Andrzej Kurek4b1216b2022-02-24 13:38:48 -05003805 destruction_status = psa_destroy_key( handshake->ecdh_psa_privkey );
Ronald Croncf56a0a2020-08-04 09:51:30 +02003806 handshake->ecdh_psa_privkey = MBEDTLS_SVC_KEY_ID_INIT;
Andrzej Kurek4b1216b2022-02-24 13:38:48 -05003807
3808 if( status != PSA_SUCCESS || destruction_status != PSA_SUCCESS )
3809 return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
Hanno Becker4a63ed42019-01-08 11:39:35 +00003810 }
3811 else
3812#endif /* MBEDTLS_USE_PSA_CRYPTO &&
3813 ( MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
3814 MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ) */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003815#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
3816 defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
3817 defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) || \
3818 defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
3819 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_RSA ||
3820 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA ||
3821 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_RSA ||
3822 ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA )
Paul Bakker41c83d32013-03-20 14:39:14 +01003823 {
3824 /*
3825 * ECDH key exchange -- send client public value
3826 */
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003827 header_len = 4;
Paul Bakker41c83d32013-03-20 14:39:14 +01003828
Gilles Peskineeccd8882020-03-10 12:19:08 +01003829#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02003830 if( ssl->handshake->ecrs_enabled )
3831 {
Manuel Pégourié-Gonnardc37423f2018-10-16 10:28:17 +02003832 if( ssl->handshake->ecrs_state == ssl_ecrs_cke_ecdh_calc_secret )
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02003833 goto ecdh_calc_secret;
Manuel Pégourié-Gonnard23e41622017-05-18 12:35:37 +02003834
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02003835 mbedtls_ecdh_enable_restart( &ssl->handshake->ecdh_ctx );
3836 }
Manuel Pégourié-Gonnard2350b4e2017-05-16 09:26:48 +02003837#endif
3838
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003839 ret = mbedtls_ecdh_make_public( &ssl->handshake->ecdh_ctx,
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003840 &content_len,
3841 &ssl->out_msg[header_len], 1000,
Manuel Pégourié-Gonnard750e4d72015-05-07 12:35:38 +01003842 ssl->conf->f_rng, ssl->conf->p_rng );
Paul Bakker41c83d32013-03-20 14:39:14 +01003843 if( ret != 0 )
3844 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003845 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_make_public", ret );
Gilles Peskineeccd8882020-03-10 12:19:08 +01003846#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnard558da9c2018-06-13 12:02:12 +02003847 if( ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
3848 ret = MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS;
3849#endif
Paul Bakker41c83d32013-03-20 14:39:14 +01003850 return( ret );
3851 }
3852
Andrzej Kurekc470b6b2019-01-31 08:20:20 -05003853 MBEDTLS_SSL_DEBUG_ECDH( 3, &ssl->handshake->ecdh_ctx,
3854 MBEDTLS_DEBUG_ECDH_Q );
Paul Bakker41c83d32013-03-20 14:39:14 +01003855
Gilles Peskineeccd8882020-03-10 12:19:08 +01003856#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02003857 if( ssl->handshake->ecrs_enabled )
3858 {
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003859 ssl->handshake->ecrs_n = content_len;
Manuel Pégourié-Gonnardc37423f2018-10-16 10:28:17 +02003860 ssl->handshake->ecrs_state = ssl_ecrs_cke_ecdh_calc_secret;
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02003861 }
Manuel Pégourié-Gonnard2350b4e2017-05-16 09:26:48 +02003862
3863ecdh_calc_secret:
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02003864 if( ssl->handshake->ecrs_enabled )
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003865 content_len = ssl->handshake->ecrs_n;
Manuel Pégourié-Gonnard2350b4e2017-05-16 09:26:48 +02003866#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003867 if( ( ret = mbedtls_ecdh_calc_secret( &ssl->handshake->ecdh_ctx,
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003868 &ssl->handshake->pmslen,
3869 ssl->handshake->premaster,
3870 MBEDTLS_MPI_MAX_SIZE,
3871 ssl->conf->f_rng, ssl->conf->p_rng ) ) != 0 )
Paul Bakker41c83d32013-03-20 14:39:14 +01003872 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003873 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_calc_secret", ret );
Gilles Peskineeccd8882020-03-10 12:19:08 +01003874#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnard558da9c2018-06-13 12:02:12 +02003875 if( ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
3876 ret = MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS;
3877#endif
Paul Bakker41c83d32013-03-20 14:39:14 +01003878 return( ret );
3879 }
3880
Andrzej Kurekc470b6b2019-01-31 08:20:20 -05003881 MBEDTLS_SSL_DEBUG_ECDH( 3, &ssl->handshake->ecdh_ctx,
3882 MBEDTLS_DEBUG_ECDH_Z );
Paul Bakker41c83d32013-03-20 14:39:14 +01003883 }
3884 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003885#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
3886 MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
3887 MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
3888 MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
Gilles Peskineeccd8882020-03-10 12:19:08 +01003889#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
Hanno Becker1aa267c2017-04-28 17:08:27 +01003890 if( mbedtls_ssl_ciphersuite_uses_psk( ciphersuite_info ) )
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02003891 {
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02003892 /*
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02003893 * opaque psk_identity<0..2^16-1>;
3894 */
Hanno Becker520224e2018-10-26 11:38:07 +01003895 if( ssl_conf_has_static_psk( ssl->conf ) == 0 )
Manuel Pégourié-Gonnardb4b19f32015-07-07 11:41:21 +02003896 {
Hanno Becker2e4f6162018-10-23 11:54:44 +01003897 /* We don't offer PSK suites if we don't have a PSK,
3898 * and we check that the server's choice is among the
3899 * ciphersuites we offered, so this should never happen. */
3900 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Manuel Pégourié-Gonnardb4b19f32015-07-07 11:41:21 +02003901 }
Paul Bakkerd4a56ec2013-04-16 18:05:29 +02003902
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003903 header_len = 4;
3904 content_len = ssl->conf->psk_identity_len;
Manuel Pégourié-Gonnardc6b5d832015-08-27 16:37:35 +02003905
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003906 if( header_len + 2 + content_len > MBEDTLS_SSL_OUT_CONTENT_LEN )
Manuel Pégourié-Gonnardc6b5d832015-08-27 16:37:35 +02003907 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003908 MBEDTLS_SSL_DEBUG_MSG( 1,
3909 ( "psk identity too long or SSL buffer too short" ) );
Manuel Pégourié-Gonnardc6b5d832015-08-27 16:37:35 +02003910 return( MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
3911 }
3912
Joe Subbianiad1115a2021-07-16 14:27:50 +01003913 ssl->out_msg[header_len++] = MBEDTLS_BYTE_1( content_len );
3914 ssl->out_msg[header_len++] = MBEDTLS_BYTE_0( content_len );
Paul Bakker48f7a5d2013-04-19 14:30:58 +02003915
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003916 memcpy( ssl->out_msg + header_len,
3917 ssl->conf->psk_identity,
3918 ssl->conf->psk_identity_len );
3919 header_len += ssl->conf->psk_identity_len;
Paul Bakker48f7a5d2013-04-19 14:30:58 +02003920
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003921#if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
3922 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK )
Paul Bakker48f7a5d2013-04-19 14:30:58 +02003923 {
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003924 content_len = 0;
Manuel Pégourié-Gonnardbd1ae242013-10-14 13:09:25 +02003925 }
Manuel Pégourié-Gonnard72fb62d2013-10-14 14:01:58 +02003926 else
3927#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003928#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
3929 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA_PSK )
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02003930 {
Hanno Beckerdfab8e22018-10-23 11:59:34 +01003931#if defined(MBEDTLS_USE_PSA_CRYPTO)
3932 /* Opaque PSKs are currently only supported for PSK-only suites. */
Hanno Becker520224e2018-10-26 11:38:07 +01003933 if( ssl_conf_has_static_raw_psk( ssl->conf ) == 0 )
Hanno Beckerdfab8e22018-10-23 11:59:34 +01003934 return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
3935#endif /* MBEDTLS_USE_PSA_CRYPTO */
3936
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003937 if( ( ret = ssl_write_encrypted_pms( ssl, header_len,
3938 &content_len, 2 ) ) != 0 )
Manuel Pégourié-Gonnard0fae60b2013-10-14 17:39:48 +02003939 return( ret );
3940 }
3941 else
3942#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003943#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
3944 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_DHE_PSK )
Paul Bakker48f7a5d2013-04-19 14:30:58 +02003945 {
Hanno Beckerdfab8e22018-10-23 11:59:34 +01003946#if defined(MBEDTLS_USE_PSA_CRYPTO)
3947 /* Opaque PSKs are currently only supported for PSK-only suites. */
Hanno Becker520224e2018-10-26 11:38:07 +01003948 if( ssl_conf_has_static_raw_psk( ssl->conf ) == 0 )
Hanno Beckerdfab8e22018-10-23 11:59:34 +01003949 return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
3950#endif /* MBEDTLS_USE_PSA_CRYPTO */
3951
Manuel Pégourié-Gonnard72fb62d2013-10-14 14:01:58 +02003952 /*
3953 * ClientDiffieHellmanPublic public (DHM send G^X mod P)
3954 */
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003955 content_len = ssl->handshake->dhm_ctx.len;
Manuel Pégourié-Gonnardc6b5d832015-08-27 16:37:35 +02003956
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003957 if( header_len + 2 + content_len >
3958 MBEDTLS_SSL_OUT_CONTENT_LEN )
Manuel Pégourié-Gonnardc6b5d832015-08-27 16:37:35 +02003959 {
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01003960 MBEDTLS_SSL_DEBUG_MSG( 1,
3961 ( "psk identity or DHM size too long or SSL buffer too short" ) );
Manuel Pégourié-Gonnardc6b5d832015-08-27 16:37:35 +02003962 return( MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
3963 }
3964
Joe Subbianiad1115a2021-07-16 14:27:50 +01003965 ssl->out_msg[header_len++] = MBEDTLS_BYTE_1( content_len );
3966 ssl->out_msg[header_len++] = MBEDTLS_BYTE_0( content_len );
Paul Bakker48f7a5d2013-04-19 14:30:58 +02003967
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003968 ret = mbedtls_dhm_make_public( &ssl->handshake->dhm_ctx,
3969 (int) mbedtls_mpi_size( &ssl->handshake->dhm_ctx.P ),
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003970 &ssl->out_msg[header_len], content_len,
Manuel Pégourié-Gonnard750e4d72015-05-07 12:35:38 +01003971 ssl->conf->f_rng, ssl->conf->p_rng );
Manuel Pégourié-Gonnard72fb62d2013-10-14 14:01:58 +02003972 if( ret != 0 )
3973 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003974 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_dhm_make_public", ret );
Manuel Pégourié-Gonnard72fb62d2013-10-14 14:01:58 +02003975 return( ret );
3976 }
Paul Bakker48f7a5d2013-04-19 14:30:58 +02003977 }
Manuel Pégourié-Gonnard72fb62d2013-10-14 14:01:58 +02003978 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003979#endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
3980#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
3981 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECDHE_PSK )
Manuel Pégourié-Gonnard3ce3bbd2013-10-11 16:53:50 +02003982 {
Hanno Beckerdfab8e22018-10-23 11:59:34 +01003983#if defined(MBEDTLS_USE_PSA_CRYPTO)
3984 /* Opaque PSKs are currently only supported for PSK-only suites. */
Hanno Becker520224e2018-10-26 11:38:07 +01003985 if( ssl_conf_has_static_raw_psk( ssl->conf ) == 0 )
Hanno Beckerdfab8e22018-10-23 11:59:34 +01003986 return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE );
3987#endif /* MBEDTLS_USE_PSA_CRYPTO */
3988
Manuel Pégourié-Gonnard72fb62d2013-10-14 14:01:58 +02003989 /*
3990 * ClientECDiffieHellmanPublic public;
3991 */
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00003992 ret = mbedtls_ecdh_make_public( &ssl->handshake->ecdh_ctx,
3993 &content_len,
3994 &ssl->out_msg[header_len],
3995 MBEDTLS_SSL_OUT_CONTENT_LEN - header_len,
Manuel Pégourié-Gonnard750e4d72015-05-07 12:35:38 +01003996 ssl->conf->f_rng, ssl->conf->p_rng );
Manuel Pégourié-Gonnard72fb62d2013-10-14 14:01:58 +02003997 if( ret != 0 )
3998 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003999 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecdh_make_public", ret );
Manuel Pégourié-Gonnard72fb62d2013-10-14 14:01:58 +02004000 return( ret );
4001 }
Manuel Pégourié-Gonnard3ce3bbd2013-10-11 16:53:50 +02004002
Andrzej Kurekc470b6b2019-01-31 08:20:20 -05004003 MBEDTLS_SSL_DEBUG_ECDH( 3, &ssl->handshake->ecdh_ctx,
4004 MBEDTLS_DEBUG_ECDH_Q );
Manuel Pégourié-Gonnard72fb62d2013-10-14 14:01:58 +02004005 }
4006 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004007#endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
Manuel Pégourié-Gonnard72fb62d2013-10-14 14:01:58 +02004008 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004009 MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
4010 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Paul Bakker48f7a5d2013-04-19 14:30:58 +02004011 }
4012
Hanno Beckerafd311e2018-10-23 15:26:40 +01004013#if defined(MBEDTLS_USE_PSA_CRYPTO) && \
4014 defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
4015 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_PSK &&
4016 ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 &&
Hanno Becker520224e2018-10-26 11:38:07 +01004017 ssl_conf_has_static_raw_psk( ssl->conf ) == 0 )
Hanno Beckerafd311e2018-10-23 15:26:40 +01004018 {
Ronald Cron5ee57072020-06-11 09:34:06 +02004019 MBEDTLS_SSL_DEBUG_MSG( 1,
4020 ( "skip PMS generation for opaque PSK" ) );
Hanno Beckerafd311e2018-10-23 15:26:40 +01004021 }
4022 else
4023#endif /* MBEDTLS_USE_PSA_CRYPTO &&
4024 MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004025 if( ( ret = mbedtls_ssl_psk_derive_premaster( ssl,
Manuel Pégourié-Gonnardbd1ae242013-10-14 13:09:25 +02004026 ciphersuite_info->key_exchange ) ) != 0 )
Paul Bakker48f7a5d2013-04-19 14:30:58 +02004027 {
Ronald Cron5ee57072020-06-11 09:34:06 +02004028 MBEDTLS_SSL_DEBUG_RET( 1,
4029 "mbedtls_ssl_psk_derive_premaster", ret );
Paul Bakker48f7a5d2013-04-19 14:30:58 +02004030 return( ret );
4031 }
Paul Bakker48f7a5d2013-04-19 14:30:58 +02004032 }
4033 else
Gilles Peskineeccd8882020-03-10 12:19:08 +01004034#endif /* MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004035#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
4036 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_RSA )
Paul Bakker5121ce52009-01-03 21:22:43 +00004037 {
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00004038 header_len = 4;
4039 if( ( ret = ssl_write_encrypted_pms( ssl, header_len,
4040 &content_len, 0 ) ) != 0 )
Paul Bakkera3d195c2011-11-27 21:07:34 +00004041 return( ret );
Paul Bakker5121ce52009-01-03 21:22:43 +00004042 }
Paul Bakkered27a042013-04-18 22:46:23 +02004043 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004044#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
Manuel Pégourié-Gonnard0f1660a2015-09-16 22:41:06 +02004045#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
4046 if( ciphersuite_info->key_exchange == MBEDTLS_KEY_EXCHANGE_ECJPAKE )
4047 {
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00004048 header_len = 4;
Manuel Pégourié-Gonnard0f1660a2015-09-16 22:41:06 +02004049
4050 ret = mbedtls_ecjpake_write_round_two( &ssl->handshake->ecjpake_ctx,
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00004051 ssl->out_msg + header_len,
4052 MBEDTLS_SSL_OUT_CONTENT_LEN - header_len,
4053 &content_len,
Manuel Pégourié-Gonnard0f1660a2015-09-16 22:41:06 +02004054 ssl->conf->f_rng, ssl->conf->p_rng );
4055 if( ret != 0 )
4056 {
4057 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecjpake_write_round_two", ret );
4058 return( ret );
4059 }
4060
4061 ret = mbedtls_ecjpake_derive_secret( &ssl->handshake->ecjpake_ctx,
4062 ssl->handshake->premaster, 32, &ssl->handshake->pmslen,
4063 ssl->conf->f_rng, ssl->conf->p_rng );
4064 if( ret != 0 )
4065 {
4066 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ecjpake_derive_secret", ret );
4067 return( ret );
4068 }
4069 }
4070 else
4071#endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
Paul Bakkered27a042013-04-18 22:46:23 +02004072 {
4073 ((void) ciphersuite_info);
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004074 MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
4075 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Paul Bakkered27a042013-04-18 22:46:23 +02004076 }
Paul Bakker5121ce52009-01-03 21:22:43 +00004077
Hanno Beckerc14a3bb2019-01-14 09:41:16 +00004078 ssl->out_msglen = header_len + content_len;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004079 ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
4080 ssl->out_msg[0] = MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE;
Paul Bakker5121ce52009-01-03 21:22:43 +00004081
4082 ssl->state++;
4083
Manuel Pégourié-Gonnard31c15862017-09-13 09:38:11 +02004084 if( ( ret = mbedtls_ssl_write_handshake_msg( ssl ) ) != 0 )
Paul Bakker5121ce52009-01-03 21:22:43 +00004085 {
Manuel Pégourié-Gonnard31c15862017-09-13 09:38:11 +02004086 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_handshake_msg", ret );
Paul Bakker5121ce52009-01-03 21:22:43 +00004087 return( ret );
4088 }
4089
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004090 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write client key exchange" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00004091
4092 return( 0 );
4093}
4094
Gilles Peskineeccd8882020-03-10 12:19:08 +01004095#if !defined(MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004096static int ssl_write_certificate_verify( mbedtls_ssl_context *ssl )
Paul Bakker5121ce52009-01-03 21:22:43 +00004097{
Hanno Becker0d0cd4b2017-05-11 14:06:43 +01004098 const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
Hanno Beckere694c3e2017-12-27 21:34:08 +00004099 ssl->handshake->ciphersuite_info;
Janos Follath865b3eb2019-12-16 11:46:15 +00004100 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Paul Bakker5121ce52009-01-03 21:22:43 +00004101
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004102 MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write certificate verify" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00004103
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004104 if( ( ret = mbedtls_ssl_derive_keys( ssl ) ) != 0 )
Manuel Pégourié-Gonnardada30302014-10-20 20:33:10 +02004105 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004106 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_derive_keys", ret );
Manuel Pégourié-Gonnardada30302014-10-20 20:33:10 +02004107 return( ret );
4108 }
4109
Hanno Becker77adddc2019-02-07 12:32:43 +00004110 if( !mbedtls_ssl_ciphersuite_cert_req_allowed( ciphersuite_info ) )
Paul Bakkered27a042013-04-18 22:46:23 +02004111 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004112 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate verify" ) );
Paul Bakkered27a042013-04-18 22:46:23 +02004113 ssl->state++;
4114 return( 0 );
4115 }
4116
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004117 MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
4118 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Paul Bakker48f7a5d2013-04-19 14:30:58 +02004119}
Gilles Peskineeccd8882020-03-10 12:19:08 +01004120#else /* !MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004121static int ssl_write_certificate_verify( mbedtls_ssl_context *ssl )
Paul Bakker48f7a5d2013-04-19 14:30:58 +02004122{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004123 int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
Hanno Becker0d0cd4b2017-05-11 14:06:43 +01004124 const mbedtls_ssl_ciphersuite_t *ciphersuite_info =
Hanno Beckere694c3e2017-12-27 21:34:08 +00004125 ssl->handshake->ciphersuite_info;
Paul Bakker48f7a5d2013-04-19 14:30:58 +02004126 size_t n = 0, offset = 0;
4127 unsigned char hash[48];
Manuel Pégourié-Gonnard4bd12842013-08-27 13:31:28 +02004128 unsigned char *hash_start = hash;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004129 mbedtls_md_type_t md_alg = MBEDTLS_MD_NONE;
Manuel Pégourié-Gonnardde718b92019-05-03 11:43:28 +02004130 size_t hashlen;
Manuel Pégourié-Gonnard862cde52017-05-17 11:56:15 +02004131 void *rs_ctx = NULL;
Paul Bakker48f7a5d2013-04-19 14:30:58 +02004132
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004133 MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write certificate verify" ) );
Paul Bakker48f7a5d2013-04-19 14:30:58 +02004134
Gilles Peskineeccd8882020-03-10 12:19:08 +01004135#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02004136 if( ssl->handshake->ecrs_enabled &&
Manuel Pégourié-Gonnard0b23f162017-08-24 12:08:33 +02004137 ssl->handshake->ecrs_state == ssl_ecrs_crt_vrfy_sign )
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02004138 {
Manuel Pégourié-Gonnard0b23f162017-08-24 12:08:33 +02004139 goto sign;
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02004140 }
Manuel Pégourié-Gonnard862cde52017-05-17 11:56:15 +02004141#endif
4142
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004143 if( ( ret = mbedtls_ssl_derive_keys( ssl ) ) != 0 )
Manuel Pégourié-Gonnardada30302014-10-20 20:33:10 +02004144 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004145 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_derive_keys", ret );
Manuel Pégourié-Gonnardada30302014-10-20 20:33:10 +02004146 return( ret );
4147 }
4148
Hanno Becker77adddc2019-02-07 12:32:43 +00004149 if( !mbedtls_ssl_ciphersuite_cert_req_allowed( ciphersuite_info ) )
Paul Bakker48f7a5d2013-04-19 14:30:58 +02004150 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004151 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate verify" ) );
Paul Bakker48f7a5d2013-04-19 14:30:58 +02004152 ssl->state++;
4153 return( 0 );
4154 }
4155
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004156 if( ssl->client_auth == 0 || mbedtls_ssl_own_cert( ssl ) == NULL )
Paul Bakker5121ce52009-01-03 21:22:43 +00004157 {
Johan Pascala89ca862020-08-25 10:03:19 +02004158 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= skip write certificate verify" ) );
4159 ssl->state++;
4160 return( 0 );
Paul Bakker5121ce52009-01-03 21:22:43 +00004161 }
4162
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004163 if( mbedtls_ssl_own_key( ssl ) == NULL )
Paul Bakker5121ce52009-01-03 21:22:43 +00004164 {
Manuel Pégourié-Gonnardb4b19f32015-07-07 11:41:21 +02004165 MBEDTLS_SSL_DEBUG_MSG( 1, ( "got no private key for certificate" ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004166 return( MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED );
Paul Bakker5121ce52009-01-03 21:22:43 +00004167 }
4168
4169 /*
Manuel Pégourié-Gonnard0b23f162017-08-24 12:08:33 +02004170 * Make a signature of the handshake digests
Paul Bakker5121ce52009-01-03 21:22:43 +00004171 */
Gilles Peskineeccd8882020-03-10 12:19:08 +01004172#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnard0b23f162017-08-24 12:08:33 +02004173 if( ssl->handshake->ecrs_enabled )
4174 ssl->handshake->ecrs_state = ssl_ecrs_crt_vrfy_sign;
4175
4176sign:
4177#endif
4178
Manuel Pégourié-Gonnardde718b92019-05-03 11:43:28 +02004179 ssl->handshake->calc_verify( ssl, hash, &hashlen );
Paul Bakker5121ce52009-01-03 21:22:43 +00004180
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004181#if defined(MBEDTLS_SSL_PROTO_SSL3) || defined(MBEDTLS_SSL_PROTO_TLS1) || \
4182 defined(MBEDTLS_SSL_PROTO_TLS1_1)
4183 if( ssl->minor_ver != MBEDTLS_SSL_MINOR_VERSION_3 )
Paul Bakker1ef83d62012-04-11 12:09:53 +00004184 {
Paul Bakker926af752012-11-23 13:38:07 +01004185 /*
4186 * digitally-signed struct {
4187 * opaque md5_hash[16];
4188 * opaque sha_hash[20];
4189 * };
4190 *
4191 * md5_hash
4192 * MD5(handshake_messages);
4193 *
4194 * sha_hash
4195 * SHA(handshake_messages);
4196 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004197 md_alg = MBEDTLS_MD_NONE;
Manuel Pégourié-Gonnard4bd12842013-08-27 13:31:28 +02004198
4199 /*
4200 * For ECDSA, default hash is SHA-1 only
4201 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004202 if( mbedtls_pk_can_do( mbedtls_ssl_own_key( ssl ), MBEDTLS_PK_ECDSA ) )
Manuel Pégourié-Gonnard4bd12842013-08-27 13:31:28 +02004203 {
4204 hash_start += 16;
4205 hashlen -= 16;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004206 md_alg = MBEDTLS_MD_SHA1;
Manuel Pégourié-Gonnard4bd12842013-08-27 13:31:28 +02004207 }
Paul Bakker926af752012-11-23 13:38:07 +01004208 }
4209 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004210#endif /* MBEDTLS_SSL_PROTO_SSL3 || MBEDTLS_SSL_PROTO_TLS1 || \
4211 MBEDTLS_SSL_PROTO_TLS1_1 */
4212#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
4213 if( ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_3 )
Paul Bakker926af752012-11-23 13:38:07 +01004214 {
4215 /*
4216 * digitally-signed struct {
4217 * opaque handshake_messages[handshake_messages_length];
4218 * };
4219 *
4220 * Taking shortcut here. We assume that the server always allows the
4221 * PRF Hash function and has sent it in the allowed signature
4222 * algorithms list received in the Certificate Request message.
4223 *
4224 * Until we encounter a server that does not, we will take this
4225 * shortcut.
4226 *
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01004227 * Reason: Otherwise we should have running hashes for SHA512 and
4228 * SHA224 in order to satisfy 'weird' needs from the server
4229 * side.
Paul Bakker926af752012-11-23 13:38:07 +01004230 */
Hanno Beckere694c3e2017-12-27 21:34:08 +00004231 if( ssl->handshake->ciphersuite_info->mac == MBEDTLS_MD_SHA384 )
Paul Bakkerca4ab492012-04-18 14:23:57 +00004232 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004233 md_alg = MBEDTLS_MD_SHA384;
4234 ssl->out_msg[4] = MBEDTLS_SSL_HASH_SHA384;
Paul Bakkerca4ab492012-04-18 14:23:57 +00004235 }
4236 else
4237 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004238 md_alg = MBEDTLS_MD_SHA256;
4239 ssl->out_msg[4] = MBEDTLS_SSL_HASH_SHA256;
Paul Bakkerca4ab492012-04-18 14:23:57 +00004240 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004241 ssl->out_msg[5] = mbedtls_ssl_sig_from_pk( mbedtls_ssl_own_key( ssl ) );
Paul Bakker1ef83d62012-04-11 12:09:53 +00004242
Manuel Pégourié-Gonnardbfe32ef2013-08-22 14:55:30 +02004243 /* Info from md_alg will be used instead */
4244 hashlen = 0;
Paul Bakker1ef83d62012-04-11 12:09:53 +00004245 offset = 2;
4246 }
Paul Bakkerd2f068e2013-08-27 21:19:20 +02004247 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004248#endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
Paul Bakker577e0062013-08-28 11:57:20 +02004249 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004250 MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
4251 return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
Paul Bakker577e0062013-08-28 11:57:20 +02004252 }
Paul Bakker1ef83d62012-04-11 12:09:53 +00004253
Gilles Peskineeccd8882020-03-10 12:19:08 +01004254#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnardd27d1a52017-08-15 11:49:08 +02004255 if( ssl->handshake->ecrs_enabled )
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +02004256 rs_ctx = &ssl->handshake->ecrs_ctx.pk;
Manuel Pégourié-Gonnard862cde52017-05-17 11:56:15 +02004257#endif
4258
4259 if( ( ret = mbedtls_pk_sign_restartable( mbedtls_ssl_own_key( ssl ),
4260 md_alg, hash_start, hashlen,
Manuel Pégourié-Gonnard0d420492013-08-21 16:14:26 +02004261 ssl->out_msg + 6 + offset, &n,
Manuel Pégourié-Gonnard862cde52017-05-17 11:56:15 +02004262 ssl->conf->f_rng, ssl->conf->p_rng, rs_ctx ) ) != 0 )
Manuel Pégourié-Gonnard76c18a12013-08-20 16:50:40 +02004263 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004264 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_pk_sign", ret );
Gilles Peskineeccd8882020-03-10 12:19:08 +01004265#if defined(MBEDTLS_SSL_ECP_RESTARTABLE_ENABLED)
Manuel Pégourié-Gonnard558da9c2018-06-13 12:02:12 +02004266 if( ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
4267 ret = MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS;
4268#endif
Manuel Pégourié-Gonnard0d420492013-08-21 16:14:26 +02004269 return( ret );
Manuel Pégourié-Gonnard76c18a12013-08-20 16:50:40 +02004270 }
Paul Bakker926af752012-11-23 13:38:07 +01004271
Joe Subbianic54e9082021-07-19 11:56:54 +01004272 MBEDTLS_PUT_UINT16_BE( n, ssl->out_msg, offset + 4 );
Paul Bakker5121ce52009-01-03 21:22:43 +00004273
Paul Bakker1ef83d62012-04-11 12:09:53 +00004274 ssl->out_msglen = 6 + n + offset;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004275 ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE;
4276 ssl->out_msg[0] = MBEDTLS_SSL_HS_CERTIFICATE_VERIFY;
Paul Bakker5121ce52009-01-03 21:22:43 +00004277
4278 ssl->state++;
4279
Manuel Pégourié-Gonnard31c15862017-09-13 09:38:11 +02004280 if( ( ret = mbedtls_ssl_write_handshake_msg( ssl ) ) != 0 )
Paul Bakker5121ce52009-01-03 21:22:43 +00004281 {
Manuel Pégourié-Gonnard31c15862017-09-13 09:38:11 +02004282 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_write_handshake_msg", ret );
Paul Bakker5121ce52009-01-03 21:22:43 +00004283 return( ret );
4284 }
4285
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004286 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= write certificate verify" ) );
Paul Bakker5121ce52009-01-03 21:22:43 +00004287
Paul Bakkered27a042013-04-18 22:46:23 +02004288 return( ret );
Paul Bakker5121ce52009-01-03 21:22:43 +00004289}
Gilles Peskineeccd8882020-03-10 12:19:08 +01004290#endif /* MBEDTLS_KEY_EXCHANGE_CERT_REQ_ALLOWED_ENABLED */
Paul Bakker5121ce52009-01-03 21:22:43 +00004291
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004292#if defined(MBEDTLS_SSL_SESSION_TICKETS)
4293static int ssl_parse_new_session_ticket( mbedtls_ssl_context *ssl )
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004294{
Janos Follath865b3eb2019-12-16 11:46:15 +00004295 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004296 uint32_t lifetime;
4297 size_t ticket_len;
4298 unsigned char *ticket;
Manuel Pégourié-Gonnard000d5ae2014-09-10 21:52:12 +02004299 const unsigned char *msg;
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004300
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004301 MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> parse new session ticket" ) );
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004302
Hanno Becker327c93b2018-08-15 13:56:18 +01004303 if( ( ret = mbedtls_ssl_read_record( ssl, 1 ) ) != 0 )
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004304 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004305 MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_read_record", ret );
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004306 return( ret );
4307 }
4308
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004309 if( ssl->in_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE )
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004310 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004311 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad new session ticket message" ) );
Hanno Beckerb2fff6d2017-05-08 11:06:19 +01004312 mbedtls_ssl_send_alert_message(
4313 ssl,
4314 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
4315 MBEDTLS_SSL_ALERT_MSG_UNEXPECTED_MESSAGE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004316 return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004317 }
4318
4319 /*
4320 * struct {
4321 * uint32 ticket_lifetime_hint;
4322 * opaque ticket<0..2^16-1>;
4323 * } NewSessionTicket;
4324 *
Manuel Pégourié-Gonnard000d5ae2014-09-10 21:52:12 +02004325 * 0 . 3 ticket_lifetime_hint
4326 * 4 . 5 ticket_len (n)
4327 * 6 . 5+n ticket content
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004328 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004329 if( ssl->in_msg[0] != MBEDTLS_SSL_HS_NEW_SESSION_TICKET ||
4330 ssl->in_hslen < 6 + mbedtls_ssl_hs_hdr_len( ssl ) )
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004331 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004332 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad new session ticket message" ) );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02004333 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
4334 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004335 return( MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET );
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004336 }
4337
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004338 msg = ssl->in_msg + mbedtls_ssl_hs_hdr_len( ssl );
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004339
Philippe Antoineb5b25432018-05-11 11:06:29 +02004340 lifetime = ( ((uint32_t) msg[0]) << 24 ) | ( msg[1] << 16 ) |
4341 ( msg[2] << 8 ) | ( msg[3] );
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004342
Manuel Pégourié-Gonnard000d5ae2014-09-10 21:52:12 +02004343 ticket_len = ( msg[4] << 8 ) | ( msg[5] );
4344
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004345 if( ticket_len + 6 + mbedtls_ssl_hs_hdr_len( ssl ) != ssl->in_hslen )
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004346 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004347 MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad new session ticket message" ) );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02004348 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
4349 MBEDTLS_SSL_ALERT_MSG_DECODE_ERROR );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004350 return( MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET );
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004351 }
4352
Paul Elliottd48d5c62021-01-07 14:47:05 +00004353 MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket length: %" MBEDTLS_PRINTF_SIZET, ticket_len ) );
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004354
Manuel Pégourié-Gonnard7cd59242013-08-02 13:24:41 +02004355 /* We're not waiting for a NewSessionTicket message any more */
4356 ssl->handshake->new_session_ticket = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004357 ssl->state = MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC;
Manuel Pégourié-Gonnard7cd59242013-08-02 13:24:41 +02004358
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004359 /*
4360 * Zero-length ticket means the server changed his mind and doesn't want
4361 * to send a ticket after all, so just forget it
4362 */
Paul Bakker66d5d072014-06-17 16:39:18 +02004363 if( ticket_len == 0 )
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004364 return( 0 );
4365
Hanno Beckerb2964cb2019-01-30 14:46:35 +00004366 if( ssl->session != NULL && ssl->session->ticket != NULL )
4367 {
4368 mbedtls_platform_zeroize( ssl->session->ticket,
4369 ssl->session->ticket_len );
4370 mbedtls_free( ssl->session->ticket );
4371 ssl->session->ticket = NULL;
4372 ssl->session->ticket_len = 0;
4373 }
4374
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -05004375 mbedtls_platform_zeroize( ssl->session_negotiate->ticket,
4376 ssl->session_negotiate->ticket_len );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004377 mbedtls_free( ssl->session_negotiate->ticket );
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004378 ssl->session_negotiate->ticket = NULL;
4379 ssl->session_negotiate->ticket_len = 0;
4380
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +02004381 if( ( ticket = mbedtls_calloc( 1, ticket_len ) ) == NULL )
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004382 {
Manuel Pégourié-Gonnardb2a18a22015-05-27 16:29:56 +02004383 MBEDTLS_SSL_DEBUG_MSG( 1, ( "ticket alloc failed" ) );
Gilles Peskine1cc8e342017-05-03 16:28:34 +02004384 mbedtls_ssl_send_alert_message( ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
4385 MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR );
Manuel Pégourié-Gonnard6a8ca332015-05-28 09:33:39 +02004386 return( MBEDTLS_ERR_SSL_ALLOC_FAILED );
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004387 }
4388
Manuel Pégourié-Gonnard000d5ae2014-09-10 21:52:12 +02004389 memcpy( ticket, msg + 6, ticket_len );
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004390
4391 ssl->session_negotiate->ticket = ticket;
4392 ssl->session_negotiate->ticket_len = ticket_len;
4393 ssl->session_negotiate->ticket_lifetime = lifetime;
4394
4395 /*
4396 * RFC 5077 section 3.4:
4397 * "If the client receives a session ticket from the server, then it
4398 * discards any Session ID that was sent in the ServerHello."
4399 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004400 MBEDTLS_SSL_DEBUG_MSG( 3, ( "ticket in use, discarding session id" ) );
Manuel Pégourié-Gonnard12ad7982015-06-18 15:50:37 +02004401 ssl->session_negotiate->id_len = 0;
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004402
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004403 MBEDTLS_SSL_DEBUG_MSG( 2, ( "<= parse new session ticket" ) );
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004404
4405 return( 0 );
4406}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004407#endif /* MBEDTLS_SSL_SESSION_TICKETS */
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004408
Paul Bakker5121ce52009-01-03 21:22:43 +00004409/*
Paul Bakker1961b702013-01-25 14:49:24 +01004410 * SSL handshake -- client side -- single step
Paul Bakker5121ce52009-01-03 21:22:43 +00004411 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004412int mbedtls_ssl_handshake_client_step( mbedtls_ssl_context *ssl )
Paul Bakker5121ce52009-01-03 21:22:43 +00004413{
4414 int ret = 0;
4415
Manuel Pégourié-Gonnarddba460f2015-06-24 22:59:30 +02004416 if( ssl->state == MBEDTLS_SSL_HANDSHAKE_OVER || ssl->handshake == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004417 return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
Paul Bakker5121ce52009-01-03 21:22:43 +00004418
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004419 MBEDTLS_SSL_DEBUG_MSG( 2, ( "client state: %d", ssl->state ) );
Paul Bakker1961b702013-01-25 14:49:24 +01004420
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004421 if( ( ret = mbedtls_ssl_flush_output( ssl ) ) != 0 )
Paul Bakker1961b702013-01-25 14:49:24 +01004422 return( ret );
4423
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004424#if defined(MBEDTLS_SSL_PROTO_DTLS)
Manuel Pégourié-Gonnard7ca4e4d2015-05-04 10:55:58 +02004425 if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM &&
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004426 ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING )
Manuel Pégourié-Gonnard5d8ba532014-09-19 15:09:21 +02004427 {
Manuel Pégourié-Gonnard87a346f2017-09-13 12:45:21 +02004428 if( ( ret = mbedtls_ssl_flight_transmit( ssl ) ) != 0 )
Manuel Pégourié-Gonnard5d8ba532014-09-19 15:09:21 +02004429 return( ret );
4430 }
Hanno Beckerbc2498a2018-08-28 10:13:29 +01004431#endif /* MBEDTLS_SSL_PROTO_DTLS */
Manuel Pégourié-Gonnard5d8ba532014-09-19 15:09:21 +02004432
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004433 /* Change state now, so that it is right in mbedtls_ssl_read_record(), used
Manuel Pégourié-Gonnardcd32a502014-09-20 13:54:12 +02004434 * by DTLS for dropping out-of-sequence ChangeCipherSpec records */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004435#if defined(MBEDTLS_SSL_SESSION_TICKETS)
4436 if( ssl->state == MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC &&
Manuel Pégourié-Gonnardcd32a502014-09-20 13:54:12 +02004437 ssl->handshake->new_session_ticket != 0 )
4438 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004439 ssl->state = MBEDTLS_SSL_SERVER_NEW_SESSION_TICKET;
Manuel Pégourié-Gonnardcd32a502014-09-20 13:54:12 +02004440 }
4441#endif
4442
Paul Bakker1961b702013-01-25 14:49:24 +01004443 switch( ssl->state )
Paul Bakker5121ce52009-01-03 21:22:43 +00004444 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004445 case MBEDTLS_SSL_HELLO_REQUEST:
4446 ssl->state = MBEDTLS_SSL_CLIENT_HELLO;
Paul Bakker5121ce52009-01-03 21:22:43 +00004447 break;
4448
Paul Bakker1961b702013-01-25 14:49:24 +01004449 /*
4450 * ==> ClientHello
4451 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004452 case MBEDTLS_SSL_CLIENT_HELLO:
Paul Bakker1961b702013-01-25 14:49:24 +01004453 ret = ssl_write_client_hello( ssl );
4454 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004455
Paul Bakker1961b702013-01-25 14:49:24 +01004456 /*
4457 * <== ServerHello
4458 * Certificate
4459 * ( ServerKeyExchange )
4460 * ( CertificateRequest )
4461 * ServerHelloDone
4462 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004463 case MBEDTLS_SSL_SERVER_HELLO:
Paul Bakker1961b702013-01-25 14:49:24 +01004464 ret = ssl_parse_server_hello( ssl );
4465 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004466
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004467 case MBEDTLS_SSL_SERVER_CERTIFICATE:
4468 ret = mbedtls_ssl_parse_certificate( ssl );
Paul Bakker1961b702013-01-25 14:49:24 +01004469 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004470
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004471 case MBEDTLS_SSL_SERVER_KEY_EXCHANGE:
Paul Bakker1961b702013-01-25 14:49:24 +01004472 ret = ssl_parse_server_key_exchange( ssl );
4473 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004474
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004475 case MBEDTLS_SSL_CERTIFICATE_REQUEST:
Paul Bakker1961b702013-01-25 14:49:24 +01004476 ret = ssl_parse_certificate_request( ssl );
4477 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004478
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004479 case MBEDTLS_SSL_SERVER_HELLO_DONE:
Paul Bakker1961b702013-01-25 14:49:24 +01004480 ret = ssl_parse_server_hello_done( ssl );
4481 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004482
Paul Bakker1961b702013-01-25 14:49:24 +01004483 /*
4484 * ==> ( Certificate/Alert )
4485 * ClientKeyExchange
4486 * ( CertificateVerify )
4487 * ChangeCipherSpec
4488 * Finished
4489 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004490 case MBEDTLS_SSL_CLIENT_CERTIFICATE:
4491 ret = mbedtls_ssl_write_certificate( ssl );
Paul Bakker1961b702013-01-25 14:49:24 +01004492 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004493
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004494 case MBEDTLS_SSL_CLIENT_KEY_EXCHANGE:
Paul Bakker1961b702013-01-25 14:49:24 +01004495 ret = ssl_write_client_key_exchange( ssl );
4496 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004497
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004498 case MBEDTLS_SSL_CERTIFICATE_VERIFY:
Paul Bakker1961b702013-01-25 14:49:24 +01004499 ret = ssl_write_certificate_verify( ssl );
4500 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004501
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004502 case MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC:
4503 ret = mbedtls_ssl_write_change_cipher_spec( ssl );
Paul Bakker1961b702013-01-25 14:49:24 +01004504 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004505
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004506 case MBEDTLS_SSL_CLIENT_FINISHED:
4507 ret = mbedtls_ssl_write_finished( ssl );
Paul Bakker1961b702013-01-25 14:49:24 +01004508 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004509
Paul Bakker1961b702013-01-25 14:49:24 +01004510 /*
Manuel Pégourié-Gonnarda5cc6022013-07-31 12:58:16 +02004511 * <== ( NewSessionTicket )
4512 * ChangeCipherSpec
Paul Bakker1961b702013-01-25 14:49:24 +01004513 * Finished
4514 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004515#if defined(MBEDTLS_SSL_SESSION_TICKETS)
4516 case MBEDTLS_SSL_SERVER_NEW_SESSION_TICKET:
Manuel Pégourié-Gonnardcd32a502014-09-20 13:54:12 +02004517 ret = ssl_parse_new_session_ticket( ssl );
4518 break;
Paul Bakkera503a632013-08-14 13:48:06 +02004519#endif
Manuel Pégourié-Gonnardcd32a502014-09-20 13:54:12 +02004520
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004521 case MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC:
4522 ret = mbedtls_ssl_parse_change_cipher_spec( ssl );
Paul Bakker1961b702013-01-25 14:49:24 +01004523 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004524
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004525 case MBEDTLS_SSL_SERVER_FINISHED:
4526 ret = mbedtls_ssl_parse_finished( ssl );
Paul Bakker1961b702013-01-25 14:49:24 +01004527 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004528
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004529 case MBEDTLS_SSL_FLUSH_BUFFERS:
4530 MBEDTLS_SSL_DEBUG_MSG( 2, ( "handshake: done" ) );
4531 ssl->state = MBEDTLS_SSL_HANDSHAKE_WRAPUP;
Paul Bakker1961b702013-01-25 14:49:24 +01004532 break;
Paul Bakker5121ce52009-01-03 21:22:43 +00004533
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004534 case MBEDTLS_SSL_HANDSHAKE_WRAPUP:
4535 mbedtls_ssl_handshake_wrapup( ssl );
Paul Bakker1961b702013-01-25 14:49:24 +01004536 break;
Paul Bakker48916f92012-09-16 19:57:18 +00004537
Paul Bakker1961b702013-01-25 14:49:24 +01004538 default:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004539 MBEDTLS_SSL_DEBUG_MSG( 1, ( "invalid state %d", ssl->state ) );
4540 return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
Paul Bakker1961b702013-01-25 14:49:24 +01004541 }
Paul Bakker5121ce52009-01-03 21:22:43 +00004542
4543 return( ret );
4544}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004545#endif /* MBEDTLS_SSL_CLI_C */