Nucleoid CVE-2025-11864
MEDIUMAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach exposed Nucleoid endpoint
-
DeliverySupply crafted ip/port/path/headers
-
ExploitTrigger extension.apply outbound request
-
ExecutionServer fetches attacker-chosen internal URL
-
ImpactExfiltrate 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
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).
Primary rating from Vendor (vuldb).
CVSS VectorVendor: vuldb
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
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
Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.
NVD
CVE.org
EPSS
GitHub
VulDB
Exploit-DB