A injeção de XML é a manipulação da entrada de XML para alterar a forma como um aplicativo analisa ou interpreta os dados. Ela ocorre quando a entrada controlada pelo usuário é inserida em um documento XML sem a devida validação, permitindo que os invasores injetem nós, atributos, entidades ou cargas úteis que modificam o fluxo de controle, ignoram a lógica ou acionam comportamentos perigosos do analisador. Nos ecossistemas atuais de APIs pesadas e orientadas para a integração, a injeção de XML continua sendo uma ameaça real que as equipes de segurança não podem ignorar.

Diferentemente da simples adulteração de entrada, a injeção de XML explora o poder expressivo do próprio XML, afetando sistemas complexos, incluindo SOAP, SAML, dispositivos IoT, integrações empresariais e sistemas financeiros legados.

Por que a injeção de XML ainda é importante

Embora o JSON domine os aplicativos modernos, o XML está profundamente incorporado ao software corporativo, aos protocolos de autenticação e às integrações de back-end. Os invasores podem abusar das estruturas XML para:

• Alterar a lógica comercial
• Injetar nós não autorizados
• Manipular consultas XPath
• Acionar a divulgação de arquivos no estilo XXE
• Interromper a validação do esquema
• Causa de negação de serviço baseada em XML

A flexibilidade do XML torna seu uso indevido particularmente poderoso.

Exemplo real de CVE: CVE-2025-13526

O CVE-2025-13526 demonstra como uma simples configuração incorreta de análise de XML pode levar à divulgação completa do arquivo. O sistema permitiu o upload de arquivos de configuração XML, mas não conseguiu desativar a resolução de entidades externas.

Exemplo de carga útil maliciosa:

xml

<!DOCTYPE data [

]>

&xxe;

O servidor retornou o conteúdo de /etc/passwdmostrando como a injeção de XML combinada com o XXE pode expor arquivos críticos.

Superfícies de ataque da injeção de XML

Abuso dos atacantes:

• Injeção de nós
• Injeção de atributos
• Manipulação de consultas XPath
• Manipulação do esquema (XSD)
• Cargas úteis XXE
• Expansão da entidade para DoS
• Bypass lógico dentro de fluxos de trabalho baseados em XML

Cada categoria afeta uma camada diferente do sistema.

Exemplos de ataque (mesma quantidade preservada)

1. Manipulação de injeção de nós

xml

Produto A

Carga útil injetada:

pgsql

verdadeiro

O XML resultante fica estruturalmente corrompido e pode conceder privilégios não autorizados.

Injeção de XPath

python

query = f"//users/user[username/text()='{user}']"

Entrada maliciosa:

bash

' ou '1'='1

Isso expõe registros de usuários não autorizados.

XXE Carga útil

xml

<!DOCTYPE foo [

]>&payload;

Manipulação de esquemas

xml

<xs:element name="amount" type="xs:string"/>

Isso desativa o comportamento de validação esperado.

Billion Laughs DoS

xml

<!ENTITY a "ha"><!ENTITY b "&a;&a;"><!ENTITY c "&b;&b;">

A expansão maciça sobrecarrega o analisador.

Técnicas defensivas

Desativar a resolução de entidades

python

parser = etree.XMLParser(resolve_entities=False, no_network=True)

Use bibliotecas seguras

python

importar defusedxml.ElementTree como ET

Forte validação do esquema

python

schema.validate(input_xml)

Nunca concatenar cadeias de caracteres XML

Abordagem mais segura:

python

el = Element("user") name_tag.text = user_input

Tabela de comparação

Tipo	Alvo	Gravidade	Impacto
Injeção de XML	Manipulação de estrutura	Médio-Alto	Bypass lógico
Injeção de XPath	Controle de consulta	Alta	Acesso não autorizado
XXE	Uso indevido do analisador	Alta	Leitura de arquivo / SSRF
Injeção de esquema	Desvio de validação	Médio	Riscos de integridade

Injeção de XML em testes automatizados de penetração

