master
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 ***************************************************************************/
25/* This file is for implementing all "generic" SSL functions that all libcurl
26 internals should use. It is then responsible for calling the proper
27 "backend" function.
29 SSL-functions in libcurl should call functions in this source file, and not
30 to any specific SSL-layer.
32 Curl_ssl_ - prefix for generic ones
34 Note that this source code uses the functions of the configured SSL
35 backend via the global Curl_ssl instance.
37 "SSL/TLS Strong Encryption: An Introduction"
38 https://httpd.apache.org/docs/2.0/ssl/ssl_intro.html
39 */
41#include "curl_setup.h"
43#include "urldata.h"
44#include "setopt.h"
45#include "strcase.h"
46#include "vtls/vtls.h"
47#include "vtls/vtls_config.h"
50#define CLONE_STRING(var) \
51 do { \
52 if(source->var) { \
53 dest->var = curlx_strdup(source->var); \
54 if(!dest->var) \
55 return FALSE; \
56 } \
57 else \
58 dest->var = NULL; \
59 } while(0)
61#define CLONE_BLOB(var) \
62 do { \
63 if(blobdup(&dest->var, source->var)) \
64 return FALSE; \
65 } while(0)
67static CURLcode blobdup(struct curl_blob **dest, struct curl_blob *src)
68{
69 DEBUGASSERT(dest);
70 DEBUGASSERT(!*dest);
71 if(src) {
72 /* only if there is data to dupe! */
73 struct curl_blob *d;
74 d = curlx_malloc(sizeof(struct curl_blob) + src->len);
75 if(!d)
76 return CURLE_OUT_OF_MEMORY;
77 d->len = src->len;
78 /* Always duplicate because the connection may survive longer than the
79 handle that passed in the blob. */
80 d->flags = CURL_BLOB_COPY;
81 d->data = (void *)((char *)d + sizeof(struct curl_blob));
82 memcpy(d->data, src->data, src->len);
83 *dest = d;
84 }
85 return CURLE_OK;
86}
88/* returns TRUE if the blobs are identical */
89static bool blobcmp(struct curl_blob *first, struct curl_blob *second)
90{
91 if(!first && !second) /* both are NULL */
92 return TRUE;
93 if(!first || !second) /* one is NULL */
94 return FALSE;
95 if(first->len != second->len) /* different sizes */
96 return FALSE;
97 return !memcmp(first->data, second->data, first->len); /* same data */
98}
100void Curl_ssl_config_init(struct ssl_easy_config *sslc)
101{
102 /*
103 * libcurl 7.10 introduced SSL verification *by default*! This needs to be
104 * switched off unless wanted.
105 */
106 sslc->verifypeer = TRUE;
107 sslc->verifyhost = TRUE;
108 sslc->cache_session = TRUE; /* caching by default */
109}
111void Curl_ssl_config_cleanup(struct ssl_filter_config *sslc)
112{
113 if(sslc->deep_copy) {
114 curlx_safefree(sslc->CApath);
115 curlx_safefree(sslc->CAfile);
116 curlx_safefree(sslc->issuercert);
117 curlx_safefree(sslc->clientcert);
118 curlx_safefree(sslc->cipher_list);
119 curlx_safefree(sslc->cipher_list13);
120 curlx_safefree(sslc->pinned_key);
121 curlx_safefree(sslc->cert_blob);
122 curlx_safefree(sslc->ca_info_blob);
123 curlx_safefree(sslc->issuercert_blob);
124 curlx_safefree(sslc->key_blob);
125 curlx_safefree(sslc->curves);
126 curlx_safefree(sslc->signature_algorithms);
127 curlx_safefree(sslc->CRLfile);
128 curlx_safefree(sslc->cert_type);
129 curlx_safefree(sslc->key);
130 curlx_safefree(sslc->key_type);
131 curlx_safefree(sslc->key_passwd);
132#ifdef USE_ECH
133 curlx_safefree(sslc->ech_config);
134 curlx_safefree(sslc->ech_public);
135#endif
136 sslc->deep_copy = FALSE;
137 }
138}
140static bool match_ssl_primary_config(struct Curl_easy *data,
141 struct ssl_filter_config *c1,
142 struct ssl_filter_config *c2)
143{
144 (void)data;
145 if((c1->version == c2->version) &&
146 (c1->version_max == c2->version_max) &&
147 (c1->ssl_options == c2->ssl_options) &&
148 (c1->native_ca_store == c2->native_ca_store) &&
149 (c1->verifypeer == c2->verifypeer) &&
150 (c1->verifyhost == c2->verifyhost) &&
151 (c1->verifystatus == c2->verifystatus) &&
152 (c1->auto_client_cert == c2->auto_client_cert) &&
153#ifdef USE_ECH
154 (c1->ech == c2->ech) &&
155 Curl_safecmp(c1->ech_config, c2->ech_config) &&
156 Curl_safecmp(c1->ech_public, c2->ech_public) &&
157#endif
158 blobcmp(c1->cert_blob, c2->cert_blob) &&
159 blobcmp(c1->ca_info_blob, c2->ca_info_blob) &&
160 blobcmp(c1->issuercert_blob, c2->issuercert_blob) &&
161 blobcmp(c1->key_blob, c2->key_blob) &&
162 Curl_safecmp(c1->CApath, c2->CApath) &&
163 Curl_safecmp(c1->CAfile, c2->CAfile) &&
164 Curl_safecmp(c1->issuercert, c2->issuercert) &&
165 Curl_safecmp(c1->clientcert, c2->clientcert) &&
166 curl_strequal(c1->cipher_list, c2->cipher_list) &&
167 curl_strequal(c1->cipher_list13, c2->cipher_list13) &&
168 curl_strequal(c1->curves, c2->curves) &&
169 curl_strequal(c1->signature_algorithms, c2->signature_algorithms) &&
170 Curl_safecmp(c1->CRLfile, c2->CRLfile) &&
171 Curl_safecmp(c1->pinned_key, c2->pinned_key) &&
172 curl_strequal(c1->cert_type, c2->cert_type) &&
173 Curl_safecmp(c1->key, c2->key) &&
174 curl_strequal(c1->key_type, c2->key_type) &&
175 !Curl_timestrcmp(c1->key_passwd, c2->key_passwd))
176 return TRUE;
178 return FALSE;
179}
181bool Curl_ssl_conn_config_match(struct Curl_easy *data,
182 struct ssl_filter_config *conn_config,
183 struct connectdata *candidate,
184 bool proxy)
185{
186#ifndef CURL_DISABLE_PROXY
187 if(proxy)
188 return match_ssl_primary_config(data, conn_config,
189 &candidate->proxy_ssl_config);
190#else
191 (void)proxy;
192#endif
193 return match_ssl_primary_config(data, conn_config,
194 &candidate->ssl_config);
195}
197static bool clone_ssl_primary_config(struct ssl_filter_config *source,
198 struct ssl_filter_config *dest)
199{
200 DEBUGASSERT(!dest->deep_copy);
201 dest->deep_copy = TRUE;
202 dest->version = source->version;
203 dest->version_max = source->version_max;
204 dest->verifypeer = source->verifypeer;
205 dest->verifyhost = source->verifyhost;
206 dest->verifystatus = source->verifystatus;
207 dest->ssl_options = source->ssl_options;
208 dest->native_ca_store = source->native_ca_store;
209 dest->cache_session = source->cache_session;
210 dest->auto_client_cert = source->auto_client_cert;
211 dest->earlydata = source->earlydata;
212 dest->enable_beast = source->enable_beast;
213 dest->no_partialchain = source->no_partialchain;
214 dest->no_revoke = source->no_revoke;
215 dest->revoke_best_effort = source->revoke_best_effort;
217 CLONE_BLOB(cert_blob);
218 CLONE_BLOB(ca_info_blob);
219 CLONE_BLOB(issuercert_blob);
220 CLONE_STRING(CApath);
221 CLONE_STRING(CAfile);
222 CLONE_STRING(issuercert);
223 CLONE_STRING(cipher_list);
224 CLONE_STRING(cipher_list13);
225 CLONE_STRING(pinned_key);
226 CLONE_STRING(curves);
227 CLONE_STRING(signature_algorithms);
228 CLONE_STRING(CRLfile);
229 /* SSL credentials: client certificate */
230 CLONE_STRING(clientcert);
231 CLONE_STRING(cert_type);
232 CLONE_STRING(key);
233 CLONE_STRING(key_type);
234 CLONE_STRING(key_passwd);
235 CLONE_BLOB(key_blob);
236#ifdef USE_ECH
237 dest->ech = source->ech;
238 CLONE_STRING(ech_config);
239 CLONE_STRING(ech_public);
240#endif
241 return TRUE;
242}
244static void
245ssl_easy_config_compl_options(struct Curl_peer *origin,
246 struct Curl_peer *initial_origin,
247 struct ssl_easy_config *sslc,
248 struct ssl_filter_config *primary)
249{
250 uint8_t options = sslc->ssl_options;
251 /* If set via CURLOPT_(PROXY_)SSL_OPTIONS, we definitely use it.
252 * If not, we switch it on for supported backends if no custom
253 * CA settings exist. */
254 primary->native_ca_store = !!(options & CURLSSLOPT_NATIVE_CA);
255 primary->earlydata = !!(options & CURLSSLOPT_EARLYDATA);
256 primary->auto_client_cert =
257 Curl_peer_equal(origin, initial_origin) &&
258 !!(options & CURLSSLOPT_AUTO_CLIENT_CERT);
259 primary->enable_beast = !!(options & CURLSSLOPT_ALLOW_BEAST);
260 primary->no_partialchain = !!(options & CURLSSLOPT_NO_PARTIALCHAIN);
261 primary->no_revoke = !!(options & CURLSSLOPT_NO_REVOKE);
262 primary->revoke_best_effort = !!(options & CURLSSLOPT_REVOKE_BEST_EFFORT);
263}
265static char *ssl_easy_steal(struct Curl_easy *data, enum dupstring id)
266{
267 /* For connection matching, we borrow string references from data
268 * THIS IS NOT REALLY NICE. */
269 return CURL_UNCONST(CURL_EASY_STR(data, id));
270}
272CURLcode Curl_ssl_filter_config_tmp_init(
273 struct Curl_easy *data, struct Curl_peer *origin,
274 struct ssl_filter_config *ssl_origin,
275 struct ssl_filter_config *ssl_proxy)
276{
277 struct ssl_easy_config *sslc = &data->set.ssl;
278#if defined(CURL_CA_PATH) || defined(CURL_CA_BUNDLE)
279 CURLcode result;
280#endif
282 ssl_easy_config_compl_options(origin, data->state.initial_origin, sslc,
283 ssl_origin);
285 if(Curl_ssl_backend() != CURLSSLBACKEND_SCHANNEL) {
286#if defined(USE_APPLE_SECTRUST) || defined(CURL_CA_NATIVE)
287 if(!sslc->custom_capath && !sslc->custom_cafile && !sslc->custom_cablob)
288 ssl_origin->native_ca_store = TRUE;
289#endif
290#ifdef CURL_CA_PATH
291 if(!sslc->custom_capath && !CURL_EASY_STR(data, STRING_SSL_CAPATH)) {
292 result = Curl_setstropt(data, STRING_SSL_CAPATH, CURL_CA_PATH);
293 if(result)
294 return result;
295 }
296#endif
297#ifdef CURL_CA_BUNDLE
298 if(!sslc->custom_cafile && !CURL_EASY_STR(data, STRING_SSL_CAFILE)) {
299 result = Curl_setstropt(data, STRING_SSL_CAFILE, CURL_CA_BUNDLE);
300 if(result)
301 return result;
302 }
303#endif
304 }
306 ssl_origin->version = sslc->version;
307 ssl_origin->version_max = sslc->version_max;
308 ssl_origin->verifypeer = sslc->verifypeer;
309 ssl_origin->verifyhost = sslc->verifyhost;
310 ssl_origin->verifystatus = sslc->verifystatus;
311 ssl_origin->cache_session = sslc->cache_session;
312 ssl_origin->ssl_options = sslc->ssl_options;
313 ssl_origin->CAfile = ssl_easy_steal(data, STRING_SSL_CAFILE);
314 ssl_origin->CRLfile = ssl_easy_steal(data, STRING_SSL_CRLFILE);
315 ssl_origin->CApath = ssl_easy_steal(data, STRING_SSL_CAPATH);
316 ssl_origin->cipher_list = ssl_easy_steal(data, STRING_SSL_CIPHER_LIST);
317 ssl_origin->cipher_list13 = ssl_easy_steal(data, STRING_SSL_CIPHER13_LIST);
318 ssl_origin->signature_algorithms =
319 ssl_easy_steal(data, STRING_SSL_SIGNATURE_ALGORITHMS);
320 ssl_origin->ca_info_blob = data->set.blobs[BLOB_CAINFO];
321 ssl_origin->curves = ssl_easy_steal(data, STRING_SSL_EC_CURVES);
322 /* Maybe these should not be used for another origin. But for
323 * backwards compatibility, keep them in. */
324 ssl_origin->issuercert = ssl_easy_steal(data, STRING_SSL_ISSUERCERT);
325 ssl_origin->issuercert_blob = data->set.blobs[BLOB_SSL_ISSUERCERT];
327 if(Curl_peer_equal(data->state.initial_origin, origin)) {
328 ssl_origin->pinned_key =
329 ssl_easy_steal(data, STRING_SSL_PINNEDPUBLICKEY);
330 ssl_origin->cert_blob = data->set.blobs[BLOB_CERT];
331 ssl_origin->cert_type = ssl_easy_steal(data, STRING_CERT_TYPE);
332 ssl_origin->key = ssl_easy_steal(data, STRING_KEY);
333 ssl_origin->key_type = ssl_easy_steal(data, STRING_KEY_TYPE);
334 ssl_origin->key_passwd = ssl_easy_steal(data, STRING_KEY_PASSWD);
335 ssl_origin->clientcert = ssl_easy_steal(data, STRING_CERT);
336 ssl_origin->key_blob = data->set.blobs[BLOB_KEY];
337#ifdef USE_ECH
338 ssl_origin->ech = data->set.ssl.ech;
339 ssl_origin->ech_config = ssl_easy_steal(data, STRING_ECH_CONFIG);
340 ssl_origin->ech_public = ssl_easy_steal(data, STRING_ECH_PUBLIC);
341#endif
342 }
343 else {
344 ssl_origin->pinned_key = NULL;
345 ssl_origin->cert_blob = NULL;
346 ssl_origin->cert_type = NULL;
347 ssl_origin->key = NULL;
348 ssl_origin->key_type = NULL;
349 ssl_origin->key_passwd = NULL;
350 ssl_origin->clientcert = NULL;
351 ssl_origin->key_blob = NULL;
352#ifdef USE_ECH
353 ssl_origin->ech = 0;
354 ssl_origin->ech_config = NULL;
355 ssl_origin->ech_public = NULL;
356#endif
357 }
359#ifndef CURL_DISABLE_PROXY
360 sslc = &data->set.proxy_ssl;
362 ssl_easy_config_compl_options(NULL, NULL, sslc, ssl_proxy);
363 if((Curl_ssl_backend() != CURLSSLBACKEND_SCHANNEL)) {
364 /* no initial origin for proxy, it is not changed for redirects */
365#if defined(USE_APPLE_SECTRUST) || defined(CURL_CA_NATIVE)
366 if(!sslc->custom_capath && !sslc->custom_cafile && !sslc->custom_cablob)
367 ssl_proxy->native_ca_store = TRUE;
368#endif
369#ifdef CURL_CA_PATH
370 if(!sslc->custom_capath &&
371 !CURL_EASY_STR(data, STRING_SSL_CAPATH_PROXY)) {
372 result = Curl_setstropt(data, STRING_SSL_CAPATH_PROXY, CURL_CA_PATH);
373 if(result)
374 return result;
375 }
376#endif
377#ifdef CURL_CA_BUNDLE
378 if(!sslc->custom_cafile &&
379 !CURL_EASY_STR(data, STRING_SSL_CAFILE_PROXY)) {
380 result = Curl_setstropt(data, STRING_SSL_CAFILE_PROXY, CURL_CA_BUNDLE);
381 if(result)
382 return result;
383 }
384#endif
385 }
387 ssl_proxy->version = sslc->version;
388 ssl_proxy->version_max = sslc->version_max;
389 ssl_proxy->verifypeer = sslc->verifypeer;
390 ssl_proxy->verifyhost = sslc->verifyhost;
391 ssl_proxy->verifystatus = sslc->verifystatus;
392 ssl_proxy->cache_session = sslc->cache_session;
393 ssl_proxy->ssl_options = sslc->ssl_options;
394 ssl_proxy->CAfile = ssl_easy_steal(data, STRING_SSL_CAFILE_PROXY);
395 ssl_proxy->CApath = ssl_easy_steal(data, STRING_SSL_CAPATH_PROXY);
396 ssl_proxy->cipher_list =
397 ssl_easy_steal(data, STRING_SSL_CIPHER_LIST_PROXY);
398 ssl_proxy->cipher_list13 =
399 ssl_easy_steal(data, STRING_SSL_CIPHER13_LIST_PROXY);
400 ssl_proxy->pinned_key =
401 ssl_easy_steal(data, STRING_SSL_PINNEDPUBLICKEY_PROXY);
402 ssl_proxy->cert_blob = data->set.blobs[BLOB_CERT_PROXY];
403 ssl_proxy->ca_info_blob = data->set.blobs[BLOB_CAINFO_PROXY];
404 ssl_proxy->issuercert = ssl_easy_steal(data, STRING_SSL_ISSUERCERT_PROXY);
405 ssl_proxy->issuercert_blob = data->set.blobs[BLOB_SSL_ISSUERCERT_PROXY];
406 ssl_proxy->CRLfile = ssl_easy_steal(data, STRING_SSL_CRLFILE_PROXY);
407 ssl_proxy->cert_type = ssl_easy_steal(data, STRING_CERT_TYPE_PROXY);
408 ssl_proxy->key = ssl_easy_steal(data, STRING_KEY_PROXY);
409 ssl_proxy->key_type = ssl_easy_steal(data, STRING_KEY_TYPE_PROXY);
410 ssl_proxy->key_passwd = ssl_easy_steal(data, STRING_KEY_PASSWD_PROXY);
411 ssl_proxy->clientcert = ssl_easy_steal(data, STRING_CERT_PROXY);
412 ssl_proxy->key_blob = data->set.blobs[BLOB_KEY_PROXY];
413#ifdef USE_ECH
414 /* Not configurable via a CURLOPT_* */
415 ssl_proxy->ech = 0;
416 ssl_proxy->ech_config = NULL;
417 ssl_proxy->ech_public = NULL;
418#endif
419#else
420 (void)ssl_proxy;
421#endif /* CURL_DISABLE_PROXY */
423 return CURLE_OK;
424}
426CURLcode Curl_ssl_conn_config_clone(struct ssl_filter_config *ssl_config,
427 struct ssl_filter_config *proxy_ssl_config,
428 struct connectdata *conn)
429{
430 /* Clone "primary" SSL configurations from the easy handle to
431 * the connection. They are used for connection cache matching and
432 * probably outlive the easy handle */
433 if(!clone_ssl_primary_config(ssl_config, &conn->ssl_config))
434 return CURLE_OUT_OF_MEMORY;
435#ifndef CURL_DISABLE_PROXY
436 if(proxy_ssl_config &&
437 !clone_ssl_primary_config(proxy_ssl_config, &conn->proxy_ssl_config))
438 return CURLE_OUT_OF_MEMORY;
439#else
440 (void)proxy_ssl_config;
441#endif
442 return CURLE_OK;
443}
445void Curl_ssl_conn_config_cleanup(struct connectdata *conn)
446{
447 Curl_ssl_config_cleanup(&conn->ssl_config);
448#ifndef CURL_DISABLE_PROXY
449 Curl_ssl_config_cleanup(&conn->proxy_ssl_config);
450#endif
451}
453void Curl_ssl_conn_config_update(struct Curl_easy *data, bool for_proxy)
454{
455 /* May be called on an easy that has no connection yet */
456 if(data->conn) {
457 struct ssl_easy_config *src;
458 struct ssl_filter_config *dest;
459#ifndef CURL_DISABLE_PROXY
460 src = for_proxy ? &data->set.proxy_ssl : &data->set.ssl;
461 dest = for_proxy ? &data->conn->proxy_ssl_config : &data->conn->ssl_config;
462#else
463 (void)for_proxy;
464 src = &data->set.ssl;
465 dest = &data->conn->ssl_config;
466#endif
467 dest->verifyhost = src->verifyhost;
468 dest->verifypeer = src->verifypeer;
469 dest->verifystatus = src->verifystatus;
470#ifdef USE_ECH
471 dest->ech = src->ech;
472#endif
473 }
474}
Diagnostics4 git calls · 26 ms
CallStatusSizeTime026 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=21 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=86Open pack map
fetch2004.6 KiB · hit21 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=4726 git.response.cache=HIT git.response.duration_ms=21 git.fetch.wants=aae321227d0f8e14ddceb67947d92538f0da7b79 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=4726 git.pkt.payload.max=4705 git.sideband.band1.bytes=4704 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
- a5e375c32c83a140
- Request
- d9e6823e…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format