Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft YAML document with malicious !js tag
-
DeliveryDeliver document to application YAML parsing endpoint
-
ExploitParser invokes eval() on tag string value
-
ExecutionArbitrary JavaScript executes in Node.js process
-
PersistExfiltrate environment variables or filesystem data
-
ImpactEstablish persistent access or lateral movement
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Eval input sanitization
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that the target application uses @cgauge/yaml version ≤ 0.27.0 to parse YAML content that contains attacker-controlled values, and that the |
| Impact | The CVSS 4.0 score of 8.4 with vector AV:L/AC:L/AT:N/PR:N/UI:A reflects that the attacker must deliver a malicious YAML document that a user or automated process then parses - the library itself does not listen on a network socket. However, in typical Node.js service deployments that accept YAML from API consumers, file-upload endpoints, or configuration ingestion pipelines, the effective attack vector becomes network-reachable, substantially increasing real-world risk beyond what AV:L implies in isolation. The existence of a public POC (GitHub Gist) dramatically lowers the skill threshold for exploitation. Active exploitation has not been confirmed by CISA KEV, suggesting opportunistic or targeted attacks rather than broad automated scanning at this time. No EPSS data was provided; the low-footprint nature of the package limits aggregate exposure, but any organization that does run it faces critical-severity conditions. The absence of any safe-parsing alternative within the library means runtime mitigation is architectural rather than configurational - risk cannot be reduced without removing the dependency. |
| Exploit ScenarioDerived | An attacker crafts a YAML document containing a |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 20, 2026
Arbitrary code execution in @cgauge/yaml (all versions ≤ 0.27.0) is achieved by embedding a custom !js YAML tag in a document supplied to the parser; the library's tag handler unconditionally passes the tag's string value to eval(), granting attackers the full authority of the Node.js runtime - including filesystem access, environment variable exfiltration, network calls, and subprocess spawning. No safe-mode parsing option or opt-out mechanism exists in the library, meaning every call site that parses attacker-controlled YAML is unconditionally vulnerable. A public proof-of-concept exploit is available via GitHub Gist, and no vendor-released patch has been identified at time of analysis.
RemediationAI
No vendor-released patch has been identified at time of analysis; the absence of patch data is inferred from the references provided, not confirmed by an explicit vendor statement. The primary remediation is to remove @cgauge/yaml from all dependency trees and replace it with a YAML library that does not implement unsafe tag construction - suitable alternatives include js-yaml used via its safeLoad / load API (which rejects custom tag handlers by default) or the yaml package with custom tag schemas disabled. If immediate removal is not feasible, all code paths that invoke @cgauge/yaml must be audited and any YAML input originating from untrusted sources (API bodies, user uploads, external feeds) must be rejected or stripped at the network or application boundary before reaching the parser - note that stripping !js tags via regex pre-processing is fragile and not recommended as a durable control. VulnCheck advisory: https://www.vulncheck.com/advisories/cgauge-yaml-npm-package-arbitrary-code-execution-via-eval-yaml-tag. Public POC: https://gist.github.com/arjunjaincs/35da3a80b4b16f324f194acec18489ba.
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
The root cause is CWE-95 (Eval Injection): the @cgauge/yaml library (CPE cpe:2.3:a:cgauge:@cgauge/yaml:*:*:*:*:*:*:*:*) implements a custom YAML tag !js whose construct callback passes the raw tag string value directly to JavaScript's eval() function with no sanitization, allowlisting, or sandboxing. The YAML specification permits custom tag handlers as extension points for embedding domain-specific types, but invoking eval() on untrusted content at parse time is an inherently unsafe design: it conflates the data plane with the code plane. Because Node.js eval() executes within the same V8 isolate and process context as the host application, there is no privilege boundary - the injected code inherits all OS-level permissions held by the Node.js process. The library is distributed as an npm package within the cgauge monorepo (https://github.com/cgauge/packages) and is affected across its entire release history through 0.27.0, per EUVD-2026-63350.
Know when Node.js 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:L/AC:L/AT:N/PR:N/UI:A/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Typical Node.js deployments expose YAML parsing over the network making AV:N appropriate; eval() grants full C/I/A; UI:R reflects parsing must be triggered on the malicious document.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
@cgauge/yaml npm package contains an arbitrary code execution vulnerability that allows attackers to execute arbitrary JavaScript by embedding a custom !js YAML tag whose construct callback unconditionally calls eval() on attacker-supplied string values during document parsing. Any application parsing untrusted YAML input with this library exposes full Node.js runtime authority, including environment variable access, filesystem read/write, network access, and subprocess execution, with no safe-mode alternative or opt-out mechanism available.
Executive ViewAI
The @cgauge/yaml library (all versions through 0.27.0) contains an arbitrary code execution vulnerability that allows attackers to execute arbitrary code with full Node.js runtime privileges through malicious YAML documents. Any application using this library to parse untrusted YAML input faces immediate risk of system compromise, data exfiltration, and lateral movement within the network. With a public proof-of-concept exploit available and no vendor patch identified, this vulnerability requires urgent remediation through immediate dependency audit and library replacement.
No vendor-released patch identified at time of analysis. Interim mitigations: (1) restrict YAML parsing to trusted, internally-sourced input only; (2) implement strict input validation to reject any YAML documents containing custom tags; (3) execute YAML parsing in a sandboxed process with minimal filesystem, network, and subprocess permissions; (4) prioritize urgent migration to a secure alternative library as the primary remediation path.
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
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Remote code execution in n8n's workflow expression evaluation system allows an authenticated user with workflow creation
A vulnerability in the NuPoint Unified Messaging (NPM) component of Mitel MiCollab through 9.8 SP1 FP2 (9.8.1.201) could
FortiOS and FortiProxy contain an authentication bypass via the Node.js websocket module allowing unauthenticated remote
Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour
Eval injection vulnerability in the internals.batch function in lib/batch.js in the bassmaster plugin before 1.5.2 for t
Flowise version 3.0.5 contains a remote code execution vulnerability in the CustomMCP node. The mcpServerConfig paramete
Node.js 8.5.0 before 8.6.0 allows remote attackers to access unintended files, because a change to ".." handling was inc
An issue was discovered in the node-serialize package 0.0.4 for Node.js. Rated critical severity (CVSS 9.8), this vulner
OpenSSL before 0.9.8za, 1.0.0 before 1.0.0m, and 1.0.1 before 1.0.1h does not properly restrict processing of ChangeCiph
Directory traversal vulnerability in the st module before 0.2.5 for Node.js allows remote attackers to read arbitrary fi
Multiple SQL injection vulnerabilities in the Manage Accounts page in the AccountManagement.asmx service in the Solarwin
The JS-YAML module before 2.0.5 for Node.js parses input without properly considering the unsafe !!js/function tag, whic
EUVD-2026-63350
GHSA-fqg3-vq72-r4q2
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB