Skip to main content

rapidyaml CVE-2026-120455

| EUVDEUVD-2026-115215 MEDIUM
Out-of-bounds Write (CWE-787)
2026-11-02 VulnCheck GHSA-pj6m-mgp5-m3qx
6.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Supply YAML with excess consecutive anchors or tags
  2. Exploit
    Parser calls _add_annotation() past two-element array
  3. Execution
    Out-of-bounds write corrupts stack memory
  4. Impact
    Process crashes (denial of service)

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

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 host application to feed an attacker-controlled YAML document into rapidyaml 0.16.0 or earlier, and the document must contain consecutive/excess anchors or tags that exceed the fixed two-element annotation array used by ParseEngine::_add_annotation(). The description specifically scopes the memory corruption to release builds (debug builds likely trip an assertion instead), so the impact manifests in production/release configurations. Exploitation is limited by the local attack vector (AV:L) and required passive user interaction (UI:P) - a victim or application must actually process the malicious document - and by the fact that the attacker needs no authentication but also gains only a crash/memory corruption rather than confidentiality loss.

Impact

This is a medium-severity issue (CVSS 4.0 base 6.9) whose signals point to a moderate, non-emergency priority rather than a top-tier threat. The vector (AV:L/AC:L/AT:N/PR:N/UI:P) describes an unauthenticated, low-complexity trigger but requires local delivery and passive user interaction - the host application must process an attacker-supplied YAML document. Impact is dominated by availability (VA:H, a process crash) with only limited integrity impact (VI:L) and no confidentiality impact (VC:N); the evidence confirms stack memory corruption and a crash, not code execution, so the realistic consequence is denial of service. No EPSS score and no CISA KEV listing were provided, so there is no signal of active or widespread exploitation; the vuln.today decision label is 'this_month', consistent with scheduled remediation rather than act_now/emergency. A public PoC reference exists (a hackmd technical write-up plus the VulnCheck advisory and GitHub issue #680), which raises the likelihood of exploitation attempts against exposed parsers, but it is not verified as working weaponized exploit code. Net: a legitimate memory-corruption bug worth patching on a normal cycle, not a high-CVSS-but-illusory issue, though its real-world urgency is bounded by the local vector and the DoS-level impact. Note that an out-of-bounds stack write can in principle enable more than a crash, but the available sources only confirm memory corruption and process termination.

Exploit ScenarioDerived

An application that embeds rapidyaml 0.16.0 or earlier parses a YAML document originating from an untrusted source (e.g., an uploaded file or supplied configuration). The attacker crafts a document containing consecutive/excess anchors or tags on a node, overflowing the fixed two-element annotation array in ParseEngine::_add_annotation() and corrupting stack memory, which crashes the process. A public technical write-up describing the flaw exists, though it is not verified as working exploit code.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Nov 02, 2026

Out-of-bounds write in rapidyaml (ryml) through 0.16.0 lets an attacker who can supply a YAML document containing consecutive or excessive anchors/tags overflow the parser's fixed two-element annotation array in ParseEngine::_add_annotation(), corrupting stack memory and crashing the host process in release builds. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P, with VA:H and VI:L) means unauthenticated attackers at the local vector need only get an application to process the crafted document, and the assessed consequence is high availability impact with limited integrity effect rather than confidentiality loss. No CISA KEV entry exists and no public exploit code is confirmed at time of analysis, though a third-party technical writeup describing the parser annotation overflow is referenced; vuln.today priority is this_month, i.e. a moderate, non-emergency issue.

RemediationAI

No vendor-released fixed version is identified in the available data; the upstream tracking issue is https://github.com/biojppm/rapidyaml/issues/680, so monitor it and the repository's release tags for a patched release and upgrade as soon as one is published. Until then, the practical control is to stop feeding attacker-controlled or untrusted YAML into rapidyaml 0.16.0 or earlier, either by rejecting or pre-validating external YAML at the trust boundary (side effect: legitimate document formats must be constrained and rejected input must be handled gracefully), or by performing the parse in an isolated, least-privilege worker or sandboxed process whose crash cannot take down the primary service (side effect: added architectural complexity, inter-process overhead and the need to restart/reap the worker on failure). Building with assertions enabled is expected to convert the overflow into an assertion trip rather than silent stack corruption, but that is a risk-reduction measure only, carries a performance cost, and does not remove the underlying out-of-bounds write, so it should not be treated as a fix. Operators should also note that the flaw manifests in release/production builds, so testing only against debug builds will not surface it.

Affected VersionsENISA

rapidyaml 0 ≤0.16.0

Affected Packages

euvd rapidyaml no fix

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

rapidyaml (ryml, vendor biojppm) is a C++ header/library YAML parser and emitter that vendors the required c4core sources as of the 0.16.0 release. Internally, ParseEngine::_add_annotation() records the anchors and tags that precede a YAML node in a fixed two-element annotation container declared in parse_engine.hpp (lines 249-260) and implemented in parse_engine.def.hpp (lines 4307-4351); the sink is the annotation handling around lines 5524-5535. Because the code does not guard against a document that supplies more than the expected number of consecutive anchors or tags, the write runs past the end of that fixed array, which is the classic CWE-787 out-of-bounds write pattern. The description scopes the memory-corruption outcome to release builds, where assertion checks are compiled out and the overflow silently corrupts adjacent stack memory and typically terminates the process, while debug/assertion-enabled builds are expected to trip an assertion first. The exact trigger conditions beyond "consecutive anchors or tags exceeding two elements" are not described in the available sources, and the CPE cpe:2.3:a:biojppm:rapidyaml:*:*:*:*:*:*:*:* indicates the flaw is present in releases up to and including 0.16.0.

Know when Rapidyaml 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 6.9 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
vuln.today AI 6.1 MEDIUM

Attacker needs no privileges (PR:N) but the app must process the malicious YAML (AV:L, UI:R); impact is a crash (A:H) with only limited memory-corruption integrity effect (I:L) and no confidentiality loss.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

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

DescriptionCVE.org

rapidyaml through 0.16.0 contains an out-of-bounds write vulnerability in ParseEngine::_add_annotation() that allows attackers to corrupt memory by supplying YAML with excess anchors or tags. Attackers can submit YAML with consecutive anchors or tags to overflow the fixed two-element annotation array in release builds, corrupting stack memory and crashing the process.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Low
niche but known fast C++ YAML parser, modest production footprint
Data Quality
4 sources
Confidence: Medium

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.1%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

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

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.

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

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