use std::fmt;
use crate::error::ConnectError;
use crate::target::ConnectTarget;
pub struct ConnectRequest<'a> {
pub target: &'a ConnectTarget,
pub proxy_authorization: Option<&'a str>,
pub extra_headers: &'a [(String, Vec<u8>)],
pub max_head_bytes: usize,
}
impl fmt::Debug for ConnectRequest<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let redacted_extra: Vec<(&str, String)> = self
.extra_headers
.iter()
.map(|(name, value)| {
if name.eq_ignore_ascii_case("proxy-authorization") {
(name.as_str(), String::from("<redacted>"))
} else {
(name.as_str(), String::from_utf8_lossy(value).into_owned())
}
})
.collect();
f.debug_struct("ConnectRequest")
.field("target", &self.target)
.field(
"proxy_authorization",
&self.proxy_authorization.map(|_| "<redacted>"),
)
.field("extra_headers", &redacted_extra)
.field("max_head_bytes", &self.max_head_bytes)
.finish()
}
}
pub fn basic_auth_value(username: &str, password: &str) -> Result<String, ConnectError> {
if username.contains(':') {
return Err(ConnectError::InvalidCredentials);
}
for value in [username, password] {
for c in value.chars() {
if c == '\r' || c == '\n' || c == '\0' || c.is_control() || c == '\u{7f}' {
return Err(ConnectError::InvalidCredentials);
}
}
}
{
use base64::Engine as _;
let credential = format!("{username}:{password}");
let encoded = base64::engine::general_purpose::STANDARD.encode(credential.as_bytes());
Ok(format!("Basic {encoded}"))
}
}
pub fn encode_connect_request(request: &ConnectRequest<'_>) -> Result<Vec<u8>, ConnectError> {
let authority = request.target.authority();
if let Some(auth) = request.proxy_authorization {
validate_header_value_bytes(auth.as_bytes())?;
}
let mut extra_auth_count = 0_usize;
for (name, value) in request.extra_headers {
validate_header_name(name)?;
validate_header_value_bytes(value)?;
if name.eq_ignore_ascii_case("proxy-authorization") {
extra_auth_count += 1;
}
if name.eq_ignore_ascii_case("host") {
return Err(ConnectError::ReservedHeader);
}
}
if request.proxy_authorization.is_some() && extra_auth_count > 0 {
return Err(ConnectError::DuplicateAuthorization);
}
if extra_auth_count > 1 {
return Err(ConnectError::DuplicateAuthorization);
}
let max = request.max_head_bytes;
let mut out = Vec::new();
let request_line = format!("CONNECT {authority} HTTP/1.1\r\n");
let host_line = format!("Host: {authority}\r\n");
let mut len = 0_usize;
for chunk_len in [
request_line.len(),
host_line.len(),
request
.proxy_authorization
.map_or(0, |v| "Proxy-Authorization: ".len() + v.len() + 2),
] {
len = len
.checked_add(chunk_len)
.ok_or(ConnectError::RequestHeadTooLarge {
len: usize::MAX,
max,
})?;
if len > max {
return Err(ConnectError::RequestHeadTooLarge { len, max });
}
}
for (name, value) in request.extra_headers {
let header_len = name.len().checked_add(2 + value.len() + 2).ok_or(
ConnectError::RequestHeadTooLarge {
len: usize::MAX,
max,
},
)?;
len = len
.checked_add(header_len)
.ok_or(ConnectError::RequestHeadTooLarge {
len: usize::MAX,
max,
})?;
if len > max {
return Err(ConnectError::RequestHeadTooLarge { len, max });
}
}
len = len
.checked_add(2)
.ok_or(ConnectError::RequestHeadTooLarge {
len: usize::MAX,
max,
})?;
if len > max {
return Err(ConnectError::RequestHeadTooLarge { len, max });
}
out.extend_from_slice(request_line.as_bytes());
out.extend_from_slice(host_line.as_bytes());
if let Some(auth) = request.proxy_authorization {
out.extend_from_slice(b"Proxy-Authorization: ");
out.extend_from_slice(auth.as_bytes());
out.extend_from_slice(b"\r\n");
}
for (name, value) in request.extra_headers {
out.extend_from_slice(name.as_bytes());
out.extend_from_slice(b": ");
out.extend_from_slice(value);
out.extend_from_slice(b"\r\n");
}
out.extend_from_slice(b"\r\n");
debug_assert_eq!(out.len(), len);
Ok(out)
}
fn validate_header_name(name: &str) -> Result<(), ConnectError> {
if name.is_empty() || name.len() > 256 {
return Err(ConnectError::InvalidHeader);
}
for byte in name.bytes() {
if !is_token_byte(byte) {
return Err(ConnectError::InvalidHeader);
}
}
Ok(())
}
fn validate_header_value_bytes(value: &[u8]) -> Result<(), ConnectError> {
for byte in value {
if matches!(byte, 0x00..=0x08 | 0x0A..=0x1F | 0x7F) {
return Err(ConnectError::InvalidHeader);
}
}
Ok(())
}
fn is_token_byte(byte: u8) -> bool {
matches!(
byte,
b'!' | b'#'
| b'$'
| b'%'
| b'&'
| b'\''
| b'*'
| b'+'
| b'-'
| b'.'
| b'^'
| b'_'
| b'`'
| b'|'
| b'~'
| b'0'..=b'9'
| b'A'..=b'Z'
| b'a'..=b'z'
)
}