dssrf CVE-2026-44232
HIGHAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit URL with IPv6 notation
-
Deliverydssrf validation incorrectly passes
-
ExploitApplication makes HTTP request
-
ExecutionReach internal resource or cloud IMDS
-
ImpactExfiltrate credentials or sensitive data
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input filtering completeness
|
| Exploitation Conditions | Exploitation requires that the vulnerable application (1) uses dssrf versions prior to 1.3.0 with the is_url_safe() function for URL validation, (2) accepts attacker-controlled input that becomes part of HTTP request URLs (such as webhook callbacks, proxy targets, link expansion services, or image fetch URLs), (3) runs in an environment where IPv6 networking is functional or where the Node.js HTTP client processes IPv6 bracket notation (default behavior in Node.js http/https modules), and (4) has network connectivity to internal resources or metadata services that would be blocked by proper SSRF protections. Exploitation is NOT limited to environments with native IPv6 routing - IPv4-mapped IPv6 addresses (::ffff:x.x.x.x) work even in IPv4-only networks because they are processed at the application layer before network transmission. No authentication or user interaction is required; the attack succeeds through server-side request handling. The vulnerability is most dangerous in cloud deployments (AWS, GCP, Azure) where metadata services at 169.254.169.254 are reachable, but also enables access to any internal HTTP services on private IPs, Docker APIs, Kubernetes endpoints, or localhost services when crafted as IPv6 loopback [::1]. |
| Impact | Without CVSS vector or EPSS data, risk assessment relies on technical impact and exploit accessibility. The vulnerability presents HIGH real-world risk for applications using dssrf < 1.3.0 as an SSRF defense layer, because publicly available exploit code exists demonstrating 12 distinct IPv6 bypass techniques against the library's core security function. Attack complexity is LOW - exploitation requires only crafting URLs with IPv6 bracket notation, no special privileges, and the POC script provides ready-to-use payloads. Technical impact is CRITICAL when the protected application runs in cloud environments (AWS EC2, GCP Compute, Azure VMs) where IMDS endpoints at [::ffff:169.254.169.254] expose IAM credentials, user-data scripts, and instance metadata. Impact extends to internal service enumeration, Docker daemon access (if bound to IPv6), Kubernetes API servers, and private network pivoting. The vulnerability is particularly dangerous because it creates a false sense of security - developers believing dssrf protects against SSRF will not implement defense-in-depth controls. However, exploitation is NOT fully automatic across all deployments: it requires that (1) the vulnerable application actually makes HTTP requests to attacker-controlled URLs, (2) the underlying Node.js HTTP client supports IPv6 (most do by default), and (3) IPv6 networking is functional in the deployment environment (increasingly common but not universal). Organizations using dssrf 1.0.2-1.2.x in cloud environments or IPv6-enabled networks should treat this as an urgent patching priority. No CISA KEV status indicates this is not yet exploited at scale, but the comprehensive POC and cloud metadata targeting suggest rapid weaponization risk. |
| Exploit ScenarioDerived | An attacker identifies a Node.js web application using dssrf for URL validation before fetching user-specified resources (common in proxy services, webhook handlers, image processors, or link preview features). The attacker submits a POST request with URL parameter 'http://[::ffff:169.254.169.254]/latest/meta-data/iam/security-credentials/' which dssrf incorrectly marks as safe. The application fetches this URL, reaches the AWS EC2 instance metadata service via IPv6-mapped IPv4 address, and returns IAM temporary credentials to the attacker, enabling full compromise of the cloud workload's AWS permissions. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 06, 2026
The dssrf Node.js library (versions < 1.3.0) allows Server-Side Request Forgery (SSRF) protection bypass through IPv6 addresses targeting internal resources. Attackers can craft HTTP requests using IPv6 loopback (::1), unique local addresses (fc00::/7), link-local addresses (fe80::/10), IPv4-mapped IPv6 addresses (::ffff:127.0.0.1, ::ffff:169.254.169.254), NAT64 prefixes, and other IPv6 categories to access internal services, cloud metadata endpoints (IMDS), and private networks that the library was explicitly designed to block. The vulnerability directly contradicts dssrf documentation claiming IPv6 is disabled entirely, and a publicly available exploit code (POC) demonstrates all affected IPv6 categories. Patch available in version 1.3.0.
RemediationAI
Immediately upgrade to dssrf version 1.3.0 or later, which addresses all IPv6 bypass categories documented in the advisory. Update via npm with 'npm install dssrf@latest' or 'npm update dssrf', then verify package.json and package-lock.json reflect version 1.3.0+. Organizations requiring immediate risk reduction before patching can implement compensating controls: (1) Deploy network-level egress filtering to block outbound connections to RFC1918 IPv4 space, IPv6 ULA (fc00::/7), link-local (fe80::/10), loopback addresses, and cloud metadata endpoints (169.254.169.254 for both IPv4 and ::ffff:169.254.169.254 IPv6-mapped) at firewall or security group level, though this adds operational complexity and may break legitimate internal service communication; (2) Implement application-layer validation using an alternative SSRF protection library that explicitly supports IPv6 filtering (verify through security audit or published test suite); (3) Disable IPv6 at the host network stack level if the application does not require IPv6 connectivity (sysctl net.ipv6.conf.all.disable_ipv6=1 on Linux), though this prevents legitimate IPv6 usage and is not viable for dual-stack environments. Note that relying solely on dssrf versions < 1.3.0 with any compensating control still leaves gaps - upgrade to 1.3.0 is the only complete remediation. Advisory and patch details: https://github.com/advisories/GHSA-8p33-q827-ghj5.
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The dssrf npm package (CPE: pkg:npm/dssrf) is a security library designed to prevent Server-Side Request Forgery attacks by validating URL safety before Node.js applications make outbound HTTP requests. The vulnerability stems from CWE-791 (Incomplete Filtering of Special Elements), specifically the failure to implement IPv6 address validation logic that parallels its IPv4 protections. While the library correctly blocks IPv4 private ranges (127.0.0.0/8, 10.0.0.0/8, 169.254.0.0/16) and RFC1918 space, it completely fails to filter IPv6 equivalents including loopback (::1/128), unique local addresses (fc00::/7 and deprecated fec0::/10), link-local (fe80::/10), IPv4-mapped IPv6 addresses (::ffff:0:0/96 wrapping private IPv4 space), IPv4-compatible addresses (deprecated ::/96 format), NAT64 well-known prefix (64:ff9b::/96) and local-use prefix (64:ff9b:1::/48), SRv6 SID space (5f00::/16), and IPv6 documentation ranges (3fff::/20). This oversight allows attackers to target AWS/GCP/Azure instance metadata services at ::ffff:169.254.169.254, internal APIs, and cloud admin endpoints through IPv6 notation that bypasses URL safety checks.
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:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N
Primary rating from Vendor (https://github.com/HackingRepo/dssrf-js) · only source for this CVE.
CVSS VectorVendor: https://github.com/HackingRepo/dssrf-js
Lifecycle Timeline
2DescriptionCVE.org
A vulnerability in dssrf allows an attacker to bypass its SSRF protections by supplying one of the following IPv6 addresses, resulting in a successful SSRF. This contradicts dssrf documentation, which incorrectly claims that IPv6 is disabled entirely. See below:
Input Category
http://[::1]/ IPv6 loopback
http://[fc00::1]/ IPv6 ULA
http://[fe80::1]/ IPv6 link-local
http://[::ffff:127.0.0.1]/ IPv4-mapped loopback
http://[::ffff:169.254.169.254]/ IPv4-mapped IMDS
http://[::ffff:100.64.0.1]/ IPv4-mapped CGNAT
http://[64:ff9b::7f00:1]/ NAT64 well-known prefix
http://[64:ff9b:1::1]/ NAT64 local-use (RFC 8215)
http://[5f00::1]/ SRv6 SID (RFC 9602)
http://[3fff::1]/ IPv6 documentation (RFC 9637)
http://[fec0::1]/ IPv6 site-local (deprecated, RFC 3879)
http://[::127.0.0.1]/ IPv4-compatible IPv6POC
mkdir dssrf-poc && cd dssrf-poc
npm init -y >/dev/null
npm install dssrf@^1.0.2
cat > audit.js <<'EOF'
const dssrf = require('dssrf');
const cases = [
['http://[::1]/', 'IPv6 loopback'],
['http://[fc00::1]/', 'IPv6 ULA'],
['http://[fe80::1]/', 'IPv6 link-local'],
['http://[::ffff:127.0.0.1]/', 'IPv4-mapped loopback'],
['http://[::ffff:169.254.169.254]/', 'IPv4-mapped IMDS'],
['http://[64:ff9b::7f00:1]/', 'NAT64 well-known + 127.0.0.1'],
['http://[64:ff9b:1::1]/', 'NAT64 local-use (RFC 8215)'],
['http://[5f00::1]/', 'SRv6 SID (RFC 9602)'],
['http://[fec0::1]/', 'IPv6 site-local deprecated'],
['http://127.0.0.1/', 'IPv4 loopback (control)'],
['http://10.0.0.1/', 'IPv4 RFC1918 (control)'],
['http://8.8.8.8/', 'PUBLIC IPv4 (control)'],
];
(async () => {
for (const [url, label] of cases) {
const safe = await dssrf.is_url_safe(url);
console.log(`${safe ? '✓ALLOW' : '·block'} ${url.padEnd(40)} ${label}`);
}
})();
EOF
node audit.jsCredit
dssrf thanks <brmenna@gmail.com> for reporting this issue responsibly.
Update
Users should immediately update to dssrf 1.3.0.
Lessons Learned
As seen both in the past and today, many advisories and CVE bypasses leverage IPv6. IPv6 remains the weakest link, as it is rarely configured correctly and seldom tested. In this case, while IPv4 was properly blocked, the corresponding IPv6 blocking logic was completely broken and never actually worked.,
Executive ViewAI
The dssrf Node.js library (versions below 1.3.0) contains a critical Server-Side Request Forgery (SSRF) bypass vulnerability that allows attackers to reach internal services and cloud metadata endpoints using IPv6 address manipulation, directly undermining the library's core security function. Organizations using affected versions face immediate risk of unauthorized access to sensitive internal resources, including AWS metadata services, and require urgent remediation to prevent data exfiltration and lateral movement.
Vendor-released patch: dssrf version 1.3.0. If immediate patching is blocked, implement network-level controls: restrict outbound HTTP/HTTPS from application servers to internal IP ranges (0.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 127.0.0.0/8, ::1/128, fc00::/7, fe80::/10, and cloud provider metadata endpoints); disable IPv6 at application or network layer if not required; implement application-level URL validation independent of dssrf to whitelist only necessary external endpoints.
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.
Affected Products (CPE)CVE.org
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
GHSA-8p33-q827-ghj5
NVD
CVE.org
EPSS
VulDB
Exploit-DB