Struct actix_web_httpauth::middleware::HttpAuthentication

source ·

pub struct HttpAuthentication<T, F>where
    T: FromRequest,
{ /* private fields */ }

Expand description

Middleware for checking HTTP authentication.

If there is no Authorization header in the request, this middleware returns an error immediately, without calling the F callback.

Otherwise, it will pass both the request and the parsed credentials into it. In case of successful validation F callback is required to return the ServiceRequest back.

Implementations§

source §

impl<T, F, O> HttpAuthentication<T, F>
where T: FromRequest, F: Fn(ServiceRequest, T) -> O, O: Future<Output = Result<ServiceRequest, (Error, ServiceRequest)>>,

source

pub fn with_fn(process_fn: F) -> HttpAuthentication<T, F>

Construct HttpAuthentication middleware with the provided auth extractor T and validation callback F.

This function can be used to implement optional authentication and/or custom responses to missing authentication.

§Examples

§Required Basic Auth

async fn validator(
    req: ServiceRequest,
    credentials: BasicAuth,
) -> Result<ServiceRequest, (actix_web::Error, ServiceRequest)> {
    eprintln!("{credentials:?}");

    if credentials.user_id().contains('x') {
        return Err((actix_web::error::ErrorBadRequest("user ID contains x"), req));
    }

    Ok(req)
}

§Optional Bearer Auth

async fn validator(
    req: ServiceRequest,
    credentials: Option<BearerAuth>,
) -> Result<ServiceRequest, (actix_web::Error, ServiceRequest)> {
    let Some(credentials) = credentials else {
        return Err((actix_web::error::ErrorBadRequest("no bearer header"), req));
    };

    eprintln!("{credentials:?}");

    if credentials.token().contains('x') {
        return Err((actix_web::error::ErrorBadRequest("token contains x"), req));
    }

    Ok(req)
}

source §

impl<F, O> HttpAuthentication<BasicAuth, F>
where F: Fn(ServiceRequest, BasicAuth) -> O, O: Future<Output = Result<ServiceRequest, (Error, ServiceRequest)>>,

source

pub fn basic(process_fn: F) -> Self

Construct HttpAuthentication middleware for the HTTP “Basic” authentication scheme.

§Examples

// In this example validator returns immediately, but since it is required to return
// anything that implements `IntoFuture` trait, it can be extended to query database or to
// do something else in a async manner.
async fn validator(
    req: ServiceRequest,
    credentials: BasicAuth,
) -> Result<ServiceRequest, (Error, ServiceRequest)> {
    // All users are great and more than welcome!
    Ok(req)
}

let middleware = HttpAuthentication::basic(validator);

source §

impl<F, O> HttpAuthentication<BearerAuth, F>
where F: Fn(ServiceRequest, BearerAuth) -> O, O: Future<Output = Result<ServiceRequest, (Error, ServiceRequest)>>,

source

pub fn bearer(process_fn: F) -> Self

Construct HttpAuthentication middleware for the HTTP “Bearer” authentication scheme.

§Examples

async fn validator(
    req: ServiceRequest,
    credentials: BearerAuth
) -> Result<ServiceRequest, (Error, ServiceRequest)> {
    if credentials.token() == "mF_9.B5f-4.1JqM" {
        Ok(req)
    } else {
        let config = req.app_data::<bearer::Config>()
            .cloned()
            .unwrap_or_default()
            .scope("urn:example:channel=HBO&urn:example:rating=G,PG-13");

        Err((AuthenticationError::from(config).into(), req))
    }
}

let middleware = HttpAuthentication::bearer(validator);