en
Seguridad en APIs GraphQL en 2026: Cómo Prevenir Batching Attacks, Consultas Recursivas y DoS
development

Seguridad en APIs GraphQL en 2026: Cómo Prevenir Batching Attacks, Consultas Recursivas y DoS

Guía técnica de seguridad en APIs GraphQL en 2026: previene ataques de batching, abuso de alias y DoS cíclico con límites de profundidad, costo y blindaje.

Y
Yan ZC
Publicado: October 13, 2026

Cuando los equipos de ingeniería migran de los tradicionales endpoints REST a GraphQL, obtienen una flexibilidad notable en el frontend: eliminan la sobrecarga de datos innecesarios (over-fetching) y condensan múltiples peticiones de red en una única llamada. Sin embargo, esa misma ventaja arquitectónica introduce una superficie de ataque completamente distinta.

En una API REST, el servidor impone la estructura, profundidad y coste computacional de cada petición mediante rutas URL fijas como /usuarios/123/pedidos-recientes. En GraphQL, el cliente determina el grafo de ejecución. Una única solicitud HTTP POST a /graphql puede solicitar cientos de objetos anidados, abusar de los alias de campos para evadir los límites de tasa (rate limits), provocar consultas explosivas a la base de datos mediante relaciones cíclicas en el esquema o ejecutar bucles de mutaciones empaquetadas orientadas al robo de credenciales (credential stuffing).

Las defensas perimetrales tradicionales —como los cortafuegos de aplicaciones web (WAF) basados en URLs y los limitadores de tráfico por dirección IP— son prácticamente ciegas ante las operaciones de GraphQL. Si tu modelo de seguridad trata todas las peticiones a /graphql como simples llamadas HTTP idénticas, tu infraestructura queda expuesta a agotamiento crítico de recursos, Denegación de Servicio (DoS) y vulnerabilidades de control de acceso.

En esta guía técnica analizamos el panorama de amenazas de GraphQL en 2026, explicamos con precisión cómo funcionan los ataques de batching y el abuso de alias, detallamos los algoritmos de profundidad de consulta (query depth) y análisis de coste y complejidad, y proporcionamos configuraciones defensivas verificadas para Apollo Server, GraphQL Yoga, GraphQL Armor y graphql-query-complexity.


Resumen Ejecutivo: Matriz de Amenazas y Defensas en GraphQL

Patrón de Amenaza Mecanismo de Ataque Impacto en Producción Defensa Principal Mitigación en Capas
Batching en Transporte HTTP El cliente envía un arreglo JSON de operaciones ([{query:...}, {query:...}]) Elude rate limits basados en IP; fuerza bruta contra contraseñas o códigos OTP Desactivar batching HTTP (allowBatchedHttpRequests: false) Rate limiting a nivel de operación por token bucket
Abuso de Alias (Multiplexing) El cliente solicita el mismo campo o mutación 500 veces con alias distintos en una sola query Multiplica el trabajo de ejecución dentro de una única solicitud HTTP Limitar el número máximo de alias (maxAliases) Reglas de validación AST y análisis de coste
Consultas Profundas / Cíclicas Explota relaciones bidireccionales en el esquema (autor -> posts -> autor -> posts) Agota la memoria RAM del servidor, bloquea el bucle de eventos y satura conexiones a la BD Límite estático de profundidad (graphql-depth-limit) Desacoplamiento de ciclos y autorización por campo
Consultas de Alta Complejidad Consultas poco profundas que solicitan listas masivas no paginadas (first: 10000) Carga cuadrática en la base de datos, dispersión de resolvers y desbordamiento de memoria Análisis de complejidad y coste (graphql-query-complexity) Paginación forzada estricta (max: 50) y DataLoader
Reconocimiento y Fugas Extracción masiva mediante introspección (__schema, __type) y pistas de autocompletado Mapea mutaciones administrativas ocultas, campos internos y APIs obsoletas Desactivar introspección en producción; bloquear sugerencias de campos Listas blancas de operaciones / Persisted Queries
BOLA / IDOR en Objetos y Campos Manipulación de identificadores en argumentos (userId: "admin") sin validación de propiedad Exposición no autorizada de datos y elevación de privilegios Autorización a nivel de campo y capa de lógica de negocio Políticas centralizadas de acceso (CASL, Oso, ABAC)

1. Por Qué las APIs GraphQL Requieren Controles de Seguridad Específicos

Para proteger una API GraphQL, es fundamental entender por qué fallan los paradigmas de seguridad convencionales de REST. En una arquitectura REST, los equipos de seguridad aplican controles perimetrales a nivel de pasarela:

  • Un límite de 60 peticiones/minuto sobre POST /api/v1/login detiene ataques de fuerza bruta.
  • Un WAF inspecciona la ruta de la URI y el método HTTP para validar privilegios de acceso.
  • El almacenamiento en caché a nivel de ruta protege la base de datos frente a lecturas repetitivas.

