Graphql Introspection in Chi with Jwt Tokens

GraphQL introspection is a feature that allows clients to query the schema of a GraphQL server, including types, queries, and mutations. When this capability is left enabled in a Chi-based application that also uses JWT tokens for authentication, it can expose sensitive design details even when requests present valid tokens. Introspection queries do not inherently validate business-level permissions; they often run regardless of whether a JWT is present or valid, depending on server configuration.

In Chi, routes are typically composed as a series of middleware and handlers. If introspection is mapped to a route without explicit guards, an attacker can send an introspection query to the same endpoint that otherwise requires a JWT for sensitive operations. The presence of a JWT may grant access to certain fields or operations, but introspection itself can leak schema information such as argument names, return types, and resolver paths. This can reveal internal data models, field relationships, and potential injection points that are otherwise hidden behind authentication.

Moreover, because Chi handlers are often built as function pipelines, introspection may execute before or alongside authorization checks if not carefully separated. A valid JWT might grant access to a mutation, but an attacker can still run introspection without needing to trigger the mutation itself. This creates a discrepancy where authentication is verified, but the unauthenticated attack surface of schema exposure remains open. The combination therefore does not inherently mitigate information leakage through introspection, and may unintentionally signal to an attacker that the endpoint is actively managed and secured at the application layer.

When using JWT tokens, developers sometimes assume that middleware validating the token is sufficient to protect introspection. However, introspection queries can bypass business logic and directly interact with the GraphQL layer, which may not enforce the same constraints as route-level middleware. This mismatch can lead to unintentional schema disclosure alongside authenticated sessions, increasing the risk of targeted attacks such as IDOR or BOLA that rely on detailed knowledge of the data model.

middleBrick scans this specific combination by running unauthenticated checks against the endpoint, testing whether introspection is accessible even when JWT validation is expected. One of the 12 parallel security checks focuses on authentication and authorization boundaries, highlighting whether schema introspection leaks information in the presence of token-based controls. The scan also tests for excessive agency in LLM-related endpoints and maps findings to frameworks such as OWASP API Top 10 and SOC2, providing prioritized remediation guidance rather than attempting to fix the issue automatically.

To secure GraphQL introspection in Chi when using JWT tokens, you should explicitly disable introspection in production or gate it behind the same authorization checks applied to other operations. Below are concrete code examples showing how to configure a Chi application to conditionally allow introspection only for authenticated users with valid JWTs.

Example 1: Disabling introspection entirely

This approach removes introspection support by customizing the GraphQL settings, ensuring the endpoint does not respond to introspection queries regardless of authentication.

// main.chi
import "github.com/graph-gophers/graphql-go"
import "github.com/graph-gophers/graphql-go/graphql/handler"
import "github.com/graph-gophers/graphql-go/graphql/handler/transport"

func buildSchema() graphql.Schema {
    // Define your schema with graphql.NewSchema
    // ...
}

func main() {
    srv := handler.NewDefaultServer(buildSchema())
    // Disable introspection and validation of queries
    srv.AddTransport(transport.POST{})
    srv.AddTransport(transport.GET{
        IntrospectionDisabled: true,
    })
    // ... route and server start
}

Example 2: Guarding introspection with JWT validation

This approach allows introspection only when a valid JWT is present and verified by Chi middleware, aligning schema visibility with authentication.

// main.chi
import "github.com/dgrijalva/jwt-go"
import "github.com/labstack/chi/v5"
import "github.com/labstack/chi/v5/middleware"

func validateJWT(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tokenString := extractToken(r)
        token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
            return []byte("your-secret-key"), nil
        })
        if err != nil || !token.Valid {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

func allowIntrospection(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path == "/graphql" && r.Method == "GET" {
            // Allow introspection only when JWT is valid
            next.ServeHTTP(w, r)
            return
        }
        http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            http.Error(w, "Forbidden", http.StatusForbidden)
        }).ServeHTTP(w, r)
    })
}

func main() {
    r := chi.NewRouter()
    r.Use(middleware.RequestID)
    r.Use(validateJWT)
    r.Post("/graphql", graphqlHandler)
    r.Get("/graphql", allowIntrospection(graphqlHandler))
    // ... start server
}

Example 3: Schema-level introspection control

Using the graphql-go library, you can disable introspection at the schema level by setting appropriate resolver configurations.

// schema.chi
import "github.com/graph-gophers/graphql-go"

var schema graphql.Schema

func init() {
    rootQuery := graphql.NewObject(graphql.ObjectConfig{
        Name: "Query",
        Fields: graphql.Fields{
            "publicField": &graphql.Field{
                Type: graphql.String,
                Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                    return "visible", nil
                },
            },
        },
    })

    // Disable introspection by not including __schema and __type fields
    schema = graphql.MustParseSchema(`
        schema {
            query: Query
            # Introspection types are omitted
        }
        type Query {
            publicField: String
        }
    `, rootQuery)
}

middleBrick integration

middleBrick can scan Chi endpoints that use JWT tokens to detect whether introspection remains accessible and whether authentication boundaries are respected. The tool runs 12 parallel checks, including Authentication, Input Validation, and LLM/AI Security, and maps findings to compliance frameworks. With the Pro plan, continuous monitoring can be enabled to periodically verify that introspection is properly gated and that changes to the API do not reintroduce exposure.