7.5

CVSS Score

3.1

-

CVSS Score

Basic Information

Concerned about an active attack path?

Talk to our security experts and see Miggo in action.

Miggo Vulnerability Database

→

CVE-2026-46374

CVE-2026-46374: SQLFluff: Uncontrolled Resource Consumption in Parser

SQLFluff is a modular SQL linter and auto-formatter with support for multiple dialects and templated code. Prior to version 4.2.0, in deployments where untrusted users can provide SQL queries to be linted, an untrusted user can submit a malicious long query to any application using the parser to trigger a Denial of Service through resource exhaustion. This issue has been patched in version 4.2.0.

(GitHub Advisory)

Miggo Vulnerability Database

→

CVE-2026-46374

CVE-2026-46374:

7.5

CVSS Score

3.1

-

CVSS Score

Basic Information

Is this CVE running in your environment?

Easily map the attack path and prioritize which CVEs are a threat to your organization

Validate Exposure

Technical Details

SSVC / BOD 26-04 ↗

Exploitation NoneAutomatable YesTech Impact Partial

Select your environment

→SSVCDeferfix on upgrade

Runtime reachability resolves your actual outcome.Book a demo

Package Name	Ecosystem	Vulnerable Versions	First Patched Version
sqlfluff	pip	< 4.2.0	4.2.0

Technical Details

Vulnerability Intelligence
Miggo AI

Root Cause Analysis

The vulnerability, CVE-2026-46374, is an uncontrolled resource consumption issue in the SQLFluff parser. An attacker could provide a specially crafted, large SQL query that would cause the parser to consume excessive memory and CPU, leading to a Denial of Service. This was possible because the parsing process, in both the Python and the experimental Rust implementations, did not have a limit on the number of nodes it could create in the parse tree.

The patch, introduced in version 4.2.0, mitigates this by adding a configurable limit, max_parse_nodes, which defaults to 100,000. The analysis of the patch commit 68321612f51ac62a6d04ab3e83d72d6f7cf29e36 reveals how this limit is enforced.

The core of the fix involves modifying the ParseContext to track the number of nodes created. The MatchResult.apply function, which is responsible for recursively building the parse tree, was updated to increment a counter and check it against the max_parse_nodes limit on each invocation. If the limit is exceeded, a SQLParseError is raised, terminating the parsing process.

The key vulnerable functions identified are the primary entry points and core recursive components of the parsing engine. Functions like Linter._parse_tokens and Parser.parse initiate the process, while MatchResult.apply is where the unbounded node creation occurred. The RustParser.parse function serves as the equivalent entry point for the Rust implementation, which received a parallel fix. During an exploit, these functions would be active on the stack, consuming resources until the system is exhausted.

Vulnerable functions

Linter._parse_tokens

src/sqlfluff/core/linter/linter.py

This function is one of the main entry points for parsing. The patch adds a pre-emptive check to abort parsing if the number of tokens exceeds the `max_parse_nodes` limit, preventing the parser from attempting to process a potentially malicious and oversized input. Before this check, the function would proceed to the main parsing logic which lacked resource controls.

Parser.parse

src/sqlfluff/core/parser/parser.py

This is the core entry point for the Python-based parser. The vulnerability lies in its previously unbounded execution. The patch modifies it to initialize (`seed`) the parse node counter within the `ParseContext`. This counter is then used throughout the parsing process to enforce the new resource limit. Without this seeding, the limit checks would not function correctly.

MatchResult.apply

src/sqlfluff/core/parser/match_result.py

This function is called recursively to construct the parse tree by turning a `MatchResult` into concrete `BaseSegment` objects. This is where the unbounded growth of the parse tree occurred. The patch adds calls to `increment_parse_nodes`, which checks against the `max_parse_nodes` limit and raises an error if exceeded, directly mitigating the resource consumption vulnerability.

BaseFileSegment.root_parse

src/sqlfluff/core/parser/segments/file.py

This method is the top-level parsing routine for a file. It was modified to pass the `parse_context` down into the `MatchResult.apply` method. This change is critical for propagating the resource limits down through the recursive parsing process. It also directly increments the node count for segments it creates.

RustParser.parse

src/sqlfluff/core/parser/rust_parser.py

This function is the Python entry point for the experimental Rust parser. It was vulnerable to the same uncontrolled resource consumption issue. The patch ensures that the `max_parse_nodes` configuration is read and passed to the underlying Rust parser instance, which now contains the logic to enforce this limit during its execution.

Vulnerability Intelligence
Miggo AI

Unlock WAF rules for this CVE

Generate vendor-ready rules for the observed attack patterns, plus reasoning and safe deployment guidance

Get WAF rules

WAF Protection Rules

WAF Rule

W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.W** rul*s *v*il**l* *or Mi**o *ustom*rs only.

Reasoning

*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.*v*il**l* *or Mi**o *ustom*rs only.