As modernas plataformas de teste de penetração orientadas por IA, como a Penligent, realizam mutação de estrutura, fuzzing XML, teste de carga útil XPath e detecção de configuração incorreta do analisador. Essas plataformas:

• Descubra superfícies de ataque baseadas em XML
• Identificar pontos de injeção
• Aprendizado automático do comportamento do esquema
• Gerar cargas úteis adaptáveis
• Validar o comportamento do analisador em várias configurações

Isso amplia significativamente a cobertura de detecção.

Linhas de base de segurança e recomendações de correções automatizadas

As plataformas automatizadas também podem fornecer:

• Auditorias de configuração do analisador
• Detecção de bibliotecas XML inseguras
• Verificação das configurações de resolução de entidades
• Aplicação de validação XSD rigorosa
• Bloqueio de CI/CD de operações XML inseguras

Isso transforma a detecção em correção acionável.

Script para exemplo

Regras do Semgrep - injeção de XML em Python / XXE / análise insegura

Criar um arquivo:

semgrep-rules/python-xml-injection.yaml

yaml

`regras:

REGRA 1: Uso inseguro de xml.etree - o analisador padrão é vulnerável a XXE

• id: python-unsafe-xml-etree severity: Mensagem de ERRO: | xml.etree.ElementTree não é seguro para XML não confiável. Ele NÃO desabilita a expansão de entidades externas por padrão. Em vez disso, use defusedxml. metadados: cwe: "CWE-611" owasp: "A04:2021 XML External Entities" patterns:
  • padrão: | import xml.etree.ElementTree as ET languages: [python]

REGRA 2: Uso direto de xml.dom.minidom - analisador XML inseguro

• id: python-unsafe-xml-minidom severity: Mensagem de ERRO: | xml.dom.minidom não desabilita DTDs ou expansão ENTITY. NÃO o utilize para XML não confiável. metadados: cwe: "CWE-611" pattern: | import xml.dom.minidom languages: [python]

REGRA 3: XMLParser lxml perigoso com resolve_entities=True

• id: python-lxml-resolve-entities-enabled severity: ERROR message: | O lxml XMLParser() com resolve_entities=True habilita o XXE. Defina resolve_entities=False e load_dtd=False. metadata: cwe: "CWE-611" pattern: | XMLParser(resolve_entities=True, ...) languages: [python]

REGRA 4: lxml com load_dtd=True - perigoso

• id: python-lxml-load-dtd severity: WARNING mensagem: | load_dtd=True habilita o processamento de DTD e pode permitir a expansão da entidade. Desative a menos que seja absolutamente necessário. metadados: cwe: "CWE-611" pattern: | XMLParser(load_dtd=True, ...) languages: [python]

REGRA 5: Falta de configuração do analisador seguro ao usar lxml.fromstring()

• id: python-lxml-fromstring-no-safe-config severity: WARNING mensagem: | lxml.fromstring() chamado sem um XMLParser reforçado. Certifique-se de que resolve_entities=False, no_network=True. metadados: cwe: "CWE-611" padrões:
  • padrão: | from lxml import etree - pattern: | etree.fromstring($XML) languages: [python]

REGRA 6: Não usar o defusedxml ao analisar XML externo

• id: python-defusedxml-not-used severity: INFO message: | Falta de uso do defusedxml, recomendado para análise segura de XML em Python. metadados: cwe: "CWE-611" pattern-either:
  • padrão: | ET.parse($X) - padrão: | etree.parse($X) languages: [python]

REGRA 7: xmltodict sem forçar o analisador desativado

• id: python-xmltodict-unsafe severity: WARNING mensagem: | xmltodict pode invocar um analisador XML subjacente que permite XXE. Use defusedxml em vez disso. padrão: | xmltodict.parse($X) languages: [python]

REGRA 8: Uso perigoso de eval() em entradas derivadas de XML

• id: python-eval-from-xml severity: CRITICAL mensagem: | eval() na entrada derivada de XML pode levar a RCE. Nunca avalie valores XML analisados diretamente. metadados: cwe: "CWE-95" owasp: "A03:2021 Injection" patterns:
  • padrão: | $VAL = $XML.xpath(...) - pattern: | eval($VAL) languages: [python]

REGRA 9: Pickle.loads inseguros em dados de origem XML

• id: python-pickle-on-xml severity: CRITICAL message: | O uso de pickle.loads() em entradas derivadas de XML pode levar à execução arbitrária de código. Evite o pickle nos dados do usuário. metadados: cwe: "CWE-502" padrões:
  • padrão: | $DATA = etree.fromstring(...) - pattern: | pickle.loads($DATA) languages: [python]`

