Ataque XML External Entity (XXE) y Billion Laughs

El ataque de entidad externa XXE o XML es una vulnerabilidad de la aplicación web que afecta a un sitio web que analiza el XML inseguro que maneja el usuario. El ataque XXE, cuando se realiza con éxito, puede revelar archivos locales en el sistema de archivos del sitio web. XXE está destinado a acceder a estos archivos locales confidenciales del sitio web que son vulnerables al análisis inseguro.

Tipos de ataques XXE

1. Recuperación de archivos XXE : como su nombre lo indica, los archivos arbitrarios en el servidor de aplicaciones de una empresa víctima pueden estar expuestos al atacante, si hay un extremo vulnerable XXE en el sistema de destino. Esto se puede llevar a cabo pasando una entidad XML externa en el archivo controlado por el usuario.
2. Blind XXE: Es posible que un sistema de destino no devuelva datos de las entidades colocadas por el atacante aún siendo inseguro y vulnerable a XXE. Esto se hace probando entradas de usuario mal formadas. Estos incluyen la entrada de una longitud mayor a la que espera el sistema, el tipo de datos incorrecto, entidades especiales, etc. La intención es hacer que el sistema falle y verificar si arroja información confidencial en la respuesta de error.
3. XXE a SSRF: incluso si el sistema no devuelve la respuesta con el contenido del archivo local al atacante, el sistema aún puede ser explotado en presencia de un ataque XXE. La entidad puede apuntar a una IP local de la empresa de destino a la que solo pueden acceder sus sitios web/red. Colocar una IP de intranet en la carga XXE hará que la aplicación de destino llame a su punto final local al que el atacante no tendrá acceso de otra manera. Este tipo de ataque se llama SSRF o Server Side Request Forgery.

Análisis XML

XML es uno de los formatos de intercambio de datos más utilizados. Los datos se pueden transferir entre el usuario y el sitio web en formato XML. Considere un sitio web que acepte información del usuario en forma de XML. El XML que se envía al sitio web tiene el siguiente aspecto:

<?xml version="1.0" encoding="ISO-8859-1"?>
<profiles>
  <profile>
    <name> Siva </name>
    <Age> 24 </Age>
    <occupation> Lead </occupation>
  </profile>
  <profile>
    <name> Subbu </name>
    <Age> 25 </Age>
    <occupation> Developer </occupation>
  </profile>
</profiles>

El sitio web acepta este XML, lo analiza, obtiene el nombre, la edad y la ocupación de los registros en el XML de entrada y, a cambio, devuelve una respuesta de los nombres procesados.

XML consiste en un concepto de entidades para referirse a un solo objeto en un documento XML. Una entidad se puede definir en un XML y se puede reutilizar varias veces en el sitio web. Por ejemplo,

<!ENTITY test SYSTEM "https://www.geeksforgeeks.org/DTD.dtd">
<custom>&test;;</custtom>

test se describe como una Entidad en un documento XML y se puede reutilizar en cualquier lugar. También es posible buscar una entidad externa que se refiera a algún sitio web de terceros.

Código para analizar documentos XML

Hay varias bibliotecas de análisis de XML que analizan el documento XML y devuelven un objeto consultable. Por lo general, en Java, XML se analiza de la siguiente manera,

import java.io.File;  
import javax.xml.parsers.DocumentBuilderFactory;  
import org.w3c.dom.NodeList;  
import org.w3c.dom.Node;  
import javax.xml.parsers.DocumentBuilder;  
import org.w3c.dom.Document;  
import org.w3c.dom.Element;  
public class GFGXMLParser 
{ 
public static void main(String[] args)   
{  
  try   
  {  
    File file = new File("/Users/Siva-5136/Downloads/Untrusted.xml");  
    DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();  
    DocumentBuilder db = dbFactory.newDocumentBuilder();  
    Document doc = db.parse(file);    
    NodeList nodeList = doc.getElementsByTagName("userDetails");  
      
    //Set XML XXE Related Properties 
      
      
    for (int ind = 0; ind < nodeList.getLength(); ind++)   
    {  
      Node node = nodeList.item(ind);  
      if(Node.ELEMENT_NODE == node.getNodeType() )
      {
        Element nodeElement = (Element) node;
        System.out.println(nodeElement.getElementsByTagName("uId").item(0).getTextContent());
         System.out.println(nodeElement.getElementsByTagName("uFirstName").item(0).getTextContent());  
      }
    }  
}   
    catch (Throwable e)   
    {  
            System.out.println("Exception Parsing XML ",e);               
    }  
}  
}

