use url::Url;
pub const INVALID_PLACEHOLDER: &str = "[INVALID-PROXY-URL]";
#[derive(Debug, thiserror::Error)]
pub enum ProxyUrlError {
#[error("invalid URL format: {0}")]
InvalidFormat(String),
#[error("missing host in proxy URL")]
MissingHost,
#[error("unsupported scheme '{0}': allowed {1:?}")]
UnsupportedScheme(String, &'static [&'static str]),
#[error("URL contains whitespace")]
ContainsWhitespace,
}
pub fn validate_proxy_url(
proxy_url: &str,
allowed_schemes: &'static [&'static str],
) -> Result<String, ProxyUrlError> {
validate_proxy_scheme(proxy_url, allowed_schemes)?;
if proxy_url.chars().any(|c| c.is_whitespace()) {
return Err(ProxyUrlError::ContainsWhitespace);
}
let parsed = Url::parse(proxy_url).map_err(|e| ProxyUrlError::InvalidFormat(e.to_string()))?;
if parsed.host_str().is_none() || parsed.host_str().map(|h| h.is_empty()).unwrap_or(true) {
return Err(ProxyUrlError::MissingHost);
}
Ok(proxy_url.to_string())
}
fn validate_proxy_scheme(
proxy_url: &str,
allowed_schemes: &'static [&'static str],
) -> Result<(), ProxyUrlError> {
let scheme_end = proxy_url
.find("://")
.ok_or_else(|| ProxyUrlError::InvalidFormat("missing '://' separator".to_string()))?;
let scheme = &proxy_url[..scheme_end];
if scheme.is_empty() {
return Err(ProxyUrlError::InvalidFormat("empty scheme".to_string()));
}
if !scheme
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '+' || c == '-' || c == '.')
{
return Err(ProxyUrlError::InvalidFormat(format!(
"invalid scheme characters: {scheme}"
)));
}
if !allowed_schemes.contains(&scheme) {
return Err(ProxyUrlError::UnsupportedScheme(
scheme.to_string(),
allowed_schemes,
));
}
Ok(())
}
#[must_use]
pub fn redact_proxy_url(proxy_url: &str) -> String {
let parsed = match Url::parse(proxy_url) {
Ok(u) => u,
Err(_) => return INVALID_PLACEHOLDER.to_string(),
};
let username = parsed.username();
let password = parsed.password();
if username.is_empty() && password.is_none() {
return proxy_url.to_string();
}
let mut redacted = String::new();
redacted.push_str(parsed.scheme());
redacted.push_str("://***@");
if let Some(host_str) = parsed.host_str() {
redacted.push_str(host_str);
}
if let Some(port) = parsed.port() {
redacted.push_str(&format!(":{}", port));
}
let path = parsed.path();
if !path.is_empty() && path != "/" {
redacted.push_str(path);
}
if let Some(query) = parsed.query() {
redacted.push_str(&format!("?{}", query));
}
if let Some(fragment) = parsed.fragment() {
redacted.push_str(&format!("#{}", fragment));
}
redacted
}
#[cfg(test)]
mod tests {
use super::*;
const CHROME_ALLOWED: &[&str] = &["http", "https", "socks5", "socks4"];
#[test]
fn validate_proxy_url_http_passes() {
assert!(validate_proxy_url("http://proxy.example.com:8080", CHROME_ALLOWED).is_ok());
}
#[test]
fn validate_proxy_url_https_passes() {
assert!(validate_proxy_url("https://proxy.example.com:443", CHROME_ALLOWED).is_ok());
}
#[test]
fn validate_proxy_url_socks5_passes() {
assert!(validate_proxy_url("socks5://proxy.example.com:1080", CHROME_ALLOWED).is_ok());
}
#[test]
fn validate_proxy_url_socks4_passes() {
assert!(validate_proxy_url("socks4://proxy.example.com:1080", CHROME_ALLOWED).is_ok());
}
#[test]
fn validate_proxy_url_with_credentials_passes() {
assert!(
validate_proxy_url("http://user:secret@proxy.example.com:8080", CHROME_ALLOWED).is_ok()
);
}
#[test]
fn validate_proxy_url_with_ipv6_passes() {
assert!(
validate_proxy_url("http://[::1]:8080", CHROME_ALLOWED).is_ok(),
"IPv6 host should pass"
);
}
#[test]
fn validate_proxy_url_with_path_and_query_passes() {
assert!(
validate_proxy_url("http://proxy.example.com:8080/path?q=1", CHROME_ALLOWED).is_ok()
);
}
#[test]
fn validate_proxy_url_rejects_file_scheme() {
match validate_proxy_url("file:///etc/passwd", CHROME_ALLOWED) {
Err(ProxyUrlError::UnsupportedScheme(s, allowed)) => {
assert_eq!(s, "file");
assert_eq!(allowed, CHROME_ALLOWED);
}
other => panic!("expected UnsupportedScheme, got {other:?}"),
}
}
#[test]
fn validate_proxy_url_rejects_ftp_scheme() {
match validate_proxy_url("ftp://proxy.example.com:21", CHROME_ALLOWED) {
Err(ProxyUrlError::UnsupportedScheme(s, _)) => assert_eq!(s, "ftp"),
other => panic!("expected UnsupportedScheme, got {other:?}"),
}
}
#[test]
fn validate_proxy_url_rejects_gopher_scheme() {
match validate_proxy_url("gopher://proxy.example.com:70", CHROME_ALLOWED) {
Err(ProxyUrlError::UnsupportedScheme(s, _)) => assert_eq!(s, "gopher"),
other => panic!("expected UnsupportedScheme, got {other:?}"),
}
}
#[test]
fn validate_proxy_url_rejects_whitespace_in_url() {
match validate_proxy_url("http://evil.com --enable-bad-flag", CHROME_ALLOWED) {
Err(ProxyUrlError::ContainsWhitespace) => {}
other => panic!("expected ContainsWhitespace, got {other:?}"),
}
}
#[test]
fn validate_proxy_url_rejects_tab_in_url() {
match validate_proxy_url("http://evil.com\t--bad", CHROME_ALLOWED) {
Err(ProxyUrlError::ContainsWhitespace) => {}
other => panic!("expected ContainsWhitespace, got {other:?}"),
}
}
#[test]
fn validate_proxy_url_rejects_newline_in_url() {
match validate_proxy_url("http://evil.com\n--bad", CHROME_ALLOWED) {
Err(ProxyUrlError::ContainsWhitespace) => {}
other => panic!("expected ContainsWhitespace, got {other:?}"),
}
}
#[test]
fn validate_proxy_url_rejects_missing_scheme_separator() {
match validate_proxy_url("proxy.example.com:8080", CHROME_ALLOWED) {
Err(ProxyUrlError::InvalidFormat(_)) => {}
other => panic!("expected InvalidFormat, got {other:?}"),
}
}
#[test]
fn validate_proxy_url_rejects_empty_scheme() {
match validate_proxy_url("://example.com", CHROME_ALLOWED) {
Err(ProxyUrlError::InvalidFormat(_)) => {}
other => panic!("expected InvalidFormat, got {other:?}"),
}
}
#[test]
fn validate_proxy_url_rejects_empty_input() {
assert!(validate_proxy_url("", CHROME_ALLOWED).is_err());
}
#[test]
fn validate_proxy_url_rejects_missing_host() {
let result = validate_proxy_url("http://", CHROME_ALLOWED);
assert!(
matches!(
result,
Err(ProxyUrlError::InvalidFormat(_)) | Err(ProxyUrlError::MissingHost)
),
"expected InvalidFormat or MissingHost, got {result:?}"
);
}
#[test]
fn validate_proxy_url_rejects_invalid_scheme_chars() {
match validate_proxy_url("ht tp://example.com", CHROME_ALLOWED) {
Err(ProxyUrlError::InvalidFormat(_)) => {}
other => panic!("expected InvalidFormat, got {other:?}"),
}
}
#[test]
fn validate_proxy_url_rejects_invalid_url_format() {
match validate_proxy_url("http://[invalid-ipv6", CHROME_ALLOWED) {
Err(ProxyUrlError::InvalidFormat(_)) => {}
other => panic!("expected InvalidFormat, got {other:?}"),
}
}
#[test]
fn validate_proxy_url_preserves_input_string_in_ok() {
let input = "socks5://user:pass@proxy.example.com:1080";
let result = validate_proxy_url(input, CHROME_ALLOWED).unwrap();
assert_eq!(result, input);
}
#[test]
fn validate_proxy_url_custom_scheme_whitelist() {
const FLARESOLVERR_ALLOWED: &[&str] = &["http", "https"];
assert!(validate_proxy_url("http://x.com", FLARESOLVERR_ALLOWED).is_ok());
assert!(validate_proxy_url("https://x.com", FLARESOLVERR_ALLOWED).is_ok());
assert!(validate_proxy_url("socks5://x.com", FLARESOLVERR_ALLOWED).is_err());
}
#[test]
fn redact_proxy_url_no_credentials() {
assert_eq!(
redact_proxy_url("http://proxy.example.com:8080"),
"http://proxy.example.com:8080"
);
}
#[test]
fn redact_proxy_url_with_user_only() {
assert_eq!(
redact_proxy_url("http://user@proxy.example.com:8080"),
"http://***@proxy.example.com:8080"
);
}
#[test]
fn redact_proxy_url_with_user_and_password() {
assert_eq!(
redact_proxy_url("http://user:secret@proxy.example.com:8080"),
"http://***@proxy.example.com:8080"
);
}
#[test]
fn redact_proxy_url_invalid_url_returns_placeholder() {
assert_eq!(redact_proxy_url("not a url at all"), INVALID_PLACEHOLDER);
}
#[test]
fn redact_proxy_url_preserves_path_and_query() {
assert_eq!(
redact_proxy_url("http://user:pass@proxy.example.com:8080/path?q=1"),
"http://***@proxy.example.com:8080/path?q=1"
);
}
#[test]
fn redact_proxy_url_https() {
assert_eq!(
redact_proxy_url("https://user:pass@proxy.example.com:443"),
"https://***@proxy.example.com"
);
}
#[test]
fn redact_proxy_url_ipv6() {
assert_eq!(
redact_proxy_url("http://user:pass@[::1]:8080"),
"http://***@[::1]:8080"
);
}
#[test]
fn redact_proxy_url_url_encoded_credentials() {
assert_eq!(
redact_proxy_url("http://us%40er:p%40ss@proxy.example.com:8080"),
"http://***@proxy.example.com:8080"
);
}
#[test]
fn redact_proxy_url_preserves_fragment() {
assert_eq!(
redact_proxy_url("http://user:pass@proxy.example.com:8080/#section"),
"http://***@proxy.example.com:8080#section"
);
}
#[test]
fn redact_proxy_url_empty_string() {
assert_eq!(redact_proxy_url(""), INVALID_PLACEHOLDER);
}
#[test]
fn redact_proxy_url_only_userinfo_no_host() {
assert_eq!(redact_proxy_url("http://user:pass@"), INVALID_PLACEHOLDER);
}
#[test]
fn redact_proxy_url_socks5_scheme() {
assert_eq!(
redact_proxy_url("socks5://user:pass@proxy.example.com:1080"),
"socks5://***@proxy.example.com:1080"
);
}
}