use bytes::Bytes;
use futures_util::{AsyncReadExt as _, AsyncWriteExt as _};
use http::HeaderValue;
use std::net::IpAddr;
use crate::{
Body, Error, Result,
runtime::{Deadline, Executor, Io, PrefixedIo, Timer},
};
const MAX_PROXY_RESPONSE_SIZE: usize = 16 * 1024;
pub(crate) mod http1 {
use super::{Body, Error, Executor, Io, Result};
use crate::connection::Http1;
pub(crate) type Sender = hyper::client::conn::http1::SendRequest<Body>;
pub(crate) async fn connect(
stream: Io,
executor: &Executor,
settings: Http1,
) -> Result<Sender> {
let mut builder = hyper::client::conn::http1::Builder::new();
settings.apply(&mut builder);
let (sender, connection) = builder
.handshake(stream)
.await
.map_err(|_| Error::connect())?;
executor.spawn(async move {
let _ = connection.with_upgrades().await;
});
Ok(sender)
}
}
pub(crate) mod http2 {
use super::{Body, Error, Executor, Io, Result, Timer};
use crate::connection::Http2;
pub(crate) type Sender = hyper::client::conn::http2::SendRequest<Body>;
pub(crate) async fn connect(
stream: Io,
executor: &Executor,
timer: &Timer,
settings: Http2,
) -> Result<Sender> {
let mut builder = hyper::client::conn::http2::Builder::new(executor.clone());
builder.timer(timer.clone());
settings.apply(&mut builder);
let (sender, connection) = builder
.handshake(stream)
.await
.map_err(|_| Error::connect())?;
executor.spawn(async move {
let _ = connection.await;
});
Ok(sender)
}
}
pub(crate) fn classify_error(error: &hyper::Error) -> Error {
if error.is_timeout() {
Error::timeout()
} else if error.is_closed() || error.is_canceled() {
Error::connect()
} else {
Error::body()
}
}
pub(crate) async fn tunnel(
mut io: Io,
authority: &str,
authorization: Option<&HeaderValue>,
deadline: Deadline,
) -> Result<Io> {
let mut request = format!(
"CONNECT {authority} HTTP/1.1\r\nHost: {authority}\r\nProxy-Connection: keep-alive\r\n"
)
.into_bytes();
if let Some(authorization) = authorization {
request.extend_from_slice(b"Proxy-Authorization: ");
request.extend_from_slice(authorization.as_bytes());
request.extend_from_slice(b"\r\n");
}
request.extend_from_slice(b"\r\n");
deadline
.run(async {
io.write_all(&request).await.map_err(|_| Error::connect())?;
io.flush().await.map_err(|_| Error::connect())?;
Ok(())
})
.await?;
let mut response = Vec::with_capacity(1024);
let mut chunk = [0; 1024];
let consumed = deadline
.run(async {
loop {
let read = io.read(&mut chunk).await.map_err(|_| Error::connect())?;
if read == 0 {
return Err(Error::connect());
}
response.extend_from_slice(&chunk[..read]);
if let Some(consumed) = parse_tunnel_response(&response)? {
return Ok(consumed);
}
}
})
.await?;
let prefix = Bytes::copy_from_slice(&response[consumed..]);
Ok(Io::from_futures(PrefixedIo::new(prefix, io)))
}
pub(crate) async fn socks5(
mut io: Io,
host: &str,
port: u16,
credentials: Option<(&str, &str)>,
deadline: Deadline,
) -> Result<Io> {
let target = socks5_target(host, port)?;
let authenticated = credentials.is_some();
let greeting = if authenticated {
&[5, 1, 2][..]
} else {
&[5, 1, 0][..]
};
deadline
.run(async {
io.write_all(greeting).await.map_err(|_| Error::connect())?;
io.flush().await.map_err(|_| Error::connect())?;
let mut selection = [0; 2];
io.read_exact(&mut selection)
.await
.map_err(|_| Error::connect())?;
if selection != [5, if authenticated { 2 } else { 0 }] {
return Err(Error::connect());
}
if let Some((username, password)) = credentials {
let username = username.as_bytes();
let password = password.as_bytes();
if username.len() > u8::MAX as usize || password.len() > u8::MAX as usize {
return Err(Error::connect());
}
let mut auth = Vec::with_capacity(username.len() + password.len() + 3);
auth.extend_from_slice(&[1, username.len() as u8]);
auth.extend_from_slice(username);
auth.push(password.len() as u8);
auth.extend_from_slice(password);
io.write_all(&auth).await.map_err(|_| Error::connect())?;
io.flush().await.map_err(|_| Error::connect())?;
let mut reply = [0; 2];
io.read_exact(&mut reply)
.await
.map_err(|_| Error::connect())?;
if reply != [1, 0] {
return Err(Error::connect());
}
}
let mut request = Vec::with_capacity(target.len() + 3);
request.extend_from_slice(&[5, 1, 0]);
request.extend_from_slice(&target);
io.write_all(&request).await.map_err(|_| Error::connect())?;
io.flush().await.map_err(|_| Error::connect())?;
let mut reply = [0; 4];
io.read_exact(&mut reply)
.await
.map_err(|_| Error::connect())?;
if reply[0] != 5 || reply[1] != 0 {
return Err(Error::connect());
}
let address_length = match reply[3] {
1 => 4,
3 => {
let mut length = [0; 1];
io.read_exact(&mut length)
.await
.map_err(|_| Error::connect())?;
usize::from(length[0])
}
4 => 16,
_ => return Err(Error::connect()),
};
let mut ignored = vec![0; address_length + 2];
io.read_exact(&mut ignored)
.await
.map_err(|_| Error::connect())?;
Ok(())
})
.await?;
Ok(io)
}
fn socks5_target(host: &str, port: u16) -> Result<Vec<u8>> {
let mut target = Vec::with_capacity(host.len() + 3);
match host.parse() {
Ok(IpAddr::V4(address)) => {
target.push(1);
target.extend_from_slice(&address.octets());
}
Ok(IpAddr::V6(address)) => {
target.push(4);
target.extend_from_slice(&address.octets());
}
Err(_) => {
if host.is_empty() || host.len() > u8::MAX as usize {
return Err(Error::connect());
}
target.extend_from_slice(&[3, host.len() as u8]);
target.extend_from_slice(host.as_bytes());
}
}
target.extend_from_slice(&port.to_be_bytes());
Ok(target)
}
fn parse_tunnel_response(input: &[u8]) -> Result<Option<usize>> {
let mut headers = [httparse::EMPTY_HEADER; 64];
let mut response = httparse::Response::new(&mut headers);
let consumed = match response.parse(input).map_err(|_| Error::connect())? {
httparse::Status::Partial if input.len() < MAX_PROXY_RESPONSE_SIZE => return Ok(None),
httparse::Status::Partial => return Err(Error::connect()),
httparse::Status::Complete(consumed) => consumed,
};
if !(200..300).contains(&response.code.unwrap_or_default()) {
return Err(Error::connect());
}
Ok(Some(consumed))
}
#[cfg(test)]
mod tests {
use super::socks5_target;
#[test]
fn socks_targets_preserve_ip_address_types() {
assert_eq!(
socks5_target("127.0.0.1", 80).unwrap(),
[1, 127, 0, 0, 1, 0, 80]
);
assert_eq!(
socks5_target("::1", 443).unwrap(),
[4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 187]
);
assert_eq!(
socks5_target("example.com", 8080).unwrap(),
[
3, 11, b'e', b'x', b'a', b'm', b'p', b'l', b'e', b'.', b'c', b'o', b'm', 31, 144
]
);
}
}