Realización del ataque XXE

Considere que el XML de entrada se utiliza de forma controlada. La entrada no se valida y se pasa directamente al analizador XML. El usuario puede intentar cargar el siguiente archivo XML,

<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE name
    <!ELEMENT name ANY >
  <!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
<profiles>
  <profile>
      <name>`&xxe;`</name>
      <address>`test`</address>
  <profile>
</profiles>

Cuando el analizador XML analiza la entrada XML, resuelve la entidad denominada ‘xxe’ según su definición. A partir de la entrada, la entidad XML se define como recurso del sistema » file://etc/passwd» , que es un archivo local confidencial en el servidor de aplicaciones del sitio web. El XML analizado reemplaza la entidad con el contenido de este archivo local confidencial y puede devolverlo al usuario. Esto se denomina ataque de entidad XML.  

Protección contra ataques XXE 

El sitio web debe protegerse de XXE al deshabilitar entidades en el contenido XML generado por el usuario antes de analizarlos. De lo contrario, el sitio web se vuelve vulnerable al ataque XXE y, por lo tanto, puede revelar información privada altamente confidencial al atacante. Hay varias formas de deshabilitar esto en función de la pila de la aplicación y la biblioteca utilizada para analizar el archivo fuente XML.

Casi todos los principales analizadores de XML proporcionan una forma de deshabilitar las entidades externas de XML en el propio analizador de XML. Para el ejemplo de análisis XML anterior, la versión segura del código tiene el siguiente aspecto:

import java.io.File;  
import javax.xml.parsers.DocumentBuilderFactory;  
import org.w3c.dom.NodeList;  
import org.w3c.dom.Node;  
import javax.xml.parsers.DocumentBuilder;  
import org.w3c.dom.Document;  
import org.w3c.dom.Element;  
public class GFGXMLParser 
{ 
public static void main(String[] args)   
{  
  try   
  {  
    File file = new File("/Users/Siva-5136/Downloads/Untrusted.xml");  
    DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();  
    DocumentBuilder db = dbFactory.newDocumentBuilder();  
    Document doc = db.parse(file);    
    NodeList nodeList = doc.getElementsByTagName("userDetails");  
      
    //Set XML XXE Related Properties 
  
    dbFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
     dbFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
     dbFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
  
      
      
    for (int ind = 0; ind < nodeList.getLength(); ind++)   
    {  
      Node node = nodeList.item(ind);  
      if(Node.ELEMENT_NODE == node.getNodeType() )
      {
        Element nodeElement = (Element) node;
        System.out.println(nodeElement.getElementsByTagName("uId").item(0).getTextContent());
         System.out.println(nodeElement.getElementsByTagName("uFirstName").item(0).getTextContent());  
      }
    }  
}   
    catch (Throwable e)   
    {  
        System.out.println("Exception Parsing XML ",e);               
    }  
}  
}

Vulnerabilidades relacionadas 

Otra vulnerabilidad común asociada con el análisis de XML se llama A Billion Laughs Attack. Utiliza una entidad para resolverse cíclicamente, por lo que consume más CPU y provoca un ataque de denegación de servicio. Un ejemplo de carga útil XML que puede causar un ataque XXE es el siguiente:

<?xml version="1.0"?>
<!DOCTYPE lolz [
 <!ENTITY lol "lol">
 <!ELEMENT lolz (#PCDATA)>
 <!ENTITY lol1 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
 <!ENTITY lol2 "&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;">
 <!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
 <!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
 <!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
 <!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
 <!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
 <!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
 <!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
]>
<lolz>&lol9;</lolz>

La entidad sigue resolviéndose a sí misma cíclicamente, lo que ralentiza las requests y provoca un ataque de DOS en la aplicación. Un ataque de mil millones de risas puede deshabilitar completamente DOCTYPE como en el fragmento de código anterior o establecer un límite máximo en la evaluación de entidades.

Impacto de XXE y mil millones de ataques de risas

1. XXE puede causar fugas de información, puede filtrar archivos del sistema que tienen datos críticos.
2. Los datos obtenidos de XXE se pueden usar para apuntar a sitios web en busca de vulnerabilidades adicionales.
3. Mil millones de risas pueden provocar una interrupción del servicio o un ataque de denegación de servicio.