use std::sync::Arc;
use base64::{Engine as _, engine::general_purpose::STANDARD};
use http::HeaderValue;
use url::Url;
use crate::{
Error, Result,
connection::{Connection, Origin, Protocol, Scheme, Settings, handshake},
proxy::{Kind as ProxyKind, Policy as ProxyPolicy},
runtime::{Deadline, Runtime},
tls::{TlsBuilder, TlsConfig},
};
#[derive(Clone)]
pub(crate) struct Transport {
tls: TlsConfig,
proxy: Proxy,
runtime: Runtime,
settings: Settings,
}
#[derive(Clone)]
enum Proxy {
Direct,
All(Arc<ExplicitProxy>),
#[cfg(feature = "system-proxy")]
System(Arc<SystemProxy>),
}
struct ExplicitProxy {
server: ProxyServer,
bypass: Vec<String>,
}
struct ProxyServer {
origin: Origin,
protocol: ProxyProtocol,
}
enum ProxyProtocol {
Http {
authorization: Option<HeaderValue>,
},
Socks5 {
username: Option<String>,
password: Option<String>,
},
}
#[cfg(feature = "system-proxy")]
struct SystemProxy {
http: Option<Arc<ProxyServer>>,
https: Option<Arc<ProxyServer>>,
no_proxy: Vec<String>,
}
impl Transport {
pub(crate) fn new(
tls: TlsBuilder,
policy: ProxyPolicy,
runtime: Runtime,
settings: Settings,
) -> Result<Self> {
let proxy = Proxy::from_policy(policy)?;
let tls = tls.build(
settings.http2_policy().is_enabled(),
proxy.uses_secure_proxy(),
)?;
Ok(Self {
tls,
proxy,
runtime,
settings,
})
}
pub(crate) async fn connect(&self, origin: &Origin, deadline: Deadline) -> Result<Connection> {
deadline.remaining()?;
let proxy = self.proxy.for_origin(origin);
let endpoint = proxy.map_or(origin, |proxy| &proxy.origin);
let connected = crate::dns::connect(
self.runtime.resolver(),
self.runtime.connector(),
&endpoint.host,
endpoint.port,
self.settings,
deadline.clone(),
)
.await?;
let (mut io, remote_addr) = connected.into_parts();
if let Some(proxy) = proxy {
match &proxy.protocol {
ProxyProtocol::Http { authorization } => {
if proxy.origin.secure() {
let proxy_tls = self.tls.proxy.as_ref().ok_or_else(Error::connect)?;
io = crate::tls::connect(
io,
&proxy.origin.host,
Arc::clone(proxy_tls),
deadline.clone(),
)
.await?
.0;
}
if origin.secure() {
io = handshake::tunnel(
io,
&origin.authority(),
authorization.as_ref(),
deadline.clone(),
)
.await?;
}
}
ProxyProtocol::Socks5 { username, password } => {
io = handshake::socks5(
io,
&origin.host,
origin.port,
username
.as_deref()
.map(|username| (username, password.as_deref().unwrap_or_default())),
deadline.clone(),
)
.await?;
}
}
}
let protocol = if origin.secure() {
let connected =
crate::tls::connect(io, &origin.host, Arc::clone(&self.tls.target), deadline)
.await?;
io = connected.0;
connected.1
} else if self.settings.http2_policy().uses_prior_knowledge()
&& proxy.is_none_or(|proxy| matches!(&proxy.protocol, ProxyProtocol::Socks5 { .. }))
{
Protocol::Http2
} else {
Protocol::Http1
};
Ok(Connection {
io,
protocol,
remote_addr,
absolute_form: proxy.is_some_and(|proxy| {
matches!(&proxy.protocol, ProxyProtocol::Http { .. }) && !origin.secure()
}),
proxy_authorization: proxy.and_then(|proxy| match &proxy.protocol {
ProxyProtocol::Http { authorization } if !origin.secure() => authorization.clone(),
_ => None,
}),
})
}
}
impl Proxy {
fn from_policy(policy: ProxyPolicy) -> Result<Self> {
match policy.into_kind() {
ProxyKind::Direct => Ok(Self::Direct),
ProxyKind::All { url, bypass } => Ok(Self::All(Arc::new(ExplicitProxy {
server: ProxyServer::parse(&url)?,
bypass,
}))),
#[cfg(feature = "system-proxy")]
ProxyKind::System => Ok(Self::System(Arc::new(SystemProxy::from_environment()?))),
}
}
fn for_origin(&self, origin: &Origin) -> Option<&ProxyServer> {
match self {
Self::Direct => None,
Self::All(proxy) => (!proxy
.bypass
.iter()
.any(|entry| no_proxy_matches(entry, &origin.host, origin.port)))
.then_some(&proxy.server),
#[cfg(feature = "system-proxy")]
Self::System(system) => system.for_origin(origin),
}
}
fn uses_secure_proxy(&self) -> bool {
match self {
Self::Direct => false,
Self::All(proxy) => proxy.server.origin.secure(),
#[cfg(feature = "system-proxy")]
Self::System(system) => system
.http
.iter()
.chain(system.https.iter())
.any(|proxy| proxy.origin.secure()),
}
}
}
impl ProxyServer {
fn parse(value: &str) -> Result<Self> {
let mut url =
Url::parse(value).map_err(|_| Error::request("client proxy URL is invalid"))?;
if !matches!(url.scheme(), "http" | "https" | "socks5h")
|| url.host_str().is_none()
|| !matches!(url.path(), "" | "/")
|| url.query().is_some()
|| url.fragment().is_some()
{
return Err(Error::request("client proxy URL is invalid"));
}
let scheme = url.scheme().to_owned();
let username = (!url.username().is_empty())
.then(|| decode_user_info(url.username()))
.transpose()?;
let password = url.password().map(decode_user_info).transpose()?;
let protocol = if scheme == "socks5h" {
ProxyProtocol::Socks5 { username, password }
} else {
if username
.as_deref()
.is_some_and(|username| username.contains(':'))
{
return Err(Error::request("client proxy credentials are invalid"));
}
let authorization = username
.as_deref()
.map(|username| {
let credentials =
format!("{username}:{}", password.as_deref().unwrap_or_default());
let mut authorization =
HeaderValue::from_str(&format!("Basic {}", STANDARD.encode(credentials)))
.map_err(|_| Error::request("client proxy credentials are invalid"))?;
authorization.set_sensitive(true);
Ok::<_, Error>(authorization)
})
.transpose()?;
ProxyProtocol::Http { authorization }
};
let _ = url.set_username("");
let _ = url.set_password(None);
let origin = Origin {
scheme: if scheme == "https" {
Scheme::Https
} else {
Scheme::Http
},
host: url
.host_str()
.ok_or_else(|| Error::request("client proxy URL is invalid"))?
.to_owned(),
port: url
.port()
.or(match scheme.as_str() {
"http" => Some(80),
"https" => Some(443),
"socks5h" => Some(1080),
_ => None,
})
.ok_or_else(|| Error::request("client proxy URL is invalid"))?,
};
Ok(Self { origin, protocol })
}
}
fn decode_user_info(value: &str) -> Result<String> {
let bytes = value.as_bytes();
let mut decoded = Vec::with_capacity(bytes.len());
let mut index = 0;
while index < bytes.len() {
if bytes[index] == b'%' {
let Some(hex) = bytes.get(index + 1..index + 3) else {
return Err(Error::request("client proxy credentials are invalid"));
};
let high = hex_digit(hex[0])
.ok_or_else(|| Error::request("client proxy credentials are invalid"))?;
let low = hex_digit(hex[1])
.ok_or_else(|| Error::request("client proxy credentials are invalid"))?;
decoded.push((high << 4) | low);
index += 3;
} else {
decoded.push(bytes[index]);
index += 1;
}
}
String::from_utf8(decoded).map_err(|_| Error::request("client proxy credentials are invalid"))
}
const fn hex_digit(byte: u8) -> Option<u8> {
match byte {
b'0'..=b'9' => Some(byte - b'0'),
b'a'..=b'f' => Some(byte - b'a' + 10),
b'A'..=b'F' => Some(byte - b'A' + 10),
_ => None,
}
}
#[cfg(feature = "system-proxy")]
impl SystemProxy {
fn from_environment() -> Result<Self> {
let all = environment("ALL_PROXY");
let http = environment("HTTP_PROXY")
.or_else(|| all.clone())
.map(|value| ProxyServer::parse(&value).map(Arc::new))
.transpose()?;
let https = environment("HTTPS_PROXY")
.or(all)
.map(|value| ProxyServer::parse(&value).map(Arc::new))
.transpose()?;
let no_proxy = environment("NO_PROXY")
.unwrap_or_default()
.split(',')
.map(str::trim)
.filter(|entry| !entry.is_empty())
.map(str::to_ascii_lowercase)
.collect();
Ok(Self {
http,
https,
no_proxy,
})
}
fn for_origin(&self, origin: &Origin) -> Option<&ProxyServer> {
if self
.no_proxy
.iter()
.any(|entry| no_proxy_matches(entry, &origin.host, origin.port))
{
return None;
}
match origin.scheme {
Scheme::Http => self.http.as_deref(),
Scheme::Https => self.https.as_deref(),
}
}
}
#[cfg(feature = "system-proxy")]
fn environment(name: &str) -> Option<String> {
let uppercase = !(name == "HTTP_PROXY" && std::env::var_os("REQUEST_METHOD").is_some());
environment_with(name, uppercase, |name| std::env::var(name).ok())
}
#[cfg(feature = "system-proxy")]
fn environment_with(
name: &str,
uppercase: bool,
mut get: impl FnMut(&str) -> Option<String>,
) -> Option<String> {
let mut nonempty = |name: &str| get(name).filter(|value| !value.trim().is_empty());
uppercase
.then(|| nonempty(name))
.flatten()
.or_else(|| nonempty(&name.to_ascii_lowercase()))
}
fn no_proxy_matches(entry: &str, host: &str, port: u16) -> bool {
if entry == "*" {
return true;
}
let host = host
.trim_matches(['[', ']'])
.trim_end_matches('.')
.to_ascii_lowercase();
let (pattern, required_port) = split_no_proxy_port(entry);
if required_port.is_some_and(|required| required != port) {
return false;
}
if let Some((network, prefix)) = pattern.rsplit_once('/')
&& let (Ok(network), Ok(host), Ok(prefix)) = (
network.trim_matches(['[', ']']).parse::<std::net::IpAddr>(),
host.parse::<std::net::IpAddr>(),
prefix.parse::<u8>(),
)
{
return address_in_network(host, network, prefix);
}
let pattern = pattern
.trim_start_matches("*.")
.trim_start_matches('.')
.trim_end_matches('.');
host == pattern || host.ends_with(&format!(".{pattern}"))
}
fn split_no_proxy_port(entry: &str) -> (&str, Option<u16>) {
if let Some(rest) = entry.strip_prefix('[')
&& let Some((host, port)) = rest.rsplit_once("]:")
&& let Ok(port) = port.parse()
{
return (host, Some(port));
}
if entry.matches(':').count() <= 1
&& let Some((host, port)) = entry.rsplit_once(':')
&& let Ok(port) = port.parse()
{
return (host, Some(port));
}
(entry.trim_matches(['[', ']']), None)
}
fn address_in_network(address: std::net::IpAddr, network: std::net::IpAddr, prefix: u8) -> bool {
match (address, network) {
(std::net::IpAddr::V4(address), std::net::IpAddr::V4(network)) if prefix <= 32 => {
let mask = u32::MAX.checked_shl(u32::from(32 - prefix)).unwrap_or(0);
u32::from(address) & mask == u32::from(network) & mask
}
(std::net::IpAddr::V6(address), std::net::IpAddr::V6(network)) if prefix <= 128 => {
let mask = u128::MAX.checked_shl(u32::from(128 - prefix)).unwrap_or(0);
u128::from(address) & mask == u128::from(network) & mask
}
_ => false,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn proxy_credentials_are_encoded_without_entering_debug_output() {
let proxy = ProxyServer::parse("http://user:password@localhost:8080").unwrap();
assert_eq!(
match &proxy.protocol {
ProxyProtocol::Http { authorization } => authorization.as_ref().unwrap(),
ProxyProtocol::Socks5 { .. } => panic!("expected an HTTP proxy"),
},
"Basic dXNlcjpwYXNzd29yZA=="
);
}
#[test]
fn proxy_credentials_are_percent_decoded_before_authentication() {
let proxy = ProxyServer::parse("http://user:p%C3%A4ss@localhost:8080").unwrap();
let ProxyProtocol::Http {
authorization: Some(authorization),
} = &proxy.protocol
else {
panic!("expected an authenticated HTTP proxy");
};
assert_eq!(authorization, "Basic dXNlcjpww6Rzcw==");
}
#[test]
fn socks_credentials_remain_outside_the_proxy_endpoint() {
let proxy = ProxyServer::parse("socks5h://user:password@localhost:1080").unwrap();
assert_eq!(proxy.origin.authority(), "localhost:1080");
assert!(matches!(
proxy.protocol,
ProxyProtocol::Socks5 {
username: Some(_),
password: Some(_)
}
));
}
#[test]
fn no_proxy_supports_domains_ports_ipv6_and_cidr_networks() {
assert!(no_proxy_matches(".example.com", "api.example.com", 443));
assert!(no_proxy_matches("example.com:8443", "example.com", 8443));
assert!(!no_proxy_matches("example.com:8443", "example.com", 443));
assert!(no_proxy_matches("[::1]:8080", "::1", 8080));
assert!(no_proxy_matches("10.0.0.0/8", "10.1.2.3", 80));
assert!(!no_proxy_matches("10.0.0.0/8", "11.1.2.3", 80));
assert!(no_proxy_matches("2001:db8::/32", "2001:db8::1", 443));
}
#[cfg(feature = "system-proxy")]
#[test]
fn empty_uppercase_proxy_settings_fall_back_to_lowercase() {
let value = environment_with("HTTPS_PROXY", true, |name| match name {
"HTTPS_PROXY" => Some(" ".to_owned()),
"https_proxy" => Some("http://localhost:8080".to_owned()),
_ => None,
});
assert_eq!(value.as_deref(), Some("http://localhost:8080"));
}
#[test]
fn explicit_proxy_bypass_is_independent_of_process_settings() {
let proxy = Proxy::from_policy(
ProxyPolicy::all("http://localhost:8080").exclude([".internal.example", "10.0.0.0/8"]),
)
.unwrap();
let internal =
Origin::from_uri(&"https://api.internal.example/resource".parse().unwrap()).unwrap();
let public = Origin::from_uri(&"https://public.example/resource".parse().unwrap()).unwrap();
assert!(proxy.for_origin(&internal).is_none());
assert!(proxy.for_origin(&public).is_some());
}
}