Xpath Injection in Axum with Firestore

XPath Injection occurs when untrusted data is concatenated into an XPath expression without proper sanitization or parameterization, allowing an attacker to alter the query logic. In an Axum service that builds XPath queries to query a Firestore-backed dataset (e.g., via a Firestore export or a custom XML/JSON-to-XPath layer), this can lead to unauthorized data access or data exfiltration.

Consider an endpoint in Axum that receives a user-supplied string intended to filter documents. If the application constructs an XPath expression by string interpolation, an attacker can inject additional predicates or path steps. For example:

// UNSAFE: building XPath via string concatenation in Axum
let user_value = "admin' or username != ''";
let xpath_expr = format!("/users/user[username='{}' and role='{}']", user_value, "admin");
// Resulting XPath: /users/user[username='admin' or username != '' and role='admin']

Because Firestore does not execute XPath directly, this scenario typically involves an intermediate transformation where Firestore documents are mapped to an XML or in-memory tree structure before XPath evaluation. If the transformation or the XPath evaluator does not enforce strict input validation, the injected condition can change the predicate logic, potentially bypassing intended filters.

Impacts include reading data belonging to other users (BOLA/IDOR), extracting sensitive configuration nodes, or enumerating structure via boolean-based blind injection. This maps to the OWASP API Top 10 Broken Access Control and Injection categories. middleBrick’s 12 security checks, including Input Validation and Property Authorization, would flag such patterns and provide severity-ranked findings with remediation guidance.

To detect this in a CI/CD context, you can use the GitHub Action to add API security checks to your CI/CD pipeline and fail builds if the risk score drops below your threshold. The CLI tool can also be used locally: middlebrick scan <url> to quickly validate endpoint behavior before deployment.

Remediation centers on avoiding string concatenation for query construction and using strict allow-listing and parameterization. When integrating Firestore with Axum, treat any user input as opaque to the eventual XPath evaluation layer; do not embed it into path segments or predicate expressions.

1) Use parameterized queries or allow-listed filters instead of XPath injection-prone constructs. If you must evaluate XPath, prepare the expression with a dedicated, well-tested library and pass user input as variables, never as raw text.

2) Validate and sanitize input against a strict schema. For Axum, leverage strong typing and validation crates (e.g., validator or serde_with) before any transformation occurs.

3) Apply the principle of least privilege: ensure the Firestore read scopes and IAM bindings for the service account are minimal and scoped to the collections and fields necessary for the operation.

Concrete secure Axum handler example with Firestore-like data flow:

// Safe approach: validate input, avoid XPath injection surface
use axum::{routing::get, Router};
use serde::{Deserialize, Serialize};
use validator::Validate;

#[derive(Deserialize, Validate)]
struct UserQuery {
    #[validate(length(min = 1, max = 64, regex = "^[a-zA-Z0-9_]+$"))]
    username: String,
    #[validate(length(min = 1, max = 32))]
    role: String,
}

async fn get_user(
    Query(params): Query<UserQuery>,
) -> Result<impl IntoResponse, (StatusCode, String)> {
    params.validate().map_err(|e| (StatusCode::BAD_REQUEST, e.to_string()))?;
    // Here you would call Firestore with parameterized filters, e.g., via the Firestore REST API
    // using params.username and params.role as bound values, not string interpolation.
    // Do not construct XPath expressions from these values.
    Ok(Json(("ok",)))
}

fn app() -> Router {
    Router::new().route("/user", get(get_user))
}

If you maintain an OpenAPI spec and use Firestore-exported XML schemas, middleBrick’s OpenAPI/Swagger spec analysis (supporting 2.0, 3.0, 3.1 with full $ref resolution) can cross-reference runtime findings against spec definitions to highlight mismatches that may enable injection paths. For teams needing continuous visibility, the Pro plan’s continuous monitoring can schedule scans and deliver alerts when risky patterns reappear.

Finally, for AI-assisted development workflows, the MCP Server enables scanning APIs directly from your AI coding assistant, helping catch concatenation patterns before they reach production.