En GraphQL, ninguna de estas premisas es válida:

  1. Punto de Entrada Único (/graphql): Prácticamente todas las consultas, mutaciones e introspecciones se canalizan a través de una única URL mediante POST y responden con código 200 OK, incluso cuando ocurren errores de ejecución internos. Un proxy inverso que inspeccione únicamente la URI no puede distinguir una consulta inocente de perfil de usuario de una carga maliciosa diseñada para tumbar la base de datos.
  2. Grafos de Ejecución Definidos por el Cliente: El cliente determina qué resolvers se ejecutan. Un desarrollador puede definir un esquema normal donde un Hilo contiene comentarios, cada comentario tiene un autor y cada autor tiene hilos. Un cliente malicioso puede construir una consulta recursiva arbitraria que obligue al motor a ejecutar millones de operaciones join.
  3. Desconexión entre Transporte y Aplicación: La pasarela HTTP mide solicitudes de red. El servidor GraphQL mide ejecuciones de resolvers. Cuando una sola petición HTTP desencadena 10.000 ejecuciones de resolvers, el limitador de tráfico HTTP queda completamente neutralizado.

GraphQL no es intrínsecamente inseguro. Las vulnerabilidades surgen cuando los desarrolladores exponen el grafo de datos sin implementar validación previa a la ejecución, presupuestos de recursos y autorización granular a nivel de campo.

flowchart LR
    subgraph ClientLayer["1. Petición del Cliente"]
        Req["HTTP POST /graphql<br/>(JSON Simple o Arreglo Batched)"]
    end

    subgraph TransportGateway["2. Controles de Pasarela y Transporte"]
        BatchCheck{"¿Batching HTTP<br/>Permitido?"}
        SizeCheck{"¿Límites de Tamaño<br/>y Tokens Correctos?"}
    end

    subgraph ASTValidation["3. Validación AST Pre-Ejecución"]
        Parse["Parsear Documento a AST"]
        DepthCheck{"¿Profundidad<br/>≤ Máximo Permitido?"}
        CostCheck{"¿Coste de Consulta<br/>≤ Presupuesto?"}
        AliasCheck{"¿Cantidad de Alias<br/>≤ Límite?"}
    end

    subgraph ExecutionLayer["4. Capa de Ejecución y Datos"]
        AuthZ{"¿Autorización de<br/>Campo Válida?"}
        DataLoad["Agrupación con DataLoader<br/>y Resolvers de BD"]
        Resp["Respuesta JSON Sanitizada<br/>(Sin Trazas de Error)"]
    end

    Req --> BatchCheck
    BatchCheck -- "No (Arreglo Rechazado)" --> Err1["400 Bad Request"]
    BatchCheck -- "Sí / Petición Única" --> SizeCheck
    SizeCheck -- "Excedido" --> Err2["413 Payload Too Large"]
    SizeCheck -- "Válido" --> Parse
    Parse --> DepthCheck
    DepthCheck -- "Demasiado Profunda" --> Err3["GraphQLError (Profundidad Excedida)"]
    DepthCheck -- "Pasa" --> CostCheck
    CostCheck -- "Demasiado Costosa" --> Err4["GraphQLError (Coste Excedido)"]
    CostCheck -- "Pasa" --> AliasCheck
    AliasCheck -- "Pasa" --> AuthZ
    AuthZ -- "Permitido" --> DataLoad --> Resp
    AuthZ -- "Denegado" --> Err5["GraphQLError (Acceso Prohibido)"]

2. El Modelo de Amenazas en GraphQL: Qué Buscan los Atacantes

Cuando los auditores de seguridad y actores maliciosos examinan un endpoint GraphQL, suelen explotar cinco características estructurales del lenguaje:

  1. Reconocimiento mediante Introspección: Consultar el meta-esquema (__schema) para descubrir tipos ocultos, mutaciones administrativas no documentadas, consultas obsoletas y relaciones internas.
  2. Cosecha por Sugerencia de Campos (Field Suggestions): Enviar nombres de campos mal escritos deliberadamente (ej. userPasswrd) para que el motor responda con la sugerencia automática: «¿Quiso decir ‘userPassword’?».
  3. Batching de Transporte y Multiplexación: Empaquetar cientos de intentos de inicio de sesión o validación de tokens en una sola solicitud HTTP para eludir cortafuegos perimetrales.
  4. Denegación de Servicio Asimétrica (DoS): Construir consultas diminutas en tamaño de red (ej. 400 bytes) que requieran gigabytes de memoria o minutos de procesamiento en la base de datos para completarse.
  5. Vulnerabilidades de Acceso a Nivel de Objeto (BOLA / IDOR): Alterar identificadores en argumentos (node(id: "UUID") o pedido(id: 1054)) asumiendo que el resolver valida la autenticación del usuario, pero olvida comprobar si dicho usuario es el legítimo propietario de la entidad.

Captura de la documentación oficial OWASP GraphQL Cheat Sheet detallando validación de entrada y prevención de ataques DoS La guía oficial OWASP GraphQL Cheat Sheet define las directrices principales de seguridad, haciendo énfasis en validación de entrada, contención de DoS y control granular de acceso.


3. Ataques de Batching: Transporte HTTP vs. Multiplexación en un Solo Documento

