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###########################################################################
24#
25import base64
26import ipaddress
27import os
28import re
29import shutil
30import subprocess
31from datetime import datetime, timedelta, timezone
32from typing import Any, List, Optional
34from cryptography import x509
35from cryptography.hazmat.backends import default_backend
36from cryptography.hazmat.primitives import hashes
37from cryptography.hazmat.primitives._serialization import PublicFormat
38from cryptography.hazmat.primitives.asymmetric import ec, rsa
39from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePrivateKey
40from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
41from cryptography.hazmat.primitives.serialization import (
42 Encoding,
43 NoEncryption,
44 PrivateFormat,
45 load_pem_private_key,
46)
47from cryptography.x509 import ExtendedKeyUsageOID, NameOID
49EC_SUPPORTED = {}
50EC_SUPPORTED.update([(curve.name.upper(), curve) for curve in [
51 ec.SECP192R1,
52 ec.SECP224R1,
53 ec.SECP256R1,
54 ec.SECP384R1,
55]])
58class CertError(Exception):
59 """Error in certificate handling."""
62def _private_key(key_type):
63 if isinstance(key_type, str):
64 key_type = key_type.upper()
65 m = re.match(r'^(RSA)?(\d+)$', key_type)
66 if m:
67 key_type = int(m.group(2))
69 if isinstance(key_type, int):
70 return rsa.generate_private_key(
71 public_exponent=65537,
72 key_size=key_type,
73 backend=default_backend()
74 )
75 if not isinstance(key_type, ec.EllipticCurve) and key_type in EC_SUPPORTED:
76 key_type = EC_SUPPORTED[key_type]
77 return ec.generate_private_key(
78 curve=key_type,
79 backend=default_backend()
80 )
83class CertificateSpec:
85 def __init__(self, name: Optional[str] = None,
86 domains: Optional[List[str]] = None,
87 email: Optional[str] = None,
88 key_type: Optional[str] = None,
89 single_file: bool = False,
90 valid_from: timedelta = timedelta(days=-1),
91 valid_to: timedelta = timedelta(days=89),
92 client: bool = False,
93 check_valid: bool = True,
94 sub_specs: Optional[List['CertificateSpec']] = None):
95 self._name = name
96 self.domains = domains
97 self.client = client
98 self.email = email
99 self.key_type = key_type
100 self.single_file = single_file
101 self.valid_from = valid_from
102 self.valid_to = valid_to
103 self.sub_specs = sub_specs
104 self.check_valid = check_valid
106 @property
107 def name(self) -> Optional[str]:
108 if self._name:
109 return self._name
110 if self.domains:
111 return self.domains[0]
112 return None
114 @property
115 def type(self) -> Optional[str]:
116 if self.domains and len(self.domains):
117 return "server"
118 if self.client:
119 return "client"
120 if self.name:
121 return "ca"
122 return None
125class Credentials:
127 def __init__(self,
128 name: str,
129 cert: Any,
130 pkey: Any,
131 issuer: Optional['Credentials'] = None):
132 self._name = name
133 self._cert = cert
134 self._pkey = pkey
135 self._issuer = issuer
136 self._cert_file = None
137 self._pkey_file = None
138 self._store = None
139 self._combined_file = None
141 @property
142 def name(self) -> str:
143 return self._name
145 @property
146 def subject(self) -> x509.Name:
147 return self._cert.subject
149 @property
150 def serial_number(self):
151 return self._cert.serial_number
153 @property
154 def key_type(self):
155 if isinstance(self._pkey, RSAPrivateKey):
156 return f"rsa{self._pkey.key_size}"
157 if isinstance(self._pkey, EllipticCurvePrivateKey):
158 return f"{self._pkey.curve.name}"
159 raise CertError(f"unknown key type: {self._pkey}")
161 @property
162 def private_key(self) -> Any:
163 return self._pkey
165 def pub_sha256_b64(self) -> Any:
166 pubkey = self._pkey.public_key()
167 sha256 = hashes.Hash(algorithm=hashes.SHA256())
168 sha256.update(pubkey.public_bytes(
169 encoding=Encoding.DER,
170 format=PublicFormat.SubjectPublicKeyInfo
171 ))
172 return base64.b64encode(sha256.finalize()).decode('utf8')
174 @property
175 def certificate(self) -> Any:
176 return self._cert
178 @property
179 def cert_pem(self) -> bytes:
180 return self._cert.public_bytes(Encoding.PEM)
182 @property
183 def pkey_pem(self) -> bytes:
184 return self._pkey.private_bytes(
185 Encoding.PEM,
186 PrivateFormat.TraditionalOpenSSL if self.key_type.startswith('rsa') else PrivateFormat.PKCS8,
187 NoEncryption())
189 @property
190 def issuer(self) -> Optional['Credentials']:
191 return self._issuer
193 def set_store(self, store: 'CertStore'):
194 self._store = store
196 def set_files(self, cert_file: str, pkey_file: Optional[str] = None,
197 combined_file: Optional[str] = None):
198 self._cert_file = cert_file
199 self._pkey_file = pkey_file
200 self._combined_file = combined_file
202 @property
203 def cert_file(self) -> str:
204 return self._cert_file
206 @property
207 def pkey_file(self) -> Optional[str]:
208 return self._pkey_file
210 @property
211 def combined_file(self) -> Optional[str]:
212 return self._combined_file
214 @property
215 def hashdir(self) -> Optional[str]:
216 return os.path.join(self._store.path, 'hashdir')
218 def get_first(self, name) -> Optional['Credentials']:
219 creds = self._store.get_credentials_for_name(name) if self._store else []
220 return creds[0] if creds else None
222 def get_credentials_for_name(self, name) -> List['Credentials']:
223 return self._store.get_credentials_for_name(name) if self._store else []
225 def issue_certs(self, specs: List[CertificateSpec],
226 chain: Optional[List['Credentials']] = None) -> List['Credentials']:
227 return [self.issue_cert(spec=spec, chain=chain) for spec in specs]
229 def issue_cert(self, spec: CertificateSpec,
230 chain: Optional[List['Credentials']] = None) -> 'Credentials':
231 key_type = spec.key_type or self.key_type
232 creds = None
233 if self._store:
234 creds = self._store.load_credentials(
235 name=spec.name, key_type=key_type, single_file=spec.single_file,
236 issuer=self, check_valid=spec.check_valid)
237 if creds is None:
238 creds = TestCA.create_credentials(spec=spec, issuer=self, key_type=key_type,
239 valid_from=spec.valid_from, valid_to=spec.valid_to)
240 if self._store:
241 self._store.save(creds, single_file=spec.single_file)
242 if spec.type == "ca":
243 self._store.save_chain(creds, "ca", with_root=True)
245 if spec.sub_specs:
246 if self._store:
247 sub_store = CertStore(fpath=os.path.join(self._store.path, creds.name))
248 creds.set_store(sub_store)
249 subchain = chain.copy() if chain else []
250 subchain.append(self)
251 creds.issue_certs(spec.sub_specs, chain=subchain)
252 return creds
254 def create_hashdir(self, openssl):
255 os.makedirs(self.hashdir, exist_ok=True)
256 p = subprocess.run(args=[
257 openssl, 'x509', '-hash', '-noout', '-in', self.cert_file
258 ], capture_output=True, text=True, check=True)
259 cert_hname = f'{p.stdout.strip()}.0'
260 shutil.copy(self.cert_file, os.path.join(self.hashdir, cert_hname))
263class CertStore:
265 def __init__(self, fpath: str):
266 self._store_dir = fpath
267 if not os.path.exists(self._store_dir):
268 os.makedirs(self._store_dir)
269 self._creds_by_name = {}
271 @property
272 def path(self) -> str:
273 return self._store_dir
275 def save(self, creds: Credentials, name: Optional[str] = None,
276 chain: Optional[List[Credentials]] = None,
277 single_file: bool = False) -> None:
278 name = name if name is not None else creds.name
279 cert_file = self.get_cert_file(name=name, key_type=creds.key_type)
280 pkey_file = self.get_pkey_file(name=name, key_type=creds.key_type)
281 comb_file = self.get_combined_file(name=name, key_type=creds.key_type)
282 if single_file:
283 pkey_file = None
284 with open(cert_file, "wb") as fd:
285 fd.write(creds.cert_pem)
286 if chain:
287 fd.writelines(c.cert_pem for c in chain)
288 if pkey_file is None:
289 fd.write(creds.pkey_pem)
290 if pkey_file is not None:
291 with open(pkey_file, "wb") as fd:
292 fd.write(creds.pkey_pem)
293 with open(comb_file, "wb") as fd:
294 fd.write(creds.cert_pem)
295 if chain:
296 fd.writelines(c.cert_pem for c in chain)
297 fd.write(creds.pkey_pem)
298 creds.set_files(cert_file, pkey_file, comb_file)
299 self._add_credentials(name, creds)
301 def save_chain(self, creds: Credentials, infix: str, with_root=False):
302 name = creds.name
303 chain = [creds]
304 while creds.issuer is not None:
305 creds = creds.issuer
306 chain.append(creds)
307 if not with_root and len(chain) > 1:
308 chain = chain[:-1]
309 chain_file = os.path.join(self._store_dir, f'{name}-{infix}.pem')
310 with open(chain_file, "wb") as fd:
311 fd.writelines(c.cert_pem for c in chain)
313 def _add_credentials(self, name: str, creds: Credentials):
314 if name not in self._creds_by_name:
315 self._creds_by_name[name] = []
316 self._creds_by_name[name].append(creds)
318 def get_credentials_for_name(self, name) -> List[Credentials]:
319 return self._creds_by_name.get(name, [])
321 def get_cert_file(self, name: str, key_type=None) -> str:
322 key_infix = f".{key_type}" if key_type is not None else ""
323 return os.path.join(self._store_dir, f'{name}{key_infix}.cert.pem')
325 def get_pkey_file(self, name: str, key_type=None) -> str:
326 key_infix = f".{key_type}" if key_type is not None else ""
327 return os.path.join(self._store_dir, f'{name}{key_infix}.pkey.pem')
329 def get_combined_file(self, name: str, key_type=None) -> str:
330 return os.path.join(self._store_dir, f'{name}.pem')
332 def load_pem_cert(self, fpath: str) -> x509.Certificate:
333 with open(fpath) as fd:
334 return x509.load_pem_x509_certificate("".join(fd.readlines()).encode())
336 def load_pem_pkey(self, fpath: str):
337 with open(fpath) as fd:
338 return load_pem_private_key("".join(fd.readlines()).encode(), password=None)
340 def load_credentials(self, name: str, key_type=None,
341 single_file: bool = False,
342 issuer: Optional[Credentials] = None,
343 check_valid: bool = False):
344 cert_file = self.get_cert_file(name=name, key_type=key_type)
345 pkey_file = cert_file if single_file else self.get_pkey_file(name=name, key_type=key_type)
346 comb_file = self.get_combined_file(name=name, key_type=key_type)
347 if os.path.isfile(cert_file) and os.path.isfile(pkey_file):
348 cert = self.load_pem_cert(cert_file)
349 pkey = self.load_pem_pkey(pkey_file)
350 try:
351 before = cert.not_valid_before_utc
352 after = cert.not_valid_after_utc
353 except AttributeError: # cryptography < 42.0.0
354 # the timestamps are already returned in UTC, just missing the time zone
355 before = cert.not_valid_before.replace(tzinfo=timezone.utc)
356 after = cert.not_valid_after.replace(tzinfo=timezone.utc)
357 now = datetime.now(timezone.utc)
358 if check_valid and ((after < now) or (before > now)):
359 return None
360 creds = Credentials(name=name, cert=cert, pkey=pkey, issuer=issuer)
361 creds.set_store(self)
362 creds.set_files(cert_file, pkey_file, comb_file)
363 self._add_credentials(name, creds)
364 return creds
365 return None
368class TestCA:
370 @classmethod
371 def create_root(cls, name: str, store_dir: str, key_type: str = "rsa2048") -> Credentials:
372 store = CertStore(fpath=store_dir)
373 creds = store.load_credentials(name="ca", key_type=key_type, issuer=None)
374 if creds is None:
375 creds = cls._make_ca_credentials(name=name, key_type=key_type)
376 store.save(creds, name="ca")
377 creds.set_store(store)
378 return creds
380 @classmethod
381 def create_credentials(cls, spec: CertificateSpec, issuer: Credentials, key_type: Any,
382 valid_from: timedelta = timedelta(days=-1),
383 valid_to: timedelta = timedelta(days=89),
384 ) -> Credentials:
385 """
386 Create a certificate signed by this CA for the given domains.
388 :returns: the certificate and private key PEM file paths
389 """
390 if spec.domains and len(spec.domains):
391 return cls._make_server_credentials(name=spec.name, domains=spec.domains,
392 issuer=issuer, valid_from=valid_from,
393 valid_to=valid_to, key_type=key_type)
394 if spec.client:
395 return cls._make_client_credentials(name=spec.name, issuer=issuer,
396 email=spec.email, valid_from=valid_from,
397 valid_to=valid_to, key_type=key_type)
398 if spec.name:
399 return cls._make_ca_credentials(name=spec.name, issuer=issuer,
400 valid_from=valid_from, valid_to=valid_to,
401 key_type=key_type)
402 raise CertError(f"unrecognized certificate specification: {spec}")
404 @staticmethod
405 def _make_x509_name(org_name: Optional[str] = None, common_name: Optional[str] = None, parent: x509.Name = None) -> x509.Name:
406 name_pieces = []
407 if org_name:
408 oid = NameOID.ORGANIZATIONAL_UNIT_NAME if parent else NameOID.ORGANIZATION_NAME
409 name_pieces.append(x509.NameAttribute(oid, org_name))
410 elif common_name:
411 name_pieces.append(x509.NameAttribute(NameOID.COMMON_NAME, common_name))
412 if parent:
413 name_pieces.extend(list(parent))
414 return x509.Name(name_pieces)
416 @staticmethod
417 def _make_csr(
418 subject: x509.Name,
419 pkey: Any,
420 issuer_subject: Optional[Credentials],
421 valid_from_delta: Optional[timedelta] = None,
422 valid_until_delta: Optional[timedelta] = None
423 ) -> x509.CertificateBuilder:
424 pubkey = pkey.public_key()
425 issuer_subject = issuer_subject if issuer_subject is not None else subject
427 valid_from = datetime.now(timezone.utc)
428 if valid_until_delta is not None:
429 valid_from += valid_from_delta
430 valid_until = datetime.now(timezone.utc)
431 if valid_until_delta is not None:
432 valid_until += valid_until_delta
434 return (
435 x509.CertificateBuilder()
436 .subject_name(subject)
437 .issuer_name(issuer_subject)
438 .public_key(pubkey)
439 .not_valid_before(valid_from)
440 .not_valid_after(valid_until)
441 .serial_number(x509.random_serial_number())
442 .add_extension(
443 x509.SubjectKeyIdentifier.from_public_key(pubkey),
444 critical=False,
445 )
446 )
448 @staticmethod
449 def _add_ca_usages(csr: Any) -> Any:
450 return csr.add_extension(
451 x509.BasicConstraints(ca=True, path_length=9),
452 critical=True,
453 ).add_extension(
454 x509.KeyUsage(
455 digital_signature=True,
456 content_commitment=False,
457 key_encipherment=False,
458 data_encipherment=False,
459 key_agreement=False,
460 key_cert_sign=True,
461 crl_sign=True,
462 encipher_only=False,
463 decipher_only=False),
464 critical=True
465 ).add_extension(
466 x509.ExtendedKeyUsage([
467 ExtendedKeyUsageOID.CLIENT_AUTH,
468 ExtendedKeyUsageOID.SERVER_AUTH,
469 ExtendedKeyUsageOID.CODE_SIGNING,
470 ]),
471 critical=True
472 )
474 @staticmethod
475 def _add_leaf_usages(csr: Any, domains: List[str], issuer: Credentials) -> Any:
476 names = []
477 for name in domains:
478 m = re.match(r'dns:(.+)', name)
479 if m:
480 names.append(x509.DNSName(m.group(1)))
481 else:
482 try:
483 names.append(x509.IPAddress(ipaddress.ip_address(name)))
484 except ValueError:
485 names.append(x509.DNSName(name))
487 return csr.add_extension(
488 x509.BasicConstraints(ca=False, path_length=None),
489 critical=True,
490 ).add_extension(
491 x509.AuthorityKeyIdentifier.from_issuer_subject_key_identifier(
492 issuer.certificate.extensions.get_extension_for_class(
493 x509.SubjectKeyIdentifier).value),
494 critical=False
495 ).add_extension(
496 x509.SubjectAlternativeName(names), critical=True,
497 ).add_extension(
498 x509.ExtendedKeyUsage([
499 ExtendedKeyUsageOID.SERVER_AUTH,
500 ]),
501 critical=False
502 )
504 @staticmethod
505 def _add_client_usages(csr: Any, issuer: Credentials, rfc82name: Optional[str] = None) -> Any:
506 cert = csr.add_extension(
507 x509.BasicConstraints(ca=False, path_length=None),
508 critical=True,
509 ).add_extension(
510 x509.AuthorityKeyIdentifier.from_issuer_subject_key_identifier(
511 issuer.certificate.extensions.get_extension_for_class(
512 x509.SubjectKeyIdentifier).value),
513 critical=False
514 )
515 if rfc82name:
516 cert.add_extension(
517 x509.SubjectAlternativeName([x509.RFC822Name(rfc82name)]),
518 critical=True,
519 )
520 cert.add_extension(
521 x509.ExtendedKeyUsage([
522 ExtendedKeyUsageOID.CLIENT_AUTH,
523 ]),
524 critical=True
525 )
526 return cert
528 @classmethod
529 def _make_ca_credentials(cls, name: str, key_type: Any,
530 issuer: Optional[Credentials] = None,
531 valid_from: timedelta = timedelta(days=-1),
532 valid_to: timedelta = timedelta(days=89),
533 ) -> Credentials:
534 pkey = _private_key(key_type=key_type)
535 if issuer is not None:
536 issuer_subject = issuer.certificate.subject
537 issuer_key = issuer.private_key
538 else:
539 issuer_subject = None
540 issuer_key = pkey
541 subject = cls._make_x509_name(org_name=name, parent=issuer.subject if issuer else None)
542 csr = cls._make_csr(subject=subject,
543 issuer_subject=issuer_subject, pkey=pkey,
544 valid_from_delta=valid_from, valid_until_delta=valid_to)
545 csr = cls._add_ca_usages(csr)
546 cert = csr.sign(private_key=issuer_key,
547 algorithm=hashes.SHA256(),
548 backend=default_backend())
549 return Credentials(name=name, cert=cert, pkey=pkey, issuer=issuer)
551 @classmethod
552 def _make_server_credentials(cls,
553 name: str, domains: List[str], issuer: Credentials,
554 key_type: Any,
555 valid_from: timedelta = timedelta(days=-1),
556 valid_to: timedelta = timedelta(days=89),
557 ) -> Credentials:
558 pkey = _private_key(key_type=key_type)
559 subject = cls._make_x509_name(common_name=name, parent=issuer.subject)
560 csr = cls._make_csr(subject=subject,
561 issuer_subject=issuer.certificate.subject, pkey=pkey,
562 valid_from_delta=valid_from, valid_until_delta=valid_to)
563 csr = cls._add_leaf_usages(csr, domains=domains, issuer=issuer)
564 cert = csr.sign(private_key=issuer.private_key,
565 algorithm=hashes.SHA256(),
566 backend=default_backend())
567 return Credentials(name=name, cert=cert, pkey=pkey, issuer=issuer)
569 @classmethod
570 def _make_client_credentials(cls,
571 name: str,
572 issuer: Credentials, email: Optional[str],
573 key_type: Any,
574 valid_from: timedelta = timedelta(days=-1),
575 valid_to: timedelta = timedelta(days=89),
576 ) -> Credentials:
577 pkey = _private_key(key_type=key_type)
578 subject = cls._make_x509_name(common_name=name, parent=issuer.subject)
579 csr = cls._make_csr(subject=subject,
580 issuer_subject=issuer.certificate.subject, pkey=pkey,
581 valid_from_delta=valid_from, valid_until_delta=valid_to)
582 csr = cls._add_client_usages(csr, issuer=issuer, rfc82name=email)
583 cert = csr.sign(private_key=issuer.private_key,
584 algorithm=hashes.SHA256(),
585 backend=default_backend())
586 return Credentials(name=name, cert=cert, pkey=pkey, issuer=issuer)
Diagnostics4 git calls · 434 ms
CallStatusSizeTime0434 ms
discover200152 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 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 · hit4 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 git.response.bytes=293470 git.response.cache=HIT git.response.duration_ms=4 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
fetch2005.5 KiB427 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=427 git.response.bytes=5581 git.response.cache=MISS git.response.duration_ms=427 git.fetch.wants=269263586adb3eff386bd1b109a7b244410257dc 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=5581 git.pkt.payload.max=5560 git.sideband.band1.bytes=5559 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
- a5e2d2b5c9e7cf3a
- Request
- a733355c…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format