XML-Injection ist die Manipulation von XML-Eingaben, um zu verändern, wie eine Anwendung Daten analysiert oder interpretiert. Dies geschieht, wenn benutzergesteuerte Eingaben ohne ordnungsgemäße Validierung in ein XML-Dokument eingefügt werden, so dass Angreifer Knoten, Attribute, Entitäten oder Nutzdaten einfügen können, die den Kontrollfluss verändern, die Logik umgehen oder gefährliches Parser-Verhalten auslösen. In den heutigen API-lastigen und integrationsgesteuerten Ökosystemen bleibt XML Injection eine reale Bedrohung, die Sicherheitsteams nicht ignorieren können.

Im Gegensatz zu einfachen Eingabemanipulationen wird bei XML Injection die Ausdruckskraft von XML selbst ausgenutzt, was sich auf komplexe Systeme wie SOAP, SAML, IoT-Geräte, Unternehmensintegrationen und alte Finanzsysteme auswirkt.

Warum XML-Injektion immer noch wichtig ist

Obwohl JSON in modernen Anwendungen dominiert, ist XML tief in Unternehmenssoftware, Authentifizierungsprotokollen und Backend-Integrationen verankert. Angreifer können XML-Strukturen missbrauchen, um:

• Eingriffe in die Geschäftslogik
• Einschleusen nicht autorisierter Knoten
• Manipulation von XPath-Abfragen
• Datei-Offenlegung im Stil von XXE auslösen
• Schema-Validierung unterbrechen
• Verursacht XML-basierten Denial of Service

Die Flexibilität von XML macht seinen Missbrauch besonders stark.

Echtes CVE-Beispiel: CVE-2025-13526

CVE-2025-13526 zeigt, wie eine einfache Fehlkonfiguration beim XML-Parsing zur vollständigen Offenlegung von Dateien führen kann. Das System erlaubte das Hochladen von XML-Konfigurationsdateien, versäumte es aber, die Auflösung externer Entitäten zu deaktivieren.

Beispiel für bösartige Nutzdaten:

xml

<!DOCTYPE data [

]>

&xxe;

Der Server hat den Inhalt von /etc/passwdund zeigt, wie XML Injection in Kombination mit XXE kritische Dateien offenlegen kann.

Angriffsflächen der XML-Injektion

Angreifer missbrauchen:

• Knoten Injektion
• Attribut-Injektion
• XPath-Abfrage-Manipulation
• Schema (XSD) Manipulation
• XXE-Nutzlasten
• Entitätserweiterung für DoS
• Logische Umgehung in XML-basierten Workflows

Jede Kategorie wirkt sich auf eine andere Ebene des Systems aus.

Angriffsbeispiele (Gleiche Menge erhalten)

1. Manipulation durch Knoteninjektion

xml

ProduktA

Eingespritzte Nutzlast:

pgsql

true

Das resultierende XML wird strukturell beschädigt und kann unberechtigte Rechte gewähren.

XPath-Injektion

python

query = f"//benutzer/benutzer[benutzername/text()='{benutzer}']"

Böswillige Eingabe:

bash

' oder '1'='1

Dadurch werden unberechtigte Benutzerdatensätze aufgedeckt.

XXE Nutzlast

xml

<!DOCTYPE foo [

]>&payload;

Schema-Manipulation

xml

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

Dadurch wird das erwartete Validierungsverhalten deaktiviert.

Billion Laughs DoS

xml

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

Massive Expansion überlastet den Parser.

Abwehrtechniken

Entitätsauflösung deaktivieren

python

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

Sichere Bibliotheken verwenden

python

import defusedxml.ElementTree as ET

Starke Schema-Validierung

python

schema.validate(input_xml)

Keine Verkettung von XML-Strings

Sicherer Ansatz:

python

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

Vergleichstabelle