El concepto de ataque de batching suele generar confusión porque abarca dos técnicas técnicamente distintas en el ecosistema GraphQL:

A. Batching en el Transporte HTTP (Arreglos JSON de Operaciones)

Muchos servidores GraphQL (como Apollo Server cuando se configura con allowBatchedHttpRequests: true, o GraphQL Yoga con soporte de lotes) permiten que el cliente envíe un arreglo JSON con múltiples operaciones completas en una sola petición HTTP POST:

[
  {"query": "mutation { login(user: \"admin\", pass: \"123456\") { token } }"},
  {"query": "mutation { login(user: \"admin\", pass: \"password\") { token } }"},
  {"query": "mutation { login(user: \"admin\", pass: \"admin2026\") { token } }"}
]

Si la pasarela API aplica un límite de 100 solicitudes por minuto por IP, un atacante que envíe lotes de 100 consultas por llamada puede probar 10.000 combinaciones de contraseñas en 60 segundos utilizando únicamente 100 peticiones HTTP. La pasarela solo registrará 100 peticiones y no activará ninguna alerta.

En Apollo Server 4, el batching HTTP viene desactivado por defecto (allowBatchedHttpRequests: false). Sin embargo, muchas migraciones desde versiones antiguas o configuraciones personalizadas de Express lo activaron explícitamente sin considerar este vector de riesgo.

B. Múltiples Operaciones en un Mismo Documento vs. Selección de Operación

Según la especificación oficial de GraphQL, un mismo archivo o documento puede contener varias operaciones con nombre:

query ObtenerPerfil { usuario(id: "1") { nombre } }
query ObtenerPedidos { usuario(id: "1") { pedidos { id } } }

Sin embargo, el estándar exige que el cliente envíe el parámetro operationName indicando cuál de ellas debe ejecutarse. Los servidores conformes a la especificación no ejecutan todas las operaciones de forma concurrente, a menos que se utilice un ciclo de ejecución no estándar.


4. Abuso de Alias: Multiplexación de Trabajo dentro de una Única Consulta

Desactivar el batching HTTP previene el envío de arreglos JSON, pero no detiene el abuso de alias. Los alias son una característica nativa de la especificación diseñada para permitir que los clientes renombren campos en la respuesta (por ejemplo, al consultar dos usuarios distintos en la misma llamada).

Los atacantes utilizan los alias para multiplicar cientos o miles de mutaciones o consultas pesadas dentro de una única operación GraphQL estándar y no agrupada en lote:

mutation FuerzaBrutaPIN {
  intento0001: verificarCodigo(codigo: "0001") { valido token }
  intento0002: verificarCodigo(codigo: "0002") { valido token }
  intento0003: verificarCodigo(codigo: "0003") { valido token }
  # ... repetido 500 veces en la misma operación
  intento0500: verificarCodigo(codigo: "0500") { valido token }
}

Por Qué el Abuso de Alias Elude las Defensas Comunes

  1. Es una única petición HTTP: El contador del limitador de tráfico de la pasarela se incrementa en solo una unidad.
  2. Es una única operación GraphQL: Las listas de operaciones permitidas (allowlists) y filtros de recuento detectan una sola mutación legítima.
  3. Sobrecarga de Concurrencia: El motor de GraphQL resuelve concurrentemente los 500 alias. Si cada resolver consulta una base de datos o un servicio de autenticación externo, una sola petición HTTP puede agotar el grupo de conexiones (connection pool) y colapsar la CPU.

Mitigaciones Defensivas para Batching y Alias

  1. Desactivar Batching HTTP: Salvo que tu cliente frontend lo requiera de forma indispensable, mantén esta opción apagada.
  2. Limitar Alias Máximos (maxAliases): Implementa una regla de validación AST (como @escape.tech/graphql-armor-max-aliases) para restringir el número total de alias permitidos por documento (típicamente entre 10 y 20 como máximo).
  3. Limitación de Tasa Basada en Tokens por Resolver: Protege operaciones sensibles (autenticación, validación de códigos SMS, canje de cupones) aplicando limitación dentro de la lógica del resolver, monitorizando la cuenta afectada (nombre de usuario o teléfono) y no solo la dirección IP de origen.

5. Consultas Profundas y Recursivas: La Trampa de los Esquemas Cíclicos

Los esquemas de GraphQL representan grafos interconectados, no árboles planos. En aplicaciones empresariales reales, las entidades suelen vincularse mutuamente de forma circular:

type Usuario {
  id: ID!
  nombre: String!
  articulos: [Articulo!]!
}

type Articulo {
  id: ID!
  titulo: String!
  autor: Usuario!
  comentarios: [Comentario!]!
}

type Comentario {
  id: ID!
  texto: String!
  articulo: Articulo!
  creador: Usuario!
}

Dado que Usuario enlaza con Articulo y Articulo vuelve a enlazar con Usuario, un cliente malicioso puede redactar una consulta recursiva de profundidad extrema:

