Skip to main content

Crow CVE-2026-116011

| EUVDEUVD-2026-109269 HIGH
Uncontrolled Recursion (CWE-674)
2026-10-24 VulnCheck GHSA-88wj-6c62-8f7x
8.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify Crow endpoint parsing JSON body
  2. Delivery
    Craft ~4000-deep nested JSON payload
  3. Exploit
    POST payload to trigger recursive descent
  4. Execution
    Exhaust worker-thread stack (STATUS_STACK_OVERFLOW)
  5. Impact
    Process 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.7% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Crow 0 <1.3.4

Affected Packages

euvd crow fix: 1.3.4

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

Vendor (VulnCheck) PRIMARY 8.7 HIGH
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
vuln.today AI 7.5 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.7%
Top 48% exploitable
Prevalence
Low
niche header-only C++ micro-framework, limited production web footprint
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.7%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

45
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy