Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify Crow endpoint parsing JSON body
-
DeliveryCraft ~4000-deep nested JSON payload
-
ExploitPOST payload to trigger recursive descent
-
ExecutionExhaust worker-thread stack (STATUS_STACK_OVERFLOW)
-
ImpactProcess terminates, all connections dropped
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Recursion depth limits
|
| Exploitation Conditions | The target Crow application (version <1.3.4) must expose a route that passes attacker-controlled request-body data to crow::json::load() - the published PoC uses a POST /json handler doing exactly this. No authentication, user interaction, or special feature flag is required (PR:N/UI:N). The decisive LIMITING factor is the server's worker-thread stack size: the advisory states the process crashes reliably on Windows (1MB default stack, ~4000 nested objects), whereas Linux's ~8MB default stack resists the demonstrated depth; a reverse proxy that rejects oversized request bodies also prevents the attack. Pre-patch, max_depth was 10000, well above the ~4000 levels needed to overflow a 1MB stack; the fix lowers it to 1024 and adds an explicit depth check returning a parse error. |
| Impact | This is a legitimately actionable availability issue, though not a top-tier emergency. The supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) describes remote, unauthenticated, low-complexity reach with no user interaction, and impact is confined to availability (VA:H; VC:N/VI:N - no data disclosure or integrity loss). The vuln.today decision label is 'this_week', consistent with a serious-but-not-'act_now' DoS. Exploitation status: publicly available exploit code exists (full PoC server and client are published in the GHSA advisory), but there is no CISA KEV listing and no EPSS score in the input, so there is no evidence of active in-the-wild exploitation - treat this as exploit-code-available, not confirmed exploited. A key nuance the raw CVSS score hides: the advisory states the crash is platform-dependent. Windows (1MB default thread stack) dies at roughly 4000 nested objects, whereas Linux's ~8MB default stack is far more resilient to the tested 4000-depth payload, and a reverse proxy enforcing a small request-body limit blunts the attack entirely. So AC:L/VA:H is accurate for a vulnerable Windows deployment, but real-world risk varies sharply by platform and fronting infrastructure. Net: a real priority for Windows-hosted Crow services exposing JSON endpoints, lower practical urgency elsewhere. |
| Exploit ScenarioDerived | An attacker sends a single unauthenticated POST request to any Crow endpoint that calls crow::json::load() on the request body, with a payload of several thousand nested JSON objects (e.g. {"a":{"a":... 4000 deep). The recursive-descent parser consumes ~250 bytes of stack per level, overflowing the 1MB default Windows worker-thread stack and terminating the whole process - a stack overflow is not catchable with try/catch - which drops all active connections. A complete working PoC (client and server) is published in the GHSA advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 24, 2026
Unauthenticated remote attackers can terminate a Crow (CrowCpp) server process by sending an HTTP request body containing thousands of nested JSON objects to any route that passes the body to crow::json::load(). The recursive-descent parser in the Crow headers recursed without an effective depth guard, and a stack overflow is not catchable with try/catch, so the whole process dies and all open connections are dropped rather than a single request failing. The behavior is version-dependent on the deployment: the published PoC crashes a Windows build reliably with roughly 4000 nesting levels against a 1MB default stack, whereas Linux's ~8MB default stack resists the demonstrated depth, and a fronting reverse proxy that rejects oversized bodies prevents the attack. A public proof-of-concept (client and server source) accompanies the GitHub advisory; it is not independently verified as working exploit code, and there is no CISA KEV confirmation of active exploitation. Vendor-released patch: 1.3.4.
RemediationAI
Upgrade to Crow 1.3.4, the vendor-released fix, which reduces the JSON parser's max_depth from 10000 to 1024 and returns a parse error instead of recursing to stack exhaustion; apply it via the v1.3.4 release tag (https://github.com/CrowCpp/Crow/releases/tag/v1.3.4), the commit 6956b7ca93c5df22f5aaccd670e5aa000c0d882b (https://github.com/CrowCpp/Crow/commit/6956b7ca93c5df22f5aaccd670e5aa000c0d882b), and track the advisory at https://github.com/CrowCpp/Crow/security/advisories/GHSA-7x84-xhp8-6cqj. Because Crow is header-only, rebuilding and redeploying every affected service is required - hot-patching a binary is not an option. If upgrading is not immediately possible, the compensating controls named in the advisory are: front the service with a reverse proxy or load balancer that rejects request bodies above a size that can carry a deeply nested payload (trade-off: legitimate large uploads must be re-scoped or routed differently, and the limit must genuinely truncate nesting rather than only total bytes), and run the service on a platform with a larger worker-thread stack such as Linux's ~8MB default, which resists the demonstrated ~4000-level payload (trade-off: this raises the bar rather than removing the bug, since a deep enough body can still overflow, and it does nothing for Windows deployments on the 1MB default). Routes that never call crow::json::load() on untrusted bodies are not reachable through the documented trigger, so validating and parsing bodies with an external parser with its own depth limits is an option for handlers that can be changed.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Crow is a C++ header-only microframework; the flaw lives in the JSON implementation shipped in include/crow/json.h and is classified CWE-674 (Uncontrolled Recursion). Before the fix, the parser's max_depth constant was set to 10000 (json.h around line 887-889 in v1.3.3), but the recursive descent consumed roughly 250 bytes of stack per nesting level, so the nominal limit sat far above the depth actually survivable on a typical thread stack. On Windows, where worker threads default to a 1MB stack, about 4000 nested objects are enough to exhaust the stack and raise STATUS_STACK_OVERFLOW; because stack overflow bypasses C++ exception handling, the entire process terminates instead of the request being rejected with a parse error. The assessed CVSS:3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H reflects a purely availability-targeting attack requiring no credentials, no user interaction and no non-default configuration - only an exposed route that calls crow::json::load() on request-body data, as in the advisory's POST /json handler. Exploitability is therefore a function of the stack size of the deployment, and the trigger as documented is a deliberately crafted deeply nested object chain such as {"a":{"a":...}}, not any deeper structural parsing quirk. The upstream commit 6956b7ca93c5df22f5aaccd670e5aa000c0d882b lowers max_depth to 1024 and adds an explicit depth check that sets a parse error and returns, converting the crash into a 400 Bad Request; a regression test in tests/unittest.cpp reproduces the 4000-level payload and asserts the 400 response.
Know when Crow gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Remote unauthenticated POST with no interaction and low complexity (send nested JSON), causing process termination, so AV:N/AC:L/PR:N/UI:N and A:H with no confidentiality or integrity impact.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Crow before 1.3.4 contains an uncontrolled recursion vulnerability in crow::json::load() that allows remote unauthenticated attackers to crash the server by sending deeply nested JSON. Attackers can send a request body with thousands of nested objects to exhaust the worker thread stack, terminating the process and dropping all connections.
Technical POC Analysis
CWE-674 (Uncontrolled Recursion).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
CrowCpp server deployments using crow::json::load() are vulnerable to unauthenticated remote denial-of-service via deeply nested JSON. Attackers can crash the entire server process, disrupting all users and services, but exploitation requires specific conditions (e.g., Windows) and no active exploitation has been confirmed. Leadership should prioritize patching to prevent availability incidents, especially for internet-facing services.
Apply vendor patch. If immediate patching is not possible, enforce request body size limits via a reverse proxy, and consider restricting access to trusted networks.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
HTTP applications (servers) based on Crow through 1.0+4 may allow a Use-After-Free and code execution when HTTP pipelini
Crow before 1.0+4 has a heap-based buffer overflow via the function qs_parse in query_string.h. Rated critical severity
HTTP applications (servers) based on Crow through 1.0+4 may reveal potentially sensitive uninitialized data from stack m
All versions of the package crow are vulnerable to HTTP Response Splitting when untrusted user input is used to build he
EUVD-2026-109269
GHSA-88wj-6c62-8f7x
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB