CVE-2026-69249: 
CBL Mariner vulnerability analysis and mitigation

CVE-2026-69249 is a denial-of-service vulnerability in the python-cryptography package (pyca/cryptography) caused by exponential path-building when processing certificate chains containing duplicate self-signed intermediate certificates. It affects all versions up to and including 48.0.0, and is fixed in version 49.0.0. The vulnerability was identified by Trail of Bits as part of the Patch The Planet project in collaboration with OpenAI, with the finding attributed primarily to the Codex coding agent; it was published on July 31, 2026. It carries a CVSS v4.0 base score of 8.7 (High) (Github Advisory, GHSA Advisory).

The root cause is classified as CWE-400 (Uncontrolled Resource Consumption). The vulnerable function build_chain_inner in the Rust-based cryptography-x509-verification crate recursively iterates over potential certificate issuers without de-duplicating previously analyzed candidates. When an attacker supplies a certificate chain containing multiple duplicate copies of a self-signed CA certificate, the recursive processing re-evaluates the same candidate at each depth level, producing an exponential blowup in computation. While the maximum chain depth limit prevents unbounded recursion, testing showed that as few as 4 duplicate certificates with a max depth of 7 could cause processing to exceed 5 seconds, and higher combinations resulted in timeouts. A public proof-of-concept script is included in the advisory that demonstrates the timing amplification using Python's cryptography.x509.verification API (GHSA Advisory, Fix PR).

Exploitation of this vulnerability exclusively affects availability — confidentiality and integrity of validated data are not impacted, as the correctness of certificate validation is preserved. An attacker who can supply attacker-controlled certificate chains to an application using cryptography's X.509 path verification API can cause significant CPU resource exhaustion, potentially rendering the service unresponsive or severely degraded. In many real-world deployments, certificate chain data may be user-controlled (e.g., during TLS client authentication or certificate upload workflows), making this a practical denial-of-service amplification vector (Github Advisory).

A proof-of-concept script is publicly available as part of the official security advisory, demonstrating the exponential timing blowup with crafted certificate chains. The NVD SSVC assessment classifies exploitation as "poc" and the vulnerability as "automatable," meaning no user interaction or special privileges are required — an unauthenticated network attacker can trigger the condition. The EPSS score is approximately 0.19% (9th percentile), indicating a currently low but non-negligible probability of exploitation in the wild. There is no known evidence of active in-the-wild exploitation or threat actor attribution at this time, and the vulnerability is not listed in the CISA KEV catalog (Github Advisory, GHSA Advisory).

1. Identify target: Locate an application that uses python-cryptography <= 48.0.0 and exposes an endpoint that accepts and validates X.509 certificate chains (e.g., TLS mutual authentication, certificate upload, or OCSP/CRL processing).
2. Generate malicious certificate material: Using the public PoC script from the advisory, generate a self-signed looping CA certificate and a leaf certificate signed by it. Also generate an unrelated trust anchor that is not in the chain.
3. Craft the malicious chain: Construct a certificate chain containing multiple duplicate copies of the self-signed CA (e.g., [looping_ca] * 4 or more), paired with the leaf certificate.
4. Submit the chain: Send the crafted certificate chain to the target application's verification endpoint. The application's call to verifier.verify(leaf, [looping_ca] * N) triggers the vulnerable build_chain_inner recursive path-building logic.
5. Trigger resource exhaustion: The recursive function re-evaluates the duplicate CA candidate at each depth level without de-duplication, causing exponential CPU consumption. With sufficient duplicates and max depth, processing exceeds 5 seconds per request, enabling a sustained denial-of-service with minimal attacker bandwidth (GHSA Advisory).

• Network: Repeated TLS handshake attempts or certificate submission requests from the same source IP, particularly with unusually large or structurally anomalous certificate chains; connections that remain open for extended periods (>5s) during certificate validation.
• Process/System: Sustained high CPU utilization on processes running Python applications that use cryptography's X.509 verification API; worker threads or processes becoming unresponsive or timing out during certificate validation operations.
• Logs: Application logs showing repeated VerificationError or chain validation failures accompanied by abnormally long processing times; log entries referencing chain construction exceeds max depth or Exceeded maximum signature check limit (the latter only in patched versions) may indicate probing activity.
• File System: Presence of the public PoC script (cryptography benchmark script using PolicyBuilder, Store, and DNSName with duplicate intermediates) on attacker-controlled or compromised systems (GHSA Advisory).

The primary remediation is to upgrade python-cryptography to version 49.0.0 or later, which introduces a signature validation budget (capped at 128 signature checks per path construction attempt) that prevents the exponential blowup. The fix also improves candidate ordering by AKI/SKI match likelihood to make best use of the budget. No configuration-based workaround is available for unpatched versions; operators should prioritize upgrading, especially for applications that accept user-supplied certificate chains. Detection is available via Qualys (ID: 5016625) and Nessus (ID: 331890) (Github Advisory, Fix PR, Fix Commit).

The vulnerability was discovered by Trail of Bits as part of the Patch The Planet project in collaboration with OpenAI, with the finding credited to the Codex AI coding agent — notable as an example of AI-assisted security research identifying a real vulnerability in a widely used cryptographic library. The fix was merged by the pyca/cryptography maintainers promptly after disclosure. The NixOS/nixpkgs project opened a tracking issue for backporting the fix, and downstream projects such as connectedhomeip flagged the issue for remediation, reflecting broad ecosystem awareness (GHSA Advisory, Fix PR).