<summary><strong>Aprende a hackear AWS desde cero hasta convertirte en un experto con</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
GraphQL es **destacado** como una **alternativa eficiente** a las API REST, ofreciendo un enfoque simplificado para consultar datos desde el backend. A diferencia de REST, que a menudo requiere numerosas solicitudes en diferentes puntos finales para recopilar datos, GraphQL permite la obtención de toda la información requerida a través de una **sola solicitud**. Esta optimización beneficia significativamente a los desarrolladores al disminuir la complejidad de sus procesos de obtención de datos.
Con la llegada de nuevas tecnologías, incluido GraphQL, también surgen nuevas vulnerabilidades de seguridad. Un punto clave a tener en cuenta es que **GraphQL no incluye mecanismos de autenticación de forma predeterminada**. Es responsabilidad de los desarrolladores implementar dichas medidas de seguridad. Sin una autenticación adecuada, los puntos finales de GraphQL pueden exponer información sensible a usuarios no autenticados, lo que representa un riesgo de seguridad significativo.
Para identificar instancias de GraphQL expuestas, se recomienda la inclusión de rutas específicas en ataques de fuerza bruta de directorios. Estas rutas son:
Identificar instancias de GraphQL abiertas permite examinar las consultas admitidas. Esto es crucial para comprender los datos accesibles a través del punto final. El sistema de introspección de GraphQL facilita esto al detallar las consultas que admite un esquema. Para obtener más información al respecto, consulta la documentación de GraphQL sobre introspección: [**GraphQL: Un lenguaje de consulta para APIs.**](https://graphql.org/learn/introspection/)
La herramienta [**graphw00f**](https://github.com/dolevf/graphw00f) es capaz de detectar qué motor de GraphQL se utiliza en un servidor y luego imprime información útil para el auditor de seguridad.
Para verificar si una URL es un servicio GraphQL, se puede enviar una **consulta universal**, `query{__typename}`. Si la respuesta incluye `{"data": {"__typename": "Query"}}`, confirma que la URL alberga un punto final de GraphQL. Este método se basa en el campo `__typename` de GraphQL, que revela el tipo del objeto consultado.
GraphQL generalmente admite **GET**, **POST** (x-www-form-urlencoded) y **POST**(json). Aunque por seguridad se recomienda permitir solo json para prevenir ataques CSRF.
Para utilizar la introspección y descubrir información del esquema, consulta el campo `__schema`. Este campo está disponible en el tipo raíz de todas las consultas.
Con esta consulta puedes extraer todos los tipos, sus campos y sus argumentos (y el tipo de los argumentos). Esto será muy útil para saber cómo consultar la base de datos.
Si la introspección está habilitada pero la consulta anterior no se ejecuta, intente eliminar las directivas `onOperation`, `onFragment` y `onField` de la estructura de la consulta.
Si la introspección está habilitada, puedes usar [**GraphQL Voyager**](https://github.com/APIs-guru/graphql-voyager) para ver en una interfaz gráfica todas las opciones.
En la introspección puedes encontrar **qué objeto puedes consultar directamente** (porque no puedes consultar un objeto solo porque existe). En la siguiente imagen puedes ver que el "_queryType_" se llama "_Query_" y que uno de los campos del objeto "_Query_" es "_flags_", que también es un tipo de objeto. Por lo tanto, puedes consultar el objeto de la bandera.
Puedes ver que los objetos "_Flags_" están compuestos por **nombre** y **valor**. Luego puedes obtener todos los nombres y valores de las banderas con la consulta:
Si estos objetos no necesitan ningún argumento para buscar, se podría **obtener toda la información de ellos** simplemente **pidiendo** los datos que se desean. En este ejemplo de Internet se podrían extraer los nombres de usuario y contraseñas guardados:
De todos modos, ya sabíamos que, en la sección de [Enumeración Básica](graphql.md#basic-enumeration) se propuso una consulta que nos mostraba toda la información necesaria: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
Ten en cuenta que **descubrí** que podía solicitar los **parámetros** "_**user**_" y "_**password**_" porque si intento buscar algo que no existe (`query={user(uid:1){noExists}}`) obtengo este error:
Si puedes buscar por un tipo de cadena, como: `query={theusers(description: ""){username,password}}` y **buscas una cadena vacía** se volcarán todos los datos. (_Ten en cuenta que este ejemplo no está relacionado con el ejemplo de los tutoriales, para este ejemplo supongamos que puedes buscar usando "**theusers**" por un campo de tipo String llamado "**description**"_).
En esta configuración, una **base de datos** contiene **personas** y **películas**. Las **personas** se identifican por su **correo electrónico** y nombre; las **películas** por su nombre y **calificación**. Las **personas** pueden ser amigas entre sí y también tener películas, lo que indica relaciones dentro de la base de datos.
En la **introspección** puedes encontrar las **mutaciones****declaradas**. En la siguiente imagen, el "_MutationType_" se llama "_Mutation_" y el objeto "_Mutation_" contiene los nombres de las mutaciones (como "_addPerson_" en este caso):
En esta configuración, una **base de datos** contiene **personas** y **películas**. Las **personas** se identifican por su **correo electrónico** y **nombre**; las **películas** por su **nombre** y **calificación**. Las **personas** pueden ser amigas entre sí y también tener películas, lo que indica relaciones dentro de la base de datos.
Una mutación para **crear nuevas** películas dentro de la base de datos puede ser como la siguiente (en este ejemplo, la mutación se llama `addMovie`):
Además, la base de datos admite una operación de **mutación**, llamada `addPerson`, que permite la creación de **personas** junto con sus asociaciones a **amigos** y **películas** existentes. Es crucial tener en cuenta que los amigos y las películas deben existir previamente en la base de datos antes de vincularlos a la persona recién creada.
Como se explica en [**uno de los fallos descritos en este informe**](https://www.landh.tech/blog/20240304-google-hack-50000/), una sobrecarga de directivas implica llamar a una directiva incluso millones de veces para hacer que el servidor pierda operaciones hasta que sea posible realizar un ataque de denegación de servicio (DoS).
Autenticación a través de la API de GraphQL con **el envío simultáneo de muchas consultas con diferentes credenciales** para verificarla. Es un ataque clásico de fuerza bruta, pero ahora es posible enviar más de un par de inicio de sesión/contraseña por solicitud HTTP debido a la función de lotes de GraphQL. Este enfoque engañaría a las aplicaciones externas de monitoreo de velocidad para que crean que todo está bien y que no hay un bot de fuerza bruta intentando adivinar contraseñas.
A continuación, puedes encontrar la demostración más simple de una solicitud de autenticación de aplicación, con **3 pares de correo electrónico/contraseña diferentes a la vez**. Obviamente, es posible enviar miles en una sola solicitud de la misma manera:
Como podemos ver en la captura de pantalla de la respuesta, las primeras y terceras solicitudes devolvieron _null_ y reflejaron la información correspondiente en la sección de _error_. La **segunda mutación tenía los datos de autenticación correctos** y la respuesta tenía el token de sesión de autenticación correcto.
Cada vez más **los puntos finales de GraphQL están deshabilitando la introspección**. Sin embargo, los errores que GraphQL arroja cuando recibe una solicitud inesperada son suficientes para que herramientas como [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) puedan recrear la mayor parte del esquema.
Además, la extensión de Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observa las solicitudes de API de GraphQL que pasan por Burp** y **construye** un esquema interno de GraphQL **con cada nueva consulta que ve**. También puede exponer el esquema para GraphiQL y Voyager. La extensión devuelve una respuesta falsa cuando recibe una consulta de introspección. Como resultado, GraphQuail muestra todas las consultas, argumentos y campos disponibles para su uso dentro de la API. Para más información, [**consultar aquí**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
Una **lista de palabras** útil para descubrir [**entidades de GraphQL se puede encontrar aquí**](https://github.com/Escape-Technologies/graphql-wordlist?).
### Eludir las defensas de introspección de GraphQL <a href="#bypassing-graphql-introspection-defences" id="bypassing-graphql-introspection-defences"></a>
Para eludir las restricciones en las consultas de introspección en las APIs, insertar un **carácter especial después de la palabra clave `__schema`** resulta efectivo. Este método explota descuidos comunes de los desarrolladores en patrones de regex que buscan bloquear la introspección al enfocarse en la palabra clave `__schema`. Al agregar caracteres como **espacios, saltos de línea y comas**, que GraphQL ignora pero que quizás no se tengan en cuenta en las regex, se pueden eludir las restricciones. Por ejemplo, una consulta de introspección con un salto de línea después de `__schema` puede eludir tales defensas:
Si no tiene éxito, considere métodos de solicitud alternativos, como **solicitudes GET** o **POST con `x-www-form-urlencoded`**, ya que las restricciones pueden aplicarse solo a las solicitudes POST.
Cuando la introspección está deshabilitada, examinar el código fuente del sitio web en busca de consultas precargadas en bibliotecas de JavaScript es una estrategia útil. Estas consultas se pueden encontrar utilizando la pestaña `Sources` en las herramientas para desarrolladores, lo que proporciona información sobre el esquema de la API y revela posibles **consultas sensibles expuestas**. Los comandos para buscar dentro de las herramientas para desarrolladores son:
Por lo tanto, dado que las solicitudes CSRF como las anteriores se envían **sin solicitudes de preflight**, es posible **realizar****cambios** en el GraphQL abusando de un CSRF.
Sin embargo, ten en cuenta que el nuevo valor de cookie predeterminado de la bandera `samesite` de Chrome es `Lax`. Esto significa que la cookie solo se enviará desde un sitio web de terceros en solicitudes GET.
Ten en cuenta que generalmente es posible enviar la **solicitud** de **consulta** también como una solicitud **GET y el token CSRF podría no ser validado en una solicitud GET.**
Además, abusando de un ataque [**XS-Search**](../../pentesting-web/xs-search/) podría ser posible exfiltrar contenido del punto final de GraphQL abusando de las credenciales del usuario.
Modificar las variables de entrada de la consulta podría llevar a la filtración de detalles de cuenta sensibles [filtrados](https://hackerone.com/reports/792927).
En el siguiente ejemplo, se puede ver que la operación es "forgotPassword" y que solo debería ejecutar la consulta forgotPassword asociada. Esto se puede saltar agregando una consulta al final, en este caso agregamos "register" y una variable de usuario para que el sistema se registre como un nuevo usuario.
En GraphQL, los alias son una característica poderosa que permite **nombrar explícitamente propiedades** al hacer una solicitud de API. Esta capacidad es particularmente útil para recuperar **múltiples instancias del mismo tipo** de objeto dentro de una sola solicitud. Los alias se pueden utilizar para superar la limitación que impide que los objetos GraphQL tengan múltiples propiedades con el mismo nombre.
Para comprender detalladamente los alias en GraphQL, se recomienda el siguiente recurso: [Aliases](https://portswigger.net/web-security/graphql/what-is-graphql#aliases).
Si bien el propósito principal de los alias es reducir la necesidad de numerosas llamadas a la API, se ha identificado un caso de uso no previsto donde los alias se pueden aprovechar para ejecutar ataques de fuerza bruta en un punto final de GraphQL. Esto es posible porque algunos puntos finales están protegidos por limitadores de velocidad diseñados para evitar ataques de fuerza bruta restringiendo el **número de solicitudes HTTP**. Sin embargo, estos limitadores de velocidad pueden no tener en cuenta el número de operaciones dentro de cada solicitud. Dado que los alias permiten la inclusión de múltiples consultas en una sola solicitud HTTP, pueden eludir tales medidas de limitación de velocidad.
Considere el siguiente ejemplo que ilustra cómo las consultas con alias se pueden utilizar para verificar la validez de códigos de descuento de tienda. Este método podría evitar los límites de velocidad ya que recopila varias consultas en una sola solicitud HTTP, lo que potencialmente permite verificar numerosos códigos de descuento simultáneamente.
* [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Kit que se puede utilizar para obtener esquemas y buscar datos sensibles, probar autorización, forzar esquemas y encontrar rutas hacia un tipo dado.
* [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Se puede utilizar de forma independiente o como [extensión de Burp](https://github.com/doyensec/inql).
* [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Se puede utilizar como cliente CLI también para automatizar ataques.
* [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Herramienta que lista las diferentes formas de llegar a un tipo dado en un esquema de GraphQL.
* [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Extensión de Burp para pruebas avanzadas de GraphQL. El _**Escáner**_ es el núcleo de InQL v5.0, donde puedes analizar un punto final de GraphQL o un archivo de esquema de introspección local. Genera automáticamente todas las consultas y mutaciones posibles, organizándolas en una vista estructurada para su análisis. El componente _**Atacante**_ te permite ejecutar ataques de GraphQL por lotes, lo que puede ser útil para evadir límites de velocidad implementados de manera deficiente.
<summary><strong>Aprende a hackear AWS desde cero hasta experto con</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