Typ	Ziel	Schweregrad	Auswirkungen
XML-Injektion	Struktur-Manipulation	Mittel-Hoch	Logischer Bypass
XPath-Injektion	Abfragekontrolle	Hoch	Unbefugter Zugang
XXE	Missbrauch von Parsern	Hoch	Datei lesen / SSRF
Schema-Injektion	Validierungs-Bypass	Mittel	Integritätsrisiken

XML-Injektion bei automatisierten Penetrationstests

Moderne KI-gesteuerte Penetrationstestplattformen - wie Penligent - führen Strukturmutation, XML-Fuzzing, XPath-Payload-Tests und die Erkennung von Parser-Fehlkonfigurationen durch. Diese Plattformen:

• Entdecken Sie XML-basierte Angriffsflächen
• Injektionspunkte identifizieren
• Selbstlernendes Schemaverhalten
• Generierung adaptiver Nutzdaten
• Validierung des Parserverhaltens bei mehreren Konfigurationen

Dadurch wird der Erfassungsbereich erheblich erweitert.

Sicherheitsgrundlagen und automatisierte Empfehlungen für Korrekturen

Auch automatisierte Plattformen können dies leisten:

• Prüfungen der Parserkonfiguration
• Erkennung von unsicheren XML-Bibliotheken
• Überprüfung der Einstellungen für die Entitätsauflösung
• Durchsetzung einer strengen XSD-Validierung
• CI/CD-Blockierung von unsicheren XML-Operationen

So wird aus der Erkennung eine umsetzbare Abhilfe.

Skript für Beispiel

Semgrep-Regeln - Python XML Injection / XXE / Unsicheres Parsing

Erstellen Sie eine Datei:

semgrep-regeln/python-xml-injection.yaml

yaml

`Regeln:

REGEL 1: Unsichere Verwendung von xml.etree - Standard-Parser ist anfällig für XXE

• id: python-unsafe-xml-etree Schweregrad: ERROR Meldung: | xml.etree.ElementTree ist unsicher für nicht vertrauenswürdiges XML. Es deaktiviert standardmäßig NICHT die externe Entitätserweiterung. Verwenden Sie stattdessen defusedxml. metadata: cwe: "CWE-611" owasp: "A04:2021 XML External Entities" patterns:
  • Muster: | import xml.etree.ElementTree as ET languages: [python]

REGEL 2: Direkte Verwendung von xml.dom.minidom - unsicherer XML-Parser

• id: python-unsafe-xml-minidom Schweregrad: ERROR Meldung: | xml.dom.minidom deaktiviert keine DTDs oder ENTITY-Erweiterung. Verwenden Sie es NICHT für nicht vertrauenswürdiges XML. metadata: cwe: "CWE-611" pattern: | import xml.dom.minidom languages: [python]

REGEL 3: Gefährlicher lxml XMLParser mit resolve_entities=True

• id: python-lxml-resolve-entities-enabled Schweregrad: ERROR Meldung: | lxml XMLParser() mit resolve_entities=True aktiviert XXE. Setzen Sie resolve_entities=False und load_dtd=False. metadata: cwe: "CWE-611" pattern: | XMLParser(resolve_entities=True, ...) languages: [python]

REGEL 4: lxml mit load_dtd=True - gefährlich

• id: python-lxml-load-dtd Schweregrad: WARNUNG Meldung: | load_dtd=True aktiviert die DTD-Verarbeitung und kann eine Entitätserweiterung ermöglichen. Deaktivieren, wenn nicht unbedingt erforderlich. metadata: cwe: "CWE-611" pattern: | XMLParser(load_dtd=True, ...) languages: [python]

REGEL 5: Fehlende sichere Parser-Konfiguration bei Verwendung von lxml.fromstring()

• id: python-lxml-fromstring-no-safe-config Schweregrad: WARNUNG Meldung: | lxml.fromstring() wurde ohne einen gehärteten XMLParser aufgerufen. Stellen Sie resolve_entities=False, no_network=True sicher. metadata: cwe: "CWE-611" patterns:
  • Muster: | from lxml import etree - Muster: | etree.fromstring($XML) Sprachen: [python]

REGEL 6: Keine Verwendung von defusedxml beim Parsen von externem XML

• id: python-defusedxml-not-used Schweregrad: INFO Meldung: | Fehlende Verwendung von defusedxml, empfohlen für sicheres XML-Parsing in Python. metadata: cwe: "CWE-611" pattern-either:
  • Muster: | ET.parse($X) - pattern: | etree.parse($X) Sprachen: [python]

REGEL 7: xmltodict ohne Erzwingen eines entschärften Parsers

• id: python-xmltodict-unsafe Schweregrad: WARNUNG Meldung: | xmltodict kann einen zugrunde liegenden XML-Parser aufrufen, der XXE erlaubt. Verwenden Sie defusedxml Parser stattdessen. pattern: | xmltodict.parse($X) Sprachen: [python]

REGEL 8: Gefährliche Verwendung von eval() bei von XML abgeleiteten Eingaben

• id: python-eval-from-xml Schweregrad: CRITICAL Meldung: | eval() auf von XML abgeleiteter Eingabe kann zu RCE führen. Niemals geparste XML-Werte direkt auswerten. metadata: cwe: "CWE-95" owasp: "A03:2021 Injection" Muster:
  • Muster: | $VAL = $XML.xpath(...) - pattern: | eval($VAL) Sprachen: [python]

REGEL 9: Unsichere pickle.loads auf XML-gestützte Daten

• id: python-pickle-on-xml Schweregrad: CRITICAL Meldung: | pickle.loads() auf von XML abgeleiteten Eingaben kann zur Ausführung von beliebigem Code führen. Vermeiden Sie Pickle auf Benutzerdaten. metadata: cwe: "CWE-502" patterns:
  • Muster: | $DATA = etree.fromstring(...) - pattern: | pickle.loads($DATA) Sprachen: [python]`

