use std::fmt;
use base64::{Engine as _, engine::general_purpose::STANDARD};
use http::HeaderValue;
#[derive(Clone)]
pub struct AuthProvider(AuthKind);
#[derive(Clone)]
enum AuthKind {
Basic { username: String, password: String },
Bearer { token: String },
}
impl AuthProvider {
#[must_use]
pub fn basic(username: impl Into<String>, password: impl Into<String>) -> Self {
Self(AuthKind::Basic {
username: username.into(),
password: password.into(),
})
}
#[must_use]
pub fn bearer(token: impl Into<String>) -> Self {
Self(AuthKind::Bearer {
token: token.into(),
})
}
pub(crate) fn authorization(&self) -> Option<HeaderValue> {
match &self.0 {
AuthKind::Basic { username, password } => basic(username, password),
AuthKind::Bearer { token } => bearer(token),
}
}
}
impl fmt::Debug for AuthProvider {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.0 {
AuthKind::Basic { .. } => formatter.write_str("AuthProvider::Basic(..)"),
AuthKind::Bearer { .. } => formatter.write_str("AuthProvider::Bearer(..)"),
}
}
}
fn basic(username: &str, password: &str) -> Option<HeaderValue> {
if username.contains(':') || contains_control(username) || contains_control(password) {
return None;
}
let mut credentials = String::with_capacity(username.len() + password.len() + 1);
credentials.push_str(username);
credentials.push(':');
credentials.push_str(password);
authorization("Basic", &STANDARD.encode(credentials))
}
fn bearer(token: &str) -> Option<HeaderValue> {
if !valid_bearer_token(token) {
return None;
}
authorization("Bearer", token)
}
fn authorization(scheme: &str, credentials: &str) -> Option<HeaderValue> {
let mut header = String::with_capacity(scheme.len() + credentials.len() + 1);
header.push_str(scheme);
header.push(' ');
header.push_str(credentials);
let mut value = HeaderValue::from_bytes(header.as_bytes()).ok()?;
value.set_sensitive(true);
Some(value)
}
fn contains_control(value: &str) -> bool {
value.bytes().any(|byte| byte.is_ascii_control())
}
fn valid_bearer_token(token: &str) -> bool {
let mut has_credentials = false;
let mut padding_started = false;
for byte in token.bytes() {
if byte == b'=' {
if !has_credentials {
return false;
}
padding_started = true;
} else if padding_started
|| !matches!(
byte,
b'A'..=b'Z'
| b'a'..=b'z'
| b'0'..=b'9'
| b'-'
| b'.'
| b'_'
| b'~'
| b'+'
| b'/'
)
{
return false;
} else {
has_credentials = true;
}
}
has_credentials
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bearer_tokens_follow_rfc_6750_syntax() {
for token in ["token", "header.payload.signature", "abc-._~+/=="] {
assert!(valid_bearer_token(token));
}
for token in ["", "token with space", "token=middle", "=padding", "tøken"] {
assert!(!valid_bearer_token(token));
}
}
#[test]
fn generated_values_are_sensitive() {
assert!(basic("user", "password").unwrap().is_sensitive());
assert!(bearer("token").unwrap().is_sensitive());
}
#[test]
fn providers_redact_their_credentials() {
let basic = AuthProvider::basic("user", "secret");
let bearer = AuthProvider::bearer("token");
assert!(!format!("{basic:?}").contains("secret"));
assert!(!format!("{bearer:?}").contains("token"));
}
}