codeimprint 0.5.0a11__py3-none-any.whl

codeimprint_cli/records.py

@@ -0,0 +1,59 @@
+"""Ownership records (receipt format 4): the public byte format, for verification only.
+
+A record's digest is SHA-256 of its canonical JSON document; its ID is a typed ID built from
+that digest with its type's prefix. Each type fixes the attestation ``kind`` and the document
+fields that name other records or seals (they become the attestation's ``parents``). Owner and
+counter-party signatures are Ed25519 over the canonical
+``{"type": "codeimprint.record-sign.v1", "record_type": <type>, "digest": <digest>}``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+RECORD_SIGN = "codeimprint.record-sign.v1"
+
+
+@dataclass(frozen=True)
+class RecordType:
+    prefix: str
+    kind: str
+    refs: tuple[str, ...] = ()
+    roles: tuple[str, ...] = ()
+
+
+TYPES: dict[str, RecordType] = {
+    "codeimprint.identity.v1": RecordType("IDT1", "identity", ("renews",)),
+    "codeimprint.revocation.v1": RecordType("REV1", "revocation", ("revokes",)),
+    "codeimprint.org-member.v1": RecordType("MBR1", "membership", (), ("member",)),
+    "codeimprint.org-member-end.v1": RecordType("MBR1", "membership-end", ("membership",)),
+    "codeimprint.org-endorsement.v1": RecordType("END1", "endorsement", ("head",), ("signer",)),
+    "codeimprint.claim.v1": RecordType("CLM1", "claim", ("counters", "supersedes"),
+                                       ("claimant",)),
+    "codeimprint.claim-key.v1": RecordType("CLM1", "claim-key", ("claim",), ("authorised",)),
+    "codeimprint.transfer.v1": RecordType("XFR1", "transfer", ("from_claim",), ("from", "to")),
+    "codeimprint.org-transfer.v1": RecordType("XFR1", "org-transfer", (), ("from", "to")),
+    "codeimprint.assignment.v1": RecordType("ASG1", "assignment", ("to_claim",),
+                                            ("assignor", "assignee")),
+    "codeimprint.declaration.v1": RecordType("DCL1", "declaration", ("head",), ("project",)),
+    "codeimprint.contributor.v1": RecordType("CTB1", "contributor", (),
+                                             ("contributor", "project")),
+    "codeimprint.notice.v1": RecordType("NTC1", "notice", ("about",)),
+    "codeimprint.disclosure.v1": RecordType("DSC1", "disclosure", ("record",), ("admin",)),
+    "codeimprint.integration.v1": RecordType("INT1", "integration", (),
+                                             ("integration", "owner")),
+}
+
+
+def parents(rtype: RecordType, document: dict) -> list[str]:
+    out: set[str] = set()
+    for field in rtype.refs:
+        value = document.get(field)
+        for ref in value if isinstance(value, list) else [value]:
+            if isinstance(ref, str):
+                out.add(ref)
+    return sorted(out)
+
+
+def sign_statement(record_type: str, digest: str) -> dict:
+    return {"type": RECORD_SIGN, "record_type": record_type, "digest": digest}

codeimprint_cli/timestamp.py

@@ -0,0 +1,187 @@
+"""Offline verification of RFC 3161 time-stamp tokens.
+
+A token from an independent time-stamping authority (TSA) proves that a hash existed no later
+than the token's ``genTime``. The client only checks tokens; it never requests them.
+
+A token counts only if all of these hold:
+
+- it is signed by the certificate it names, over a TSTInfo for exactly this hash;
+- that signer certificate carries the timeStamping extended key usage, marked critical, and
+  was valid at ``genTime``;
+- the signer certificate chains, through CA certificates that were valid at ``genTime``, to
+  a pinned root (``tsa_roots``) or to a certificate the user passed with ``--tsa-certs``.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+from .tsa_roots import PINNED_ROOTS
+
+MAX_CHAIN = 8
+
+
+class TimestampError(Exception):
+    """The token is malformed, for other data, untrusted, or its signature does not verify."""
+
+
+@dataclass
+class TokenInfo:
+    gen_time: str               # YYYY-MM-DDTHH:MM:SSZ
+    tsa: str                    # the signer certificate's subject
+    tsa_cert_sha256: str
+    root: str                   # which trusted root the chain ends at
+
+
+@dataclass
+class Anchor:
+    name: str
+    cert: object                # cryptography.x509.Certificate
+
+
+def pinned_anchors() -> list[Anchor]:
+    from cryptography import x509
+
+    return [Anchor(name, x509.load_pem_x509_certificate(pem.encode()))
+            for name, pem in PINNED_ROOTS.items()]
+
+
+def load_anchors(extra: str | Path | None = None) -> list[Anchor]:
+    """The pinned roots, plus every certificate in a PEM bundle the user chose to trust."""
+    from cryptography import x509
+
+    anchors = pinned_anchors()
+    if extra:
+        certs = x509.load_pem_x509_certificates(Path(extra).read_bytes())
+        anchors += [Anchor(f"--tsa-certs {c.subject.rfc4514_string()}", c) for c in certs]
+    return anchors
+
+
+def _issued_by(cert, issuer) -> bool:
+    from cryptography.exceptions import InvalidSignature
+
+    if cert.issuer != issuer.subject:
+        return False
+    try:
+        cert.verify_directly_issued_by(issuer)
+    except (InvalidSignature, ValueError, TypeError):
+        return False
+    return True
+
+
+def _valid_at(cert, when: datetime) -> bool:
+    return cert.not_valid_before_utc <= when <= cert.not_valid_after_utc
+
+
+def _may_issue(cert) -> bool:
+    """A CA certificate whose usage (if restricted) still allows time-stamping below it."""
+    from cryptography import x509
+    from cryptography.x509.oid import ExtendedKeyUsageOID
+
+    try:
+        if not cert.extensions.get_extension_for_class(x509.BasicConstraints).value.ca:
+            return False
+    except x509.ExtensionNotFound:
+        return False
+    try:
+        eku = cert.extensions.get_extension_for_class(x509.ExtendedKeyUsage).value
+    except x509.ExtensionNotFound:
+        return True
+    return (ExtendedKeyUsageOID.TIME_STAMPING in eku
+            or ExtendedKeyUsageOID.ANY_EXTENDED_KEY_USAGE in eku)
+
+
+def _chain_to_anchor(signer, carried: list, anchors: list[Anchor], when: datetime) -> str:
+    current = signer
+    for _ in range(MAX_CHAIN):
+        for anchor in anchors:
+            if _issued_by(current, anchor.cert):
+                if not _valid_at(anchor.cert, when):
+                    raise TimestampError(f"root {anchor.name} was not valid at genTime")
+                return anchor.name
+        if current.issuer == current.subject:
+            break                                   # self-signed and not trusted
+        issuer = next((c for c in carried if c is not current and _issued_by(current, c)),
+                      None)
+        if issuer is None or not _may_issue(issuer):
+            break
+        if not _valid_at(issuer, when):
+            raise TimestampError(f"CA certificate {issuer.subject.rfc4514_string()} was not "
+                                 "valid at genTime")
+        current = issuer
+    raise TimestampError("unknown TSA: its certificate does not chain to a pinned root "
+                         "(pass --tsa-certs FILE to trust it)")
+
+
+def verify_token(token_der: bytes, digest: bytes,
+                 anchors: list[Anchor] | None = None) -> TokenInfo:
+    """Check that ``token_der`` is a trusted RFC 3161 token over SHA-256 ``digest``."""
+    from asn1crypto import cms, tsp  # noqa: F401 — importing tsp registers TSTInfo with cms
+    from cryptography import x509
+    from cryptography.exceptions import InvalidSignature
+    from cryptography.hazmat.primitives import hashes
+    from cryptography.hazmat.primitives.asymmetric import ec, padding, rsa
+    from cryptography.hazmat.primitives.serialization import Encoding
+    from cryptography.x509.oid import ExtendedKeyUsageOID
+
+    anchors = pinned_anchors() if anchors is None else anchors
+    try:
+        signed = cms.ContentInfo.load(token_der)["content"]
+        encap = signed["encap_content_info"]
+        if encap["content_type"].native != "tst_info":
+            raise TimestampError("not a time-stamp token")
+        tst = encap["content"].parsed
+        imprint = tst["message_imprint"]
+        if imprint["hash_algorithm"]["algorithm"].native != "sha256":
+            raise TimestampError("token does not use SHA-256")
+        if imprint["hashed_message"].native != digest:
+            raise TimestampError("token is for different data")
+        signer = signed["signer_infos"][0]
+        algo = signer["digest_algorithm"]["algorithm"].native
+        hash_cls = {"sha256": hashes.SHA256, "sha384": hashes.SHA384,
+                    "sha512": hashes.SHA512}.get(algo)
+        if hash_cls is None:
+            raise TimestampError(f"unsupported digest {algo}")
+        attrs = signer["signed_attrs"]
+        message_digest = next(a["values"][0].native for a in attrs
+                              if a["type"].native == "message_digest")
+        if message_digest != hashlib.new(algo, encap["content"].contents).digest():
+            raise TimestampError("token content was changed")
+        carried = [x509.load_der_x509_certificate(c.chosen.dump())
+                   for c in signed["certificates"] or []]
+        sid = signer["sid"].chosen
+        cert = next((c for c, raw in zip(carried, signed["certificates"] or [])
+                     if raw.chosen.issuer == sid["issuer"]
+                     and raw.chosen.serial_number == sid["serial_number"].native), None)
+        if cert is None:
+            raise TimestampError("token carries no TSA certificate")
+        eku = cert.extensions.get_extension_for_class(x509.ExtendedKeyUsage)
+        if ExtendedKeyUsageOID.TIME_STAMPING not in eku.value:
+            raise TimestampError("certificate is not for time-stamping")
+        if not eku.critical:
+            raise TimestampError("the time-stamping key usage is not marked critical")
+        signed_bytes = b"\x31" + attrs.dump()[1:]     # signed as SET OF, not [0] IMPLICIT
+        signature = signer["signature"].native
+        key = cert.public_key()
+        if isinstance(key, rsa.RSAPublicKey):
+            key.verify(signature, signed_bytes, padding.PKCS1v15(), hash_cls())
+        elif isinstance(key, ec.EllipticCurvePublicKey):
+            key.verify(signature, signed_bytes, ec.ECDSA(hash_cls()))
+        else:
+            raise TimestampError("unsupported TSA key type")
+        gen = tst["gen_time"].native
+    except InvalidSignature as exc:
+        raise TimestampError("token signature does not match") from exc
+    except (ValueError, KeyError, TypeError, IndexError, StopIteration,
+            x509.ExtensionNotFound) as exc:
+        raise TimestampError(f"malformed token: {exc}") from exc
+    if not _valid_at(cert, gen):
+        raise TimestampError("the TSA certificate was not valid at genTime")
+    root = _chain_to_anchor(cert, carried, anchors, gen)
+    return TokenInfo(gen_time=gen.strftime("%Y-%m-%dT%H:%M:%SZ"),
+                     tsa=cert.subject.rfc4514_string(),
+                     tsa_cert_sha256=hashlib.sha256(cert.public_bytes(Encoding.DER)).hexdigest(),
+                     root=root)

