#![allow(
missing_docs,
dead_code,
unused_mut,
clippy::large_futures,
clippy::missing_panics_doc,
clippy::redundant_closure_for_method_calls,
clippy::inefficient_to_string,
clippy::manual_let_else,
clippy::single_char_pattern,
clippy::match_same_arms,
clippy::needless_borrow,
clippy::trim_split_whitespace,
clippy::too_many_lines,
clippy::unused_self,
clippy::items_after_statements,
clippy::expect_fun_call,
clippy::len_zero,
clippy::unnecessary_debug_formatting,
clippy::format_push_string,
clippy::new_without_default,
clippy::map_unwrap_or
)]
#![allow(clippy::module_name_repetitions)]
#![cfg(feature = "proxy")]
mod tls_fixtures;
use std::collections::HashMap;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::time::Duration;
use bytes::Bytes;
use eggfetch_core::{
Client, Error, Proxy, ProxyAuth, RequestBody, Timeout, TimeoutPhase, TlsConfig,
};
use futures_util::StreamExt;
use tls_fixtures::{CertAuthority, TlsTestServer};
use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::watch;
#[derive(Default)]
struct HttpProxyConfig {
required_auth: Option<(String, String)>,
connect_delay: Option<(usize, Duration)>,
}
struct HttpProxyServer {
port: u16,
connection_count: Arc<AtomicUsize>,
connect_targets: Arc<std::sync::Mutex<Vec<String>>>,
close_tunnel: tokio::sync::broadcast::Sender<()>,
closed_tunnel_count: Arc<AtomicUsize>,
shutdown: watch::Sender<bool>,
}
impl HttpProxyServer {
async fn start(config: HttpProxyConfig) -> Self {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
let required_auth = config.required_auth;
let connection_count = Arc::new(AtomicUsize::new(0));
let counter = connection_count.clone();
let connect_targets = Arc::new(std::sync::Mutex::new(Vec::new()));
let connect_targets_clone = connect_targets.clone();
let (close_tunnel, _) = tokio::sync::broadcast::channel(8);
let close_tunnel_clone = close_tunnel.clone();
let closed_tunnel_count = Arc::new(AtomicUsize::new(0));
let closed_tunnel_count_clone = closed_tunnel_count.clone();
let connect_delay = config.connect_delay;
tokio::spawn(async move {
loop {
tokio::select! {
result = listener.accept() => {
match result {
Ok((stream, _)) => {
let connection_number = counter.fetch_add(1, Ordering::SeqCst) + 1;
let auth = required_auth.clone();
let targets = connect_targets_clone.clone();
let close_rx = close_tunnel_clone.subscribe();
let close_count = closed_tunnel_count_clone.clone();
let delay = connect_delay
.filter(|(number, _)| *number == connection_number)
.map(|(_, duration)| duration);
tokio::spawn(async move {
if let Err(e) = handle_proxy_connection(
stream,
auth,
targets,
delay,
close_rx,
close_count,
).await {
eprintln!("proxy connection error: {e}");
}
});
}
Err(e) => {
eprintln!("accept error: {e}");
break;
}
}
}
_ = shutdown_rx.changed() => {
break;
}
}
}
});
Self {
port,
connection_count,
connect_targets,
close_tunnel,
closed_tunnel_count,
shutdown: shutdown_tx,
}
}
fn url(&self) -> String {
format!("http://127.0.0.1:{}", self.port)
}
fn connection_count(&self) -> usize {
self.connection_count.load(Ordering::SeqCst)
}
fn connect_targets(&self) -> Vec<String> {
self.connect_targets.lock().unwrap().clone()
}
fn close_tunnels(&self) {
let _ = self.close_tunnel.send(());
}
async fn wait_for_closed_tunnels(&self, expected: usize) {
tokio::time::timeout(Duration::from_secs(1), async {
while self.closed_tunnel_count.load(Ordering::SeqCst) < expected {
tokio::task::yield_now().await;
}
})
.await
.expect("proxy tunnel did not close");
}
fn shutdown(&self) {
let _ = self.shutdown.send(true);
}
}
struct HttpsProxyServer {
port: u16,
connection_count: Arc<AtomicUsize>,
connect_targets: Arc<std::sync::Mutex<Vec<String>>>,
shutdown: watch::Sender<bool>,
}
impl HttpsProxyServer {
async fn start_self_signed() -> Self {
let sans = vec!["localhost".to_string()];
let mut params = rcgen::CertificateParams::new(sans).unwrap();
params.is_ca = rcgen::IsCa::NoCa;
let key = rcgen::KeyPair::generate().unwrap();
let cert = params.self_signed(&key).unwrap();
let cert_der = rustls::pki_types::CertificateDer::from(cert.der().to_vec());
let key_der = rustls::pki_types::PrivateKeyDer::Pkcs8(
rustls::pki_types::PrivatePkcs8KeyDer::from(key.serialize_der()),
);
let server_config = rustls::ServerConfig::builder()
.with_no_client_auth()
.with_single_cert(vec![cert_der], key_der)
.unwrap();
let acceptor = tokio_rustls::TlsAcceptor::from(Arc::new(server_config));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
let connection_count = Arc::new(AtomicUsize::new(0));
let counter = connection_count.clone();
let connect_targets = Arc::new(std::sync::Mutex::new(Vec::new()));
let targets_clone = connect_targets.clone();
tokio::spawn(async move {
loop {
tokio::select! {
result = listener.accept() => {
match result {
Ok((stream, _)) => {
counter.fetch_add(1, Ordering::SeqCst);
let acceptor = acceptor.clone();
let targets = targets_clone.clone();
tokio::spawn(async move {
let tls_stream = match acceptor.accept(stream).await {
Ok(s) => s,
Err(_) => return,
};
if let Err(e) = handle_https_proxy_connection(
tls_stream, targets,
)
.await
{
eprintln!("https proxy connection error: {e}");
}
});
}
Err(e) => {
eprintln!("https proxy accept error: {e}");
break;
}
}
}
_ = shutdown_rx.changed() => {
break;
}
}
}
});
Self {
port,
connection_count,
connect_targets,
shutdown: shutdown_tx,
}
}
fn url(&self) -> String {
format!("https://localhost:{}", self.port)
}
fn connection_count(&self) -> usize {
self.connection_count.load(Ordering::SeqCst)
}
fn connect_targets(&self) -> Vec<String> {
self.connect_targets.lock().unwrap().clone()
}
fn shutdown(&self) {
let _ = self.shutdown.send(true);
}
}
async fn handle_https_proxy_connection(
tls_stream: tokio_rustls::server::TlsStream<TcpStream>,
connect_targets: Arc<std::sync::Mutex<Vec<String>>>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let mut reader = BufReader::new(tls_stream);
loop {
let mut request_line = String::new();
match reader.read_line(&mut request_line).await {
Ok(0) => return Ok(()),
Ok(_) => {}
Err(_) => return Ok(()),
}
if request_line.trim().is_empty() {
continue;
}
let mut content_length: usize = 0;
loop {
let mut line = String::new();
match reader.read_line(&mut line).await {
Ok(0) | Err(_) => return Ok(()),
Ok(_) => {}
}
if line.trim().is_empty() {
break;
}
if let Some((name, value)) = line.split_once(':') {
if name.trim().eq_ignore_ascii_case("content-length") {
content_length = value.trim().parse().unwrap_or(0);
}
}
}
let parts: Vec<&str> = request_line.split_whitespace().collect();
if parts.len() < 2 {
return Ok(());
}
let method = parts[0];
let target = parts[1].to_owned();
if method.eq_ignore_ascii_case("CONNECT") {
connect_targets.lock().unwrap().push(target.clone());
if let Ok(mut origin) = TcpStream::connect(&target).await {
reader
.get_mut()
.write_all(b"HTTP/1.1 200 Connection Established\r\n\r\n")
.await?;
reader.get_mut().flush().await?;
let mut tls_stream = reader.into_inner();
let _ = tokio::io::copy_bidirectional(&mut tls_stream, &mut origin).await;
return Ok(());
}
reader
.get_mut()
.write_all(b"HTTP/1.1 502 Bad Gateway\r\nContent-Length: 0\r\n\r\n")
.await?;
reader.get_mut().flush().await?;
return Ok(());
}
if content_length > 0 {
let mut remaining = content_length;
let mut discard = vec![0u8; 4096];
while remaining > 0 {
let want = remaining.min(discard.len());
match reader.read(&mut discard[..want]).await {
Ok(0) | Err(_) => return Ok(()),
Ok(n) => remaining -= n,
}
}
}
if target.contains("/slow") {
reader
.get_mut()
.write_all(
b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: keep-alive\r\n\r\n",
)
.await?;
reader.get_mut().flush().await?;
tokio::time::sleep(Duration::from_millis(300)).await;
reader.get_mut().write_all(b"ok").await?;
reader.get_mut().flush().await?;
continue;
}
reader
.get_mut()
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: keep-alive\r\n\r\nok")
.await?;
reader.get_mut().flush().await?;
}
}
#[allow(clippy::too_many_lines)]
async fn handle_proxy_connection(
mut client_stream: TcpStream,
required_auth: Option<(String, String)>,
connect_targets: Arc<std::sync::Mutex<Vec<String>>>,
connect_delay: Option<Duration>,
mut close_rx: tokio::sync::broadcast::Receiver<()>,
closed_tunnel_count: Arc<AtomicUsize>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
use std::fmt::Write as _;
let mut buf_reader = BufReader::new(&mut client_stream);
let mut request_line = String::new();
buf_reader.read_line(&mut request_line).await?;
if request_line.trim().is_empty() {
return Ok(());
}
let mut raw_headers = Vec::new();
loop {
let mut line = String::new();
buf_reader.read_line(&mut line).await?;
raw_headers.extend_from_slice(line.as_bytes());
if line.trim().is_empty() {
break;
}
}
let header_str = String::from_utf8_lossy(&raw_headers);
let mut headers = HashMap::new();
for h in header_str.lines() {
if let Some((name, value)) = h.split_once(':') {
headers.insert(name.trim().to_lowercase(), value.trim().to_string());
}
}
if let Some((ref required_user, ref required_pass)) = required_auth {
let mut authorized = false;
if let Some(auth_header) = headers.get("proxy-authorization") {
if let Some(encoded) = auth_header.strip_prefix("Basic ") {
use base64::Engine;
let decoded = base64::engine::general_purpose::STANDARD
.decode(encoded.as_bytes())
.unwrap_or_default();
let decoded_str = String::from_utf8_lossy(&decoded);
let expected = format!("{required_user}:{required_pass}");
authorized = decoded_str == expected;
}
}
if !authorized {
let resp = b"HTTP/1.1 407 Proxy Authentication Required\r\nContent-Length: 0\r\n\r\n";
let w = buf_reader.into_inner();
w.write_all(resp).await?;
return Ok(());
}
}
let parts: Vec<&str> = request_line.split_whitespace().collect();
let method = parts[0];
let target = parts[1];
if method.eq_ignore_ascii_case("CONNECT") {
connect_targets.lock().unwrap().push(target.to_owned());
drop(buf_reader);
handle_connect_tunnel(
&mut client_stream,
target,
connect_delay,
&mut close_rx,
&closed_tunnel_count,
)
.await?;
} else {
let content_length: usize = headers
.get("content-length")
.and_then(|v| v.parse().ok())
.unwrap_or(0);
let mut request_body = vec![0u8; content_length];
if content_length > 0 {
let mut total = 0;
while total < content_length {
match buf_reader.read(&mut request_body[total..]).await {
Ok(0) | Err(_) => break,
Ok(n) => total += n,
}
}
request_body.truncate(total);
}
drop(buf_reader);
let dest_url = url::Url::parse(target)?;
let dest_host = dest_url.host_str().unwrap_or("127.0.0.1");
let dest_port = dest_url.port_or_known_default().unwrap_or(80);
let dest_addr = format!("{dest_host}:{dest_port}");
let dest_stream = TcpStream::connect(&dest_addr).await?;
let (mut dest_reader, mut dest_writer) = dest_stream.into_split();
let dest_path = dest_url.path();
let dest_query = dest_url
.query()
.map(|q| format!("?{q}"))
.unwrap_or_default();
let dest_path_query = format!("{dest_path}{dest_query}");
let mut dest_req = format!("{method} {dest_path_query} HTTP/1.1\r\n");
for (name, value) in &headers {
if name == "proxy-authorization" || name == "host" {
continue;
}
let _ = write!(dest_req, "{name}: {value}\r\n");
}
if let Some(host) = headers.get("host") {
let _ = write!(dest_req, "host: {host}\r\n");
} else if let Ok(parsed) = url::Url::parse(target) {
let host = parsed.host_str().unwrap_or("");
let _ = write!(dest_req, "host: {host}\r\n");
}
dest_req.push_str("\r\n");
dest_writer.write_all(dest_req.as_bytes()).await?;
if !request_body.is_empty() {
dest_writer.write_all(&request_body).await?;
}
let mut resp_buf = Vec::new();
let mut resp_reader = BufReader::new(&mut dest_reader);
let mut status_line = String::new();
resp_reader.read_line(&mut status_line).await?;
resp_buf.extend_from_slice(status_line.as_bytes());
loop {
let mut line = String::new();
resp_reader.read_line(&mut line).await?;
resp_buf.extend_from_slice(line.as_bytes());
if line.trim().is_empty() {
break;
}
}
let status_str = String::from_utf8_lossy(&resp_buf);
let mut resp_content_length: Option<usize> = None;
let mut chunked = false;
for line in status_str.lines() {
if let Some(val) = line
.strip_prefix("Content-Length:")
.or_else(|| line.strip_prefix("content-length:"))
{
resp_content_length = val.trim().parse().ok();
}
if let Some(val) = line
.strip_prefix("Transfer-Encoding:")
.or_else(|| line.strip_prefix("transfer-encoding:"))
{
if val.trim().to_lowercase().contains("chunked") {
chunked = true;
}
}
}
if chunked {
loop {
let mut chunk_size_line = String::new();
resp_reader.read_line(&mut chunk_size_line).await?;
resp_buf.extend_from_slice(chunk_size_line.as_bytes());
let size_str = chunk_size_line.trim();
if size_str.is_empty() || size_str == "0" {
if size_str == "0" {
let mut trailer = String::new();
resp_reader.read_line(&mut trailer).await?;
resp_buf.extend_from_slice(trailer.as_bytes());
}
break;
}
let chunk_size = usize::from_str_radix(size_str, 16).unwrap_or(0);
let mut chunk_body = vec![0u8; chunk_size];
let mut total = 0;
while total < chunk_size {
match resp_reader.read(&mut chunk_body[total..]).await {
Ok(0) | Err(_) => break,
Ok(n) => total += n,
}
}
resp_buf.extend_from_slice(&chunk_body);
let mut crlf = String::new();
resp_reader.read_line(&mut crlf).await?;
resp_buf.extend_from_slice(crlf.as_bytes());
}
} else if let Some(cl) = resp_content_length {
let mut body = vec![0u8; cl];
let mut total = 0;
while total < cl {
match resp_reader.read(&mut body[total..]).await {
Ok(0) | Err(_) => break,
Ok(n) => total += n,
}
}
resp_buf.extend_from_slice(&body);
} else {
let mut buf = vec![0u8; 4096];
loop {
match resp_reader.read(&mut buf).await {
Ok(0) | Err(_) => break,
Ok(n) => resp_buf.extend_from_slice(&buf[..n]),
}
}
}
client_stream.write_all(&resp_buf).await?;
client_stream.flush().await?;
}
Ok(())
}
async fn handle_connect_tunnel(
client_stream: &mut TcpStream,
target: &str,
connect_delay: Option<Duration>,
close_rx: &mut tokio::sync::broadcast::Receiver<()>,
closed_tunnel_count: &AtomicUsize,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
if let Some(delay) = connect_delay {
tokio::time::sleep(delay).await;
}
if let Ok(dest_stream) = TcpStream::connect(target).await {
let resp = b"HTTP/1.1 200 Connection Established\r\n\r\n";
client_stream.write_all(resp).await?;
let (mut client_read, mut client_write) = tokio::io::split(&mut *client_stream);
let (mut dest_read, mut dest_write) = dest_stream.into_split();
let c2d = async {
let _ = tokio::io::copy(&mut client_read, &mut dest_write).await;
let _ = dest_write.shutdown().await;
};
let d2c = async {
let _ = tokio::io::copy(&mut dest_read, &mut client_write).await;
let _ = client_write.shutdown().await;
};
let closed_by_fixture = tokio::select! {
() = c2d => false,
() = d2c => false,
Ok(()) = close_rx.recv() => true,
};
if closed_by_fixture {
let _ = client_stream.shutdown().await;
closed_tunnel_count.fetch_add(1, Ordering::SeqCst);
}
} else {
let resp = b"HTTP/1.1 502 Bad Gateway\r\nContent-Length: 0\r\n\r\n";
client_stream.write_all(resp).await?;
}
Ok(())
}
struct EchoServer {
port: u16,
shutdown: watch::Sender<bool>,
}
impl EchoServer {
async fn start() -> Self {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
tokio::spawn(async move {
loop {
tokio::select! {
result = listener.accept() => {
if let Ok((mut stream, _)) = result {
tokio::spawn(async move {
let mut buf = vec![0u8; 4096];
loop {
match stream.read(&mut buf).await {
Ok(0) | Err(_) => break,
Ok(n) => {
if stream.write_all(&buf[..n]).await.is_err() {
break;
}
}
}
}
});
}
}
_ = shutdown_rx.changed() => { break; }
}
}
});
Self {
port,
shutdown: shutdown_tx,
}
}
fn port(&self) -> u16 {
self.port
}
fn shutdown(&self) {
let _ = self.shutdown.send(true);
}
}
struct EchoHttpServer {
port: u16,
shutdown: watch::Sender<bool>,
}
impl EchoHttpServer {
async fn start() -> Self {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
tokio::spawn(async move {
loop {
tokio::select! {
result = listener.accept() => {
if let Ok((stream, _)) = result {
tokio::spawn(async move {
if let Err(e) = handle_echo_http(stream).await {
eprintln!("echo server error: {e}");
}
});
}
}
_ = shutdown_rx.changed() => { break; }
}
}
});
Self {
port,
shutdown: shutdown_tx,
}
}
fn url(&self) -> String {
format!("http://127.0.0.1:{}", self.port)
}
fn shutdown(&self) {
let _ = self.shutdown.send(true);
}
}
async fn handle_echo_http(
mut stream: TcpStream,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
use std::fmt::Write as _;
let mut reader = BufReader::new(&mut stream);
let mut request_line = String::new();
reader.read_line(&mut request_line).await?;
let parts: Vec<&str> = request_line.split_whitespace().collect();
let method = parts.first().copied().unwrap_or("GET");
let path = parts.get(1).copied().unwrap_or("/");
let mut headers = Vec::new();
let mut content_length: usize = 0;
loop {
let mut line = String::new();
reader.read_line(&mut line).await?;
let trimmed = line.trim().to_string();
if trimmed.is_empty() {
break;
}
if let Some((name, value)) = trimmed.split_once(':') {
let name_lower = name.trim().to_lowercase();
if name_lower == "content-length" {
content_length = value.trim().parse().unwrap_or(0);
}
headers.push((name.trim().to_string(), value.trim().to_string()));
}
}
let mut body = vec![0u8; content_length];
let mut total = 0;
while total < content_length {
match reader.read(&mut body[total..]).await {
Ok(0) | Err(_) => break,
Ok(n) => total += n,
}
}
let mut response_body = format!("{method} {path}");
for (name, value) in &headers {
let _ = write!(response_body, "\n{name}: {value}");
}
if !body.is_empty() {
let _ = write!(response_body, "\nBody: {}", String::from_utf8_lossy(&body));
}
let resp = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{response_body}",
response_body.len()
);
stream.write_all(resp.as_bytes()).await?;
stream.flush().await?;
Ok(())
}
fn test_client(proxy_url: &str) -> Client {
Client::builder()
.proxy(Proxy::all(proxy_url).unwrap())
.timeout(Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build()
}
#[tokio::test]
async fn http_proxy_get_returns_correct_response() {
let echo = EchoHttpServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = test_client(&proxy.url());
let dest = format!("{}/test", echo.url());
let mut resp = client.get(&dest).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let body = resp.text().await.unwrap();
assert!(body.contains("GET"));
assert!(body.contains("/test"));
proxy.shutdown();
echo.shutdown();
}
#[tokio::test]
async fn http_proxy_post_with_body() {
let echo = EchoHttpServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = test_client(&proxy.url());
let dest = echo.url();
let mut resp = client
.post(&dest)
.unwrap()
.header("Content-Type", "text/plain")
.body("hello proxy")
.send()
.await
.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let body = resp.text().await.unwrap();
assert!(body.contains("POST"));
assert!(body.contains("hello proxy"));
proxy.shutdown();
echo.shutdown();
}
#[tokio::test]
async fn http_proxy_auth_sent_to_proxy_not_destination() {
let echo = EchoHttpServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig {
required_auth: Some(("testuser".into(), "testpass".into())),
..Default::default()
})
.await;
let client = Client::builder()
.proxy(
Proxy::all(&proxy.url())
.unwrap()
.auth(ProxyAuth::basic("testuser", "testpass").unwrap()),
)
.timeout(Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let dest = format!("{}/auth-test", echo.url());
let mut resp = client.get(&dest).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let body = resp.text().await.unwrap();
assert!(
!body.contains("proxy-authorization"),
"proxy auth header should not reach destination"
);
proxy.shutdown();
echo.shutdown();
}
#[tokio::test]
async fn http_proxy_auth_failure_returns_error() {
let echo = EchoHttpServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig {
required_auth: Some(("testuser".into(), "testpass".into())),
..Default::default()
})
.await;
let client = Client::builder()
.proxy(
Proxy::all(&proxy.url())
.unwrap()
.auth(ProxyAuth::basic("wronguser", "wrongpass").unwrap()),
)
.timeout(Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let dest = echo.url();
let resp = client.get(&dest).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 407);
proxy.shutdown();
echo.shutdown();
}
#[tokio::test]
async fn http_proxy_streaming_download() {
let echo = EchoHttpServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = test_client(&proxy.url());
let dest = echo.url();
let mut resp = client.get(&dest).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let mut stream = resp.bytes_stream().unwrap();
let mut total = 0usize;
while let Some(chunk) = stream.next().await {
let chunk = chunk.unwrap();
total += chunk.len();
}
assert!(total > 0);
proxy.shutdown();
echo.shutdown();
}
#[tokio::test]
async fn http_proxy_streaming_upload() {
let echo = EchoHttpServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = test_client(&proxy.url());
let chunks = vec![
Ok(Bytes::from("chunk1-")),
Ok(Bytes::from("chunk2-")),
Ok(Bytes::from("chunk3")),
];
let stream = Box::pin(futures_util::stream::iter(chunks));
let body = RequestBody::from_stream(stream, Some(20));
let dest = echo.url();
let mut resp = client.post(&dest).unwrap().body(body).send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let resp_body = resp.text().await.unwrap();
eprintln!("STREAMING UPLOAD BODY: {resp_body:?}");
assert!(resp_body.contains("chunk1-chunk2-chunk3"));
proxy.shutdown();
echo.shutdown();
}
#[tokio::test]
async fn http_proxy_large_body() {
let echo = EchoHttpServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = test_client(&proxy.url());
let large_body = vec![b'x'; 50_000];
let dest = echo.url();
let mut resp = client
.post(&dest)
.unwrap()
.body(RequestBody::from(large_body))
.send()
.await
.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let body = resp.text().await.unwrap();
assert!(body.contains("Body: "));
assert!(body.len() > 50_000);
proxy.shutdown();
echo.shutdown();
}
#[tokio::test]
async fn pinned_proxy_peer_does_not_resolve_logical_proxy_host() {
let origin = EchoHttpServer::start().await;
let proxy_server = HttpProxyServer::start(HttpProxyConfig::default()).await;
let proxy = Proxy::all(&format!(
"http://unresolvable-proxy.invalid:{}",
proxy_server.port
))
.unwrap()
.resolved_addresses([format!("127.0.0.1:{}", proxy_server.port).parse().unwrap()])
.unwrap();
let client = Client::builder().proxy(proxy).build();
let mut response = client.get(&origin.url()).unwrap().send().await.unwrap();
assert!(response.text().await.unwrap().starts_with("GET /"));
proxy_server.shutdown();
origin.shutdown();
}
#[tokio::test]
async fn pinned_connect_target_uses_ip_but_preserves_origin_tls_identity() {
let ca = CertAuthority::new();
let origin = TlsTestServer::start(&ca, &["origin.invalid"]).await;
let proxy_server = HttpProxyServer::start(HttpProxyConfig::default()).await;
let proxy = Proxy::all(&format!(
"http://unresolvable-proxy.invalid:{}",
proxy_server.port
))
.unwrap()
.resolved_addresses([format!("127.0.0.1:{}", proxy_server.port).parse().unwrap()])
.unwrap();
let client = Client::builder()
.proxy(proxy)
.tls_config(
TlsConfig::builder()
.ca_certificate_pem(&ca.cert_pem())
.unwrap()
.build(),
)
.build();
let mut response = client
.get(&format!("https://origin.invalid:{}/", origin.port()))
.unwrap()
.proxy_target_addresses([format!("127.0.0.1:{}", origin.port()).parse().unwrap()])
.send()
.await
.unwrap();
assert_eq!(response.url().host_str(), Some("origin.invalid"));
assert_eq!(response.text().await.unwrap(), "OK");
assert_eq!(
proxy_server.connect_targets(),
vec![format!("127.0.0.1:{}", origin.port())]
);
proxy_server.shutdown();
origin.shutdown();
}
#[tokio::test]
async fn pinned_socks5_target_uses_ip_without_origin_dns() {
let origin = EchoHttpServer::start().await;
let socks = Socks5Server::start(Socks5Config::default()).await;
let proxy = Proxy::all(&format!(
"socks5://unresolvable-proxy.invalid:{}",
socks.port
))
.unwrap()
.resolved_addresses([format!("127.0.0.1:{}", socks.port).parse().unwrap()])
.unwrap();
let client = Client::builder().proxy(proxy).build();
let mut response = client
.get(&format!("http://origin.invalid:{}/", origin.port))
.unwrap()
.proxy_target_addresses([format!("127.0.0.1:{}", origin.port).parse().unwrap()])
.send()
.await
.unwrap();
assert!(response.text().await.unwrap().starts_with("GET /"));
assert_eq!(
socks.last_connect().map(|(host, _, atyp)| (host, atyp)),
Some(("127.0.0.1".into(), 0x01))
);
socks.shutdown();
origin.shutdown();
}
#[tokio::test]
async fn pinned_socks5_target_fallback_uses_only_candidate_specific_replies() {
let origin = EchoHttpServer::start().await;
let socks = Socks5Server::start(Socks5Config {
reject_target: Some(("192.0.2.1".into(), 0x05)),
..Default::default()
})
.await;
let client = Client::builder()
.proxy(Proxy::all(&socks.url()).unwrap())
.build();
let mut response = client
.get(&format!("http://origin.invalid:{}/", origin.port))
.unwrap()
.proxy_target_addresses([
format!("192.0.2.1:{}", origin.port).parse().unwrap(),
format!("127.0.0.1:{}", origin.port).parse().unwrap(),
])
.send()
.await
.unwrap();
assert!(response.text().await.unwrap().starts_with("GET /"));
assert_eq!(
socks.last_connect().map(|(host, _, atyp)| (host, atyp)),
Some(("127.0.0.1".into(), 0x01))
);
socks.shutdown();
origin.shutdown();
}
#[tokio::test]
async fn pinned_socks5_target_stops_on_proxy_policy_rejection() {
let origin = EchoHttpServer::start().await;
let socks = Socks5Server::start(Socks5Config {
reject_target: Some(("192.0.2.1".into(), 0x02)),
..Default::default()
})
.await;
let client = Client::builder()
.proxy(Proxy::all(&socks.url()).unwrap())
.build();
let error = client
.get(&format!("http://origin.invalid:{}/", origin.port))
.unwrap()
.proxy_target_addresses([
format!("192.0.2.1:{}", origin.port).parse().unwrap(),
format!("127.0.0.1:{}", origin.port).parse().unwrap(),
])
.send()
.await
.unwrap_err();
assert_eq!(error.kind(), "proxy_connect");
assert_eq!(socks.connect_count(), 1);
socks.shutdown();
origin.shutdown();
}
#[tokio::test]
async fn unpinned_socks5_stops_on_malformed_reply() {
let socks = Socks5Server::start(Socks5Config {
malformed: true,
..Default::default()
})
.await;
let client = Client::builder()
.proxy(Proxy::all(&socks.url()).unwrap())
.build();
let error = client
.get("http://localhost:9/")
.unwrap()
.send()
.await
.unwrap_err();
assert_eq!(error.kind(), "malformed_proxy_response");
assert_eq!(socks.connect_count(), 1);
socks.shutdown();
}
#[tokio::test]
async fn unsupported_pinned_proxy_target_routes_fail_before_proxy_io() {
let proxy_server = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = Client::builder()
.proxy(
Proxy::all(&proxy_server.url())
.unwrap()
.resolved_addresses([format!("127.0.0.1:{}", proxy_server.port).parse().unwrap()])
.unwrap(),
)
.build();
let error = client
.get("http://example.invalid/")
.unwrap()
.proxy_target_addresses(["127.0.0.1:80".parse().unwrap()])
.send()
.await
.unwrap_err();
assert_eq!(error.kind(), "unsupported");
assert_eq!(proxy_server.connection_count(), 0);
proxy_server.shutdown();
}
#[tokio::test]
async fn pinned_proxy_target_validation_fails_before_proxy_io() {
let proxy_server = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = Client::builder()
.proxy(Proxy::all(&proxy_server.url()).unwrap())
.build();
let empty = client
.get("https://example.invalid/")
.unwrap()
.proxy_target_addresses(Vec::<std::net::SocketAddr>::new())
.send()
.await
.unwrap_err();
assert_eq!(empty.kind(), "invalid_resolved_target");
let mismatch = client
.get("https://example.invalid/")
.unwrap()
.proxy_target_addresses(["127.0.0.1:80".parse().unwrap()])
.send()
.await
.unwrap_err();
assert_eq!(mismatch.kind(), "invalid_resolved_target");
assert_eq!(proxy_server.connection_count(), 0);
proxy_server.shutdown();
}
#[tokio::test]
async fn socks5h_rejects_pinned_target_before_proxy_io() {
let socks = Socks5Server::start(Socks5Config::default()).await;
let client = Client::builder()
.proxy(
Proxy::all(&socks.url_remote_dns())
.unwrap()
.resolved_addresses([format!("127.0.0.1:{}", socks.port).parse().unwrap()])
.unwrap(),
)
.build();
let error = client
.get("http://example.invalid/")
.unwrap()
.proxy_target_addresses(["127.0.0.1:80".parse().unwrap()])
.send()
.await
.unwrap_err();
assert_eq!(error.kind(), "unsupported");
assert_eq!(socks.last_connect(), None);
socks.shutdown();
}
#[tokio::test]
async fn connect_tunnel_echo_roundtrip() {
let echo = EchoServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let proxy_url = url::Url::parse(&proxy.url()).unwrap();
let proxy_host = proxy_url.host_str().unwrap().to_string();
let proxy_port = proxy_url.port().unwrap();
let mut stream = TcpStream::connect(format!("{proxy_host}:{proxy_port}"))
.await
.unwrap();
let connect_req = format!(
"CONNECT 127.0.0.1:{} HTTP/1.1\r\nHost: 127.0.0.1:{}\r\n\r\n",
echo.port(),
echo.port()
);
stream.write_all(connect_req.as_bytes()).await.unwrap();
let mut reader = BufReader::new(&mut stream);
let mut status_line = String::new();
reader.read_line(&mut status_line).await.unwrap();
assert!(status_line.contains("200"), "CONNECT failed: {status_line}");
loop {
let mut line = String::new();
reader.read_line(&mut line).await.unwrap();
if line.trim().is_empty() {
break;
}
}
let stream = reader.into_inner();
stream.write_all(b"hello tunnel").await.unwrap();
let mut response = vec![0u8; 12];
stream.read_exact(&mut response).await.unwrap();
assert_eq!(&response, b"hello tunnel");
proxy.shutdown();
echo.shutdown();
}
#[tokio::test]
async fn connect_tunnel_auth_required() {
let echo = EchoServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig {
required_auth: Some(("user".into(), "pass".into())),
..Default::default()
})
.await;
let proxy_url = url::Url::parse(&proxy.url()).unwrap();
let proxy_host = proxy_url.host_str().unwrap().to_string();
let proxy_port = proxy_url.port().unwrap();
let mut stream = TcpStream::connect(format!("{proxy_host}:{proxy_port}"))
.await
.unwrap();
let connect_req = format!(
"CONNECT 127.0.0.1:{} HTTP/1.1\r\nHost: 127.0.0.1:{}\r\n\r\n",
echo.port(),
echo.port()
);
stream.write_all(connect_req.as_bytes()).await.unwrap();
let mut reader = BufReader::new(&mut stream);
let mut status_line = String::new();
reader.read_line(&mut status_line).await.unwrap();
assert!(
status_line.contains("407"),
"Expected 407, got: {status_line}"
);
proxy.shutdown();
echo.shutdown();
}
#[tokio::test]
async fn connect_tunnel_auth_with_valid_creds() {
use base64::Engine;
let echo = EchoServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig {
required_auth: Some(("user".into(), "pass".into())),
..Default::default()
})
.await;
let proxy_url = url::Url::parse(&proxy.url()).unwrap();
let proxy_host = proxy_url.host_str().unwrap().to_string();
let proxy_port = proxy_url.port().unwrap();
let mut stream = TcpStream::connect(format!("{proxy_host}:{proxy_port}"))
.await
.unwrap();
let creds = base64::engine::general_purpose::STANDARD.encode(b"user:pass");
let connect_req = format!(
"CONNECT 127.0.0.1:{} HTTP/1.1\r\nHost: 127.0.0.1:{}\r\nProxy-Authorization: Basic {creds}\r\n\r\n",
echo.port(),
echo.port()
);
stream.write_all(connect_req.as_bytes()).await.unwrap();
let mut reader = BufReader::new(&mut stream);
let mut status_line = String::new();
reader.read_line(&mut status_line).await.unwrap();
assert!(
status_line.contains("200"),
"Expected 200, got: {status_line}"
);
loop {
let mut line = String::new();
reader.read_line(&mut line).await.unwrap();
if line.trim().is_empty() {
break;
}
}
let stream = reader.into_inner();
stream.write_all(b"hello").await.unwrap();
let mut response = vec![0u8; 5];
stream.read_exact(&mut response).await.unwrap();
assert_eq!(&response, b"hello");
let _ = stream;
proxy.shutdown();
echo.shutdown();
}
#[tokio::test]
async fn proxy_auth_header_never_reaches_destination() {
let echo = EchoHttpServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = Client::builder()
.proxy(
Proxy::all(&proxy.url())
.unwrap()
.auth(ProxyAuth::basic("secretuser", "secretpass").unwrap()),
)
.timeout(Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let dest = format!("{}/security-test", echo.url());
let mut resp = client.get(&dest).unwrap().send().await.unwrap();
let body = resp.text().await.unwrap();
assert!(
!body.contains("proxy-authorization"),
"Proxy-Authorization header leaked to destination"
);
assert!(
!body.contains("secretuser"),
"Proxy username leaked to destination"
);
assert!(
!body.contains("secretpass"),
"Proxy password leaked to destination"
);
proxy.shutdown();
echo.shutdown();
}
#[tokio::test]
async fn credentials_not_in_error_messages() {
let proxy = HttpProxyServer::start(HttpProxyConfig {
required_auth: Some(("secretuser".into(), "secretpass".into())),
..Default::default()
})
.await;
let client = Client::builder()
.proxy(
Proxy::all(&proxy.url())
.unwrap()
.auth(ProxyAuth::basic("wronguser", "wrongpass").unwrap()),
)
.timeout(Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let result = client
.get("http://127.0.0.1:1/nonexistent")
.unwrap()
.send()
.await;
let resp = result.unwrap();
assert_eq!(resp.status().as_u16(), 407);
proxy.shutdown();
}
#[tokio::test]
async fn no_proxy_bypass_direct_request() {
let echo = EchoHttpServer::start().await;
let no_proxy = eggfetch_core::NoProxy::parse("127.0.0.1").unwrap();
let client = Client::builder()
.proxy(
Proxy::all("http://127.0.0.1:9999")
.unwrap()
.no_proxy(no_proxy),
)
.timeout(Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let mut resp = client.get(&echo.url()).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let body = resp.text().await.unwrap();
assert!(body.contains("GET"));
echo.shutdown();
}
#[tokio::test]
async fn per_request_bypass_proxy() {
let echo = EchoHttpServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = Client::builder()
.proxy(Proxy::all(&proxy.url()).unwrap())
.timeout(Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let mut resp = client
.get(&echo.url())
.unwrap()
.without_proxy()
.send()
.await
.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let body = resp.text().await.unwrap();
assert!(body.contains("GET"));
assert_eq!(
proxy.connection_count(),
0,
".without_proxy() request reached the client-level proxy"
);
let mut resp = client.get(&echo.url()).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let _ = resp.text().await.unwrap();
assert_eq!(
proxy.connection_count(),
1,
"default request should be routed through the client-level proxy"
);
proxy.shutdown();
echo.shutdown();
}
#[tokio::test]
async fn per_request_proxy_override_routes_through_specified_proxy() {
let echo = EchoHttpServer::start().await;
let client_proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let request_proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = Client::builder()
.proxy(Proxy::all(&client_proxy.url()).unwrap())
.timeout(Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let mut resp = client
.get(&echo.url())
.unwrap()
.proxy(&Proxy::all(&request_proxy.url()).unwrap())
.send()
.await
.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let _ = resp.text().await.unwrap();
assert_eq!(
client_proxy.connection_count(),
0,
".proxy() override must not use the client-level proxy"
);
assert_eq!(
request_proxy.connection_count(),
1,
".proxy() override must route through the request-level proxy"
);
client_proxy.shutdown();
request_proxy.shutdown();
echo.shutdown();
}
struct ConnectionCountingServer {
port: u16,
connection_count: Arc<AtomicUsize>,
shutdown: watch::Sender<bool>,
}
impl ConnectionCountingServer {
async fn start() -> Self {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
let connection_count = Arc::new(AtomicUsize::new(0));
let count = connection_count.clone();
tokio::spawn(async move {
loop {
tokio::select! {
result = listener.accept() => {
if let Ok((mut stream, _)) = result {
count.fetch_add(1, Ordering::SeqCst);
tokio::spawn(async move {
let mut reader = BufReader::new(&mut stream);
let mut request_line = String::new();
reader.read_line(&mut request_line).await.ok();
let mut content_length: usize = 0;
loop {
let mut line = String::new();
reader.read_line(&mut line).await.ok();
let trimmed = line.trim().to_string();
if trimmed.is_empty() {
break;
}
if let Some((name, value)) = trimmed.split_once(':') {
if name.trim().to_lowercase() == "content-length" {
content_length = value.trim().parse().unwrap_or(0);
}
}
}
if content_length > 0 {
let mut body = vec![0u8; content_length];
let mut total = 0;
while total < content_length {
match reader.read(&mut body[total..]).await {
Ok(0) | Err(_) => break,
Ok(n) => total += n,
}
}
}
let resp = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok";
stream.write_all(resp.as_bytes()).await.ok();
});
}
}
_ = shutdown_rx.changed() => { break; }
}
}
});
Self {
port,
connection_count,
shutdown: shutdown_tx,
}
}
fn url(&self) -> String {
format!("http://127.0.0.1:{}", self.port)
}
fn connection_count(&self) -> usize {
self.connection_count.load(Ordering::SeqCst)
}
fn shutdown(&self) {
let _ = self.shutdown.send(true);
}
}
#[tokio::test]
async fn repeated_proxy_requests_create_separate_connections() {
let server = ConnectionCountingServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = test_client(&proxy.url());
let request_count = 5;
for i in 0..request_count {
let url = format!("{}/req/{i}", server.url());
let mut resp = client.get(&url).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let body = resp.text().await.unwrap();
assert_eq!(body, "ok");
}
let connections = server.connection_count();
assert_eq!(
connections, request_count,
"Expected {request_count} separate connections but got {connections}"
);
proxy.shutdown();
server.shutdown();
}
#[tokio::test]
async fn hyper_forward_proxy_reuses_keep_alive_connection() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let accepted = Arc::new(AtomicUsize::new(0));
let accepted_task = accepted.clone();
let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
tokio::spawn(async move {
tokio::select! {
result = listener.accept() => {
let (stream, _) = result.unwrap();
accepted_task.fetch_add(1, Ordering::SeqCst);
let mut stream = BufReader::new(stream);
loop {
let mut request = Vec::new();
loop {
let mut line = Vec::new();
if stream.read_until(b'\n', &mut line).await.unwrap() == 0 {
return;
}
request.extend_from_slice(&line);
if request.ends_with(b"\r\n\r\n") {
break;
}
}
stream
.get_mut()
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: keep-alive\r\n\r\nok")
.await
.unwrap();
stream.get_mut().flush().await.unwrap();
}
}
_ = shutdown_rx.changed() => {}
}
});
let client = test_client(&format!("http://127.0.0.1:{port}"));
for (path, total) in [
("/one", Duration::from_millis(500)),
("/two", Duration::from_secs(5)),
] {
let mut response = client
.get(&format!("http://origin.invalid{path}"))
.unwrap()
.timeout(Timeout {
total: Some(total),
..Default::default()
})
.send()
.await
.unwrap();
assert_eq!(response.text().await.unwrap(), "ok");
}
assert_eq!(accepted.load(Ordering::SeqCst), 1);
let _ = shutdown_tx.send(true);
}
#[tokio::test]
async fn hyper_connect_proxy_reuses_keep_alive_tunnel() {
let ca = CertAuthority::new();
let origin = TlsTestServer::start(&ca, &["origin.invalid"]).await;
let proxy_server = HttpProxyServer::start(HttpProxyConfig::default()).await;
let proxy = Proxy::all(&proxy_server.url()).unwrap();
let client = Client::builder()
.proxy(proxy)
.tls_config(
TlsConfig::builder()
.ca_certificate_pem(&ca.cert_pem())
.unwrap()
.build(),
)
.build();
for total in [Duration::from_millis(500), Duration::from_secs(5)] {
let mut response = client
.get(&format!("https://origin.invalid:{}/", origin.port()))
.unwrap()
.proxy_target_addresses([format!("127.0.0.1:{}", origin.port()).parse().unwrap()])
.timeout(Timeout {
total: Some(total),
..Default::default()
})
.send()
.await
.unwrap();
assert_eq!(response.text().await.unwrap(), "OK");
}
assert_eq!(proxy_server.connection_count(), 1);
proxy_server.shutdown();
origin.shutdown();
}
#[tokio::test]
async fn hyper_connect_proxy_does_not_reuse_short_total_on_reconnect() {
let ca = CertAuthority::new();
let origin = TlsTestServer::start(&ca, &["origin.invalid", "second-origin.invalid"]).await;
let proxy_server = HttpProxyServer::start(HttpProxyConfig {
connect_delay: Some((2, Duration::from_millis(700))),
..Default::default()
})
.await;
let client = Client::builder()
.proxy(Proxy::all(&proxy_server.url()).unwrap())
.tls_config(
TlsConfig::builder()
.ca_certificate_pem(&ca.cert_pem())
.unwrap()
.build(),
)
.build();
let origin_url = format!("https://origin.invalid:{}/", origin.port());
let second_origin_url = format!("https://second-origin.invalid:{}/", origin.port());
let target = format!("127.0.0.1:{}", origin.port()).parse().unwrap();
let mut first = client
.get(&origin_url)
.unwrap()
.proxy_target_addresses([target])
.timeout(Timeout {
total: Some(Duration::from_millis(500)),
connect: Some(Duration::from_secs(2)),
..Default::default()
})
.send()
.await
.unwrap();
assert_eq!(first.text().await.unwrap(), "OK");
let mut second = client
.get(&second_origin_url)
.unwrap()
.proxy_target_addresses([target])
.timeout(Timeout {
total: Some(Duration::from_secs(2)),
connect: Some(Duration::from_secs(2)),
..Default::default()
})
.send()
.await
.expect("a reused CONNECT client must use the current request total budget");
assert_eq!(second.text().await.unwrap(), "OK");
assert_eq!(proxy_server.connection_count(), 2);
assert_eq!(proxy_server.connect_targets().len(), 2);
proxy_server.shutdown();
origin.shutdown();
}
#[tokio::test]
async fn hyper_connect_proxy_fresh_client_honors_short_total() {
let ca = CertAuthority::new();
let origin = TlsTestServer::start(&ca, &["origin.invalid"]).await;
let proxy_server = HttpProxyServer::start(HttpProxyConfig {
connect_delay: Some((2, Duration::from_millis(400))),
..Default::default()
})
.await;
let client = Client::builder()
.proxy(Proxy::all(&proxy_server.url()).unwrap())
.tls_config(
TlsConfig::builder()
.ca_certificate_pem(&ca.cert_pem())
.unwrap()
.build(),
)
.build();
let origin_url = format!("https://origin.invalid:{}/", origin.port());
let target = format!("127.0.0.1:{}", origin.port()).parse().unwrap();
let mut first = client
.get(&origin_url)
.unwrap()
.proxy_target_addresses([target])
.timeout(Timeout {
total: Some(Duration::from_secs(2)),
connect: Some(Duration::from_secs(2)),
..Default::default()
})
.send()
.await
.unwrap();
assert_eq!(first.text().await.unwrap(), "OK");
proxy_server.close_tunnels();
proxy_server.wait_for_closed_tunnels(1).await;
drop(client);
let client = Client::builder()
.proxy(Proxy::all(&proxy_server.url()).unwrap())
.tls_config(
TlsConfig::builder()
.ca_certificate_pem(&ca.cert_pem())
.unwrap()
.build(),
)
.build();
let error = client
.get(&origin_url)
.unwrap()
.proxy_target_addresses([target])
.timeout(Timeout {
total: Some(Duration::from_millis(100)),
connect: Some(Duration::from_secs(2)),
..Default::default()
})
.send()
.await
.expect_err("the current short total budget must cancel reconnect setup");
assert!(
matches!(
&error,
Error::Timeout {
phase: TimeoutPhase::Total,
..
}
),
"expected the current request's total timeout, got: {error:?}"
);
assert_eq!(proxy_server.connection_count(), 2);
assert_eq!(proxy_server.connect_targets().len(), 2);
proxy_server.shutdown();
origin.shutdown();
}
fn weak_and_strict_proxy_tls() -> (TlsConfig, TlsConfig) {
let base = TlsConfig::builder().build();
let strict = base.clone();
let weak = base.danger_accept_invalid_certs(true);
(weak, strict)
}
#[tokio::test]
async fn forward_proxy_weak_then_strict_does_not_reuse_weak_route() {
let proxy_server = HttpsProxyServer::start_self_signed().await;
let (weak_tls, strict_tls) = weak_and_strict_proxy_tls();
let weak_holder = Proxy::all(&proxy_server.url())
.unwrap()
.with_proxy_tls_config(weak_tls);
let strict_holder = Proxy::all(&proxy_server.url())
.unwrap()
.with_proxy_tls_config(strict_tls);
let client = Client::builder().build();
let mut first = client
.get("http://origin.invalid/")
.unwrap()
.proxy(&weak_holder)
.send()
.await
.expect("weak proxy TLS must establish the fixture route");
assert_eq!(first.text().await.unwrap(), "ok");
assert_eq!(proxy_server.connection_count(), 1);
let strict_result = client
.get("http://origin.invalid/")
.unwrap()
.proxy(&strict_holder)
.send()
.await;
assert!(
strict_result.is_err(),
"strict proxy TLS must not silently reuse the weak pooled route"
);
assert_eq!(
proxy_server.connection_count(),
2,
"strict request must open its own proxy connection rather than reuse weak"
);
proxy_server.shutdown();
}
#[tokio::test]
async fn forward_proxy_strict_then_weak_uses_separate_routes() {
let proxy_server = HttpsProxyServer::start_self_signed().await;
let weak_holder = Proxy::all(&proxy_server.url())
.unwrap()
.with_proxy_tls_config(
TlsConfig::builder()
.build()
.danger_accept_invalid_certs(true),
);
let strict_holder = Proxy::all(&proxy_server.url()).unwrap();
let client = Client::builder().build();
assert!(
client
.get("http://origin.invalid/")
.unwrap()
.proxy(&strict_holder)
.send()
.await
.is_err(),
"strict proxy TLS must reject the self-signed fixture"
);
assert_eq!(proxy_server.connection_count(), 1);
let mut response = client
.get("http://origin.invalid/")
.unwrap()
.proxy(&weak_holder)
.send()
.await
.expect("weak proxy TLS must succeed on its own route");
assert_eq!(response.text().await.unwrap(), "ok");
assert_eq!(proxy_server.connection_count(), 2);
let mut again = client
.get("http://origin.invalid/")
.unwrap()
.proxy(&weak_holder)
.send()
.await
.expect("unchanged weak proxy TLS must reuse its route");
assert_eq!(again.text().await.unwrap(), "ok");
assert_eq!(
proxy_server.connection_count(),
2,
"unchanged proxy TLS clones must share the cached route client"
);
proxy_server.shutdown();
}
#[tokio::test]
async fn connect_proxy_weak_then_strict_does_not_reuse_weak_route() {
let ca = CertAuthority::new();
let origin = TlsTestServer::start(&ca, &["origin.invalid"]).await;
let proxy_server = HttpsProxyServer::start_self_signed().await;
let origin_tls = TlsConfig::builder()
.ca_certificate_pem(&ca.cert_pem())
.unwrap()
.build();
let weak_holder = Proxy::all(&proxy_server.url())
.unwrap()
.with_proxy_tls_config(
TlsConfig::builder()
.build()
.danger_accept_invalid_certs(true),
);
let strict_holder = Proxy::all(&proxy_server.url()).unwrap();
let client = Client::builder().tls_config(origin_tls).build();
let origin_url = format!("https://origin.invalid:{}/", origin.port());
let target: std::net::SocketAddr = format!("127.0.0.1:{}", origin.port()).parse().unwrap();
let mut first = client
.get(&origin_url)
.unwrap()
.proxy(&weak_holder)
.proxy_target_addresses([target])
.send()
.await
.expect("weak proxy TLS must establish the CONNECT route");
assert_eq!(first.text().await.unwrap(), "OK");
assert_eq!(proxy_server.connection_count(), 1);
assert_eq!(proxy_server.connect_targets().len(), 1);
let strict_result = client
.get(&origin_url)
.unwrap()
.proxy(&strict_holder)
.proxy_target_addresses([target])
.send()
.await;
assert!(
strict_result.is_err(),
"strict proxy TLS must not reuse the weak CONNECT route"
);
assert_eq!(
proxy_server.connection_count(),
2,
"strict CONNECT must open its own proxy connection"
);
proxy_server.shutdown();
origin.shutdown();
}
#[tokio::test]
async fn connect_proxy_strict_then_weak_uses_separate_routes() {
let ca = CertAuthority::new();
let origin = TlsTestServer::start(&ca, &["origin.invalid"]).await;
let proxy_server = HttpsProxyServer::start_self_signed().await;
let origin_tls = TlsConfig::builder()
.ca_certificate_pem(&ca.cert_pem())
.unwrap()
.build();
let weak_holder = Proxy::all(&proxy_server.url())
.unwrap()
.with_proxy_tls_config(
TlsConfig::builder()
.build()
.danger_accept_invalid_certs(true),
);
let strict_holder = Proxy::all(&proxy_server.url()).unwrap();
let client = Client::builder().tls_config(origin_tls).build();
let origin_url = format!("https://origin.invalid:{}/", origin.port());
let target: std::net::SocketAddr = format!("127.0.0.1:{}", origin.port()).parse().unwrap();
assert!(
client
.get(&origin_url)
.unwrap()
.proxy(&strict_holder)
.proxy_target_addresses([target])
.send()
.await
.is_err(),
"strict proxy TLS must reject the self-signed CONNECT proxy"
);
assert_eq!(proxy_server.connection_count(), 1);
let mut response = client
.get(&origin_url)
.unwrap()
.proxy(&weak_holder)
.proxy_target_addresses([target])
.send()
.await
.expect("weak proxy TLS must succeed on its own CONNECT route");
assert_eq!(response.text().await.unwrap(), "OK");
assert_eq!(proxy_server.connection_count(), 2);
assert_eq!(proxy_server.connect_targets().len(), 1);
proxy_server.shutdown();
origin.shutdown();
}
#[tokio::test]
async fn forward_proxy_per_request_read_budget_is_not_retained() {
let proxy_server = HttpsProxyServer::start_self_signed().await;
let weak_holder = Proxy::all(&proxy_server.url())
.unwrap()
.with_proxy_tls_config(
TlsConfig::builder()
.build()
.danger_accept_invalid_certs(true),
);
let client = Client::builder().build();
let mut first = client
.get("http://origin.invalid/slow")
.unwrap()
.proxy(&weak_holder)
.timeout(Timeout {
read: Some(Duration::from_secs(2)),
total: Some(Duration::from_secs(5)),
..Default::default()
})
.send()
.await
.expect("long read budget must succeed on the cached forward route");
assert_eq!(first.text().await.unwrap(), "ok");
let mut second = client
.get("http://origin.invalid/slow")
.unwrap()
.proxy(&weak_holder)
.timeout(Timeout {
read: Some(Duration::from_millis(50)),
total: Some(Duration::from_secs(5)),
..Default::default()
})
.send()
.await
.expect("headers arrive immediately; the read budget applies to the body");
let error = second
.text()
.await
.expect_err("short read budget must apply to the current request body");
assert!(
matches!(
error,
Error::Timeout {
phase: TimeoutPhase::Read,
..
}
),
"expected read timeout, got: {error:?}"
);
proxy_server.shutdown();
}
#[tokio::test]
async fn forward_proxy_per_request_trace_observer_is_not_retained() {
use eggfetch_core::trace::CollectingTraceObserver;
use eggfetch_core::TransportHints;
use std::sync::Arc;
let echo = EchoHttpServer::start().await;
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = test_client(&proxy.url());
let first_observer = Arc::new(CollectingTraceObserver::new());
let mut first = client
.get(&format!("{}/one", echo.url()))
.unwrap()
.transport_hints(TransportHints {
trace: Some(first_observer.clone()),
..Default::default()
})
.send()
.await
.expect("first traced request must succeed");
let first_body = first.text().await.unwrap();
assert!(
first_body.contains("GET /one"),
"unexpected echo body: {first_body}"
);
assert!(
!first_observer.is_empty(),
"first request must emit to its own observer"
);
let first_count = first_observer.len();
let second_observer = Arc::new(CollectingTraceObserver::new());
let mut second = client
.get(&format!("{}/two", echo.url()))
.unwrap()
.transport_hints(TransportHints {
trace: Some(second_observer.clone()),
..Default::default()
})
.send()
.await
.expect("second traced request must succeed on the cached route");
let second_body = second.text().await.unwrap();
assert!(
second_body.contains("GET /two"),
"unexpected echo body: {second_body}"
);
assert!(
!second_observer.is_empty(),
"second request must emit to its own observer"
);
assert_eq!(
first_observer.len(),
first_count,
"cached route must not replay the second request into the first observer"
);
echo.shutdown();
proxy.shutdown();
}
#[tokio::test]
async fn connect_empty_authority_returns_error() {
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = test_client(&proxy.url());
let result = client.get("https:///path").unwrap().send().await;
assert!(
result.is_err(),
"Expected error for URL with empty authority, got: {result:?}"
);
proxy.shutdown();
}
#[tokio::test]
async fn connect_missing_port_returns_error() {
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = test_client(&proxy.url());
let result = client
.get("https://this-host-does-not-exist-xyz.invalid/")
.unwrap()
.send()
.await;
assert!(
result.is_err(),
"Expected error for URL with unreachable host, got: {result:?}"
);
proxy.shutdown();
}
#[tokio::test]
async fn connect_invalid_host_returns_error() {
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = test_client(&proxy.url());
let result = client
.get("https://this.host.does.not.exist.invalid/")
.unwrap()
.send()
.await;
assert!(
result.is_err(),
"Expected error for URL with invalid host, got: {result:?}"
);
proxy.shutdown();
}
#[tokio::test]
async fn connect_non_numeric_port_returns_error() {
let proxy = HttpProxyServer::start(HttpProxyConfig::default()).await;
let client = test_client(&proxy.url());
let result = client.get("https://host:notaport/path");
assert!(
result.is_err(),
"Expected error for URL with non-numeric port"
);
proxy.shutdown();
}
#[tokio::test]
async fn proxy_response_exceeding_max_header_bytes_rejected() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
tokio::spawn(async move {
loop {
tokio::select! {
result = listener.accept() => {
if let Ok((mut stream, _)) = result {
tokio::spawn(async move {
let mut buf = [0u8; 4096];
loop {
let n = stream.read(&mut buf).await.unwrap_or(0);
if n == 0 { return; }
if buf[..n].windows(4).any(|w| w == b"\r\n\r\n") { break; }
}
let status = b"HTTP/1.1 200 OK\r\n";
let mut response = Vec::from(status.as_slice());
for i in 0..700 {
let header = format!("X-Pad-{i}: {}\r\n", "A".repeat(80));
response.extend_from_slice(header.as_bytes());
}
response.extend_from_slice(b"\r\n");
let _ = stream.write_all(&response).await;
let _ = stream.flush().await;
});
}
}
_ = shutdown_rx.changed() => { break; }
}
}
});
let client = Client::builder()
.proxy(Proxy::all(&format!("http://127.0.0.1:{port}")).unwrap())
.timeout(Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let result = client.get("http://127.0.0.1:1/").unwrap().send().await;
let err = result.unwrap_err();
assert_eq!(
err.kind(),
"malformed_proxy_response",
"proxy response exceeding MAX_TOTAL_HEADER_BYTES should fail with MalformedProxyResponse, got: {err}"
);
let _ = shutdown_tx.send(true);
}
#[tokio::test]
async fn no_proxy_port_bypass() {
let echo = EchoHttpServer::start().await;
let echo_port: u16 = echo.url().rsplit(':').next().unwrap().parse().unwrap();
let no_proxy = eggfetch_core::NoProxy::parse(&format!("127.0.0.1:{echo_port}")).unwrap();
let client = Client::builder()
.proxy(
Proxy::all("http://127.0.0.1:9999")
.unwrap()
.no_proxy(no_proxy),
)
.timeout(Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let mut resp = client.get(&echo.url()).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let body = resp.text().await.unwrap();
assert!(body.contains("GET"));
echo.shutdown();
}
#[tokio::test]
async fn no_proxy_ipv4_bypass() {
let echo = EchoHttpServer::start().await;
let no_proxy = eggfetch_core::NoProxy::parse("127.0.0.1").unwrap();
let client = Client::builder()
.proxy(
Proxy::all("http://127.0.0.1:9999")
.unwrap()
.no_proxy(no_proxy),
)
.timeout(Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let mut resp = client.get(&echo.url()).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let body = resp.text().await.unwrap();
assert!(body.contains("GET"));
echo.shutdown();
}
#[tokio::test]
async fn no_proxy_localhost_bypass() {
let echo = EchoHttpServer::start().await;
let no_proxy = eggfetch_core::NoProxy::parse("localhost").unwrap();
let client = Client::builder()
.proxy(
Proxy::all("http://127.0.0.1:9999")
.unwrap()
.no_proxy(no_proxy),
)
.timeout(Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let mut resp = client.get(&echo.url()).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let body = resp.text().await.unwrap();
assert!(body.contains("GET"));
echo.shutdown();
}
struct SlowConnectResponseProxy {
port: u16,
connect_delay_ms: u64,
shutdown: watch::Sender<bool>,
}
impl SlowConnectResponseProxy {
async fn start(connect_delay_ms: u64) -> Self {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
tokio::spawn(async move {
loop {
tokio::select! {
result = listener.accept() => {
if let Ok((stream, _)) = result {
let delay = connect_delay_ms;
tokio::spawn(async move {
if let Err(e) = handle_slow_connect(stream, delay).await {
eprintln!("slow connect proxy error: {e}");
}
});
}
}
_ = shutdown_rx.changed() => {
break;
}
}
}
});
Self {
port,
connect_delay_ms,
shutdown: shutdown_tx,
}
}
fn url(&self) -> String {
format!("http://127.0.0.1:{}", self.port)
}
fn shutdown(&self) {
let _ = self.shutdown.send(true);
}
}
async fn handle_slow_connect(
mut client_stream: TcpStream,
delay_ms: u64,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let mut buf_reader = BufReader::new(&mut client_stream);
let mut request_line = String::new();
buf_reader.read_line(&mut request_line).await?;
if request_line.trim().is_empty() {
return Ok(());
}
loop {
let mut line = String::new();
buf_reader.read_line(&mut line).await?;
if line.trim().is_empty() {
break;
}
}
let parts: Vec<&str> = request_line.split_whitespace().collect();
let method = parts[0];
if method.eq_ignore_ascii_case("CONNECT") {
drop(buf_reader);
tokio::time::sleep(Duration::from_millis(delay_ms)).await;
let resp = b"HTTP/1.1 200 Connection Established\r\n\r\n";
client_stream.write_all(resp).await?;
tokio::time::sleep(Duration::from_secs(60)).await;
}
Ok(())
}
struct StallingTlsServer {
port: u16,
shutdown: watch::Sender<bool>,
}
impl StallingTlsServer {
async fn start() -> Self {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
tokio::spawn(async move {
loop {
tokio::select! {
result = listener.accept() => {
if let Ok((_stream, _)) = result {
tokio::time::sleep(Duration::from_secs(60)).await;
}
}
_ = shutdown_rx.changed() => {
break;
}
}
}
});
Self {
port,
shutdown: shutdown_tx,
}
}
fn port(&self) -> u16 {
self.port
}
fn shutdown(&self) {
let _ = self.shutdown.send(true);
}
}
struct ConnectToStallingProxy {
port: u16,
shutdown: watch::Sender<bool>,
}
impl ConnectToStallingProxy {
async fn start(dest_port: u16) -> Self {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
tokio::spawn(async move {
loop {
tokio::select! {
result = listener.accept() => {
if let Ok((stream, _)) = result {
tokio::spawn(async move {
if let Err(e) = handle_connect_to_stalling(stream, dest_port).await {
eprintln!("connect-to-stalling proxy error: {e}");
}
});
}
}
_ = shutdown_rx.changed() => {
break;
}
}
}
});
Self {
port,
shutdown: shutdown_tx,
}
}
fn url(&self) -> String {
format!("http://127.0.0.1:{}", self.port)
}
fn shutdown(&self) {
let _ = self.shutdown.send(true);
}
}
async fn handle_connect_to_stalling(
mut client_stream: TcpStream,
dest_port: u16,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let mut buf_reader = BufReader::new(&mut client_stream);
let mut request_line = String::new();
buf_reader.read_line(&mut request_line).await?;
if request_line.trim().is_empty() {
return Ok(());
}
loop {
let mut line = String::new();
buf_reader.read_line(&mut line).await?;
if line.trim().is_empty() {
break;
}
}
let parts: Vec<&str> = request_line.split_whitespace().collect();
let method = parts[0];
if method.eq_ignore_ascii_case("CONNECT") {
drop(buf_reader);
if let Ok(dest_stream) = TcpStream::connect(format!("127.0.0.1:{dest_port}")).await {
let resp = b"HTTP/1.1 200 Connection Established\r\n\r\n";
client_stream.write_all(resp).await?;
let (mut client_read, mut client_write) = tokio::io::split(client_stream);
let (mut dest_read, mut dest_write) = dest_stream.into_split();
let c2d = async {
let _ = tokio::io::copy(&mut client_read, &mut dest_write).await;
let _ = dest_write.shutdown().await;
};
let d2c = async {
let _ = tokio::io::copy(&mut dest_read, &mut client_write).await;
let _ = client_write.shutdown().await;
};
tokio::select! {
() = c2d => {}
() = d2c => {}
}
} else {
let resp = b"HTTP/1.1 502 Bad Gateway\r\nContent-Length: 0\r\n\r\n";
client_stream.write_all(resp).await?;
}
}
Ok(())
}
#[tokio::test]
async fn test_proxy_connect_timeout_on_unreachable_proxy() {
let client = Client::builder()
.proxy(Proxy::all("http://192.0.2.1:8080").unwrap())
.timeout(Timeout {
total: Some(Duration::from_millis(200)),
..Default::default()
})
.build();
let start = std::time::Instant::now();
let result = client.get("https://example.com/test").unwrap().send().await;
let elapsed = start.elapsed();
assert!(
result.is_err(),
"expected error connecting to unreachable proxy"
);
assert!(
elapsed < Duration::from_secs(2),
"total timeout should fire within 200ms + margin, took {elapsed:?}"
);
}
#[tokio::test]
async fn test_proxy_tls_timeout_on_stalling_destination() {
let stalling = StallingTlsServer::start().await;
let proxy = ConnectToStallingProxy::start(stalling.port()).await;
let client = Client::builder()
.proxy(Proxy::all(&proxy.url()).unwrap())
.timeout(Timeout {
total: Some(Duration::from_millis(300)),
connect: Some(Duration::from_millis(100)),
..Default::default()
})
.build();
let result = client
.get(&format!("https://127.0.0.1:{}/test", stalling.port()))
.unwrap()
.send()
.await;
assert!(
matches!(
result,
Err(Error::Timeout {
phase: TimeoutPhase::Connect,
..
})
),
"expected Connect timeout, got: {result:?}"
);
proxy.shutdown();
stalling.shutdown();
}
#[tokio::test]
async fn test_total_timeout_envelope_across_proxy_phases() {
let client = Client::builder()
.proxy(Proxy::all("http://192.0.2.1:8080").unwrap())
.timeout(Timeout {
total: Some(Duration::from_millis(150)),
..Default::default()
})
.build();
let start = std::time::Instant::now();
let result = client.get("https://example.com/test").unwrap().send().await;
let elapsed = start.elapsed();
assert!(
result.is_err(),
"expected error from total timeout envelope"
);
assert!(
elapsed < Duration::from_secs(2),
"total timeout should fire within 150ms + margin, took {elapsed:?}"
);
}
#[derive(Default)]
struct Socks5Config {
auth: Option<(String, String)>,
reject_all: bool,
malformed: bool,
reject_target: Option<(String, u8)>,
}
struct Socks5Server {
port: u16,
shutdown: watch::Sender<bool>,
last_connect: Arc<std::sync::Mutex<Option<(String, u16, u8)>>>,
connect_count: Arc<AtomicUsize>,
}
impl Socks5Server {
async fn start(config: Socks5Config) -> Self {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
let last_connect = Arc::new(std::sync::Mutex::new(None));
let last_connect_clone = last_connect.clone();
let connect_count = Arc::new(AtomicUsize::new(0));
let connect_count_clone = connect_count.clone();
tokio::spawn(async move {
loop {
tokio::select! {
result = listener.accept() => {
match result {
Ok((stream, _)) => {
let auth = config.auth.clone();
let reject = config.reject_all;
let malformed = config.malformed;
let reject_target = config.reject_target.clone();
let lc = last_connect_clone.clone();
let cc = connect_count_clone.clone();
tokio::spawn(async move {
if let Err(e) = handle_socks5_connection(
stream, auth, reject, malformed, reject_target, lc, cc,
).await {
eprintln!("SOCKS5 connection error: {e}");
}
});
}
Err(e) => {
eprintln!("accept error: {e}");
break;
}
}
}
_ = shutdown_rx.changed() => {
break;
}
}
}
});
Self {
port,
shutdown: shutdown_tx,
last_connect,
connect_count,
}
}
fn url(&self) -> String {
format!("socks5://127.0.0.1:{}", self.port)
}
fn url_with_auth(&self, user: &str, pass: &str) -> String {
format!("socks5://{user}:{pass}@127.0.0.1:{}", self.port)
}
fn url_remote_dns(&self) -> String {
format!("socks5h://127.0.0.1:{}", self.port)
}
fn last_connect(&self) -> Option<(String, u16, u8)> {
self.last_connect.lock().unwrap().clone()
}
fn connect_count(&self) -> usize {
self.connect_count.load(Ordering::SeqCst)
}
fn shutdown(&self) {
let _ = self.shutdown.send(true);
}
}
#[allow(clippy::too_many_lines)]
async fn handle_socks5_connection(
mut stream: TcpStream,
required_auth: Option<(String, String)>,
reject_all: bool,
malformed: bool,
reject_target: Option<(String, u8)>,
last_connect: Arc<std::sync::Mutex<Option<(String, u16, u8)>>>,
connect_count: Arc<AtomicUsize>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let mut version = [0u8; 1];
stream.read_exact(&mut version).await?;
if version[0] != 0x05 {
return Err("invalid SOCKS5 version".into());
}
let mut nmethods = [0u8; 1];
stream.read_exact(&mut nmethods).await?;
let mut methods = vec![0u8; nmethods[0] as usize];
stream.read_exact(&mut methods).await?;
if required_auth.is_some() {
stream.write_all(&[0x05, 0x02]).await?;
} else {
stream.write_all(&[0x05, 0x00]).await?;
}
if let Some((ref required_user, ref required_pass)) = required_auth {
let mut sub_version = [0u8; 1];
stream.read_exact(&mut sub_version).await?;
if sub_version[0] != 0x01 {
return Err("invalid auth subnegotiation version".into());
}
let mut ulen = [0u8; 1];
stream.read_exact(&mut ulen).await?;
let mut username = vec![0u8; ulen[0] as usize];
stream.read_exact(&mut username).await?;
let mut plen = [0u8; 1];
stream.read_exact(&mut plen).await?;
let mut password = vec![0u8; plen[0] as usize];
stream.read_exact(&mut password).await?;
let username = String::from_utf8_lossy(&username);
let password = String::from_utf8_lossy(&password);
if *username == *required_user && *password == *required_pass {
stream.write_all(&[0x01, 0x00]).await?; } else {
stream.write_all(&[0x01, 0x01]).await?; return Ok(());
}
}
let mut req_header = [0u8; 4];
stream.read_exact(&mut req_header).await?;
if req_header[0] != 0x05 {
return Err("invalid SOCKS5 request version".into());
}
if req_header[1] != 0x01 {
stream
.write_all(&[0x05, 0x07, 0x00, 0x01, 0, 0, 0, 0, 0, 0])
.await?;
return Ok(());
}
let (dest_host, dest_port, atyp) = match req_header[3] {
0x01 => {
let mut addr = [0u8; 4];
stream.read_exact(&mut addr).await?;
let mut port_buf = [0u8; 2];
stream.read_exact(&mut port_buf).await?;
let port = u16::from_be_bytes(port_buf);
let host = std::net::Ipv4Addr::from(addr).to_string();
(host, port, 0x01)
}
0x03 => {
let mut dlen = [0u8; 1];
stream.read_exact(&mut dlen).await?;
let mut domain = vec![0u8; dlen[0] as usize];
stream.read_exact(&mut domain).await?;
let mut port_buf = [0u8; 2];
stream.read_exact(&mut port_buf).await?;
let port = u16::from_be_bytes(port_buf);
let host = String::from_utf8_lossy(&domain).into_owned();
(host, port, 0x03)
}
0x04 => {
let mut addr = [0u8; 16];
stream.read_exact(&mut addr).await?;
let mut port_buf = [0u8; 2];
stream.read_exact(&mut port_buf).await?;
let port = u16::from_be_bytes(port_buf);
let host = std::net::Ipv6Addr::from(addr).to_string();
(host, port, 0x04)
}
other => {
return Err(format!("unsupported address type: {other}").into());
}
};
{
let mut lc = last_connect.lock().unwrap();
*lc = Some((dest_host.clone(), dest_port, atyp));
}
connect_count.fetch_add(1, Ordering::SeqCst);
if malformed {
stream.write_all(&[0x05, 0xFF]).await?;
return Ok(());
}
if reject_all
|| reject_target
.as_ref()
.is_some_and(|(host, _)| host == &dest_host)
{
let reply_code = reject_target
.as_ref()
.filter(|(host, _)| host == &dest_host)
.map_or(0x05, |(_, code)| *code);
stream
.write_all(&[0x05, reply_code, 0x00, 0x01, 0, 0, 0, 0, 0, 0])
.await?;
return Ok(());
}
let dest_addr = if dest_host == "localhost" {
format!("127.0.0.1:{dest_port}")
} else {
format!("{dest_host}:{dest_port}")
};
match TcpStream::connect(&dest_addr).await {
Ok(dest_stream) => {
stream
.write_all(&[0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0])
.await?;
let (mut client_read, mut client_write) = stream.into_split();
let (mut dest_read, mut dest_write) = dest_stream.into_split();
let client_to_dest = async {
let _ = tokio::io::copy(&mut client_read, &mut dest_write).await;
let _ = dest_write.shutdown().await;
};
let dest_to_client = async {
let _ = tokio::io::copy(&mut dest_read, &mut client_write).await;
let _ = client_write.shutdown().await;
};
tokio::select! {
() = client_to_dest => {}
() = dest_to_client => {}
}
}
Err(e) => {
let _ = e; stream
.write_all(&[0x05, 0x05, 0x00, 0x01, 0, 0, 0, 0, 0, 0])
.await?;
}
}
Ok(())
}
struct LocalHttpServer {
port: u16,
shutdown: watch::Sender<bool>,
}
impl LocalHttpServer {
async fn start() -> Self {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
tokio::spawn(async move {
loop {
tokio::select! {
result = listener.accept() => {
match result {
Ok((stream, _)) => {
tokio::spawn(async move {
if let Err(e) = handle_http_request(stream).await {
eprintln!("HTTP server error: {e}");
}
});
}
Err(e) => {
eprintln!("accept error: {e}");
break;
}
}
}
_ = shutdown_rx.changed() => {
break;
}
}
}
});
Self {
port,
shutdown: shutdown_tx,
}
}
fn url(&self) -> String {
format!("http://127.0.0.1:{}", self.port)
}
fn shutdown(&self) {
let _ = self.shutdown.send(true);
}
}
async fn handle_http_request(
mut stream: TcpStream,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
use tokio::io::AsyncWriteExt;
let mut buf_reader = BufReader::new(&mut stream);
let mut request_line = String::new();
buf_reader.read_line(&mut request_line).await?;
loop {
let mut line = String::new();
buf_reader.read_line(&mut line).await?;
if line.trim().is_empty() {
break;
}
}
let response = "HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r\nHello, World!";
let w = buf_reader.into_inner();
w.write_all(response.as_bytes()).await?;
Ok(())
}
#[tokio::test]
async fn test_socks5_http_through_proxy() {
let http_server = LocalHttpServer::start().await;
let socks_server = Socks5Server::start(Socks5Config::default()).await;
let client = Client::builder()
.proxy(Proxy::all(&socks_server.url()).unwrap())
.build();
let result = client
.get(&format!("http://127.0.0.1:{}", http_server.port))
.unwrap()
.send()
.await;
assert!(result.is_ok(), "SOCKS5 HTTP request failed: {result:?}");
let mut response = result.unwrap();
assert_eq!(response.status(), 200);
let body = response.text().await.unwrap();
assert_eq!(body, "Hello, World!");
let connect = socks_server.last_connect();
assert!(
connect.is_some(),
"SOCKS server should have recorded a CONNECT"
);
let (host, _port, _atyp) = connect.unwrap();
assert_eq!(host, "127.0.0.1");
socks_server.shutdown();
http_server.shutdown();
}
#[tokio::test]
async fn test_socks5_no_auth() {
let http_server = LocalHttpServer::start().await;
let socks_server = Socks5Server::start(Socks5Config::default()).await;
let client = Client::builder()
.proxy(Proxy::all(&socks_server.url()).unwrap())
.build();
let result = client
.get(&format!("http://127.0.0.1:{}", http_server.port))
.unwrap()
.send()
.await;
assert!(result.is_ok(), "SOCKS5 no-auth request failed: {result:?}");
assert_eq!(result.unwrap().status(), 200);
socks_server.shutdown();
http_server.shutdown();
}
#[tokio::test]
async fn test_socks5_with_auth() {
let http_server = LocalHttpServer::start().await;
let socks_server = Socks5Server::start(Socks5Config {
auth: Some(("testuser".into(), "testpass".into())),
..Default::default()
})
.await;
let client = Client::builder()
.proxy(Proxy::all(&socks_server.url_with_auth("testuser", "testpass")).unwrap())
.build();
let result = client
.get(&format!("http://127.0.0.1:{}", http_server.port))
.unwrap()
.send()
.await;
assert!(result.is_ok(), "SOCKS5 auth request failed: {result:?}");
assert_eq!(result.unwrap().status(), 200);
socks_server.shutdown();
http_server.shutdown();
}
#[tokio::test]
async fn test_socks5_auth_rejection() {
let http_server = LocalHttpServer::start().await;
let socks_server = Socks5Server::start(Socks5Config {
auth: Some(("testuser".into(), "testpass".into())),
..Default::default()
})
.await;
let client = Client::builder()
.proxy(Proxy::all(&socks_server.url_with_auth("wrong", "creds")).unwrap())
.build();
let result = client
.get(&format!("http://127.0.0.1:{}", http_server.port))
.unwrap()
.send()
.await;
assert!(result.is_err(), "SOCKS5 auth rejection should fail");
socks_server.shutdown();
http_server.shutdown();
}
#[tokio::test]
async fn test_socks5_connect_refusal() {
let http_server = LocalHttpServer::start().await;
let socks_server = Socks5Server::start(Socks5Config {
reject_all: true,
..Default::default()
})
.await;
let client = Client::builder()
.proxy(Proxy::all(&socks_server.url()).unwrap())
.build();
let result = client
.get(&format!("http://127.0.0.1:{}", http_server.port))
.unwrap()
.send()
.await;
assert!(result.is_err(), "SOCKS5 connect refusal should fail");
socks_server.shutdown();
http_server.shutdown();
}
#[tokio::test]
async fn test_socks5_malformed_reply() {
let http_server = LocalHttpServer::start().await;
let socks_server = Socks5Server::start(Socks5Config {
malformed: true,
..Default::default()
})
.await;
let client = Client::builder()
.proxy(Proxy::all(&socks_server.url()).unwrap())
.build();
let result = client
.get(&format!("http://127.0.0.1:{}", http_server.port))
.unwrap()
.send()
.await;
assert!(result.is_err(), "SOCKS5 malformed reply should fail");
socks_server.shutdown();
http_server.shutdown();
}
#[tokio::test]
async fn test_socks5_remote_dns() {
let http_server = LocalHttpServer::start().await;
let socks_server = Socks5Server::start(Socks5Config::default()).await;
let client = Client::builder()
.proxy(Proxy::all(&socks_server.url_remote_dns()).unwrap())
.build();
let result = client
.get(&format!("http://localhost:{}", http_server.port))
.unwrap()
.send()
.await;
assert!(
result.is_ok(),
"SOCKS5h remote DNS request failed: {result:?}"
);
assert_eq!(result.unwrap().status(), 200);
let connect = socks_server.last_connect();
assert!(connect.is_some());
let (_host, _port, atyp) = connect.unwrap();
assert_eq!(atyp, 0x03, "socks5h should use domain name (ATYP_DOMAIN)");
socks_server.shutdown();
http_server.shutdown();
}
#[tokio::test]
async fn test_socks5_connect_timeout() {
let client = Client::builder()
.proxy(Proxy::all("socks5://192.0.2.1:1080").unwrap())
.timeout(Timeout {
total: Some(Duration::from_millis(200)),
..Default::default()
})
.build();
let start = std::time::Instant::now();
let result = client.get("http://example.com").unwrap().send().await;
let elapsed = start.elapsed();
assert!(result.is_err(), "SOCKS5 timeout should fail");
assert!(
elapsed < Duration::from_secs(2),
"timeout should fire quickly, took {elapsed:?}"
);
let err = result.unwrap_err();
assert!(
matches!(
err,
Error::Timeout {
phase: TimeoutPhase::ProxyConnect | TimeoutPhase::Total,
..
} | Error::ProxyConnect(_)
),
"expected timeout or proxy connect error, got: {err}"
);
}
#[tokio::test]
async fn test_socks5_no_proxy_bypass() {
let http_server = LocalHttpServer::start().await;
let socks_server = Socks5Server::start(Socks5Config::default()).await;
use eggfetch_core::NoProxy;
let no_proxy = NoProxy::parse("127.0.0.1").unwrap();
let proxy = Proxy::all(&socks_server.url()).unwrap().no_proxy(no_proxy);
let client = Client::builder().proxy(proxy).build();
let result = client
.get(&format!("http://127.0.0.1:{}", http_server.port))
.unwrap()
.send()
.await;
assert!(result.is_ok(), "NO_PROXY bypass request failed: {result:?}");
assert_eq!(result.unwrap().status(), 200);
let connect = socks_server.last_connect();
assert!(
connect.is_none(),
"SOCKS proxy should not have been used with NO_PROXY bypass"
);
socks_server.shutdown();
http_server.shutdown();
}