use std::net::IpAddr;
use std::time::Duration;
use mlua::ExternalResult as _;
use reqwest::Url;
use crate::config::FetchOptions;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub(crate) struct ConnectPolicy {
pub(crate) allow_private_networks: bool,
pub(crate) private_hosts: Vec<String>,
pub(crate) connect_timeout: Duration,
pub(crate) timeout: Duration,
pub(crate) pool_max_idle_per_host: usize,
pub(crate) proxy: Option<String>,
pub(crate) no_proxy: bool,
}
impl FetchOptions {
pub(crate) fn connect_policy(&self) -> ConnectPolicy {
ConnectPolicy {
allow_private_networks: self.allow_private_networks,
private_hosts: self.private_hosts.clone(),
connect_timeout: self.connect_timeout,
timeout: self.timeout,
pool_max_idle_per_host: self.pool_max_idle_per_host,
proxy: self.proxy.clone(),
no_proxy: self.no_proxy,
}
}
}
#[derive(Debug)]
pub(crate) struct GuardedResolver {
allow_private_networks: bool,
private_hosts: Vec<String>,
}
impl GuardedResolver {
pub(crate) fn new(allow_private_networks: bool, private_hosts: Vec<String>) -> Self {
Self {
allow_private_networks,
private_hosts,
}
}
}
fn is_private_host(private_hosts: &[String], host: &str) -> bool {
private_hosts.iter().any(|h| h.eq_ignore_ascii_case(host))
}
impl reqwest::dns::Resolve for GuardedResolver {
fn resolve(&self, name: reqwest::dns::Name) -> reqwest::dns::Resolving {
let host = name.as_str().to_string();
let allow_private =
self.allow_private_networks || is_private_host(&self.private_hosts, &host);
Box::pin(async move {
let resolved: Vec<std::net::SocketAddr> = tokio::net::lookup_host((host.as_str(), 0))
.await
.map_err(|err| -> BoxError { Box::new(err) })?
.collect();
if resolved.is_empty() {
return Err(no_address(&host));
}
let allowed: Vec<std::net::SocketAddr> = resolved
.into_iter()
.filter(|addr| allow_private || !is_forbidden_ip(addr.ip()))
.collect();
if allowed.is_empty() {
return Err(forbidden(&host));
}
Ok(Box::new(allowed.into_iter()) as reqwest::dns::Addrs)
})
}
}
type BoxError = Box<dyn std::error::Error + Send + Sync>;
fn no_address(host: &str) -> BoxError {
format!("fetch host `{host}` did not resolve to any address").into()
}
fn forbidden(host: &str) -> BoxError {
Box::new(Refused(format!(
"fetch host `{host}` resolves to a private or local address: name it in \
[fetch] private_hosts, or set allow_private_networks = true to permit every one"
)))
}
#[derive(Debug)]
pub(crate) struct Refused(String);
impl std::fmt::Display for Refused {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl std::error::Error for Refused {}
pub(crate) async fn check_url(url: &Url, opts: &FetchOptions) -> mlua::Result<()> {
if !matches!(url.scheme(), "http" | "https") {
return Err(mlua::Error::RuntimeError(format!(
"fetch only supports http/https URLs, got `{url}`"
)));
}
let Some(host) = url.host() else {
return Err(mlua::Error::RuntimeError(format!(
"fetch URL `{url}` has no host"
)));
};
if let Some(allowed) = &opts.allowed_hosts {
let name = url.host_str().unwrap_or_default();
if !allowed.iter().any(|a| a.eq_ignore_ascii_case(name)) {
return Err(mlua::Error::RuntimeError(format!(
"fetch host `{name}` is not in fetch.allowed_hosts"
)));
}
}
if opts.allow_private_networks
|| is_private_host(&opts.private_hosts, url.host_str().unwrap_or_default())
{
return Ok(());
}
let ips: Vec<IpAddr> = match host {
url::Host::Ipv4(ip) => vec![ip.into()],
url::Host::Ipv6(ip) => vec![ip.into()],
url::Host::Domain(domain) => {
let port = url.port_or_known_default().unwrap_or(80);
tokio::net::lookup_host((domain, port))
.await
.into_lua_err()?
.map(|addr| addr.ip())
.collect()
}
};
if ips.is_empty() {
return Err(mlua::Error::RuntimeError(format!(
"fetch host `{}` did not resolve to any address",
url.host_str().unwrap_or_default()
)));
}
if ips.iter().any(|ip| is_forbidden_ip(*ip)) {
return Err(mlua::Error::RuntimeError(format!(
"fetch host `{}` resolves to a private or local address: name it in \
[fetch] private_hosts, or set allow_private_networks = true to permit every one",
url.host_str().unwrap_or_default()
)));
}
Ok(())
}
fn is_forbidden_ip(ip: IpAddr) -> bool {
match ip {
IpAddr::V4(v4) => {
let octets = v4.octets();
v4.is_loopback()
|| v4.is_private()
|| v4.is_link_local()
|| v4.is_unspecified()
|| v4.is_broadcast()
|| v4.is_multicast()
|| v4.is_documentation()
|| octets[0] == 0
|| (octets[0] == 100 && (64..128).contains(&octets[1]))
|| (octets[0] == 192 && octets[1] == 0 && octets[2] == 0)
|| (octets[0] == 198 && (18..20).contains(&octets[1]))
|| octets[0] >= 240
}
IpAddr::V6(v6) => {
let seg = v6.segments();
v6.is_loopback()
|| v6.is_unspecified()
|| v6.is_multicast()
|| (seg[0] & 0xfe00) == 0xfc00
|| (seg[0] & 0xffc0) == 0xfe80
|| embedded_ipv4(v6).is_some_and(|v4| is_forbidden_ip(v4.into()))
}
}
}
fn embedded_ipv4(v6: std::net::Ipv6Addr) -> Option<std::net::Ipv4Addr> {
let seg = v6.segments();
let tail = |hi: u16, lo: u16| std::net::Ipv4Addr::from(((hi as u32) << 16) | lo as u32);
if let Some(v4) = v6.to_ipv4_mapped() {
return Some(v4);
}
match seg {
[0, 0, 0, 0, 0, 0, hi, lo] => Some(tail(hi, lo)),
[0x64, 0xff9b, 0, 0, 0, 0, hi, lo] => Some(tail(hi, lo)),
[0x2002, hi, lo, ..] => Some(tail(hi, lo)),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
fn ip(s: &str) -> IpAddr {
s.parse().expect("ip literal")
}
#[test]
fn special_purpose_addresses_are_forbidden() {
for forbidden in [
"64:ff9b::a9fe:a9fe",
"64:ff9b::7f00:1",
"::7f00:1",
"2002:a9fe:a9fe::",
"ff02::1",
"224.0.0.1",
"240.0.0.1",
"0.0.0.1",
"0.1.2.3",
"192.0.0.8",
"198.18.0.1",
] {
assert!(
is_forbidden_ip(ip(forbidden)),
"{forbidden} must be forbidden"
);
}
for allowed in ["64:ff9b::0808:0808", "2002:0808:0808::", "2606:4700::1111"] {
assert!(
!is_forbidden_ip(ip(allowed)),
"{allowed} embeds a public address"
);
}
for bad in [
"127.0.0.1",
"10.1.2.3",
"172.16.0.1",
"192.168.1.1",
"169.254.169.254", "100.64.0.1", "0.0.0.0",
"::1",
"fc00::1",
"fe80::1",
"::ffff:127.0.0.1",
"::ffff:10.0.0.1",
] {
assert!(is_forbidden_ip(ip(bad)), "{bad} must be forbidden");
}
for good in ["93.184.216.34", "1.1.1.1", "2606:4700::1111"] {
assert!(!is_forbidden_ip(ip(good)), "{good} must be allowed");
}
}
#[tokio::test]
async fn the_resolver_refuses_to_hand_over_a_forbidden_address() {
use reqwest::dns::Resolve as _;
let guarded = GuardedResolver::new(false, Vec::new());
let name: reqwest::dns::Name = "localhost".parse().expect("name");
let err = guarded
.resolve(name)
.await
.err()
.expect("localhost resolves to loopback and must be refused");
assert!(err.to_string().contains("private or local"), "{err}");
let open = GuardedResolver::new(true, Vec::new());
let name: reqwest::dns::Name = "localhost".parse().expect("name");
let addrs = open.resolve(name).await.expect("allowed");
assert!(addrs.count() > 0);
}
#[tokio::test]
async fn private_hosts_are_allowed_by_name_only() {
let opts = FetchOptions {
private_hosts: vec!["localhost".into()],
..Default::default()
};
let url: Url = "http://localhost:1/x".parse().expect("url");
check_url(&url, &opts).await.expect("named host");
let other: Url = "http://127.0.0.1:1/x".parse().expect("url");
assert!(check_url(&other, &opts).await.is_err(), "not named");
use std::str::FromStr as _;
use reqwest::dns::{Name, Resolve as _};
let resolver = GuardedResolver::new(false, opts.private_hosts.clone());
let name = Name::from_str("localhost").expect("name");
let addrs = resolver.resolve(name).await.expect("named host resolves");
assert!(addrs.count() > 0);
let strict = GuardedResolver::new(false, Vec::new());
let name = Name::from_str("localhost").expect("name");
assert!(strict.resolve(name).await.is_err());
}
#[tokio::test]
async fn policy_checks_urls() {
let default = FetchOptions::default();
let url: Url = "http://127.0.0.1:8080/x".parse().expect("url");
let err = check_url(&url, &default)
.await
.expect_err("loopback under the default policy");
assert!(err.to_string().contains("private or local"), "got: {err}");
let open = FetchOptions {
allow_private_networks: true,
..Default::default()
};
check_url(&url, &open)
.await
.expect("loopback once private networks are allowed");
let ftp: Url = "ftp://example.com/x".parse().expect("url");
let err = check_url(&ftp, &open).await.expect_err("non-http scheme");
assert!(err.to_string().contains("http/https"), "got: {err}");
let listed = FetchOptions {
allowed_hosts: Some(vec!["api.example.com".into()]),
allow_private_networks: true,
..Default::default()
};
let other: Url = "http://evil.example.com/".parse().expect("url");
let err = check_url(&other, &listed).await.expect_err("unlisted host");
assert!(err.to_string().contains("allowed_hosts"), "got: {err}");
let ok: Url = "http://API.example.com/".parse().expect("url");
check_url(&ok, &listed)
.await
.expect("listed host, any case");
for literal in [
"http://169.254.169.254/latest/meta-data/",
"http://[::1]/x",
"http://10.0.0.7/x",
] {
let url: Url = literal.parse().expect("url");
let err = check_url(&url, &default)
.await
.expect_err("forbidden IP literal");
assert!(
err.to_string().contains("private or local"),
"{literal}: {err}"
);
}
}
}