Graphql Introspection in Actix with Firestore

GraphQL introspection is a standard query capability that allows clients to discover the schema, types, and operations available on an endpoint. When an Actix service exposes a GraphQL endpoint backed by Firestore without restricting introspection, the API surface can reveal detailed structural information, including collection names, field types, and query patterns. This exposure can aid an attacker in crafting targeted queries or identifying data models that may be improperly exposed.

In an Actix-based Rust service, GraphQL endpoints are often implemented using async handlers that forward queries to a backend such as Firestore. Firestore data structures—collections, documents, and field paths—are reflected into the GraphQL schema, and introspection queries can enumerate these elements. Because the introspection operation does not require authentication in many implementations, an unauthenticated attacker can run an introspection query to map the API surface. This becomes particularly sensitive when the schema includes references to sensitive collections or operations that, while not directly exposing data, clarify how data is organized and accessed.

middleBrick detects GraphQL introspection exposure as part of its 12 security checks. For an Actix service integrating Firestore, the scanner will flag unauthenticated introspection as a finding, highlighting that the endpoint reveals schema metadata without requiring credentials. The report includes severity, references to the GraphQL introspection standard, and remediation guidance that focuses on disabling or guarding introspection in production environments.

Additionally, because middleBrick supports OpenAPI/Swagger spec analysis with full $ref resolution, it cross-references any schema definitions present in a provided spec against runtime behavior. If introspection is discoverable, this cross-reference helps contextualize the exposure within the broader API design, ensuring that the finding is tied to concrete schema elements and operations rather than generic assumptions.

An example of a GraphQL introspection query that an attacker might send is:

query IntrospectionQuery {
  __schema {
    queryType {
      name
    }
    mutationType {
      name
    }
    subscriptionType {
      name
    }
    types {
      ...FullType
    }
  }
}

fragment FullType on __Type {
  kind
  name
  fields(includeDeprecated: true) {
    name
    args {
      name
      type {
        ...TypeRef
      }
    }
    type {
      ...TypeRef
    }
  }
  inputFields {
    name
    type {
      ...TypeRef
    }
  }
  interfaces {
      ...TypeRef
    }
    enumValues(includeDeprecated: true) {
    name
    deprecationReason
  }
}

fragment TypeRef on __Type {
  kind
  name
  ofType {
    kind
    name
    ofType {
      kind
      name
    }
  }
}

If the Actix GraphQL endpoint responds with detailed type information, this confirms that introspection is active. middleBrick flags such responses during its output scanning phase and notes that introspection should be disabled or restricted behind authentication and authorization controls to reduce the attack surface.

To remediate GraphQL introspection exposure in an Actix service that uses Firestore, you must control whether introspection is allowed and ensure that the GraphQL layer does not expose metadata that could aid an attacker. Below are concrete code examples showing how to configure a GraphQL endpoint in Actix with controlled introspection and secure Firestore integration.

1. Disable introspection in the GraphQL schema builder. Using the graphql crate, you can set introspection: false when creating the schema:

use graphql::{Schema, RootNode};
use actix_web::{web, App, HttpResponse, HttpServer, Responder};

struct QueryRoot;

// Define your GraphQL schema with introspection disabled
fn create_schema() -> Schema {
    Schema::new(
        RootNode::new(QueryRoot, ()),
        &[], // extensions
        graphql::Config {
            introspection: false, // disable introspection
            ..Default::default()
        },
    )
}

This ensures that introspection queries return an error, preventing schema enumeration.

2. If introspection must be available in a controlled environment (e.g., staging), guard it behind authentication and scope checks. In an Actix handler, inspect request metadata before allowing introspection operations:

use actix_web::{dev::ServiceRequest, Error};
use actix_web_httpauth::extractors::bearer::BearerAuth;

async fn guarded_graphql(
    schema: web::Data<Schema>,
    auth: Option<BearerAuth>,
    body: web::Json<serde_json::Value>
) -> Result<impl Responder, Error> {
    // Require authentication for introspection queries
    let request = ServiceRequest::from((&actix_web::HttpRequest::default(), body.into_inner()));
    if is_introspection_query(&request) {
        if auth.is_none() {
            return Err(actix_web::error::ErrorUnauthorized("Missing authentication"));
        }
        // Optionally enforce additional role-based checks here
    }
    // Proceed with schema execution
    let (parts, payload) = request.into_parts();
    let response = schema.execute(payload, &()).await;
    Ok(HttpResponse::Ok().json(response))
}

fn is_introspection_query(req: &ServiceRequest) -> bool {
    // Inspect the GraphQL query text for introspection operation
    if let Some(body) = req.payload().downcast_ref::<serde_json::Value>() {
        if let Some(op) = body.get("query") {
            return op.to_string().contains("__schema") || op.to_string().contains("__type");
        }
    }
    false
}

This pattern ensures that introspection is only permitted for authenticated requests, reducing the risk of unauthorized schema discovery.

3. When integrating with Firestore, avoid reflecting sensitive collection or document structures into the GraphQL schema. Instead, define explicit types and resolvers that limit the fields exposed. For example:

use firestore::*;
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct PublicData {
    pub id: String,
    pub name: String,
    // Do not include sensitive fields here
}

async fn fetch_public_collection(firestore: &FirestoreDb) -> Vec<PublicData> {
    let docs: Vec<PublicData> = firestore
        .collection("public_items")
        .limit(10)
        .get()
        .await
        .unwrap_or_default();
    docs
}

By explicitly selecting which collections and fields are exposed through GraphQL, you reduce the information available through introspection and minimize the risk of inadvertent data exposure.

middleBrick’s CLI can be used to verify that introspection is properly disabled or guarded. Run middlebrick scan <url> to generate a report that highlights any remaining introspection exposure and provides prioritized remediation steps. For teams managing multiple services, the Pro plan’s continuous monitoring can track changes to the GraphQL schema and alert you if introspection becomes accessible again.