Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit JSON ending in a decimal point to parser
-
ExploitOver-read past buffer in __flatcc_json_parser_number
-
ImpactCrash application when buffer ends at unmapped page
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 | The attacker must be able to supply untrusted JSON that terminates immediately after a decimal point (e.g. a bare '3.') to a flatcc-generated JSON parser; this triggers the one-byte over-read in __flatcc_json_parser_number. The crash only materializes when the input buffer ends exactly at an unmapped memory page (reflected as AT:P in the CVSS 4.0 vector) - otherwise the over-read is benign - so the practical limiting factor is the victim process's memory/allocation layout, which is not fully under attacker control. No authentication or user interaction is required (PR:N, UI:N), and the only impact is availability (process crash); there is no confidentiality or integrity effect. Applicable to flatcc 0 through 0.6.4 using the JSON parser runtime. |
| Impact | This is a genuine but moderate-priority issue, not a high-severity emergency. The CVSS 4.0 base score is 6.3 (medium) with an availability-only impact (VA:L; VC:N, VI:N) - the flaw crashes applications but does not leak data or allow code execution, so the CWE-125 out-of-bounds read is a denial-of-service primitive rather than an information-disclosure one. Signals are internally consistent and point to limited real-world urgency: EPSS is 0.38% (32nd percentile, low), the CVE is NOT in CISA KEV, and the vuln.today decision label is 'this_month' rather than act_now/emergency. The one factor raising realistic exploitability is AV:N/PR:N/UI:N - any application feeding attacker-controlled JSON to a flatcc-generated parser is reachable remotely without authentication. However, the 4.0 vector's AT:P (Attack Requirement: Present) correctly reflects that a crash only occurs when the input buffer happens to end at an unmapped memory page, so exploitation is not fully reliable. A public PoC reference exists (HackMD writeup and VulnCheck advisory) but it is not verified as working exploit code. Note one conflicting signal: the 'Information Disclosure' tag contradicts the CVSS metrics (VC:N) and the description, which states the bug crashes applications - treat this as a DoS, not data disclosure. |
| Exploit ScenarioDerived | An attacker sends untrusted JSON ending immediately after a decimal point (e.g. '3.') to an application that uses a flatcc-generated JSON parser; __flatcc_json_parser_number reads one byte past the end of the input buffer, and when the buffer ends exactly at an unmapped page the process crashes, causing a denial of service. Exploitation is remote and unauthenticated (PR:N) but reliability depends on the victim's memory layout (AT:P). A public PoC reference exists (HackMD analysis, VulnCheck advisory); it is not verified as working exploit code. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
An out-of-bounds read in flatcc's JSON parser runtime (__flatcc_json_parser_number, src/runtime/json_parser.c) affects versions 0 through 0.6.4 and lets an attacker who supplies untrusted JSON that terminates immediately after a decimal point force a one-byte read past the end of the input buffer. The realistic outcome is a process crash, and only when the buffer ends exactly at an unmapped page; otherwise the over-read is benign, which is why the assessed severity is denial-of-service with a high attack-complexity precondition rather than a high-severity emergency. No authentication or user interaction is required, but there is no confidentiality or integrity impact. This is not in CISA KEV and EPSS is low at 0.38% (32nd percentile); a public technical write-up of the flaw has been published, but no working exploit code is confirmed, and the vendor fix is an upstream commit rather than a confirmed tagged release.
RemediationAI
Apply the upstream fix commit 356792dc155a9e685acdfe0ec1e209bdadcb4ab9 (https://github.com/dvidelabs/flatcc/commit/356792dc155a9e685acdfe0ec1e209bdadcb4ab9), which adds the missing 'buf == end' bounds check in __flatcc_json_parser_number; the patch is confirmed in the vendor's source tree but a tagged release containing it is not confirmed in the available data, so consumers should track https://github.com/dvidelabs/flatcc for the first release after 0.6.4 and pin to that tag once it exists, and meanwhile may vendor the patched json_parser.c. Per the vendor advisory (https://www.vulncheck.com/advisories/flatcc-through-0.6.4-out-of-bounds-read-via-flatcc-json-parser-number) the update is the documented remediation; the sources describe no separate vendor workaround. Because the crash requires the input buffer to end exactly at an unmapped page, the exposure is layout-dependent, so services that cannot rebuild immediately should treat this as a moderate availability risk (decision: patch this month) and prioritize the rebuild on any endpoint that parses untrusted JSON with a flatcc-generated parser. There is no CISA KEV listing and EPSS is 0.38%, so this is not an emergency, but the fix is a one-line change and cheap to adopt.
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
flatcc is a C compiler and runtime for FlatBuffers, and its generated parsers rely on a shared runtime module, src/runtime/json_parser.c, to walk JSON text. In __flatcc_json_parser_number, the numeric scanning loop dereferenced the current byte to test whether it was a digit without first checking whether the pointer had already reached the end of the buffer. For most inputs the loop only reads bytes it has already validated, but a number that ends immediately after a decimal point (a bare fragment such as '3.') advances the pointer to the terminator and then performs one read past the end. That is CWE-125, an out-of-bounds read of a single byte; the value read is only used for a character-class comparison, so there is no disclosure of buffer contents to the attacker, only the potential for a segmentation fault when the byte lands on an unmapped page. The upstream commit 356792dc155a9e685acdfe0ec1e209bdadcb4ab9 (CHANGELOG entry: 'Guard against adversarial buffer overrun in JSON numeric parser (FINDING 1 in #400)') fixes it with a short-circuit bounds test, changing the condition to 'if (buf == end || *buf < '0' || *buf > '9')'. Exposure is therefore tied to any application that feeds attacker-controlled JSON to a flatcc-generated parser, and the practical trigger depends on the victim process's allocation and memory layout, which the attacker does not fully control.
Know when Flatcc 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:P/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
Remote unauthenticated JSON input (AV:N/PR:N/UI:N); AC:H because the crash depends on the buffer ending at an unmapped page, and impact is availability-only (A:L) with no C/I.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
flatcc through 0.6.4 contains an out-of-bounds read vulnerability in __flatcc_json_parser_number that allows attackers to read past the input buffer via numbers ending in a decimal point. Attackers can supply untrusted JSON ending immediately after a decimal point to generated parsers, crashing applications when the buffer ends at an unmapped page.
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.
Reachable assertion in the flatcc FlatBuffers schema compiler (versions 0.6.0-0.6.3) crashes the compiler process when a
Reachable assertion in the flatcc FlatBuffers compiler (versions 0.6.0-0.6.3) allows remote attackers to crash the compi
An out-of-bounds read in the flatcc FlatBuffers verifier (check_header, through version 0.6.4) lets a crafted buffer cra
EUVD-2026-110481
GHSA-ffg2-pv59-mvp5
NVD
CVE.org
EPSS
Exploit-DB