query AnidacionMaliciosa {
  usuario(id: "1") {
    articulos {
      autor {
        articulos {
          autor {
            articulos {
              autor {
                articulos {
                  titulo
                }
              }
            }
          }
        }
      }
    }
  }
}
flowchart TD
    subgraph CyclicAttack["Abuso de Esquema Cíclico (Multiplicación Exponencial)"]
        U1["Usuario (1 registro)"] --> P1["Artículos (100 registros)"]
        P1 --> U2["Autor (100 registros)"]
        U2 --> P2["Artículos (10.000 registros)"]
        P2 --> U3["Autor (10.000 registros)"]
        U3 --> P3["Artículos (1.000.000 registros)"]
    end

    subgraph DefenseLayer["Capa de Intercepción Defensiva"]
        Limit["Límite de Profundidad (Máx: 5)<br/>La validación AST rechaza la consulta antes de ejecutar"]
        Cost["Análisis de Coste y Complejidad<br/>Rechaza multiplicadores de lista exponenciales"]
    end

    P2 -. "Excede Umbral de Profundidad" .-> Limit
    P3 -. "Aproba Presupuesto Computacional" .-> Cost

El Mecanismo de Agotamiento de Memoria

Si un usuario tiene 100 artículos y cada artículo referencia a un autor con otros 100 artículos, anidar esta consulta únicamente cuatro niveles intenta resolver 100 × 100 × 100 × 100 = 100.000.000 de objetos.

Incluso si utilizas DataLoader para optimizar el acceso a la base de datos, el motor de ejecución de GraphQL debe instanciar, serializar y formatear 100 millones de objetos JSON en la memoria del servidor. El bucle de eventos de Node.js se bloquea por completo, el consumo de RAM supera los límites del motor V8 y el proceso se cae (out of memory).


6. Límites de Profundidad de Consulta: Primera Barrera Estructural

El límite de profundidad de consulta (query depth limiting) es un análisis estático del Árbol de Sintaxis Abstracta (AST) que calcula qué tan anidados están los conjuntos de selección en un documento entrante antes de que se ejecute cualquier resolver o consulta a la base de datos.

Cómo se Calcula la Profundidad

El algoritmo recorre el AST de la consulta:

  • Los campos raíz de la consulta inician con una profundidad de 1.
  • Cada conjunto de selección secundario (child selection set) incrementa la profundidad en 1.
  • Los fragmentos estándar y fragmentos en línea (inline fragments) se aplanan y se incorporan al cómputo.
  • Los campos escalares terminales (como id o nombre) no añaden profundidad adicional.

Implementación Real en Apollo Server 4

Utilizando la librería comunitaria estándar graphql-depth-limit:

import { ApolloServer } from '@apollo/server';
import { startStandaloneServer } from '@apollo/server/standalone';
import depthLimit from 'graphql-depth-limit';
import { typeDefs, resolvers } from './schema.js';

interface ContextValue {
  userId?: string;
}

const server = new ApolloServer<ContextValue>({
  typeDefs,
  resolvers,
  // Establece un límite máximo de profundidad de 6 niveles
  validationRules: [
    depthLimit(6, { ignore: [/_typename$/] }, (profundidades) => {
      // Registro opcional para observabilidad y telemetría
      if (profundidades[''] > 4) {
        console.warn(`[SEGURIDAD] Consulta con profundidad elevada detectada: ${profundidades['']}`);
      }
    }),
  ],
});

const { url } = await startStandaloneServer(server, {
  listen: { port: 4000 },
});

console.log(`🚀 Servidor GraphQL con protección de profundidad listo en: ${url}`);

La Limitación Crítica del Control de Profundidad

Aunque el límite de profundidad es un control indispensable, no puede prevenir por sí solo los ataques de denegación de servicio. Observa la siguiente consulta cuya profundidad es de apenas 2:

query AtaquePocoProfundo {
  usuarios(first: 100000) {
    id
    correo
    hashTarjetaCredito
    biografia
  }
}

Esta consulta tiene una profundidad de 2, por lo que supera holgadamente un límite de profundidad de 6. Sin embargo, solicitar 100.000 usuarios con cuatro campos escalares obliga a la base de datos a recorrer miles de registros y serializar megabytes de datos. Para frenar este tipo de abuso, se requiere Análisis de Complejidad y Coste.


7. Análisis de Complejidad y Coste: Presupuestando el Esfuerzo de Cómputo

El Análisis de Complejidad de Consulta (Query Cost Analysis) determina el peso computacional de una operación inspeccionando los campos, los tipos de datos y los argumentos de paginación antes de permitir la ejecución.

Captura del repositorio oficial de graphql-query-complexity en GitHub mostrando la instalación y configuración de createComplexityRule La librería graphql-query-complexity (creada por slicknode) es la herramienta de referencia para asignar puntuaciones de coste estático basadas en multiplicadores de paginación y pesos de campos.

Principios del Cálculo de Coste

  1. Coste Base Escalar: Los campos escalares básicos (String, Int, Boolean) suelen ponderarse con un coste de 1 (o 0 si proceden directamente del objeto padre en memoria).
  2. Coste por Objeto: Los objetos relacionales que requieren consultas o joins adicionales reciben un peso superior (ej. entre 5 y 10).
  3. Multiplicadores de Lista: Los campos que aceptan parámetros de paginación (como first: N o limit: N) multiplican el coste de todos sus campos dependientes por N.
  4. Presupuesto Máximo de Operación: El servidor fija un umbral de complejidad por consulta (por ejemplo, 1.000 puntos). Si la suma de pesos calculada sobre el AST supera ese límite, la operación se cancela de inmediato sin consultar la base de datos.

