Artifactspublic-v0

curl

master
ply4 git calls26 ms292 KiB3 cachedprotocol v2
635 lines20 KiBRaw
1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) Steve Holme, <steve_holme@hotmail.com>.
9 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
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 * RFC2831 DIGEST-MD5 authentication
25 *
26 ***************************************************************************/
27#include "curl_setup.h"
29#if defined(USE_WINDOWS_SSPI) && !defined(CURL_DISABLE_DIGEST_AUTH)
31#include "creds.h"
32#include "vauth/vauth.h"
33#include "vauth/digest.h"
34#include "curlx/multibyte.h"
35#include "curl_trc.h"
36#include "curlx/strdup.h"
37#include "curlx/strparse.h"
38#include "strcase.h"
39#include "strerror.h"
41/*
42 * Curl_auth_is_digest_supported()
43 *
44 * This is used to evaluate if DIGEST is supported.
45 *
46 * Parameters: None
47 *
48 * Returns TRUE if DIGEST is supported by Windows SSPI.
49 */
50bool Curl_auth_is_digest_supported(void)
52 PSecPkgInfo SecurityPackage;
53 SECURITY_STATUS status;
55 /* Query the security package for Digest */
56 status =
57 Curl_pSecFn->QuerySecurityPackageInfo(
58 CURL_UNCONST(TEXT(SP_NAME_DIGEST)),
59 &SecurityPackage);
61 /* Release the package buffer as it is not required anymore */
62 if(status == SEC_E_OK) {
63 Curl_pSecFn->FreeContextBuffer(SecurityPackage);
64 }
66 return status == SEC_E_OK;
69/*
70 * Curl_auth_create_digest_md5_message()
71 *
72 * This is used to generate an already encoded DIGEST-MD5 response message
73 * ready for sending to the recipient.
74 *
75 * Parameters:
76 *
77 * data [in] - The session handle.
78 * chlg [in] - The challenge message.
79 * userp [in] - The username in the format User or Domain\User.
80 * passwdp [in] - The user's password.
81 * service [in] - The service type such as http, smtp, pop or imap.
82 * out [out] - The result storage.
83 *
84 * Returns CURLE_OK on success.
85 */
86CURLcode Curl_auth_create_digest_md5_message(struct Curl_easy *data,
87 const struct bufref *chlg,
88 struct Curl_creds *creds,
89 const char *default_service,
90 struct bufref *out)
92 CURLcode result = CURLE_OK;
93 TCHAR *spn = NULL;
94 size_t token_max = 0;
95 unsigned char *output_token = NULL;
96 CredHandle credentials;
97 CtxtHandle context;
98 PSecPkgInfo SecurityPackage;
99 SEC_WINNT_AUTH_IDENTITY_EX identity;
100 SEC_WINNT_AUTH_IDENTITY_EX *p_identity;
101 SecBuffer chlg_buf;
102 SecBuffer resp_buf;
103 SecBufferDesc chlg_desc;
104 SecBufferDesc resp_desc;
105 SECURITY_STATUS status;
106 unsigned long attrs;
107 const char *service = Curl_creds_has_sasl_service(creds) ?
108 Curl_creds_sasl_service(creds) : default_service;
110 /* Ensure we have a valid challenge message */
111 if(!Curl_bufref_len(chlg)) {
112 infof(data, "DIGEST-MD5 handshake failure (empty challenge message)");
113 return CURLE_BAD_CONTENT_ENCODING;
114 }
116 /* Query the security package for DigestSSP */
117 status =
118 Curl_pSecFn->QuerySecurityPackageInfo(
119 CURL_UNCONST(TEXT(SP_NAME_DIGEST)),
120 &SecurityPackage);
121 if(status != SEC_E_OK) {
122 failf(data, "SSPI: could not get auth info");
123 return CURLE_AUTH_ERROR;
124 }
126 token_max = SecurityPackage->cbMaxToken;
128 /* Release the package buffer as it is not required anymore */
129 Curl_pSecFn->FreeContextBuffer(SecurityPackage);
131 /* Allocate our response buffer */
132 output_token = curlx_malloc(token_max);
133 if(!output_token)
134 return CURLE_OUT_OF_MEMORY;
136 /* Generate our SPN */
137 spn = Curl_auth_build_spn(service, data->state.origin->hostname, NULL);
138 if(!spn) {
139 curlx_free(output_token);
140 return CURLE_OUT_OF_MEMORY;
141 }
143 if(Curl_creds_has_user(creds)) {
144 /* Populate our identity structure */
145 result = Curl_create_sspi_identity(creds->user, creds->passwd,
146 &identity);
147 if(result) {
148 curlx_free(spn);
149 curlx_free(output_token);
150 return result;
151 }
153 /* Allow proper cleanup of the identity structure */
154 p_identity = &identity;
155 }
156 else
157 /* Use the current Windows user */
158 p_identity = NULL;
160 /* Acquire our credentials handle */
161 status = Curl_pSecFn->AcquireCredentialsHandle(NULL,
162 CURL_UNCONST(TEXT(SP_NAME_DIGEST)),
163 SECPKG_CRED_OUTBOUND, NULL,
164 p_identity, NULL, NULL,
165 &credentials, NULL);
167 if(status != SEC_E_OK) {
168 Curl_sspi_free_identity(p_identity);
169 curlx_free(spn);
170 curlx_free(output_token);
171 return CURLE_LOGIN_DENIED;
172 }
174 /* Setup the challenge "input" security buffer */
175 chlg_desc.ulVersion = SECBUFFER_VERSION;
176 chlg_desc.cBuffers = 1;
177 chlg_desc.pBuffers = &chlg_buf;
178 chlg_buf.BufferType = SECBUFFER_TOKEN;
179 chlg_buf.pvBuffer = CURL_UNCONST(Curl_bufref_ptr(chlg));
180 chlg_buf.cbBuffer = curlx_uztoul(Curl_bufref_len(chlg));
182 /* Setup the response "output" security buffer */
183 resp_desc.ulVersion = SECBUFFER_VERSION;
184 resp_desc.cBuffers = 1;
185 resp_desc.pBuffers = &resp_buf;
186 resp_buf.BufferType = SECBUFFER_TOKEN;
187 resp_buf.pvBuffer = output_token;
188 resp_buf.cbBuffer = curlx_uztoul(token_max);
190 /* Generate our response message */
191 status = Curl_pSecFn->InitializeSecurityContext(&credentials, NULL, spn,
192 0, 0, 0, &chlg_desc, 0,
193 &context, &resp_desc, &attrs,
194 NULL);
196 if(status == SEC_I_COMPLETE_NEEDED ||
197 status == SEC_I_COMPLETE_AND_CONTINUE)
198 Curl_pSecFn->CompleteAuthToken(&credentials, &resp_desc);
199 else if(status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) {
200 VERBOSE(char buffer[STRERROR_LEN]);
202 Curl_pSecFn->FreeCredentialsHandle(&credentials);
203 Curl_sspi_free_identity(p_identity);
204 curlx_free(spn);
205 curlx_free(output_token);
207 if(status == SEC_E_INSUFFICIENT_MEMORY)
208 return CURLE_OUT_OF_MEMORY;
210 infof(data, "schannel: InitializeSecurityContext failed: %s",
211 Curl_sspi_strerror(status, buffer, sizeof(buffer)));
213 return CURLE_AUTH_ERROR;
214 }
216 /* Return the response. */
217 Curl_bufref_set(out, output_token, resp_buf.cbBuffer, curl_free);
219 /* Free our handles */
220 Curl_pSecFn->DeleteSecurityContext(&context);
221 Curl_pSecFn->FreeCredentialsHandle(&credentials);
223 /* Free the identity structure */
224 Curl_sspi_free_identity(p_identity);
226 /* Free the SPN */
227 curlx_free(spn);
229 return result;
232/*
233 * Curl_override_sspi_http_realm()
234 *
235 * This is used to populate the domain in an SSPI identity structure
236 * The realm is extracted from the challenge message and used as the
237 * domain if it is not already explicitly set.
238 *
239 * Parameters:
240 *
241 * chlg [in] - The challenge message.
242 * identity [in/out] - The identity structure.
243 *
244 * Returns CURLE_OK on success.
245 */
246CURLcode Curl_override_sspi_http_realm(const char *chlg,
247 SEC_WINNT_AUTH_IDENTITY_EX *identity)
249 xcharp_u domain, dup_domain;
251 /* If domain is blank or unset, check challenge message for realm */
252 if(!identity->Domain || !identity->DomainLength) {
253 for(;;) {
254 struct Curl_str value;
255 char content[DIGEST_MAX_CONTENT_LENGTH];
257 /* Pass all additional spaces here */
258 curlx_str_passblanks(&chlg);
260 /* Extract a value=content pair */
261 if(Curl_auth_digest_get_pair(chlg, &value, content, &chlg)) {
262 if(curlx_str_casecompare(&value, "realm")) {
264 /* Setup identity's domain and length */
265 domain.tchar_ptr = curlx_convert_UTF8_to_tchar(content);
266 if(!domain.tchar_ptr)
267 return CURLE_OUT_OF_MEMORY;
269 dup_domain.tchar_ptr = curlx_tcsdup(domain.tchar_ptr);
270 if(!dup_domain.tchar_ptr) {
271 curlx_free(domain.tchar_ptr);
272 return CURLE_OUT_OF_MEMORY;
273 }
275 curlx_free(identity->Domain);
276 identity->Domain = dup_domain.tbyte_ptr;
277 identity->DomainLength = curlx_uztoul(_tcslen(dup_domain.tchar_ptr));
278 dup_domain.tchar_ptr = NULL;
280 curlx_free(domain.tchar_ptr);
281 }
282 else {
283 /* Unknown specifier, ignore it! */
284 }
285 }
286 else
287 break; /* We are done here */
289 /* Pass all additional spaces here */
290 curlx_str_passblanks(&chlg);
292 /* Allow the list to be comma-separated */
293 (void)curlx_str_single(&chlg, ',');
294 }
295 }
297 return CURLE_OK;
300/*
301 * Curl_auth_decode_digest_http_message()
302 *
303 * This is used to decode an HTTP DIGEST challenge message into the separate
304 * attributes.
305 *
306 * Parameters:
307 *
308 * chlg [in] - The challenge message.
309 * digest [in/out] - The digest data struct being used and modified.
310 *
311 * Returns CURLE_OK on success.
312 */
313CURLcode Curl_auth_decode_digest_http_message(const char *chlg,
314 struct digestdata *digest)
316 size_t chlglen = strlen(chlg);
318 /* We had an input token before so if there is another one now that means we
319 provided bad credentials in the previous request or it is stale. */
320 if(digest->input_token) {
321 bool stale = FALSE;
322 const char *p = chlg;
324 /* Check for the 'stale' directive */
325 for(;;) {
326 struct Curl_str value;
327 char content[DIGEST_MAX_CONTENT_LENGTH];
329 while(*p && ISBLANK(*p))
330 p++;
332 if(!Curl_auth_digest_get_pair(p, &value, content, &p))
333 break;
335 if(curlx_str_casecompare(&value, "stale") &&
336 curl_strequal(content, "true")) {
337 stale = TRUE;
338 break;
339 }
341 while(*p && ISBLANK(*p))
342 p++;
344 if(',' == *p)
345 p++;
346 }
348 if(stale)
349 Curl_auth_digest_cleanup(digest);
350 else
351 return CURLE_LOGIN_DENIED;
352 }
354 /* Store the challenge for use later */
355 digest->input_token = (BYTE *)curlx_memdup(chlg, chlglen + 1);
356 if(!digest->input_token)
357 return CURLE_OUT_OF_MEMORY;
359 digest->input_token_len = chlglen;
361 return CURLE_OK;
364/*
365 * Curl_auth_create_digest_http_message()
366 *
367 * This is used to generate an HTTP DIGEST response message ready for sending
368 * to the recipient.
369 *
370 * Parameters:
371 *
372 * data [in] - The session handle.
373 * userp [in] - The username in the format User or Domain\User.
374 * passwdp [in] - The user's password.
375 * request [in] - The HTTP request.
376 * uripath [in] - The path of the HTTP uri.
377 * digest [in/out] - The digest data struct being used and modified.
378 * outptr [in/out] - The address where a pointer to newly allocated memory
379 * holding the result is stored upon completion.
380 * outlen [out] - The length of the output message.
381 *
382 * Returns CURLE_OK on success.
383 */
384CURLcode Curl_auth_create_digest_http_message(struct Curl_easy *data,
385 struct Curl_creds *creds,
386 const unsigned char *request,
387 const unsigned char *uripath,
388 struct digestdata *digest,
389 char **outptr, size_t *outlen)
391 size_t token_max;
392 char *resp;
393 BYTE *output_token;
394 size_t output_token_len = 0;
395 PSecPkgInfo SecurityPackage;
396 SecBuffer chlg_buf[5];
397 SecBufferDesc chlg_desc;
398 SECURITY_STATUS status;
400 /* Query the security package for DigestSSP */
401 status =
402 Curl_pSecFn->QuerySecurityPackageInfo(
403 CURL_UNCONST(TEXT(SP_NAME_DIGEST)),
404 &SecurityPackage);
405 if(status != SEC_E_OK) {
406 failf(data, "SSPI: could not get auth info");
407 return CURLE_AUTH_ERROR;
408 }
410 token_max = SecurityPackage->cbMaxToken;
412 /* Release the package buffer as it is not required anymore */
413 Curl_pSecFn->FreeContextBuffer(SecurityPackage);
415 /* Allocate the output buffer according to the max token size as indicated
416 by the security package */
417 output_token = curlx_malloc(token_max);
418 if(!output_token) {
419 return CURLE_OUT_OF_MEMORY;
420 }
422 /* If the user/passwd that was used to make the identity for http_context
423 has changed then delete that context. */
424 if(!Curl_creds_same(creds, digest->creds)) {
425 if(digest->http_context) {
426 Curl_pSecFn->DeleteSecurityContext(digest->http_context);
427 curlx_safefree(digest->http_context);
428 }
429 Curl_creds_unlink(&digest->creds);
430 }
432 if(digest->http_context) {
433 chlg_desc.ulVersion = SECBUFFER_VERSION;
434 chlg_desc.cBuffers = 5;
435 chlg_desc.pBuffers = chlg_buf;
436 chlg_buf[0].BufferType = SECBUFFER_TOKEN;
437 chlg_buf[0].pvBuffer = NULL;
438 chlg_buf[0].cbBuffer = 0;
439 chlg_buf[1].BufferType = SECBUFFER_PKG_PARAMS;
440 chlg_buf[1].pvBuffer = CURL_UNCONST(request);
441 chlg_buf[1].cbBuffer = curlx_uztoul(strlen((const char *)request));
442 chlg_buf[2].BufferType = SECBUFFER_PKG_PARAMS;
443 chlg_buf[2].pvBuffer = CURL_UNCONST(uripath);
444 chlg_buf[2].cbBuffer = curlx_uztoul(strlen((const char *)uripath));
445 chlg_buf[3].BufferType = SECBUFFER_PKG_PARAMS;
446 chlg_buf[3].pvBuffer = NULL;
447 chlg_buf[3].cbBuffer = 0;
448 chlg_buf[4].BufferType = SECBUFFER_PADDING;
449 chlg_buf[4].pvBuffer = output_token;
450 chlg_buf[4].cbBuffer = curlx_uztoul(token_max);
452 status = Curl_pSecFn->MakeSignature(digest->http_context, 0, &chlg_desc,
453 0);
454 if(status == SEC_E_OK)
455 output_token_len = chlg_buf[4].cbBuffer;
456 else { /* delete the context so a new one can be made */
457 infof(data, "digest_sspi: MakeSignature failed, error 0x%08lx",
458 (unsigned long)status);
459 Curl_pSecFn->DeleteSecurityContext(digest->http_context);
460 curlx_safefree(digest->http_context);
461 }
462 }
464 if(!digest->http_context) {
465 CredHandle credentials;
466 SEC_WINNT_AUTH_IDENTITY_EX identity;
467 SEC_WINNT_AUTH_IDENTITY_EX *p_identity;
468 SecBuffer resp_buf;
469 SecBufferDesc resp_desc;
470 unsigned long attrs;
471 TCHAR *spn;
473 /* free the credentials used to make the previous identity */
474 Curl_creds_unlink(&digest->creds);
476 if(Curl_creds_has_user(creds)) {
477 /* Populate our identity structure */
478 if(Curl_create_sspi_identity(creds->user, creds->passwd, &identity)) {
479 curlx_free(output_token);
480 return CURLE_OUT_OF_MEMORY;
481 }
483 /* Populate our identity domain */
484 if(Curl_override_sspi_http_realm((const char *)digest->input_token,
485 &identity)) {
486 Curl_sspi_free_identity(&identity);
487 curlx_free(output_token);
488 return CURLE_OUT_OF_MEMORY;
489 }
491 /* Allow proper cleanup of the identity structure */
492 p_identity = &identity;
493 }
494 else
495 /* Use the current Windows user */
496 p_identity = NULL;
498 if(creds)
499 Curl_creds_link(&digest->creds, creds);
501 /* Acquire our credentials handle */
502 status = Curl_pSecFn->AcquireCredentialsHandle(NULL,
503 CURL_UNCONST(TEXT(SP_NAME_DIGEST)),
504 SECPKG_CRED_OUTBOUND, NULL,
505 p_identity, NULL, NULL,
506 &credentials, NULL);
507 if(status != SEC_E_OK) {
508 Curl_sspi_free_identity(p_identity);
509 curlx_free(output_token);
511 return CURLE_LOGIN_DENIED;
512 }
514 /* Setup the challenge "input" security buffer if present */
515 chlg_desc.ulVersion = SECBUFFER_VERSION;
516 chlg_desc.cBuffers = 3;
517 chlg_desc.pBuffers = chlg_buf;
518 chlg_buf[0].BufferType = SECBUFFER_TOKEN;
519 chlg_buf[0].pvBuffer = digest->input_token;
520 chlg_buf[0].cbBuffer = curlx_uztoul(digest->input_token_len);
521 chlg_buf[1].BufferType = SECBUFFER_PKG_PARAMS;
522 chlg_buf[1].pvBuffer = CURL_UNCONST(request);
523 chlg_buf[1].cbBuffer = curlx_uztoul(strlen((const char *)request));
524 chlg_buf[2].BufferType = SECBUFFER_PKG_PARAMS;
525 chlg_buf[2].pvBuffer = NULL;
526 chlg_buf[2].cbBuffer = 0;
528 /* Setup the response "output" security buffer */
529 resp_desc.ulVersion = SECBUFFER_VERSION;
530 resp_desc.cBuffers = 1;
531 resp_desc.pBuffers = &resp_buf;
532 resp_buf.BufferType = SECBUFFER_TOKEN;
533 resp_buf.pvBuffer = output_token;
534 resp_buf.cbBuffer = curlx_uztoul(token_max);
536 spn = curlx_convert_UTF8_to_tchar((const char *)uripath);
537 if(!spn) {
538 Curl_pSecFn->FreeCredentialsHandle(&credentials);
540 Curl_sspi_free_identity(p_identity);
541 curlx_free(output_token);
543 return CURLE_OUT_OF_MEMORY;
544 }
546 /* Allocate our new context handle */
547 digest->http_context = curlx_calloc(1, sizeof(CtxtHandle));
548 if(!digest->http_context) {
549 Curl_pSecFn->FreeCredentialsHandle(&credentials);
550 curlx_free(spn);
551 Curl_sspi_free_identity(p_identity);
552 curlx_free(output_token);
553 return CURLE_OUT_OF_MEMORY;
554 }
556 /* Generate our response message */
557 status = Curl_pSecFn->InitializeSecurityContext(&credentials, NULL,
558 spn,
559 ISC_REQ_USE_HTTP_STYLE,
560 0, 0,
561 &chlg_desc, 0,
562 digest->http_context,
563 &resp_desc, &attrs, NULL);
564 curlx_free(spn);
566 if(status == SEC_I_COMPLETE_NEEDED ||
567 status == SEC_I_COMPLETE_AND_CONTINUE)
568 Curl_pSecFn->CompleteAuthToken(&credentials, &resp_desc);
569 else if(status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) {
570 VERBOSE(char buffer[STRERROR_LEN]);
572 Curl_pSecFn->FreeCredentialsHandle(&credentials);
574 Curl_sspi_free_identity(p_identity);
575 curlx_free(output_token);
577 curlx_safefree(digest->http_context);
579 if(status == SEC_E_INSUFFICIENT_MEMORY)
580 return CURLE_OUT_OF_MEMORY;
582 infof(data, "schannel: InitializeSecurityContext failed: %s",
583 Curl_sspi_strerror(status, buffer, sizeof(buffer)));
585 return CURLE_AUTH_ERROR;
586 }
588 output_token_len = resp_buf.cbBuffer;
590 Curl_pSecFn->FreeCredentialsHandle(&credentials);
591 Curl_sspi_free_identity(p_identity);
592 }
594 resp = curlx_memdup0((const char *)output_token, output_token_len);
595 curlx_free(output_token);
596 if(!resp) {
597 return CURLE_OUT_OF_MEMORY;
598 }
600 /* Return the response */
601 *outptr = resp;
602 *outlen = output_token_len;
603 return CURLE_OK;
606/*
607 * Curl_auth_digest_cleanup()
608 *
609 * This is used to clean up the digest specific data.
610 *
611 * Parameters:
612 *
613 * digest [in/out] - The digest data struct being cleaned up.
614 *
615 */
616void Curl_auth_digest_cleanup(struct digestdata *digest)
618 /* Free the input token */
619 curlx_safefree(digest->input_token);
621 /* Reset any variables */
622 digest->input_token_len = 0;
624 /* Delete security context */
625 if(digest->http_context) {
626 Curl_pSecFn->DeleteSecurityContext(digest->http_context);
627 curlx_safefree(digest->http_context);
628 }
630 /* Free the copy of user/passwd used to make the identity for http_context */
631 Curl_creds_unlink(&digest->creds);
632 Curl_peer_unlink(&digest->origin);
635#endif /* USE_WINDOWS_SSPI && !CURL_DISABLE_DIGEST_AUTH */
Diagnostics4 git calls · 26 ms
CallStatusSizeTime026 ms
discover200152 B2 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=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
fetch2005.1 KiB · hit22 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=5271
git.response.cache=HIT
git.response.duration_ms=22
git.fetch.wants=1a8dc91c627b5bee84bb6b3d25306feedd8323e5
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=5271
git.pkt.payload.max=5250
git.sideband.band1.bytes=5249
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
a5eafa5d4f04b1bb
Request
28a291bf…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format