Hallucination Attacks in Axum with Basic Auth

Axum is a Rust web framework. When Basic Authentication is used without additional safeguards, an API can hallucinate authorization states that do not match backend enforcement. This mismatch can be exploited to induce hallucination attacks where an attacker receives responses for other users or resources by manipulating authentication or request context.

Basic Auth in Axum is typically implemented by inspecting the Authorization header, decoding the base64 payload, and validating credentials. If authorization checks are applied inconsistently—such as checking authentication status but not revalidating scope or tenant context—the application may hallucinate that a request is authorized for one resource while the token only covers another. For example, an endpoint that reads user profile data might trust a decoded user ID from the Basic Auth header without verifying that the authenticated subject has permission to view that specific profile. An attacker could enumerate usernames or IDs and observe differences in behavior or timing, leading to information exposure or unauthorized data access.

In an Axum application, this risk is compounded when routes rely on extractor patterns that separate authentication from authorization. A common pattern uses an extractor to load a User from the header, and downstream handlers assume the user context is trustworthy. If route parameters or query inputs are used to construct resource identifiers without aligning them to the authenticated identity, the application can hallucinate access paths. For instance, a route like /users/{user_id}/settings that uses Basic Auth to identify a user but then directly trusts user_id from the path can hallucinate settings for another user when the attacker simply changes the path parameter while supplying valid credentials for a different account.

Hallucination attacks in this context also involve state confusion between authentication and authorization layers. Basic Auth provides authentication, but it does not inherently convey scopes or tenant boundaries. Without explicit checks, an Axum handler might hallucinate elevated privileges, allowing an attacker to perform actions or access data that should be restricted. This becomes critical in multi-tenant scenarios where a missing tenant ID check can lead to cross-tenant data access that appears authorized from the application’s perspective.

OpenAPI/Swagger analysis can surface these risks when spec definitions do not align with runtime expectations. If the spec describes security schemes using Basic Auth but does not enforce scope or tenant constraints, runtime behavior may diverge from documented capabilities. Cross-referencing spec definitions with actual route guards helps identify where hallucination opportunities exist, such as missing parameter-level authorization or inconsistent security requirements across operations.

Remediation focuses on binding authentication context to authorization checks and avoiding implicit trust in route or query parameters. In Axum, implement a two-step validation where the Basic Auth header is parsed and verified, and the resulting identity is explicitly combined with resource ownership checks before any data access.

First, define a typed extractor that validates credentials and returns an authorized identity with clear scopes or tenant context. Avoid reusing the decoded user ID directly from the header without backend verification against a permission store.

use axum::async_trait;
use axum::extract::{FromRequest, Request};
use axum::http::header;
use base64::prelude::*;
use std::convert::Infallible;
use std::net::SocketAddr;
use std::sync::Arc;

#[derive(Debug, Clone)]
struct User {
    id: String,
    tenant_id: String,
    scopes: Vec,
}

#[derive(Debug, Clone)]
struct Auth {
    user: User,
}

struct AuthorizedUser {
    user: User,
}

#[async_trait]
impl FromRequest for AuthorizedUser
where
    S: Send + Sync,
{
    type Rejection = (axum::http::StatusCode, String);

    async fn from_request(req: Request, _state: &S) -> Result {
        let auth_header = req.headers()
            .get(header::AUTHORIZATION)
            .ok_or((axum::http::StatusCode::UNAUTHORIZED, "Missing Authorization header".to_string()))?
            .to_str()
            .map_err(|_| (axum::http::StatusCode::UNAUTHORIZED, "Invalid header encoding".to_string()))?
            .strip_prefix("Basic ")
            .ok_or((axum::http::StatusCode::UNAUTHORIZED, "Invalid auth scheme".to_string()))?;

        let decoded = BASE64_STANDARD.decode(auth_header)
            .map_err(|_| (axum::http::StatusCode::UNAUTHORIZED, "Invalid base64".to_string()))?;
        let creds = String::from_utf8(decoded)
            .map_err(|_| (axum::http::StatusCode::UNAUTHORIZED, "Invalid credentials encoding".to_string()))?;
        let parts: Vec<&str> = creds.splitn(2, ':').collect();
        if parts.len() != 2 {
            return Err((axum::http::StatusCode::UNAUTHORIZED, "Invalid credentials format".to_string()));
        }
        let (username, password) = (parts[0], parts[1]);

        // Replace with actual credential verification and tenant/scope lookup
        let user = verify_user(username, password).await.map_err(|_| (axum::http::StatusCode::FORBIDDEN, "Invalid credentials".to_string()))?;
        Ok(AuthorizedUser { user })
    }
}

async fn verify_user(username: &str, password: &str) -> Result {
    // Example verification; integrate with your identity store
    if username == "alice" && password == "secret" {
        Ok(User {
            id: username.to_string(),
            tenant_id: "tenant-a".to_string(),
            scopes: vec!["read:settings".to_string(), "write:settings".to_string()],
        })
    } else {
        Err(())
    }
}

use axum::{routing::get, Router};
use std::net::SocketAddr;

async fn settings_handler(
    AuthorizedUser { user }: AuthorizedUser,
    axum::extract::Path(params): axum::extract::Path<(String,)>, // user_id from path
) -> Result {
    let requested_user_id = params.0;
    if user.id != requested_user_id {
        return Err((axum::http::StatusCode::FORBIDDEN, "Access denied".to_string()));
    }
    // Proceed only when authenticated identity matches the requested resource
    Ok(format!("Settings for {}", user.id))
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/users/:user_id/settings", get(settings_handler))
        .layer(axum::middleware::from_fn_with_state(
        (),
        |_state, request, next| async move {
            // Optional global auth layer; handlers can still perform explicit checks
            let _auth = AuthorizedUser::from_request(&request, &()).await?;
            next.run(request).await
        },
    ));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}