Private
Public Access
The SSRF guard checked that a hostname resolved to public addresses, then let requests resolve it again to connect — so a DNS answer that changed in between (DNS rebinding) could point the connection at an internal address. Connections now go through a pinned adapter whose socket factory resolves, checks and connects inside one function: whatever the name resolves to at connect time is what gets validated and used. Only the socket is replaced, so TLS still verifies against the original hostname. The up-front validate_fetch_url check stays as defense in depth. Tests cover a rebinding answer at connect time being refused and a real loopback round trip with the original Host header preserved; checked live: a real HTTPS feed fetches, 127.0.0.1/169.254.169.254/ localhost are blocked, and a wrong-hostname certificate is still rejected. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
210 lines
7.5 KiB
Python
210 lines
7.5 KiB
Python
import socket
|
|
|
|
import pytest
|
|
import responses
|
|
|
|
from apps.feeds.services.ssrf_guard import (
|
|
MAX_REDIRECTS,
|
|
MAX_RESPONSE_BYTES,
|
|
SSRFBlocked,
|
|
safe_get,
|
|
validate_fetch_url,
|
|
)
|
|
|
|
# apps/feeds/conftest.py's autouse _fake_public_dns fixture pins every
|
|
# hostname to this address unless a test below overrides it directly.
|
|
PUBLIC_IP = "93.184.216.34"
|
|
|
|
|
|
def _patch_dns(monkeypatch, ip: str):
|
|
def _fake_getaddrinfo(host, *args, **kwargs):
|
|
return [(socket.AF_INET, socket.SOCK_STREAM, 6, "", (ip, 0))]
|
|
|
|
monkeypatch.setattr(socket, "getaddrinfo", _fake_getaddrinfo)
|
|
|
|
|
|
class TestValidateFetchUrl:
|
|
def test_allows_a_public_https_url(self):
|
|
validate_fetch_url("https://example.com/feed.xml")
|
|
|
|
def test_rejects_a_non_http_scheme(self):
|
|
with pytest.raises(SSRFBlocked, match="scheme"):
|
|
validate_fetch_url("file:///etc/passwd")
|
|
|
|
def test_rejects_a_url_with_no_hostname(self):
|
|
with pytest.raises(SSRFBlocked, match="hostname"):
|
|
validate_fetch_url("https:///feed.xml")
|
|
|
|
@pytest.mark.parametrize(
|
|
"ip",
|
|
[
|
|
"127.0.0.1", # loopback
|
|
"10.0.0.5", # RFC1918 private
|
|
"192.168.1.1", # RFC1918 private
|
|
"169.254.169.254", # link-local / cloud metadata
|
|
"0.0.0.0", # unspecified
|
|
"::1", # IPv6 loopback
|
|
"fc00::1", # IPv6 unique local
|
|
],
|
|
)
|
|
def test_rejects_a_url_resolving_to_a_non_public_address(self, monkeypatch, ip):
|
|
_patch_dns(monkeypatch, ip)
|
|
with pytest.raises(SSRFBlocked, match="non-public"):
|
|
validate_fetch_url("https://internal.example.com/feed.xml")
|
|
|
|
def test_rejects_a_url_whose_hostname_does_not_resolve(self, monkeypatch):
|
|
def _raise(*args, **kwargs):
|
|
raise socket.gaierror("nope")
|
|
|
|
monkeypatch.setattr(socket, "getaddrinfo", _raise)
|
|
with pytest.raises(SSRFBlocked, match="Could not resolve"):
|
|
validate_fetch_url("https://nowhere.example.com/feed.xml")
|
|
|
|
|
|
class TestSafeGet:
|
|
@responses.activate
|
|
def test_returns_the_response_body_for_a_normal_feed(self):
|
|
responses.add(responses.GET, "https://example.com/feed.xml", body="<rss></rss>")
|
|
response = safe_get("https://example.com/feed.xml", headers={}, timeout=5)
|
|
assert response.status_code == 200
|
|
assert response.content == b"<rss></rss>"
|
|
|
|
@responses.activate
|
|
def test_follows_a_safe_redirect(self):
|
|
responses.add(
|
|
responses.GET,
|
|
"https://example.com/feed.xml",
|
|
status=302,
|
|
headers={"Location": "https://example.com/final.xml"},
|
|
)
|
|
responses.add(responses.GET, "https://example.com/final.xml", body="<rss>final</rss>")
|
|
|
|
response = safe_get("https://example.com/feed.xml", headers={}, timeout=5)
|
|
assert response.content == b"<rss>final</rss>"
|
|
|
|
@responses.activate
|
|
def test_blocks_a_redirect_to_a_private_address(self, monkeypatch):
|
|
responses.add(
|
|
responses.GET,
|
|
"https://example.com/feed.xml",
|
|
status=302,
|
|
headers={"Location": "http://internal.example.com/secret"},
|
|
)
|
|
|
|
real_getaddrinfo = socket.getaddrinfo
|
|
|
|
def _fake_getaddrinfo(host, *args, **kwargs):
|
|
if host == "internal.example.com":
|
|
return [(socket.AF_INET, socket.SOCK_STREAM, 6, "", ("127.0.0.1", 0))]
|
|
return real_getaddrinfo(host, *args, **kwargs)
|
|
|
|
monkeypatch.setattr(socket, "getaddrinfo", _fake_getaddrinfo)
|
|
|
|
with pytest.raises(SSRFBlocked, match="non-public"):
|
|
safe_get("https://example.com/feed.xml", headers={}, timeout=5)
|
|
|
|
@responses.activate
|
|
def test_blocks_a_redirect_loop_past_max_redirects(self):
|
|
for _ in range(MAX_REDIRECTS + 2):
|
|
responses.add(
|
|
responses.GET,
|
|
"https://example.com/feed.xml",
|
|
status=302,
|
|
headers={"Location": "https://example.com/feed.xml"},
|
|
)
|
|
|
|
with pytest.raises(SSRFBlocked, match="Too many redirects"):
|
|
safe_get("https://example.com/feed.xml", headers={}, timeout=5)
|
|
|
|
@responses.activate
|
|
def test_blocks_a_response_over_the_size_cap(self):
|
|
responses.add(
|
|
responses.GET,
|
|
"https://example.com/feed.xml",
|
|
body=b"x" * (MAX_RESPONSE_BYTES + 1),
|
|
)
|
|
with pytest.raises(SSRFBlocked, match="exceeded"):
|
|
safe_get("https://example.com/feed.xml", headers={}, timeout=5)
|
|
|
|
@responses.activate
|
|
def test_preserves_case_insensitive_header_lookup(self):
|
|
responses.add(
|
|
responses.GET,
|
|
"https://example.com/feed.xml",
|
|
body="<rss></rss>",
|
|
headers={"etag": "abc123"},
|
|
)
|
|
response = safe_get("https://example.com/feed.xml", headers={}, timeout=5)
|
|
assert response.headers.get("ETag") == "abc123"
|
|
|
|
|
|
class TestConnectionPinning:
|
|
"""R2-S2: the address that's validated is the address that's connected
|
|
to — a hostname that resolves differently at connect time can't slip an
|
|
internal address past a pre-check."""
|
|
|
|
def test_a_rebinding_dns_answer_at_connect_time_is_blocked(self, monkeypatch):
|
|
import socket
|
|
|
|
calls = []
|
|
|
|
def rebinding_getaddrinfo(host, *args, **kwargs):
|
|
calls.append(host)
|
|
ip = "93.184.216.34" if len(calls) == 1 else "127.0.0.1"
|
|
return [(socket.AF_INET, socket.SOCK_STREAM, 6, "", (ip, 0))]
|
|
|
|
monkeypatch.setattr(socket, "getaddrinfo", rebinding_getaddrinfo)
|
|
|
|
# The up-front check sees the public answer...
|
|
validate_fetch_url("http://rebind.example.com/feed.xml")
|
|
# ...but the connection's own lookup gets the internal one and must refuse.
|
|
with pytest.raises(SSRFBlocked, match="non-public"):
|
|
safe_get("http://rebind.example.com/feed.xml", headers={}, timeout=2)
|
|
|
|
def test_connects_to_the_validated_address_and_keeps_the_original_host_header(
|
|
self, monkeypatch
|
|
):
|
|
import socket
|
|
import threading
|
|
from http.server import BaseHTTPRequestHandler, HTTPServer
|
|
|
|
from apps.feeds.services import ssrf_guard
|
|
|
|
seen = {}
|
|
|
|
class Handler(BaseHTTPRequestHandler):
|
|
def do_GET(self):
|
|
seen["host"] = self.headers["Host"]
|
|
body = b"<rss/>"
|
|
self.send_response(200)
|
|
self.send_header("Content-Length", str(len(body)))
|
|
self.end_headers()
|
|
self.wfile.write(body)
|
|
|
|
def log_message(self, *args):
|
|
pass
|
|
|
|
server = HTTPServer(("127.0.0.1", 0), Handler)
|
|
port = server.server_address[1]
|
|
threading.Thread(target=server.handle_request, daemon=True).start()
|
|
|
|
real_getaddrinfo = socket.getaddrinfo
|
|
monkeypatch.setattr(
|
|
socket,
|
|
"getaddrinfo",
|
|
lambda host, *a, **k: (
|
|
[(socket.AF_INET, socket.SOCK_STREAM, 6, "", ("127.0.0.1", port))]
|
|
if host == "feed.test"
|
|
else real_getaddrinfo(host, *a, **k)
|
|
),
|
|
)
|
|
# Allow loopback for this test only, standing in for a public address.
|
|
monkeypatch.setattr(ssrf_guard, "_is_allowed_ip", lambda ip: True)
|
|
|
|
response = safe_get(f"http://feed.test:{port}/feed.xml", headers={}, timeout=5)
|
|
server.server_close()
|
|
|
|
assert response.status_code == 200
|
|
assert response.content == b"<rss/>"
|
|
assert seen["host"] == f"feed.test:{port}"
|