codeimprint_cli/transparency.py

@@ -0,0 +1,71 @@
+"""Merkle proofs for the CodeImprint transparency log (RFC 6962 hashing, RFC 9162 proofs).
+
+Leaf hash = SHA-256(0x00 || leaf bytes); node hash = SHA-256(0x01 || left || right). These
+are the public, standard checks that let anyone confirm a seal is in the log and that the
+log only ever grew.
+"""
+
+from __future__ import annotations
+
+import hashlib
+
+
+def leaf_hash(data: bytes) -> bytes:
+    return hashlib.sha256(b"\x00" + data).digest()
+
+
+def node_hash(left: bytes, right: bytes) -> bytes:
+    return hashlib.sha256(b"\x01" + left + right).digest()
+
+
+def verify_inclusion(index: int, size: int, leaf: bytes, proof: list[bytes],
+                     root: bytes) -> bool:
+    """RFC 9162 section 2.1.3.2: is ``leaf`` at ``index`` of the tree with this root?"""
+    if not 0 <= index < size:
+        return False
+    fn, sn, r = index, size - 1, leaf
+    for p in proof:
+        if sn == 0:
+            return False
+        if fn & 1 or fn == sn:
+            r = node_hash(p, r)
+            if not fn & 1:
+                while not fn & 1 and fn != 0:
+                    fn >>= 1
+                    sn >>= 1
+        else:
+            r = node_hash(r, p)
+        fn >>= 1
+        sn >>= 1
+    return sn == 0 and r == root
+
+
+def verify_consistency(first: int, second: int, first_root: bytes, second_root: bytes,
+                       proof: list[bytes]) -> bool:
+    """RFC 9162 section 2.1.4.2: does the tree of ``second`` leaves extend that of ``first``?"""
+    if first == second:
+        return not proof and first_root == second_root
+    if not 0 < first < second or not proof:
+        return False
+    if first & (first - 1) == 0:              # first is an exact power of two
+        proof = [first_root, *proof]
+    fn, sn = first - 1, second - 1
+    while fn & 1:
+        fn >>= 1
+        sn >>= 1
+    fr = sr = proof[0]
+    for c in proof[1:]:
+        if sn == 0:
+            return False
+        if fn & 1 or fn == sn:
+            fr = node_hash(c, fr)
+            sr = node_hash(c, sr)
+            if not fn & 1:
+                while not fn & 1 and fn != 0:
+                    fn >>= 1
+                    sn >>= 1
+        else:
+            sr = node_hash(sr, c)
+        fn >>= 1
+        sn >>= 1
+    return fr == first_root and sr == second_root and sn == 0

