Struct HttpAuthentication 

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

Middleware for checking HTTP authentication.

By default, if the extractor T fails (for example because the Authorization header is missing), this middleware returns an error immediately, without calling the F callback.

To make authentication optional (or to implement multiple auth methods), wrap the extractor in Option<T> or Result<T, T::Error>. In those cases, extraction never fails, so the validator always runs and can decide how to proceed.

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

impl<T, F, O> HttpAuthentication<T, F>

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

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 (fallback to other auth methods)

async fn validator(
    req: ServiceRequest,
    credentials: Option<BearerAuth>,
) -> Result<ServiceRequest, (actix_web::Error, ServiceRequest)> {
    let Some(credentials) = credentials else {
        // No Authorization header; allow other auth methods (eg cookies/sessions) to proceed.
        return Ok(req);
    };

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

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

    Ok(req)
}

impl<F, O> HttpAuthentication<BasicAuth, F>

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

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);

impl<F, O> HttpAuthentication<BearerAuth, F>

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

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);

Trait Implementations

impl<T, F: Clone> Clone for HttpAuthentication<T, F>

where T: FromRequest + Clone,

fn clone(&self) -> HttpAuthentication<T, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, F: Debug> Debug for HttpAuthentication<T, F>

where T: FromRequest + Debug,

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

Formats the value using the given formatter.

impl<S, B, T, F, O> Transform<S, ServiceRequest> for HttpAuthentication<T, F>

where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, S::Future: 'static, F: Fn(ServiceRequest, T) -> O + 'static, O: Future<Output = Result<ServiceRequest, (Error, ServiceRequest)>> + 'static, T: FromRequest + 'static, B: MessageBody + 'static,

type Response = ServiceResponse<EitherBody<B>>

Responses produced by the service.

type Error = Error

Errors produced by the service.

type Transform = AuthenticationMiddleware<S, F, T>

The TransformService value created by this factory

type InitError = ()

Errors produced while building a transform service.

type Future = Ready<Result<<HttpAuthentication<T, F> as Transform<S, ServiceRequest>>::Transform, <HttpAuthentication<T, F> as Transform<S, ServiceRequest>>::InitError>>

The future response value.

fn new_transform(&self, service: S) -> Self::Future

Creates and returns a new Transform component, asynchronously