Scanner Python SAST completo

Isso complementa o Semgrep ao procurar padrões de risco, incluindo:

• Importações inseguras do analisador XML
• ENTITY / DOCTYPE utilização
• avaliação, executar, picles, marechal, yaml.load padrões
• XXE aciona em .xml, .xsd, .wsdl arquivos

Criar: python_sast_scanner.py

python

`#!/usr/bin/env python3″"" python_sast_scanner.py Scanner SAST leve e rápido específico para Python, especializado em:

• Injeção de XML / XXE
• uso inseguro do analisador
• funções perigosas (eval, exec, pickle.loads, yaml.load) Seguro para CI; não executa nenhum código. Emite JSON e saída diferente de zero quando encontrado. """import os, re, json, sys PATTERNS = {# XML / XXE "xml_etree": r "import\s+xml\.etree\.ElementTree", "xml_minidom": r "import\s+xml\.dom\.minidom", "lxml_resolve_entities": r "resolve_entities\s*=\sTrue", "lxml_load_dtd": r "load_dtd\s=\s*True", "doctype_in_xml": r"<!DOCTYPE", "entity_in_xml": r"<!ENTITY",

Funções perigosas

"eval_usage": r"\\beval\\s*\\(","exec_usage": r"\\bexec\\s*\\(","pickle_loads": r"pickle\\.loads\\s*\\(","marshal_loads": r"marshal\\.loads\\s*\\(","yaml_unsafe_load": r"yaml\\.load\\s*\\(",

} IGNORED = {".git", "venv", "env", "pycache", "dist", "build", "node_modules"} def scan_file(path): findings = []try:with open(path, "r", encoding="utf-8″, errors="ignore") as f:for i, line in enumerate(f, 1):for rule, regex in PATTERNS.items():if re.search(regex, line): findings.append({"rule": rule, "line": line.strip(), "lineno": i, })except Exception:pass return findings def walk(root="."): results={}for dp, dirs, files in os.walk(root): dirs[:] = [d for d in dirs if d not in IGNORED]for f in files:if f.endswith((".py",".xml",".xsd",".wsdl")): full = os.path.join(dp, f) hits = scan_file(full)if hits: results[full] = hitsreturn results def main(): root = sys.argv[1] if len(sys.argv)>1 else "." results = walk(root)print(json.dumps({"results": results, "file_count": len(results)}, indent=2))if results: sys.exit(3) sys.exit(0) if name == "main": main()`

O que isso cobre - Escopo do Python SAST

Injeção de XML / XXE

Analisadores XML inseguros ✔ lxml com resolve_entities=True ✔ Carregamento de DTD (potencialmente perigoso) ✔ Marcadores XXE em arquivos XML armazenados

Injeção de código

✔ eval() ✔ exec()

Desserialização insegura

✔ pickle.loads() ✔ marshal.loads() ✔ inseguro yaml.load()

Outros padrões inseguros

✔ ENTITY / DOCTYPE em .xml, .xsd, .wsdl xmltodict sem analisador reforçado

Conclusão

A injeção de XML continua sendo uma categoria de vulnerabilidade relevante e perigosa. Seu impacto varia desde o desvio da lógica de negócios até a divulgação de arquivos e a negação de serviço. Compreender os comportamentos de XML, proteger os analisadores, validar a estrutura e incorporar testes de penetração automatizados são etapas essenciais para garantir a segurança robusta dos aplicativos.