CVE-2026-69249

The vulnerability in python-cryptography's certificate chain validation (CVE-2026-69249) is not a traditional exploit — it's an algorithmic complexity attack that exploits the gap between termination guarantees and meaningful availability guarantees. Developers added a max depth limit to prevent unbounded recursion, which solves the "will this terminate?" problem but leaves the branching factor uncontrolled. A certificate chain with n duplicate intermediate CAs doesn't produce n times the work; it produces work proportional to the power set of those duplicates. The recursion terminates, but not in any timeframe an attacker can't make arbitrarily expensive. This matters because correctness tests pass: invalid chains are rejected, self-signed certs are handled properly, validation integrity is sound. The defect lives in performance under adversarial input — a region where standard fuzzing and static analysis routinely fail to detect issues. The CVSS 8.7 rating treats all availability impacts as equivalent, but CPU exhaustion from crafted certificate chains is fundamentally different from a crash or memory corruption in both exploitability and operational response. When evaluating the 49.0.0 fix, you need to answer two questions. First, does it use memoization to prevent re-analyzing the same certificate, or does it impose time budgets — or both? Second, and this is critical: memoization introduces timing side-channel risk. If an attacker can measure whether certificate C was previously validated (cached, fast) versus freshly evaluated (uncached, slow), they gain oracle access to certificate identity relationships within a chain. That's a potential confidentiality failure compounding silently over months, which is categorically different from the availability DoS you're fixing. Check your own certificate processing code paths for the same pattern: recursive validation with depth caps but no deduplication. This isn't specific to python-cryptography — it's a recurring cognitive pattern where developers conflate depth complexity with branching complexity. The fix is trivial (memoization with proper scope tracking). The failure is that no tooling flags "recursive function without memoization" as a DoS risk at code review time.

Reviewed through automated stages and approved by a human before publication.