AI and data stack advisories

Severe, 6 weeks2431Projects328

2431 severe, 6 weeks · 328 projects

NLTKGHSA-w3pv-xfw4-ghr7

NLTK: Uncontrolled recursion in semantic-logic type parser causes denial of service via nested type strings

NLTK

CVE-2026-129226 · Published Nov 19, 2026 · updated Nov 20, 2026

Medium5.3
Fix: upgrade to 3.10.4 or later
GitHub advisory

Root Cause

The semantic-logic type parser read_type (nltk/sem/logic.py:866) recurses on both

halves of every <a,b> complex type (nltk/sem/logic.py:882-884) with no depth or length

bound , only an isinstance assertion and a parenthesis-balance assertion. The

LogicParser.MAX_PARSE_DEPTH guard (nltk/sem/logic.py:107,294) protects the expression

parser but never runs on the read_type path, which is reached directly by the public

Type.fromstring classmethod and by signature-string type checking.

Impact

An application that parses an untrusted type string, or type-checks an expression against

an attacker-influenced signature, aborts with an unhandled RecursionError, terminating

the affected operation or request worker (denial of service, CWE-674). The recursion is

pure Python, yielding a catchable RecursionError rather than memory corruption or code

execution. Confidentiality and integrity are unaffected. Exposure is narrower than a

general-purpose parser because the input must reach a type-string or signature parameter.

Attack Chain

1. The application calls nltk.sem.logic.Type.fromstring(s) (nltk/sem/logic.py:736) , or

Expression.typecheck(signature) / `Expression.fromstring(expr, type_check=True,

signature=...), which reach read_type` for each type-string signature value

(nltk/sem/logic.py:1080) , with a deeply nested type...

Affected versions

PackageAffectedFixed in
nltk
PyPI
< 3.10.43.10.4
Details and references

## Root Cause The semantic-logic type parser `read_type` (`nltk/sem/logic.py:866`) recurses on both halves of every `<a,b>` complex type (`nltk/sem/logic.py:882-884`) with no depth or length bound , only an `isinstance` assertion and a parenthesis-balance assertion. The `LogicParser.MAX_PARSE_DEPTH` guard (`nltk/sem/logic.py:107,294`) protects the expression parser but never runs on the `read_type` path, which is reached directly by the public `Type.fromstring` classmethod and by signature-string type checking. ## Impact An application that parses an untrusted type string, or type-checks an expression against an attacker-influenced signature, aborts with an unhandled `RecursionError`, terminating the affected operation or request worker (denial of service, CWE-674). The recursion is pure Python, yielding a catchable `RecursionError` rather than memory corruption or code execution. Confidentiality and integrity are unaffected. Exposure is narrower than a general-purpose parser because the input must reach a type-string or signature parameter. ## Attack Chain 1. The application calls `nltk.sem.logic.Type.fromstring(s)` (`nltk/sem/logic.py:736`) , or `Expression.typecheck(signature)` / `Expression.fromstring(expr, type_check=True, signature=...)`, which reach `read_type` for each type-string signature value (`nltk/sem/logic.py:1080`) , with a deeply nested type string such as `"<" * n + "e,e" + ">" * n`. 2. `Type.fromstring` passes the string straight to `read_type` with no length or depth check (only assertions on type and parenthesis balance). 3. `read_type` recurses on both halves of each `<a,b>` level, consuming one stack frame per nesting level; the `MAX_PARSE_DEPTH` guard on the separate `LogicParser` class does not execute here. 4. Once the depth exceeds the interpreter recursion limit, an unhandled `RecursionError` propagates out of the public API. ## Bypass Evidence Running the shipped `read_type`/`ComplexType`/`Type` source verbatim at the default recursion limit: depth 5 parses cleanly to a `ComplexType` (both assertions satisfied at every level), while depth 5000 raises an unhandled `RecursionError`. The clean shallow parse shows the failure is depth-driven rather than an assertion failure. A code review confirms the `MAX_PARSE_DEPTH` bound lives on the `LogicParser` class and is not applied to `read_type`, whose own module docstring for that guard explicitly names uncontrolled recursion (CWE-674) as the risk it addresses. ## Suggested Fix Apply a recursion-depth bound to `read_type` (a depth argument raising a bounded `ValueError` past a configurable maximum), matching the intent of the existing `LogicParser.MAX_PARSE_DEPTH` guard so that both the expression and type-string paths are protected. Reported by pi (GitHub: @manus-pi). ## Fix status (2026-09-28) Status: MERGED on develop (unreleased; v3.10.3 of 2026-08-12 predates the fix). PR: #3885 "Bound recursion depth in parsers and traversal helpers" (ekaf), merged 2026-09-11, merge commit e521ecafc on develop. Fix commit: 2f4f0d47e (nltk/sem/logic.py: read_type is bounded by LogicParser.MAX_PARSE_DEPTH) with a8036c5e7 (fixes a NameError in that bound). Probe: nltk/test/unit/security_probes/ghsa_w3pv_xfw4_ghr7.py (added in 2a6704952 on that PR); verdict on develop 2fa3f48fe: FIXED (bounded (LogicalExpressionException)). Release: none yet; no release tag contains e521ecafc.

CVSS 3.1
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
Severity from
GitHub (reviewed advisory)
Weakness
CWE-674
Also known as
CVE-2026-129226

More NLTK advisories

All NLTK