Summary
Flyto2 Core contains a server-side request forgery guard bypass in its HTTP modules, where the IPv6 address :: can evade private-address and blocked-hostname checks while resolving to loopback. An attacker who can submit URLs or influence redirects may use this behavior to reach services available on the local host or internal network.
Affected context
The vulnerability occurs in Flyto2 Core HTTP functionality, including http.get, http.request, and http.batch, when user-controlled URLs or redirect destinations are processed by the SSRF protection logic. It is relevant where the application can make outbound requests and relies on is_private_ip() or related hostname checks to block loopback and private network targets.
Exploit preconditions
- Attack surface: Outbound HTTP request functionality exposed through the affected Flyto2 Core modules
- Required access: Ability to submit, influence, or cause processing of a request URL or redirect destination
- Trigger point: URL validation and request handling before an outbound connection is made
- Why exploitation is possible: The guard does not recognize the IPv6 unspecified address
::as an equivalent route to loopback, allowing private-address restrictions to be bypassed
Why this happens
The underlying bug is incomplete normalization and canonicalization of IP address representations before applying SSRF filters. The validation logic checks selected private IPv4 ranges and blocked hostnames but fails to account for the operating system's treatment of ::, which can route to the local IPv6 loopback interface similarly to 0.0.0.0. This behavior maps to CWE-918: Server-Side Request Forgery, because attacker-influenced destinations are insufficiently restricted before server-side requests are issued.
Potential impact
- An attacker may access services bound to IPv6 loopback
- Internal administrative interfaces or metadata services could be exposed
- Sensitive response data could be returned to the attacker
- Internal network reconnaissance could become possible
- Requests may trigger unintended actions in trusted internal services
General mitigation guidance
Mitigation generally focuses on making destination validation comprehensive, canonical, and independent of ambiguous address representations.
Common defensive patterns include:
- Resolve hostnames and normalize IPv4 and IPv6 addresses before policy evaluation
- Treat unspecified, loopback, link-local, private, and mapped address ranges as restricted by default
- Revalidate every redirect destination rather than trusting the original URL
- Use explicit outbound allowlists for destinations and protocols where feasible
- Apply network egress controls that limit access to internal services
- Run request-making components with minimal network and application privileges
- Avoid returning unrestricted upstream responses to untrusted callers
How teams detect issues like this
Organizations can look for SSRF guard bypasses through:
- Static analysis of URL validation followed by HTTP client calls
- Code review signals involving incomplete IPv4/IPv6 normalization or one-time redirect validation
- Tests covering loopback, unspecified, link-local, mapped, decimal, hexadecimal, and alternative hostname forms
- Runtime telemetry for requests to loopback, private, link-local, and metadata address ranges
- Network policy alerts for unexpected connections from application workloads to internal control-plane services
- Automated security review tools that identify attacker-controlled URLs reaching outbound request APIs

