1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 2012 - 2021, Daniel Stenberg, <daniel@haxx.se>, et al.
9 * Copyright (C) 2010 - 2011, Hoi-Ho Chan, <hoiho.chan@gmail.com>
10 *
11 * This software is licensed as described in the file COPYING, which
12 * you should have received as part of this distribution. The terms
13 * are also available at https://curl.se/docs/copyright.html.
14 *
15 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
16 * copies of the Software, and permit persons to whom the Software is
17 * furnished to do so, under the terms of the COPYING file.
18 *
19 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20 * KIND, either express or implied.
21 *
22 ***************************************************************************/
23
24 /*
25 * Source file for all mbedTLS-specific code for the TLS/SSL layer. No code
26 * but vtls.c should ever call or use these functions.
27 *
28 */
29
30 #include "curl_setup.h"
31
32 #ifdef USE_MBEDTLS
33
34 /* Define this to enable lots of debugging for mbedTLS */
35 /* #define MBEDTLS_DEBUG */
36
37 #include <mbedtls/version.h>
38 #if MBEDTLS_VERSION_NUMBER >= 0x02040000
39 #include <mbedtls/net_sockets.h>
40 #else
41 #include <mbedtls/net.h>
42 #endif
43 #include <mbedtls/ssl.h>
44 #if MBEDTLS_VERSION_NUMBER < 0x03000000
45 #include <mbedtls/certs.h>
46 #endif
47 #include <mbedtls/x509.h>
48
49 #include <mbedtls/error.h>
50 #include <mbedtls/entropy.h>
51 #include <mbedtls/ctr_drbg.h>
52 #include <mbedtls/sha256.h>
53
54 #if MBEDTLS_VERSION_MAJOR >= 2
55 # ifdef MBEDTLS_DEBUG
56 # include <mbedtls/debug.h>
57 # endif
58 #endif
59
60 #include "urldata.h"
61 #include "sendf.h"
62 #include "inet_pton.h"
63 #include "mbedtls.h"
64 #include "vtls.h"
65 #include "parsedate.h"
66 #include "connect.h" /* for the connect timeout */
67 #include "select.h"
68 #include "multiif.h"
69 #include "mbedtls_threadlock.h"
70
71 /* The last 3 #include files should be in this order */
72 #include "curl_printf.h"
73 #include "curl_memory.h"
74 #include "memdebug.h"
75
76 struct ssl_backend_data {
77 mbedtls_ctr_drbg_context ctr_drbg;
78 mbedtls_entropy_context entropy;
79 mbedtls_ssl_context ssl;
80 int server_fd;
81 mbedtls_x509_crt cacert;
82 mbedtls_x509_crt clicert;
83 mbedtls_x509_crl crl;
84 mbedtls_pk_context pk;
85 mbedtls_ssl_config config;
86 const char *protocols[3];
87 };
88
89 /* apply threading? */
90 #if defined(USE_THREADS_POSIX) || defined(USE_THREADS_WIN32)
91 #define THREADING_SUPPORT
92 #endif
93
94 #ifndef MBEDTLS_ERROR_C
95 #define mbedtls_strerror(a,b,c) b[0] = 0
96 #endif
97
98 #if defined(THREADING_SUPPORT)
99 static mbedtls_entropy_context ts_entropy;
100
101 static int entropy_init_initialized = 0;
102
103 /* start of entropy_init_mutex() */
entropy_init_mutex(mbedtls_entropy_context * ctx)104 static void entropy_init_mutex(mbedtls_entropy_context *ctx)
105 {
106 /* lock 0 = entropy_init_mutex() */
107 Curl_mbedtlsthreadlock_lock_function(0);
108 if(entropy_init_initialized == 0) {
109 mbedtls_entropy_init(ctx);
110 entropy_init_initialized = 1;
111 }
112 Curl_mbedtlsthreadlock_unlock_function(0);
113 }
114 /* end of entropy_init_mutex() */
115
116 /* start of entropy_func_mutex() */
entropy_func_mutex(void * data,unsigned char * output,size_t len)117 static int entropy_func_mutex(void *data, unsigned char *output, size_t len)
118 {
119 int ret;
120 /* lock 1 = entropy_func_mutex() */
121 Curl_mbedtlsthreadlock_lock_function(1);
122 ret = mbedtls_entropy_func(data, output, len);
123 Curl_mbedtlsthreadlock_unlock_function(1);
124
125 return ret;
126 }
127 /* end of entropy_func_mutex() */
128
129 #endif /* THREADING_SUPPORT */
130
131 #ifdef MBEDTLS_DEBUG
mbed_debug(void * context,int level,const char * f_name,int line_nb,const char * line)132 static void mbed_debug(void *context, int level, const char *f_name,
133 int line_nb, const char *line)
134 {
135 struct Curl_easy *data = NULL;
136
137 if(!context)
138 return;
139
140 data = (struct Curl_easy *)context;
141
142 infof(data, "%s", line);
143 (void) level;
144 }
145 #else
146 #endif
147
148 /* ALPN for http2? */
149 #ifdef USE_NGHTTP2
150 # undef HAS_ALPN
151 # ifdef MBEDTLS_SSL_ALPN
152 # define HAS_ALPN
153 # endif
154 #endif
155
156
157 /*
158 * profile
159 */
160 static const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_fr =
161 {
162 /* Hashes from SHA-1 and above */
163 MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA1) |
164 MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_RIPEMD160) |
165 MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA224) |
166 MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA256) |
167 MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA384) |
168 MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA512),
169 0xFFFFFFF, /* Any PK alg */
170 0xFFFFFFF, /* Any curve */
171 1024, /* RSA min key len */
172 };
173
174 /* See https://tls.mbed.org/discussions/generic/
175 howto-determine-exact-buffer-len-for-mbedtls_pk_write_pubkey_der
176 */
177 #define RSA_PUB_DER_MAX_BYTES (38 + 2 * MBEDTLS_MPI_MAX_SIZE)
178 #define ECP_PUB_DER_MAX_BYTES (30 + 2 * MBEDTLS_ECP_MAX_BYTES)
179
180 #define PUB_DER_MAX_BYTES (RSA_PUB_DER_MAX_BYTES > ECP_PUB_DER_MAX_BYTES ? \
181 RSA_PUB_DER_MAX_BYTES : ECP_PUB_DER_MAX_BYTES)
182
183 static Curl_recv mbed_recv;
184 static Curl_send mbed_send;
185
mbedtls_version_from_curl(int * mbedver,long version)186 static CURLcode mbedtls_version_from_curl(int *mbedver, long version)
187 {
188 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
189 switch(version) {
190 case CURL_SSLVERSION_TLSv1_0:
191 case CURL_SSLVERSION_TLSv1_1:
192 case CURL_SSLVERSION_TLSv1_2:
193 *mbedver = MBEDTLS_SSL_MINOR_VERSION_3;
194 return CURLE_OK;
195 case CURL_SSLVERSION_TLSv1_3:
196 break;
197 }
198 #else
199 switch(version) {
200 case CURL_SSLVERSION_TLSv1_0:
201 *mbedver = MBEDTLS_SSL_MINOR_VERSION_1;
202 return CURLE_OK;
203 case CURL_SSLVERSION_TLSv1_1:
204 *mbedver = MBEDTLS_SSL_MINOR_VERSION_2;
205 return CURLE_OK;
206 case CURL_SSLVERSION_TLSv1_2:
207 *mbedver = MBEDTLS_SSL_MINOR_VERSION_3;
208 return CURLE_OK;
209 case CURL_SSLVERSION_TLSv1_3:
210 break;
211 }
212 #endif
213
214 return CURLE_SSL_CONNECT_ERROR;
215 }
216
217 static CURLcode
set_ssl_version_min_max(struct Curl_easy * data,struct connectdata * conn,int sockindex)218 set_ssl_version_min_max(struct Curl_easy *data, struct connectdata *conn,
219 int sockindex)
220 {
221 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
222 struct ssl_backend_data *backend = connssl->backend;
223 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
224 int mbedtls_ver_min = MBEDTLS_SSL_MINOR_VERSION_3;
225 int mbedtls_ver_max = MBEDTLS_SSL_MINOR_VERSION_3;
226 #else
227 int mbedtls_ver_min = MBEDTLS_SSL_MINOR_VERSION_1;
228 int mbedtls_ver_max = MBEDTLS_SSL_MINOR_VERSION_1;
229 #endif
230 long ssl_version = SSL_CONN_CONFIG(version);
231 long ssl_version_max = SSL_CONN_CONFIG(version_max);
232 CURLcode result = CURLE_OK;
233
234 switch(ssl_version) {
235 case CURL_SSLVERSION_DEFAULT:
236 case CURL_SSLVERSION_TLSv1:
237 ssl_version = CURL_SSLVERSION_TLSv1_0;
238 break;
239 }
240
241 switch(ssl_version_max) {
242 case CURL_SSLVERSION_MAX_NONE:
243 case CURL_SSLVERSION_MAX_DEFAULT:
244 ssl_version_max = CURL_SSLVERSION_MAX_TLSv1_2;
245 break;
246 }
247
248 result = mbedtls_version_from_curl(&mbedtls_ver_min, ssl_version);
249 if(result) {
250 failf(data, "unsupported min version passed via CURLOPT_SSLVERSION");
251 return result;
252 }
253 result = mbedtls_version_from_curl(&mbedtls_ver_max, ssl_version_max >> 16);
254 if(result) {
255 failf(data, "unsupported max version passed via CURLOPT_SSLVERSION");
256 return result;
257 }
258
259 mbedtls_ssl_conf_min_version(&backend->config, MBEDTLS_SSL_MAJOR_VERSION_3,
260 mbedtls_ver_min);
261 mbedtls_ssl_conf_max_version(&backend->config, MBEDTLS_SSL_MAJOR_VERSION_3,
262 mbedtls_ver_max);
263
264 return result;
265 }
266
267 static CURLcode
mbed_connect_step1(struct Curl_easy * data,struct connectdata * conn,int sockindex)268 mbed_connect_step1(struct Curl_easy *data, struct connectdata *conn,
269 int sockindex)
270 {
271 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
272 struct ssl_backend_data *backend = connssl->backend;
273 const char * const ssl_cafile = SSL_CONN_CONFIG(CAfile);
274 const bool verifypeer = SSL_CONN_CONFIG(verifypeer);
275 const char * const ssl_capath = SSL_CONN_CONFIG(CApath);
276 char * const ssl_cert = SSL_SET_OPTION(primary.clientcert);
277 const struct curl_blob *ssl_cert_blob = SSL_SET_OPTION(primary.cert_blob);
278 const char * const ssl_crlfile = SSL_SET_OPTION(CRLfile);
279 const char * const hostname = SSL_HOST_NAME();
280 #ifndef CURL_DISABLE_VERBOSE_STRINGS
281 const long int port = SSL_HOST_PORT();
282 #endif
283 int ret = -1;
284 char errorbuf[128];
285
286 if((SSL_CONN_CONFIG(version) == CURL_SSLVERSION_SSLv2) ||
287 (SSL_CONN_CONFIG(version) == CURL_SSLVERSION_SSLv3)) {
288 failf(data, "Not supported SSL version");
289 return CURLE_NOT_BUILT_IN;
290 }
291
292 #ifdef THREADING_SUPPORT
293 entropy_init_mutex(&ts_entropy);
294 mbedtls_ctr_drbg_init(&backend->ctr_drbg);
295
296 ret = mbedtls_ctr_drbg_seed(&backend->ctr_drbg, entropy_func_mutex,
297 &ts_entropy, NULL, 0);
298 if(ret) {
299 mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
300 failf(data, "Failed - mbedTLS: ctr_drbg_init returned (-0x%04X) %s",
301 -ret, errorbuf);
302 }
303 #else
304 mbedtls_entropy_init(&backend->entropy);
305 mbedtls_ctr_drbg_init(&backend->ctr_drbg);
306
307 ret = mbedtls_ctr_drbg_seed(&backend->ctr_drbg, mbedtls_entropy_func,
308 &backend->entropy, NULL, 0);
309 if(ret) {
310 mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
311 failf(data, "Failed - mbedTLS: ctr_drbg_init returned (-0x%04X) %s",
312 -ret, errorbuf);
313 }
314 #endif /* THREADING_SUPPORT */
315
316 /* Load the trusted CA */
317 mbedtls_x509_crt_init(&backend->cacert);
318
319 if(ssl_cafile) {
320 ret = mbedtls_x509_crt_parse_file(&backend->cacert, ssl_cafile);
321
322 if(ret<0) {
323 mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
324 failf(data, "Error reading ca cert file %s - mbedTLS: (-0x%04X) %s",
325 ssl_cafile, -ret, errorbuf);
326
327 if(verifypeer)
328 return CURLE_SSL_CACERT_BADFILE;
329 }
330 }
331
332 if(ssl_capath) {
333 ret = mbedtls_x509_crt_parse_path(&backend->cacert, ssl_capath);
334
335 if(ret<0) {
336 mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
337 failf(data, "Error reading ca cert path %s - mbedTLS: (-0x%04X) %s",
338 ssl_capath, -ret, errorbuf);
339
340 if(verifypeer)
341 return CURLE_SSL_CACERT_BADFILE;
342 }
343 }
344
345 /* Load the client certificate */
346 mbedtls_x509_crt_init(&backend->clicert);
347
348 if(ssl_cert) {
349 ret = mbedtls_x509_crt_parse_file(&backend->clicert, ssl_cert);
350
351 if(ret) {
352 mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
353 failf(data, "Error reading client cert file %s - mbedTLS: (-0x%04X) %s",
354 ssl_cert, -ret, errorbuf);
355
356 return CURLE_SSL_CERTPROBLEM;
357 }
358 }
359
360 if(ssl_cert_blob) {
361 const unsigned char *blob_data =
362 (const unsigned char *)ssl_cert_blob->data;
363 ret = mbedtls_x509_crt_parse(&backend->clicert, blob_data,
364 ssl_cert_blob->len);
365
366 if(ret) {
367 mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
368 failf(data, "Error reading private key %s - mbedTLS: (-0x%04X) %s",
369 SSL_SET_OPTION(key), -ret, errorbuf);
370 return CURLE_SSL_CERTPROBLEM;
371 }
372 }
373
374 /* Load the client private key */
375 mbedtls_pk_init(&backend->pk);
376
377 if(SSL_SET_OPTION(key) || SSL_SET_OPTION(key_blob)) {
378 if(SSL_SET_OPTION(key)) {
379 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
380 ret = mbedtls_pk_parse_keyfile(&backend->pk, SSL_SET_OPTION(key),
381 SSL_SET_OPTION(key_passwd),
382 mbedtls_ctr_drbg_random,
383 &backend->ctr_drbg);
384 #else
385 ret = mbedtls_pk_parse_keyfile(&backend->pk, SSL_SET_OPTION(key),
386 SSL_SET_OPTION(key_passwd));
387 #endif
388
389 if(ret) {
390 mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
391 failf(data, "Error reading private key %s - mbedTLS: (-0x%04X) %s",
392 SSL_SET_OPTION(key), -ret, errorbuf);
393 return CURLE_SSL_CERTPROBLEM;
394 }
395 }
396 else {
397 const struct curl_blob *ssl_key_blob = SSL_SET_OPTION(key_blob);
398 const unsigned char *key_data =
399 (const unsigned char *)ssl_key_blob->data;
400 const char *passwd = SSL_SET_OPTION(key_passwd);
401 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
402 ret = mbedtls_pk_parse_key(&backend->pk, key_data, ssl_key_blob->len,
403 (const unsigned char *)passwd,
404 passwd ? strlen(passwd) : 0,
405 mbedtls_ctr_drbg_random,
406 &backend->ctr_drbg);
407 #else
408 ret = mbedtls_pk_parse_key(&backend->pk, key_data, ssl_key_blob->len,
409 (const unsigned char *)passwd,
410 passwd ? strlen(passwd) : 0);
411 #endif
412
413 if(ret) {
414 mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
415 failf(data, "Error parsing private key - mbedTLS: (-0x%04X) %s",
416 -ret, errorbuf);
417 return CURLE_SSL_CERTPROBLEM;
418 }
419 }
420
421 if(ret == 0 && !(mbedtls_pk_can_do(&backend->pk, MBEDTLS_PK_RSA) ||
422 mbedtls_pk_can_do(&backend->pk, MBEDTLS_PK_ECKEY)))
423 ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
424 }
425
426 /* Load the CRL */
427 mbedtls_x509_crl_init(&backend->crl);
428
429 if(ssl_crlfile) {
430 ret = mbedtls_x509_crl_parse_file(&backend->crl, ssl_crlfile);
431
432 if(ret) {
433 mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
434 failf(data, "Error reading CRL file %s - mbedTLS: (-0x%04X) %s",
435 ssl_crlfile, -ret, errorbuf);
436
437 return CURLE_SSL_CRL_BADFILE;
438 }
439 }
440
441 infof(data, "mbedTLS: Connecting to %s:%ld", hostname, port);
442
443 mbedtls_ssl_config_init(&backend->config);
444
445 mbedtls_ssl_init(&backend->ssl);
446 if(mbedtls_ssl_setup(&backend->ssl, &backend->config)) {
447 failf(data, "mbedTLS: ssl_init failed");
448 return CURLE_SSL_CONNECT_ERROR;
449 }
450 ret = mbedtls_ssl_config_defaults(&backend->config,
451 MBEDTLS_SSL_IS_CLIENT,
452 MBEDTLS_SSL_TRANSPORT_STREAM,
453 MBEDTLS_SSL_PRESET_DEFAULT);
454 if(ret) {
455 failf(data, "mbedTLS: ssl_config failed");
456 return CURLE_SSL_CONNECT_ERROR;
457 }
458
459 /* new profile with RSA min key len = 1024 ... */
460 mbedtls_ssl_conf_cert_profile(&backend->config,
461 &mbedtls_x509_crt_profile_fr);
462
463 switch(SSL_CONN_CONFIG(version)) {
464 case CURL_SSLVERSION_DEFAULT:
465 case CURL_SSLVERSION_TLSv1:
466 #if MBEDTLS_VERSION_NUMBER < 0x03000000
467 mbedtls_ssl_conf_min_version(&backend->config, MBEDTLS_SSL_MAJOR_VERSION_3,
468 MBEDTLS_SSL_MINOR_VERSION_1);
469 infof(data, "mbedTLS: Set min SSL version to TLS 1.0");
470 break;
471 #endif
472 case CURL_SSLVERSION_TLSv1_0:
473 case CURL_SSLVERSION_TLSv1_1:
474 case CURL_SSLVERSION_TLSv1_2:
475 case CURL_SSLVERSION_TLSv1_3:
476 {
477 CURLcode result = set_ssl_version_min_max(data, conn, sockindex);
478 if(result != CURLE_OK)
479 return result;
480 break;
481 }
482 default:
483 failf(data, "Unrecognized parameter passed via CURLOPT_SSLVERSION");
484 return CURLE_SSL_CONNECT_ERROR;
485 }
486
487 mbedtls_ssl_conf_authmode(&backend->config, MBEDTLS_SSL_VERIFY_OPTIONAL);
488
489 mbedtls_ssl_conf_rng(&backend->config, mbedtls_ctr_drbg_random,
490 &backend->ctr_drbg);
491 mbedtls_ssl_set_bio(&backend->ssl, &conn->sock[sockindex],
492 mbedtls_net_send,
493 mbedtls_net_recv,
494 NULL /* rev_timeout() */);
495
496 mbedtls_ssl_conf_ciphersuites(&backend->config,
497 mbedtls_ssl_list_ciphersuites());
498
499 #if defined(MBEDTLS_SSL_RENEGOTIATION)
500 mbedtls_ssl_conf_renegotiation(&backend->config,
501 MBEDTLS_SSL_RENEGOTIATION_ENABLED);
502 #endif
503
504 #if defined(MBEDTLS_SSL_SESSION_TICKETS)
505 mbedtls_ssl_conf_session_tickets(&backend->config,
506 MBEDTLS_SSL_SESSION_TICKETS_DISABLED);
507 #endif
508
509 /* Check if there's a cached ID we can/should use here! */
510 if(SSL_SET_OPTION(primary.sessionid)) {
511 void *old_session = NULL;
512
513 Curl_ssl_sessionid_lock(data);
514 if(!Curl_ssl_getsessionid(data, conn,
515 SSL_IS_PROXY() ? TRUE : FALSE,
516 &old_session, NULL, sockindex)) {
517 ret = mbedtls_ssl_set_session(&backend->ssl, old_session);
518 if(ret) {
519 Curl_ssl_sessionid_unlock(data);
520 failf(data, "mbedtls_ssl_set_session returned -0x%x", -ret);
521 return CURLE_SSL_CONNECT_ERROR;
522 }
523 infof(data, "mbedTLS re-using session");
524 }
525 Curl_ssl_sessionid_unlock(data);
526 }
527
528 mbedtls_ssl_conf_ca_chain(&backend->config,
529 &backend->cacert,
530 &backend->crl);
531
532 if(SSL_SET_OPTION(key) || SSL_SET_OPTION(key_blob)) {
533 mbedtls_ssl_conf_own_cert(&backend->config,
534 &backend->clicert, &backend->pk);
535 }
536 if(mbedtls_ssl_set_hostname(&backend->ssl, hostname)) {
537 /* mbedtls_ssl_set_hostname() sets the name to use in CN/SAN checks *and*
538 the name to set in the SNI extension. So even if curl connects to a
539 host specified as an IP address, this function must be used. */
540 failf(data, "couldn't set hostname in mbedTLS");
541 return CURLE_SSL_CONNECT_ERROR;
542 }
543
544 #ifdef HAS_ALPN
545 if(conn->bits.tls_enable_alpn) {
546 const char **p = &backend->protocols[0];
547 #ifdef USE_NGHTTP2
548 if(data->state.httpwant >= CURL_HTTP_VERSION_2)
549 *p++ = NGHTTP2_PROTO_VERSION_ID;
550 #endif
551 *p++ = ALPN_HTTP_1_1;
552 *p = NULL;
553 /* this function doesn't clone the protocols array, which is why we need
554 to keep it around */
555 if(mbedtls_ssl_conf_alpn_protocols(&backend->config,
556 &backend->protocols[0])) {
557 failf(data, "Failed setting ALPN protocols");
558 return CURLE_SSL_CONNECT_ERROR;
559 }
560 for(p = &backend->protocols[0]; *p; ++p)
561 infof(data, "ALPN, offering %s", *p);
562 }
563 #endif
564
565 #ifdef MBEDTLS_DEBUG
566 /* In order to make that work in mbedtls MBEDTLS_DEBUG_C must be defined. */
567 mbedtls_ssl_conf_dbg(&backend->config, mbed_debug, data);
568 /* - 0 No debug
569 * - 1 Error
570 * - 2 State change
571 * - 3 Informational
572 * - 4 Verbose
573 */
574 mbedtls_debug_set_threshold(4);
575 #endif
576
577 /* give application a chance to interfere with mbedTLS set up. */
578 if(data->set.ssl.fsslctx) {
579 ret = (*data->set.ssl.fsslctx)(data, &backend->config,
580 data->set.ssl.fsslctxp);
581 if(ret) {
582 failf(data, "error signaled by ssl ctx callback");
583 return ret;
584 }
585 }
586
587 connssl->connecting_state = ssl_connect_2;
588
589 return CURLE_OK;
590 }
591
592 static CURLcode
mbed_connect_step2(struct Curl_easy * data,struct connectdata * conn,int sockindex)593 mbed_connect_step2(struct Curl_easy *data, struct connectdata *conn,
594 int sockindex)
595 {
596 int ret;
597 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
598 struct ssl_backend_data *backend = connssl->backend;
599 const mbedtls_x509_crt *peercert;
600 const char * const pinnedpubkey = SSL_PINNED_PUB_KEY();
601
602 conn->recv[sockindex] = mbed_recv;
603 conn->send[sockindex] = mbed_send;
604
605 ret = mbedtls_ssl_handshake(&backend->ssl);
606
607 if(ret == MBEDTLS_ERR_SSL_WANT_READ) {
608 connssl->connecting_state = ssl_connect_2_reading;
609 return CURLE_OK;
610 }
611 else if(ret == MBEDTLS_ERR_SSL_WANT_WRITE) {
612 connssl->connecting_state = ssl_connect_2_writing;
613 return CURLE_OK;
614 }
615 else if(ret) {
616 char errorbuf[128];
617 mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
618 failf(data, "ssl_handshake returned - mbedTLS: (-0x%04X) %s",
619 -ret, errorbuf);
620 return CURLE_SSL_CONNECT_ERROR;
621 }
622
623 infof(data, "mbedTLS: Handshake complete, cipher is %s",
624 mbedtls_ssl_get_ciphersuite(&backend->ssl));
625
626 ret = mbedtls_ssl_get_verify_result(&backend->ssl);
627
628 if(!SSL_CONN_CONFIG(verifyhost))
629 /* Ignore hostname errors if verifyhost is disabled */
630 ret &= ~MBEDTLS_X509_BADCERT_CN_MISMATCH;
631
632 if(ret && SSL_CONN_CONFIG(verifypeer)) {
633 if(ret & MBEDTLS_X509_BADCERT_EXPIRED)
634 failf(data, "Cert verify failed: BADCERT_EXPIRED");
635
636 else if(ret & MBEDTLS_X509_BADCERT_REVOKED)
637 failf(data, "Cert verify failed: BADCERT_REVOKED");
638
639 else if(ret & MBEDTLS_X509_BADCERT_CN_MISMATCH)
640 failf(data, "Cert verify failed: BADCERT_CN_MISMATCH");
641
642 else if(ret & MBEDTLS_X509_BADCERT_NOT_TRUSTED)
643 failf(data, "Cert verify failed: BADCERT_NOT_TRUSTED");
644
645 else if(ret & MBEDTLS_X509_BADCERT_FUTURE)
646 failf(data, "Cert verify failed: BADCERT_FUTURE");
647
648 return CURLE_PEER_FAILED_VERIFICATION;
649 }
650
651 peercert = mbedtls_ssl_get_peer_cert(&backend->ssl);
652
653 if(peercert && data->set.verbose) {
654 const size_t bufsize = 16384;
655 char *buffer = malloc(bufsize);
656
657 if(!buffer)
658 return CURLE_OUT_OF_MEMORY;
659
660 if(mbedtls_x509_crt_info(buffer, bufsize, "* ", peercert) > 0)
661 infof(data, "Dumping cert info: %s", buffer);
662 else
663 infof(data, "Unable to dump certificate information");
664
665 free(buffer);
666 }
667
668 if(pinnedpubkey) {
669 int size;
670 CURLcode result;
671 mbedtls_x509_crt *p = NULL;
672 unsigned char *pubkey = NULL;
673
674 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
675 if(!peercert || !peercert->MBEDTLS_PRIVATE(raw).MBEDTLS_PRIVATE(p) ||
676 !peercert->MBEDTLS_PRIVATE(raw).MBEDTLS_PRIVATE(len)) {
677 #else
678 if(!peercert || !peercert->raw.p || !peercert->raw.len) {
679 #endif
680 failf(data, "Failed due to missing peer certificate");
681 return CURLE_SSL_PINNEDPUBKEYNOTMATCH;
682 }
683
684 p = calloc(1, sizeof(*p));
685
686 if(!p)
687 return CURLE_OUT_OF_MEMORY;
688
689 pubkey = malloc(PUB_DER_MAX_BYTES);
690
691 if(!pubkey) {
692 result = CURLE_OUT_OF_MEMORY;
693 goto pinnedpubkey_error;
694 }
695
696 mbedtls_x509_crt_init(p);
697
698 /* Make a copy of our const peercert because mbedtls_pk_write_pubkey_der
699 needs a non-const key, for now.
700 https://github.com/ARMmbed/mbedtls/issues/396 */
701 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
702 if(mbedtls_x509_crt_parse_der(p,
703 peercert->MBEDTLS_PRIVATE(raw).MBEDTLS_PRIVATE(p),
704 peercert->MBEDTLS_PRIVATE(raw).MBEDTLS_PRIVATE(len))) {
705 #else
706 if(mbedtls_x509_crt_parse_der(p, peercert->raw.p, peercert->raw.len)) {
707 #endif
708 failf(data, "Failed copying peer certificate");
709 result = CURLE_SSL_PINNEDPUBKEYNOTMATCH;
710 goto pinnedpubkey_error;
711 }
712
713 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
714 size = mbedtls_pk_write_pubkey_der(&p->MBEDTLS_PRIVATE(pk), pubkey,
715 PUB_DER_MAX_BYTES);
716 #else
717 size = mbedtls_pk_write_pubkey_der(&p->pk, pubkey, PUB_DER_MAX_BYTES);
718 #endif
719
720 if(size <= 0) {
721 failf(data, "Failed copying public key from peer certificate");
722 result = CURLE_SSL_PINNEDPUBKEYNOTMATCH;
723 goto pinnedpubkey_error;
724 }
725
726 /* mbedtls_pk_write_pubkey_der writes data at the end of the buffer. */
727 result = Curl_pin_peer_pubkey(data,
728 pinnedpubkey,
729 &pubkey[PUB_DER_MAX_BYTES - size], size);
730 pinnedpubkey_error:
731 mbedtls_x509_crt_free(p);
732 free(p);
733 free(pubkey);
734 if(result) {
735 return result;
736 }
737 }
738
739 #ifdef HAS_ALPN
740 if(conn->bits.tls_enable_alpn) {
741 const char *next_protocol = mbedtls_ssl_get_alpn_protocol(&backend->ssl);
742
743 if(next_protocol) {
744 infof(data, "ALPN, server accepted to use %s", next_protocol);
745 #ifdef USE_NGHTTP2
746 if(!strncmp(next_protocol, NGHTTP2_PROTO_VERSION_ID,
747 NGHTTP2_PROTO_VERSION_ID_LEN) &&
748 !next_protocol[NGHTTP2_PROTO_VERSION_ID_LEN]) {
749 conn->negnpn = CURL_HTTP_VERSION_2;
750 }
751 else
752 #endif
753 if(!strncmp(next_protocol, ALPN_HTTP_1_1, ALPN_HTTP_1_1_LENGTH) &&
754 !next_protocol[ALPN_HTTP_1_1_LENGTH]) {
755 conn->negnpn = CURL_HTTP_VERSION_1_1;
756 }
757 }
758 else {
759 infof(data, "ALPN, server did not agree to a protocol");
760 }
761 Curl_multiuse_state(data, conn->negnpn == CURL_HTTP_VERSION_2 ?
762 BUNDLE_MULTIPLEX : BUNDLE_NO_MULTIUSE);
763 }
764 #endif
765
766 connssl->connecting_state = ssl_connect_3;
767 infof(data, "SSL connected");
768
769 return CURLE_OK;
770 }
771
772 static CURLcode
773 mbed_connect_step3(struct Curl_easy *data, struct connectdata *conn,
774 int sockindex)
775 {
776 CURLcode retcode = CURLE_OK;
777 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
778 struct ssl_backend_data *backend = connssl->backend;
779
780 DEBUGASSERT(ssl_connect_3 == connssl->connecting_state);
781
782 if(SSL_SET_OPTION(primary.sessionid)) {
783 int ret;
784 mbedtls_ssl_session *our_ssl_sessionid;
785 void *old_ssl_sessionid = NULL;
786 bool isproxy = SSL_IS_PROXY() ? TRUE : FALSE;
787 bool added = FALSE;
788
789 our_ssl_sessionid = malloc(sizeof(mbedtls_ssl_session));
790 if(!our_ssl_sessionid)
791 return CURLE_OUT_OF_MEMORY;
792
793 mbedtls_ssl_session_init(our_ssl_sessionid);
794
795 ret = mbedtls_ssl_get_session(&backend->ssl, our_ssl_sessionid);
796 if(ret) {
797 if(ret != MBEDTLS_ERR_SSL_ALLOC_FAILED)
798 mbedtls_ssl_session_free(our_ssl_sessionid);
799 free(our_ssl_sessionid);
800 failf(data, "mbedtls_ssl_get_session returned -0x%x", -ret);
801 return CURLE_SSL_CONNECT_ERROR;
802 }
803
804 /* If there's already a matching session in the cache, delete it */
805 Curl_ssl_sessionid_lock(data);
806 if(!Curl_ssl_getsessionid(data, conn, isproxy, &old_ssl_sessionid, NULL,
807 sockindex))
808 Curl_ssl_delsessionid(data, old_ssl_sessionid);
809
810 retcode = Curl_ssl_addsessionid(data, conn, isproxy, our_ssl_sessionid,
811 0, sockindex, &added);
812 Curl_ssl_sessionid_unlock(data);
813 if(!added) {
814 mbedtls_ssl_session_free(our_ssl_sessionid);
815 free(our_ssl_sessionid);
816 }
817 if(retcode) {
818 failf(data, "failed to store ssl session");
819 return retcode;
820 }
821 }
822
823 connssl->connecting_state = ssl_connect_done;
824
825 return CURLE_OK;
826 }
827
828 static ssize_t mbed_send(struct Curl_easy *data, int sockindex,
829 const void *mem, size_t len,
830 CURLcode *curlcode)
831 {
832 struct connectdata *conn = data->conn;
833 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
834 struct ssl_backend_data *backend = connssl->backend;
835 int ret = -1;
836
837 ret = mbedtls_ssl_write(&backend->ssl, (unsigned char *)mem, len);
838
839 if(ret < 0) {
840 *curlcode = (ret == MBEDTLS_ERR_SSL_WANT_WRITE) ?
841 CURLE_AGAIN : CURLE_SEND_ERROR;
842 ret = -1;
843 }
844
845 return ret;
846 }
847
848 static void mbedtls_close_all(struct Curl_easy *data)
849 {
850 (void)data;
851 }
852
853 static void mbedtls_close(struct Curl_easy *data,
854 struct connectdata *conn, int sockindex)
855 {
856 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
857 struct ssl_backend_data *backend = connssl->backend;
858 char buf[32];
859 (void) data;
860
861 /* Maybe the server has already sent a close notify alert.
862 Read it to avoid an RST on the TCP connection. */
863 (void)mbedtls_ssl_read(&backend->ssl, (unsigned char *)buf, sizeof(buf));
864
865 mbedtls_pk_free(&backend->pk);
866 mbedtls_x509_crt_free(&backend->clicert);
867 mbedtls_x509_crt_free(&backend->cacert);
868 mbedtls_x509_crl_free(&backend->crl);
869 mbedtls_ssl_config_free(&backend->config);
870 mbedtls_ssl_free(&backend->ssl);
871 mbedtls_ctr_drbg_free(&backend->ctr_drbg);
872 #ifndef THREADING_SUPPORT
873 mbedtls_entropy_free(&backend->entropy);
874 #endif /* THREADING_SUPPORT */
875 }
876
877 static ssize_t mbed_recv(struct Curl_easy *data, int num,
878 char *buf, size_t buffersize,
879 CURLcode *curlcode)
880 {
881 struct connectdata *conn = data->conn;
882 struct ssl_connect_data *connssl = &conn->ssl[num];
883 struct ssl_backend_data *backend = connssl->backend;
884 int ret = -1;
885 ssize_t len = -1;
886
887 ret = mbedtls_ssl_read(&backend->ssl, (unsigned char *)buf,
888 buffersize);
889
890 if(ret <= 0) {
891 if(ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY)
892 return 0;
893
894 *curlcode = (ret == MBEDTLS_ERR_SSL_WANT_READ) ?
895 CURLE_AGAIN : CURLE_RECV_ERROR;
896 return -1;
897 }
898
899 len = ret;
900
901 return len;
902 }
903
904 static void mbedtls_session_free(void *ptr)
905 {
906 mbedtls_ssl_session_free(ptr);
907 free(ptr);
908 }
909
910 static size_t mbedtls_version(char *buffer, size_t size)
911 {
912 #ifdef MBEDTLS_VERSION_C
913 /* if mbedtls_version_get_number() is available it is better */
914 unsigned int version = mbedtls_version_get_number();
915 return msnprintf(buffer, size, "mbedTLS/%u.%u.%u", version>>24,
916 (version>>16)&0xff, (version>>8)&0xff);
917 #else
918 return msnprintf(buffer, size, "mbedTLS/%s", MBEDTLS_VERSION_STRING);
919 #endif
920 }
921
922 static CURLcode mbedtls_random(struct Curl_easy *data,
923 unsigned char *entropy, size_t length)
924 {
925 #if defined(MBEDTLS_CTR_DRBG_C)
926 int ret = -1;
927 char errorbuf[128];
928 mbedtls_entropy_context ctr_entropy;
929 mbedtls_ctr_drbg_context ctr_drbg;
930 mbedtls_entropy_init(&ctr_entropy);
931 mbedtls_ctr_drbg_init(&ctr_drbg);
932
933 ret = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func,
934 &ctr_entropy, NULL, 0);
935
936 if(ret) {
937 mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
938 failf(data, "Failed - mbedTLS: ctr_drbg_seed returned (-0x%04X) %s",
939 -ret, errorbuf);
940 }
941 else {
942 ret = mbedtls_ctr_drbg_random(&ctr_drbg, entropy, length);
943
944 if(ret) {
945 mbedtls_strerror(ret, errorbuf, sizeof(errorbuf));
946 failf(data, "mbedTLS: ctr_drbg_init returned (-0x%04X) %s",
947 -ret, errorbuf);
948 }
949 }
950
951 mbedtls_ctr_drbg_free(&ctr_drbg);
952 mbedtls_entropy_free(&ctr_entropy);
953
954 return ret == 0 ? CURLE_OK : CURLE_FAILED_INIT;
955 #elif defined(MBEDTLS_HAVEGE_C)
956 mbedtls_havege_state hs;
957 mbedtls_havege_init(&hs);
958 mbedtls_havege_random(&hs, entropy, length);
959 mbedtls_havege_free(&hs);
960 return CURLE_OK;
961 #else
962 return CURLE_NOT_BUILT_IN;
963 #endif
964 }
965
966 static CURLcode
967 mbed_connect_common(struct Curl_easy *data,
968 struct connectdata *conn,
969 int sockindex,
970 bool nonblocking,
971 bool *done)
972 {
973 CURLcode retcode;
974 struct ssl_connect_data *connssl = &conn->ssl[sockindex];
975 curl_socket_t sockfd = conn->sock[sockindex];
976 timediff_t timeout_ms;
977 int what;
978
979 /* check if the connection has already been established */
980 if(ssl_connection_complete == connssl->state) {
981 *done = TRUE;
982 return CURLE_OK;
983 }
984
985 if(ssl_connect_1 == connssl->connecting_state) {
986 /* Find out how much more time we're allowed */
987 timeout_ms = Curl_timeleft(data, NULL, TRUE);
988
989 if(timeout_ms < 0) {
990 /* no need to continue if time already is up */
991 failf(data, "SSL connection timeout");
992 return CURLE_OPERATION_TIMEDOUT;
993 }
994 retcode = mbed_connect_step1(data, conn, sockindex);
995 if(retcode)
996 return retcode;
997 }
998
999 while(ssl_connect_2 == connssl->connecting_state ||
1000 ssl_connect_2_reading == connssl->connecting_state ||
1001 ssl_connect_2_writing == connssl->connecting_state) {
1002
1003 /* check allowed time left */
1004 timeout_ms = Curl_timeleft(data, NULL, TRUE);
1005
1006 if(timeout_ms < 0) {
1007 /* no need to continue if time already is up */
1008 failf(data, "SSL connection timeout");
1009 return CURLE_OPERATION_TIMEDOUT;
1010 }
1011
1012 /* if ssl is expecting something, check if it's available. */
1013 if(connssl->connecting_state == ssl_connect_2_reading
1014 || connssl->connecting_state == ssl_connect_2_writing) {
1015
1016 curl_socket_t writefd = ssl_connect_2_writing ==
1017 connssl->connecting_state?sockfd:CURL_SOCKET_BAD;
1018 curl_socket_t readfd = ssl_connect_2_reading ==
1019 connssl->connecting_state?sockfd:CURL_SOCKET_BAD;
1020
1021 what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd,
1022 nonblocking ? 0 : timeout_ms);
1023 if(what < 0) {
1024 /* fatal error */
1025 failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
1026 return CURLE_SSL_CONNECT_ERROR;
1027 }
1028 else if(0 == what) {
1029 if(nonblocking) {
1030 *done = FALSE;
1031 return CURLE_OK;
1032 }
1033 else {
1034 /* timeout */
1035 failf(data, "SSL connection timeout");
1036 return CURLE_OPERATION_TIMEDOUT;
1037 }
1038 }
1039 /* socket is readable or writable */
1040 }
1041
1042 /* Run transaction, and return to the caller if it failed or if
1043 * this connection is part of a multi handle and this loop would
1044 * execute again. This permits the owner of a multi handle to
1045 * abort a connection attempt before step2 has completed while
1046 * ensuring that a client using select() or epoll() will always
1047 * have a valid fdset to wait on.
1048 */
1049 retcode = mbed_connect_step2(data, conn, sockindex);
1050 if(retcode || (nonblocking &&
1051 (ssl_connect_2 == connssl->connecting_state ||
1052 ssl_connect_2_reading == connssl->connecting_state ||
1053 ssl_connect_2_writing == connssl->connecting_state)))
1054 return retcode;
1055
1056 } /* repeat step2 until all transactions are done. */
1057
1058 if(ssl_connect_3 == connssl->connecting_state) {
1059 retcode = mbed_connect_step3(data, conn, sockindex);
1060 if(retcode)
1061 return retcode;
1062 }
1063
1064 if(ssl_connect_done == connssl->connecting_state) {
1065 connssl->state = ssl_connection_complete;
1066 conn->recv[sockindex] = mbed_recv;
1067 conn->send[sockindex] = mbed_send;
1068 *done = TRUE;
1069 }
1070 else
1071 *done = FALSE;
1072
1073 /* Reset our connect state machine */
1074 connssl->connecting_state = ssl_connect_1;
1075
1076 return CURLE_OK;
1077 }
1078
1079 static CURLcode mbedtls_connect_nonblocking(struct Curl_easy *data,
1080 struct connectdata *conn,
1081 int sockindex, bool *done)
1082 {
1083 return mbed_connect_common(data, conn, sockindex, TRUE, done);
1084 }
1085
1086
1087 static CURLcode mbedtls_connect(struct Curl_easy *data,
1088 struct connectdata *conn, int sockindex)
1089 {
1090 CURLcode retcode;
1091 bool done = FALSE;
1092
1093 retcode = mbed_connect_common(data, conn, sockindex, FALSE, &done);
1094 if(retcode)
1095 return retcode;
1096
1097 DEBUGASSERT(done);
1098
1099 return CURLE_OK;
1100 }
1101
1102 /*
1103 * return 0 error initializing SSL
1104 * return 1 SSL initialized successfully
1105 */
1106 static int mbedtls_init(void)
1107 {
1108 return Curl_mbedtlsthreadlock_thread_setup();
1109 }
1110
1111 static void mbedtls_cleanup(void)
1112 {
1113 (void)Curl_mbedtlsthreadlock_thread_cleanup();
1114 }
1115
1116 static bool mbedtls_data_pending(const struct connectdata *conn,
1117 int sockindex)
1118 {
1119 const struct ssl_connect_data *connssl = &conn->ssl[sockindex];
1120 struct ssl_backend_data *backend = connssl->backend;
1121 return mbedtls_ssl_get_bytes_avail(&backend->ssl) != 0;
1122 }
1123
1124 static CURLcode mbedtls_sha256sum(const unsigned char *input,
1125 size_t inputlen,
1126 unsigned char *sha256sum,
1127 size_t sha256len UNUSED_PARAM)
1128 {
1129 /* TODO: explain this for different mbedtls 2.x vs 3 version */
1130 (void)sha256len;
1131 #if MBEDTLS_VERSION_NUMBER < 0x02070000
1132 mbedtls_sha256(input, inputlen, sha256sum, 0);
1133 #else
1134 /* returns 0 on success, otherwise failure */
1135 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
1136 if(mbedtls_sha256(input, inputlen, sha256sum, 0) != 0)
1137 #else
1138 if(mbedtls_sha256_ret(input, inputlen, sha256sum, 0) != 0)
1139 #endif
1140 return CURLE_BAD_FUNCTION_ARGUMENT;
1141 #endif
1142 return CURLE_OK;
1143 }
1144
1145 static void *mbedtls_get_internals(struct ssl_connect_data *connssl,
1146 CURLINFO info UNUSED_PARAM)
1147 {
1148 struct ssl_backend_data *backend = connssl->backend;
1149 (void)info;
1150 return &backend->ssl;
1151 }
1152
1153 const struct Curl_ssl Curl_ssl_mbedtls = {
1154 { CURLSSLBACKEND_MBEDTLS, "mbedtls" }, /* info */
1155
1156 SSLSUPP_CA_PATH |
1157 SSLSUPP_PINNEDPUBKEY |
1158 SSLSUPP_SSL_CTX,
1159
1160 sizeof(struct ssl_backend_data),
1161
1162 mbedtls_init, /* init */
1163 mbedtls_cleanup, /* cleanup */
1164 mbedtls_version, /* version */
1165 Curl_none_check_cxn, /* check_cxn */
1166 Curl_none_shutdown, /* shutdown */
1167 mbedtls_data_pending, /* data_pending */
1168 mbedtls_random, /* random */
1169 Curl_none_cert_status_request, /* cert_status_request */
1170 mbedtls_connect, /* connect */
1171 mbedtls_connect_nonblocking, /* connect_nonblocking */
1172 Curl_ssl_getsock, /* getsock */
1173 mbedtls_get_internals, /* get_internals */
1174 mbedtls_close, /* close_one */
1175 mbedtls_close_all, /* close_all */
1176 mbedtls_session_free, /* session_free */
1177 Curl_none_set_engine, /* set_engine */
1178 Curl_none_set_engine_default, /* set_engine_default */
1179 Curl_none_engines_list, /* engines_list */
1180 Curl_none_false_start, /* false_start */
1181 mbedtls_sha256sum, /* sha256sum */
1182 NULL, /* associate_connection */
1183 NULL /* disassociate_connection */
1184 };
1185
1186 #endif /* USE_MBEDTLS */
1187