Struct BasicAuth 

pub struct BasicAuth {
    pub username: String,
    pub password: String,
}

HTTP Basic credentials from Authorization: Basic ..., as an extractor (Rails’ http_basic_authenticate_with).

Rejects requests without valid Basic credentials with BasicAuth::challenge: 401 and WWW-Authenticate: Basic, so the browser asks for a user name and password. Check them with matches (constant time) against Worker secrets, and answer challenge when they are wrong. Browsers resend the credentials on every request over HTTPS; use it for a staging site or an internal page, not for user accounts (ocre g auth).

Examples

use axum::{extract::State, response::{IntoResponse, Response}};
use ocre::{Ctx, Result, security::BasicAuth};

async fn admin(State(ctx): State<Ctx>, auth: BasicAuth) -> Result<Response> {
    let password = ctx.secret("ADMIN_PASSWORD").await?;
    if !auth.matches("admin", &password) {
        return Ok(BasicAuth::challenge());
    }
    Ok("Welcome, admin".into_response())
}

Fields

username: String

The user name the client sent.

password: String

The password the client sent.

Implementations

impl BasicAuth

pub fn matches(&self, username: &str, password: &str) -> bool

Whether the credentials are username and password, compared in constant time.

Examples

use ocre::security::BasicAuth;

let auth = BasicAuth { username: "admin".into(), password: "s3cret".into() };
assert!(auth.matches("admin", "s3cret"));
assert!(!auth.matches("admin", "guess"));

pub fn challenge() -> Response

401 Unauthorized with WWW-Authenticate: Basic realm="Application": the browser asks again.

Examples

let response = ocre::security::BasicAuth::challenge();
assert_eq!(response.status(), 401);
assert_eq!(response.headers()["www-authenticate"], r#"Basic realm="Application", charset="UTF-8""#);

Trait Implementations

impl Clone for BasicAuth

fn clone(&self) -> BasicAuth

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BasicAuth

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

Formats the value using the given formatter.

impl Eq for BasicAuth

impl<S: Sync> FromRequestParts<S> for BasicAuth

type Rejection = Response<Body>

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, _state: &S, ) -> Result<Self, Response>

Perform the extraction.

impl PartialEq for BasicAuth

fn eq(&self, other: &BasicAuth) -> 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 StructuralPartialEq for BasicAuth