Vollständiger Python-SAST-Scanner

Dies ergänzt Semgrep, indem es nach riskanten Mustern sucht, einschließlich:

• Unsichere XML-Parser-Importe
• ENTITY / DOCTYPE Verwendung
• eval, Ausführung, Essiggurke, Marschall, yaml.load Muster
• XXE-Auslöser in .xml, .xsd, .wsdl Dateien

Erstellen: python_sast_scanner.py

python

`#!/usr/bin/env python3″"" python_sast_scanner.py Leichter, schneller Python-spezifischer SAST-Scanner, spezialisiert auf:

• XML-Injektion / XXE
• unsichere Parser-Verwendung
• gefährliche Funktionen (eval, exec, pickle.loads, yaml.load) Sicher für CI; führt keinen Code aus. Gibt JSON und einen Exit ungleich Null aus, wenn er gefunden wird. """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",

Gefährliche Funktionen

"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()`

Was wird hier abgedeckt - Python SAST Scope

XML-Injektion / XXE

✔ Unsichere XML-Parser ✔ lxml mit resolve_entities=True ✔ DTD-Laden (potenziell gefährlich) ✔ XXE-Markierungen in gespeicherten XML-Dateien

Code-Einspritzung

✔ eval() ✔ exec()

Unsichere Deserialisierung

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

Andere unsichere Muster

✔ ENTITY / DOCTYPE in .xml, .xsd, .wsdl ✔ xmltodict ohne gehärteten Parser

Schlussfolgerung

XML Injection ist nach wie vor eine relevante und gefährliche Kategorie von Sicherheitslücken. Die Auswirkungen reichen von der Umgehung der Geschäftslogik bis hin zur Offenlegung von Dateien und Denial-of-Service. Das Verständnis des XML-Verhaltens, die Absicherung von Parsern, die Validierung der Struktur und die Einbeziehung automatisierter Penetrationstests sind wesentliche Schritte zur Gewährleistung einer robusten Anwendungssicherheit.