Private
Public Access
fetch_and_ingest fetched a feed_url supplied straight from the "add feed" form or an uploaded OPML file, with requests following redirects on its own and no check that the target (or a redirect's target) was actually a public, fetchable feed rather than an internal service, localhost, or a cloud metadata endpoint — reachable from wherever this app runs, on any authenticated user's behalf. apps.feeds.services.ssrf_guard.safe_get() replaces the direct requests.get() call: it resolves and validates the hostname (rejecting anything that isn't a globally routable address) before the initial request and before following each redirect hop manually, caps the number of hops, and bounds the response body size by streaming it instead of buffering it unbounded. OPML-imported feeds go through the same check the first time poll_due_feeds fetches them, since this is the one chokepoint every feed URL passes through regardless of which path created the Feed row. Known residual gap, documented in ssrf_guard.py: this validates then connects rather than pinning the TCP connection to the exact address it validated, so a narrow DNS-rebinding race isn't closed. Fixing that needs a custom transport and felt like more machinery than this self-hosted app's threat model currently justifies. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
139 lines
4.9 KiB
Python
139 lines
4.9 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"
|