Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend crafted JSON/regex input to app
-
DeliveryInput routed to RapidJSON regex parser
-
ExploitGenericStringStream::Take reads past buffer end
-
ExecutionOut-of-bounds memory read
-
ImpactInformation disclosure or process crash
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 | Exploitation requires the embedding application to pass attacker-influenced data through RapidJSON's Regex Parser path (its schema/regex validation feature), which reaches the vulnerable GenericStringStream::Take in include/rapidjson/stream.h; applications that never use the regex/schema functionality are not exposed. The CVSS vector (AV:N/AC:L/PR:N/UI:N) implies no authentication or user interaction once that code path is reachable, but because RapidJSON is a header-only library, actual remote reachability depends on how the host application exposes JSON/regex parsing to untrusted input. Impact is limited to a partial out-of-bounds read (information disclosure of adjacent memory and/or crash), not code execution. Affected versions are RapidJSON 1.0 and 1.1.0 (up to 1.1.0); no fixed release has been published by the project. |
| Impact | This is a moderate-severity out-of-bounds read (CWE-125) in Tencent RapidJSON's GenericStringStream::Take, reached through the library's Regex Parser component. Signals are consistent and point to a real-but-not-urgent issue rather than a top-priority emergency. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) describes a low-complexity, unauthenticated, remotely reachable flaw, but the impact is capped at partial (VC:L/VI:L/VA:L), yielding only 5.5. EPSS is low at 0.30% (23rd percentile) and the vuln.today decision label is 'this_month', not 'act_now' or 'emergency'. SSVC records Exploitation=poc, Automatable=yes, Technical Impact=partial. There is no CISA KEV listing, so there is no evidence of active exploitation. A public PoC reference exists (the GitHub issue report) but it is not verified as working exploit code, so POC availability must not be read as confirmed exploitability. A notable caveat: 'remotely reachable' depends entirely on whether the embedding application feeds attacker-controlled input through RapidJSON's regex/schema path - RapidJSON is a header-only library, so the true attack surface is application-dependent and cannot be confirmed from this data. The CVSS VI:L (integrity) assignment is also questionable for a pure out-of-bounds read, which typically affects confidentiality and availability, not integrity - verify with the vendor. |
| Exploit ScenarioDerived | An application that uses RapidJSON's schema/regex validation processes attacker-supplied input, and a crafted string drives GenericStringStream::Take past the end of the buffer, causing an out-of-bounds read. Because AC:L/PR:N/UI:N, no authentication or user interaction is required once the vulnerable code path is reachable, and the attacker may be able to leak adjacent memory contents or crash the process. A public PoC reference exists in the project's issue tracker, but 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 (CWE-125) exists in Tencent RapidJSON up to and including 1.1.0, reachable through the library's Regex Parser component when the templated GenericStringStream<UTF8<char>>::Take function in include/rapidjson/stream.h is exercised; a successful trigger reads memory adjacent to the intended buffer, producing partial information disclosure and/or a crash rather than code execution. Exposure is conditional: because RapidJSON is a header-only C++ library with no network surface of its own, only applications that pass attacker-influenced data into the regex/schema validation path inherit the flaw - deployments that never use regex or schema functionality are not exposed. A public PoC reference exists (upstream GitHub issue #2401); it is not verified as working exploit code, and there is no CISA KEV entry, though SSVC records exploitation status as 'poc' and the EPSS score of 0.30% (23rd percentile) reflects low predicted exploitation activity.
RemediationAI
No vendor-released patch identified at time of analysis: the project was notified early through upstream issue #2401 (https://github.com/Tencent/rapidjson/issues/2401) and has not responded, and no fixed RapidJSON version is published for either the 1.0 or 1.1.0 branch, so teams should track that issue and the VulDB entry https://vuldb.com/vuln/426552 for a fix commit to backport. The most direct compensating control follows from the exposure analysis: remove or block untrusted input from the regex/schema validation path - do not feed attacker-controlled JSON into schema or regex validation, or avoid that functionality entirely - with the trade-off that schema/regex validation is lost and must be replaced by upstream validation in the embedding application. Where the regex path cannot be removed, run the parsing component in a memory-constrained, sandboxed worker so that an out-of-bounds read terminates an isolated process rather than the main service, accepting the added latency and operational complexity of process isolation, and treat any resulting crash as a potential information-disclosure event rather than a benign failure. Since RapidJSON is header-only, remediation ultimately means rebuilding and redeploying every dependent application with a corrected stream.h once an upstream fix lands; there is no library upgrade path available today, and the EPSS score of 0.30% (23rd percentile) with SSVC decision 'this_month' supports scheduled rather than emergency handling.
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
RapidJSON is a header-only C++ JSON parser and generator, so the vulnerable code is compiled directly into every consuming application rather than shipped as a service; the affected routine is GenericStringStream<UTF8<char>>::Take in include/rapidjson/stream.h, a stream accessor used to advance over the input buffer during parsing, including when the Regex Parser component performs schema/regex validation. The weakness class is CWE-125 (out-of-bounds read), which in a stream/writer abstraction typically means a read past the end of the underlying buffer, but the available sources do not describe the precise trigger condition or the exact bounds-check that fails, so the mechanism should be treated as unconfirmed beyond the CWE classification. Impact is bounded to disclosure of adjacent memory contents and possible denial of service via crash; the CVSS:4.0 vector supplied with the CVE records only low confidentiality, integrity and availability impact with no subsequent-system impact, and the independently assessed CVSS:3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:L) likewise caps effect at partial information leak and partial availability loss. The lack of authentication or user-interaction requirements in both vectors describes the library call path, not a network service; real remote reachability is determined entirely by how the embedding application exposes JSON or regex parsing to untrusted input. RapidJSON 1.0 and 1.1.0 are listed as affected versions by EUVD, with the CPE cpe:2.3:a:tencent:rapidjson:*:*:*:*:*:*:*:* covering all published releases.
Know when Rapidjson 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:L/VI:L/VA:L/SC:N/SI:N/SA:N/E:P
Crafted input to a remotely reachable parser with no auth gives AV:N/AC:L/PR:N/UI:N; an out-of-bounds read yields limited memory disclosure (C:L) and possible crash (A:L), with no integrity impact (I:N).
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
Lifecycle Timeline
2DescriptionCVE.org
A security vulnerability has been detected in Tencent RapidJSON up to 1.1.0. This issue affects the function GenericStringStream<UTF8<char>>::Take in the library include/rapidjson/stream.h of the component Regex Parser. The manipulation leads to out-of-bounds read. The attack can be initiated remotely. The exploit has been disclosed publicly and may be used. The project was informed of the problem early through an issue report but has not responded yet.
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.
EUVD-2026-110567
GHSA-xfhf-c35f-773q
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB