CVE-2026-33699: 
Python vulnerability analysis and mitigation

CVE-2026-33699 is a denial-of-service vulnerability in pypdf, a free and open-source pure-Python PDF library, caused by a possible infinite loop during recovery attempts in the DictionaryObject.read_from_stream method. It affects all pypdf versions prior to 6.9.2 and is triggered only when reading a PDF file in non-strict mode. The vulnerability was reported by researcher kejcao, analyzed by stefan6419846, and disclosed on March 23, 2026, with the fix released the same day. It carries a CVSS v3.1 base score of 7.5 (High) and a CVSS v4.0 base score of 4.6 (Medium) (GitHub Advisory).

The root cause is classified as CWE-835 (Loop with Unreachable Exit Condition / Infinite Loop). Specifically, the DictionaryObject.read_from_stream method in pypdf's PDF parsing logic fails to properly handle certain malformed or crafted PDF structures when operating in non-strict (recovery) mode — particularly errors that should always trigger a hard failure, such as recursion and filter limit errors. Instead of raising an exception, the recovery path re-enters the loop without making progress, resulting in an infinite loop that consumes CPU indefinitely. Exploitation requires only that the target application processes a specially crafted PDF file with non-strict mode enabled; no authentication or user interaction beyond file submission is required (GitHub Advisory, PR #3693).

Successful exploitation causes a denial-of-service condition: the affected process enters an infinite loop, consuming excessive CPU resources and rendering the application unresponsive to legitimate users. There is no impact on confidentiality or data integrity — the vulnerability is purely an availability issue. Applications that automatically process user-supplied or externally sourced PDF files (e.g., document management systems, AI pipelines, web services) are at greatest risk, as a single malicious file can hang the processing thread or worker indefinitely (GitHub Advisory, Feedly).

There is no public proof-of-concept exploit code and no evidence of in-the-wild exploitation at this time (GitHub Advisory). The EPSS score is approximately 0.04% (0.000400), indicating a very low probability of exploitation in the near term. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog. Exploitation is constrained by the requirement that the target application must process PDFs in non-strict mode, which limits the attack surface compared to vulnerabilities with no preconditions.

1. Identify a target: Locate an application or service that uses pypdf (versions < 6.9.2) to process PDF files in non-strict mode — common in document ingestion pipelines, AI/ML platforms, or web upload services.
2. Craft a malicious PDF: Create a specially structured PDF file that contains malformed dictionary objects designed to trigger the recovery path in DictionaryObject.read_from_stream, specifically exploiting conditions such as recursion or filter limit errors that should raise hard errors but instead loop indefinitely in non-strict mode.
3. Submit the file: Upload or deliver the crafted PDF to the target application through any available file submission mechanism (e.g., web upload form, email attachment, API endpoint).
4. Trigger the infinite loop: When the application processes the file using pypdf in non-strict mode, the parser enters an infinite loop, consuming 100% of a CPU core and causing the processing thread or worker to hang indefinitely.
5. Achieve denial of service: The application becomes unresponsive for the affected processing path; repeated submissions can exhaust all available workers, causing a full service outage (GitHub Advisory, PR #3693).

• Process: Python processes consuming sustained 100% CPU on a single core with no progress, associated with PDF processing tasks; processes that do not terminate after an unusually long time when handling a specific PDF file.
• Logs: Application logs showing a PDF processing job that started but never completed or timed out; absence of completion log entries for a submitted PDF file; potential stack traces referencing DictionaryObject.read_from_stream in pypdf.
• File System: Presence of a suspicious or unexpected PDF file in upload directories or processing queues that consistently causes worker hangs when processed.
• Network: Repeated submissions of the same or similar PDF file from an external source to a document processing endpoint, potentially indicating automated exploitation attempts.

The primary remediation is to upgrade pypdf to version 6.9.2 or later, which contains the fix merged via PR #3693 on March 23, 2026 (pypdf Release 6.9.2). For users who cannot upgrade immediately, the patch changes from PR #3693 can be applied manually to the affected DictionaryObject.read_from_stream method (PR #3693). As an additional workaround, configure PDF processing to use strict mode where possible, which prevents the vulnerable recovery code path from being triggered. Restricting the processing of PDF files from untrusted or external sources and implementing process timeouts for PDF parsing tasks can further reduce risk (GitHub Advisory). IBM has also issued an advisory for affected watsonx Orchestrate products (IBM Advisory).

The vulnerability was responsibly disclosed by researcher kejcao and addressed by pypdf maintainer stefan6419846 on the same day (March 23, 2026), reflecting a rapid response from the open-source project (GitHub Advisory). IBM subsequently issued a security advisory acknowledging the impact on its watsonx Orchestrate with watsonx Assistant Cartridge products, indicating downstream vendor awareness (IBM Advisory). The vulnerability was also picked up by automated dependency scanning tools (Dependabot, Mend) across numerous open-source projects that depend on pypdf, prompting widespread upgrade pull requests in the community.