mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/network-services-pentesting/pentesting-web/graphql.md']
This commit is contained in:
Translator
parent
b15740f09b
commit
b77d7b225e
@ -23,7 +23,7 @@ Um exponierte GraphQL-Instanzen zu identifizieren, wird empfohlen, spezifische P
|
||||
- `/graphql/api`
|
||||
- `/graphql/graphql`
|
||||
|
||||
Die Identifizierung offener GraphQL-Instanzen ermöglicht die Untersuchung der unterstützten Abfragen. Dies ist entscheidend für das Verständnis der über den Endpunkt zugänglichen Daten. Das Introspektionssystem von GraphQL erleichtert dies, indem es die Abfragen detailliert, die ein Schema unterstützt. Für weitere Informationen dazu siehe die GraphQL-Dokumentation zur Introspektion: [**GraphQL: Eine Abfragesprache für APIs.**](https://graphql.org/learn/introspection/)
|
||||
Die Identifizierung offener GraphQL-Instanzen ermöglicht die Untersuchung der unterstützten Abfragen. Dies ist entscheidend, um die über den Endpunkt zugänglichen Daten zu verstehen. Das Introspektionssystem von GraphQL erleichtert dies, indem es die Abfragen detailliert, die ein Schema unterstützt. Für weitere Informationen hierzu siehe die GraphQL-Dokumentation zur Introspektion: [**GraphQL: Eine Abfragesprache für APIs.**](https://graphql.org/learn/introspection/)
|
||||
|
||||
### Fingerabdruck
|
||||
|
||||
@ -41,7 +41,7 @@ Graphql unterstützt normalerweise **GET**, **POST** (x-www-form-urlencoded) und
|
||||
|
||||
#### Introspektion
|
||||
|
||||
Um Introspektion zu verwenden, um Schema-Informationen zu entdecken, abfragen Sie das Feld `__schema`. Dieses Feld ist auf dem Wurzeltyp aller Abfragen verfügbar.
|
||||
Um Introspektion zu verwenden, um Schema-Informationen zu entdecken, fragen Sie das Feld `__schema` ab. Dieses Feld ist auf dem Wurzeltyp aller Abfragen verfügbar.
|
||||
```bash
|
||||
query={__schema{types{name,fields{name}}}}
|
||||
```
|
||||
@ -162,25 +162,25 @@ Inline-Introspektionsanfrage:
|
||||
```
|
||||
/?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}+}
|
||||
```
|
||||
Die letzte Codezeile ist eine GraphQL-Abfrage, die alle Metainformationen aus dem GraphQL (Objektnamen, Parameter, Typen...) ausgibt.
|
||||
Die letzte Codezeile ist eine GraphQL-Abfrage, die alle Metainformationen aus der GraphQL-Datenbank (Objektnamen, Parameter, Typen...) ausgibt.
|
||||
|
||||
.png>)
|
||||
|
||||
Wenn die Introspektion aktiviert ist, können Sie [**GraphQL Voyager**](https://github.com/APIs-guru/graphql-voyager) verwenden, um in einer GUI alle Optionen anzuzeigen.
|
||||
Wenn die Introspektion aktiviert ist, kannst du [**GraphQL Voyager**](https://github.com/APIs-guru/graphql-voyager) verwenden, um in einer GUI alle Optionen anzuzeigen.
|
||||
|
||||
### Abfragen
|
||||
|
||||
Jetzt, da wir wissen, welche Art von Informationen in der Datenbank gespeichert ist, lassen Sie uns versuchen, **einige Werte zu extrahieren**.
|
||||
Jetzt, da wir wissen, welche Art von Informationen in der Datenbank gespeichert ist, lass uns versuchen, **einige Werte zu extrahieren**.
|
||||
|
||||
In der Introspektion können Sie **sehen, welches Objekt Sie direkt abfragen können** (weil Sie ein Objekt nicht nur abfragen können, weil es existiert). Im folgenden Bild sehen Sie, dass der "_queryType_" "_Query_" genannt wird und dass eines der Felder des "_Query_"-Objekts "_flags_" ist, das ebenfalls ein Objekttyp ist. Daher können Sie das Flag-Objekt abfragen.
|
||||
In der Introspektion kannst du **sehen, welches Objekt du direkt abfragen kannst** (weil du ein Objekt nicht nur abfragen kannst, weil es existiert). Im folgenden Bild siehst du, dass der "_queryType_" "_Query_" genannt wird und dass eines der Felder des "_Query_"-Objekts "_flags_" ist, das ebenfalls ein Objekttyp ist. Daher kannst du das Flag-Objekt abfragen.
|
||||
|
||||
|
||||
|
||||
Beachten Sie, dass der Typ der Abfrage "_flags_" "_Flags_" ist, und dieses Objekt ist wie folgt definiert:
|
||||
Beachte, dass der Typ der Abfrage "_flags_" "_Flags_" ist, und dieses Objekt wie folgt definiert ist:
|
||||
|
||||
.png>)
|
||||
|
||||
Sie können sehen, dass die "_Flags_"-Objekte aus **name** und **value** bestehen. Dann können Sie alle Namen und Werte der Flags mit der Abfrage erhalten:
|
||||
Du kannst sehen, dass die "_Flags_"-Objekte aus **name** und **value** bestehen. Dann kannst du alle Namen und Werte der Flags mit der Abfrage erhalten:
|
||||
```javascript
|
||||
query={flags{name, value}}
|
||||
```
|
||||
@ -188,11 +188,11 @@ Beachten Sie, dass Sie im Falle, dass das **Objekt, das abgefragt werden soll**,
|
||||
|
||||
.png>)
|
||||
|
||||
einfach damit abfragen können:
|
||||
einfach abfragen können mit:
|
||||
```javascript
|
||||
query = { hiddenFlags }
|
||||
```
|
||||
In einem anderen Beispiel, in dem es 2 Objekte im Typ "_Query_" gab: "_user_" und "_users_".\
|
||||
In einem anderen Beispiel, in dem es 2 Objekte im Typ-Objekt "_Query_" gab: "_user_" und "_users_".\
|
||||
Wenn diese Objekte keine Argumente benötigen, um zu suchen, könnte man **alle Informationen von ihnen abrufen**, indem man einfach nach den gewünschten Daten fragt. In diesem Beispiel aus dem Internet könnte man die gespeicherten Benutzernamen und Passwörter extrahieren:
|
||||
|
||||
.png>)
|
||||
@ -204,14 +204,14 @@ Wenn man jedoch in diesem Beispiel versucht, dies zu tun, erhält man diesen **F
|
||||
Es scheint, dass es irgendwie mit dem Argument "_**uid**_" vom Typ _**Int**_ suchen wird.\
|
||||
Wie auch immer, das wussten wir bereits, im Abschnitt [Basic Enumeration](graphql.md#basic-enumeration) wurde eine Abfrage vorgeschlagen, die uns alle benötigten Informationen zeigte: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
|
||||
|
||||
Wenn du das Bild liest, das bereitgestellt wurde, als ich diese Abfrage ausgeführt habe, wirst du sehen, dass "_**user**_" das **arg** "_**uid**_" vom Typ _Int_ hatte.
|
||||
Wenn du das Bild liest, das ich bereitgestellt habe, wirst du sehen, dass "_**user**_" das **arg** "_**uid**_" vom Typ _Int_ hatte.
|
||||
|
||||
Durch einige leichte _**uid**_-Bruteforce fand ich heraus, dass bei _**uid**=**1**_ ein Benutzername und ein Passwort abgerufen wurden:\
|
||||
Durch einige leichte _**uid**_ Bruteforce fand ich heraus, dass bei _**uid**=**1**_ ein Benutzername und ein Passwort abgerufen wurden:\
|
||||
`query={user(uid:1){user,password}}`
|
||||
|
||||
.png>)
|
||||
|
||||
Beachte, dass ich **entdeckt** habe, dass ich nach den **Parametern** "_**user**_" und "_**password**_" fragen konnte, denn wenn ich versuche, nach etwas zu suchen, das nicht existiert (`query={user(uid:1){noExists}}`), erhalte ich diesen Fehler:
|
||||
Beachte, dass ich **entdeckte**, dass ich nach den **Parametern** "_**user**_" und "_**password**_" fragen konnte, denn wenn ich versuche, nach etwas zu suchen, das nicht existiert (`query={user(uid:1){noExists}}`), erhalte ich diesen Fehler:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -221,7 +221,7 @@ Und während der **Enumeration-Phase** entdeckte ich, dass das Objekt "_**dbuser
|
||||
|
||||
Wenn du nach einem String-Typ suchen kannst, wie: `query={theusers(description: ""){username,password}}` und du **nach einem leeren String** suchst, wird es **alle Daten dumpen**. (_Beachte, dass dieses Beispiel nicht mit dem Beispiel der Tutorials zusammenhängt, für dieses Beispiel gehe davon aus, dass du mit "**theusers**" nach einem String-Feld namens "**description**" suchen kannst_).
|
||||
|
||||
### Suche
|
||||
### Suchen
|
||||
|
||||
In diesem Setup enthält eine **Datenbank** **Personen** und **Filme**. **Personen** werden durch ihre **E-Mail** und **Namen** identifiziert; **Filme** durch ihren **Namen** und **Bewertung**. **Personen** können Freunde miteinander sein und auch Filme haben, was Beziehungen innerhalb der Datenbank anzeigt.
|
||||
|
||||
@ -304,7 +304,7 @@ rating
|
||||
```
|
||||
**Beachten Sie, wie sowohl die Werte als auch der Datentyp in der Abfrage angegeben sind.**
|
||||
|
||||
Zusätzlich unterstützt die Datenbank eine **Mutation**-Operation, die `addPerson` genannt wird, die die Erstellung von **Personen** zusammen mit ihren Verbindungen zu bestehenden **Freunden** und **Filmen** ermöglicht. Es ist wichtig zu beachten, dass die Freunde und Filme bereits in der Datenbank vorhanden sein müssen, bevor sie mit der neu erstellten Person verknüpft werden.
|
||||
Zusätzlich unterstützt die Datenbank eine **Mutation**-Operation, die `addPerson` genannt wird, die die Erstellung von **Personen** zusammen mit ihren Assoziationen zu bestehenden **Freunden** und **Filmen** ermöglicht. Es ist wichtig zu beachten, dass die Freunde und Filme bereits in der Datenbank vorhanden sein müssen, bevor sie mit der neu erstellten Person verknüpft werden.
|
||||
```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"}]) {
|
||||
@ -339,7 +339,7 @@ Wie in [**einer der Schwachstellen, die in diesem Bericht beschrieben sind**](ht
|
||||
### Batching brute-force in 1 API request
|
||||
|
||||
Diese Informationen stammen von [https://lab.wallarm.com/graphql-batching-attack/](https://lab.wallarm.com/graphql-batching-attack/).\
|
||||
Authentifizierung über die GraphQL-API mit **gleichzeitigem Senden vieler Abfragen mit unterschiedlichen Anmeldeinformationen**, um dies zu überprüfen. Es handelt sich um einen klassischen Brute-Force-Angriff, aber jetzt ist es möglich, mehr als ein Login/Passwort-Paar pro HTTP-Anfrage zu senden, dank der GraphQL-Batching-Funktion. Dieser Ansatz würde externe Rate-Überwachungsanwendungen täuschen, indem er denkt, dass alles in Ordnung ist und kein Brute-Forcing-Bot versucht, Passwörter zu erraten.
|
||||
Authentifizierung über die GraphQL API mit **gleichzeitigem Senden vieler Abfragen mit unterschiedlichen Anmeldeinformationen**, um dies zu überprüfen. Es handelt sich um einen klassischen Brute-Force-Angriff, aber jetzt ist es möglich, mehr als ein Login/Passwort-Paar pro HTTP-Anfrage zu senden, dank der GraphQL-Batching-Funktion. Dieser Ansatz würde externe Rate-Überwachungsanwendungen dazu bringen zu glauben, dass alles in Ordnung ist und kein Brute-Forcing-Bot versucht, Passwörter zu erraten.
|
||||
|
||||
Unten finden Sie die einfachste Demonstration einer Anwendungsauthentifizierungsanfrage, mit **3 verschiedenen E-Mail/Passwort-Paaren gleichzeitig**. Offensichtlich ist es möglich, Tausende in einer einzigen Anfrage auf die gleiche Weise zu senden:
|
||||
|
||||
@ -353,7 +353,7 @@ Wie wir aus dem Screenshot der Antwort sehen können, gaben die erste und die dr
|
||||
|
||||
Immer mehr **GraphQL-Endpunkte deaktivieren die Introspektion**. Die Fehler, die GraphQL wirft, wenn eine unerwartete Anfrage empfangen wird, sind jedoch ausreichend für Tools wie [**clairvoyance**](https://github.com/nikitastupin/clairvoyance), um den größten Teil des Schemas zu rekonstruieren.
|
||||
|
||||
Darüber hinaus beobachtet die Burp Suite-Erweiterung [**GraphQuail**](https://github.com/forcesunseen/graphquail) **GraphQL-API-Anfragen, die durch Burp gehen**, und **baut** mit jeder neuen Abfrage, die sie sieht, ein internes GraphQL-**Schema** auf. Es kann auch das Schema für GraphiQL und Voyager offenlegen. Die Erweiterung gibt eine gefälschte Antwort zurück, wenn sie eine Introspektionsanfrage erhält. Infolgedessen zeigt GraphQuail alle Abfragen, Argumente und Felder an, die innerhalb der API verfügbar sind. Für weitere Informationen [**überprüfen Sie dies**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
|
||||
Darüber hinaus beobachtet die Burp Suite-Erweiterung [**GraphQuail**](https://github.com/forcesunseen/graphquail) **GraphQL API-Anfragen, die durch Burp gehen**, und **baut** ein internes GraphQL-**Schema** mit jeder neuen Abfrage, die sie sieht. Es kann auch das Schema für GraphiQL und Voyager offenlegen. Die Erweiterung gibt eine gefälschte Antwort zurück, wenn sie eine Introspektionsanfrage erhält. Infolgedessen zeigt GraphQuail alle Abfragen, Argumente und Felder, die innerhalb der API verfügbar sind. Für weitere Informationen [**überprüfen Sie dies**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
|
||||
|
||||
Eine schöne **Wortliste**, um [**GraphQL-Entitäten zu entdecken, finden Sie hier**](https://github.com/Escape-Technologies/graphql-wordlist?).
|
||||
|
||||
@ -367,7 +367,7 @@ Um Einschränkungen bei Introspektionsanfragen in APIs zu umgehen, erweist sich
|
||||
{queryType{name}}}"
|
||||
}
|
||||
```
|
||||
Wenn dies nicht erfolgreich ist, ziehen Sie alternative Anforderungsmethoden in Betracht, wie **GET-Anfragen** oder **POST mit `x-www-form-urlencoded`**, da Einschränkungen möglicherweise nur für POST-Anfragen gelten.
|
||||
Wenn nicht erfolgreich, ziehen Sie alternative Anforderungsmethoden in Betracht, wie **GET-Anfragen** oder **POST mit `x-www-form-urlencoded`**, da Einschränkungen möglicherweise nur für POST-Anfragen gelten.
|
||||
|
||||
### Versuchen Sie WebSockets
|
||||
|
||||
@ -411,7 +411,7 @@ Wenn Sie nicht wissen, was CSRF ist, lesen Sie die folgende Seite:
|
||||
../../pentesting-web/csrf-cross-site-request-forgery.md
|
||||
{{#endref}}
|
||||
|
||||
Dort draußen werden Sie mehrere GraphQL-Endpunkte finden, **die ohne CSRF-Token konfiguriert sind.**
|
||||
Dort draußen werden Sie mehrere GraphQL-Endpunkte finden, die **ohne CSRF-Token konfiguriert sind.**
|
||||
|
||||
Beachten Sie, dass GraphQL-Anfragen normalerweise über POST-Anfragen mit dem Content-Type **`application/json`** gesendet werden.
|
||||
```javascript
|
||||
@ -423,17 +423,17 @@ query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
|
||||
```
|
||||
Daher ist es möglich, **Änderungen** in der GraphQL vorzunehmen, indem man eine CSRF ausnutzt, da CSRF-Anfragen wie die vorherigen **ohne Preflight-Anfragen** gesendet werden.
|
||||
|
||||
Beachten Sie jedoch, dass der neue Standardwert des Cookie-Werts des `samesite`-Flags von Chrome `Lax` ist. Das bedeutet, dass das Cookie nur von einer Drittanbieter-Website in GET-Anfragen gesendet wird.
|
||||
Beachten Sie jedoch, dass der neue Standardwert des Cookies für das `samesite`-Flag von Chrome `Lax` ist. Das bedeutet, dass das Cookie nur von einer Drittanbieter-Website in GET-Anfragen gesendet wird.
|
||||
|
||||
Es ist zu beachten, dass es normalerweise möglich ist, die **Abfrage** **Anfrage** auch als **GET** **Anfrage** zu senden und das CSRF-Token möglicherweise in einer GET-Anfrage nicht validiert wird.
|
||||
|
||||
Außerdem könnte es möglich sein, durch einen [**XS-Search**](../../pentesting-web/xs-search/index.html) **Angriff** Inhalte vom GraphQL-Endpunkt zu exfiltrieren, indem man die Anmeldeinformationen des Benutzers ausnutzt.
|
||||
|
||||
Für weitere Informationen **überprüfen Sie den** [**originalen Beitrag hier**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).
|
||||
Für weitere Informationen **überprüfen Sie** [**den ursprünglichen Beitrag hier**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).
|
||||
|
||||
## Cross-Site WebSocket-Hijacking in GraphQL
|
||||
## Cross-Site-WebSocket-Hijacking in GraphQL
|
||||
|
||||
Ähnlich wie bei CRSF-Schwachstellen, die GraphQL ausnutzen, ist es auch möglich, ein **Cross-Site WebSocket-Hijacking durchzuführen, um eine Authentifizierung mit GraphQL mit ungeschützten Cookies auszunutzen** und einen Benutzer dazu zu bringen, unerwartete Aktionen in GraphQL auszuführen.
|
||||
Ähnlich wie bei CRSF-Schwachstellen, die GraphQL ausnutzen, ist es auch möglich, ein **Cross-Site-WebSocket-Hijacking durchzuführen, um eine Authentifizierung mit GraphQL mit ungeschützten Cookies auszunutzen** und einen Benutzer dazu zu bringen, unerwartete Aktionen in GraphQL auszuführen.
|
||||
|
||||
Für weitere Informationen überprüfen Sie:
|
||||
|
||||
@ -471,7 +471,7 @@ Für ein detailliertes Verständnis von GraphQL-Aliassen wird die folgende Resso
|
||||
|
||||
Während der Hauptzweck von Aliassen darin besteht, die Notwendigkeit für zahlreiche API-Aufrufe zu reduzieren, wurde ein unbeabsichtigter Anwendungsfall identifiziert, bei dem Aliasse genutzt werden können, um Brute-Force-Angriffe auf einen GraphQL-Endpunkt durchzuführen. Dies ist möglich, weil einige Endpunkte durch Ratenbegrenzer geschützt sind, die darauf ausgelegt sind, Brute-Force-Angriffe zu verhindern, indem sie die **Anzahl der HTTP-Anfragen** einschränken. Diese Ratenbegrenzer berücksichtigen jedoch möglicherweise nicht die Anzahl der Operationen innerhalb jeder Anfrage. Da Aliasse die Einbeziehung mehrerer Abfragen in einer einzigen HTTP-Anfrage ermöglichen, können sie solche Ratenbegrenzungsmaßnahmen umgehen.
|
||||
|
||||
Betrachten Sie das unten angegebene Beispiel, das veranschaulicht, wie aliierte Abfragen verwendet werden können, um die Gültigkeit von Rabattcodes im Geschäft zu überprüfen. Diese Methode könnte Ratenbegrenzungen umgehen, da sie mehrere Abfragen in einer HTTP-Anfrage zusammenfasst, was möglicherweise die Überprüfung zahlreicher Rabattcodes gleichzeitig ermöglicht.
|
||||
Betrachten Sie das unten angegebene Beispiel, das veranschaulicht, wie aliierte Abfragen verwendet werden können, um die Gültigkeit von Rabattcodes im Geschäft zu überprüfen. Diese Methode könnte die Ratenbegrenzung umgehen, da sie mehrere Abfragen in einer HTTP-Anfrage zusammenfasst, was möglicherweise die Überprüfung zahlreicher Rabattcodes gleichzeitig ermöglicht.
|
||||
```bash
|
||||
# Example of a request utilizing aliased queries to check for valid discount codes
|
||||
query isValidDiscount($code: Int) {
|
||||
@ -490,14 +490,14 @@ valid
|
||||
|
||||
### Alias Overloading
|
||||
|
||||
**Alias Overloading** ist eine GraphQL-Sicherheitsanfälligkeit, bei der Angreifer eine Abfrage mit vielen Aliasen für dasselbe Feld überlasten, was dazu führt, dass der Backend-Resolver dieses Feld wiederholt ausführt. Dies kann die Serverressourcen überlasten und zu einer **Denial of Service (DoS)** führen. Zum Beispiel wird im folgenden Query dasselbe Feld (`expensiveField`) 1.000 Mal mit Aliasen angefordert, was den Backend zwingt, es 1.000 Mal zu berechnen, was potenziell die CPU oder den Speicher erschöpfen kann:
|
||||
**Alias Overloading** ist eine GraphQL-Sicherheitsanfälligkeit, bei der Angreifer eine Abfrage mit vielen Aliasen für dasselbe Feld überladen, was dazu führt, dass der Backend-Resolver dieses Feld wiederholt ausführt. Dies kann die Serverressourcen überlasten und zu einem **Denial of Service (DoS)** führen. Zum Beispiel wird im folgenden Query dasselbe Feld (`expensiveField`) 1.000 Mal mit Aliasen angefordert, was den Backend zwingt, es 1.000 Mal zu berechnen, was möglicherweise die CPU oder den Speicher erschöpft:
|
||||
```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'
|
||||
```
|
||||
Um dies zu mildern, implementieren Sie Alias-Zählgrenzen, eine Analyse der Abfragekomplexität oder eine Ratenbegrenzung, um den Missbrauch von Ressourcen zu verhindern.
|
||||
Um dies zu mildern, implementieren Sie Alias-Zählgrenzen, Abfragekomplexitätsanalysen oder Ratenbegrenzungen, um Ressourcenmissbrauch zu verhindern.
|
||||
|
||||
### **Array-basierte Abfrage-Batching**
|
||||
|
||||
@ -513,7 +513,7 @@ In diesem Beispiel werden 10 verschiedene Abfragen in einer Anfrage gebündelt,
|
||||
|
||||
### **Directive Overloading Vulnerability**
|
||||
|
||||
**Directive Overloading** tritt auf, wenn ein GraphQL-Server Abfragen mit übermäßigen, duplizierten Direktiven zulässt. Dies kann den Parser und den Executor des Servers überwältigen, insbesondere wenn der Server wiederholt dieselbe Direktivenlogik verarbeitet. Ohne angemessene Validierung oder Grenzen kann ein Angreifer dies ausnutzen, indem er eine Abfrage mit zahlreichen duplizierten Direktiven erstellt, um eine hohe Rechen- oder Speichernutzung auszulösen, was zu **Denial of Service (DoS)** führt.
|
||||
**Directive Overloading** tritt auf, wenn ein GraphQL-Server Abfragen mit übermäßigen, duplizierten Direktiven zulässt. Dies kann den Parser und Executor des Servers überwältigen, insbesondere wenn der Server wiederholt dieselbe Direktivenlogik verarbeitet. Ohne angemessene Validierung oder Grenzen kann ein Angreifer dies ausnutzen, indem er eine Abfrage mit zahlreichen duplizierten Direktiven erstellt, um eine hohe Rechen- oder Speichernutzung auszulösen, was zu **Denial of Service (DoS)** führt.
|
||||
```bash
|
||||
# Test provided by https://github.com/dolevf/graphql-cop
|
||||
curl -X POST -H "User-Agent: graphql-cop/1.13" \
|
||||
@ -521,7 +521,7 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" \
|
||||
-d '{"query": "query cop { __typename @aa@aa@aa@aa@aa@aa@aa@aa@aa@aa }", "operationName": "cop"}' \
|
||||
'https://example.com/graphql'
|
||||
```
|
||||
Beachten Sie, dass `@aa` im vorherigen Beispiel eine benutzerdefinierte Direktive ist, die **möglicherweise nicht deklariert ist**. Eine gängige Direktive, die normalerweise vorhanden ist, ist **`@include`**:
|
||||
Beachten Sie, dass im vorherigen Beispiel `@aa` eine benutzerdefinierte Direktive ist, die **möglicherweise nicht deklariert ist**. Eine gängige Direktive, die normalerweise vorhanden ist, ist **`@include`**:
|
||||
```bash
|
||||
curl -X POST \
|
||||
-H "Content-Type: application/json" \
|
||||
@ -550,7 +550,7 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
|
||||
|
||||
### Schwachstellenscanner
|
||||
|
||||
- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testet gängige Fehlkonfigurationen von GraphQL-Endpunkten
|
||||
- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testen von häufigen Fehlkonfigurationen von GraphQL-Endpunkten
|
||||
- [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): GraphQL-Sicherheitsprüfskript mit Fokus auf das Durchführen von Batch-GraphQL-Abfragen und -Mutationen.
|
||||
- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Fingerabdruck des verwendeten GraphQL
|
||||
- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Toolkit, das verwendet werden kann, um Schemata zu erfassen und nach sensiblen Daten zu suchen, Autorisierungen zu testen, Schemata zu brute-forcen und Pfade zu einem bestimmten Typ zu finden.
|
||||
@ -561,6 +561,10 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
|
||||
- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Burp-Erweiterung oder Python-Skript für fortgeschrittene GraphQL-Tests. Der _**Scanner**_ ist der Kern von InQL v5.0, wo Sie einen GraphQL-Endpunkt oder eine lokale Introspektionsschema-Datei analysieren können. Er generiert automatisch alle möglichen Abfragen und Mutationen und organisiert sie in einer strukturierten Ansicht für Ihre Analyse. Die _**Attacker**_-Komponente ermöglicht es Ihnen, Batch-GraphQL-Angriffe durchzuführen, die nützlich sein können, um schlecht implementierte Ratenlimits zu umgehen: `python3 inql.py -t http://example.com/graphql -o output.json`
|
||||
- [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Versuchen Sie, das Schema selbst bei deaktivierter Introspektion zu erhalten, indem Sie die Hilfe einiger GraphQL-Datenbanken in Anspruch nehmen, die die Namen von Mutationen und Parametern vorschlagen.
|
||||
|
||||
### Skripte zur Ausnutzung häufiger Schwachstellen
|
||||
|
||||
- [https://github.com/reycotallo98/pentestScripts/tree/main/GraphQLDoS](https://github.com/reycotallo98/pentestScripts/tree/main/GraphQLDoS): Sammlung von Skripten zur Ausnutzung von Denial-of-Service-Schwachstellen in anfälligen GraphQL-Umgebungen.
|
||||
|
||||
### Clients
|
||||
|
||||
- [https://github.com/graphql/graphiql](https://github.com/graphql/graphiql): GUI-Client
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user