Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach service parsing untrusted JSON
-
DeliverySubmit truncated JSON closing nested array/object
-
ExploitTrigger buf[len] read past buffer via unpadded parse
-
ExecutionHeap OOB read crashes process
-
ImpactDenial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires the target application to parse attacker-supplied JSON via simdjson 4.6.1's unpadded parse path (dom::parser::parse_unpadded, i.e. the UNPADDED=true branch of walk_document); applications using the standard padded parse API are not exposed. The malicious input must be a truncated JSON document whose final structural token closes a nested array or object, so that the buffer is exhausted exactly when the iterator reads buf[len]. Limiting factors: the impact is confined to availability (process termination / DoS), a single-byte OOB read may not fault on over-allocated heap buffers, and exploitation depends entirely on the deployment choosing the unpadded parsing mode. |
| Impact | This is a low-to-moderate real-world priority despite the 6.5 CVSS. All impact is availability-only: the CVSS vector (AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H) and the description agree the outcome is a single-byte heap out-of-bounds read that at worst crashes the process (DoS) - there is no confidentiality or integrity impact (C:N/I:N), so no code execution or data theft. Signals are consistent and point toward low urgency: EPSS is 0.17% (6th percentile), the CVE is NOT in CISA KEV, and there is no public exploit - exploitation status is 'no public exploit identified at time of analysis.' The one nuance the raw score hides is that the flaw is specific to the unpadded parsing path (dom::parser::parse_unpadded / walk_document with the UNPADDED template branch introduced by the fix); applications using the standard padded parse API are not affected, which materially narrows the exposed population below what AV:N/PR:N implies. A one-byte OOB read on a typically over-allocated heap buffer also frequently will not fault at all, making 'A:H' somewhat optimistic. Net: a legitimate hardening fix for services that parse untrusted JSON via the unpadded path, but not an emergency. |
| Exploit ScenarioDerived | An attacker sends a specially crafted, truncated JSON document (whose final structural token closes a nested array or object) to a service that parses untrusted input using simdjson's unpadded parse path. walk_document reads buf[len] one byte past the exhausted buffer, causing a heap OOB read that may terminate the application, denying service. No public exploit code exists, though the triggering issue and fix are documented in the project's GitHub issue #2815 and PR #2817. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 29, 2026
A one-byte heap out-of-bounds read in simdjson 4.6.1 lets remote, unauthenticated attackers crash any application that parses attacker-supplied JSON through the unpadded DOM API (dom::parser::parse_unpadded). The flaw is a CWE-125 out-of-bounds read in which json_iterator::walk_document() dereferences buf[len] after the input buffer has been exhausted, causing process termination and a denial-of-service condition with no confidentiality or integrity impact (CVSS: 6.5, AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H). Per available intelligence there is no public exploit code and no confirmed active exploitation (not in CISA KEV), and EPSS is only 0.17% (6th percentile); exploitation further requires user interaction and, critically, that the target deployment has chosen the unpadded parsing path rather than the standard padded parse API.
RemediationAI
Upstream fix available (PR/commit); released patched version not independently confirmed. The authoritative remediation is commit 20b28712ffce8320237b75a587d35a2e89140577 (pull request https://github.com/simdjson/simdjson/pull/2817, tracked by issue https://github.com/simdjson/simdjson/issues/2815), which adds an UNPADDED template parameter to json_iterator::peek()/advance()/walk_document() so that a structural index >= dom_parser.len returns a static zero sentinel rather than buf[len]; rebuild against that commit or a later release once a tagged version containing it is published, and vendor the patch if you consume simdjson as a submodule or static dependency. If immediate patching is not possible, the highest-value compensating control is to stop using dom::parser::parse_unpadded() and switch to the classic padded parse() API - its trade-off is that callers must allocate SIMDJSON_PADDING extra bytes and copy the input into a padded buffer, adding a copy and a small memory overhead per document, but it structurally removes the out-of-bounds read because the padding bytes are legally readable. A secondary mitigation is to reject or pre-screen truncated documents at the application boundary (for example, verify the input is well-formed and ends with a balanced closing bracket/brace, or cap document size and reject inputs whose final token closes an unterminated nested array or object) before handing them to simdjson; this costs an extra validation pass and can be bypassed if the pre-screener is not as strict as simdjson, so it should be treated as defense in depth rather than a substitute for the fix. Because the impact is limited to availability - a single-byte over-read that often lands in over-allocated heap memory and may not fault at all - operators should also run JSON-parsing services under process supervision with restart-on-crash and per-request memory/time limits to contain the denial-of-service effect. There is no vendor advisory indicating a workaround, and no public exploit code is currently identified, so remediation should be prioritized by exposure: systems that expose the unpadded parse path to untrusted JSON first, padded-API-only users later.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
simdjson is a high-throughput C++ JSON parser that relies on SIMD-friendly input padding: the classic padded parse API assumes the caller has allocated SIMDJSON_PADDING extra bytes past the logical end of the buffer so that wide loads never touch unmapped memory. The newer unpadded parse path (dom::parser::parse_unpadded) removes that requirement and instead must explicitly guard every access. Internally, stage 1 emits a sentinel structural index equal to len when the document is exhausted, and stage 2's json_iterator::peek()/advance() historically returned &buf[*(next_structural)] unconditionally. In simdjson 4.6.1 that meant that a truncated JSON document whose final structural token closes a nested array or object could cause walk_document() to evaluate buf[len] - one byte past the end of the validated input - producing a heap out-of-bounds read (CWE-125). The upstream fix threads a new bool UNPADDED template parameter through walk_document(), peek() and advance(); when UNPADDED is true it checks whether the structural index is >= dom_parser.len and, if so, returns a pointer to a static zero sentinel instead of buf[idx], letting the parser fail cleanly rather than read out of bounds. tape_builder.h was updated to instantiate walk_document<STREAMING, true> for the unpadded path and <STREAMING, false> for the padded path, and a regression test was added to tests/dom/unpadded_tests.cpp. The CPE supplied by the feed is a placeholder (cpe:2.3:a/n/a:n/a:*) and the EUVD affected-version field is also 'n/a n/a', so the vendor's GitHub issue #2815 and PR #2817 are the authoritative sources for the affected artifact.
Know when N A 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
AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H
Remotely supplied JSON (AV:N/PR:N) processed via the unpadded path (UI:R) yields only a crash, so C:N/I:N/A:H; complexity is low to craft the truncated document.
Primary rating from Vendor (mitre).
CVSS VectorVendor: mitre
Lifecycle Timeline
3DescriptionCVE.org
simdjson 4.6.1 contains a one-byte out-of-bounds read vulnerability in dom::parser::parse_unpadded(). A specially crafted truncated JSON document whose final structural token closes a nested array or object can cause json_iterator::walk_document() to access buf[len] after the input buffer has been exhausted. This results in a heap out-of-bounds read and may cause application termination, leading to denial of service.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
LibreNMS before 24.10.0 allows a remote attacker to execute arbitrary code via OS command injection involving AboutContr
Reachable assertion in Open5GS up to version 2.7.6 allows remote unauthenticated attackers to crash the Diameter CER han
A Command Injection issue in the payload build page in BYOB (Build Your Own Botnet) 2.0 allows attackers to execute arbi
Denial of service in Open5GS 2.7.6 and earlier allows network-adjacent attackers with low-privilege Diameter Gx peer acc
Denial of service in Open5GS HSS (Home Subscriber Server) versions 2.7.0 through 2.7.6 is triggered remotely by manipula
Remote command injection in Control Web Panel allows unauthenticated attackers to execute arbitrary OS commands as root
LINQPad before 5.52.01 Pro edition is vulnerable to Unsafe Deserialization in LINQPad.AutoRefManager::PopulateFromCache(
Remote code execution in dash-uploader (Python package for Plotly Dash) versions 0.1.0 through 0.7.0a2 allows unauthenti
Command injection in LiteLLM 1.18.10 lets attackers who can configure MCP (Model Context Protocol) servers supply arbitr
SQL injection in AzuraCast's backup restore flow (versions up to and including 0.23.7) lets an attacker achieve privileg
Arbitrary file read in Yu AI Code Mother v4.3 lets anonymous, remote attackers retrieve files outside the intended previ
Remote code execution in APScheduler (all versions through 3.10.x and 4.0.0a5) is achievable when applications deseriali
EUVD-2026-86284
GHSA-w8jv-57mm-8396
NVD
CVE.org
EPSS
Exploit-DB