Skip to main content

Nucleoid CVE-2025-11864

MEDIUM
Server-Side Request Forgery (SSRF) (CWE-918)
2025-10-16 cna@vuldb.com
6.9
CVSS 4.0 · Vendor: vuldb
View

Attack ChainAIDerived

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

  1. Access
    Reach exposed Nucleoid endpoint
  2. Delivery
    Supply crafted ip/port/path/headers
  3. Exploit
    Trigger extension.apply outbound request
  4. Execution
    Server fetches attacker-chosen internal URL
  5. Impact
    Exfiltrate internal response or probe services

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service URL allowlisting, SSRF prevention
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Credential 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 that the Nucleoid instance actually exercise the Outbound Request Handler code path (extension.apply in /src/cluster.ts) with the https/ip/port/path/headers arguments influenced by remote input - i.e., an application or declarative logic on top of Nucleoid that passes externally supplied values into an outbound request. Per the CVSS vector (PR:N/UI:N/AC:L) no authentication or user interaction is needed and complexity is low. Real-world impact is limited by what the Nucleoid host can reach: SSRF value depends on the presence of sensitive internal services, cloud metadata endpoints, or non-segmented internal networks reachable from the server; the uniformly LOW impact metrics (VC:L/VI:L/VA:L) suggest constrained read/influence rather than full internal compromise. A limiting factor is deployment scale - Nucleoid is a niche runtime, so exposed, internet-reachable instances exercising this path may be uncommon.

Impact

This is a moderate, not urgent, priority. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) describes a remotely reachable, low-complexity, unauthenticated SSRF, but the impact metrics are uniformly LOW (VC:L/VI:L/VA:L) with no subsequent-system impact (SC:N/SI:N/SA:N), yielding a medium score of 6.9. Exploitation signals are weak-to-moderate: EPSS is 0.46% (38th percentile), indicating low modeled probability of exploitation in the near term; there is no CISA KEV listing and no SSVC exploitation/automatable data supplied. No vendor security advisory is present - the only sources are a third-party researcher's GitHub discovery writeup and VulDB catalog entries (reporter cna@vuldb.com), so the CVSS was assigned by VulDB rather than the vendor. The signals are internally consistent (low EPSS, no KEV, low impact), so this reads as a genuine-but-low-stakes issue rather than a high-CVSS/low-real-risk mismatch; the main caveat is that SSRF severity is highly deployment-dependent and could be worse in environments with sensitive internal services or cloud metadata endpoints reachable from the Nucleoid host.

Exploit ScenarioDerived

A remote, unauthenticated attacker submits a request to a Nucleoid instance whose declarative logic invokes the Outbound Request Handler (extension.apply in /src/cluster.ts), supplying attacker-chosen https/ip/port/path/headers values so the server issues an HTTP request to an internal target the attacker cannot reach directly. Because the CVSS vector is AV:N/AC:L/PR:N/UI:N, no authentication or user interaction is needed; the attacker could probe internal services or attempt to read cloud metadata. A researcher's discovery writeup is published on GitHub and may include reproduction details, but no confirmed weaponized public exploit was provided in the input data.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
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 09, 2026

Server-side request forgery in NucleoidAI Nucleoid 0.7.10 and earlier lets unauthenticated remote attackers steer outbound requests issued by the runtime: when the Outbound Request Handler path (extension.apply in /src/cluster.ts) is exercised with externally influenced https/ip/port/path/headers arguments, the attacker controls the destination the server connects to. Per the assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:L) no authentication or user interaction is required and complexity is low, but impact is constrained to LOW confidentiality, integrity and availability for the Nucleoid host itself, with no scope change - real damage depends on what internal services, metadata endpoints, or flat internal networks the host can reach. No confirmed actively exploited in CISA KEV, no public exploit identified at time of analysis, and EPSS is low at 0.46% (38th percentile), so this is a moderate, not urgent, priority, further limited by Nucleoid being a niche runtime with relatively few internet-exposed deployments that also pass remote input into this code path.

RemediationAI