codeimprint_cli/trust.py

@@ -0,0 +1,190 @@
+"""Keys: the server's published attestation keys, and the developer's own signing key.
+
+Server keys are trusted on first use and then only ever extended: a later key set must keep
+every key already seen, unchanged (rotation adds keys and closes old windows; it never removes
+or replaces one). The developer key is an Ed25519 key that stays in the user config folder;
+only its public half and signatures are sent.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+from pathlib import Path
+
+from . import config
+from .imprint_file import b64d, canonical
+
+TRUSTED_FILE = "trusted-keys.json"           # in the user config folder: {server URL: keys}
+PROJECT_KEYS = "server-keys.json"            # in .imprint/: a copy for other verifiers
+DEVELOPER_KEY = "developer-key.pem"
+DEVELOPER_CONTEXT = b"codeimprint.developer-signature.v1\x00"
+
+
+def b64e(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def fingerprint(public_raw: bytes) -> str:
+    return hashlib.sha256(public_raw).hexdigest()[:16]
+
+
+def _write_private(path: Path, data: bytes) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "wb") as f:
+        f.write(data)
+    if os.name != "nt":
+        path.chmod(0o600)
+
+
+# -- signed statements ---------------------------------------------------------------------
+def verify_signed(block: dict, keys: list[dict]) -> tuple[bool, str]:
+    """Check a server-signed block against trusted keys, including the key's validity window.
+
+    Returns (ok, key_id) or (False, reason).
+    """
+    from cryptography.exceptions import InvalidSignature
+    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+
+    if not isinstance(block, dict):
+        return False, "missing"
+    key = next((k for k in keys if k.get("key_id") == block.get("key_id")), None)
+    if key is None:
+        return False, f"signed by unknown key {block.get('key_id')}"
+    statement = block.get("statement") or {}
+    at = statement.get("attested_at") or statement.get("issued_at") or ""
+    if at < key["valid_from"] or (key.get("valid_until") and at > key["valid_until"]):
+        return False, f"key {key['key_id']} was not valid at {at}"
+    try:
+        Ed25519PublicKey.from_public_bytes(b64d(key["public_key"])).verify(
+            b64d(block["signature"]), canonical(statement))
+    except (InvalidSignature, ValueError, KeyError, TypeError):
+        return False, "signature does not match"
+    return True, key["key_id"]
+
+
+# -- server keys ---------------------------------------------------------------------------
+def merge_keys(known: list[dict], published: list[dict]) -> tuple[list[dict], list[str]]:
+    """Accept a newly published key set only if it extends the known one.
+
+    Returns the merged keys and a list of problems (empty when the new set is acceptable).
+    """
+    by_id = {k["key_id"]: k for k in published}
+    problems = []
+    for old in known:
+        new = by_id.get(old["key_id"])
+        if new is None:
+            problems.append(f"key {old['key_id']} is no longer published")
+        elif new["public_key"] != old["public_key"] or new["valid_from"] != old["valid_from"]:
+            problems.append(f"key {old['key_id']} was replaced")
+        elif old.get("valid_until") and new.get("valid_until") != old["valid_until"]:
+            problems.append(f"key {old['key_id']} had its validity window changed")
+    for k in published:
+        if k.get("alg") != "Ed25519":
+            problems.append(f"key {k.get('key_id')} uses unsupported algorithm {k.get('alg')}")
+        elif fingerprint(b64d(k["public_key"])) != k["key_id"][3:]:
+            problems.append(f"key {k['key_id']} does not match its ID")
+    merged = sorted(by_id.values(), key=lambda k: (k["valid_from"], k["key_id"]))
+    return merged, problems
+
+
+def _trusted_path() -> Path:
+    return config.config_dir() / TRUSTED_FILE
+
+
+def load_trusted() -> dict[str, list[dict]]:
+    path = _trusted_path()
+    try:
+        return json.loads(path.read_text(encoding="utf-8")) if path.is_file() else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def trust_server_keys(url: str, published: dict) -> tuple[list[dict], list[str]]:
+    """Merge the server's published keys into the trusted set for ``url``."""
+    trusted = load_trusted()
+    keys, problems = merge_keys(trusted.get(url, []), published.get("keys", []))
+    if not problems:
+        trusted[url] = keys
+        path = _trusted_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(trusted, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return keys, problems
+
+
+def all_trusted_keys() -> list[dict]:
+    """Every key trusted for any server (key IDs are hashes of the keys, so they cannot clash)."""
+    seen: dict[str, dict] = {}
+    for keys in load_trusted().values():
+        for k in keys:
+            seen.setdefault(k["key_id"], k)
+    return list(seen.values())
+
+
+def load_keys_file(path: str | Path) -> list[dict]:
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    keys = data["keys"] if isinstance(data, dict) else data
+    merged, problems = merge_keys([], keys)
+    if problems:
+        raise ValueError(f"{path}: " + "; ".join(problems))
+    return merged
+
+
+def save_project_keys(folder: Path, url: str, keys: list[dict]) -> Path:
+    path = folder / PROJECT_KEYS
+    path.write_text(json.dumps({"server": url, "keys": keys}, indent=2, sort_keys=True) + "\n",
+                    encoding="utf-8")
+    return path
+
+
+# -- developer key -------------------------------------------------------------------------
+def developer_key_path() -> Path:
+    return config.config_dir() / DEVELOPER_KEY
+
+
+def load_developer_key():
+    """The developer's Ed25519 private key: CODEIMPRINT_DEVELOPER_KEY (PEM) or the config
+    folder. Returns None when there is none."""
+    from cryptography.hazmat.primitives import serialization
+    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+    pem = os.environ.get("CODEIMPRINT_DEVELOPER_KEY", "").strip().encode()
+    if not pem and developer_key_path().is_file():
+        pem = developer_key_path().read_bytes()
+    if not pem:
+        return None
+    key = serialization.load_pem_private_key(pem, password=None)
+    if not isinstance(key, Ed25519PrivateKey):
+        raise ValueError("the developer key is not an Ed25519 key")  # noqa: TRY004 (bad input)
+    return key
+
+
+def create_developer_key():
+    from cryptography.hazmat.primitives import serialization
+    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+    key = Ed25519PrivateKey.generate()
+    _write_private(developer_key_path(), key.private_bytes(
+        serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8,
+        serialization.NoEncryption()))
+    return key
+
+
+def public_raw(private_key) -> bytes:
+    from cryptography.hazmat.primitives import serialization
+
+    return private_key.public_key().public_bytes(serialization.Encoding.Raw,
+                                                 serialization.PublicFormat.Raw)
+
+
+def developer_message(digest_hex: str) -> bytes:
+    return DEVELOPER_CONTEXT + bytes.fromhex(digest_hex)
+
+
+def sign_digest(private_key, digest_hex: str) -> dict:
+    raw = public_raw(private_key)
+    return {"public_key": b64e(raw), "signature": b64e(private_key.sign(
+        developer_message(digest_hex)))}

codeimprint_cli/tsa_roots.py

@@ -0,0 +1,137 @@
+"""Pinned root certificates of the time-stamping authorities the client trusts.
+
+A timestamp token counts only if its signer certificate chains to one of these roots
+(or to a certificate passed with `imprint verify --tsa-certs FILE`).
+
+Source: the Mozilla root store, as shipped by Debian `ca-certificates` in the
+python:3.12-slim image and by certifi; both copies are byte-identical. Each root is
+selected by its SHA-256 fingerprint, which matches the value its owner publishes.
+Listed in docs/how-sealing-works.md.
+
+| TSA | Root | SHA-256 | Valid until |
+| --- | --- | --- | --- |
+| DigiCert | DigiCert Trusted Root G4 | 552f7bdcf1a7af9e6ce672017f4f12abf77240c78e761ac203d1d9d20ac89988 | 2038-01-15 |
+| Sectigo | USERTrust RSA Certification Authority | e793c9b02fd8aa13e21c31228accb08119643b749c898964b1746d46c3d4cbd2 | 2038-01-18 |
+| GlobalSign | GlobalSign Root CA - R6 | 2cabeafe37d06ca22aba7391c0033d25982952c453647349763a3ab5ad6ccf69 | 2034-12-10 |
+"""
+
+# DigiCert: DigiCert Trusted Root G4
+# SHA-256 552f7bdcf1a7af9e6ce672017f4f12abf77240c78e761ac203d1d9d20ac89988
+DIGICERT = """\
+-----BEGIN CERTIFICATE-----
+MIIFkDCCA3igAwIBAgIQBZsbV56OITLiOQe9p3d1XDANBgkqhkiG9w0BAQwFADBi
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3Qg
+RzQwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBiMQswCQYDVQQGEwJV
+UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu
+Y29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3QgRzQwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN675F1KPDAiMGkz7MKnJS7JIT3y
+ithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaXbR2rsnnyyhHS5F/WBTxSD1If
+xp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQLt+C8weE5nQ7bXHiLQwb7iDV
+ySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82sNEBfsXpm7nfISKhmV1efVFiO
+DCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4DatpGYQJB5w3jHtrHEtWoYOAMQ
+jdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwhTNS8rhsDdV14Ztk6MUSaM0C/
+CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98FpiHaYdj1ZXUJ2h4mXaXpI8OCi
+EhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppEGSt+wJS00mFt6zPZxd9LBADM
+fRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+9oCw++hkpjPRiQfhvbfmQ6QY
+uKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56rF+NP8m800ERElvlEFDrMcXK
+chYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8oR7FwI+isX4KJpn15GkvmB0t
+9dmpsh3lGwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+hjAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wDQYJKoZIhvcNAQEMBQAD
+ggIBALth2X2pbL4XxJEbw6GiAI3jZGgPVs93rnD5/ZpKmbnJeFwMDF/k5hQpVgs2
+SV1EY+CtnJYYZhsjDT156W1r1lT40jzBQ0CuHVD1UvyQO7uYmWlrx8GnqGikJ9yd
++SeuMIW59mdNOj6PWTkiU0TryF0Dyu1Qen1iIQqAyHNm0aAFYF/opbSnr6j3bTWc
+fFqK1qI4mfN4i/RN0iAL3gTujJtHgXINwBQy7zBZLq7gcfJW5GqXb5JQbZaNaHqa
+sjYUegbyJLkJEVDXCLG4iXqEI2FCKeWjzaIgQdfRnGTZ6iahixTXTBmyUEFxPT9N
+cCOGDErcgdLMMpSEDQgJlxxPwO5rIHQw0uA5NBCFIRUBCOhVMt5xSdkoF1BN5r5N
+0XWs0Mr7QbhDparTwwVETyw2m+L64kW4I1NsBm9nVX9GtUw/bihaeSbSpKhil9Ie
+4u1Ki7wb/UdKDd9nZn6yW0HQO+T0O/QEY+nvwlQAUaCKKsnOeMzV6ocEGLPOr0mI
+r/OSmbaz5mEP0oUA51Aa5BuVnRmhuZyxm7EAHu/QD09CbMkKvO5D+jpxpchNJqU1
+/YldvIViHTLSoCtU7ZpXwdv6EM8Zt4tKG48BtieVU+i2iW1bvGjUI+iLUaJW+fCm
+gKDWHrO8Dw9TdSmq6hN35N6MgSGtBxBHEa2HPQfRdbzP82Z+
+-----END CERTIFICATE-----
+"""
+
+
+# Sectigo: USERTrust RSA Certification Authority
+# SHA-256 e793c9b02fd8aa13e21c31228accb08119643b749c898964b1746d46c3d4cbd2
+SECTIGO = """\
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+"""
+
+
+# GlobalSign: GlobalSign Root CA - R6
+# SHA-256 2cabeafe37d06ca22aba7391c0033d25982952c453647349763a3ab5ad6ccf69
+GLOBALSIGN = """\
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIORea7A4Mzw4VlSOb/RVEwDQYJKoZIhvcNAQEMBQAwTDEg
+MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjYxEzARBgNVBAoTCkdsb2Jh
+bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTQxMjEwMDAwMDAwWhcNMzQx
+MjEwMDAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSNjET
+MBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCAiIwDQYJ
+KoZIhvcNAQEBBQADggIPADCCAgoCggIBAJUH6HPKZvnsFMp7PPcNCPG0RQssgrRI
+xutbPK6DuEGSMxSkb3/pKszGsIhrxbaJ0cay/xTOURQh7ErdG1rG1ofuTToVBu1k
+ZguSgMpE3nOUTvOniX9PeGMIyBJQbUJmL025eShNUhqKGoC3GYEOfsSKvGRMIRxD
+aNc9PIrFsmbVkJq3MQbFvuJtMgamHvm566qjuL++gmNQ0PAYid/kD3n16qIfKtJw
+LnvnvJO7bVPiSHyMEAc4/2ayd2F+4OqMPKq0pPbzlUoSB239jLKJz9CgYXfIWHSw
+1CM69106yqLbnQneXUQtkPGBzVeS+n68UARjNN9rkxi+azayOeSsJDa38O+2HBNX
+k7besvjihbdzorg1qkXy4J02oW9UivFyVm4uiMVRQkQVlO6jxTiWm05OWgtH8wY2
+SXcwvHE35absIQh1/OZhFj931dmRl4QKbNQCTXTAFO39OfuD8l4UoQSwC+n+7o/h
+bguyCLNhZglqsQY6ZZZZwPA1/cnaKI0aEYdwgQqomnUdnjqGBQCe24DWJfncBZ4n
+WUx2OVvq+aWh2IMP0f/fMBH5hc8zSPXKbWQULHpYT9NLCEnFlWQaYw55PfWzjMpY
+rZxCRXluDocZXFSxZba/jJvcE+kNb7gu3GduyYsRtYQUigAZcIN5kZeR1Bonvzce
+MgfYFGM8KEyvAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTAD
+AQH/MB0GA1UdDgQWBBSubAWjkxPioufi1xzWx/B/yGdToDAfBgNVHSMEGDAWgBSu
+bAWjkxPioufi1xzWx/B/yGdToDANBgkqhkiG9w0BAQwFAAOCAgEAgyXt6NH9lVLN
+nsAEoJFp5lzQhN7craJP6Ed41mWYqVuoPId8AorRbrcWc+ZfwFSY1XS+wc3iEZGt
+Ixg93eFyRJa0lV7Ae46ZeBZDE1ZXs6KzO7V33EByrKPrmzU+sQghoefEQzd5Mr61
+55wsTLxDKZmOMNOsIeDjHfrYBzN2VAAiKrlNIC5waNrlU/yDXNOd8v9EDERm8tLj
+vUYAGm0CuiVdjaExUd1URhxN25mW7xocBFymFe944Hn+Xds+qkxV/ZoVqW/hpvvf
+cDDpw+5CRu3CkwWJ+n1jez/QcYF8AOiYrg54NMMl+68KnyBr3TsTjxKM4kEaSHpz
+oHdpx7Zcf4LIHv5YGygrqGytXm3ABdJ7t+uA/iU3/gKbaKxCXcPu9czc8FB10jZp
+nOZ7BN9uBmm23goJSFmH63sUYHpkqmlD75HHTOwY3WzvUy2MmeFe8nI+z1TIvWfs
+pA9MRf/TuTAjB0yPEL+GltmZWrSZVxykzLsViVO6LAUP5MSeGbEYNNVMnbrt9x+v
+JJUEeKgDu+6B5dpffItKoZB0JaezPkvILFa9x8jvOOJckvB595yEunQtYQEgfn7R
+8k8HWV+LLUNS60YMlOH1Zkd5d9VUWx+tJDfLRVpOoERIyNiwmcUVhAn21klJwGW4
+5hpxbqCo8YLoRT5s1gLXCmeDBVrJpBA=
+-----END CERTIFICATE-----
+"""
+
+PINNED_ROOTS = {
+    "DigiCert": DIGICERT,
+    "Sectigo": SECTIGO,
+    "GlobalSign": GLOBALSIGN,
+}