Ecuación Conceptual de Coste de Consulta

$$\text{Coste}(\text{Campo}) = \text{CosteBase} + (\text{Multiplicador} \times \sum \text{Coste}(\text{Hijos}))$$

Si una consulta solicita usuarios(first: 50) y cada usuario incluye pedidos(first: 20) con 3 campos escalares cada uno:

$$\text{Coste} = 10 + (50 \times (5 + (20 \times 3))) = 10 + (50 \times 65) = 3.260 \text{ puntos}$$

Si el presupuesto máximo fijado en el servidor es de 1.000 puntos, la consulta es rechazada en menos de 2 milisegundos, protegiendo la infraestructura de ejecutar miles de operaciones innecesarias.

Configuración Práctica con graphql-query-complexity

import { ApolloServer } from '@apollo/server';
import { GraphQLError } from 'graphql';
import {
  getComplexity,
  simpleEstimator,
  fieldExtensionsEstimator,
} from 'graphql-query-complexity';
import { typeDefs, resolvers } from './schema.js';

const PRESUPUESTO_MAXIMO_COMPLEJIDAD = 1000;

const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [
    {
      async requestDidStart() {
        return {
          async didResolveOperation({ request, document, schema }) {
            // Estimar la complejidad antes de que se invoquen los resolvers
            const complejidad = getComplexity({
              schema,
              operationName: request.operationName,
              query: document,
              variables: request.variables,
              estimators: [
                // 1. Leer anotaciones de coste definidas en el esquema
                fieldExtensionsEstimator(),
                // 2. Coste por defecto de 1 para campos convencionales
                simpleEstimator({ defaultComplexity: 1 }),
              ],
            });

            if (complejidad > PRESUPUESTO_MAXIMO_COMPLEJIDAD) {
              throw new GraphQLError(
                `La complejidad de la consulta (${complejidad}) excede el presupuesto máximo permitido de ${PRESUPUESTO_MAXIMO_COMPLEJIDAD}.`,
                {
                  extensions: {
                    code: 'GRAPHQL_QUERY_COMPLEXITY_EXCEEDED',
                    http: { status: 400 },
                    complejidadCalculada: complejidad,
                    presupuestoPermitido: PRESUPUESTO_MAXIMO_COMPLEJIDAD,
                  },
                }
              );
            }
          },
        };
      },
    },
  ],
});

8. Rate Limiting en GraphQL: Más Allá del Conteo de Peticiones por IP

Los limitadores de tasa tradicionales en capas perimetrales (NGINX, Cloudflare o AWS WAF) cuentan solicitudes HTTP por dirección IP (ej. 100 peticiones / 5 minutos). Como hemos visto, este esquema no es adecuado para GraphQL:

  • Un atacante puede consumir miles de unidades de trabajo en base de datos mediante solo 2 peticiones HTTP con abuso de alias.
  • Múltiples usuarios corporativos que navegan bajo la misma dirección IP pública compartida (NAT) se verán bloqueados injustamente durante horas pico.

Estrategias Modernas de Limitación en GraphQL

  1. Limitación de Tasa Basada en Coste (Modelo GitHub): En lugar de contar solicitudes de red, descuenta del saldo del usuario los puntos de complejidad calculados de cada consulta. Por ejemplo, asigna 50.000 puntos por hora a cada cuenta autenticada. Una consulta simple resta 10 puntos, mientras que una consulta analítica compleja resta 1.200 puntos. Los usuarios pagan con su cuota el esfuerzo computacional exacto que exigen al sistema.
  2. Identificadores Criptográficos de Usuario: Aplica el control de tasa según el identificador de usuario (sub del token JWT), ID de organización o API Key en lugar de la IP efímera del cliente.
  3. Limitación Específica en Mutaciones Críticas: Asigna limitadores de ventana deslizante (sliding window) independientes a mutaciones de alto riesgo (recuperarPassword, enviarCodigoSms, procesarPago), con independencia del cupo general de consultas del cliente.

9. Seguridad de la Introspección en Producción: Hechos vs. Mitos

La conveniencia de desactivar o mantener la introspección (__schema y __type) en entornos de producción es uno de los temas más debatidos en arquitectura GraphQL.

Para Qué Sirve la Introspección

La introspección permite a los clientes y herramientas de desarrollo (GraphQL Playground, Apollo Studio, clientes IDE) consultar la estructura del grafo para obtener documentación interactiva y autocompletado de tipos.

La Realidad Técnica sobre Desactivar la Introspección

Desactivar la introspección NO soluciona ninguna vulnerabilidad de fondo. No protege contra inyecciones SQL, controles de acceso rotos, fallos de autorización ni ataques de denegación de servicio. Confiar exclusivamente en desactivar la introspección constituye una falsa sensación de seguridad (security by obscurity).

