use std::fmt;
use base64::{Engine, engine::general_purpose::STANDARD};
use http::{HeaderMap, HeaderName, HeaderValue, header::AUTHORIZATION};
use url::Url;
use crate::{Error, Result};
#[derive(Clone, Eq, PartialEq)]
pub enum Auth {
Basic(BasicAuth),
Bearer(BearerToken),
ApiKey(ApiKey),
}
#[derive(Clone, Eq, PartialEq)]
pub struct BasicAuth {
username: String,
password: Option<String>,
}
#[derive(Clone, Eq, PartialEq)]
pub struct BearerToken {
token: String,
}
#[derive(Clone, Eq, PartialEq)]
pub struct ApiKey {
location: ApiKeyLocation,
}
#[derive(Clone, Eq, PartialEq)]
enum ApiKeyLocation {
Header {
name: HeaderName,
value: HeaderValue,
},
Query {
name: String,
value: String,
},
}
impl Auth {
pub(crate) fn validate(&self) -> Result<()> {
match self {
Self::Basic(auth) => auth.header_value().map(drop),
Self::Bearer(auth) => auth.header_value().map(drop),
Self::ApiKey(_) => Ok(()),
}
}
pub(crate) fn apply(&self, headers: &mut HeaderMap, url: Option<&mut Url>) -> Result<()> {
match self {
Self::Basic(auth) => {
headers.insert(AUTHORIZATION, auth.header_value()?);
Ok(())
}
Self::Bearer(auth) => {
headers.insert(AUTHORIZATION, auth.header_value()?);
Ok(())
}
Self::ApiKey(auth) => auth.apply(headers, url),
}
}
pub(crate) fn apply_default(
&self,
headers: &mut HeaderMap,
url: Option<&mut Url>,
) -> Result<()> {
match self {
Self::Basic(auth) => {
if !headers.contains_key(AUTHORIZATION) {
headers.insert(AUTHORIZATION, auth.header_value()?);
}
Ok(())
}
Self::Bearer(auth) => {
if !headers.contains_key(AUTHORIZATION) {
headers.insert(AUTHORIZATION, auth.header_value()?);
}
Ok(())
}
Self::ApiKey(auth) => auth.apply_default(headers, url),
}
}
}
impl BasicAuth {
#[must_use]
pub fn new<P>(username: impl Into<String>, password: Option<P>) -> Self
where
P: Into<String>,
{
Self {
username: username.into(),
password: password.map(Into::into),
}
}
#[must_use]
pub fn without_password(username: impl Into<String>) -> Self {
Self::new(username, None::<String>)
}
fn header_value(&self) -> Result<HeaderValue> {
if self.username.contains(':') {
return Err(Error::invalid_request(
"Basic authentication username cannot contain a colon",
));
}
let credentials = match &self.password {
Some(password) => format!("{}:{password}", self.username),
None => format!("{}:", self.username),
};
let mut value = HeaderValue::from_str(&format!("Basic {}", STANDARD.encode(credentials)))?;
value.set_sensitive(true);
Ok(value)
}
}
impl BearerToken {
#[must_use]
pub fn new(token: impl Into<String>) -> Self {
Self {
token: token.into(),
}
}
fn header_value(&self) -> Result<HeaderValue> {
let token = self.token.as_bytes();
let payload_length = token
.iter()
.position(|byte| *byte == b'=')
.unwrap_or(token.len());
let valid_payload = payload_length > 0
&& token[..payload_length].iter().all(|byte| {
byte.is_ascii_alphanumeric()
|| matches!(byte, b'-' | b'.' | b'_' | b'~' | b'+' | b'/')
});
let valid_padding = token[payload_length..].iter().all(|byte| *byte == b'=');
if !valid_payload || !valid_padding {
return Err(Error::invalid_request("Bearer token syntax is invalid"));
}
let mut value = HeaderValue::from_str(&format!("Bearer {}", self.token))?;
value.set_sensitive(true);
Ok(value)
}
}
impl ApiKey {
pub fn header(name: impl AsRef<str>, value: impl AsRef<str>) -> Result<Self> {
let name = HeaderName::from_bytes(name.as_ref().as_bytes())?;
let mut value = HeaderValue::from_str(value.as_ref())?;
value.set_sensitive(true);
Ok(Self {
location: ApiKeyLocation::Header { name, value },
})
}
pub fn query(name: impl Into<String>, value: impl Into<String>) -> Result<Self> {
let name = name.into();
if name.is_empty() {
return Err(Error::invalid_request(
"API key query parameter name is required",
));
}
Ok(Self {
location: ApiKeyLocation::Query {
name,
value: value.into(),
},
})
}
fn apply(&self, headers: &mut HeaderMap, url: Option<&mut Url>) -> Result<()> {
match &self.location {
ApiKeyLocation::Header { name, value } => {
headers.insert(name.clone(), value.clone());
Ok(())
}
ApiKeyLocation::Query { name, value } => {
let url = url.ok_or(Error::invalid_request(
"request URL is required for query API key authentication",
))?;
url.query_pairs_mut().append_pair(name, value);
Ok(())
}
}
}
fn apply_default(&self, headers: &mut HeaderMap, url: Option<&mut Url>) -> Result<()> {
match &self.location {
ApiKeyLocation::Header { name, value } => {
if !headers.contains_key(name) {
headers.insert(name.clone(), value.clone());
}
Ok(())
}
ApiKeyLocation::Query { name, value } => {
let url = url.ok_or(Error::invalid_request(
"request URL is required for query API key authentication",
))?;
if !url.query_pairs().any(|(key, _)| key == *name) {
url.query_pairs_mut().append_pair(name, value);
}
Ok(())
}
}
}
}
impl From<BasicAuth> for Auth {
fn from(auth: BasicAuth) -> Self {
Self::Basic(auth)
}
}
impl From<BearerToken> for Auth {
fn from(auth: BearerToken) -> Self {
Self::Bearer(auth)
}
}
impl From<ApiKey> for Auth {
fn from(auth: ApiKey) -> Self {
Self::ApiKey(auth)
}
}
impl fmt::Debug for Auth {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Basic(auth) => fmt::Debug::fmt(auth, formatter),
Self::Bearer(auth) => fmt::Debug::fmt(auth, formatter),
Self::ApiKey(auth) => fmt::Debug::fmt(auth, formatter),
}
}
}
impl fmt::Debug for BasicAuth {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("BasicAuth")
.field("username", &"[redacted]")
.field("password", &self.password.as_ref().map(|_| "[redacted]"))
.finish()
}
}
impl fmt::Debug for BearerToken {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("BearerToken")
.field("token", &"[redacted]")
.finish()
}
}
impl fmt::Debug for ApiKey {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.location {
ApiKeyLocation::Header { name, value: _ } => formatter
.debug_struct("ApiKey")
.field("location", &"header")
.field("name", name)
.field("value", &"[redacted]")
.finish(),
ApiKeyLocation::Query { name, value: _ } => formatter
.debug_struct("ApiKey")
.field("location", &"query")
.field("name", name)
.field("value", &"[redacted]")
.finish(),
}
}
}
#[cfg(test)]
mod describe_auth {
use http::{HeaderMap, header::AUTHORIZATION};
use url::Url;
use super::*;
mod describe_basic_auth {
use super::*;
#[test]
fn it_encodes_username_and_password() {
let mut headers = HeaderMap::new();
let auth = BasicAuth::new("user", Some("pass"));
Auth::from(auth).apply(&mut headers, None).unwrap();
let value = headers.get(AUTHORIZATION).unwrap();
assert_eq!(value, "Basic dXNlcjpwYXNz");
assert!(value.is_sensitive());
}
#[test]
fn it_encodes_username_without_password() {
let mut headers = HeaderMap::new();
Auth::from(BasicAuth::without_password("user"))
.apply(&mut headers, None)
.unwrap();
assert_eq!(headers.get(AUTHORIZATION).unwrap(), "Basic dXNlcjo=");
}
#[test]
fn it_redacts_password_in_debug_output() {
let auth = BasicAuth::new("account-name-secret", Some("password-secret"));
let debug = format!("{auth:?}");
assert!(debug.contains("[redacted]"));
assert!(!debug.contains("account-name-secret"));
assert!(!debug.contains("password-secret"));
}
#[test]
fn it_rejects_ambiguous_colons_in_usernames() {
let error = Auth::from(BasicAuth::new("user:name", Some("password")))
.validate()
.unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
}
}
mod describe_bearer_token {
use super::*;
#[test]
fn it_sets_a_sensitive_authorization_header() {
let mut headers = HeaderMap::new();
Auth::from(BearerToken::new("token"))
.apply(&mut headers, None)
.unwrap();
let value = headers.get(AUTHORIZATION).unwrap();
assert_eq!(value, "Bearer token");
assert!(value.is_sensitive());
}
#[test]
fn it_validates_header_value_syntax() {
for token in ["", "bad\nvalue", "bad value", "bad=middle=value"] {
let error = Auth::from(BearerToken::new(token)).validate().unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
}
assert!(
Auth::from(BearerToken::new("abc-._~+/=="))
.validate()
.is_ok()
);
}
#[test]
fn it_redacts_tokens_in_debug_output() {
let auth = BearerToken::new("secret");
let debug = format!("{auth:?}");
assert!(debug.contains("[redacted]"));
assert!(!debug.contains("secret"));
}
}
mod describe_api_key {
use super::*;
#[test]
fn it_can_apply_api_keys_as_headers() {
let mut headers = HeaderMap::new();
Auth::from(ApiKey::header("x-api-key", "secret").unwrap())
.apply(&mut headers, None)
.unwrap();
let value = headers.get("x-api-key").unwrap();
assert_eq!(value, "secret");
assert!(value.is_sensitive());
}
#[test]
fn it_rejects_invalid_header_names() {
let error = ApiKey::header("bad header", "secret").unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
}
#[test]
fn it_rejects_invalid_header_values() {
let error = ApiKey::header("x-api-key", "bad\nvalue").unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
}
#[test]
fn it_can_apply_api_keys_as_query_parameters() {
let mut headers = HeaderMap::new();
let mut url = Url::parse("https://example.com/widgets?active=true").unwrap();
Auth::from(ApiKey::query("api_key", "secret").unwrap())
.apply(&mut headers, Some(&mut url))
.unwrap();
assert!(headers.is_empty());
assert_eq!(
url.as_str(),
"https://example.com/widgets?active=true&api_key=secret"
);
}
#[test]
fn it_requires_a_name_for_query_parameters() {
let error = ApiKey::query("", "secret").unwrap_err();
assert_eq!(
error.to_string(),
"invalid request: API key query parameter name is required"
);
}
#[test]
fn it_requires_a_url_for_query_parameters() {
let mut headers = HeaderMap::new();
let error = Auth::from(ApiKey::query("api_key", "secret").unwrap())
.apply(&mut headers, None)
.unwrap_err();
assert_eq!(
error.to_string(),
"invalid request: request URL is required for query API key authentication"
);
}
#[test]
fn it_redacts_secret_values_in_debug_output() {
let header = format!("{:?}", ApiKey::header("x-api-key", "secret").unwrap());
let query = format!("{:?}", ApiKey::query("api_key", "secret").unwrap());
assert!(header.contains("[redacted]"));
assert!(query.contains("[redacted]"));
assert!(!header.contains("secret"));
assert!(!query.contains("secret"));
}
}
mod describe_auth_conversions {
use super::*;
#[test]
fn it_accepts_common_auth_type_conversions() {
assert!(matches!(
Auth::from(BasicAuth::new("user", None::<String>)),
Auth::Basic(_)
));
assert!(matches!(
Auth::from(BearerToken::new("token")),
Auth::Bearer(_)
));
assert!(matches!(
Auth::from(ApiKey::query("api_key", "secret").unwrap()),
Auth::ApiKey(_)
));
}
}
}