use std::fmt;
use std::future::Future;
use std::pin::Pin;
use axum::http::{HeaderMap, HeaderValue, header};
use base64::Engine as _;
use subtle::ConstantTimeEq;
use crate::operation::Principal;
pub const MAX_AUTHORIZATION_BYTES: usize = 1024;
#[derive(Clone, PartialEq, Eq)]
pub struct Secret(String);
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct InvalidSecret;
impl fmt::Display for InvalidSecret {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("a secret must be 1 to 256 visible ASCII characters (0x21-0x7E)")
}
}
impl std::error::Error for InvalidSecret {}
pub const MAX_SECRET_BYTES: usize = 256;
impl Secret {
pub fn new(value: impl Into<String>) -> Result<Self, InvalidSecret> {
let value = value.into();
let valid = (1..=MAX_SECRET_BYTES).contains(&value.len()) && value.bytes().all(is_vchar);
if valid {
Ok(Self(value))
} else {
Err(InvalidSecret)
}
}
pub fn matches(&self, presented: &[u8]) -> bool {
self.0.as_bytes().ct_eq(presented).into()
}
pub(crate) fn as_bytes(&self) -> &[u8] {
self.0.as_bytes()
}
}
impl fmt::Debug for Secret {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("Secret(<redacted>)")
}
}
#[derive(Clone, PartialEq, Eq)]
pub enum Presented {
Basic {
user: Vec<u8>,
password: Vec<u8>,
},
Bearer(Vec<u8>),
}
impl fmt::Debug for Presented {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Basic { .. } => f.write_str("Basic(<redacted>)"),
Self::Bearer(_) => f.write_str("Bearer(<redacted>)"),
}
}
}
pub fn parse_authorization(value: &[u8]) -> Option<Presented> {
if value.len() > MAX_AUTHORIZATION_BYTES {
return None;
}
let space = value.iter().position(|&b| b == b' ')?;
let (scheme, rest) = value.split_at(space);
let credentials = trim_leading_spaces(rest);
if credentials.is_empty() || !credentials.iter().all(|&b| is_vchar(b)) {
return None;
}
if scheme.eq_ignore_ascii_case(b"basic") {
let decoded = base64::engine::general_purpose::STANDARD
.decode(credentials)
.ok()?;
let colon = decoded.iter().position(|&b| b == b':')?;
Some(Presented::Basic {
user: decoded[..colon].to_vec(),
password: decoded[colon + 1..].to_vec(),
})
} else if scheme.eq_ignore_ascii_case(b"bearer") {
Some(Presented::Bearer(credentials.to_vec()))
} else {
None
}
}
pub fn basic_matches(header: Option<&[u8]>, user: &Secret, password: &Secret) -> bool {
match header.and_then(parse_authorization) {
Some(Presented::Basic {
user: presented_user,
password: presented_password,
}) => {
let user_ok = user.as_bytes().ct_eq(&presented_user);
let password_ok = password.as_bytes().ct_eq(&presented_password);
(user_ok & password_ok).into()
}
_ => false,
}
}
pub fn bearer_matches(header: Option<&[u8]>, token: &Secret) -> bool {
match header.and_then(parse_authorization) {
Some(Presented::Bearer(presented)) => token.matches(&presented),
_ => false,
}
}
pub type AuthFuture<'a> = Pin<Box<dyn Future<Output = Option<Principal>> + Send + 'a>>;
pub trait Authenticate: Send + Sync + 'static {
fn authenticate<'a>(&'a self, headers: &'a HeaderMap) -> AuthFuture<'a>;
fn challenge(&self) -> HeaderValue;
}
pub fn single_authorization(headers: &HeaderMap) -> Option<&[u8]> {
let mut values = headers.get_all(header::AUTHORIZATION).iter();
match (values.next(), values.next()) {
(Some(value), None) => Some(value.as_bytes()),
_ => None,
}
}
pub fn bearer_token(headers: &HeaderMap) -> Option<Vec<u8>> {
match single_authorization(headers).and_then(parse_authorization) {
Some(Presented::Bearer(token)) => Some(token),
_ => None,
}
}
#[derive(Debug)]
pub struct Basic {
user: Secret,
password: Secret,
principal: Principal,
}
impl Basic {
pub fn new(user: Secret, password: Secret, principal: Principal) -> Self {
Self {
user,
password,
principal,
}
}
}
impl Authenticate for Basic {
fn authenticate<'a>(&'a self, headers: &'a HeaderMap) -> AuthFuture<'a> {
let matches = basic_matches(single_authorization(headers), &self.user, &self.password);
Box::pin(std::future::ready(matches.then(|| self.principal.clone())))
}
fn challenge(&self) -> HeaderValue {
HeaderValue::from_static("Basic realm=\"senu\", charset=\"UTF-8\"")
}
}
#[derive(Debug)]
pub struct Bearer {
tokens: Vec<(Secret, Principal)>,
}
impl Bearer {
pub fn new(token: Secret, principal: Principal) -> Self {
Self {
tokens: vec![(token, principal)],
}
}
pub fn and(mut self, token: Secret, principal: Principal) -> Self {
self.tokens.push((token, principal));
self
}
}
impl Authenticate for Bearer {
fn authenticate<'a>(&'a self, headers: &'a HeaderMap) -> AuthFuture<'a> {
let presented = bearer_token(headers);
let mut found = None;
if let Some(presented) = presented {
for (token, principal) in &self.tokens {
if token.matches(&presented) && found.is_none() {
found = Some(principal.clone());
}
}
}
Box::pin(std::future::ready(found))
}
fn challenge(&self) -> HeaderValue {
HeaderValue::from_static("Bearer realm=\"senu\"")
}
}
pub(crate) fn is_vchar(byte: u8) -> bool {
(0x21..=0x7e).contains(&byte)
}
fn trim_leading_spaces(bytes: &[u8]) -> &[u8] {
let start = bytes.iter().position(|&b| b != b' ').unwrap_or(bytes.len());
&bytes[start..]
}
#[cfg(test)]
mod tests {
use super::*;
fn secret(value: &str) -> Secret {
Secret::new(value).expect("a valid secret")
}
fn basic_header(user: &str, password: &str) -> String {
let raw = format!("{user}:{password}");
format!(
"Basic {}",
base64::engine::general_purpose::STANDARD.encode(raw)
)
}
#[test]
fn parses_basic_credentials() {
assert_eq!(
parse_authorization(basic_header("demo", "pw").as_bytes()),
Some(Presented::Basic {
user: b"demo".to_vec(),
password: b"pw".to_vec(),
})
);
}
#[test]
fn basic_password_may_contain_colons() {
assert_eq!(
parse_authorization(basic_header("demo", "a:b:c").as_bytes()),
Some(Presented::Basic {
user: b"demo".to_vec(),
password: b"a:b:c".to_vec(),
})
);
}
#[test]
fn parses_bearer_tokens_with_any_visible_ascii() {
assert_eq!(
parse_authorization(b"Bearer abc!\"#$%~"),
Some(Presented::Bearer(b"abc!\"#$%~".to_vec()))
);
}
#[test]
fn schemes_match_case_insensitively() {
for scheme in ["basic", "BASIC", "bAsIc"] {
let header = basic_header("u", "p").replacen("Basic", scheme, 1);
assert!(
matches!(
parse_authorization(header.as_bytes()),
Some(Presented::Basic { .. })
),
"{scheme}"
);
}
for scheme in ["bearer", "BEARER", "BeArEr"] {
let header = format!("{scheme} token");
assert_eq!(
parse_authorization(header.as_bytes()),
Some(Presented::Bearer(b"token".to_vec())),
"{scheme}"
);
}
}
#[test]
fn several_spaces_after_the_scheme_are_allowed() {
assert_eq!(
parse_authorization(b"Bearer token"),
Some(Presented::Bearer(b"token".to_vec()))
);
}
#[test]
fn malformed_values_are_rejected() {
let cases: &[&[u8]] = &[
b"",
b"Bearer",
b"Bearer ",
b"Basic",
b"Basic ",
b"Bearer a b",
b"Bearer a\tb",
b"Bearer\ttoken",
b" Bearer token",
b"Bearer token ",
b"Bearer tok\x7fen",
b"Bearer t\xc3\xa9",
b"Token abc",
b"Digest abc",
b"Bearertoken",
b"Basic !!!notbase64",
b"Basic ZGVtbw==",
];
for value in cases {
assert_eq!(
parse_authorization(value),
None,
"{:?}",
String::from_utf8_lossy(value)
);
}
}
#[test]
fn oversized_values_are_rejected() {
let token = "a".repeat(MAX_AUTHORIZATION_BYTES);
let header = format!("Bearer {token}");
assert!(header.len() > MAX_AUTHORIZATION_BYTES);
assert_eq!(parse_authorization(header.as_bytes()), None);
}
#[test]
fn secret_matches_only_the_exact_bytes() {
let s = secret("correct-horse");
assert!(s.matches(b"correct-horse"));
assert!(!s.matches(b"correct-hors"));
assert!(!s.matches(b"correct-horse!"));
assert!(!s.matches(b"CORRECT-HORSE"));
assert!(!s.matches(b""));
}
#[test]
fn basic_matches_requires_both_user_and_password() {
let (user, password) = (secret("demo"), secret("web-pass"));
let ok = basic_header("demo", "web-pass");
assert!(basic_matches(Some(ok.as_bytes()), &user, &password));
let wrong_user = basic_header("demo2", "web-pass");
assert!(!basic_matches(
Some(wrong_user.as_bytes()),
&user,
&password
));
let wrong_password = basic_header("demo", "web-pas");
assert!(!basic_matches(
Some(wrong_password.as_bytes()),
&user,
&password
));
assert!(!basic_matches(None, &user, &password));
}
#[test]
fn basic_matches_rejects_bearer_credentials() {
let (user, password) = (secret("demo"), secret("web-pass"));
assert!(!basic_matches(Some(b"Bearer web-pass"), &user, &password));
}
#[test]
fn bearer_matches_only_the_configured_token() {
let token = secret("api-token");
assert!(bearer_matches(Some(b"Bearer api-token"), &token));
assert!(bearer_matches(Some(b"bearer api-token"), &token));
assert!(!bearer_matches(Some(b"Bearer api-token2"), &token));
assert!(!bearer_matches(None, &token));
let basic = basic_header("demo", "api-token");
assert!(!bearer_matches(Some(basic.as_bytes()), &token));
}
#[test]
fn debug_output_never_contains_credentials() {
let s = secret("sentinel-secret");
assert!(!format!("{s:?}").contains("sentinel"));
let presented = parse_authorization(b"Bearer sentinel-secret");
assert!(!format!("{presented:?}").contains("sentinel"));
let presented = parse_authorization(basic_header("u", "sentinel-secret").as_bytes());
assert!(!format!("{presented:?}").contains("sentinel"));
}
fn headers(values: &[&str]) -> HeaderMap {
let mut headers = HeaderMap::new();
for value in values {
headers.append(
header::AUTHORIZATION,
HeaderValue::from_str(value).expect("a header value"),
);
}
headers
}
fn principal(name: &'static str) -> Principal {
Principal::new(name, crate::operation::TenantId::from_static("t"), &[])
}
fn now(future: AuthFuture<'_>) -> Option<Principal> {
let mut future = future;
let mut context = std::task::Context::from_waker(std::task::Waker::noop());
match future.as_mut().poll(&mut context) {
std::task::Poll::Ready(principal) => principal,
std::task::Poll::Pending => panic!("a built-in authenticator was not ready"),
}
}
#[test]
fn secrets_are_1_to_256_visible_ascii_characters() {
assert!(Secret::new("a").is_ok());
assert!(Secret::new("a".repeat(256)).is_ok());
assert!(Secret::new("!~").is_ok());
for bad in [
String::new(),
"a".repeat(257),
"a b".to_owned(),
"tab\there".to_owned(),
"line\n".to_owned(),
"caf\u{e9}".to_owned(),
"del\u{7f}".to_owned(),
] {
assert_eq!(Secret::new(bad.clone()).err(), Some(InvalidSecret));
}
let message = InvalidSecret.to_string();
assert!(message.contains("1 to 256"), "{message}");
}
#[test]
fn only_a_single_authorization_header_is_used() {
assert_eq!(single_authorization(&headers(&[])), None);
let one = headers(&["Bearer a"]);
assert_eq!(single_authorization(&one), Some(&b"Bearer a"[..]));
assert_eq!(
single_authorization(&headers(&["Bearer a", "Bearer a"])),
None
);
assert_eq!(bearer_token(&one), Some(b"a".to_vec()));
assert_eq!(bearer_token(&headers(&["Bearer a", "Bearer a"])), None);
assert_eq!(bearer_token(&headers(&[&basic_header("u", "p")])), None);
}
#[test]
fn basic_yields_its_principal_only_for_the_exact_pair() {
let auth = Basic::new(secret("demo"), secret("web-pass"), principal("web"));
let good = basic_header("demo", "web-pass");
assert_eq!(
now(auth.authenticate(&headers(&[&good]))),
Some(principal("web"))
);
for wrong in [
basic_header("demo", "web-pasS"),
basic_header("Demo", "web-pass"),
basic_header("demo", ""),
"Bearer web-pass".to_owned(),
] {
assert_eq!(now(auth.authenticate(&headers(&[&wrong]))), None, "{wrong}");
}
assert_eq!(now(auth.authenticate(&headers(&[]))), None);
assert_eq!(now(auth.authenticate(&headers(&[&good, &good]))), None);
assert_eq!(auth.challenge(), "Basic realm=\"senu\", charset=\"UTF-8\"");
let debug = format!("{auth:?}");
assert!(
!debug.contains("web-pass") && !debug.contains("demo"),
"{debug}"
);
}
#[test]
fn bearer_maps_each_token_to_its_own_principal() {
let auth = Bearer::new(secret("token-a"), principal("a"))
.and(secret("token-b"), principal("b"))
.and(secret("token-a"), principal("shadowed"));
let call = |value: &str| now(auth.authenticate(&headers(&[value])));
assert_eq!(call("Bearer token-a"), Some(principal("a")));
assert_eq!(call("bearer token-b"), Some(principal("b")));
for wrong in [
"Bearer token-c",
"Bearer token-",
"Bearer token-aa",
"Token token-a",
] {
assert_eq!(call(wrong), None, "{wrong}");
}
assert_eq!(call(&basic_header("token-a", "token-a")), None);
assert_eq!(now(auth.authenticate(&headers(&[]))), None);
let twice = headers(&["Bearer token-a", "Bearer token-a"]);
assert_eq!(now(auth.authenticate(&twice)), None);
assert_eq!(auth.challenge(), "Bearer realm=\"senu\"");
assert!(!format!("{auth:?}").contains("token-a"));
}
}