Los atacantes no dependen exclusivamente de la introspección para comprometer una API:

  • Las aplicaciones web públicas y aplicaciones móviles ya contienen todas las consultas y mutaciones compiladas en sus archivos JavaScript o binarios.
  • Existen herramientas automatizadas (como Clairvoyance o GraphQL-Cop) que reconstruyen el esquema enviando listas de palabras clave (wordlists) aprovechando las sugerencias de campos de GraphQL.

Cuándo y Cómo Restringir la Introspección

En APIs privadas, internas o de consumo exclusivo para aplicaciones corporativas, desactivar la introspección en producción es una medida de defensa en profundidad válida para dificultar el reconocimiento inicial a atacantes oportunistas.

En Apollo Server 4:

const server = new ApolloServer({
  typeDefs,
  resolvers,
  // Desactivar la introspección en entornos de producción
  introspection: process.env.NODE_ENV !== 'production',
});

Bloqueo Obligatorio de Sugerencias de Campos

Si decides restringir la introspección, debes bloquear también las sugerencias de campos. Cuando un cliente envía usuario { passwrd }, el motor de GraphQL responde habitualmente: «No se puede consultar el campo ‘passwrd’ en ‘Usuario’. ¿Quiso decir ‘password’?» Los atacantes alimentan diccionarios automatizados para mapear el esquema completo basándose en estas respuestas. Herramientas de middleware como GraphQL Armor suprimen automáticamente estas sugerencias en producción.


10. Autenticación y Autorización a Nivel de Campo (Prevención de BOLA / IDOR)

En arquitecturas REST, el control de acceso suele aplicarse mediante middlewares de enrutamiento (ej. router.get('/admin/*', verificarAdmin)). En GraphQL, dado que todas las operaciones transitan por un único endpoint, la autorización debe verificarse obligatoriamente a nivel de campo y objeto.

La Vulnerabilidad: BOLA (Broken Object-Level Authorization)

Examina la siguiente consulta para obtener una factura:

query ObtenerFactura {
  factura(id: "INV-99482") {
    id
    montoTotal
    correoCliente
    detallesPago
  }
}

Si el resolver ejecuta directamente db.facturas.buscarPorId(args.id) sin comprobar si context.usuarioActual.id === factura.idPropietario, cualquier usuario autenticado podrá acceder a las facturas de todos los demás clientes simplemente modificando el identificador.

Práctica Defensiva: Autorizar en la Capa de Lógica de Negocio

Nunca confíes en validaciones en el frontend ni en middlewares genéricos de transporte. Verifica los permisos de acceso en el resolver o en la capa de servicios de dominio:

export const resolvers = {
  Query: {
    factura: async (_parent, { id }, context) => {
      // 1. Verificar Autenticación
      if (!context.usuarioActual) {
        throw new GraphQLError('Se requiere autenticación previa.', {
          extensions: { code: 'UNAUTHENTICATED', http: { status: 401 } },
        });
      }

      // 2. Recuperar la entidad desde la fuente de datos
      const factura = await context.dataSources.facturas.buscarPorId(id);
      if (!factura) {
        throw new GraphQLError('Factura no encontrada.', {
          extensions: { code: 'NOT_FOUND', http: { status: 404 } },
        });
      }

      // 3. Aplicar Autorización a Nivel de Objeto (Prevención de BOLA / IDOR)
      const esPropietario = factura.idPropietario === context.usuarioActual.id;
      const esAdmin = context.usuarioActual.roles.includes('ADMIN_FACTURACION');

      if (!esPropietario && !esAdmin) {
        throw new GraphQLError('No tienes permisos para visualizar esta factura.', {
          extensions: { code: 'FORBIDDEN', http: { status: 403 } },
        });
      }

      return factura;
    },
  },
};

11. Persisted Queries y Listas Blancas: La Protección Definitiva

En sistemas con clientes controlados (como aplicaciones web SPA o aplicaciones móviles iOS y Android), la medida de seguridad más efectiva es la implementación de Persisted Queries (Listas Blancas de Operaciones).

flowchart LR
    subgraph BuildTime["1. Fase de Compilación / CI"]
        SourceCode["Código Fuente Frontend<br/>(React / Vue / Swift)"] --> Extract["Extraer Consultas y Mutaciones"]
        Extract --> Hash["Generar Hash SHA-256<br/>ej. 'a8f3...bc91'"]
        Hash --> Manifest["Publicar Manifiesto Aprobado<br/>en Pasarela / Registro Hive"]
    end

    subgraph Runtime["2. Petición en Producción"]
        ClientApp["App Cliente"] -- "POST /graphql<br/>{ docId: 'a8f3...bc91', vars: {...} }" --> Gateway["Pasarela GraphQL"]
    end

    subgraph Enforcement["3. Verificación de Lista Blanca"]
        Gateway --> Lookup{"¿Hash SHA-256<br/>en Manifiesto?"}
        Lookup -- "No (Consulta Desconocida)" --> Reject["403 Forbidden<br/>(Operaciones ad-hoc bloqueadas)"]
        Lookup -- "Sí (Consulta Aprobada)" --> Execute["Ejecutar AST Confiable<br/>desde Memoria"]
    end

