Artifactspublic-v0

curl

master
ply4 git calls27 ms307 KiB3 cachedprotocol v2
2326 lines73 KiBRaw
1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9 *
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at https://curl.se/docs/copyright.html.
13 *
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 * SPDX-License-Identifier: curl
22 *
23 ***************************************************************************/
24/*
25 * Source file for all GnuTLS-specific code for the TLS/SSL layer. No code
26 * but vtls.c should ever call or use these functions.
27 *
28 * Note: do not use the GnuTLS' *_t variable type names in this source code,
29 * since they were not present in 1.0.x.
30 */
31#include "curl_setup.h"
33#ifdef USE_GNUTLS
35#include <gnutls/abstract.h>
36#include <gnutls/gnutls.h>
37#include <gnutls/x509.h>
38#include <gnutls/crypto.h>
39#include <nettle/sha2.h>
40#include <nettle/version.h>
42#include "urldata.h"
43#include "curl_trc.h"
44#include "vtls/keylog.h"
45#include "vtls/gtls.h"
46#include "vtls/vtls.h"
47#include "vtls/vtls_int.h"
48#include "vtls/vtls_scache.h"
49#include "vtls/apple.h"
50#include "vauth/vauth.h"
51#include "parsedate.h"
52#include "connect.h" /* for the connect timeout */
53#include "progress.h"
54#include "curlx/strdup.h"
55#include "curlx/win32-fopen.h"
56#include "vtls/x509asn1.h"
58/* Enable GnuTLS debugging by defining GTLSDEBUG */
59#if 0
60#define GTLSDEBUG
61#endif
63#ifdef GTLSDEBUG
64static void tls_log_func(int level, const char *str)
66 curl_mfprintf(stderr, "|<%d>| %s", level, str);
68#endif
70#if !defined(GNUTLS_VERSION_NUMBER) || (GNUTLS_VERSION_NUMBER < 0x030605)
71#error "too old GnuTLS version"
72#endif
74#undef CURL_GNUTLS_EARLY_DATA
75#if GNUTLS_VERSION_NUMBER >= 0x030702
76#define CURL_GNUTLS_EARLY_DATA
77#endif
79#include <gnutls/ocsp.h>
81struct gtls_ssl_backend_data {
82 struct gtls_ctx gtls;
83};
85static ssize_t gtls_push(void *s, const void *buf, size_t blen)
87 struct Curl_cfilter *cf = s;
88 struct ssl_connect_data *connssl = cf->ctx;
89 struct gtls_ssl_backend_data *backend =
90 (struct gtls_ssl_backend_data *)connssl->backend;
91 struct Curl_easy *data = CF_DATA_CURRENT(cf);
92 size_t nwritten;
93 CURLcode result;
95 DEBUGASSERT(data);
96 result = Curl_conn_cf_send(cf->next, data, buf, blen, FALSE, &nwritten);
97 CURL_TRC_CF(data, cf, "gtls_push(len=%zu) -> %d, %zu",
98 blen, (int)result, nwritten);
99 backend->gtls.io_result = result;
100 if(result) {
101 /* !checksrc! disable ERRNOVAR 1 */
102 gnutls_transport_set_errno(backend->gtls.session,
103 (result == CURLE_AGAIN) ? EAGAIN : EINVAL);
104 return -1;
105 }
106 return (ssize_t)nwritten;
109static ssize_t gtls_pull(void *s, void *buf, size_t blen)
111 struct Curl_cfilter *cf = s;
112 struct ssl_connect_data *connssl = cf->ctx;
113 struct gtls_ssl_backend_data *backend =
114 (struct gtls_ssl_backend_data *)connssl->backend;
115 struct Curl_easy *data = CF_DATA_CURRENT(cf);
116 size_t nread;
117 CURLcode result;
119 DEBUGASSERT(data);
120 if(!backend->gtls.shared_creds->trust_setup) {
121 result = Curl_gtls_client_trust_setup(cf, data, &backend->gtls);
122 if(result) {
123 /* !checksrc! disable ERRNOVAR 1 */
124 gnutls_transport_set_errno(backend->gtls.session, EINVAL);
125 backend->gtls.io_result = result;
126 return -1;
127 }
128 }
130 result = Curl_conn_cf_recv(cf->next, data, buf, blen, &nread);
131 CURL_TRC_CF(data, cf, "gtls_pull(len=%zu) -> %d, %zu", blen, (int)result,
132 nread);
133 backend->gtls.io_result = result;
134 if(result) {
135 /* !checksrc! disable ERRNOVAR 1 */
136 gnutls_transport_set_errno(backend->gtls.session,
137 (result == CURLE_AGAIN) ? EAGAIN : EINVAL);
138 return -1;
139 }
140 else if(nread == 0)
141 connssl->peer_closed = TRUE;
142 return (ssize_t)nread;
145/**
146 * gtls_init()
147 *
148 * Global GnuTLS init, called from Curl_ssl_init(). This calls functions that
149 * are not thread-safe (It is thread-safe since GnuTLS 3.3.0) and thus this
150 * function itself is not thread-safe and must only be called from within
151 * curl_global_init() to keep the thread situation under control!
152 *
153 * @retval 0 error initializing SSL
154 * @retval 1 SSL initialized successfully
155 */
156static int gtls_init(void)
158 int ret = 1;
159 ret = gnutls_global_init() ? 0 : 1;
160#ifdef GTLSDEBUG
161 gnutls_global_set_log_function(tls_log_func);
162 gnutls_global_set_log_level(2);
163#endif
164 return ret;
167static void gtls_cleanup(void)
169 gnutls_global_deinit();
170 Curl_tls_keylog_close();
173#ifdef CURLVERBOSE
174static void showtime(struct Curl_easy *data, const char *text, time_t stamp)
176 struct tm buffer;
177 const struct tm *tm = &buffer;
178 char str[96];
179 CURLcode result = curlx_gmtime(stamp, &buffer);
180 if(result)
181 return;
183 curl_msnprintf(str,
184 sizeof(str),
185 " %s: %s, %02d %s %4d %02d:%02d:%02d GMT",
186 text,
187 Curl_wkday[tm->tm_wday ? tm->tm_wday-1 : 6],
188 tm->tm_mday,
189 Curl_month[tm->tm_mon],
190 tm->tm_year + 1900,
191 tm->tm_hour,
192 tm->tm_min,
193 tm->tm_sec);
194 infof(data, "%s", str);
196#endif
198static gnutls_datum_t load_file(const char *file)
200 FILE *f;
201 gnutls_datum_t loaded_file = { NULL, 0 };
202 long filelen;
203 void *ptr;
205 f = curlx_fopen(file, "rb");
206 if(!f)
207 return loaded_file;
208 if(fseek(f, 0, SEEK_END))
209 goto out;
210 filelen = ftell(f);
211 if(filelen < 0 || filelen > CURL_MAX_INPUT_LENGTH)
212 goto out;
213 if(fseek(f, 0, SEEK_SET))
214 goto out;
215 ptr = curlx_malloc((size_t)filelen);
216 if(!ptr)
217 goto out;
218 if(fread(ptr, 1, (size_t)filelen, f) < (size_t)filelen) {
219 curlx_free(ptr);
220 goto out;
221 }
223 loaded_file.data = ptr;
224 loaded_file.size = (unsigned int)filelen;
225out:
226 curlx_fclose(f);
227 return loaded_file;
230static void unload_file(gnutls_datum_t data)
232 curlx_free(data.data);
235/* this function does an SSL/TLS (re-)handshake */
236static CURLcode cf_gtls_handshake(struct Curl_cfilter *cf,
237 struct Curl_easy *data)
239 struct ssl_connect_data *connssl = cf->ctx;
240 struct gtls_ssl_backend_data *backend =
241 (struct gtls_ssl_backend_data *)connssl->backend;
242 gnutls_session_t session;
243 int rc;
245 DEBUGASSERT(backend);
246 session = backend->gtls.session;
248 connssl->io_need = CURL_SSL_IO_NEED_NONE;
249 backend->gtls.io_result = CURLE_OK;
250 rc = gnutls_handshake(session);
252 if(!backend->gtls.shared_creds->trust_setup) {
253 /* After having send off the ClientHello, we prepare the trust
254 * store to verify the coming certificate from the server */
255 CURLcode result = Curl_gtls_client_trust_setup(cf, data, &backend->gtls);
256 if(result)
257 return result;
258 }
260 if((rc == GNUTLS_E_AGAIN) || (rc == GNUTLS_E_INTERRUPTED)) {
261 connssl->io_need =
262 gnutls_record_get_direction(session) ?
263 CURL_SSL_IO_NEED_SEND : CURL_SSL_IO_NEED_RECV;
264 return CURLE_AGAIN;
265 }
266 else if((rc < 0) && !gnutls_error_is_fatal(rc)) {
267#ifdef CURLVERBOSE
268 const char *strerr = NULL;
270 if(rc == GNUTLS_E_WARNING_ALERT_RECEIVED) {
271 gnutls_alert_description_t alert = gnutls_alert_get(session);
272 strerr = gnutls_alert_get_name(alert);
273 }
275 if(!strerr)
276 strerr = gnutls_strerror(rc);
278 infof(data, "gnutls_handshake() warning: %s", strerr);
279#endif
280 return CURLE_AGAIN;
281 }
282 else if((rc < 0) && backend->gtls.io_result) {
283 return backend->gtls.io_result;
284 }
285 else if(rc < 0) {
286 const char *strerr = NULL;
288 if(rc == GNUTLS_E_FATAL_ALERT_RECEIVED) {
289 gnutls_alert_description_t alert = gnutls_alert_get(session);
290 strerr = gnutls_alert_get_name(alert);
291 }
293 if(!strerr)
294 strerr = gnutls_strerror(rc);
296 failf(data, "GnuTLS, handshake failed: %s", strerr);
297 return CURLE_SSL_CONNECT_ERROR;
298 }
300 return CURLE_OK;
303static gnutls_x509_crt_fmt_t gnutls_do_file_type(const char *type)
305 if(!type || !type[0])
306 return GNUTLS_X509_FMT_PEM;
307 if(curl_strequal(type, "PEM"))
308 return GNUTLS_X509_FMT_PEM;
309 if(curl_strequal(type, "DER"))
310 return GNUTLS_X509_FMT_DER;
311 return GNUTLS_X509_FMT_PEM; /* default to PEM */
314#define GNUTLS_CIPHERS "NORMAL:%PROFILE_MEDIUM:-ARCFOUR-128:" \
315 "-CTYPE-ALL:+CTYPE-X509"
317#define QUIC_PRIORITY \
318 "NORMAL:%PROFILE_MEDIUM:-VERS-ALL:+VERS-TLS1.3:-CIPHER-ALL:+AES-128-GCM:" \
319 "+AES-256-GCM:+CHACHA20-POLY1305:+AES-128-CCM:-GROUP-ALL:" \
320 "+GROUP-SECP256R1:+GROUP-X25519:+GROUP-SECP384R1:+GROUP-SECP521R1:" \
321 "%DISABLE_TLS13_COMPAT_MODE"
323static CURLcode gnutls_set_ssl_version_min_max(
324 struct Curl_easy *data,
325 struct ssl_peer *peer,
326 struct ssl_filter_config *conn_config,
327 const char **prioritylist,
328 bool tls13support)
330 long ssl_version = conn_config->version;
331 long ssl_version_max = conn_config->version_max;
333 DEBUGASSERT(ssl_version != CURL_SSLVERSION_DEFAULT);
334 if(ssl_version <= CURL_SSLVERSION_TLSv1)
335 ssl_version = CURL_SSLVERSION_TLSv1_0;
336 if((ssl_version_max == CURL_SSLVERSION_MAX_NONE) ||
337 (ssl_version_max == CURL_SSLVERSION_MAX_DEFAULT))
338 ssl_version_max = tls13support ?
339 CURL_SSLVERSION_MAX_TLSv1_3 : CURL_SSLVERSION_MAX_TLSv1_2;
341 if(peer->transport == TRNSPRT_QUIC) {
342 if(ssl_version_max < CURL_SSLVERSION_MAX_TLSv1_3) {
343 failf(data, "QUIC needs at least TLS version 1.3");
344 return CURLE_SSL_CONNECT_ERROR;
345 }
346 *prioritylist = QUIC_PRIORITY;
347 return CURLE_OK;
348 }
350 switch(ssl_version | ssl_version_max) {
351 case CURL_SSLVERSION_TLSv1_0 | CURL_SSLVERSION_MAX_TLSv1_0:
352 *prioritylist = GNUTLS_CIPHERS ":-VERS-SSL3.0:-VERS-TLS-ALL:"
353 "+VERS-TLS1.0";
354 return CURLE_OK;
355 case CURL_SSLVERSION_TLSv1_0 | CURL_SSLVERSION_MAX_TLSv1_1:
356 *prioritylist = GNUTLS_CIPHERS ":-VERS-SSL3.0:-VERS-TLS-ALL:"
357 "+VERS-TLS1.1:+VERS-TLS1.0";
358 return CURLE_OK;
359 case CURL_SSLVERSION_TLSv1_0 | CURL_SSLVERSION_MAX_TLSv1_2:
360 *prioritylist = GNUTLS_CIPHERS ":-VERS-SSL3.0:-VERS-TLS-ALL:"
361 "+VERS-TLS1.2:+VERS-TLS1.1:+VERS-TLS1.0";
362 return CURLE_OK;
363 case CURL_SSLVERSION_TLSv1_1 | CURL_SSLVERSION_MAX_TLSv1_1:
364 *prioritylist = GNUTLS_CIPHERS ":-VERS-SSL3.0:-VERS-TLS-ALL:"
365 "+VERS-TLS1.1";
366 return CURLE_OK;
367 case CURL_SSLVERSION_TLSv1_1 | CURL_SSLVERSION_MAX_TLSv1_2:
368 *prioritylist = GNUTLS_CIPHERS ":-VERS-SSL3.0:-VERS-TLS-ALL:"
369 "+VERS-TLS1.2:+VERS-TLS1.1";
370 return CURLE_OK;
371 case CURL_SSLVERSION_TLSv1_2 | CURL_SSLVERSION_MAX_TLSv1_2:
372 *prioritylist = GNUTLS_CIPHERS ":-VERS-SSL3.0:-VERS-TLS-ALL:"
373 "+VERS-TLS1.2";
374 return CURLE_OK;
375 case CURL_SSLVERSION_TLSv1_3 | CURL_SSLVERSION_MAX_TLSv1_3:
376 *prioritylist = GNUTLS_CIPHERS ":-VERS-SSL3.0:-VERS-TLS-ALL:"
377 "+VERS-TLS1.3";
378 return CURLE_OK;
379 case CURL_SSLVERSION_TLSv1_0 | CURL_SSLVERSION_MAX_TLSv1_3:
380 *prioritylist = GNUTLS_CIPHERS ":-VERS-SSL3.0";
381 return CURLE_OK;
382 case CURL_SSLVERSION_TLSv1_1 | CURL_SSLVERSION_MAX_TLSv1_3:
383 *prioritylist = GNUTLS_CIPHERS ":-VERS-SSL3.0:-VERS-TLS-ALL:"
384 "+VERS-TLS1.3:+VERS-TLS1.2:+VERS-TLS1.1";
385 return CURLE_OK;
386 case CURL_SSLVERSION_TLSv1_2 | CURL_SSLVERSION_MAX_TLSv1_3:
387 *prioritylist = GNUTLS_CIPHERS ":-VERS-SSL3.0:-VERS-TLS-ALL:"
388 "+VERS-TLS1.3:+VERS-TLS1.2";
389 return CURLE_OK;
390 }
392 failf(data, "GnuTLS: cannot set TLS protocol");
393 return CURLE_SSL_CONNECT_ERROR;
396CURLcode Curl_gtls_shared_creds_create(struct Curl_easy *data,
397 struct gtls_shared_creds **pcreds)
399 struct gtls_shared_creds *shared;
400 int rc;
402 *pcreds = NULL;
403 shared = curlx_calloc(1, sizeof(*shared));
404 if(!shared)
405 return CURLE_OUT_OF_MEMORY;
407 rc = gnutls_certificate_allocate_credentials(&shared->creds);
408 if(rc != GNUTLS_E_SUCCESS) {
409 failf(data, "gnutls_certificate_allocate_credentials() failed: %s",
410 gnutls_strerror(rc));
411 curlx_free(shared);
412 return CURLE_SSL_CONNECT_ERROR;
413 }
415 shared->refcount = 1;
416 shared->time = *Curl_pgrs_now(data);
417 *pcreds = shared;
418 return CURLE_OK;
421CURLcode Curl_gtls_shared_creds_up_ref(struct gtls_shared_creds *creds)
423 DEBUGASSERT(creds);
424 if(creds->refcount < SIZE_MAX) {
425 ++creds->refcount;
426 return CURLE_OK;
427 }
428 return CURLE_BAD_FUNCTION_ARGUMENT;
431void Curl_gtls_shared_creds_free(struct gtls_shared_creds **pcreds)
433 struct gtls_shared_creds *shared = *pcreds;
434 *pcreds = NULL;
435 if(shared) {
436 --shared->refcount;
437 if(!shared->refcount) {
438 gnutls_certificate_free_credentials(shared->creds);
439 curlx_free(shared->CAfile);
440 curlx_free(shared);
441 }
442 }
445static CURLcode gtls_populate_creds(struct Curl_cfilter *cf,
446 struct Curl_easy *data,
447 gnutls_certificate_credentials_t creds)
449 struct ssl_filter_config *config = Curl_ssl_cf_get_filter_config(cf);
450 struct ssl_easy_config *ssl_config = Curl_ssl_cf_get_easy_config(cf, data);
451 bool creds_are_empty = TRUE;
452 int rc;
454 if(!config->verifypeer) {
455 infof(data, "SSL Trust: peer verification disabled");
456 return CURLE_OK;
457 }
459 infof(data, "SSL Trust Anchors:");
460 if(config->native_ca_store) {
461#ifdef USE_APPLE_SECTRUST
462 infof(data, " Native: Apple SecTrust");
463 creds_are_empty = FALSE;
464#else
465 rc = gnutls_certificate_set_x509_system_trust(creds);
466 if(rc < 0)
467 infof(data, "error reading native CA store (%s), continuing anyway",
468 gnutls_strerror(rc));
469 else {
470 infof(data, " Native: %d certificates from system trust", rc);
471 if(rc > 0)
472 creds_are_empty = FALSE;
473 }
474#endif
475 }
477 if(config->ca_info_blob) {
478 gnutls_datum_t ca_info_datum;
479 if(config->ca_info_blob->len > (size_t)UINT_MAX) {
480 failf(data, "certificate blob too long: %zu bytes",
481 config->ca_info_blob->len);
482 return CURLE_SSL_CACERT_BADFILE;
483 }
484 ca_info_datum.data = config->ca_info_blob->data;
485 ca_info_datum.size = (unsigned int)config->ca_info_blob->len;
486 rc = gnutls_certificate_set_x509_trust_mem(creds, &ca_info_datum,
487 GNUTLS_X509_FMT_PEM);
488 creds_are_empty = creds_are_empty && (rc <= 0);
489 if(rc < 0) {
490 infof(data, "error reading CA cert blob (%s)%s", gnutls_strerror(rc),
491 (creds_are_empty ? "" : ", continuing anyway"));
492 if(creds_are_empty) {
493 ssl_config->certverifyresult = rc;
494 return CURLE_SSL_CACERT_BADFILE;
495 }
496 }
497 else
498 infof(data, " CA Blob: %d certificates", rc);
499 }
500 /* CURLOPT_CAINFO_BLOB overrides CURLOPT_CAINFO */
501 else if(config->CAfile) {
502 /* set the trusted CA cert bundle file */
503 gnutls_certificate_set_verify_flags(creds,
504 GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT);
506 rc = gnutls_certificate_set_x509_trust_file(creds,
507 config->CAfile,
508 GNUTLS_X509_FMT_PEM);
509 creds_are_empty = creds_are_empty && (rc <= 0);
510 if(rc < 0) {
511 infof(data, "error reading CA cert file %s (%s)%s",
512 config->CAfile, gnutls_strerror(rc),
513 (creds_are_empty ? "" : ", continuing anyway"));
514 if(creds_are_empty) {
515 ssl_config->certverifyresult = rc;
516 return CURLE_SSL_CACERT_BADFILE;
517 }
518 }
519 else
520 infof(data, " CAfile: %d certificates in %s", rc, config->CAfile);
521 }
523 if(config->CApath) {
524 /* set the trusted CA cert directory */
525 rc = gnutls_certificate_set_x509_trust_dir(creds, config->CApath,
526 GNUTLS_X509_FMT_PEM);
527 creds_are_empty = creds_are_empty && (rc <= 0);
528 if(rc < 0) {
529 infof(data, "error reading CA cert file %s (%s)%s",
530 config->CApath, gnutls_strerror(rc),
531 (creds_are_empty ? "" : ", continuing anyway"));
532 if(creds_are_empty) {
533 ssl_config->certverifyresult = rc;
534 return CURLE_SSL_CACERT_BADFILE;
535 }
536 }
537 else
538 infof(data, " CApath: %d certificates in %s", rc, config->CApath);
539 }
541 if(creds_are_empty)
542 infof(data, " no trust anchors configured");
544#ifdef USE_APPLE_SECTRUST
545 if(config->CRLfile && config->native_ca_store) {
546 failf(data, "gnutls: CRL file not supported with native CA store; "
547 "the platform verifier has no CRL attachment API");
548 return CURLE_NOT_BUILT_IN;
549 }
550#endif
551 if(config->CRLfile) {
552 /* set the CRL list file */
553 rc = gnutls_certificate_set_x509_crl_file(creds, config->CRLfile,
554 GNUTLS_X509_FMT_PEM);
555 if(rc < 0) {
556 failf(data, "error reading CRL file %s (%s)",
557 config->CRLfile, gnutls_strerror(rc));
558 return CURLE_SSL_CRL_BADFILE;
559 }
560 else
561 infof(data, " CRLfile: %d CRL in %s", rc, config->CRLfile);
562 }
564 return CURLE_OK;
567/* key to use at `multi->proto_hash` */
568#define MPROTO_GTLS_X509_KEY "tls:gtls:x509:share"
570static bool gtls_shared_creds_expired(struct Curl_easy *data,
571 const struct gtls_shared_creds *sc)
573 timediff_t elapsed_ms = curlx_ptimediff_ms(Curl_pgrs_now(data), &sc->time);
574 timediff_t timeout_ms = data->set.ssl_ca_cache_timeout * (timediff_t)1000;
576 if(timeout_ms < 0)
577 return FALSE;
579 return elapsed_ms >= timeout_ms;
582static bool gtls_shared_creds_different(struct Curl_cfilter *cf,
583 const struct gtls_shared_creds *sc)
585 struct ssl_filter_config *conn_config = Curl_ssl_cf_get_filter_config(cf);
586 if(!sc->CAfile || !conn_config->CAfile)
587 return sc->CAfile != conn_config->CAfile;
589 return strcmp(sc->CAfile, conn_config->CAfile);
592static struct gtls_shared_creds *gtls_get_cached_creds(struct Curl_cfilter *cf,
593 struct Curl_easy *data)
595 struct gtls_shared_creds *shared_creds;
597 if(data->multi) {
598 shared_creds = Curl_hash_pick(&data->multi->proto_hash,
599 MPROTO_GTLS_X509_KEY,
600 CURL_CSTRLEN(MPROTO_GTLS_X509_KEY));
601 if(shared_creds && shared_creds->creds &&
602 !gtls_shared_creds_expired(data, shared_creds) &&
603 !gtls_shared_creds_different(cf, shared_creds)) {
604 return shared_creds;
605 }
606 }
607 return NULL;
610static void gtls_shared_creds_hash_free(const void *key,
611 size_t key_len, void *p)
613 struct gtls_shared_creds *sc = p;
614 DEBUGASSERT(key_len == CURL_CSTRLEN(MPROTO_GTLS_X509_KEY));
615 DEBUGASSERT(!memcmp(MPROTO_GTLS_X509_KEY, key, key_len));
616 (void)key;
617 (void)key_len;
618 Curl_gtls_shared_creds_free(&sc); /* down reference */
621static void gtls_set_cached_creds(struct Curl_cfilter *cf,
622 struct Curl_easy *data,
623 struct gtls_shared_creds *sc)
625 struct ssl_filter_config *conn_config = Curl_ssl_cf_get_filter_config(cf);
627 DEBUGASSERT(sc);
628 DEBUGASSERT(sc->creds);
629 DEBUGASSERT(!sc->CAfile);
630 DEBUGASSERT(sc->refcount == 1);
631 if(!data->multi)
632 return;
634 if(conn_config->CAfile) {
635 sc->CAfile = curlx_strdup(conn_config->CAfile);
636 if(!sc->CAfile)
637 return;
638 }
640 if(Curl_gtls_shared_creds_up_ref(sc))
641 return;
643 if(!Curl_hash_add2(&data->multi->proto_hash,
644 MPROTO_GTLS_X509_KEY,
645 CURL_CSTRLEN(MPROTO_GTLS_X509_KEY),
646 sc, gtls_shared_creds_hash_free)) {
647 Curl_gtls_shared_creds_free(&sc); /* down reference again */
648 return;
649 }
652CURLcode Curl_gtls_client_trust_setup(struct Curl_cfilter *cf,
653 struct Curl_easy *data,
654 struct gtls_ctx *gtls)
656 struct ssl_filter_config *conn_config = Curl_ssl_cf_get_filter_config(cf);
657 struct gtls_shared_creds *cached_creds = NULL;
658 bool cache_criteria_met;
659 CURLcode result;
660 int rc;
662 /* Consider the X509 store cacheable if it comes exclusively from a CAfile,
663 or no source is provided and we are falling back to OpenSSL's built-in
664 default. */
665 cache_criteria_met = (data->set.ssl_ca_cache_timeout != 0) &&
666 conn_config->verifypeer &&
667 !conn_config->CApath &&
668 !conn_config->ca_info_blob &&
669 !conn_config->CRLfile &&
670 !conn_config->native_ca_store &&
671 !conn_config->clientcert; /* GnuTLS adds client cert to its credentials! */
673 if(cache_criteria_met)
674 cached_creds = gtls_get_cached_creds(cf, data);
676 if(cached_creds && !Curl_gtls_shared_creds_up_ref(cached_creds)) {
677 CURL_TRC_CF(data, cf, "using shared trust anchors and CRLs");
678 Curl_gtls_shared_creds_free(&gtls->shared_creds);
679 gtls->shared_creds = cached_creds;
680 rc = gnutls_credentials_set(gtls->session, GNUTLS_CRD_CERTIFICATE,
681 gtls->shared_creds->creds);
682 if(rc != GNUTLS_E_SUCCESS) {
683 failf(data, "gnutls_credentials_set() failed: %s", gnutls_strerror(rc));
684 return CURLE_SSL_CONNECT_ERROR;
685 }
686 }
687 else {
688 CURL_TRC_CF(data, cf, "loading trust anchors and CRLs");
689 result = gtls_populate_creds(cf, data, gtls->shared_creds->creds);
690 if(result)
691 return result;
692 gtls->shared_creds->trust_setup = TRUE;
693 if(cache_criteria_met)
694 gtls_set_cached_creds(cf, data, gtls->shared_creds);
695 }
696 return CURLE_OK;
699#ifdef CURL_GNUTLS_EARLY_DATA
700static int gtls_get_ietf_proto(gnutls_session_t session)
702 switch(gnutls_protocol_get_version(session)) {
703 case GNUTLS_SSL3:
704 return CURL_IETF_PROTO_SSL3;
705 case GNUTLS_TLS1_0:
706 return CURL_IETF_PROTO_TLS1;
707 case GNUTLS_TLS1_1:
708 return CURL_IETF_PROTO_TLS1_1;
709 case GNUTLS_TLS1_2:
710 return CURL_IETF_PROTO_TLS1_2;
711 case GNUTLS_TLS1_3:
712 return CURL_IETF_PROTO_TLS1_3;
713 default:
714 return CURL_IETF_PROTO_UNKNOWN;
715 }
718CURLcode Curl_gtls_cache_session(struct Curl_cfilter *cf,
719 struct Curl_easy *data,
720 const char *ssl_peer_key,
721 gnutls_session_t session,
722 curl_off_t valid_until,
723 const char *alpn,
724 unsigned char *quic_tp,
725 size_t quic_tp_len,
726 struct Curl_ssl_session **psession)
728 struct Curl_ssl_session *sc_session = NULL, *sc_dup = NULL;
729 unsigned char *sdata, *qtp_clone = NULL;
730 size_t sdata_len = 0;
731 size_t earlydata_max = 0;
732 CURLcode result = CURLE_OK;
734 if(psession)
735 *psession = NULL;
736 if(!Curl_ssl_scache_use(cf, data))
737 return CURLE_OK;
739 /* we always unconditionally get the session id here, as even if we
740 already got it from the cache and asked to use it in the connection, it
741 might have been rejected and then a new one is in use now and we need to
742 detect that. */
744 /* get the session ID data size */
745 gnutls_session_get_data(session, NULL, &sdata_len);
746 if(!sdata_len) /* GnuTLS does this for some version combinations */
747 return CURLE_OK;
749 sdata = curlx_malloc(sdata_len); /* get a buffer for it */
750 if(!sdata)
751 return CURLE_OUT_OF_MEMORY;
753 /* extract session ID to the allocated buffer */
754 gnutls_session_get_data(session, sdata, &sdata_len);
755 earlydata_max = gnutls_record_get_max_early_data_size(session);
757 CURL_TRC_CF(data, cf, "get session id (len=%zu, alpn=%s, earlymax=%zu) "
758 "and store in cache", sdata_len, alpn ? alpn : "-",
759 earlydata_max);
760 if(quic_tp && quic_tp_len) {
761 qtp_clone = curlx_memdup0((const char *)quic_tp, quic_tp_len);
762 if(!qtp_clone) {
763 curlx_free(sdata);
764 return CURLE_OUT_OF_MEMORY;
765 }
766 }
768 result = Curl_ssl_session_create2(sdata, sdata_len,
769 gtls_get_ietf_proto(session),
770 alpn, valid_until, earlydata_max,
771 qtp_clone, quic_tp_len,
772 &sc_session);
773 /* call took ownership of `sdata` and `qtp_clone` */
774 if(!result && psession && /* return a duplicate if asked for and FTP */
775 (cf->conn->scheme->family == CURLPROTO_FTP))
776 result = Curl_ssl_session_dup(sc_session, &sc_dup);
777 if(!result) {
778 result = Curl_ssl_scache_put(cf, data, ssl_peer_key, sc_session);
779 /* took ownership of `sc_session` */
780 sc_session = NULL;
781 }
782 if(!result && psession) {
783 *psession = sc_dup;
784 sc_dup = NULL;
785 }
786 Curl_ssl_session_destroy(sc_session);
787 Curl_ssl_session_destroy(sc_dup);
788 return result;
790#endif
792#ifdef CURL_GNUTLS_EARLY_DATA
793static CURLcode cf_gtls_update_session_id(struct Curl_cfilter *cf,
794 struct Curl_easy *data,
795 gnutls_session_t session)
797 struct ssl_connect_data *connssl = cf->ctx;
798 struct Curl_ssl_session *scs = NULL;
799 CURLcode result;
801 result = Curl_gtls_cache_session(cf, data, connssl->peer.scache_key,
802 session, 0, connssl->negotiated.alpn,
803 NULL, 0, &scs);
804 if(!result) {
805 Curl_ssl_session_destroy(connssl->session);
806 connssl->session = scs;
807 }
808 return result;
811static int gtls_handshake_cb(gnutls_session_t session, unsigned int htype,
812 unsigned when, unsigned int incoming,
813 const gnutls_datum_t *msg)
815 struct Curl_cfilter *cf = gnutls_session_get_ptr(session);
817 (void)msg;
818 (void)incoming;
819 if(when) { /* after message has been processed */
820 struct Curl_easy *data = CF_DATA_CURRENT(cf);
821 if(data) {
822 CURL_TRC_CF(data, cf, "handshake: %s message type %u",
823 incoming ? "incoming" : "outgoing", htype);
824 switch(htype) {
825 case GNUTLS_HANDSHAKE_NEW_SESSION_TICKET: {
826 cf_gtls_update_session_id(cf, data, session);
827 break;
828 }
829 default:
830 break;
831 }
832 }
833 }
834 return 0;
836#endif
838static CURLcode gtls_set_priority(struct Curl_cfilter *cf,
839 struct Curl_easy *data,
840 struct gtls_ctx *gtls,
841 const char *priority)
843 struct ssl_filter_config *conn_config = Curl_ssl_cf_get_filter_config(cf);
844 struct dynbuf buf;
845 const char *err = NULL;
846 CURLcode result = CURLE_OK;
847 int rc;
849 curlx_dyn_init(&buf, 4096);
851 if(conn_config->cipher_list) {
852 if((conn_config->cipher_list[0] == '+') ||
853 (conn_config->cipher_list[0] == '-') ||
854 (conn_config->cipher_list[0] == '!')) {
855 /* add it to our own */
856 if(!curlx_dyn_len(&buf)) { /* not added yet */
857 result = curlx_dyn_add(&buf, priority);
858 if(result)
859 goto out;
860 }
861 result = curlx_dyn_addf(&buf, ":%s", conn_config->cipher_list);
862 if(result)
863 goto out;
864 priority = curlx_dyn_ptr(&buf);
865 }
866 else /* replace our own completely */
867 priority = conn_config->cipher_list;
868 }
870 infof(data, "GnuTLS priority: %s", priority);
871 rc = gnutls_priority_set_direct(gtls->session, priority, &err);
872 if(rc != GNUTLS_E_SUCCESS) {
873 failf(data, "Error %d setting GnuTLS priority: %s", rc, err);
874 result = CURLE_SSL_CONNECT_ERROR;
875 }
877out:
878 curlx_dyn_free(&buf);
879 return result;
882static CURLcode gtls_client_init(struct Curl_cfilter *cf,
883 struct Curl_easy *data,
884 struct ssl_peer *peer,
885 size_t earlydata_max,
886 struct gtls_ctx *gtls)
888 struct ssl_filter_config *config = Curl_ssl_cf_get_filter_config(cf);
889 struct ssl_easy_config *ssl_config = Curl_ssl_cf_get_easy_config(cf, data);
890 unsigned int init_flags;
891 int rc;
892 const char *prioritylist;
893 bool tls13support;
894 CURLcode result;
896 if(config->version == CURL_SSLVERSION_SSLv2 ||
897 config->version == CURL_SSLVERSION_SSLv3) {
898 failf(data, "GnuTLS does not support SSLv2 or SSLv3");
899 return CURLE_SSL_CONNECT_ERROR;
900 }
902 /* allocate a shared creds struct */
903 result = Curl_gtls_shared_creds_create(data, &gtls->shared_creds);
904 if(result)
905 return result;
907 ssl_config->certverifyresult = 0;
909 /* Initialize TLS session as a client */
910 init_flags = GNUTLS_CLIENT;
911#ifdef CURL_GNUTLS_EARLY_DATA
912 if(peer->transport == TRNSPRT_QUIC && earlydata_max > 0)
913 init_flags |= GNUTLS_ENABLE_EARLY_DATA | GNUTLS_NO_END_OF_EARLY_DATA;
914 else if(earlydata_max > 0 && earlydata_max != 0xFFFFFFFFUL)
915 /* See https://gitlab.com/gnutls/gnutls/-/issues/1619
916 * We cannot differentiate between a session announcing no earldata
917 * and one announcing 0xFFFFFFFFUL. On TCP+TLS, this is unlikely, but
918 * on QUIC this is common. */
919 init_flags |= GNUTLS_ENABLE_EARLY_DATA;
920#endif
922#ifdef GNUTLS_FORCE_CLIENT_CERT
923 init_flags |= GNUTLS_FORCE_CLIENT_CERT;
924#endif
926#ifdef GNUTLS_NO_TICKETS_TLS12
927 init_flags |= GNUTLS_NO_TICKETS_TLS12;
928#endif
930#ifdef GNUTLS_NO_STATUS_REQUEST
931 if(!config->verifystatus)
932 /* Disable the "status_request" TLS extension, enabled by default since
933 GnuTLS 3.8.0. */
934 init_flags |= GNUTLS_NO_STATUS_REQUEST;
935#endif
937 CURL_TRC_CF(data, cf, "gnutls_init(flags=%x), earlydata=%zu",
938 init_flags, earlydata_max);
939 rc = gnutls_init(&gtls->session, init_flags);
940 if(rc != GNUTLS_E_SUCCESS) {
941 failf(data, "gnutls_init() failed: %d", rc);
942 return CURLE_SSL_CONNECT_ERROR;
943 }
945 if(peer->sni) {
946 if(gnutls_server_name_set(gtls->session, GNUTLS_NAME_DNS,
947 peer->sni, strlen(peer->sni)) < 0) {
948 failf(data, "Failed to set SNI");
949 return CURLE_SSL_CONNECT_ERROR;
950 }
951 }
953 /* Use default priorities */
954 rc = gnutls_set_default_priority(gtls->session);
955 if(rc != GNUTLS_E_SUCCESS)
956 return CURLE_SSL_CONNECT_ERROR;
958 /* "In GnuTLS 3.6.5, TLS 1.3 is enabled by default" */
959 tls13support = !!gnutls_check_version("3.6.5");
961 if(config->version == CURL_SSLVERSION_TLSv1_3) {
962 if(!tls13support) {
963 failf(data, "This GnuTLS installation does not support TLS 1.3");
964 return CURLE_SSL_CONNECT_ERROR;
965 }
966 }
968 /* At this point we know we have a supported TLS version, so set it */
969 result = gnutls_set_ssl_version_min_max(data, peer,
970 config, &prioritylist, tls13support);
971 if(result)
972 return result;
974 result = gtls_set_priority(cf, data, gtls, prioritylist);
975 if(result)
976 return result;
978 if(config->clientcert) {
979 if(!gtls->shared_creds->trust_setup) {
980 result = Curl_gtls_client_trust_setup(cf, data, gtls);
981 if(result)
982 return result;
983 }
984 if(config->cert_type &&
985 curl_strequal(config->cert_type, "P12")) {
986 rc = gnutls_certificate_set_x509_simple_pkcs12_file(
987 gtls->shared_creds->creds, config->clientcert, GNUTLS_X509_FMT_DER,
988 config->key_passwd ? config->key_passwd : "");
989 if(rc != GNUTLS_E_SUCCESS) {
990 failf(data,
991 "error reading X.509 potentially-encrypted key or certificate "
992 "file: %s",
993 gnutls_strerror(rc));
994 return CURLE_SSL_CONNECT_ERROR;
995 }
996 }
997 else {
998 const unsigned int supported_key_encryption_algorithms =
999 GNUTLS_PKCS_USE_PKCS12_3DES | GNUTLS_PKCS_USE_PKCS12_ARCFOUR |
1000 GNUTLS_PKCS_USE_PKCS12_RC2_40 | GNUTLS_PKCS_USE_PBES2_3DES |
1001 GNUTLS_PKCS_USE_PBES2_AES_128 | GNUTLS_PKCS_USE_PBES2_AES_192 |
1002 GNUTLS_PKCS_USE_PBES2_AES_256;
1003 rc = gnutls_certificate_set_x509_key_file2(
1004 gtls->shared_creds->creds,
1005 config->clientcert,
1006 config->key ? config->key : config->clientcert,
1007 gnutls_do_file_type(config->cert_type),
1008 config->key_passwd,
1009 supported_key_encryption_algorithms);
1010 if(rc != GNUTLS_E_SUCCESS) {
1011 failf(data,
1012 "error reading X.509 %skey file: %s",
1013 config->key_passwd ? "potentially-encrypted " : "",
1014 gnutls_strerror(rc));
1015 return CURLE_SSL_CONNECT_ERROR;
1020 rc = gnutls_credentials_set(gtls->session, GNUTLS_CRD_CERTIFICATE,
1021 gtls->shared_creds->creds);
1022 if(rc != GNUTLS_E_SUCCESS) {
1023 failf(data, "gnutls_credentials_set() failed: %s", gnutls_strerror(rc));
1024 return CURLE_SSL_CONNECT_ERROR;
1027 if(config->verifystatus) {
1028 rc = gnutls_ocsp_status_request_enable_client(gtls->session,
1029 NULL, 0, NULL);
1030 if(rc != GNUTLS_E_SUCCESS) {
1031 failf(data, "gnutls_ocsp_status_request_enable_client() failed: %d", rc);
1032 return CURLE_SSL_CONNECT_ERROR;
1036 return CURLE_OK;
1039#ifdef CURL_GNUTLS_EARLY_DATA
1040static int keylog_callback(gnutls_session_t session, const char *label,
1041 const gnutls_datum_t *secret)
1043 gnutls_datum_t crandom;
1044 gnutls_datum_t srandom;
1046 gnutls_session_get_random(session, &crandom, &srandom);
1047 if(crandom.size != 32) {
1048 return -1;
1051 Curl_tls_keylog_write(label, crandom.data, crandom.size,
1052 secret->data, secret->size);
1053 return 0;
1056static CURLcode gtls_on_session_reuse(struct Curl_cfilter *cf,
1057 struct Curl_easy *data,
1058 struct alpn_spec *alpns,
1059 struct Curl_ssl_session *scs,
1060 bool *do_early_data)
1062 struct ssl_connect_data *connssl = cf->ctx;
1063 struct gtls_ssl_backend_data *backend =
1064 (struct gtls_ssl_backend_data *)connssl->backend;
1066 connssl->earlydata_max =
1067 gnutls_record_get_max_early_data_size(backend->gtls.session);
1069 /* Seems to be no GnuTLS way to signal no EarlyData in session */
1070 return Curl_on_session_reuse(cf, data, alpns, scs, do_early_data,
1071 connssl->earlydata_max &&
1072 connssl->earlydata_max != 0xFFFFFFFFUL);
1074#endif
1076static CURLcode gtls_apply_session(
1077 struct gtls_ctx *gctx,
1078 struct Curl_cfilter *cf,
1079 struct Curl_easy *data,
1080 struct ssl_peer *peer,
1081 struct alpn_spec *alpns,
1082 Curl_gtls_init_session_reuse_cb *sess_reuse_cb,
1083 struct Curl_ssl_session *scs,
1084 bool *pwas_setup)
1086 struct ssl_filter_config *conn_config = Curl_ssl_cf_get_filter_config(cf);
1087 CURLcode result = CURLE_OK;
1088 int rc;
1090 if(scs && scs->sdata && scs->sdata_len &&
1091 (!scs->alpn || Curl_alpn_contains_proto(alpns, scs->alpn))) {
1092 /* we got a cached session, use it! */
1094 result = gtls_client_init(cf, data, peer, scs->earlydata_max, gctx);
1095 if(result)
1096 goto out;
1097 *pwas_setup = TRUE;
1099 rc = gnutls_session_set_data(gctx->session, scs->sdata, scs->sdata_len);
1100 if(rc < 0)
1101 infof(data, "SSL session not accepted by GnuTLS, continuing without");
1102 else {
1103 infof(data, "SSL reusing session with ALPN '%s'",
1104 scs->alpn ? scs->alpn : "-");
1105 if(conn_config->earlydata && scs->alpn &&
1106 !cf->conn->bits.connect_only) {
1107 bool do_early_data = FALSE;
1108 if(sess_reuse_cb) {
1109 result = sess_reuse_cb(cf, data, alpns, scs, &do_early_data);
1110 if(result)
1111 goto out;
1113 if(do_early_data) {
1114 /* We only try the ALPN protocol the session used before,
1115 * otherwise we might send early data for the wrong protocol */
1116 Curl_alpn_restrict_to(alpns, scs->alpn);
1121out:
1122 return result;
1125CURLcode Curl_gtls_ctx_init(struct gtls_ctx *gctx,
1126 struct Curl_cfilter *cf,
1127 struct Curl_easy *data,
1128 struct ssl_peer *peer,
1129 const struct alpn_spec *alpns_requested,
1130 Curl_gtls_ctx_setup_cb *cb_setup,
1131 void *cb_user_data,
1132 void *ssl_user_data,
1133 Curl_gtls_init_session_reuse_cb *sess_reuse_cb)
1135 struct ssl_filter_config *conn_config = Curl_ssl_cf_get_filter_config(cf);
1136 struct Curl_ssl_session *scs = NULL;
1137 gnutls_datum_t gtls_alpns[ALPN_ENTRIES_MAX];
1138 size_t gtls_alpns_count = 0;
1139 bool gtls_session_setup = FALSE;
1140 struct alpn_spec alpns;
1141 CURLcode result = CURLE_OK;
1143 DEBUGASSERT(gctx);
1144 Curl_alpn_copy(&alpns, alpns_requested);
1146 if((cf->sockindex == SECONDARYSOCKET) && !(cf->cft->flags & CF_TYPE_PROXY)) {
1147 /* FTP is a bitch. On TLS secured transfers, it is a common server
1148 * option to require the client to use the SAME TLS session as on
1149 * the control connection or it fails the request. See #22225. */
1150 scs = Curl_ssl_get_cf_session(data, cf->cft, FIRSTSOCKET);
1151 if(scs) {
1152 result = gtls_apply_session(gctx, cf, data, peer, &alpns,
1153 sess_reuse_cb, scs, &gtls_session_setup);
1154 scs = NULL;
1155 if(!result && gtls_session_setup) {
1156 CURL_TRC_CF(data, cf, "applied SSL session from control connection");
1160 /* This might be a reconnect, so we check for a session ID in the cache
1161 to speed up things. We need to do this before constructing the GnuTLS
1162 session since we need to set flags depending on the kind of reuse. */
1163 if(!gtls_session_setup && conn_config->cache_session &&
1164 !conn_config->verifystatus) {
1165 result = Curl_ssl_scache_take(cf, data, peer->scache_key, &scs);
1166 if(result)
1167 goto out;
1168 result = gtls_apply_session(gctx, cf, data, peer, &alpns,
1169 sess_reuse_cb, scs, &gtls_session_setup);
1172 if(!gtls_session_setup) {
1173 result = gtls_client_init(cf, data, peer, 0, gctx);
1174 if(result)
1175 goto out;
1178 gnutls_session_set_ptr(gctx->session, ssl_user_data);
1180 if(cb_setup) {
1181 result = cb_setup(cf, data, cb_user_data);
1182 if(result)
1183 goto out;
1186#ifdef CURL_GNUTLS_EARLY_DATA
1187 /* Open the file if a TLS or QUIC backend has not done this before. */
1188 Curl_tls_keylog_open();
1189 if(Curl_tls_keylog_enabled()) {
1190 gnutls_session_set_keylog_function(gctx->session, keylog_callback);
1192#endif
1194 /* convert the ALPN string from our arguments to a list of strings that
1195 * GnuTLS wants and does convert internally back to this string for sending
1196 * to the server. nice. */
1197 if(!gtls_alpns_count && alpns.count) {
1198 size_t i;
1199 DEBUGASSERT(CURL_ARRAYSIZE(gtls_alpns) >= alpns.count);
1200 for(i = 0; i < alpns.count; ++i) {
1201 gtls_alpns[i].data = (unsigned char *)alpns.entries[i];
1202 gtls_alpns[i].size = (unsigned int)strlen(alpns.entries[i]);
1204 gtls_alpns_count = alpns.count;
1207 if(gtls_alpns_count &&
1208 gnutls_alpn_set_protocols(gctx->session,
1209 gtls_alpns, (unsigned int)gtls_alpns_count,
1210 GNUTLS_ALPN_MANDATORY)) {
1211 failf(data, "failed setting ALPN");
1212 result = CURLE_SSL_CONNECT_ERROR;
1215out:
1216 Curl_ssl_scache_return(cf, data, peer->scache_key, scs);
1217 return result;
1220static CURLcode gtls_connect_step1(struct Curl_cfilter *cf,
1221 struct Curl_easy *data)
1223 struct ssl_connect_data *connssl = cf->ctx;
1224 struct gtls_ssl_backend_data *backend =
1225 (struct gtls_ssl_backend_data *)connssl->backend;
1226 CURLcode result;
1228 DEBUGASSERT(backend);
1230 if(connssl->state == ssl_connection_complete)
1231 /* to make us tolerant against being called more than once for the
1232 same connection */
1233 return CURLE_OK;
1235 result = Curl_gtls_ctx_init(&backend->gtls, cf, data, &connssl->peer,
1236 connssl->alpn, NULL, NULL, cf,
1237#ifdef CURL_GNUTLS_EARLY_DATA
1238 gtls_on_session_reuse
1239#else
1240 NULL
1241#endif
1242 );
1244 if(result)
1245 return result;
1247 if(connssl->alpn && (connssl->state != ssl_connection_deferred)) {
1248 struct alpn_proto_buf proto;
1249 memset(&proto, 0, sizeof(proto));
1250 Curl_alpn_to_proto_str(&proto, connssl->alpn);
1251 infof(data, VTLS_INFOF_ALPN_OFFER_1STR, proto.data);
1254#ifdef CURL_GNUTLS_EARLY_DATA
1255 gnutls_handshake_set_hook_function(backend->gtls.session,
1256 GNUTLS_HANDSHAKE_ANY, GNUTLS_HOOK_POST,
1257 gtls_handshake_cb);
1258#endif
1260 /* register callback functions and handle to send and receive data. */
1261 gnutls_transport_set_ptr(backend->gtls.session, cf);
1262 gnutls_transport_set_push_function(backend->gtls.session, gtls_push);
1263 gnutls_transport_set_pull_function(backend->gtls.session, gtls_pull);
1265 return CURLE_OK;
1268static CURLcode pkp_pin_peer_pubkey(struct Curl_easy *data,
1269 gnutls_x509_crt_t cert,
1270 const char *pinnedpubkey)
1272 /* Scratch */
1273 size_t len1 = 0, len2 = 0;
1274 unsigned char *buff1 = NULL;
1276 gnutls_pubkey_t key = NULL;
1278 /* Result is returned to caller */
1279 CURLcode result = CURLE_SSL_PINNEDPUBKEYNOTMATCH;
1281 /* if a path was not specified, do not pin */
1282 if(!pinnedpubkey)
1283 return CURLE_OK;
1285 if(!cert)
1286 return result;
1288 do {
1289 int ret;
1291 /* Begin Gyrations to get the public key */
1292 ret = gnutls_pubkey_init(&key);
1293 if(ret < 0)
1294 break; /* failed */
1296 ret = gnutls_pubkey_import_x509(key, cert, 0);
1297 if(ret < 0)
1298 break; /* failed */
1300 ret = gnutls_pubkey_export(key, GNUTLS_X509_FMT_DER, NULL, &len1);
1301 if(ret != GNUTLS_E_SHORT_MEMORY_BUFFER || len1 == 0)
1302 break; /* failed */
1304 buff1 = curlx_malloc(len1);
1305 if(!buff1)
1306 break; /* failed */
1308 len2 = len1;
1310 ret = gnutls_pubkey_export(key, GNUTLS_X509_FMT_DER, buff1, &len2);
1311 if(ret < 0 || len1 != len2)
1312 break; /* failed */
1314 /* End Gyrations */
1316 /* The one good exit point */
1317 result = Curl_pin_peer_pubkey(data, pinnedpubkey, buff1, len1);
1318 } while(0);
1320 if(key)
1321 gnutls_pubkey_deinit(key);
1323 curlx_safefree(buff1);
1325 return result;
1328void Curl_gtls_report_handshake(struct Curl_easy *data, struct gtls_ctx *gctx)
1330#ifdef CURLVERBOSE
1331 if(Curl_trc_is_verbose(data)) {
1332 const char *ptr;
1333 gnutls_protocol_t version = gnutls_protocol_get_version(gctx->session);
1335 /* the name of the cipher suite used, e.g. ECDHE_RSA_AES_256_GCM_SHA384. */
1336 ptr = gnutls_cipher_suite_get_name(gnutls_kx_get(gctx->session),
1337 gnutls_cipher_get(gctx->session),
1338 gnutls_mac_get(gctx->session));
1340 infof(data, "SSL connection using %s / %s",
1341 gnutls_protocol_get_name(version), ptr);
1343#else
1344 (void)data;
1345 (void)gctx;
1346#endif
1349static void gtls_msg_verify_result(struct Curl_easy *data,
1350 struct ssl_peer *peer,
1351 gnutls_x509_crt_t x509_cert,
1352 bool was_verified,
1353 bool needs_verified)
1355 char certname[65] = ""; /* limited to 64 chars by ASN.1 */
1356 size_t size = sizeof(certname);
1357 int rc;
1359 rc = gnutls_x509_crt_get_dn_by_oid(x509_cert, GNUTLS_OID_X520_COMMON_NAME,
1360 0, /* the first and only one */
1361 FALSE, certname, &size);
1362 if(rc) {
1363 infof(data, "error fetching CN from cert:%s", gnutls_strerror(rc));
1364 certname[0] = 0;
1367 if(!was_verified) {
1368 if(needs_verified) {
1369 failf(data, "SSL: certificate subject name (%s) does not match "
1370 "target hostname '%s'", certname,
1371 peer->origin->user_hostname);
1373 else
1374 infof(data, " common name: %s (does not match '%s')",
1375 certname, peer->origin->user_hostname);
1377 else
1378 infof(data, " common name: %s (matched)", certname);
1381static void gtls_infof_cert(struct Curl_easy *data,
1382 gnutls_x509_crt_t x509_cert)
1384#ifdef CURLVERBOSE
1385 if(Curl_trc_is_verbose(data)) {
1386 gnutls_datum_t certfields;
1387 int rc, algo;
1388 time_t tstamp;
1389 unsigned int bits;
1391 /* public key algorithm's parameters */
1392 algo = gnutls_x509_crt_get_pk_algorithm(x509_cert, &bits);
1393 infof(data, " certificate public key: %s",
1394 gnutls_pk_algorithm_get_name((gnutls_pk_algorithm_t)algo));
1396 /* version of the X.509 certificate. */
1397 infof(data, " certificate version: #%d",
1398 gnutls_x509_crt_get_version(x509_cert));
1400 rc = gnutls_x509_crt_get_dn2(x509_cert, &certfields);
1401 if(rc)
1402 infof(data, "Failed to get certificate name");
1403 else {
1404 infof(data, " subject: %s", certfields.data);
1406 tstamp = gnutls_x509_crt_get_activation_time(x509_cert);
1407 showtime(data, "start date", tstamp);
1409 tstamp = gnutls_x509_crt_get_expiration_time(x509_cert);
1410 showtime(data, "expire date", tstamp);
1412 gnutls_free(certfields.data);
1415 rc = gnutls_x509_crt_get_issuer_dn2(x509_cert, &certfields);
1416 if(rc)
1417 infof(data, "Failed to get certificate issuer");
1418 else {
1419 infof(data, " issuer: %s", certfields.data);
1421 gnutls_free(certfields.data);
1424#else
1425 (void)data;
1426 (void)x509_cert;
1427#endif
1430static CURLcode gtls_verify_ocsp_status(struct Curl_easy *data,
1431 gnutls_session_t session,
1432 gnutls_x509_crt_t cert)
1434 gnutls_datum_t ocsp_raw;
1435 gnutls_ocsp_resp_t ocsp_resp = NULL;
1436 CURLcode result = CURLE_SSL_INVALIDCERTSTATUS;
1437 int rc, idx;
1438 bool ocsp_init = FALSE;
1439 gnutls_ocsp_cert_status_t status = GNUTLS_OCSP_CERT_UNKNOWN;
1441 /* Get the OCSP stapled response. We require it to be there. */
1442 rc = gnutls_ocsp_status_request_get(session, &ocsp_raw);
1443 if(rc == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE) {
1444 failf(data, "No OCSP response received");
1445 goto out;
1447 else if(rc < 0) {
1448 failf(data, "Invalid OCSP response received");
1449 goto out;
1451 /* Parse the OCSP response, which needs to succeed. */
1452 rc = gnutls_ocsp_resp_init(&ocsp_resp);
1453 if(rc < 0) {
1454 failf(data, "failed to init OCSP response parsing");
1455 goto out;
1457 ocsp_init = TRUE;
1458 rc = gnutls_ocsp_resp_import(ocsp_resp, &ocsp_raw);
1459 if(rc < 0) {
1460 failf(data, "failed to parse OCSP response");
1461 goto out;
1463 /* OCSP responses carry a basic, overall status and then individual
1464 * parts for different certificates. The overall status must be good. */
1465 if(gnutls_ocsp_resp_get_status(ocsp_resp) != GNUTLS_OCSP_RESP_SUCCESSFUL) {
1466 failf(data, "OCSP response basic part is not successful");
1467 goto out;
1469 /* Find the OCSP sub-response for the peer certificate. */
1470 for(idx = 0;; idx++) {
1471 rc = gnutls_ocsp_resp_check_crt(ocsp_resp, idx, cert);
1472 if(!rc || (rc == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE))
1473 break;
1475 if(rc < 0) {
1476 failf(data, "OCSP does not carry status for peer cert");
1477 goto out;
1479 /* The peer certificate OCSP status is at index `idx`.
1480 * Coming here means that GnuTLS has already checked that
1481 * - the signature of this OCSP status has been verified
1482 * - the timestamp of this OCSP status has been tested
1483 * We therefore need only to inspect that actual status code. */
1484 rc = gnutls_ocsp_resp_get_single(ocsp_resp, idx, NULL, NULL, NULL, NULL,
1485 &status, NULL, NULL, NULL, NULL);
1486 if(rc < 0) {
1487 failf(data, "failed to parse OCSP response for peer cert");
1488 goto out;
1490 switch(status) {
1491 case GNUTLS_OCSP_CERT_GOOD:
1492 /* We only regard this as OK and fail all other status codes. */
1493 result = CURLE_OK;
1494 break;
1495 case GNUTLS_OCSP_CERT_REVOKED:
1496 failf(data, "peer certificate is revoked");
1497 break;
1498 default:
1499 failf(data, "peer certificate OCSP status is not good: %d", (int)status);
1500 break;
1503out:
1504 if(ocsp_init)
1505 gnutls_ocsp_resp_deinit(ocsp_resp);
1506 return result;
1509struct gtls_cert_chain {
1510 const gnutls_datum_t *certs;
1511 unsigned int num_certs;
1514#ifdef USE_APPLE_SECTRUST
1515static CURLcode gtls_chain_get_der(struct Curl_cfilter *cf,
1516 struct Curl_easy *data,
1517 void *user_data,
1518 size_t i,
1519 unsigned char **pder,
1520 size_t *pder_len)
1522 struct gtls_cert_chain *chain = user_data;
1524 (void)cf;
1525 (void)data;
1526 *pder_len = 0;
1527 *pder = NULL;
1529 if(i >= chain->num_certs)
1530 return CURLE_TOO_LARGE;
1531 *pder = chain->certs[i].data;
1532 *pder_len = (size_t)chain->certs[i].size;
1533 return CURLE_OK;
1535#endif /* USE_APPLE_SECTRUST */
1537/* This function verifies the peer's certificate and returns CURLE_OK on
1538 success or an appropriate CURLcode on error. The certificate verification
1539 status bitmask (trusted, invalid etc.) is stored in
1540 ssl_config->certverifyresult as one or more gnutls_certificate_status_t
1541 enumerated elements bitwise or'd. */
1542static CURLcode gtls_verify_cert(struct Curl_easy *data,
1543 struct ssl_filter_config *config,
1544 struct ssl_easy_config *ssl_config,
1545 gnutls_session_t session,
1546 struct Curl_cfilter *cf,
1547 struct ssl_peer *peer,
1548 struct gtls_cert_chain *chain,
1549 bool *pocsp_checked)
1551 bool verified = FALSE;
1552 unsigned int verify_status = 0;
1553 long * const certverifyresult = &ssl_config->certverifyresult;
1554 int rc;
1556 *pocsp_checked = FALSE;
1557 rc = gnutls_certificate_verify_peers2(session, &verify_status);
1558 if(rc < 0) {
1559 failf(data, "server cert verify failed: %d", rc);
1560 *certverifyresult = rc;
1561 return CURLE_SSL_CONNECT_ERROR;
1563 *certverifyresult = verify_status;
1564 verified = !(verify_status & GNUTLS_CERT_INVALID);
1565 if(verified)
1566 infof(data, " SSL certificate verified by GnuTLS");
1568#ifdef USE_APPLE_SECTRUST
1569 if(!verified && config->native_ca_store) {
1570 gnutls_datum_t ocsp_raw;
1571 CURLcode result;
1573 if(gnutls_ocsp_status_request_get(session, &ocsp_raw)) {
1574 ocsp_raw.data = NULL;
1575 ocsp_raw.size = 0;
1577 if(config->verifystatus && !ocsp_raw.size) {
1578 failf(data, "No OCSP response received");
1579 return CURLE_SSL_INVALIDCERTSTATUS;
1581 result = Curl_vtls_apple_verify(cf, data, peer, chain->num_certs,
1582 gtls_chain_get_der, chain,
1583 ocsp_raw.data, ocsp_raw.size,
1584 config->verifystatus);
1585 if(result && (result != CURLE_PEER_FAILED_VERIFICATION))
1586 return result; /* no further failure analysis needed */
1587 verified = !result;
1588 if(verified) {
1589 infof(data, "SSL certificate verified via Apple SecTrust.");
1590 *certverifyresult = 0;
1591 *pocsp_checked = TRUE;
1594#else
1595 (void)cf;
1596 (void)peer;
1597 (void)chain;
1598#endif
1600 if(!verified) {
1601 CURLcode result = CURLE_PEER_FAILED_VERIFICATION;
1602 /* verify_status is a bitmask of gnutls_certificate_status bits */
1603 const char *cause = "certificate error, no details available";
1604 if(verify_status & GNUTLS_CERT_EXPIRED)
1605 cause = "certificate has expired";
1606 else if(verify_status & GNUTLS_CERT_SIGNER_NOT_FOUND)
1607 cause = "certificate signer not trusted";
1608 else if(verify_status & GNUTLS_CERT_INSECURE_ALGORITHM)
1609 cause = "certificate uses insecure algorithm";
1610 else if(verify_status & GNUTLS_CERT_INVALID_OCSP_STATUS) {
1611 cause = "OCSP status response is invalid";
1612 result = CURLE_SSL_INVALIDCERTSTATUS;
1614 failf(data, "SSL certificate verification failed: %s. (CAfile: %s "
1615 "CRLfile: %s)", cause,
1616 config->CAfile ? config->CAfile : "none",
1617 config->CRLfile ?
1618 config->CRLfile : "none");
1620 return result;
1622 return CURLE_OK;
1625CURLcode Curl_gtls_verifyserver(struct Curl_cfilter *cf,
1626 struct Curl_easy *data,
1627 gnutls_session_t session,
1628 struct ssl_filter_config *config,
1629 struct ssl_easy_config *ssl_config,
1630 struct ssl_peer *peer,
1631 const char *pinned_key)
1633 struct gtls_cert_chain chain;
1634 gnutls_x509_crt_t x509_cert = NULL, x509_issuer = NULL;
1635 time_t certclock;
1636 bool ocsp_checked = FALSE;
1637 int rc;
1638 CURLcode result = CURLE_OK;
1639 long * const certverifyresult = &ssl_config->certverifyresult;
1641 (void)cf;
1642 /* This function returns the peer's raw certificate (chain) as sent by
1643 the peer. These certificates are in raw format (DER encoded for
1644 X.509). In case of a X.509 then a certificate list may be present. The
1645 first certificate in the list is the peer's certificate, following the
1646 issuer's certificate, then the issuer's issuer etc. */
1648 chain.certs = gnutls_certificate_get_peers(session, &chain.num_certs);
1649 if(!chain.certs) {
1650 if(config->verifypeer ||
1651 config->verifyhost ||
1652 config->issuercert) {
1653 failf(data, "failed to get server cert");
1654 *certverifyresult = GNUTLS_E_NO_CERTIFICATE_FOUND;
1655 result = CURLE_PEER_FAILED_VERIFICATION;
1656 goto out;
1658 infof(data, " common name: WARNING could not obtain");
1661 if(data->set.ssl.certinfo && chain.certs) {
1662 if(chain.num_certs > MAX_ALLOWED_CERT_AMOUNT) {
1663 failf(data, "%u certificates is more than allowed (%d)",
1664 chain.num_certs, MAX_ALLOWED_CERT_AMOUNT);
1665 result = CURLE_SSL_CONNECT_ERROR;
1666 goto out;
1668 else {
1669 unsigned int i;
1671 result = Curl_ssl_init_certinfo(data, (int)chain.num_certs);
1672 if(result)
1673 goto out;
1675 for(i = 0; i < chain.num_certs; i++) {
1676 const uint8_t *beg = chain.certs[i].data;
1677 const uint8_t *end = beg + chain.certs[i].size;
1679 result = Curl_extract_certinfo(data, (int)i, beg, end);
1680 if(result)
1681 goto out;
1686 if(config->verifypeer) {
1687 result = gtls_verify_cert(data, config, ssl_config, session,
1688 cf, peer, &chain, &ocsp_checked);
1689 if(result)
1690 goto out;
1692 else
1693 infof(data, " SSL certificate verification SKIPPED");
1695 /* initialize an X.509 certificate structure. */
1696 if(gnutls_x509_crt_init(&x509_cert)) {
1697 failf(data, "failed to init GnuTLS x509_crt");
1698 *certverifyresult = GNUTLS_E_NO_CERTIFICATE_FOUND;
1699 result = CURLE_SSL_CONNECT_ERROR;
1700 goto out;
1703 if(chain.certs) {
1704 /* convert the given DER or PEM encoded Certificate to the native
1705 gnutls_x509_crt_t format */
1706 rc = gnutls_x509_crt_import(x509_cert, chain.certs, GNUTLS_X509_FMT_DER);
1707 if(rc) {
1708 failf(data, "error parsing server's certificate chain");
1709 *certverifyresult = GNUTLS_E_NO_CERTIFICATE_FOUND;
1710 result = CURLE_SSL_CONNECT_ERROR;
1711 goto out;
1715 /* Check for time-based validity */
1716 certclock = gnutls_x509_crt_get_expiration_time(x509_cert);
1718 if(certclock == (time_t)-1) {
1719 if(config->verifypeer) {
1720 failf(data, "server cert expiration date verify failed");
1721 *certverifyresult = GNUTLS_CERT_EXPIRED;
1722 result = CURLE_SSL_CONNECT_ERROR;
1723 goto out;
1725 else
1726 infof(data, " SSL certificate expiration date verify FAILED");
1728 else {
1729 if(certclock < time(NULL)) {
1730 if(config->verifypeer) {
1731 failf(data, "server certificate expiration date has passed.");
1732 *certverifyresult = GNUTLS_CERT_EXPIRED;
1733 result = CURLE_PEER_FAILED_VERIFICATION;
1734 goto out;
1736 else
1737 infof(data, " SSL certificate expiration date FAILED");
1739 else
1740 infof(data, " SSL certificate expiration date OK");
1743 certclock = gnutls_x509_crt_get_activation_time(x509_cert);
1745 if(certclock == (time_t)-1) {
1746 if(config->verifypeer) {
1747 failf(data, "server cert activation date verify failed");
1748 *certverifyresult = GNUTLS_CERT_NOT_ACTIVATED;
1749 result = CURLE_SSL_CONNECT_ERROR;
1750 goto out;
1752 else
1753 infof(data, " SSL certificate activation date verify FAILED");
1755 else {
1756 if(certclock > time(NULL)) {
1757 if(config->verifypeer) {
1758 failf(data, "server certificate not activated yet.");
1759 *certverifyresult = GNUTLS_CERT_NOT_ACTIVATED;
1760 result = CURLE_PEER_FAILED_VERIFICATION;
1761 goto out;
1763 else
1764 infof(data, " SSL certificate activation date FAILED");
1766 else
1767 infof(data, " SSL certificate activation date OK");
1770 if(config->verifystatus && !ocsp_checked) {
1771 result = gtls_verify_ocsp_status(data, session, x509_cert);
1772 if(result)
1773 goto out;
1775 else
1776 infof(data, " SSL certificate status verification SKIPPED");
1778 if(config->issuercert) {
1779 gnutls_datum_t issuerp;
1780 if(gnutls_x509_crt_init(&x509_issuer)) {
1781 failf(data, "failed to init GnuTLS x509_crt for issuer");
1782 result = CURLE_SSL_ISSUER_ERROR;
1783 goto out;
1785 issuerp = load_file(config->issuercert);
1786 rc = gnutls_x509_crt_import(x509_issuer, &issuerp, GNUTLS_X509_FMT_PEM);
1787 unload_file(issuerp);
1788 if(rc) {
1789 failf(data, "failed to import issuer certificate (%s) (Issuer Cert: %s)",
1790 gnutls_strerror(rc), config->issuercert);
1791 result = CURLE_SSL_ISSUER_ERROR;
1792 goto out;
1794 rc = (int)gnutls_x509_crt_check_issuer(x509_cert, x509_issuer);
1795 if(rc <= 0) {
1796 failf(data, "server certificate issuer check failed (Issuer Cert: %s)",
1797 config->issuercert);
1798 result = CURLE_SSL_ISSUER_ERROR;
1799 goto out;
1801 infof(data, " SSL certificate issuer check OK (Issuer Cert: %s)",
1802 config->issuercert);
1805 /* This function checks if the given certificate's subject matches the
1806 given hostname. This is a basic implementation of the matching described
1807 in RFC2818 (HTTPS), which takes into account wildcards, and the subject
1808 alternative name PKIX extension. Returns non zero on success, and zero on
1809 failure. */
1811 /* This function does not handle trailing dots, so if we have an SNI name
1812 use that and fallback to the hostname only if there is no SNI (like for
1813 IP addresses) */
1814 rc = (int)gnutls_x509_crt_check_hostname(x509_cert,
1815 peer->sni ? peer->sni :
1816 peer->origin->hostname);
1817 result = (!rc && config->verifyhost) ?
1818 CURLE_PEER_FAILED_VERIFICATION : CURLE_OK;
1819 gtls_msg_verify_result(data, peer, x509_cert, rc, config->verifyhost);
1820 if(result)
1821 goto out;
1823 if(pinned_key) {
1824 result = pkp_pin_peer_pubkey(data, x509_cert, pinned_key);
1825 if(result != CURLE_OK) {
1826 failf(data, "SSL: public key does not match pinned public key");
1827 goto out;
1831 gtls_infof_cert(data, x509_cert);
1833out:
1834 if(x509_issuer)
1835 gnutls_x509_crt_deinit(x509_issuer);
1836 if(x509_cert)
1837 gnutls_x509_crt_deinit(x509_cert);
1838 return result;
1841static CURLcode gtls_verifyserver(struct Curl_cfilter *cf,
1842 struct Curl_easy *data,
1843 gnutls_session_t session)
1845 struct ssl_connect_data *connssl = cf->ctx;
1846 struct ssl_filter_config *conn_config = Curl_ssl_cf_get_filter_config(cf);
1847 struct ssl_easy_config *ssl_config = Curl_ssl_cf_get_easy_config(cf, data);
1848#ifndef CURL_DISABLE_PROXY
1849 const char *pinned_key = Curl_ssl_cf_is_proxy(cf) ?
1850 CURL_EASY_STR(data, STRING_SSL_PINNEDPUBLICKEY_PROXY) :
1851 CURL_EASY_STR(data, STRING_SSL_PINNEDPUBLICKEY);
1852#else
1853 const char *pinned_key = CURL_EASY_STR(data, STRING_SSL_PINNEDPUBLICKEY);
1854#endif
1855 CURLcode result;
1857 result = Curl_gtls_verifyserver(cf, data, session, conn_config, ssl_config,
1858 &connssl->peer, pinned_key);
1859 if(result)
1860 goto out;
1862#ifdef CURL_GNUTLS_EARLY_DATA
1863 /* Only on TLSv1.2 or lower do we have the session id now. For
1864 * TLSv1.3 we get it via a SESSION_TICKET message that arrives later. */
1865 if(gnutls_protocol_get_version(session) < GNUTLS_TLS1_3)
1866 result = cf_gtls_update_session_id(cf, data, session);
1867#endif
1869out:
1870 return result;
1873#ifdef CURL_GNUTLS_EARLY_DATA
1874static CURLcode gtls_send_earlydata(struct Curl_cfilter *cf,
1875 struct Curl_easy *data)
1877 struct ssl_connect_data *connssl = cf->ctx;
1878 struct gtls_ssl_backend_data *backend =
1879 (struct gtls_ssl_backend_data *)connssl->backend;
1880 CURLcode result = CURLE_OK;
1881 const unsigned char *buf;
1882 size_t blen;
1883 ssize_t n;
1885 DEBUGASSERT(connssl->earlydata_state == ssl_earlydata_sending);
1886 backend->gtls.io_result = CURLE_OK;
1887 while(Curl_bufq_peek(&connssl->earlydata, &buf, &blen)) {
1888 n = gnutls_record_send_early_data(backend->gtls.session, buf, blen);
1889 CURL_TRC_CF(data, cf, "gtls_send_earlydata(len=%zu) -> %zd", blen, n);
1890 if(n < 0) {
1891 if(n == GNUTLS_E_AGAIN)
1892 result = CURLE_AGAIN;
1893 else
1894 result = backend->gtls.io_result ?
1895 backend->gtls.io_result : CURLE_SEND_ERROR;
1896 goto out;
1898 else if(!n) {
1899 /* GnuTLS is buggy, it *SHOULD* return the amount of bytes it took in.
1900 * Instead it returns 0 if everything was written. */
1901 n = (ssize_t)blen;
1904 Curl_bufq_skip(&connssl->earlydata, (size_t)n);
1906 /* sent everything there was */
1907 infof(data, "SSL sending %zu bytes of early data", connssl->earlydata_skip);
1908out:
1909 return result;
1911#endif
1914 * This function is called after the TCP connect has completed. Setup the TLS
1915 * layer and do all necessary magic.
1916 */
1917/* We use connssl->connecting_state to keep track of the connection status;
1918 there are three states: 'ssl_connect_1' (not started yet or complete),
1919 'ssl_connect_2' (doing handshake with the server), and
1920 'ssl_connect_3' (verifying and getting stats).
1921 */
1922static CURLcode gtls_connect_common(struct Curl_cfilter *cf,
1923 struct Curl_easy *data,
1924 bool *done)
1926 struct ssl_connect_data *connssl = cf->ctx;
1927 struct gtls_ssl_backend_data *backend =
1928 (struct gtls_ssl_backend_data *)connssl->backend;
1929 CURLcode result = CURLE_OK;
1931 DEBUGASSERT(backend);
1932 /* check if the connection has already been established */
1933 if(ssl_connection_complete == connssl->state) {
1934 *done = TRUE;
1935 return CURLE_OK;
1938 *done = FALSE;
1940 /* Initiate the connection, if not already done */
1941 if(connssl->connecting_state == ssl_connect_1) {
1942 result = gtls_connect_step1(cf, data);
1943 if(result)
1944 goto out;
1945 connssl->connecting_state = ssl_connect_2;
1948 if(connssl->connecting_state == ssl_connect_2) {
1949#ifdef CURL_GNUTLS_EARLY_DATA
1950 if(connssl->earlydata_state == ssl_earlydata_await) {
1951 goto out;
1953 else if(connssl->earlydata_state == ssl_earlydata_sending) {
1954 result = gtls_send_earlydata(cf, data);
1955 if(result)
1956 goto out;
1957 connssl->earlydata_state = ssl_earlydata_sent;
1959 DEBUGASSERT((connssl->earlydata_state == ssl_earlydata_none) ||
1960 (connssl->earlydata_state == ssl_earlydata_sent));
1961#endif
1962 result = cf_gtls_handshake(cf, data);
1963 if(result)
1964 goto out;
1965 connssl->connecting_state = ssl_connect_3;
1968 /* Finish connecting once the handshake is done */
1969 if(connssl->connecting_state == ssl_connect_3) {
1970 gnutls_datum_t proto;
1971 int rc;
1973 Curl_gtls_report_handshake(data, &backend->gtls);
1975 result = gtls_verifyserver(cf, data, backend->gtls.session);
1976 if(result)
1977 goto out;
1979 connssl->state = ssl_connection_complete;
1981 rc = gnutls_alpn_get_selected_protocol(backend->gtls.session, &proto);
1982 if(rc) { /* No ALPN from server */
1983 proto.data = NULL;
1984 proto.size = 0;
1987 result = Curl_alpn_set_negotiated(cf, data, connssl,
1988 proto.data, proto.size);
1989 if(result)
1990 goto out;
1992#ifdef CURL_GNUTLS_EARLY_DATA
1993 if(connssl->earlydata_state > ssl_earlydata_none) {
1994 /* We should be in this state by now */
1995 DEBUGASSERT(connssl->earlydata_state == ssl_earlydata_sent);
1996 connssl->earlydata_state =
1997 (gnutls_session_get_flags(backend->gtls.session) &
1998 GNUTLS_SFLAGS_EARLY_DATA) ?
1999 ssl_earlydata_accepted : ssl_earlydata_rejected;
2001#endif
2002 connssl->connecting_state = ssl_connect_done;
2005 if(connssl->connecting_state == ssl_connect_done)
2006 DEBUGASSERT(connssl->state == ssl_connection_complete);
2008out:
2009 if(result == CURLE_AGAIN) {
2010 *done = FALSE;
2011 return CURLE_OK;
2013 *done = ((connssl->state == ssl_connection_complete) ||
2014 (connssl->state == ssl_connection_deferred));
2015 CURL_TRC_CF(data, cf, "gtls_connect_common() -> %d, done=%d", (int)result,
2016 *done);
2017 return result;
2020static CURLcode gtls_connect(struct Curl_cfilter *cf,
2021 struct Curl_easy *data,
2022 bool *done)
2024#ifdef CURL_GNUTLS_EARLY_DATA
2025 struct ssl_connect_data *connssl = cf->ctx;
2026 if((connssl->state == ssl_connection_deferred) &&
2027 (connssl->earlydata_state == ssl_earlydata_await)) {
2028 /* We refuse to be pushed, we are waiting for someone to send/recv. */
2029 *done = TRUE;
2030 return CURLE_OK;
2032#endif
2033 return gtls_connect_common(cf, data, done);
2036static bool gtls_data_pending(struct Curl_cfilter *cf,
2037 const struct Curl_easy *data)
2039 struct ssl_connect_data *ctx = cf->ctx;
2040 struct gtls_ssl_backend_data *backend;
2042 (void)data;
2043 DEBUGASSERT(ctx && ctx->backend);
2044 backend = (struct gtls_ssl_backend_data *)ctx->backend;
2045 if(backend->gtls.session &&
2046 gnutls_record_check_pending(backend->gtls.session) != 0)
2047 return TRUE;
2048 return FALSE;
2051static CURLcode gtls_send(struct Curl_cfilter *cf,
2052 struct Curl_easy *data,
2053 const void *buf,
2054 size_t blen,
2055 size_t *pnwritten)
2057 struct ssl_connect_data *connssl = cf->ctx;
2058 struct gtls_ssl_backend_data *backend =
2059 (struct gtls_ssl_backend_data *)connssl->backend;
2060 CURLcode result = CURLE_OK;
2061 ssize_t nwritten;
2062 size_t remain = blen;
2064 DEBUGASSERT(backend);
2065 *pnwritten = 0;
2067 while(remain) {
2068 backend->gtls.io_result = CURLE_OK;
2069 nwritten = gnutls_record_send(backend->gtls.session, buf, remain);
2071 if(nwritten >= 0) {
2072 if((size_t)nwritten > remain) {
2073 DEBUGASSERT(0);
2074 failf(data, "gnutls_record_send(len=%zu) returned %zd",
2075 remain, nwritten);
2076 return CURLE_SEND_ERROR;
2078 *pnwritten += (size_t)nwritten;
2079 buf = (char *)CURL_UNCONST(buf) + (size_t)nwritten;
2080 remain -= (size_t)nwritten;
2082 else {
2083 if(*pnwritten && (nwritten == GNUTLS_E_AGAIN)) {
2084 result = CURLE_OK;
2085 goto out;
2087 result = (nwritten == GNUTLS_E_AGAIN) ?
2088 CURLE_AGAIN :
2089 (backend->gtls.io_result ? backend->gtls.io_result : CURLE_SEND_ERROR);
2090 goto out;
2094out:
2095 CURL_TRC_CF(data, cf, "gtls_send(len=%zu) -> %d, %zu",
2096 blen, (int)result, *pnwritten);
2097 return result;
2101 * This function is called to shut down the SSL layer but keep the
2102 * socket open (CCC - Clear Command Channel)
2103 */
2104static CURLcode gtls_shutdown(struct Curl_cfilter *cf,
2105 struct Curl_easy *data,
2106 bool send_shutdown, bool *done)
2108 struct ssl_connect_data *connssl = cf->ctx;
2109 struct gtls_ssl_backend_data *backend =
2110 (struct gtls_ssl_backend_data *)connssl->backend;
2111 char buf[1024];
2112 CURLcode result = CURLE_OK;
2113 ssize_t nread = 0;
2114 size_t i;
2116 DEBUGASSERT(backend);
2117 /* If we have no handshaked connection or already shut down */
2118 if(!backend->gtls.session || cf->shutdown ||
2119 connssl->state != ssl_connection_complete) {
2120 *done = TRUE;
2121 goto out;
2124 connssl->io_need = CURL_SSL_IO_NEED_NONE;
2125 *done = FALSE;
2127 if(!backend->gtls.sent_shutdown) {
2128 /* do this only once */
2129 backend->gtls.sent_shutdown = TRUE;
2130 if(send_shutdown) {
2131 int ret = gnutls_bye(backend->gtls.session, GNUTLS_SHUT_RDWR);
2132 if((ret == GNUTLS_E_AGAIN) || (ret == GNUTLS_E_INTERRUPTED)) {
2133 CURL_TRC_CF(data, cf, "SSL shutdown, gnutls_bye EAGAIN");
2134 connssl->io_need = gnutls_record_get_direction(backend->gtls.session) ?
2135 CURL_SSL_IO_NEED_SEND : CURL_SSL_IO_NEED_RECV;
2136 backend->gtls.sent_shutdown = FALSE;
2137 result = CURLE_OK;
2138 goto out;
2140 if(ret != GNUTLS_E_SUCCESS) {
2141 CURL_TRC_CF(data, cf, "SSL shutdown, gnutls_bye error: '%s'(%d)",
2142 gnutls_strerror((int)ret), (int)ret);
2143 result = CURLE_RECV_ERROR;
2144 goto out;
2149 /* SSL should now have started the shutdown from our side. Since it
2150 * was not complete, we are lacking the close notify from the server. */
2151 for(i = 0; i < 10; ++i) {
2152 nread = gnutls_record_recv(backend->gtls.session, buf, sizeof(buf));
2153 if(nread <= 0)
2154 break;
2156 if(nread > 0) {
2157 /* still data coming in? */
2159 else if(nread == 0) {
2160 /* We got the close notify alert and are done. */
2161 *done = TRUE;
2163 else if((nread == GNUTLS_E_AGAIN) || (nread == GNUTLS_E_INTERRUPTED)) {
2164 connssl->io_need = gnutls_record_get_direction(backend->gtls.session) ?
2165 CURL_SSL_IO_NEED_SEND : CURL_SSL_IO_NEED_RECV;
2167 else {
2168 CURL_TRC_CF(data, cf, "SSL shutdown, error: '%s'(%d)",
2169 gnutls_strerror((int)nread), (int)nread);
2170 result = CURLE_RECV_ERROR;
2173out:
2174 cf->shutdown = (result || *done);
2175 return result;
2178static void gtls_close(struct Curl_cfilter *cf,
2179 struct Curl_easy *data)
2181 struct ssl_connect_data *connssl = cf->ctx;
2182 struct gtls_ssl_backend_data *backend =
2183 (struct gtls_ssl_backend_data *)connssl->backend;
2185 DEBUGASSERT(backend);
2186 CURL_TRC_CF(data, cf, "close");
2187 if(backend->gtls.session) {
2188 gnutls_deinit(backend->gtls.session);
2189 backend->gtls.session = NULL;
2191 if(backend->gtls.shared_creds) {
2192 Curl_gtls_shared_creds_free(&backend->gtls.shared_creds);
2196static CURLcode gtls_recv(struct Curl_cfilter *cf,
2197 struct Curl_easy *data,
2198 char *buf, size_t blen,
2199 size_t *pnread)
2201 struct ssl_connect_data *connssl = cf->ctx;
2202 struct gtls_ssl_backend_data *backend =
2203 (struct gtls_ssl_backend_data *)connssl->backend;
2204 CURLcode result = CURLE_OK;
2205 ssize_t nread;
2207 DEBUGASSERT(backend);
2209 nread = gnutls_record_recv(backend->gtls.session, buf, blen);
2211 if(nread >= 0)
2212 *pnread = (size_t)nread;
2213 else {
2214 if((nread == GNUTLS_E_AGAIN) || (nread == GNUTLS_E_INTERRUPTED)) {
2215 result = CURLE_AGAIN;
2216 goto out;
2218 else if(nread == GNUTLS_E_REHANDSHAKE) {
2219 /* Either TLSv1.2 renegotiate or a TLSv1.3 session key update. */
2220 result = cf_gtls_handshake(cf, data);
2221 if(!result)
2222 result = CURLE_AGAIN; /* make us get called again. */
2223 goto out;
2225 else {
2226 failf(data, "GnuTLS recv error (%d): %s",
2227 (int)nread, gnutls_strerror((int)nread));
2228 result = backend->gtls.io_result ?
2229 backend->gtls.io_result : CURLE_RECV_ERROR;
2230 goto out;
2234out:
2235 CURL_TRC_CF(data, cf, "gtls_recv(len=%zu) -> %d, %zd", blen,
2236 (int)result, nread);
2237 return result;
2240size_t Curl_gtls_version(char *buffer, size_t size)
2242 return curl_msnprintf(buffer, size, "GnuTLS/%s", gnutls_check_version(NULL));
2245/* data might be NULL! */
2246static CURLcode gtls_random(struct Curl_easy *data,
2247 unsigned char *entropy, size_t length)
2249 int rc;
2250 (void)data;
2251 rc = gnutls_rnd(GNUTLS_RND_RANDOM, entropy, length);
2252 return rc ? CURLE_FAILED_INIT : CURLE_OK;
2255static CURLcode gtls_sha256sum(const unsigned char *input,
2256 size_t len,
2257 unsigned char *sha256sum, /* output */
2258 size_t sha256len)
2260 struct sha256_ctx SHA256pw;
2261 sha256_init(&SHA256pw);
2262 do {
2263 unsigned int ilen = (unsigned int)CURLMIN(len, UINT_MAX);
2264 sha256_update(&SHA256pw, ilen, input);
2265 len -= ilen;
2266 input += ilen;
2267 } while(len);
2268#if NETTLE_VERSION_MAJOR >= 4
2269 (void)sha256len;
2270 sha256_digest(&SHA256pw, sha256sum);
2271#else
2272 sha256_digest(&SHA256pw, (unsigned int)sha256len, sha256sum);
2273#endif
2274 return CURLE_OK;
2277static bool gtls_cert_status_request(void)
2279 return TRUE;
2282static void *gtls_get_internals(struct ssl_connect_data *connssl,
2283 CURLINFO info)
2285 struct gtls_ssl_backend_data *backend =
2286 (struct gtls_ssl_backend_data *)connssl->backend;
2287 (void)info;
2288 DEBUGASSERT(backend);
2289 return backend->gtls.session;
2292const struct Curl_ssl Curl_ssl_gnutls = {
2293 { CURLSSLBACKEND_GNUTLS, "gnutls" }, /* info */
2295 SSLSUPP_CA_PATH |
2296 SSLSUPP_CERTINFO |
2297 SSLSUPP_PINNEDPUBKEY |
2298 SSLSUPP_HTTPS_PROXY |
2299 SSLSUPP_CAINFO_BLOB |
2300 SSLSUPP_CIPHER_LIST |
2301 SSLSUPP_CA_CACHE |
2302 SSLSUPP_ISSUERCERT |
2303 SSLSUPP_CRLFILE,
2305 sizeof(struct gtls_ssl_backend_data),
2307 gtls_init, /* init */
2308 gtls_cleanup, /* cleanup */
2309 Curl_gtls_version, /* version */
2310 gtls_shutdown, /* shutdown */
2311 gtls_data_pending, /* data_pending */
2312 gtls_random, /* random */
2313 gtls_cert_status_request, /* cert_status_request */
2314 gtls_connect, /* connect */
2315 Curl_ssl_adjust_pollset, /* adjust_pollset */
2316 gtls_get_internals, /* get_internals */
2317 gtls_close, /* close_one */
2318 NULL, /* close_all */
2319 NULL, /* engines_list */
2320 gtls_sha256sum, /* sha256sum */
2321 gtls_recv, /* recv decrypted data */
2322 gtls_send, /* send data to encrypt */
2323 NULL, /* get_channel_binding */
2326#endif /* USE_GNUTLS */
Diagnostics4 git calls · 27 ms
CallStatusSizeTime027 ms
discover200152 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=152
git.server.agent=gitty/1.0
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch object-format
git.server.fetch=shallow filter sideband-all
git.protocol.version=2
git.pkt.frames=8
git.pkt.data=6
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=152
git.pkt.payload.max=34
ls-refs200149 B · hit3 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=149
git.response.cache=HIT
git.response.duration_ms=3
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=149
git.pkt.payload.max=78
git.ls_refs.count=2
git.ls_refs.head=refs/heads/master
fetchblob:none · deepen 10200287 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=22
git.response.bytes=293470
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=blob:none
git.fetch.filter.requested=tree:0
git.fetch.filter.fallback=blob:none
git.fetch.filter.learned=false
git.fetch.wants=31c911efe5652725e930f4d2e60c9060e5f6646d
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=10
git.pkt.data=8
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=293470
git.pkt.payload.max=65516
git.sideband.band1.bytes=293354
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=87
git.pack.bytes=293354
git.pack.ofs_delta=0
git.pack.ref_delta=1
git.pack.chain.max=1
git.pack.trailer=6a646bcda6740bab42e321b51998b52ea15146c0
git.pack.full=86
Open pack map
fetch20020 KiB · hit22 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=20187
git.response.cache=HIT
git.response.duration_ms=22
git.fetch.wants=54074e43be612809b988271721ed93b5c81e486f
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=20187
git.pkt.payload.max=20166
git.sideband.band1.bytes=20165
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/curl.git
Ref
refs/heads/master
Commit
31c911efe5652725e930f4d2e60c9060e5f6646d
cf-ray
a5e34240c9346e2a
Request
caf93cef…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format