No vendor-released patch was identified at time of analysis, so remediation must currently rely on compensating controls; monitor the VulDB entries (https://vuldb.com/?id.328809, https://vuldb.com/?ctiid.328809) and the researcher write-up (https://github.com/lakshayyverma/CVE-Discovery/blob/main/Nucleoid.md) for an upstream fix and upgrade to a release newer than 0.7.10 only once the maintainer publishes one - do not assume any specific fixed version. As immediate mitigations: enforce strict allowlisting of outbound destinations at the network layer (egress firewall or forward proxy) so Nucleoid processes can only reach explicitly required hosts and ports - the trade-off is that legitimate integrations to new endpoints break until added to the allowlist; block requests to loopback (127.0.0.0/8, ::1), link-local and cloud metadata addresses (169.254.169.254, fd00:ec2::254), and RFC1918 ranges from the Nucleoid host, accepting that some internal integrations may stop working; and sanitize at the application layer by never passing externally supplied https/ip/port/path/headers values into extension.apply, instead mapping user input to a fixed table of vetted destinations and rejecting anything else, which is the most targeted fix but requires code changes in every rule or handler that calls it. Additionally, run Nucleoid with least-privilege network identity and consider disabling the Outbound Request Handler path entirely for workloads that do not need outbound calls, accepting loss of that functionality as the trade-off. Because exploitation requires the affected code path to be exercised with remote input, removing that data flow closes the issue even in the absence of an upstream patch.

Affected ProductsAI

NucleoidAI Nucleoid versions up to and including 0.7.10 are affected; the flaw resides in the extension.apply function of /src/cluster.ts within the Outbound Request Handler component. No CPE identifiers were supplied in the source data, so affected installations must be matched by product name and version rather than by CPE. The primary public references for this issue are the researcher write-up at https://github.com/lakshayyverma/CVE-Discovery/blob/main/Nucleoid.md and the VulDB entries https://vuldb.com/?id.328809, https://vuldb.com/?ctiid.328809 and https://vuldb.com/?submit.669928; no separate vendor advisory or CPE mapping was provided. Deployments running the 0.7.x line for internet-reachable services that forward external input into outbound requests should be treated as in scope.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Nucleoid is a declarative, rule-based JavaScript runtime that evaluates application logic and performs side effects, including outbound network requests, on behalf of that logic. The vulnerable element is the extension.apply function in /src/cluster.ts, inside the Outbound Request Handler component, which builds a request from arguments including https (scheme flag), ip, port, path and headers. Because those arguments are not restricted to a trusted destination allowlist, an attacker who can influence them - for example through an application or declarative rule that forwards user-supplied values into an outbound call - can cause the server to issue requests to arbitrary hosts, ports, paths and with attacker-chosen headers. This is the classic CWE-918 server-side request forgery pattern: the trust boundary between untrusted input and the URL-construction layer is missing, so the server becomes a proxy for the attacker. Typical consequences are access to loopback-only administrative interfaces, internal-only HTTP APIs, cloud instance metadata services, and internal port scanning or protocol probing via the request path and header manipulation. The assessed vector's uniformly LOW CIA metrics and unchanged scope indicate constrained read/influence of the Nucleoid host rather than full internal network compromise, and the practical severity scales with the host's network position and the sensitivity of reachable services.

Know when the next one hits your stack

  • 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 (vuldb) PRIMARY 6.9 MEDIUM
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
vuln.today AI 7.3 HIGH

Remote unauthenticated SSRF with low complexity and no user interaction (AV:N/AC:L/PR:N/UI:N); impacts kept Low across C/I/A and scope Unchanged to mirror the source's SC:N (no confirmed subsequent-system impact).

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

Primary rating from Vendor (vuldb).

CVSS VectorVendor: vuldb

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

DescriptionCVE.org

A vulnerability was identified in NucleoidAI Nucleoid up to 0.7.10. The impacted element is the function extension.apply of the file /src/cluster.ts of the component Outbound Request Handler. Such manipulation of the argument https/ip/port/path/headers leads to server-side request forgery. The attack may be performed from remote.

Threat Intelligence Overview

EPSS Score
0.5%
Top 62% exploitable
Prevalence
Low
niche open-source JavaScript low-code runtime, limited enterprise footprint
Data Quality
5 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.5%
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
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
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

Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.

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