**A maior parte desta seção foi retirada desta página incrível da Portswigger:** [**https://portswigger.net/web-security/xxe/xml-entities**](https://portswigger.net/web-security/xxe/xml-entities)
XML significa "extensible markup language". XML é uma linguagem projetada para armazenar e transportar dados. Como o HTML, o XML usa uma estrutura em forma de árvore de tags e dados. Ao contrário do HTML, o XML não usa tags predefinidas, e as tags podem receber nomes que descrevem os dados. No início da história da web, o XML estava na moda como formato de transporte de dados (o "X" em "AJAX" significa "XML"). Mas sua popularidade agora diminuiu em favor do formato JSON.
As entidades XML são uma maneira de representar um item de dados dentro de um documento XML, em vez de usar os dados em si. Várias entidades são incorporadas à especificação da linguagem XML. Por exemplo, as entidades `<` e `>` representam os caracteres `<` e `>`. Esses são metacaracteres usados para denotar tags XML e, portanto, geralmente devem ser representados usando suas entidades quando aparecem dentro de dados.
As declarações de tipo de elemento definem as regras para o tipo e número de elementos que podem aparecer em um documento XML, quais elementos podem aparecer dentro de outros e em que ordem devem aparecer. Por exemplo:
A definição de tipo de documento XML (DTD) contém declarações que podem definir a estrutura de um documento XML, os tipos de valores de dados que ele pode conter e outros itens. A DTD é declarada dentro do elemento `DOCTYPE` opcional no início do documento XML. A DTD pode ser totalmente autocontida dentro do próprio documento (conhecida como "DTD interna") ou pode ser carregada de outro lugar (conhecida como "DTD externa") ou pode ser híbrida das duas.
Essa definição significa que qualquer uso da referência de entidade `&myentity;` dentro do documento XML será substituído pelo valor definido: "`my entity value`".
A declaração de uma entidade externa usa a palavra-chave `SYSTEM` e deve especificar uma URL da qual o valor da entidade deve ser carregado. Por exemplo:
As entidades externas XML fornecem o principal meio pelo qual surgem os ataques de [entidade externa XML (XXE)](https://portswigger.net/web-security/xxe).
Às vezes, ataques XXE usando entidades regulares são bloqueados, devido a alguma validação de entrada pela aplicação ou alguma proteção do analisador XML que está sendo usado. Nessa situação, você pode ser capaz de usar entidades de parâmetro XML em vez disso. As entidades de parâmetro XML são um tipo especial de entidade XML que só pode ser referenciada em outro lugar dentro da DTD. Para fins presentes, você só precisa saber duas coisas. Primeiro, a declaração de uma entidade de parâmetro XML inclui o caractere de porcentagem antes do nome da entidade:
Esta carga útil XXE declara uma entidade de parâmetro XML chamada `xxe` e, em seguida, usa a entidade dentro da DTD. Isso causará uma pesquisa DNS e uma solicitação HTTP ao domínio do atacante, verificando que o ataque foi bem-sucedido.
[A maioria desses ataques foi testada usando os incríveis laboratórios XEE da Portswiggers: https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)
Em aplicações baseadas em **Java**, pode ser possível **listar o conteúdo de um diretório** via XXE com um payload como este (apenas solicitando o diretório em vez do arquivo):
Usando a **técnica comentada anteriormente** você pode fazer o servidor acessar um servidor que você controla para mostrar que ele é vulnerável. Mas, se isso não estiver funcionando, talvez seja porque **as entidades XML não são permitidas**, nesse caso você pode tentar usar **entidades de parâmetros XML**:
**Nesta ocasião, vamos fazer com que o servidor carregue um novo DTD com uma carga maliciosa que enviará o conteúdo de um arquivo via solicitação HTTP (para arquivos de várias linhas, você pode tentar exfiltrá-lo via** _**ftp://**_**). Esta explicação foi retirada do** [**laboratório Portswiggers aqui**](https://portswigger.net/web-security/xxe/blind)**.**
* Define uma entidade de parâmetro XML chamada `file`, contendo o conteúdo do arquivo `/etc/passwd`.
* Define uma entidade de parâmetro XML chamada `eval`, contendo uma declaração dinâmica de outra entidade de parâmetro XML chamada `exfiltrate`. A entidade `exfiltrate` será avaliada fazendo uma solicitação HTTP ao servidor web do atacante contendo o valor da entidade `file` dentro da string de consulta da URL.
* Usa a entidade `eval`, o que faz com que a declaração dinâmica da entidade `exfiltrate` seja executada.
* Usa a entidade `exfiltrate`, para que seu valor seja avaliado solicitando a URL especificada.
O atacante deve então hospedar a DTD maliciosa em um sistema que ele controle, normalmente carregando-a em seu próprio servidor web. Por exemplo, o atacante pode servir a DTD maliciosa na seguinte URL:\
Este payload XXE declara uma entidade de parâmetro XML chamada `xxe` e, em seguida, usa a entidade dentro do DTD. Isso fará com que o analisador XML busque o DTD externo no servidor do atacante e o interprete inline. As etapas definidas dentro do DTD malicioso são então executadas e o arquivo `/etc/passwd` é transmitido para o servidor do atacante.
**Neste caso, vamos fazer com que o servidor carregue um DTD malicioso que mostrará o conteúdo de um arquivo dentro de uma mensagem de erro (isso só é válido se você puder ver mensagens de erro).** [**Exemplo daqui.**](https://portswigger.net/web-security/xxe/blind)
Você pode acionar uma mensagem de erro de análise XML contendo o conteúdo do arquivo `/etc/passwd` usando um DTD externo malicioso da seguinte maneira:
* Define uma entidade de parâmetro XML chamada `file`, contendo o conteúdo do arquivo `/etc/passwd`.
* Define uma entidade de parâmetro XML chamada `eval`, contendo uma declaração dinâmica de outra entidade de parâmetro XML chamada `error`. A entidade `error` será avaliada carregando um arquivo inexistente cujo nome contém o valor da entidade `file`.
* Usa a entidade `eval`, o que faz com que a declaração dinâmica da entidade `error` seja executada.
* Usa a entidade `error`, de modo que seu valor seja avaliado tentando carregar o arquivo inexistente, resultando em uma mensagem de erro contendo o nome do arquivo inexistente, que é o conteúdo do arquivo `/etc/passwd`.
_**Observe que o DTD externo nos permite incluir uma entidade dentro da segunda (****`eval`****), mas é proibido no DTD interno. Portanto, você não pode forçar um erro sem usar um DTD externo (geralmente).**_
E quanto às vulnerabilidades cegas XXE quando as interações **fora de banda são bloqueadas** (conexões externas não estão disponíveis)? [Informações daqui](https://portswigger.net/web-security/xxe/blind).
Nessa situação, ainda pode ser possível **disparar mensagens de erro contendo dados sensíveis**, devido a uma brecha na especificação da linguagem XML. Se o DTD de um documento usa uma **combinação de declarações DTD internas e externas**, então o **DTD interno pode redefinir entidades que são declaradas no DTD externo**. Quando isso acontece, a restrição de usar uma entidade de parâmetro XML dentro da definição de outra entidade de parâmetro é relaxada.
Isso significa que um atacante pode empregar a técnica XXE baseada em erro de dentro de um DTD interno, desde que a entidade de parâmetro XML que eles usam esteja **redefinindo uma entidade que é declarada dentro de um DTD externo**. Claro, se as conexões fora de banda estiverem bloqueadas, o DTD externo não pode ser carregado de um local remoto. Em vez disso, ele precisa ser um **arquivo DTD externo que esteja local no servidor de aplicativos**. _Essencialmente, o ataque envolve invocar um arquivo DTD que acontece de existir no sistema de arquivos local e reutilizá-lo para redefinir uma entidade existente de uma maneira que dispara um erro de análise contendo dados sensíveis._
Por exemplo, suponha que haja um arquivo DTD no sistema de arquivos do servidor no local `/usr/local/app/schema.dtd`, e este arquivo DTD define uma entidade chamada `custom_entity`. Um atacante pode disparar uma mensagem de erro de análise XML contendo o conteúdo do arquivo `/etc/passwd` enviando um DTD híbrido como o seguinte:
* Define uma entidade de parâmetro XML chamada `local_dtd`, contendo o conteúdo do arquivo DTD externo que existe no sistema de arquivos do servidor.
* Redefine a entidade de parâmetro XML chamada `custom_entity`, que já está definida no arquivo DTD externo. A entidade é redefinida como contendo o [exploit XXE baseado em erro](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages) que já foi descrito, para disparar uma mensagem de erro contendo o conteúdo do arquivo `/etc/passwd`.
* Usa a entidade `local_dtd`, para que o DTD externo seja interpretado, incluindo o valor redefinido da entidade `custom_entity`. Isso resulta na mensagem de erro desejada.
**Exemplo do mundo real:** Sistemas que usam o ambiente de desktop GNOME frequentemente têm um DTD em `/usr/share/yelp/dtd/docbookx.dtd` contendo uma entidade chamada `ISOamso`.
Como essa técnica usa um **DTD interno, você precisa encontrar um válido primeiro**. Você pode fazer isso **instalando** o mesmo **SO / Software** que o servidor está usando e **procurando alguns DTDs padrão**, ou **obtendo uma lista** de **DTDs padrão** dentro dos sistemas e **verificando** se algum deles existe:
Além disso, se você tiver a **imagem Docker do sistema da vítima**, você pode usar a ferramenta do mesmo repositório para **escanear** a **imagem** e **encontrar** o caminho dos **DTDs** presentes dentro do sistema. Leia o [Readme do Github](https://github.com/GoSecure/dtd-finder) para aprender como fazer isso.
Muitas aplicações web permitem que você faça upload de documentos do Microsoft Office e, em seguida, analisam alguns detalhes deles. Por exemplo, você pode ter uma aplicação web que permite importar dados fazendo upload de uma planilha no formato XLSX. Em algum momento, para que o analisador extraia os dados da planilha, o analisador precisará **analisar pelo menos um arquivo XML**.
A única maneira de testar isso é gerar um **arquivo do Microsoft Office que contenha uma carga útil XXE**, então vamos fazer isso. Primeiro, crie um diretório vazio para descompactar o documento e descompacte-o!
Abra o arquivo `./unzipped/word/document.xml` no seu editor de texto favorito (vim) e edite o **XML para incluir sua carga útil XXE favorita**. A primeira coisa que eu tento geralmente é uma solicitação HTTP, como esta:
Essas linhas devem ser inseridas entre os dois objetos XML raiz, como este exemplo, e é claro que você precisará substituir a URL por uma URL que possa monitorar as solicitações:
Tudo o que resta é **compactar o arquivo para criar seu arquivo malicioso poc.docx**. A partir do diretório "descompactado" que criamos anteriormente, execute o seguinte:
Agora, faça upload do arquivo para sua aplicação web (esperançosamente) vulnerável e reze para os deuses do hacking por uma solicitação em seus logs do Burp Collaborator.
O protocolo `jar` está disponível apenas em **aplicações Java**. Ele permite acessar arquivos dentro de um arquivo **PKZIP** (`.zip`, `.jar`, ...) e funciona para arquivos locais e remotos:
Ser capaz de acessar arquivos dentro de arquivos PKZIP é **super útil para abusar do XXE via arquivos DTD do sistema.** Verifique [esta seção para aprender como abusar de arquivos DTD do sistema](xxe-xee-xml-external-entity.md#error-based-system-dtd).
Observe que é possível interromper o fluxo na segunda etapa. O truque é nunca fechar a conexão ao servir o arquivo. [Esta ferramenta pode ser útil](https://github.com/GoSecure/xxe-workshop/tree/master/24\_write\_xxe/solution): uma em python `slow_http_server.py` e outra em java `slowserver.jar`.
Depois que o servidor baixou seu arquivo, você precisa encontrar sua localização navegando no diretório temporário. Sendo aleatório, o caminho do arquivo não pode ser previsto com antecedência.
Escrever arquivos em um diretório temporário pode ajudar a **escalar outra vulnerabilidade que envolve uma travessia de caminho** (como inclusão de arquivo local, injeção de modelo, RCE XSLT, desserialização, etc).
Algumas aplicações **recebem dados enviados pelo cliente, incorporam-nos no lado do servidor em um documento XML e, em seguida, analisam o documento**. Um exemplo disso ocorre quando os dados enviados pelo cliente são colocados em uma **solicitação SOAP de backend**, que é então processada pelo serviço SOAP de backend.
Nessa situação, você não pode realizar um ataque XXE clássico, porque **não controla todo o XML** e, portanto, não pode definir ou modificar um elemento `DOCTYPE`. No entanto, você pode ser capaz de usar `XInclude` em vez disso. `XInclude` é uma parte da especificação XML que permite que um documento XML seja construído a partir de subdocumentos. Você pode colocar um ataque `XInclude` em qualquer valor de dados em um documento XML, portanto, o ataque pode ser realizado em situações em que você controla apenas um único item de dados que é colocado em um documento XML do lado do servidor.
Para realizar um ataque `XInclude`, você precisa fazer referência ao namespace `XInclude` e fornecer o caminho para o arquivo que deseja incluir. Por exemplo:
Algumas aplicações permitem que os usuários façam upload de arquivos que são processados no lado do servidor. Alguns formatos de arquivo comuns usam XML ou contêm subcomponentes XML. Exemplos de formatos baseados em XML são formatos de documentos de escritório como DOCX e formatos de imagem como SVG.
Por exemplo, uma aplicação pode permitir que os usuários **façam upload de imagens** e processem ou validem essas imagens no servidor após o upload. Mesmo que a aplicação espere receber um formato como PNG ou JPEG, a **biblioteca de processamento de imagem que está sendo usada pode suportar imagens SVG**. Como o formato SVG usa XML, um atacante pode enviar uma imagem SVG maliciosa e, assim, alcançar uma superfície de ataque oculta para vulnerabilidades XXE.
**Observação: A primeira linha do arquivo lido ou do resultado da execução aparecerá DENTRO da imagem criada. Portanto, você precisa ser capaz de acessar a imagem que o SVG criou.**
Se uma solicitação POST aceita os dados no formato XML, você pode tentar explorar um XXE nessa solicitação. Por exemplo, se uma solicitação normal contém o seguinte:
Para alterar a requisição, você pode usar uma extensão do Burp chamada "**Content Type Converter**". [Aqui](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) você pode encontrar um exemplo disso:
Você pode usar a \[**"Receita de Codificação**" do CyberChef aqui ]\(\[[https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28%27UTF-7%20%2865000%29%27%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) para transformar em UTF-7.
Se o site estiver usando PHP, em vez de usar `file:/`, você pode usar **envolvedores php**`php://filter/convert.base64-encode/resource=` para **acessar arquivos internos**.
Truque de [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
Você pode criar uma **entidade dentro de uma entidade** codificando-a com **entidades HTML** e depois chamá-la para **carregar um dtd**.\
Observe que as **Entidades HTML** usadas precisam ser **numéricas** (como \[neste exemplo]\([https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,%27Numeric%20entities%27%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B\)%5C)).
SOAP (Simple Object Access Protocol) é um protocolo baseado em XML usado para acessar serviços web. Ele usa XML para codificar sua mensagem e geralmente é transportado usando HTTP.
Uma vulnerabilidade comum em serviços SOAP é a Injeção de Entidade Externa XML (XEE). Isso ocorre quando o serviço não valida adequadamente as entradas XML recebidas, permitindo que um invasor injete uma entidade externa maliciosa que pode ser usada para ler arquivos do sistema ou executar código arbitrário.
Para explorar essa vulnerabilidade, um invasor pode enviar uma solicitação SOAP contendo uma entidade externa maliciosa, como a seguinte:
Nesse exemplo, a entidade externa `xxe` é definida como o conteúdo do arquivo `/etc/passwd`. Quando a solicitação é processada pelo serviço, o conteúdo do arquivo `/etc/passwd` é incluído na resposta SOAP, permitindo que o invasor leia informações confidenciais do sistema.
Para evitar essa vulnerabilidade, é importante validar adequadamente todas as entradas XML recebidas pelo serviço e restringir o acesso a recursos do sistema.
Esta seção foi retirada de [https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe](https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe)\
De acordo com a [Wikipedia](https://en.wikipedia.org/wiki/XLIFF):
> XLIFF (XML Localization Interchange File Format) é um formato de bitexto baseado em XML criado para padronizar a forma como os dados localizáveis são passados entre e entre ferramentas durante um processo de localização e um formato comum para a troca de ferramentas CAT.
{"status":500,"error":"Internal Server Error","message":"Error systemId: http://redacted.burpcollaborator.net/?xxe_test; The markup declarations contained or pointed to by the document type declaration must be well-formed."}
Com base no User Agent exibido pelo burp collaborator, parece que ele está usando **Java 1.8**. Um dos problemas ao explorar XXE nesta versão do Java é que **não conseguimos obter arquivos contendo uma `Nova Linha`** como `/etc/passwd` usando a técnica Out of Band.
O ataque de Entidade Externa XML (XXE) pode ser usado para ler arquivos do sistema de arquivos do servidor. Para fazer isso, o atacante precisa criar um arquivo XML malicioso que contenha uma referência a um arquivo no sistema de arquivos do servidor. Quando o servidor processa o arquivo XML, ele tenta resolver a referência do arquivo e, se bem-sucedido, o conteúdo do arquivo é retornado na resposta.
O resultado da solicitação incluirá o conteúdo do arquivo `/etc/passwd`. Esse tipo de ataque pode ser usado para obter informações confidenciais, como senhas de usuário e chaves de API.
XMLDecoder é uma classe Java que cria objetos com base em uma mensagem XML. Se um usuário mal-intencionado conseguir fazer com que um aplicativo use dados arbitrários em uma chamada ao método **readObject**, ele instantaneamente ganhará execução de código no servidor.
O `ProcessBuilder` é uma classe Java que permite executar comandos em um novo processo. É comumente usado para executar comandos do sistema operacional, como `ls` ou `dir`. No entanto, também pode ser usado para executar comandos personalizados.
Um exemplo de uso do `ProcessBuilder` é executar um comando que lê um arquivo XML e imprime seu conteúdo no console. No entanto, se o arquivo XML contiver uma entidade externa, o `ProcessBuilder` pode ser usado para explorar uma vulnerabilidade de Injeção de Entidade Externa (XXE).
Para explorar essa vulnerabilidade, o atacante pode criar um arquivo XML malicioso que contenha uma entidade externa que aponte para um arquivo no sistema do alvo. Quando o comando é executado pelo `ProcessBuilder`, a entidade externa é resolvida e o conteúdo do arquivo é incluído na saída do comando. Isso pode permitir que o atacante leia arquivos confidenciais no sistema do alvo.
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
