/

CVE-2026-75975

Severity:

HIGH RISK

(7.5)

IPv6 Validation Bypass (CWE-20) in fast-uri URI Parser

CVE-2026-75975

Analyzed

Vulnerability type

Category:

Improper Input Validation

CWE:

CWE-20, CWE-918

Impact:

Server-Side Request Forgery and Address-Policy Bypass

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A validation flaw in fast-uri can silently rewrite malformed bracketed IPv6 host literals into different valid destinations without reporting a parsing error. When applications normalize attacker-controlled URLs before making requests or enforcing address policies, this may enable server-side request forgery and access to local or private IPv6 services.

Affected context

The issue occurs in applications using fast-uri to parse and normalize untrusted URLs, particularly before outbound HTTP requests, redirect handling, proxy routing, or private-address filtering. It becomes risky when malformed bracketed IPv6 literals are accepted by the parser, transformed into another address, and trusted because the parser does not report an error.

Exploit preconditions

  • Attack surface: URL parsing and normalization performed by an application using fast-uri
  • Required access: Ability to supply or influence a URL, redirect target, proxy destination, or other authority value
  • Trigger point: Parsing of a malformed bracketed IPv6 literal in the URL authority
  • Why exploitation is possible: The parser may discard invalid trailing content and produce a different valid IPv6 destination without setting an error, allowing downstream network controls to evaluate the rewritten address

Why this happens

The vulnerability results from incomplete validation of bracketed IPv6 literals against the complete IPv6 grammar. Invalid trailing characters can be silently discarded, causing attacker-controlled input to be normalized into an unintended address while the parse result appears valid.

This maps primarily to CWE-20: Improper Input Validation. The resulting network redirection behavior also corresponds to CWE-918: Server-Side Request Forgery, because an application may use the rewritten destination for a server-initiated request.

Potential impact

  • An attacker may cause requests to reach loopback services
  • An attacker could target private-range IPv6 addresses that should be inaccessible
  • Address allowlists and deny lists may be bypassed
  • Internal APIs, metadata services, or administrative endpoints may be exposed
  • Network segmentation assumptions may be weakened by server-side requests

General mitigation guidance

Mitigation generally focuses on strict, grammar-complete validation of bracketed IP literals and reducing trust in normalized attacker-controlled URLs.

Common defensive patterns include:

  • Use a parser implementation that rejects malformed IP literals and reports authority errors
  • Validate the original authority and the final resolved address before making outbound requests
  • Apply private, loopback, link-local, and other restricted-range policies after canonicalization
  • Avoid relying solely on a parser error field when enforcing destination policies
  • Restrict outbound network access from application services using least-privilege egress controls
  • Prefer explicit destination allowlists and controlled proxy routing for server-initiated requests
  • Keep URI parsing dependencies within supported, security-maintained release lines

How teams detect issues like this

Detection can combine dependency analysis with application-level testing and code review.

Useful approaches include:

  • Scan dependency manifests and lockfiles for affected fast-uri release ranges
  • Test malformed bracketed IPv6 authorities and verify that parsing fails closed
  • Review code that normalizes URLs before HTTP requests, redirects, proxy selection, or address filtering
  • Use static analysis to identify outbound requests driven by user-controlled URLs
  • Check whether destination policies are applied after canonicalization and DNS or address resolution
  • Enforce CI policies requiring maintained parser dependencies and negative tests for invalid authorities

Sources

SourceLink
cna.openjsf.orgcna.openjsf.org/security-advisories.html
github.comgithub.com/fastify/fast-uri/security/advisories/GHSA-f65p-4m7j-42xc

Frequently asked

questions

It can be exploitable through an application-facing URL, redirect, proxy, or destination parameter when that value is processed by fast-uri and used for a server-side network request.

Typically, no direct server access is required. The attacker generally needs a way to influence a URL or authority value accepted by the vulnerable application.

Use a parser that validates the complete IPv6 grammar and rejects malformed literals, then apply destination restrictions to the canonicalized address before connecting.

Treat URL normalization as a security-sensitive operation, test malformed authorities, use explicit outbound network policies, and ensure dependency review processes identify vulnerable parser implementations.

Find out what's already
exploitable in your codebase.