Guard podcast HTTP requests against SSRF

Feed and enclosure URLs come from users and third-party feeds. SafeHttp
accepts only http(s) URLs without credentials, resolves names with a
resolver that refuses the whole answer unless every address is public
(loopback, private, CGNAT, link-local, cloud metadata, unique local,
multicast, reserved; IPv4-mapped, NAT64 and 6to4 judged by their IPv4
part), and connects to exactly the checked addresses, so DNS rebinding
cannot swap them. IP literals and every redirect hop are checked; system
proxies, cookies and Referer are off. Loopback is reachable only through a
#[cfg(test)] policy used by the local test server.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
sanapachandClaude Opus 5.5 committed 2026-11-20 15:12:38 +02:00
1 parent c2627444c5
commit 04ae7d5bd1
4 files changed
+1312

No files matched your search

+5
View File
@@ -50,13 +50,18 @@
mod actions;
mod apply;
mod net;
mod queries;
mod refresh;
pub(crate) mod schema;
#[cfg(test)]
mod net_tests;
#[cfg(test)]
pub(crate) mod postgres_tests;
#[cfg(test)]
pub(crate) mod test_server;
#[cfg(test)]
mod tests;
use std::fmt;
+570
View File
@@ -0,0 +1,570 @@
//! Outbound HTTP for podcast feeds and the audio proxy, guarded against SSRF.
//!
//! Feed URLs and enclosure URLs come from users and from third-party feed
//! documents, so the server must never be tricked into requesting its own
//! network. Every request made through [`SafeHttp`]:
//!
//! * accepts only `http` and `https` URLs with a host and without userinfo;
//! * resolves host names with [`GuardedResolver`], which rejects the whole
//! answer when **any** address is not public (loopback, private, shared
//! CGNAT, link-local, cloud metadata, multicast, unspecified, documentation,
//! reserved; IPv4 and IPv6, including IPv4-mapped, NAT64 and 6to4 forms).
//! The connection is made to exactly the addresses that were checked: the
//! resolver *is* the connector's resolver, there is no separate pre-check
//! that a second DNS answer could bypass (DNS rebinding);
//! * checks IP-literal hosts the same way (the connector does not resolve
//! them);
//! * follows redirects itself, at most `max_redirects` hops, checking every
//! hop like the first URL;
//! * never uses a system proxy (it would resolve the target instead of the
//! guarded resolver), never stores or sends cookies and never forwards
//! credentials: callers pass the few headers they need explicitly.
//!
//! Loopback can be allowed only in tests (`AddressPolicy::test_allow_loopback`
//! is `#[cfg(test)]`), so the local test servers work and nothing else does.
use std::fmt;
use std::future::Future;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
use std::pin::Pin;
use std::sync::Arc;
use std::time::Duration;
use reqwest::header::{HeaderMap, LOCATION};
use reqwest::{StatusCode, Url};
/// Why an address is not reachable through [`SafeHttp`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum AddressClass {
/// `0.0.0.0/8`, `::`.
Unspecified,
/// `127.0.0.0/8`, `::1`.
Loopback,
/// RFC 1918 and the deprecated IPv6 site-local range.
Private,
/// `100.64.0.0/10` (carrier-grade NAT).
SharedCgnat,
/// `169.254.0.0/16`, `fe80::/10`.
LinkLocal,
/// Cloud instance metadata endpoints.
CloudMetadata,
/// `fc00::/7`.
UniqueLocal,
/// `224.0.0.0/4`, `ff00::/8`.
Multicast,
/// `255.255.255.255`.
Broadcast,
/// Documentation ranges (`192.0.2.0/24`, `2001:db8::/32`, ...).
Documentation,
/// `198.18.0.0/15`, `2001:2::/48`.
Benchmarking,
/// Everything else outside global unicast (IETF protocol assignments,
/// `240.0.0.0/4`, IPv4-compatible IPv6, Teredo, local NAT64, ...).
Reserved,
}
impl fmt::Display for AddressClass {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::Unspecified => "unspecified",
Self::Loopback => "loopback",
Self::Private => "private",
Self::SharedCgnat => "shared (CGNAT)",
Self::LinkLocal => "link-local",
Self::CloudMetadata => "cloud metadata",
Self::UniqueLocal => "unique local",
Self::Multicast => "multicast",
Self::Broadcast => "broadcast",
Self::Documentation => "documentation",
Self::Benchmarking => "benchmarking",
Self::Reserved => "reserved",
})
}
}
/// Well-known cloud metadata endpoints. They also fall into blocked ranges
/// (link-local, CGNAT, unique local); naming them makes errors clearer.
const METADATA_V4: [Ipv4Addr; 3] = [
Ipv4Addr::new(169, 254, 169, 254),
Ipv4Addr::new(169, 254, 170, 2),
Ipv4Addr::new(100, 100, 100, 200),
];
const METADATA_V6: [Ipv6Addr; 1] = [Ipv6Addr::new(0xfd00, 0x0ec2, 0, 0, 0, 0, 0, 0x0254)];
fn in_v4(ip: Ipv4Addr, net: [u8; 4], prefix: u32) -> bool {
let mask = if prefix == 0 {
0
} else {
u32::MAX << (32 - prefix)
};
u32::from(ip) & mask == u32::from(Ipv4Addr::from(net)) & mask
}
fn in_v6(ip: Ipv6Addr, net: [u16; 8], prefix: u32) -> bool {
let mask = if prefix == 0 {
0
} else {
u128::MAX << (128 - prefix)
};
let [a, b, c, d, e, f, g, h] = net;
u128::from(ip) & mask == u128::from(Ipv6Addr::new(a, b, c, d, e, f, g, h)) & mask
}
/// Class of a non-public IPv4 address; `None` for a public one.
fn classify_v4(ip: Ipv4Addr) -> Option<AddressClass> {
use AddressClass::*;
if METADATA_V4.contains(&ip) {
return Some(CloudMetadata);
}
const RULES: &[([u8; 4], u32, AddressClass)] = &[
([0, 0, 0, 0], 8, Unspecified),
([10, 0, 0, 0], 8, Private),
([100, 64, 0, 0], 10, SharedCgnat),
([127, 0, 0, 0], 8, Loopback),
([169, 254, 0, 0], 16, LinkLocal),
([172, 16, 0, 0], 12, Private),
([192, 0, 0, 0], 24, Reserved),
([192, 0, 2, 0], 24, Documentation),
([192, 88, 99, 0], 24, Reserved),
([192, 168, 0, 0], 16, Private),
([198, 18, 0, 0], 15, Benchmarking),
([198, 51, 100, 0], 24, Documentation),
([203, 0, 113, 0], 24, Documentation),
([224, 0, 0, 0], 4, Multicast),
([255, 255, 255, 255], 32, Broadcast),
([240, 0, 0, 0], 4, Reserved),
];
RULES
.iter()
.find(|(net, prefix, _)| in_v4(ip, *net, *prefix))
.map(|(_, _, class)| *class)
}
/// Class of a non-public IPv6 address; `None` for a public one. Forms that
/// embed an IPv4 address (mapped, NAT64, 6to4) are judged by that address.
fn classify_v6(ip: Ipv6Addr) -> Option<AddressClass> {
use AddressClass::*;
if METADATA_V6.contains(&ip) {
return Some(CloudMetadata);
}
if ip.is_unspecified() {
return Some(Unspecified);
}
if ip.is_loopback() {
return Some(Loopback);
}
let bits = u128::from(ip);
let embedded_v4 = |shift: u32| Ipv4Addr::from((bits >> shift) as u32);
// ::ffff:a.b.c.d
if let Some(v4) = ip.to_ipv4_mapped() {
return classify_v4(v4);
}
// 64:ff9b::/96, the well-known NAT64 prefix.
if in_v6(ip, [0x64, 0xff9b, 0, 0, 0, 0, 0, 0], 96) {
return classify_v4(embedded_v4(0));
}
// 2002::/16, 6to4: the IPv4 address follows the prefix.
if in_v6(ip, [0x2002, 0, 0, 0, 0, 0, 0, 0], 16) {
return classify_v4(embedded_v4(80));
}
const RULES: &[([u16; 8], u32, AddressClass)] = &[
// IPv4-compatible (deprecated) and the rest of ::/96.
([0, 0, 0, 0, 0, 0, 0, 0], 96, Reserved),
([0x64, 0xff9b, 1, 0, 0, 0, 0, 0], 48, Reserved),
([0x100, 0, 0, 0, 0, 0, 0, 0], 64, Reserved),
([0x2001, 0x2, 0, 0, 0, 0, 0, 0], 48, Benchmarking),
([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0], 32, Documentation),
// IETF protocol assignments, including Teredo (2001::/32).
([0x2001, 0, 0, 0, 0, 0, 0, 0], 23, Reserved),
([0x3fff, 0, 0, 0, 0, 0, 0, 0], 20, Documentation),
([0xfc00, 0, 0, 0, 0, 0, 0, 0], 7, UniqueLocal),
([0xfe80, 0, 0, 0, 0, 0, 0, 0], 10, LinkLocal),
([0xfec0, 0, 0, 0, 0, 0, 0, 0], 10, Private),
([0xff00, 0, 0, 0, 0, 0, 0, 0], 8, Multicast),
];
if let Some((_, _, class)) = RULES
.iter()
.find(|(net, prefix, _)| in_v6(ip, *net, *prefix))
{
return Some(*class);
}
// Only global unicast (2000::/3) is public.
(!in_v6(ip, [0x2000, 0, 0, 0, 0, 0, 0, 0], 3)).then_some(Reserved)
}
/// Class of a non-public address; `None` when it is public.
pub(crate) fn classify(ip: IpAddr) -> Option<AddressClass> {
match ip {
IpAddr::V4(ip) => classify_v4(ip),
IpAddr::V6(ip) => classify_v6(ip),
}
}
/// Which addresses [`SafeHttp`] may connect to.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct AddressPolicy {
allow_loopback: bool,
}
impl AddressPolicy {
/// Public addresses only. The only policy available outside tests.
pub(crate) const PUBLIC_ONLY: Self = Self {
allow_loopback: false,
};
/// Public addresses plus loopback, for the local test servers.
#[cfg(test)]
pub(crate) const fn test_allow_loopback() -> Self {
Self {
allow_loopback: true,
}
}
/// Checks one address.
pub(crate) fn check(&self, ip: IpAddr) -> Result<(), AddressClass> {
match classify(ip) {
None => Ok(()),
Some(AddressClass::Loopback) if self.allow_loopback => Ok(()),
Some(class) => Err(class),
}
}
}
/// A host name or literal resolved to an address that is not allowed.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct BlockedAddress {
/// Host as written in the URL.
pub(crate) host: String,
/// The offending address.
pub(crate) address: IpAddr,
/// Why it is blocked.
pub(crate) class: AddressClass,
}
impl fmt::Display for BlockedAddress {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let literal = self.host.trim_start_matches('[').trim_end_matches(']');
if literal.parse::<IpAddr>().is_ok() {
write!(f, "{} is a {} address", self.host, self.class)?;
} else {
write!(
f,
"{} resolves to a {} address ({})",
self.host, self.class, self.address
)?;
}
f.write_str("; only public addresses are allowed")
}
}
impl std::error::Error for BlockedAddress {}
/// Name resolution used by [`GuardedResolver`].
pub(crate) trait HostLookup: Send + Sync + 'static {
/// Every address of `host` (a DNS name, never an IP literal).
fn lookup(&self, host: &str) -> LookupFuture;
}
pub(crate) type LookupFuture =
Pin<Box<dyn Future<Output = std::io::Result<Vec<IpAddr>>> + Send + 'static>>;
/// The operating system resolver (`getaddrinfo` via tokio).
#[derive(Debug, Clone, Copy, Default)]
pub(crate) struct SystemLookup;
impl HostLookup for SystemLookup {
fn lookup(&self, host: &str) -> LookupFuture {
let host = host.to_string();
Box::pin(async move {
Ok(tokio::net::lookup_host((host.as_str(), 0))
.await?
.map(|addr| addr.ip())
.collect())
})
}
}
const LOOKUP_TIMEOUT: Duration = Duration::from_secs(10);
/// DNS resolver of the guarded client: resolves, then rejects the answer
/// unless every address is allowed. The connector connects to exactly the
/// returned addresses, so a checked answer cannot be swapped afterwards.
pub(crate) struct GuardedResolver {
policy: AddressPolicy,
lookup: Arc<dyn HostLookup>,
}
impl GuardedResolver {
pub(crate) fn new(policy: AddressPolicy, lookup: Arc<dyn HostLookup>) -> Self {
Self { policy, lookup }
}
/// Resolves and checks `host`; the addresses a connection may use.
pub(crate) async fn resolve_checked(
&self,
host: &str,
) -> Result<Vec<IpAddr>, Box<dyn std::error::Error + Send + Sync>> {
let ips = tokio::time::timeout(LOOKUP_TIMEOUT, self.lookup.lookup(host))
.await
.map_err(|_| format!("resolving {host} timed out"))??;
if ips.is_empty() {
return Err(format!("{host} has no addresses").into());
}
for ip in &ips {
if let Err(class) = self.policy.check(*ip) {
return Err(Box::new(BlockedAddress {
host: host.to_string(),
address: *ip,
class,
}));
}
}
Ok(ips)
}
}
impl reqwest::dns::Resolve for GuardedResolver {
fn resolve(&self, name: reqwest::dns::Name) -> reqwest::dns::Resolving {
let resolver = Self {
policy: self.policy,
lookup: Arc::clone(&self.lookup),
};
let host = name.as_str().to_string();
Box::pin(async move {
let ips = resolver.resolve_checked(&host).await?;
// Port 0: the connector uses the URL's port.
let addrs: Vec<SocketAddr> = ips.into_iter().map(|ip| SocketAddr::new(ip, 0)).collect();
Ok(Box::new(addrs.into_iter()) as reqwest::dns::Addrs)
})
}
}
/// Errors of [`SafeHttp`].
#[derive(Debug)]
pub(crate) enum GuardError {
/// Not `http`/`https`.
UnsupportedScheme(String),
/// The URL carries `user:password@`.
Credentials,
/// The URL has no host.
MissingHost,
/// The host is (or resolves to) a blocked address.
Blocked(BlockedAddress),
/// More redirects than allowed.
TooManyRedirects(usize),
/// A redirect without a usable `Location`.
InvalidRedirect(String),
/// Any other transport failure (DNS, connect, TLS, timeout, ...).
Http(reqwest::Error),
}
impl GuardError {
pub(crate) fn is_timeout(&self) -> bool {
matches!(self, Self::Http(error) if error.is_timeout())
}
}
impl fmt::Display for GuardError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::UnsupportedScheme(scheme) => {
write!(f, "unsupported URL scheme {scheme:?} (only http and https)")
}
Self::Credentials => f.write_str("URLs with credentials are not allowed"),
Self::MissingHost => f.write_str("URL has no host"),
Self::Blocked(blocked) => blocked.fmt(f),
Self::TooManyRedirects(limit) => write!(f, "more than {limit} redirects"),
Self::InvalidRedirect(reason) => write!(f, "invalid redirect: {reason}"),
Self::Http(error) => {
write!(f, "{error}")?;
let mut source = std::error::Error::source(error);
while let Some(inner) = source {
write!(f, ": {inner}")?;
source = inner.source();
}
Ok(())
}
}
}
}
impl std::error::Error for GuardError {}
impl From<reqwest::Error> for GuardError {
/// Surfaces a resolver rejection buried in the transport error chain.
fn from(error: reqwest::Error) -> Self {
let mut source = std::error::Error::source(&error);
while let Some(inner) = source {
if let Some(blocked) = inner.downcast_ref::<BlockedAddress>() {
return Self::Blocked(blocked.clone());
}
source = inner.source();
}
Self::Http(error)
}
}
/// Timeouts and limits of a [`SafeHttp`] client.
#[derive(Debug, Clone, Copy)]
pub(crate) struct SafeHttpConfig {
/// TCP + TLS connect timeout (name resolution has its own 10 s bound).
pub(crate) connect_timeout: Duration,
/// Maximum time between two reads of a response.
pub(crate) read_timeout: Duration,
/// Whole-request timeout including the body; `None` for streams.
pub(crate) total_timeout: Option<Duration>,
/// Redirect hops followed before giving up.
pub(crate) max_redirects: usize,
}
/// A response after following redirects.
#[derive(Debug)]
pub(crate) struct Followed {
/// The final response (never a followed redirect).
pub(crate) response: reqwest::Response,
/// URL of the final response.
pub(crate) final_url: Url,
/// Status of every redirect followed, in order.
pub(crate) redirects: Vec<StatusCode>,
}
impl Followed {
/// Whether at least one redirect was followed and all of them were
/// permanent (301/308): only then has the resource moved.
pub(crate) fn moved_permanently(&self) -> bool {
!self.redirects.is_empty()
&& self
.redirects
.iter()
.all(|status| matches!(status.as_u16(), 301 | 308))
}
}
/// SSRF-guarded HTTP client (see the module documentation).
#[derive(Clone)]
pub(crate) struct SafeHttp {
client: reqwest::Client,
policy: AddressPolicy,
max_redirects: usize,
}
impl fmt::Debug for SafeHttp {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SafeHttp")
.field("policy", &self.policy)
.field("max_redirects", &self.max_redirects)
.finish_non_exhaustive()
}
}
impl SafeHttp {
/// A production client: public addresses only, system DNS.
pub(crate) fn public(config: SafeHttpConfig) -> anyhow::Result<Self> {
Self::with_lookup(config, AddressPolicy::PUBLIC_ONLY, Arc::new(SystemLookup))
}
/// A client with an explicit policy and resolver (tests inject both).
pub(crate) fn with_lookup(
config: SafeHttpConfig,
policy: AddressPolicy,
lookup: Arc<dyn HostLookup>,
) -> anyhow::Result<Self> {
let mut builder = reqwest::Client::builder()
.dns_resolver(Arc::new(GuardedResolver::new(policy, lookup)))
// A proxy would resolve the target itself, bypassing the guard.
.no_proxy()
.redirect(reqwest::redirect::Policy::none())
.referer(false)
.connect_timeout(config.connect_timeout)
.read_timeout(config.read_timeout)
.user_agent(concat!(
"furumusic/",
env!("CARGO_PKG_VERSION"),
" (podcasts)"
));
if let Some(timeout) = config.total_timeout {
builder = builder.timeout(timeout);
}
Ok(Self {
client: builder.build()?,
policy,
max_redirects: config.max_redirects,
})
}
/// Checks a URL before any connection: scheme, credentials, host, and
/// IP-literal hosts against the policy (names are checked by the
/// resolver at connect time).
pub(crate) fn check_url(&self, url: &Url) -> Result<(), GuardError> {
check_url(self.policy, url)
}
/// `GET url` with `headers`, following redirects (each hop checked, the
/// same headers re-sent; nothing else is added).
pub(crate) async fn get(&self, url: Url, headers: &HeaderMap) -> Result<Followed, GuardError> {
let mut url = url;
let mut redirects = Vec::new();
loop {
self.check_url(&url)?;
let response = self
.client
.get(url.clone())
.headers(headers.clone())
.send()
.await?;
let status = response.status();
if !matches!(status.as_u16(), 301 | 302 | 303 | 307 | 308) {
return Ok(Followed {
response,
final_url: url,
redirects,
});
}
if redirects.len() >= self.max_redirects {
return Err(GuardError::TooManyRedirects(self.max_redirects));
}
let location = response
.headers()
.get(LOCATION)
.and_then(|value| value.to_str().ok())
.ok_or_else(|| {
GuardError::InvalidRedirect(format!("HTTP {status} without Location"))
})?;
let next = url
.join(location)
.map_err(|error| GuardError::InvalidRedirect(format!("{location:?}: {error}")))?;
redirects.push(status);
url = next;
}
}
}
/// See [`SafeHttp::check_url`].
pub(crate) fn check_url(policy: AddressPolicy, url: &Url) -> Result<(), GuardError> {
if !matches!(url.scheme(), "http" | "https") {
return Err(GuardError::UnsupportedScheme(url.scheme().to_string()));
}
if !url.username().is_empty() || url.password().is_some() {
return Err(GuardError::Credentials);
}
let host = url
.host_str()
.filter(|host| !host.is_empty())
.ok_or(GuardError::MissingHost)?;
// The URL parser normalizes every IPv4 spelling (decimal, octal, hex,
// trailing dot) to dotted quads and keeps IPv6 literals in brackets.
let bare = host
.strip_prefix('[')
.and_then(|host| host.strip_suffix(']'))
.unwrap_or(host);
if let Ok(ip) = bare.parse::<IpAddr>() {
policy.check(ip).map_err(|class| {
GuardError::Blocked(BlockedAddress {
host: host.to_string(),
address: ip,
class,
})
})?;
}
Ok(())
}
+358
View File
@@ -0,0 +1,358 @@
//! SSRF guard: address classes, URL checks, the resolver, DNS rebinding,
//! redirects and headers. Network tests use the local test server; loopback
//! is allowed only through the test-only `AddressPolicy::test_allow_loopback`.
use std::net::IpAddr;
use std::sync::Arc;
use std::sync::atomic::Ordering;
use reqwest::Url;
use reqwest::header::HeaderMap;
use super::net::{
AddressClass, AddressPolicy, BlockedAddress, GuardError, GuardedResolver, SafeHttp, check_url,
classify,
};
use super::test_server::{Route, ScriptedLookup, TEST_HTTP, TestServer, test_http};
// ---------------------------------------------------------------------------
// Address classes
// ---------------------------------------------------------------------------
fn ip(text: &str) -> IpAddr {
text.parse().unwrap()
}
#[test]
fn public_addresses_are_allowed() {
for address in [
"8.8.8.8",
"1.1.1.1",
"93.184.215.14",
"172.32.0.1",
"100.128.0.1",
"192.0.3.1",
"2606:4700:4700::1111",
"2a00:1450:4001:80b::200e",
"::ffff:8.8.8.8",
"64:ff9b::808:808",
"2002:808:808::1",
] {
assert_eq!(classify(ip(address)), None, "{address}");
assert_eq!(AddressPolicy::PUBLIC_ONLY.check(ip(address)), Ok(()));
}
}
#[test]
fn non_public_addresses_are_classified() {
use AddressClass::*;
let cases = [
// IPv4
("0.0.0.0", Unspecified),
("0.1.2.3", Unspecified),
("10.1.2.3", Private),
("100.64.0.1", SharedCgnat),
("100.127.255.254", SharedCgnat),
("127.0.0.1", Loopback),
("127.255.0.9", Loopback),
("169.254.1.1", LinkLocal),
("169.254.169.254", CloudMetadata),
("169.254.170.2", CloudMetadata),
("100.100.100.200", CloudMetadata),
("172.16.0.1", Private),
("172.31.255.255", Private),
("192.0.0.8", Reserved),
("192.0.2.5", Documentation),
("192.88.99.1", Reserved),
("192.168.1.1", Private),
("198.18.0.1", Benchmarking),
("198.19.255.255", Benchmarking),
("198.51.100.1", Documentation),
("203.0.113.1", Documentation),
("224.0.0.1", Multicast),
("239.255.255.250", Multicast),
("240.0.0.1", Reserved),
("255.255.255.255", Broadcast),
// IPv6
("::", Unspecified),
("::1", Loopback),
("::ffff:127.0.0.1", Loopback),
("::ffff:10.0.0.1", Private),
("::ffff:169.254.169.254", CloudMetadata),
("::ffff:0.0.0.0", Unspecified),
("::127.0.0.1", Reserved),
("::8.8.8.8", Reserved),
("64:ff9b::a00:1", Private),
("64:ff9b::7f00:1", Loopback),
("64:ff9b:1::1", Reserved),
("2002:7f00:1::1", Loopback),
("2002:a9fe:a9fe::1", CloudMetadata),
("2002:c0a8:101::1", Private),
("100::1", Reserved),
("2001::1", Reserved),
("2001:2::1", Benchmarking),
("2001:db8::1", Documentation),
("3fff::1", Documentation),
("fc00::1", UniqueLocal),
("fd12:3456::1", UniqueLocal),
("fd00:ec2::254", CloudMetadata),
("fe80::1", LinkLocal),
("febf::1", LinkLocal),
("fec0::1", Private),
("ff02::1", Multicast),
("4000::1", Reserved),
("::2", Reserved),
];
for (address, class) in cases {
assert_eq!(classify(ip(address)), Some(class), "{address}");
assert_eq!(
AddressPolicy::PUBLIC_ONLY.check(ip(address)),
Err(class),
"{address}"
);
}
}
#[test]
fn only_the_test_policy_allows_loopback_and_nothing_else() {
let test = AddressPolicy::test_allow_loopback();
assert_eq!(test.check(ip("127.0.0.1")), Ok(()));
assert_eq!(test.check(ip("::1")), Ok(()));
assert_eq!(test.check(ip("::ffff:127.0.0.1")), Ok(()));
assert_eq!(test.check(ip("10.0.0.1")), Err(AddressClass::Private));
assert_eq!(
test.check(ip("169.254.169.254")),
Err(AddressClass::CloudMetadata)
);
assert_eq!(
AddressPolicy::PUBLIC_ONLY.check(ip("127.0.0.1")),
Err(AddressClass::Loopback)
);
}
fn url(text: &str) -> Url {
Url::parse(text).unwrap()
}
#[test]
fn urls_are_checked_before_connecting() {
let policy = AddressPolicy::PUBLIC_ONLY;
for (text, class) in [
("http://127.0.0.1/feed", AddressClass::Loopback),
// Every IPv4 spelling is normalized by the URL parser.
("http://2130706433/feed", AddressClass::Loopback),
("http://0x7f.1/feed", AddressClass::Loopback),
("http://127.1/feed", AddressClass::Loopback),
("http://0177.0.0.1/feed", AddressClass::Loopback),
("http://127.0.0.1./feed", AddressClass::Loopback),
("http://0/feed", AddressClass::Unspecified),
("http://[::1]:8080/feed", AddressClass::Loopback),
("http://[::ffff:7f00:1]/feed", AddressClass::Loopback),
("http://[::ffff:a9fe:a9fe]/", AddressClass::CloudMetadata),
(
"http://169.254.169.254/latest/meta-data/",
AddressClass::CloudMetadata,
),
("https://10.0.0.5/audio.mp3", AddressClass::Private),
("https://[fd00::1]/audio.mp3", AddressClass::UniqueLocal),
] {
match check_url(policy, &url(text)) {
Err(GuardError::Blocked(blocked)) => assert_eq!(blocked.class, class, "{text}"),
other => panic!("{text}: {other:?}"),
}
}
assert!(matches!(
check_url(policy, &url("ftp://example.com/feed")),
Err(GuardError::UnsupportedScheme(_))
));
assert!(matches!(
check_url(policy, &url("file:///etc/passwd")),
Err(GuardError::UnsupportedScheme(_))
));
assert!(matches!(
check_url(policy, &url("https://user:secret@example.com/feed")),
Err(GuardError::Credentials)
));
assert!(matches!(
check_url(policy, &url("https://user@example.com/feed")),
Err(GuardError::Credentials)
));
// Names are checked by the resolver at connect time.
assert!(check_url(policy, &url("https://feeds.example.com/rss")).is_ok());
assert!(check_url(policy, &url("http://localhost/rss")).is_ok());
}
// ---------------------------------------------------------------------------
// Resolver
// ---------------------------------------------------------------------------
fn blocked_class(error: &(dyn std::error::Error + Send + Sync + 'static)) -> Option<AddressClass> {
error
.downcast_ref::<BlockedAddress>()
.map(|blocked| blocked.class)
}
#[tokio::test]
async fn resolver_rejects_the_whole_answer_when_any_address_is_not_public() {
let lookup = ScriptedLookup::with(&[
("public.test", &[&["8.8.8.8", "2606:4700:4700::1111"]]),
("mixed.test", &[&["8.8.8.8", "10.0.0.1"]]),
("mapped.test", &[&["::ffff:192.168.0.10"]]),
("localhost", &[&["127.0.0.1", "::1"]]),
("empty.test", &[&[]]),
]);
let resolver = GuardedResolver::new(AddressPolicy::PUBLIC_ONLY, lookup);
assert_eq!(
resolver.resolve_checked("public.test").await.unwrap(),
vec![ip("8.8.8.8"), ip("2606:4700:4700::1111")]
);
let error = resolver.resolve_checked("mixed.test").await.unwrap_err();
assert_eq!(blocked_class(error.as_ref()), Some(AddressClass::Private));
let error = resolver.resolve_checked("mapped.test").await.unwrap_err();
assert_eq!(blocked_class(error.as_ref()), Some(AddressClass::Private));
let error = resolver.resolve_checked("localhost").await.unwrap_err();
assert_eq!(blocked_class(error.as_ref()), Some(AddressClass::Loopback));
assert!(resolver.resolve_checked("empty.test").await.is_err());
assert!(resolver.resolve_checked("nowhere.test").await.is_err());
}
fn public_http(lookup: Arc<ScriptedLookup>) -> SafeHttp {
SafeHttp::with_lookup(TEST_HTTP, AddressPolicy::PUBLIC_ONLY, lookup).unwrap()
}
#[tokio::test]
async fn production_policy_never_reaches_a_local_server() {
let server = TestServer::start();
server.set("/feed", Route::new("ok", "text/plain"));
let lookup = ScriptedLookup::with(&[("loop.test", &[&["127.0.0.1"]])]);
let http = public_http(Arc::clone(&lookup));
for target in [server.url("/feed"), server.url_on("loop.test", "/feed")] {
match http.get(url(&target), &HeaderMap::new()).await {
Err(GuardError::Blocked(blocked)) => {
assert_eq!(blocked.class, AddressClass::Loopback, "{target}")
}
other => panic!("{target}: {other:?}"),
}
}
assert_eq!(server.request_count(), 0);
}
#[tokio::test]
async fn every_connection_uses_the_addresses_it_checked() {
// DNS rebinding: the first answer is allowed, the next one points to a
// private address. Each connection resolves and checks once and
// connects to exactly those addresses, so the rebound answer is refused
// instead of being used after an earlier successful check.
let server = TestServer::start();
server.set("/feed", Route::new("first", "text/plain"));
let lookup = ScriptedLookup::with(&[("rebind.test", &[&["127.0.0.1"], &["10.0.0.7"]])]);
let http = test_http(Arc::clone(&lookup));
let target = url(&server.url_on("rebind.test", "/feed"));
let first = http.get(target.clone(), &HeaderMap::new()).await.unwrap();
assert_eq!(first.response.text().await.unwrap(), "first");
match http.get(target, &HeaderMap::new()).await {
Err(GuardError::Blocked(blocked)) => {
assert_eq!(blocked.class, AddressClass::Private);
assert_eq!(blocked.address, ip("10.0.0.7"));
}
other => panic!("{other:?}"),
}
assert_eq!(lookup.calls.load(Ordering::SeqCst), 2);
assert_eq!(server.requests("/feed").len(), 1);
}
#[tokio::test]
async fn every_redirect_hop_is_checked() {
let server = TestServer::start();
let lookup = ScriptedLookup::with(&[("intranet.test", &[&["192.168.1.20"]])]);
let http = test_http(lookup);
let cases = [
(
"/to-private",
"http://10.0.0.1/feed".to_string(),
AddressClass::Private,
),
(
"/to-metadata",
"http://169.254.169.254/latest/meta-data/".to_string(),
AddressClass::CloudMetadata,
),
(
"/to-mapped",
"http://[::ffff:10.1.1.1]/".to_string(),
AddressClass::Private,
),
(
"/to-name",
server.url_on("intranet.test", "/feed"),
AddressClass::Private,
),
];
for (path, location, class) in &cases {
server.set(path, Route::redirect(302, location));
match http.get(url(&server.url(path)), &HeaderMap::new()).await {
Err(GuardError::Blocked(blocked)) => assert_eq!(blocked.class, *class, "{path}"),
other => panic!("{path}: {other:?}"),
}
}
server.set("/to-file", Route::redirect(301, "file:///etc/passwd"));
assert!(matches!(
http.get(url(&server.url("/to-file")), &HeaderMap::new())
.await,
Err(GuardError::UnsupportedScheme(_))
));
server.set("/no-location", Route::new("", "text/plain").status(302));
assert!(matches!(
http.get(url(&server.url("/no-location")), &HeaderMap::new())
.await,
Err(GuardError::InvalidRedirect(_))
));
// Hop limit (3 in the test client): /hop0 -> /hop1 -> ... -> /hop4.
for hop in 0..4 {
server.set(
&format!("/hop{hop}"),
Route::redirect(307, &format!("/hop{}", hop + 1)),
);
}
server.set("/hop4", Route::new("end", "text/plain"));
assert!(matches!(
http.get(url(&server.url("/hop0")), &HeaderMap::new()).await,
Err(GuardError::TooManyRedirects(3))
));
let followed = http
.get(url(&server.url("/hop1")), &HeaderMap::new())
.await
.unwrap();
assert_eq!(followed.redirects.len(), 3);
assert_eq!(followed.final_url.path(), "/hop4");
}
#[tokio::test]
async fn no_cookies_or_credentials_are_sent() {
let server = TestServer::start();
server.set(
"/start",
Route::redirect(302, "/next").header("Set-Cookie", "session=leak; Path=/"),
);
server.set(
"/next",
Route::new("ok", "text/plain").header("Set-Cookie", "other=leak; Path=/"),
);
let http = test_http(ScriptedLookup::with(&[]));
for _ in 0..2 {
let followed = http
.get(url(&server.url("/start")), &HeaderMap::new())
.await
.unwrap();
assert_eq!(followed.response.text().await.unwrap(), "ok");
}
for request in server
.requests("/start")
.iter()
.chain(&server.requests("/next"))
{
for header in ["cookie", "authorization", "referer", "proxy-authorization"] {
assert!(!request.contains_key(header), "{header} sent: {request:?}");
}
}
}
+379
View File
@@ -0,0 +1,379 @@
//! Test support of the podcast runtime: a scripted resolver, a client that
//! may reach loopback, and a minimal HTTP/1.1 server on 127.0.0.1 (no
//! internet). One request per connection (`Connection: close`), so every
//! request opens a new connection and resolves its host again.
//!
//! Adapted from the furumi-tui prototype's test server: routes can redirect,
//! send extra headers and answer conditional requests, and every request's
//! headers are recorded.
use std::collections::{HashMap, VecDeque};
use std::io::{BufRead, BufReader, Write};
use std::net::{IpAddr, TcpListener, TcpStream};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, PoisonError};
use std::time::Duration;
use super::net::{AddressPolicy, HostLookup, LookupFuture, SafeHttp, SafeHttpConfig};
#[derive(Clone)]
pub(crate) struct Route {
pub(crate) status: u16,
pub(crate) body: Arc<Vec<u8>>,
pub(crate) content_type: Option<String>,
pub(crate) etag: Option<String>,
pub(crate) last_modified: Option<String>,
/// Honour `Range` requests with 206 responses.
pub(crate) ranges: bool,
/// Send `Content-Length` (otherwise the body is close-delimited).
pub(crate) send_length: bool,
/// Close the connection once the body reaches this absolute offset.
pub(crate) cut_after: Option<usize>,
/// Extra response headers.
pub(crate) headers: Vec<(String, String)>,
/// Pause between the headers and the body.
pub(crate) body_delay: Option<Duration>,
}
impl Route {
pub(crate) fn new(body: impl Into<Vec<u8>>, content_type: &str) -> Route {
Route {
status: 200,
body: Arc::new(body.into()),
content_type: Some(content_type.to_string()),
etag: None,
last_modified: None,
ranges: true,
send_length: true,
cut_after: None,
headers: Vec::new(),
body_delay: None,
}
}
/// A redirect to `location` with `status`.
pub(crate) fn redirect(status: u16, location: &str) -> Route {
Route {
status,
body: Arc::new(Vec::new()),
content_type: None,
ranges: false,
..Route::new(Vec::new(), "text/plain")
}
.header("Location", location)
}
pub(crate) fn status(mut self, status: u16) -> Route {
self.status = status;
self
}
pub(crate) fn etag(mut self, etag: &str) -> Route {
self.etag = Some(etag.to_string());
self
}
pub(crate) fn last_modified(mut self, date: &str) -> Route {
self.last_modified = Some(date.to_string());
self
}
pub(crate) fn no_ranges(mut self) -> Route {
self.ranges = false;
self
}
pub(crate) fn no_length(mut self) -> Route {
self.send_length = false;
self
}
pub(crate) fn no_content_type(mut self) -> Route {
self.content_type = None;
self
}
pub(crate) fn cut(mut self, after: usize) -> Route {
self.cut_after = Some(after);
self
}
pub(crate) fn delay_body(mut self, delay: Duration) -> Route {
self.body_delay = Some(delay);
self
}
pub(crate) fn header(mut self, name: &str, value: &str) -> Route {
self.headers.push((name.to_string(), value.to_string()));
self
}
}
/// Lowercased request headers of one request.
pub(crate) type RequestHeaders = HashMap<String, String>;
#[derive(Default)]
struct ServerState {
routes: HashMap<String, Route>,
requests: HashMap<String, Vec<RequestHeaders>>,
}
pub(crate) struct TestServer {
port: u16,
state: Arc<Mutex<ServerState>>,
}
impl TestServer {
pub(crate) fn start() -> TestServer {
let listener = TcpListener::bind("127.0.0.1:0").expect("bind test server");
let port = listener.local_addr().expect("local addr").port();
let state = Arc::new(Mutex::new(ServerState::default()));
let accept_state = Arc::clone(&state);
std::thread::spawn(move || {
for stream in listener.incoming() {
let Ok(stream) = stream else { continue };
let state = Arc::clone(&accept_state);
std::thread::spawn(move || handle(stream, &state));
}
});
TestServer { port, state }
}
pub(crate) fn port(&self) -> u16 {
self.port
}
/// `http://127.0.0.1:<port><path>`.
pub(crate) fn url(&self, path: &str) -> String {
format!("http://127.0.0.1:{}{path}", self.port)
}
/// `http://<host>:<port><path>` (for hosts mapped by a test resolver).
pub(crate) fn url_on(&self, host: &str, path: &str) -> String {
format!("http://{host}:{}{path}", self.port)
}
pub(crate) fn set(&self, path: &str, route: Route) {
self.lock().routes.insert(path.to_string(), route);
}
/// Headers of every request to `path`, in order.
pub(crate) fn requests(&self, path: &str) -> Vec<RequestHeaders> {
self.lock().requests.get(path).cloned().unwrap_or_default()
}
/// Requests to any path.
pub(crate) fn request_count(&self) -> usize {
self.lock().requests.values().map(Vec::len).sum()
}
fn lock(&self) -> std::sync::MutexGuard<'_, ServerState> {
self.state.lock().unwrap_or_else(PoisonError::into_inner)
}
}
fn handle(stream: TcpStream, state: &Mutex<ServerState>) {
let _ = stream.set_read_timeout(Some(Duration::from_secs(10)));
let mut reader = BufReader::new(match stream.try_clone() {
Ok(stream) => stream,
Err(_) => return,
});
let mut request_line = String::new();
if reader.read_line(&mut request_line).is_err() {
return;
}
let path = request_line
.split_whitespace()
.nth(1)
.unwrap_or("/")
.to_string();
let mut headers = HashMap::new();
loop {
let mut line = String::new();
match reader.read_line(&mut line) {
Ok(0) | Err(_) => return,
Ok(_) => {}
}
let line = line.trim_end();
if line.is_empty() {
break;
}
if let Some((name, value)) = line.split_once(':') {
headers.insert(name.trim().to_ascii_lowercase(), value.trim().to_string());
}
}
let route = {
let mut state = state.lock().unwrap_or_else(PoisonError::into_inner);
state
.requests
.entry(path.clone())
.or_default()
.push(headers.clone());
state.routes.get(&path).cloned()
};
let mut out = stream;
let Some(route) = route else {
let _ = out
.write_all(b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n");
return;
};
let not_modified = match (&route.etag, headers.get("if-none-match")) {
(Some(etag), Some(sent)) => etag == sent,
_ => matches!(
(&route.last_modified, headers.get("if-modified-since")),
(Some(date), Some(sent)) if date == sent
),
};
if route.status == 200 && not_modified {
let _ = write!(
out,
"HTTP/1.1 304 Not Modified\r\nConnection: close\r\n\r\n"
);
return;
}
let total = route.body.len();
let mut status = route.status;
let mut start = 0usize;
let mut end = total;
let mut extra = String::new();
if route.status == 200
&& route.ranges
&& let Some(range) = headers.get("range").and_then(|r| r.strip_prefix("bytes="))
&& let Some((from, to)) = range.split_once('-')
{
let (from, to) = match (from.trim().parse::<usize>(), to.trim().parse::<usize>()) {
(Ok(from), Ok(to)) => (from, (to + 1).min(total)),
(Ok(from), Err(_)) => (from, total),
(Err(_), Ok(suffix)) => (total.saturating_sub(suffix), total),
_ => (0, total),
};
if from >= total {
let _ = write!(
out,
"HTTP/1.1 416 Range Not Satisfiable\r\nContent-Range: bytes */{total}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
);
return;
}
status = 206;
start = from;
end = to;
extra.push_str(&format!(
"Content-Range: bytes {start}-{}/{total}\r\n",
end - 1
));
}
if route.ranges {
extra.push_str("Accept-Ranges: bytes\r\n");
}
if let Some(content_type) = &route.content_type {
extra.push_str(&format!("Content-Type: {content_type}\r\n"));
}
if let Some(etag) = &route.etag {
extra.push_str(&format!("ETag: {etag}\r\n"));
}
if let Some(date) = &route.last_modified {
extra.push_str(&format!("Last-Modified: {date}\r\n"));
}
for (name, value) in &route.headers {
extra.push_str(&format!("{name}: {value}\r\n"));
}
if route.send_length {
extra.push_str(&format!("Content-Length: {}\r\n", end - start));
}
if write!(
out,
"HTTP/1.1 {status} Status\r\n{extra}Connection: close\r\n\r\n"
)
.is_err()
{
return;
}
let _ = out.flush();
if let Some(delay) = route.body_delay {
std::thread::sleep(delay);
}
let limit = route.cut_after.map_or(end, |cut| cut.clamp(start, end));
for chunk in route.body[start..limit].chunks(64 * 1024) {
if out.write_all(chunk).is_err() {
return;
}
}
let _ = out.flush();
let _ = out.shutdown(std::net::Shutdown::Both);
}
/// Deterministic pseudo-random bytes.
pub(crate) fn noise(len: usize, seed: u64) -> Vec<u8> {
let mut state = seed | 1;
let mut out = Vec::with_capacity(len);
while out.len() < len {
state ^= state << 13;
state ^= state >> 7;
state ^= state << 17;
out.extend_from_slice(&state.to_le_bytes());
}
out.truncate(len);
out
}
// ---------------------------------------------------------------------------
// Resolver and client
// ---------------------------------------------------------------------------
/// Test resolver: each host answers from a script; the last answer repeats.
#[derive(Default)]
pub(crate) struct ScriptedLookup {
answers: std::sync::Mutex<HashMap<String, VecDeque<Vec<IpAddr>>>>,
pub(crate) calls: AtomicUsize,
}
impl ScriptedLookup {
pub(crate) fn with(entries: &[(&str, &[&[&str]])]) -> Arc<Self> {
let lookup = Self::default();
{
let mut answers = lookup.answers.lock().unwrap();
for (host, script) in entries {
answers.insert(
host.to_string(),
script
.iter()
.map(|answer| {
answer
.iter()
.map(|a| a.parse::<IpAddr>().unwrap())
.collect()
})
.collect(),
);
}
}
Arc::new(lookup)
}
}
impl HostLookup for ScriptedLookup {
fn lookup(&self, host: &str) -> LookupFuture {
self.calls.fetch_add(1, Ordering::SeqCst);
let mut answers = self.answers.lock().unwrap();
let answer = match answers.get_mut(host) {
Some(script) if script.len() > 1 => Ok(script.pop_front().unwrap()),
Some(script) => Ok(script.front().cloned().unwrap_or_default()),
None => Err(std::io::Error::new(
std::io::ErrorKind::NotFound,
format!("unknown test host {host}"),
)),
};
Box::pin(async move { answer })
}
}
pub(crate) const TEST_HTTP: SafeHttpConfig = SafeHttpConfig {
connect_timeout: Duration::from_secs(5),
read_timeout: Duration::from_secs(5),
total_timeout: Some(Duration::from_secs(20)),
max_redirects: 3,
};
pub(crate) fn test_http(lookup: Arc<ScriptedLookup>) -> SafeHttp {
SafeHttp::with_lookup(TEST_HTTP, AddressPolicy::test_allow_loopback(), lookup).unwrap()
}