Skip to main content

dot-access EUVDEUVD-2026-95146

| CVE-2026-107700 CRITICAL
Code Injection (CWE-94)
2026-10-08 VulnCheck GHSA-rhfh-63ph-3pch
9.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Identify app passing untrusted input to get()
  2. Delivery
    Craft malicious path with constructor.constructor payload
  3. Exploit
    Inject into new Function body
  4. Execution
    Load child_process and execute commands
  5. Impact
    Full RCE in Node.js process

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Initial Access

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires a consuming application to pass attacker-controlled input as the path argument to dot-access get() in versions 0.0.3 through 1.0.0; the flaw is in how that path is concatenated into a dynamically constructed Function body. There is no special library configuration toggle - the library is vulnerable by design in this range - but the practical limiting factor is reachability: if the application never exposes get()'s path to untrusted data, the vulnerability is not triggerable. No authentication or user interaction is imposed by the library itself (PR:N/UI:N), so wherever untrusted input reaches get(), exploitation is remote and unauthenticated.

Impact

All severity signals point the same direction: the CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N with VC:H/VI:H/VA:H, score 9.3) describes remote, low-complexity, unauthenticated code injection yielding full confidentiality, integrity, and availability loss - consistent with CWE-94 and the described path-to-new-Function concatenation reaching constructor.constructor to load child_process for OS command execution. No EPSS score, no CISA KEV listing, and no explicit POC flag were supplied in the input; however, one reference is a public gist (R3tro16) that strongly suggests proof-of-concept exploit code exists, so this should be treated as 'publicly available exploit code exists' rather than confirmed active exploitation - the two are distinct and KEV is absent. The decisive risk modifier is NOT severity but reachability: dot-access is a tiny, obscure npm library, and exploitation only matters where a consuming application feeds attacker-controlled input into get()'s path argument. Net assessment: technically a critical RCE primitive, but real-world priority is tempered by very low deployment footprint and the requirement that a downstream app expose the vulnerable call to untrusted data. EPSS is missing, so widespread-exploitation probability cannot be quantified from the input.

Exploit ScenarioDerived

An application uses dot-access get() to resolve object paths from user-supplied input (e.g., a query parameter or JSON body field). An attacker submits a crafted path string that breaks out of the intended property lookup and is concatenated into a dynamically built Function body, pivoting through constructor.constructor to require('child_process') and run OS commands. A public gist reference indicates proof-of-concept code is likely available, lowering the effort to reproduce.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
No patch listed yet 0.5% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 08, 2026

Remote code execution in dot-access versions 0.0.3 through 1.0.0 allows unauthenticated attackers to execute arbitrary JavaScript and operating system commands when a consuming application passes attacker-controlled input as the path argument to the get() function. The vulnerability arises from unsanitized path concatenation into a dynamically constructed Function body, enabling access to constructor.constructor and child_process. No public exploit code was identified at time of analysis, but the CVSS 4.0 score of 9.3 reflects high confidentiality, integrity, and availability impact. Exploitation is conditional on untrusted input reaching get().

RemediationAI

No vendor-released patch identified at time of analysis. To mitigate, first determine if any application code passes untrusted input to dot-access's get() function; if so, immediately sanitize or validate that input to ensure it cannot contain JavaScript syntax or property access chains that escape the intended context. If a patched version of dot-access becomes available, upgrade to that version. As a compensating control, consider replacing dot-access with a maintained alternative that does not use dynamic Function construction, or restrict the get() function to only accept pre-approved path strings. Disabling or removing the dependency entirely eliminates the risk but may require refactoring. Note that input validation must be robust because the injection occurs within a new Function body; simple blocklists may be bypassed, so allowlisting or using a safe property accessor is recommended. Trade-offs include potential compatibility issues with legitimate nested path usage and the effort of refactoring.

Affected VersionsENISA

dot-access 0.0.3 ≤1.0.0

Affected Packages

euvd dot_access 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 dot-access library is a Node.js utility for accessing nested object properties via dot notation. In versions 0.0.3 through 1.0.0, the get() function concatenates the user-supplied path parameter directly into the body of a new Function constructor, which is a form of dynamic code evaluation. This design flaw (CWE-94: Code Injection) allows an attacker to craft a path that breaks out of the intended expression and invokes the Function constructor's constructor property, ultimately reaching Node.js's child_process module. The CPE cpe:2.3:a:ntharim:dot-access:*:*:*:*:*:*:*:* confirms the affected package on npm as ntharim/dot-access. The root cause is the lack of input sanitization or validation before interpolation into executable code, a classic pattern that leads to arbitrary code execution in the host Node.js process.

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 9.3 CRITICAL
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 9.8 CRITICAL

Remote unauthenticated code injection into the Node.js process with no user interaction gives AV:N/AC:L/PR:N/UI:N and full C:H/I:H/A:H; scope unchanged as impact stays within the Node runtime.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
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

dot-access 0.0.3 through 1.0.0 contains a code injection vulnerability that allows remote attackers to execute JavaScript by supplying crafted paths to get(). The path is concatenated into a new Function body in index.js, so attackers can reach constructor.constructor to load child_process and run operating system commands in the Node.js process.

Executive ViewAI

Why It Matters

A critical remote code execution flaw (CVE-2026-107700, CVSS 9.3) affects the widely embedded open-source JavaScript library dot-access in versions 0.0.3 through 1.0.0, allowing arbitrary code and operating system command execution on any server or build pipeline that passes untrusted input into the library's get() function. Because dot-access is typically pulled in as a transitive dependency, many application teams may not know they are exposed, and no vendor patch is currently available. Leadership should treat this as a supply-chain exposure requiring immediate inventory and containment, with the highest risk concentrated in internet-facing services and CI/CD systems that process external data.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: inventory and locate all uses of dot-access versions 0.0.3 through 1.0.0, including transitive dependencies; strictly validate, type-check, and allow-list any path argument passed to get() so attacker-controlled input cannot reach it; reject path segments such as 'constructor', 'prototype', '__proto__', and bracket notation; replace or remove the library in favor of a maintained alternative; run affected Node.js workloads under the Node.js permission model or OS-level sandboxing (AppArmor/SELinux, non-root, read-only filesystem, restricted egress) to blunt arbitrary command execution; and monitor process-spawning and outbound network activity on hosts running the library.

Threat Intelligence Overview

EPSS Score
0.5%
Top 59% exploitable
Prevalence
Rare
obscure single-maintainer npm micro-library, negligible 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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.5%
Patch available No
Active threat No
Deciding rule
CRITICAL severity
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
Open
Automatable
Yes
Human Impact
High
Technical Impact
Total

Priority Score

47
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +46
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