use crate::error::{Error, Result};
#[derive(Clone)]
pub enum AuthScheme {
#[cfg(feature = "basic-auth")]
Basic(BasicAuth),
Bearer(BearerAuth),
}
impl AuthScheme {
#[cfg(feature = "basic-auth")]
pub fn basic(username: impl Into<String>, password: impl Into<String>) -> Result<Self> {
Ok(Self::Basic(BasicAuth::new(username, password)?))
}
pub fn bearer(token: impl Into<String>) -> Result<Self> {
Ok(Self::Bearer(BearerAuth::new(token)?))
}
pub(crate) fn apply(&self, headers: &mut crate::headers::Headers) -> Result<()> {
match self {
#[cfg(feature = "basic-auth")]
Self::Basic(b) => {
let value = b.header_value();
headers.insert("authorization", &value)?;
}
Self::Bearer(b) => {
let value = b.header_value();
headers.insert("authorization", &value)?;
}
}
Ok(())
}
}
impl std::fmt::Debug for AuthScheme {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
#[cfg(feature = "basic-auth")]
Self::Basic(b) => f.debug_tuple("Basic").field(b).finish(),
Self::Bearer(b) => f.debug_tuple("Bearer").field(b).finish(),
}
}
}
#[cfg(feature = "basic-auth")]
#[derive(Clone)]
pub struct BasicAuth {
username: String,
password: String,
}
#[cfg(feature = "basic-auth")]
impl BasicAuth {
pub fn new(username: impl Into<String>, password: impl Into<String>) -> Result<Self> {
let username = username.into();
let password = password.into();
if username.contains(':') {
return Err(Error::InvalidAuthHeader(
"basic auth username must not contain ':'".into(),
));
}
validate_auth_bytes(username.as_bytes(), "username")?;
validate_auth_bytes(password.as_bytes(), "password")?;
Ok(Self { username, password })
}
fn encoded_credentials(&self) -> String {
use base64::Engine;
let credential = format!("{}:{}", self.username, self.password);
base64::engine::general_purpose::STANDARD.encode(credential.as_bytes())
}
fn header_value(&self) -> String {
format!("Basic {}", self.encoded_credentials())
}
#[must_use]
pub fn username(&self) -> &str {
&self.username
}
}
#[cfg(feature = "basic-auth")]
impl std::fmt::Debug for BasicAuth {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BasicAuth")
.field("username", &"<redacted>")
.field("password", &"<redacted>")
.finish()
}
}
#[cfg(feature = "basic-auth")]
impl std::fmt::Display for BasicAuth {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("BasicAuth(<redacted>)")
}
}
#[derive(Clone)]
pub struct BearerAuth {
token: String,
}
impl BearerAuth {
pub fn new(token: impl Into<String>) -> Result<Self> {
let token = token.into();
validate_auth_bytes(token.as_bytes(), "token")?;
let header = format!("Bearer {token}");
http::HeaderValue::from_str(&header).map_err(|_| {
Error::InvalidAuthHeader(
"auth token must contain only characters valid in an HTTP header".into(),
)
})?;
Ok(Self { token })
}
fn header_value(&self) -> String {
format!("Bearer {}", self.token)
}
}
impl std::fmt::Debug for BearerAuth {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BearerAuth")
.field("token", &"<redacted>")
.finish()
}
}
impl std::fmt::Display for BearerAuth {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "BearerAuth(<redacted>)")
}
}
fn validate_auth_bytes(bytes: &[u8], field_name: &str) -> Result<()> {
if bytes.contains(&b'\r') {
return Err(Error::InvalidAuthHeader(format!(
"auth {field_name} must not contain CR"
)));
}
if bytes.contains(&b'\n') {
return Err(Error::InvalidAuthHeader(format!(
"auth {field_name} must not contain LF"
)));
}
Ok(())
}
pub(crate) fn resolve_request_auth(
request_auth: Option<&AuthScheme>,
request_auth_disabled: bool,
client_auth: Option<&AuthScheme>,
request_headers: &crate::headers::Headers,
) -> Result<Option<AuthScheme>> {
if request_headers.contains("authorization") {
if request_auth.is_some() || client_auth.is_some() {
return Err(Error::ConflictingAuth(
"explicit Authorization header conflicts with configured auth; \
use .auth() or remove the header, but not both"
.into(),
));
}
return Ok(None);
}
if let Some(auth) = request_auth {
return Ok(Some(auth.clone()));
}
if request_auth_disabled {
return Ok(None);
}
if let Some(auth) = client_auth {
return Ok(Some(auth.clone()));
} Ok(None)
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(feature = "basic-auth")]
use base64::Engine;
#[cfg(feature = "basic-auth")]
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_header_value() {
let auth = BasicAuth::new("user", "pass").unwrap();
assert_eq!(auth.header_value(), "Basic dXNlcjpwYXNz");
}
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_empty_password() {
let auth = BasicAuth::new("user", "").unwrap();
assert_eq!(auth.header_value(), "Basic dXNlcjo=");
}
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_utf8_credentials() {
use base64::Engine;
let auth = BasicAuth::new("usér", "päss").unwrap();
assert!(auth.header_value().starts_with("Basic "));
let header_val = auth.header_value();
let encoded = header_val.strip_prefix("Basic ").unwrap();
let decoded = base64::engine::general_purpose::STANDARD
.decode(encoded)
.unwrap();
assert_eq!(String::from_utf8(decoded).unwrap(), "usér:päss");
}
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_rejects_colon_in_username() {
let err = BasicAuth::new("user:name", "pass").unwrap_err();
assert_eq!(err.kind(), "invalid_auth_header");
assert!(!err.to_string().contains("pass"));
}
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_rejects_cr_in_username() {
let err = BasicAuth::new("user\r", "pass").unwrap_err();
assert_eq!(err.kind(), "invalid_auth_header");
}
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_rejects_lf_in_password() {
let err = BasicAuth::new("user", "pass\n").unwrap_err();
assert_eq!(err.kind(), "invalid_auth_header");
}
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_redacted_debug() {
let auth = BasicAuth::new("user", "secret123").unwrap();
let debug = format!("{auth:?}");
assert!(!debug.contains("\"user\""));
assert!(debug.contains("<redacted>"));
assert!(!debug.contains("secret123"));
}
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_redacted_display() {
let auth = BasicAuth::new("user", "secret123").unwrap();
let display = format!("{auth}");
assert!(!display.contains("user"));
assert!(!display.contains("secret123"));
assert!(display.contains("<redacted>"));
}
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_username_accessor() {
let auth = BasicAuth::new("admin", "pw").unwrap();
assert_eq!(auth.username(), "admin");
}
#[test]
fn bearer_auth_header_value() {
let auth = BearerAuth::new("my-token").unwrap();
assert_eq!(auth.header_value(), "Bearer my-token");
}
#[test]
fn bearer_auth_rejects_cr() {
let err = BearerAuth::new("tok\r").unwrap_err();
assert_eq!(err.kind(), "invalid_auth_header");
}
#[test]
fn bearer_auth_rejects_lf() {
let err = BearerAuth::new("tok\n").unwrap_err();
assert_eq!(err.kind(), "invalid_auth_header");
}
#[test]
fn bearer_auth_redacted_debug() {
let auth = BearerAuth::new("secret-token").unwrap();
let debug = format!("{auth:?}");
assert!(debug.contains("<redacted>"));
assert!(!debug.contains("secret-token"));
}
#[test]
fn bearer_auth_redacted_display() {
let auth = BearerAuth::new("secret-token").unwrap();
let display = format!("{auth}");
assert!(display.contains("<redacted>"));
assert!(!display.contains("secret-token"));
}
#[test]
fn auth_scheme_debug() {
#[cfg(feature = "basic-auth")]
{
let scheme = AuthScheme::basic("user", "pass").unwrap();
let debug = format!("{scheme:?}");
assert!(debug.contains("Basic"));
}
let scheme = AuthScheme::bearer("token").unwrap();
let debug = format!("{scheme:?}");
assert!(debug.contains("Bearer"));
}
#[test]
fn resolve_no_auth() {
let headers = crate::headers::Headers::new();
let result = resolve_request_auth(None, false, None, &headers).unwrap();
assert!(result.is_none());
}
#[test]
fn resolve_client_auth() {
let headers = crate::headers::Headers::new();
let client_auth = Some(AuthScheme::bearer("tok").unwrap());
let result = resolve_request_auth(None, false, client_auth.as_ref(), &headers).unwrap();
assert!(result.is_some());
}
#[test]
fn resolve_request_auth_overrides_client() {
let headers = crate::headers::Headers::new();
let request_auth = Some(AuthScheme::bearer("req-tok").unwrap());
let client_auth = Some(AuthScheme::bearer("client-tok").unwrap());
let result =
resolve_request_auth(request_auth.as_ref(), false, client_auth.as_ref(), &headers)
.unwrap();
let auth = result.unwrap();
match auth {
AuthScheme::Bearer(b) => {
assert_eq!(b.header_value(), "Bearer req-tok");
}
#[cfg(feature = "basic-auth")]
AuthScheme::Basic(_) => panic!("expected Bearer"),
}
}
#[test]
fn resolve_auth_disabled() {
let headers = crate::headers::Headers::new();
let client_auth = Some(AuthScheme::bearer("tok").unwrap());
let result = resolve_request_auth(None, true, client_auth.as_ref(), &headers).unwrap();
assert!(result.is_none());
}
#[test]
fn resolve_explicit_header_conflicts_with_auth() {
let mut headers = crate::headers::Headers::new();
headers.insert("authorization", "Bearer manual").unwrap();
let client_auth = Some(AuthScheme::bearer("tok").unwrap());
let err = resolve_request_auth(None, false, client_auth.as_ref(), &headers).unwrap_err();
assert_eq!(err.kind(), "conflicting_auth");
}
#[test]
fn resolve_explicit_header_no_auth_config() {
let mut headers = crate::headers::Headers::new();
headers.insert("authorization", "Bearer manual").unwrap();
let result = resolve_request_auth(None, false, None, &headers).unwrap();
assert!(result.is_none());
}
#[test]
fn resolve_request_auth_disabled_overrides_client() {
let headers = crate::headers::Headers::new();
let client_auth = Some(AuthScheme::bearer("tok").unwrap());
let result = resolve_request_auth(None, true, client_auth.as_ref(), &headers).unwrap();
assert!(result.is_none());
}
#[test]
fn resolve_no_auth_is_same_as_absent() {
let headers = crate::headers::Headers::new();
let r1 = resolve_request_auth(None, false, None, &headers).unwrap();
let r2 = resolve_request_auth(None, false, None, &headers).unwrap();
assert_eq!(r1.is_none(), r2.is_none());
}
#[cfg(feature = "basic-auth")]
#[test]
fn auth_scheme_debug_does_not_leak_basic_password() {
let scheme = AuthScheme::basic("admin", "hunter2").unwrap();
let debug = format!("{scheme:?}");
assert!(!debug.contains("admin"));
assert!(!debug.contains("hunter2"));
assert!(debug.contains("<redacted>"));
}
#[test]
fn auth_scheme_debug_does_not_leak_bearer_token() {
let scheme = AuthScheme::bearer("secret-value").unwrap();
let debug = format!("{scheme:?}");
assert!(!debug.contains("secret-value"));
assert!(debug.contains("<redacted>"));
}
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_empty_username_and_password() {
let auth = BasicAuth::new("", "").unwrap();
let expected = base64::engine::general_purpose::STANDARD.encode(b":");
assert_eq!(auth.header_value(), format!("Basic {expected}"));
}
#[test]
fn bearer_auth_empty_token() {
let auth = BearerAuth::new("").unwrap();
assert_eq!(auth.header_value(), "Bearer ");
}
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_colon_in_password_is_allowed() {
let auth = BasicAuth::new("user", "p:a:s:s").unwrap();
let expected = base64::engine::general_purpose::STANDARD.encode(b"user:p:a:s:s");
assert_eq!(auth.header_value(), format!("Basic {expected}"));
}
#[test]
fn bearer_auth_with_spaces_in_token() {
let auth = BearerAuth::new("token with spaces").unwrap();
assert_eq!(auth.header_value(), "Bearer token with spaces");
}
#[test]
fn bearer_auth_with_unicode_token() {
let auth = BearerAuth::new("tökën-üñîçödé").unwrap();
assert!(auth.header_value().starts_with("Bearer "));
assert!(auth.header_value().contains("tökën-üñîçödé"));
}
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_header_format() {
let auth = BasicAuth::new("user", "pass").unwrap();
let val = auth.header_value();
assert!(val.starts_with("Basic "), "must start with 'Basic '");
let encoded = val.strip_prefix("Basic ").unwrap();
let decoded = base64::engine::general_purpose::STANDARD
.decode(encoded)
.unwrap();
assert_eq!(String::from_utf8(decoded).unwrap(), "user:pass");
}
#[test]
fn bearer_auth_header_format() {
let auth = BearerAuth::new("my-token-123").unwrap();
let val = auth.header_value();
assert_eq!(val, "Bearer my-token-123");
}
#[test]
fn double_resolution_is_idempotent() {
let headers = crate::headers::Headers::new();
let client_auth = Some(AuthScheme::bearer("client-tok").unwrap());
let request_auth = Some(AuthScheme::bearer("req-tok").unwrap());
let first =
resolve_request_auth(request_auth.as_ref(), false, client_auth.as_ref(), &headers)
.unwrap();
assert!(first.is_some());
let second = resolve_request_auth(first.as_ref(), false, None, &headers).unwrap();
match second.unwrap() {
AuthScheme::Bearer(b) => assert_eq!(b.header_value(), "Bearer req-tok"),
#[cfg(feature = "basic-auth")]
AuthScheme::Basic(_) => panic!("expected Bearer"),
}
}
#[test]
#[cfg(feature = "high-level-url")]
fn request_builder_without_auth_sets_disabled_and_clears_auth() {
let client = crate::client::Client::builder().build();
let req = client
.request(http::Method::GET, "http://example.com")
.unwrap()
.auth(AuthScheme::bearer("tok").unwrap())
.without_auth()
.build()
.unwrap();
assert!(req.is_auth_disabled());
assert!(req.auth().is_none());
}
#[test]
#[cfg(feature = "high-level-url")]
fn request_builder_auth_clears_disabled() {
let client = crate::client::Client::builder().build();
let req = client
.request(http::Method::GET, "http://example.com")
.unwrap()
.without_auth()
.auth(AuthScheme::bearer("tok").unwrap())
.build()
.unwrap();
assert!(!req.is_auth_disabled());
assert!(req.auth().is_some());
}
#[cfg(feature = "basic-auth")]
#[test]
fn basic_auth_display_shows_username_not_password() {
let auth = BasicAuth::new("admin", "s3cret").unwrap();
let display = format!("{auth}");
assert!(!display.contains("admin"));
assert!(!display.contains("s3cret"));
assert!(display.contains("<redacted>"));
}
#[test]
fn bearer_auth_display_redacts_token() {
let auth = BearerAuth::new("my-secret-token").unwrap();
let display = format!("{auth}");
assert!(!display.contains("my-secret-token"));
assert!(display.contains("<redacted>"));
}
#[cfg(feature = "basic-auth")]
#[test]
fn resolve_request_overrides_client_different_types() {
let headers = crate::headers::Headers::new();
let client_auth = Some(AuthScheme::basic("c", "cp").unwrap());
let request_auth = Some(AuthScheme::bearer("req-tok").unwrap());
let result =
resolve_request_auth(request_auth.as_ref(), false, client_auth.as_ref(), &headers)
.unwrap();
match result.unwrap() {
AuthScheme::Bearer(b) => assert_eq!(b.header_value(), "Bearer req-tok"),
AuthScheme::Basic(_) => panic!("expected Bearer"),
}
}
}