Struct AuthBasic

pub struct AuthBasic(pub (String, Option<String>));

Basic authentication extractor, containing an identifier as well as an optional password

This is enabled via the auth-basic feature

Example

Though this structure can be used like any other axum extractor, we recommend this pattern:

use axum_auth::AuthBasic;

/// Takes basic auth details and shows a message
async fn handler(AuthBasic((id, password)): AuthBasic) -> String {
    if let Some(password) = password {
        format!("User '{}' with password '{}'", id, password)
    } else {
        format!("User '{}' without password", id)
    }
}

Errors

There are a few errors which this extractor can make. By default, all invalid responses are 400 BAD REQUEST with one of these messages:

• `Authorization` header could not be decoded – The header couldn’t be decoded, probably missing a colon
• `Authorization` header must be for basic authentication – Someone tried to use bearer auth instead of basic auth
• `Authorization` header is missing – The header was required but it wasn’t found
• `Authorization` header contains invalid characters – The header couldn’t be processed because of invalid characters

Tuple Fields

0: (String, Option<String>)

Trait Implementations

impl AuthBasicCustom for AuthBasic

const ERROR_CODE: StatusCode = ERR_DEFAULT

Error code to use instead of the typical 400 BAD REQUEST error

const ERROR_OVERWRITE: Option<&'static str> = None

Message to overwrite all default ones with if required, leave as None ideally

fn from_header(contents: (String, Option<String>)) -> Self

Converts provided header contents to new instance of self; you need to implement this

fn decode_request_parts(req: &mut Parts) -> Result<Self, Rejection>

Decodes bearer token content into new instance of self from axum body parts; this is automatically implemented

impl Clone for AuthBasic

fn clone(&self) -> AuthBasic

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AuthBasic

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B> FromRequestParts<B> for AuthBasic

where B: Send + Sync,

type Rejection = (StatusCode, &'static str)

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

async fn from_request_parts( parts: &mut Parts, _: &B, ) -> Result<Self, Self::Rejection>

Perform the extraction.

impl PartialEq for AuthBasic

fn eq(&self, other: &AuthBasic) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for AuthBasic

impl StructuralPartialEq for AuthBasic