Description

NLTK versions before 3.10.0 contain a regular expression denial of service vulnerability in Text.findall() and TokenSearcher.findall() methods that accept user-supplied regular expressions without validation or timeout. Attackers can supply crafted regex patterns that cause catastrophic backtracking, resulting in indefinite CPU saturation and denial of service to all users of the Python process.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "7.5",
  "pubDate": "2026-08-26T11:16:39.950Z",
  "pubdate": "2026-08-26T11:16:39.950Z",
  "executiveSummary": "NLTK versions prior to 3.10.0 are susceptible to a Regular Expression Denial of Service (ReDoS) vulnerability within the Text.findall() and TokenSearcher.findall() methods.\nThe vulnerability arises due to the library's acceptance of unvalidated, user-supplied regular expression patterns without enforcing execution timeouts.\nAn unauthenticated attacker can exploit this flaw by submitting a specially crafted regex payload designed to trigger catastrophic backtracking within the underlying Python regex engine.\nSuccessful exploitation results in indefinite CPU saturation, effectively halting the Python process and denying service to all concurrent users.\nThis vulnerability poses a significant risk to applications utilizing NLTK to process untrusted input, as it enables trivial resource exhaustion attacks without requiring elevated privileges.",
  "technicalDetails": "The root cause of this vulnerability lies in the implementation of the findall() methods in the Text and TokenSearcher classes within NLTK. These methods process user-provided regex patterns against textual data without implementing input sanitization or regex timeout mechanisms. This design choice leaves the application vulnerable to ReDoS attacks, where malicious patterns exploit the non-deterministic finite automaton (NFA) regex engine's backtracking behavior.\nCatastrophic backtracking occurs when a regex pattern contains ambiguous overlapping quantifiers or nested alternations. When a string that does not fully match the regex is processed, the engine may explore an exponential number of paths to determine that no match exists. This process consumes excessive CPU cycles, leading to thread or process hang.\nThe attack flow begins when an application accepts external input intended for use with Text.findall() or TokenSearcher.findall(). An attacker injects a malicious payload—often characterized by repeated character classes or nested quantifiers (e.g., (a+)+)—as the regex pattern. Once the NLTK method initiates processing, the Python interpreter becomes trapped in the backtracking loop, pinning the CPU at 100% capacity.\nSince Python's Global Interpreter Lock (GIL) is held during this computation, the entire Python process—including other threads handling legitimate requests—becomes unresponsive. This results in a complete denial of service for the affected process. No authentication or specific privilege level is required to initiate the attack; the only prerequisite is the ability to influence the input string used in the vulnerable method calls.\nAffected versions include all NLTK releases prior to 3.10.0. The vulnerability is intrinsic to the library's handling of search patterns, meaning any system providing an interface to supply custom regexes to these specific methods is exposed."
}