Ventajas de las Listas Blancas de Operaciones

  1. Elimina Consultas Ad-Hoc Maliciosas: Los atacantes no pueden enviar consultas profundamente anidadas, bombas de alias ni introspecciones imprevistas. El servidor rechaza de inmediato cualquier consulta que no forme parte del código compilado de la aplicación cliente.
  2. Ahorro Sustancial de Ancho de Banda: En lugar de transmitir documentos GraphQL extensos de varios kilobytes, los dispositivos móviles envían únicamente un identificador hash de 64 caracteres (docId).
  3. Optimización en el Servidor: La pasarela valida y parsea el AST una sola vez al iniciar, eliminando el coste de validación sintáctica en cada petición de red.

12. Blindaje Automatizado en Producción con GraphQL Armor

Para equipos que operan servidores Apollo Server o GraphQL Yoga existentes y requieren una defensa inmediata y robusta sin reescribir manualmente decenas de resolvers, GraphQL Armor (mantenido por Escape Technologies) ofrece un middleware modular y de alto rendimiento.

Captura del portal de documentación de GraphQL Armor mostrando la guía de inicio rápido y configuración en Apollo Server y Yoga GraphQL Armor (@escape.tech/graphql-armor) ofrece una capa de seguridad unificada que incluye límites de profundidad, restricción de alias, límites de tokens y supresión de sugerencias de campos.

Configuración Defensiva Completa: Apollo Server 4 + GraphQL Armor

import { ApolloServer } from '@apollo/server';
import { startStandaloneServer } from '@apollo/server/standalone';
import { ApolloArmor } from '@escape.tech/graphql-armor';
import { typeDefs, resolvers } from './schema.js';

// Inicializar GraphQL Armor con umbrales de seguridad recomendados
const armor = new ApolloArmor({
  // 1. Limitar la profundidad máxima de anidación
  maxDepth: {
    n: 6,
  },
  // 2. Limitar alias por documento para evitar fuerza bruta multiplexada
  maxAliases: {
    n: 15,
  },
  // 3. Evitar sobrecarga en el parser limitando la cantidad total de tokens
  maxTokens: {
    n: 1000,
  },
  // 4. Bloquear el reconocimiento mediante sugerencias de campos en errores
  blockFieldSuggestions: {
    enabled: process.env.NODE_ENV === 'production',
  },
  // 5. Presupuesto máximo de coste de ejecución
  costLimit: {
    maxCost: 1500,
    defaultCost: 1,
    objectCost: 2,
  },
});

// Extraer reglas de validación y plugins de protección
const proteccion = armor.protect();

const server = new ApolloServer({
  typeDefs,
  resolvers,
  // Desactivar batching de arreglos en el transporte HTTP
  allowBatchedHttpRequests: false,
  // Restringir introspección en producción
  introspection: process.env.NODE_ENV !== 'production',
  // Aplicar reglas y plugins defensivos generados por Armor
  ...proteccion,
});

const { url } = await startStandaloneServer(server, {
  listen: { port: 4000 },
});

console.log(`🛡️ API GraphQL protegida y lista en: ${url}`);

13. Comparativa de Herramientas de Seguridad GraphQL en 2026

Herramienta Categoría Capacidades Principales Caso de Uso Óptimo Licencia / Disponibilidad
GraphQL Armor Middleware de Servidor Límites de profundidad, alias, tokens, coste y bloqueo de sugerencias Protección modular e inmediata para Apollo Server y GraphQL Yoga Código Abierto (MIT)
graphql-query-complexity Regla de Validación AST Cálculo estático granular de complejidad y multiplicadores de lista Modelado matemático de presupuestos en backends a medida Código Abierto (MIT)
GraphQL Inspector Linter de CI/CD Detección de cambios disruptivos (breaking changes) y validación de consultas Validación automática en pipelines de GitHub Actions Código Abierto (MIT)
GraphQL Hive Registro y Pasarela Persisted queries, registro de esquemas y analítica a nivel de campo Gobernanza centralizada en arquitecturas federadas Código Abierto / Nivel Gratuito
Escape (Empresarial) DAST / Auditoría Activa Pruebas de penetración automatizadas y detección de fallos de lógica Auditorías de seguridad automatizadas en equipos DevSecOps Comercial SaaS

14. Lista de Control de Seguridad para Producción

Antes de desplegar cualquier API GraphQL en 2026, verifica minuciosamente cada punto de esta lista:

1. Capa de Red y Pasarela HTTP

  • Batching HTTP Desactivado: Verifica que allowBatchedHttpRequests: false esté establecido salvo justificación explícita.
  • Límites en el Cuerpo de la Petición: Restringe el tamaño máximo del payload (ej. 100 KB en body-parser).
  • Políticas CORS y Cabeceras Estrictas: Exige la cabecera Content-Type: application/json para bloquear ataques CSRF desde el navegador.
  • Tiempos de Espera Forzados (Timeouts): Aplica un límite de ejecución de entre 5 y 10 segundos en la pasarela.

