tez 0.0.1

A lightweight, ergonomic, and fast high-level HTTP client for Rust
Documentation
use std::fmt;

use base64::{Engine as _, engine::general_purpose::STANDARD};
use http::HeaderValue;

/// Credentials used to authenticate one Tez request or client.
///
/// Construct this through [`AuthProvider::basic`] or
/// [`AuthProvider::bearer`], then pass it to [`crate::ClientBuilder::auth`] or
/// [`crate::RequestBuilder::auth`]. Its debug representation never includes
/// credentials.
#[derive(Clone)]
pub struct AuthProvider(AuthKind);

#[derive(Clone)]
enum AuthKind {
    Basic { username: String, password: String },
    Bearer { token: String },
}

impl AuthProvider {
    /// Creates HTTP Basic credentials.
    #[must_use]
    pub fn basic(username: impl Into<String>, password: impl Into<String>) -> Self {
        Self(AuthKind::Basic {
            username: username.into(),
            password: password.into(),
        })
    }

    /// Creates Bearer-token credentials.
    #[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"));
    }
}