security.md

Protection Against Malicious Queries

GraphQL allows a large degree of dynamism and flexibility for clients to control what happens on the server during query execution. Malicious clients may abuse this by sending very deep and complex queries whose execution exhausts server resources.

At a basic level, it is recommended to limit the resources a single HTTP request can use through PHP settings such as:

• max_execution_time
• memory_limit
• post_max_size

In addition, graphql-php offers security mechanisms that are specific to GraphQL.

Parser Recursion Limit

The parser uses recursive descent to handle nested structures such as selection sets, list values, and list types. Without a depth limit, a deeply nested query can cause a PHP stack overflow (SIGSEGV) that cannot be caught.

By default, the parser limits recursion depth to 256. This is well above realistic queries (typically 10–20 levels deep) and far below the threshold that would crash PHP.

You can customize the limit through the recursionLimit parser option:

use GraphQL\Language\Parser;

// Custom limit
$ast = Parser::parse($source, ['recursionLimit' => 128]);

// Disable the limit (not recommended for untrusted input)
$ast = Parser::parse($source, ['recursionLimit' => 0]);

The limit is shared across all recursive entry points (parseSelectionSet, parseValueLiteral, parseTypeReference). When exceeded, the parser throws a SyntaxError before the PHP stack overflows.

Query Complexity Analysis

This is a port of Query Complexity Analysis in Sangria.

Complexity analysis is a separate validation rule which calculates query complexity score before execution. Every field in the query gets a default score 1 (including ObjectType nodes). Total complexity of the query is the sum of all field scores. For example, the complexity of introspection query is 109.

If this score exceeds a threshold, a query is not executed and an error is returned instead.

Complexity analysis is disabled by default. You may enable it by setting a maximum query complexity:

use GraphQL\GraphQL;
use GraphQL\Validator\Rules\QueryComplexity;
use GraphQL\Validator\DocumentValidator;

$rule = new QueryComplexity(100);
DocumentValidator::addRule($rule);

GraphQL::executeQuery(/*...*/);

This will set the rule globally. Alternatively, you can provide validation rules per execution.

To customize field score add complexity function to field definition:

use GraphQL\Type\Definition\Type;
use GraphQL\Type\Definition\ObjectType;

$type = new ObjectType([
    'name' => 'MyType',
    'fields' => [
        'someList' => [
            'type' => Type::listOf(Type::string()),
            'args' => [
                'limit' => [
                    'type' => Type::int(),
                    'defaultValue' => 10
                ]
            ],
            'complexity' => fn (int $childrenComplexity, array $args): int => $childrenComplexity * $args['limit'],
        ]
    ]
]);

Limiting Query Depth

This is a port of Limiting Query Depth in Sangria.

This is a simpler approach that limits the nesting depth a query can have. For example, the depth of the default introspection query is 7.

This rule is disabled by default. You may enable it by setting a maximum query depth:

use GraphQL\GraphQL;
use GraphQL\Validator\Rules\QueryDepth;
use GraphQL\Validator\DocumentValidator;

$rule = new QueryDepth(10);
DocumentValidator::addRule($rule);

GraphQL::executeQuery(/*...*/);

This will set the rule globally. Alternatively, you can provide validation rules per execution.

Disabling Introspection

Introspection is a mechanism for fetching schema structure. It is used by tools like GraphiQL for auto-completion, query validation, etc.

Introspection is enabled by default. It means that anybody can get a full description of your schema by sending a special query containing meta fields __type and __schema .

If you are not planning to expose your API to the general public, it makes sense to disable this feature.

GraphQL PHP provides you separate validation rule which prohibits queries that contain __type or __schema fields. To disable introspection, add following rule:

use GraphQL\GraphQL;
use GraphQL\Validator\Rules\DisableIntrospection;
use GraphQL\Validator\DocumentValidator;

$rule = new DisableIntrospection(DisableIntrospection::ENABLED);
DocumentValidator::addRule($rule);

GraphQL::executeQuery(/*...*/);

This will set the rule globally. Alternatively, you can provide validation rules per execution.