2. Validación de AST y Recursos Computacionales

  • Límite de Profundidad Activo: Profundidad máxima configurada entre 5 y 8 para evitar abusos recursivos.
  • Presupuesto de Complejidad Obligatorio: Límite máximo de coste evaluado antes de invocar resolvers.
  • Límite de Alias Máximos: Cantidad de alias restringida (máximo 10–20) para neutralizar multiplexación maliciosa.
  • Paginación Forzada: Todos los campos que devuelven colecciones exigen un límite superior estricto en first o limit (ej. máximo 50 registros).

3. Control de Acceso y Reconocimiento

  • Introspección Restringida: Desactivada en producción o protegida tras autenticación administrativa.
  • Sugerencias de Campos Bloqueadas: Oculta las pistas en las respuestas de error para frenar diccionarios automatizados.
  • Autorización a Nivel de Objeto (BOLA): Cada resolver verifica la propiedad de los datos en la lógica de negocio.
  • Sanitización de Errores Internos: Oculta trazas de error, consultas SQL y detalles del servidor en producción.

4. Protecciones Avanzadas

  • Persisted Queries: Habilita listas blancas de operaciones para clientes móviles y SPAs.
  • Agrupación con DataLoader: Utiliza DataLoader en campos relacionales para evitar el problema de consultas N+1.
  • Auditoría y Telemetría: Registra nombres de operaciones, costes calculados e identidades para detectar anomalías.

15. Vídeo Recomendado: Errores Comunes de Seguridad en GraphQL

Para comprender a fondo los vectores de ataque reales y los errores de configuración más frecuentes en producción, puedes consultar la conferencia técnica de Benjie Gillam (mantenedor de Graphile y colaborador del comité de la GraphQL Foundation):


16. Preguntas Frecuentes (FAQ) sobre Seguridad en GraphQL

¿Desactivar la introspección hace que una API GraphQL sea segura?

No. Desactivar la introspección reduce la visibilidad directa del esquema para atacantes casuales, pero no corrige ninguna vulnerabilidad de fondo. Las aplicaciones cliente públicas ya contienen todas las consultas compiladas, y existen herramientas capaces de reconstruir el esquema mediante sugerencias de campos. La seguridad real requiere límites de profundidad, presupuestos de complejidad y autorización a nivel de campo.

¿Cuál es la diferencia entre profundidad y complejidad de una consulta?

La profundidad (depth) mide cuántos niveles de jerarquía anidada contiene la consulta (ej. usuario -> articulos -> autor tiene una profundidad de 3). La complejidad (complexity) calcula el coste computacional total considerando los pesos de cada campo y los multiplicadores de paginación (ej. usuarios(first: 500) tiene una profundidad baja de 2, pero una complejidad computacional masiva).

¿Cómo aprovechan los atacantes los alias para burlar los límites de peticiones?

En una consulta normal no se puede repetir el mismo campo dos veces. Al asignar alias únicos a cada campo (intento1: login(...), intento2: login(...)), un atacante puede condensar cientos de operaciones en una sola llamada HTTP POST. Como las pasarelas tradicionales solo cuentan peticiones HTTP recibidas, el ataque evade el rate limit salvo que el servidor limite la cantidad máxima de alias permitidos.

¿Puede un WAF convencional proteger adecuadamente una API GraphQL?

Los cortafuegos de aplicaciones web tradicionales inspeccionan rutas URL y parámetros de consulta estándar. Aunque pueden interceptar cadenas típicas de inyección SQL en el cuerpo de la petición, no interpretan el Árbol de Sintaxis Abstracta (AST) de GraphQL, ni calculan la profundidad de las consultas, ni evalúan multiplicadores de listas. Una protección efectiva exige un WAF específico para GraphQL o middlewares integrados como GraphQL Armor.


Conclusión y Próximos Pasos

GraphQL ofrece una flexibilidad extraordinaria para la comunicación entre clientes y servidores modernos, pero esa versatilidad debe acompañarse de controles defensivos deliberados. Confiar exclusivamente en cortafuegos perimetrales o suponer que desactivar la introspección protegerá tu base de datos deja tu infraestructura expuesta a incidentes graves de indisponibilidad y fuga de datos.

Aplicando una estrategia de defensa en profundidad —desactivando el batching HTTP no utilizado, fijando límites de profundidad, presupuestando la complejidad de consulta, restringiendo la cantidad de alias y asegurando la autorización en los resolvers— garantizarás que tu API GraphQL ofrezca un rendimiento excepcional sin comprometer la seguridad en 2026.

Para profundizar en el diseño de arquitecturas backend modernas y seguras, consulta nuestras guías sobre Mejores Frameworks Backend en 2026, Django vs. FastAPI: Arquitectura y Rendimiento y El Lenguaje de Programación Gleam sobre la Máquina Virtual BEAM.

Yan ZC

Yan ZC

Software Developer & Tech Reviewer

Desarrollador de software y analista tecnológico en ToolReview. Pruebo, analizo y documento herramientas de IA y flujos de software. Mi misión es ayudarte a encontrar el stack tecnológico perfecto con reseñas honestas y benchmarks rigurosos.