Inclusión de Archivos Locales (LFI)

Cómo Funciona Inclusión de Archivos Locales (LFI)

Las vulnerabilidades LFI ocurren cuando las aplicaciones incluyen archivos dinámicamente basándose en entrada controlada por el usuario sin la validación adecuada. El contexto más común son las aplicaciones PHP que usan include(), require(), include_once() o require_once() con nombres de archivo proporcionados por el usuario. Cuando un atacante controla el nombre de archivo pasado a estas funciones, puede incluir cualquier archivo legible en el servidor. La diferencia crítica con el path traversal es que la inclusión puede significar ejecución — si el archivo incluido contiene código PHP válido (incluso incrustado dentro de otro contenido como logs), ese código será ejecutado por el intérprete PHP con los privilegios completos de la aplicación.

Ejemplos Reales

Impacto y Evaluación de Riesgo

La inclusión de archivos locales se clasifica como Crítica porque frecuentemente escala de la lectura de archivos a la ejecución remota de código completa. El impacto inmediato incluye la lectura de archivos de configuración sensibles (credenciales de base de datos, claves API, secretos de cifrado), código fuente de la aplicación, archivos del sistema (/etc/shadow para hashes de contraseñas) y claves privadas. Cuando se escala a ejecución de código mediante envenenamiento de logs, wrappers PHP o inclusión de archivos subidos, el atacante obtiene la capacidad de ejecutar comandos arbitrarios con los privilegios del servidor web, resultando típicamente en el compromiso total del servidor. En entornos contenedorizados, LFI puede exponer variables de entorno que contienen secretos, tokens de cuentas de servicio de Kubernetes y credenciales de metadatos de la nube. La prevalencia de LFI en aplicaciones PHP (que alimentan aproximadamente el 77% de todos los sitios web) la convierte en una de las vulnerabilidades web más comúnmente explotadas.

Cómo Detectar Inclusión de Archivos Locales (LFI)

Monitorear parámetros de solicitudes en busca de indicadores de inclusión de archivos: secuencias de directory traversal (../, ..\), prefijos de wrappers PHP (php://, data://, zip://, phar://), bytes nulos (%00) y referencias a archivos sensibles conocidos (/etc/passwd, /proc/self/environ, win.ini). Analizar los logs del servidor web en busca de cadenas User-Agent sospechosas que contengan código PHP (indicador de envenenamiento de logs). Implementar monitoreo de integridad de archivos en archivos de log del servidor web y directorios de sesión — etiquetas PHP inesperadas en estos archivos indican explotación activa. Desplegar registro a nivel de aplicación que registre todas las operaciones de include/require con la ruta de archivo resuelta, marcando cualquier ruta que se encuentre fuera de la estructura de directorios esperada de la aplicación. Las reglas del WAF deben detectar variantes codificadas de secuencias de traversal y sintaxis de wrappers. La autoprotección de aplicaciones en tiempo de ejecución (RASP) puede interceptar operaciones de archivos en tiempo real, bloqueando inclusiones de archivos fuera de la lista permitida.

Cómo Prevenir Inclusión de Archivos Locales (LFI)

Nunca usar entrada del usuario directamente en funciones de inclusión de archivos. Implementar una lista de permitidos de archivos/módulos autorizados y mapear la entrada del usuario a la lista permitida mediante una tabla de búsqueda (por ejemplo, switch/case o mapeo de diccionario ?page=home a templates/home.php) en lugar de usar la entrada como nombre de archivo. Si la inclusión dinámica de archivos es necesaria, resolver la ruta canónica y verificar que se encuentre dentro del directorio base esperado. Deshabilitar configuraciones peligrosas de PHP: allow_url_include=Off (previene la inclusión remota de archivos), open_basedir para restringir el acceso a archivos al directorio de la aplicación, y disable_functions para system(), exec(), passthru(). Usar un framework moderno que abstraiga la inclusión de archivos detrás de un renderizado de plantillas seguro (Twig, Blade, Jinja2). Mantener PHP y todos los frameworks del lado del servidor actualizados para parchear vulnerabilidades LFI conocidas. Desplegar un WAF con reglas específicas de LFI cubriendo patrones de traversal, wrappers PHP e inyección de bytes nulos. En despliegues contenedorizados, aplicar sistemas de archivos de solo lectura donde sea posible y minimizar los archivos accesibles al proceso de la aplicación.

Ejemplos de Código

<?php
// VULNERABLE: User input directly used in include
$page = $_GET['page'];
include("pages/" . $page . ".php");

// Attacker: ?page=../../../../etc/passwd%00
// Result: includes /etc/passwd (null byte truncates .php on old PHP)

// Attacker: ?page=php://filter/convert.base64-encode/resource=config
// Result: Leaks config.php source code as base64

// Attacker: ?page=../../../../var/log/apache2/access.log
// After poisoning User-Agent with: <?php system($_GET['cmd']); ?>
// Result: Remote code execution via log poisoning
?>

<?php
// SECURE: Map user input to allowed files via allowlist
$allowed_pages = [
    'home'     => 'pages/home.php',
    'about'    => 'pages/about.php',
    'contact'  => 'pages/contact.php',
    'products' => 'pages/products.php',
    'faq'      => 'pages/faq.php',
];

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

// Strict allowlist lookup — no file path manipulation possible
if (!array_key_exists($page, $allowed_pages)) {
    http_response_code(404);
    include('pages/404.php');
    exit;
}

include($allowed_pages[$page]);
?>

import re
import os
from functools import wraps

# LFI attack patterns
LFI_PATTERNS = [
    r'\.\.[\/\\]',                 # Directory traversal
    r'%2e%2e[%2f%5c]',              # URL-encoded traversal
    r'%252e%252e',                   # Double-encoded traversal
    r'php:\/\/',                     # PHP wrapper
    r'data:\/\/',                    # Data wrapper
    r'zip:\/\/',                     # Zip wrapper
    r'phar:\/\/',                    # Phar wrapper
    r'expect:\/\/',                  # Expect wrapper
    r'%00',                          # Null byte
    r'\/etc\/(passwd|shadow|hosts)', # Known sensitive files
    r'\/proc\/self',                 # Process info
    r'\/(var|tmp)\/log',            # Log files
    r'web\.config',                  # IIS config
    r'\.htaccess',                   # Apache config
]

def detect_lfi(request_params):
    """Check request parameters for LFI indicators"""
    compiled = [re.compile(p, re.IGNORECASE) for p in LFI_PATTERNS]
    
    for param_name, param_value in request_params.items():
        decoded = urllib.parse.unquote(urllib.parse.unquote(param_value))
        for pattern in compiled:
            if pattern.search(decoded):
                return {
                    'detected': True,
                    'parameter': param_name,
                    'value': param_value,
                    'pattern': pattern.pattern
                }
    return {'detected': False}

def safe_file_resolve(base_dir, user_input):
    """Safely resolve a file path within a base directory"""
    # Reject any path separators in user input
    if os.sep in user_input or '/' in user_input or '\\' in user_input:
        raise ValueError('Invalid filename: path separators not allowed')
    
    # Resolve canonical path
    resolved = os.path.realpath(os.path.join(base_dir, user_input))
    base_resolved = os.path.realpath(base_dir)
    
    # Verify resolved path is within base directory
    if not resolved.startswith(base_resolved + os.sep):
        raise ValueError('Access denied: path outside base directory')
    
    if not os.path.isfile(resolved):
        raise FileNotFoundError('File not found')
    
    return resolved

Preguntas Frecuentes

Ataques Relacionados