Graphql Introspection in Axum

Graphql introspection in Axum applications typically manifests through the async_graphql integration, where the introspection endpoint is enabled by default. When using Axum with async_graphql, the introspection query allows attackers to retrieve the complete schema of your GraphQL API, including all types, queries, mutations, and subscriptions. This information disclosure can be particularly dangerous in production environments where the schema reveals business logic, data structures, and potential attack vectors.

In Axum, introspection manifests through the async_graphql::Schema struct, which by default enables introspection queries. When you create a schema using Schema::new(queries, mutations), the introspection system is automatically included. This means that any GraphQL endpoint built with async_graphql in Axum will respond to introspection queries unless explicitly disabled.

The vulnerability becomes apparent when attackers send POST requests with introspection queries to your Axum GraphQL endpoint. For example, an attacker can retrieve the entire schema using a query like:

{
  __schema {
    types {
      name
      kind
      description
    }
  }
}

In Axum applications, this manifests as an endpoint that responds with detailed schema information, potentially exposing sensitive field names, argument types, and even documentation that could aid in crafting more sophisticated attacks. The introspection data often includes internal field names, deprecated fields, and type relationships that shouldn't be public knowledge.

Another manifestation occurs when using Axum's middleware pattern with GraphQL. If you're using async_graphql_axum::graphql to mount your GraphQL handler, the introspection endpoint is accessible at the same path as your main GraphQL operations. This means that without proper configuration, any client can query your entire API structure.

Detecting GraphQL introspection vulnerabilities in Axum applications requires examining both the code structure and runtime behavior. In your Axum codebase, look for schema creation patterns where introspection is enabled by default. The most common pattern is the use of async_graphql::Schema::new() without the SchemaBuilder configuration to disable introspection.

To detect this programmatically in your Axum application, you can examine how your GraphQL schema is constructed. Here's an example of vulnerable code:

use async_graphql::{Schema, EmptyMutation, EmptySubscription};
use async_graphql_axum::graphql;
use axum::{routing::post, Router};

async fn graphql_handler(schema: Schema<QueryRoot, EmptyMutation, EmptySubscription>) -> impl axum::response::IntoResponse {
    graphql(schema)
}

let app = Router::new()
    .route("/graphql", post(graphql_handler))
    .with_state(schema.clone());

The detection pattern here is the use of Schema::new() without any introspection configuration. A secure implementation would use SchemaBuilder to explicitly control introspection behavior.

Using middleBrick to scan your Axum GraphQL endpoint provides automated detection. middleBrick's GraphQL introspection check sends actual introspection queries to your endpoint and analyzes the response. The scanner tests for:

• Whether the endpoint responds to introspection queries
• The completeness of schema information returned
• Whether sensitive field names or deprecated elements are exposed
• If the endpoint implements proper authentication for schema access

middleBrick's scanning process takes 5-15 seconds and requires no credentials or configuration. Simply provide your Axum GraphQL endpoint URL, and middleBrick will test the unauthenticated attack surface, including GraphQL-specific vulnerabilities like introspection exposure.

For runtime detection, you can add middleware to your Axum application that logs or blocks introspection queries. Here's an example middleware that detects introspection attempts:

use async_graphql::{Request, Response};
use axum::middleware::Next;
use axum::response::IntoResponse;

async fn introspection_detection(mut req: axum::http::Request, next: Next) -> impl IntoResponse {
    let body = axum::body::to_bytes(req.body_mut()).await.unwrap();
    let query_str = String::from_utf8(body.to_vec()).unwrap_or_default();
    
    if query_str.contains("__schema") || query_str.contains("__type") {
        // Log or block introspection attempt
        return axum::response::Response::builder()
            .status(403)
            .body(axum::body::Full::from("Introspection disabled"))
            .unwrap();
    }
    
    let mut new_req = axum::http::Request::from_parts(req.into_parts().0, body);
    next.call(new_req).await
}

This middleware can be added to your Axum router to detect and block introspection queries before they reach your GraphQL handler.