Artifactspublic-v0

curl

master
ply4 git calls25 ms291 KiB3 cachedprotocol v2
536 lines18 KiBRaw
1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9 * Copyright (C) Markus Moeller, <markus_moeller@compuserve.com>
10 *
11 * This software is licensed as described in the file COPYING, which
12 * you should have received as part of this distribution. The terms
13 * are also available at https://curl.se/docs/copyright.html.
14 *
15 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
16 * copies of the Software, and permit persons to whom the Software is
17 * furnished to do so, under the terms of the COPYING file.
18 *
19 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20 * KIND, either express or implied.
21 *
22 * SPDX-License-Identifier: curl
23 *
24 ***************************************************************************/
25#include "curl_setup.h"
27#if defined(USE_WINDOWS_SSPI) && !defined(CURL_DISABLE_PROXY)
29#include "urldata.h"
30#include "curl_trc.h"
31#include "cfilters.h"
32#include "connect.h"
33#include "strerror.h"
34#include "curlx/nonblock.h"
35#include "socks.h"
36#include "curl_sspi.h"
37#include "curlx/multibyte.h"
39/*
40 * Helper SSPI error functions.
41 */
42static int check_sspi_err(struct Curl_easy *data,
43 SECURITY_STATUS status,
44 const char *function)
46 if(status != SEC_E_OK &&
47 status != SEC_I_COMPLETE_AND_CONTINUE &&
48 status != SEC_I_COMPLETE_NEEDED &&
49 status != SEC_I_CONTINUE_NEEDED) {
50 char buffer[STRERROR_LEN];
51 failf(data, "SSPI error: %s failed: %s", function,
52 Curl_sspi_strerror(status, buffer, sizeof(buffer)));
53 return 1;
54 }
55 return 0;
58/* This is the SSPI-using version of this function */
59static CURLcode socks5_sspi_setup(struct Curl_cfilter *cf,
60 struct Curl_easy *data,
61 struct Curl_creds *creds,
62 CredHandle *cred_handle,
63 char **service_namep)
65 struct connectdata *conn = cf->conn;
66 const char *service = Curl_creds_has_sasl_service(creds) ?
67 Curl_creds_sasl_service(creds) : "rcmd";
68 SECURITY_STATUS status;
70 /* prepare service name */
71 if(strchr(service, '/'))
72 *service_namep = curlx_strdup(service);
73 else
74 *service_namep = curl_maprintf("%s/%s",
75 service, conn->socks_proxy.peer->hostname);
76 if(!*service_namep)
77 return CURLE_OUT_OF_MEMORY;
79 status =
80 Curl_pSecFn->AcquireCredentialsHandle(NULL, CURL_UNCONST(TEXT("Kerberos")),
81 SECPKG_CRED_OUTBOUND,
82 NULL, NULL, NULL, NULL,
83 cred_handle, NULL);
85 if(check_sspi_err(data, status, "AcquireCredentialsHandle")) {
86 failf(data, "Failed to acquire credentials.");
87 return CURLE_COULDNT_CONNECT;
88 }
90 return CURLE_OK;
93static CURLcode socks5_free_token(SecBuffer *send_token,
94 CURLcode result)
96 if(send_token->pvBuffer) {
97 Curl_pSecFn->FreeContextBuffer(send_token->pvBuffer);
98 send_token->pvBuffer = NULL;
99 }
100 return result;
103static CURLcode socks5_sspi_loop(struct Curl_cfilter *cf,
104 struct Curl_easy *data,
105 CredHandle *cred_handle,
106 CtxtHandle *sspi_context,
107 char *service_name,
108 unsigned long *sspi_ret_flagsp)
110 struct connectdata *conn = cf->conn;
111 curl_socket_t sock = conn->sock[cf->sockindex];
112 CURLcode result = CURLE_OK;
113 CURLcode code;
114 SECURITY_STATUS status;
115 SecBuffer sspi_send_token, sspi_recv_token;
116 SecBufferDesc input_desc, output_desc;
117 PCtxtHandle context_handle = NULL;
118 unsigned short us_length;
119 size_t actualread;
120 size_t written;
121 unsigned char socksreq[4];
123 input_desc.cBuffers = 1;
124 input_desc.pBuffers = &sspi_recv_token;
125 input_desc.ulVersion = SECBUFFER_VERSION;
127 sspi_recv_token.BufferType = SECBUFFER_TOKEN;
128 sspi_recv_token.cbBuffer = 0;
129 sspi_recv_token.pvBuffer = NULL;
131 output_desc.cBuffers = 1;
132 output_desc.pBuffers = &sspi_send_token;
133 output_desc.ulVersion = SECBUFFER_VERSION;
135 sspi_send_token.BufferType = SECBUFFER_TOKEN;
136 sspi_send_token.cbBuffer = 0;
137 sspi_send_token.pvBuffer = NULL;
139 (void)curlx_nonblock(sock, FALSE);
141 for(;;) {
142 TCHAR *sname = curlx_convert_UTF8_to_tchar(service_name);
143 if(!sname) {
144 curlx_free(sspi_recv_token.pvBuffer);
145 return socks5_free_token(&sspi_send_token, CURLE_OUT_OF_MEMORY);
146 }
148 status =
149 Curl_pSecFn->InitializeSecurityContext(cred_handle, context_handle,
150 sname,
151 ISC_REQ_MUTUAL_AUTH |
152 ISC_REQ_ALLOCATE_MEMORY |
153 ISC_REQ_CONFIDENTIALITY |
154 ISC_REQ_REPLAY_DETECT,
155 0, SECURITY_NATIVE_DREP,
156 &input_desc, 0,
157 sspi_context,
158 &output_desc,
159 sspi_ret_flagsp, NULL);
161 curlx_free(sname);
162 curlx_safefree(sspi_recv_token.pvBuffer);
163 sspi_recv_token.cbBuffer = 0;
165 if(check_sspi_err(data, status, "InitializeSecurityContext")) {
166 failf(data, "Failed to initialize security context.");
167 return socks5_free_token(&sspi_send_token, CURLE_COULDNT_CONNECT);
168 }
170 if(sspi_send_token.cbBuffer) {
171 socksreq[0] = 1; /* GSS-API subnegotiation version */
172 socksreq[1] = 1; /* authentication message type */
173 if(sspi_send_token.cbBuffer > 0xffff) {
174 /* needs to fit in an unsigned 16-bit field */
175 return socks5_free_token(&sspi_send_token, CURLE_COULDNT_CONNECT);
176 }
177 us_length = htons((unsigned short)sspi_send_token.cbBuffer);
178 memcpy(socksreq + 2, &us_length, sizeof(short));
180 code = Curl_conn_cf_send(cf->next, data, socksreq, 4, FALSE, &written);
181 if(code || (written != 4)) {
182 failf(data, "Failed to send SSPI authentication request.");
183 return socks5_free_token(&sspi_send_token, CURLE_COULDNT_CONNECT);
184 }
186 code = Curl_conn_cf_send(cf->next, data,
187 sspi_send_token.pvBuffer,
188 sspi_send_token.cbBuffer, FALSE, &written);
189 if(code || (sspi_send_token.cbBuffer != written)) {
190 failf(data, "Failed to send SSPI authentication token.");
191 return socks5_free_token(&sspi_send_token, CURLE_COULDNT_CONNECT);
192 }
193 }
195 if(sspi_send_token.pvBuffer)
196 socks5_free_token(&sspi_send_token, CURLE_OK);
197 sspi_send_token.cbBuffer = 0;
199 curlx_safefree(sspi_recv_token.pvBuffer);
200 sspi_recv_token.cbBuffer = 0;
202 if(status != SEC_I_CONTINUE_NEEDED)
203 break;
205 result = Curl_blockread_all(cf, data, (char *)socksreq, 4, &actualread);
206 if(result || (actualread != 4)) {
207 failf(data, "Failed to receive SSPI authentication response.");
208 return result ? result : CURLE_COULDNT_CONNECT;
209 }
211 if(socksreq[1] == 255) {
212 failf(data, "User was rejected by the SOCKS5 server (%u %u).",
213 (unsigned int)socksreq[0], (unsigned int)socksreq[1]);
214 return CURLE_COULDNT_CONNECT;
215 }
217 if(socksreq[1] != 1) {
218 failf(data, "Invalid SSPI authentication response type (%u %u).",
219 (unsigned int)socksreq[0], (unsigned int)socksreq[1]);
220 return CURLE_COULDNT_CONNECT;
221 }
223 memcpy(&us_length, socksreq + 2, sizeof(short));
224 us_length = ntohs(us_length);
226 if(!us_length) {
227 failf(data, "Invalid zero-length SSPI authentication token.");
228 return CURLE_COULDNT_CONNECT;
229 }
231 sspi_recv_token.cbBuffer = us_length;
232 sspi_recv_token.pvBuffer = curlx_malloc(us_length);
234 if(!sspi_recv_token.pvBuffer)
235 return CURLE_OUT_OF_MEMORY;
237 result = Curl_blockread_all(cf, data, (char *)sspi_recv_token.pvBuffer,
238 sspi_recv_token.cbBuffer, &actualread);
240 if(result || (actualread != us_length)) {
241 failf(data, "Failed to receive SSPI authentication token.");
242 curlx_free(sspi_recv_token.pvBuffer);
243 return result ? result : CURLE_COULDNT_CONNECT;
244 }
246 context_handle = sspi_context;
247 }
249 return CURLE_OK;
252static CURLcode socks5_free(SecBuffer *sspi_w_token,
253 CURLcode result)
255 curlx_safefree(sspi_w_token[0].pvBuffer);
256 curlx_safefree(sspi_w_token[1].pvBuffer);
257 curlx_safefree(sspi_w_token[2].pvBuffer);
258 return result;
261static CURLcode socks5_sspi_encrypt(struct Curl_cfilter *cf,
262 struct Curl_easy *data,
263 CtxtHandle *sspi_context,
264 unsigned long sspi_ret_flags)
266 CURLcode result = CURLE_OK;
267 CURLcode code;
268 SECURITY_STATUS status;
269 unsigned char gss_enc;
270 SecBuffer sspi_w_token[3];
271 SecBufferDesc wrap_desc;
272 SecPkgContext_Sizes sspi_sizes;
273 unsigned short us_length;
274 unsigned long qop;
275 unsigned char socksreq[4];
276 uint8_t *etbuf = NULL;
277 size_t etbuf_size = 0;
278 size_t actualread;
279 size_t written;
281 gss_enc = 0;
282 if(sspi_ret_flags & ISC_REQ_CONFIDENTIALITY)
283 gss_enc = 2;
284 else if(sspi_ret_flags & ISC_REQ_INTEGRITY)
285 gss_enc = 1;
287 infof(data, "SOCKS5 server supports GSS-API %s data protection.",
288 (gss_enc == 0) ? "no" :
289 ((gss_enc == 1) ? "integrity" : "confidentiality"));
291 sspi_w_token[0].pvBuffer =
292 sspi_w_token[1].pvBuffer =
293 sspi_w_token[2].pvBuffer = NULL;
295 wrap_desc.cBuffers = 3;
296 wrap_desc.pBuffers = sspi_w_token;
297 wrap_desc.ulVersion = SECBUFFER_VERSION;
299 socksreq[0] = 1;
300 socksreq[1] = 2;
302 if(data->set.socks5_gssapi_nec) {
303 us_length = htons((unsigned short)1);
304 memcpy(socksreq + 2, &us_length, sizeof(short));
305 }
306 else {
307 status = Curl_pSecFn->QueryContextAttributes(sspi_context,
308 SECPKG_ATTR_SIZES,
309 &sspi_sizes);
310 if(check_sspi_err(data, status, "QueryContextAttributes")) {
311 failf(data, "Failed to query security context attributes.");
312 return CURLE_COULDNT_CONNECT;
313 }
315 sspi_w_token[0].cbBuffer = sspi_sizes.cbSecurityTrailer;
316 sspi_w_token[0].BufferType = SECBUFFER_TOKEN;
317 sspi_w_token[0].pvBuffer = curlx_malloc(sspi_sizes.cbSecurityTrailer);
319 if(!sspi_w_token[0].pvBuffer)
320 return CURLE_OUT_OF_MEMORY;
322 sspi_w_token[1].cbBuffer = 1;
323 sspi_w_token[1].BufferType = SECBUFFER_DATA;
324 sspi_w_token[1].pvBuffer = curlx_malloc(1);
325 if(!sspi_w_token[1].pvBuffer)
326 return socks5_free(sspi_w_token, CURLE_OUT_OF_MEMORY);
328 memcpy(sspi_w_token[1].pvBuffer, &gss_enc, 1);
329 sspi_w_token[2].BufferType = SECBUFFER_PADDING;
330 sspi_w_token[2].cbBuffer = sspi_sizes.cbBlockSize;
331 sspi_w_token[2].pvBuffer = curlx_malloc(sspi_sizes.cbBlockSize);
332 if(!sspi_w_token[2].pvBuffer)
333 return socks5_free(sspi_w_token, CURLE_OUT_OF_MEMORY);
335 status = Curl_pSecFn->EncryptMessage(sspi_context,
336 KERB_WRAP_NO_ENCRYPT,
337 &wrap_desc, 0);
338 if(check_sspi_err(data, status, "EncryptMessage"))
339 return socks5_free(sspi_w_token, CURLE_COULDNT_CONNECT);
341 etbuf_size = sspi_w_token[0].cbBuffer + sspi_w_token[1].cbBuffer +
342 sspi_w_token[2].cbBuffer;
343 if(etbuf_size > 0xffff)
344 return socks5_free(sspi_w_token, CURLE_COULDNT_CONNECT);
346 etbuf = curlx_malloc(etbuf_size);
347 if(!etbuf)
348 return socks5_free(sspi_w_token, CURLE_OUT_OF_MEMORY);
350 memcpy(etbuf, sspi_w_token[0].pvBuffer, sspi_w_token[0].cbBuffer);
351 memcpy(etbuf + sspi_w_token[0].cbBuffer,
352 sspi_w_token[1].pvBuffer, sspi_w_token[1].cbBuffer);
353 memcpy(etbuf + sspi_w_token[0].cbBuffer + sspi_w_token[1].cbBuffer,
354 sspi_w_token[2].pvBuffer, sspi_w_token[2].cbBuffer);
356 (void)socks5_free(sspi_w_token, CURLE_OK);
358 us_length = htons((unsigned short)etbuf_size);
359 memcpy(socksreq + 2, &us_length, sizeof(short));
360 }
362 code = Curl_conn_cf_send(cf->next, data, socksreq, 4, FALSE, &written);
363 if(code || (written != 4)) {
364 failf(data, "Failed to send SSPI encryption request.");
365 curlx_free(etbuf);
366 return CURLE_COULDNT_CONNECT;
367 }
369 if(data->set.socks5_gssapi_nec) {
370 memcpy(socksreq, &gss_enc, 1);
371 code = Curl_conn_cf_send(cf->next, data, socksreq, 1, FALSE, &written);
372 if(code || (written != 1)) {
373 failf(data, "Failed to send SSPI encryption type.");
374 return CURLE_COULDNT_CONNECT;
375 }
376 }
377 else {
378 code = Curl_conn_cf_send(cf->next, data, etbuf, etbuf_size, FALSE,
379 &written);
380 curlx_free(etbuf);
381 if(code || (etbuf_size != written)) {
382 failf(data, "Failed to send SSPI encryption type.");
383 return CURLE_COULDNT_CONNECT;
384 }
385 }
387 result = Curl_blockread_all(cf, data, (char *)socksreq, 4, &actualread);
388 if(result || (actualread != 4)) {
389 failf(data, "Failed to receive SSPI encryption response.");
390 return result ? result : CURLE_COULDNT_CONNECT;
391 }
393 if(socksreq[1] == 255) {
394 failf(data, "User was rejected by the SOCKS5 server (%u %u).",
395 (unsigned int)socksreq[0], (unsigned int)socksreq[1]);
396 return CURLE_COULDNT_CONNECT;
397 }
399 if(socksreq[1] != 2) {
400 failf(data, "Invalid SSPI encryption response type (%u %u).",
401 (unsigned int)socksreq[0], (unsigned int)socksreq[1]);
402 return CURLE_COULDNT_CONNECT;
403 }
405 memcpy(&us_length, socksreq + 2, sizeof(short));
406 us_length = ntohs(us_length);
408 if(!us_length) {
409 failf(data, "Invalid zero-length SSPI encryption token.");
410 return CURLE_COULDNT_CONNECT;
411 }
413 sspi_w_token[0].cbBuffer = us_length;
414 sspi_w_token[0].pvBuffer = curlx_malloc(us_length);
415 if(!sspi_w_token[0].pvBuffer)
416 return CURLE_OUT_OF_MEMORY;
418 result = Curl_blockread_all(cf, data, (char *)sspi_w_token[0].pvBuffer,
419 sspi_w_token[0].cbBuffer, &actualread);
421 if(result || (actualread != us_length)) {
422 failf(data, "Failed to receive SSPI encryption type.");
423 goto fail;
424 }
426 if(!data->set.socks5_gssapi_nec) {
427 wrap_desc.cBuffers = 2;
428 sspi_w_token[0].BufferType = SECBUFFER_STREAM;
429 sspi_w_token[1].BufferType = SECBUFFER_DATA;
430 sspi_w_token[1].cbBuffer = 0;
431 sspi_w_token[1].pvBuffer = NULL;
433 /* At least one of the descriptors must be of type SECBUFFER_DATA. The
434 message is decrypted in place so the SECBUFFER_DATA receives a pointer
435 to the message in SECBUFFER_STREAM. */
436 status = Curl_pSecFn->DecryptMessage(sspi_context, &wrap_desc, 0, &qop);
438 if(check_sspi_err(data, status, "DecryptMessage"))
439 goto fail;
441 if(sspi_w_token[1].cbBuffer != 1) {
442 failf(data, "Invalid SSPI encryption response length (%lu).",
443 (unsigned long)sspi_w_token[1].cbBuffer);
444 goto fail;
445 }
447 memcpy(socksreq, sspi_w_token[1].pvBuffer, sspi_w_token[1].cbBuffer);
448 }
449 else {
450 if(sspi_w_token[0].cbBuffer != 1) {
451 failf(data, "Invalid SSPI encryption response length (%lu).",
452 (unsigned long)sspi_w_token[0].cbBuffer);
453 goto fail;
454 }
455 memcpy(socksreq, sspi_w_token[0].pvBuffer, sspi_w_token[0].cbBuffer);
456 }
457 curlx_free(sspi_w_token[0].pvBuffer);
459 infof(data, "SOCKS5 access %s protection granted BUT NOT USED.",
460 (socksreq[0] == 0) ? "without GSS-API data" :
461 ((socksreq[0] == 1) ? "with GSS-API integrity" :
462 "with GSS-API confidentiality"));
464 cf->conn->socks5_gssapi_enctype = socksreq[0];
465 return CURLE_OK;
467fail:
468 curlx_free(sspi_w_token[0].pvBuffer);
469 return CURLE_COULDNT_CONNECT;
472CURLcode Curl_SOCKS5_gssapi_negotiate(struct Curl_cfilter *cf,
473 struct Curl_easy *data,
474 struct Curl_creds *creds)
476 struct connectdata *conn = cf->conn;
477 curl_socket_t sock = conn->sock[cf->sockindex];
478 CURLcode result;
479 SECURITY_STATUS status;
480 CredHandle cred_handle;
481 CtxtHandle sspi_context;
482 SecPkgCredentials_Names names;
483 char *service_name = NULL;
484 unsigned long sspi_ret_flags = 0;
486 memset(&cred_handle, 0, sizeof(cred_handle));
487 memset(&sspi_context, 0, sizeof(sspi_context));
488 names.sUserName = NULL;
490 result = socks5_sspi_setup(cf, data, creds, &cred_handle, &service_name);
491 if(result)
492 goto error;
494 result = socks5_sspi_loop(cf, data, &cred_handle, &sspi_context,
495 service_name, &sspi_ret_flags);
496 if(result)
497 goto error;
499 curlx_safefree(service_name);
501 status = Curl_pSecFn->QueryCredentialsAttributes(&cred_handle,
502 SECPKG_CRED_ATTR_NAMES,
503 &names);
504 if(check_sspi_err(data, status, "QueryCredentialAttributes")) {
505 failf(data, "Failed to determine username.");
506 result = CURLE_COULDNT_CONNECT;
507 goto error;
508 }
509 else {
510 VERBOSE(char *user_utf8 = curlx_convert_tchar_to_UTF8(names.sUserName));
511 infof(data, "SOCKS5 server authenticated user %s with GSS-API.",
512 (user_utf8 ? user_utf8 : "(unknown)"));
513 VERBOSE(curlx_free(user_utf8));
514 Curl_pSecFn->FreeContextBuffer(names.sUserName);
515 names.sUserName = NULL;
516 }
518 result = socks5_sspi_encrypt(cf, data, &sspi_context, sspi_ret_flags);
519 if(result)
520 goto error;
522 (void)curlx_nonblock(sock, TRUE);
523 Curl_pSecFn->DeleteSecurityContext(&sspi_context);
524 Curl_pSecFn->FreeCredentialsHandle(&cred_handle);
525 return CURLE_OK;
527error:
528 (void)curlx_nonblock(sock, TRUE);
529 curlx_free(service_name);
530 Curl_pSecFn->DeleteSecurityContext(&sspi_context);
531 Curl_pSecFn->FreeCredentialsHandle(&cred_handle);
532 if(names.sUserName)
533 Curl_pSecFn->FreeContextBuffer(names.sUserName);
534 return result;
536#endif
Diagnostics4 git calls · 25 ms
CallStatusSizeTime025 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 · hit2 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
git.response.bytes=149
git.response.cache=HIT
git.response.duration_ms=2
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=20
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
fetch2004.5 KiB · hit20 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=4592
git.response.cache=HIT
git.response.duration_ms=20
git.fetch.wants=576d6aef5bbc36e72f93f9ecc1a57487a008fc95
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=4592
git.pkt.payload.max=4571
git.sideband.band1.bytes=4570
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
a5e2d6817ce3689d
Request
05abfeca…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format