Three Dark Clouds

over
the Android Kernel

Jun Yao @ Alpha Lab

About me
• Security researcher in Alpha Lab of 360
• Focus on the Android/Linux kernel
 Bug hunting
 Writing exploits
 Researching Mitigations

1
Contents

01. Three Dark Clouds

02. Thunder and Lightning

03. Dispel the Clouds and See the Sun

04. Conclusion

2
Contents

01. Three Dark Clouds

02. Thunder and Lightning

03. Dispel the Clouds and See the Sun

04. Conclusion

3
Classic attack path

Bypass Arbitrary
Vulnerability Root
KASLR write

• Methods
 ret2usr
 ROP/JOP
 ...

4
The ret2dir

pagemap: hide PFN CVE-2018-9568 (WrongZone)

ret2dir + ROP

CVE-2015-3636 (PingPong)
ret2dir + ROP
ret2dir

5
The ret2dir
• Double Mapping

User Space Physical Page Kernel Space

0xFFFF...

0x4000...

https://cs.brown.edu/~vpk/papers/ret2dir.sec14.pdf
6
The ret2dir
• User can calculate the kernel address
1. Get PFN from /proc/self/pagemap
2. kaddr = (PFN << PAGE_SHIFT) – PHYS_OFFSET
+ PAGE_OFFSET
• The kernel mapping attributes
 qcom: RW
 mtk: RWX (CVE-2016-0820)

7
The ret2dir
• Hide PFN in the /proc/self/pagemap

+static int pagemap_open(struct inode *inode, struct file *file)

+{
+ /* do not disclose physical addresses: attack vector */
+ if (!capable(CAP_SYS_ADMIN))
+ return -EPERM;
+ return 0;
+}
+
const struct file_operations proc_pagemap_operations = {
.llseek = mem_lseek, /* borrow this */
.read = pagemap_read,
+ .open = pagemap_open,
};

https://android.googlesource.com/kernel/msm/+/718c232053ec81a4a732ed50ba0224ae512bb694%5E%21/
8
The ret2dir
• It still works
 CVE-2015-3636[1]
 CVE-2018-9568[2]
• The key is information leakage

[1] https://www.blackhat.com/docs/us-15/materials/us-15-Xu-Ah-Universal-Android-Rooting-Is-Back.pdf
[2] https://github.com/ThomasKing2014/slides/blob/master/Building%20universal%20Android%1920rootin
g%20with%20a%20type%20confusion%20vulnerability.pdf
9
The KSMA
• Kernel Space Mirror Attack
?

KSMA Patch CVE-2018-9568 (WrongZone)

SMA + KSMA
CVE-2020-3680
SMA + KSMA

CVE-2017-7533 (ReVent)
PIPE + KSMA
https://i.blackhat.com/briefings/asia/2018/asia-18-WANG-KSMA-Breaking-Android-kernel-isolation-and-
Rooting-with-ARM-MMU-features.pdf
10
The KSMA
• The block entry

https://documentation-service.arm.com/static/5f20515cbb903e39c84dc459?token=
11
The KSMA
• The AP (Access Permissions) attribute

12
The KSMA
• Android: 39-bits VA & 4K page

swapper_pg_dir

13
The KSMA
• The position of the swapper_pg_dir is fixed

arch/arm64/kernel/vmlinux.lds.S

BSS_SECTION(0, 0, 0)
. = ALIGN(PAGE_SIZE);
idmap_pg_dir = .;
. += IDMAP_DIR_SIZE;
swapper_pg_dir = .;
. += SWAPPER_DIR_SIZE;

• Arbitrary write is needed

14
The PIPE
• Proposed in 2017
• Has the characteristics of TOCTOU
• Converts heap problems to arbitrary reading and
writing

https://pacsec.jp/psj17/PSJ2017_DiShen_Pacsec_FINAL.pdf
15
The PIPE
• Allocate iovec on the heap
fs/read_write.c
ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
unsigned long nr_segs, unsigned long fast_segs,
struct iovec *fast_pointer, ...) {
[...]
if (nr_segs > fast_segs) { // UIO_FASTIOV == 8
iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
[...]
}
if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
ret = -EFAULT;
goto out;
}
}

16
The PIPE
• Check the iovec passed in by the user

fs/read_write.c

ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,

unsigned long nr_segs, unsigned long fast_segs,
struct iovec *fast_pointer, ...) {
[...]
for (seg = 0; seg < nr_segs; seg++) {
void __user *buf = iov[seg].iov_base;
ssize_t len = (ssize_t)iov[seg].iov_len;

if (type >= 0 && unlikely(!access_ok(vrfy_dir(type), buf, len))) {}

ret += len;
}
}

17
The PIPE
• We can block the pipe
1. There is no contents when reading
2. There is no space when writing

• Overwrite the iovec

object iovec

18
The PIPE
• Does NOT check when copying from/to the user
lib/iov_iter.c
static size_t copy_page_to_iter_iovec(..) {
[...]
left = __copy_to_user_inatomic(buf, from, copy);
copy -= left;
skip += copy;
from += copy;
bytes -= copy;
[...]
}

19
The PIPE
• Two mitigations
1. UAO (User Access Override)
2. uaccess_mask_ptr()
arch/arm64/include/asm/uaccess.h

static inline void __user *__uaccess_mask_ptr(const void __user *ptr)

{
asm volatile(
" bics xzr, %1, %2\n"
" csel %0, %1, xzr, eq\n"
: "=&r" (safe_ptr)
: "r" (ptr), "r" (current_thread_info()->addr_limit)
: "cc");
return safe_ptr;
}

https://developer.arm.com/docs/ddi0595/h/aarch64-system-registers/uao
20
The SMA
• SLAB Mirror Attack
 Two objects share the same SLAB
 Bypass KASLR
 Write kernel arbitrary (+KSMA = ROOT)

21
Contents

01. Three Dark Clouds

02. Thunder and Lightning

03. Dispel the Clouds and See the Sun

04. Conclusion

22
CVE-2020-3680
• Timeline

2019-11-10 Report to Google

2020-4-22 The CVE ID is CVE-2020-3680

2020-5-4 Public disclosure on the Qualcomm Security Bulletin

23
CVE-2020-3680
• Qualcomm ADSPRPC driver
drivers/char/adsprpc.c

int fastrpc_internal_mmap(...) { int fastrpc_internal_munmap_fd(...) {

mutex_lock(&fl->map_mutex); mutex_lock(&fl->fl_map_mutex);// 2
[...] if (fastrpc_mmap_find(..., &map))
mutex_lock(&fl->fl_map_mutex); [...]
VERIFY(err, !fastrpc_mmap_create(..., &map)); if (map)
mutex_unlock(&fl->fl_map_mutex); // 1 fastrpc_mmap_free(map, 0);// 3
VERIFY(err, !fastrpc_mmap_on_dsp()); mutex_unlock(&fl->fl_map_mutex);
bail: return err;
if (err && map) { }
mutex_lock(&fl->fl_map_mutex);
fastrpc_mmap_free(map, 0); // 4
mutex_unlock(&fl->fl_map_mutex);
}
mutex_unlock(&fl->map_mutex);
return err;
}

24
How to exploit
• ROP/JOP 😭
 PAN (Privileged Access Never)
 CFI (Control Flow Integrity)

• SMA + KSMA 😀
1. Convert UAF to Double Free
2. Bypass KASLR
3. Apply KSMA

25
Convert UAF to Double Free
drivers/char/adsprpc.c

void fastrpc_mmap_free(struct fastrpc_mmap *map, uint32_t flags) {

[...]
if (map->flags == ADSP_MMAP_HEAP_ADDR || ...) {
[...]
} else {
map->refs--;
if (!map->refs)
hlist_del_init(&map->hn); // 1
if (map->refs > 0 && !flags)
return;
}
if (map->flags == ADSP_MMAP_HEAP_ADDR || ...) {
[...]
} else if (map->flags == FASTRPC_DMAHANDLE_NOMAP) {
if (!IS_ERR_OR_NULL(map->handle))
ion_free(fl->apps->client, map->handle); // 2
}
kfree(map); // 3
}

26
Convert UAF to Double Free
• How to bypass hlist_del_init()
include/linux/list.h
static inline void hlist_del_init(struct hlist_node *n) {
if (!hlist_unhashed(n)) {
__hlist_del(n);
INIT_HLIST_NODE(n);
}
}

static inline int hlist_unhashed(const struct hlist_node *h)

{
return !h->pprev;
}

27
Convert UAF to Double Free
• The object used for heap spray
1. It uses the kmalloc-256 SLAB
2. I can control the map->refs and map->flags
3. The map->hn->pprev is zero

28
Convert UAF to Double Free
• The object used for heap spray

fs/xattr.c

setxattr(..., const void __user *value, size_t size, int flags) {

[...]
if (size) {
kvalue = kmalloc(size, GFP_KERNEL | __GFP_NOWARN);
if (copy_from_user(kvalue, value, size)) {
error = -EFAULT;
goto out;
}
}
}

29
Convert UAF to Double Free
• The SLAB appears twice in the freelist

Freelist A A

Freelist A

30
Bypass KASLR
• Use the freelist to modify the object

struct seq_file {
char *buf; // is modified by the freelist
size_t size;
[...]
struct mutex lock;
const struct seq_operations *op; // is leaked
int poll_event;
const struct file *file;
void *private;
}

31
Bypass KASLR
• Users can read the seq_file->buf

32
Bypass KASLR
• Allocate victim_fd0 & victim_fd1

Freelist A A

victim_fd0 victim_fd1
(A) (A)

33
Bypass KASLR
• Allocate the leaked_fd

victim_fd0 victim_fd1 leaked_fd

(A) (A) (B)

• Free the leaked_fd

B
Freelist
(leaked_fd)

34
Bypass KASLR
• Free the victim_fd0

A B
Freelist
(victim_fd0) (leaked_fd)

• Read seq_file->op from victim_fd1

35
Apply KSMA
• Use the object to modify the freelist
1. It uses the kmalloc-256 SLAB
2. I can control the first 8 bytes

36
Apply KSMA
• Use the object to modify the freelist

struct ipv6_mc_socklist {
struct in6_addr addr;
int ifindex;
struct ipv6_mc_socklist __rcu *next;
rwlock_t sflock;
unsigned int sfmode;
struct ip6_sf_socklist *sflist;
struct rcu_head rcu;
}

37
Apply KSMA
• Use the object to modify the freelist

net/ipv6/mcast.c

int ipv6_sock_mc_join(..., const struct in6_addr *addr) {

[...]
mc_lst = sock_kmalloc(sizeof(struct ipv6_mc_socklist));
if (!mc_lst)
return –ENOMEM;
mc_lst->next = NULL;
mc_lst->addr = *addr;
[...]
}

38
Apply KSMA
• Allocate the mc_lst

Freelist A A

mc_lst
(A)

Freelist A

39
Apply KSMA
• Update the mc_lst->addr

Freelist A A

mc_lst
(A)

Freelist A

40
Demo

41
Contents

01. Three Dark Clouds

02. Thunder and Lightning

03. Dispel the Clouds and See the Sun

04. Conclusion

42
The ret2dir mitigation
• Exclusive Page-Frame Ownership
 Unmap the user page in the kernel
 Not yet merged into the mainline

https://lwn.net/Articles/784839/
43
The KSMA mitigation
• The KSMA patch
 I submitted it in May 2018
 Was merged into the mainline in September 2018
 Android has not yet been backported 😭

https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/log/?h=v5.8.8&qt=author&q=yaojun
44
The KSMA patch
• Move the page table to the rodata section
arch/arm64/kernel/vmlinux.lds.S
+#define KERNEL_PG_TABLES \
+ . = ALIGN(PAGE_SIZE); \
+ idmap_pg_dir = .; \
+ . += IDMAP_DIR_SIZE; \
+ TRAMP_PG_TABLE \
+ RESERVED_PG_TABLE \
+ swapper_pg_dir = .; \
+ . += PAGE_SIZE; \
+ swapper_pg_end = .;

RO_DATA(PAGE_SIZE)
EXCEPTION_TABLE(8)
NOTES
+ KERNEL_PG_TABLES

45
The KSMA patch
• The kernel assumes the relative offset between the
swapper_pg_dir and the tramp_pg_dir

arch/arm64/kernel/entry.S
.macro tramp_map_kernel, tmp
mrs \tmp, ttbr1_el1
sub \tmp, \tmp, #(SWAPPER_DIR_SIZE + RESERVED_TTBR0_SIZE)
bic \tmp, \tmp, #USER_ASID_FLAG
msr ttbr1_el1, \tmp
[...]
.endm

46
The KSMA patch
• Update the page table through fixmap

void set_swapper_pgd(pgd_t *pgdp, pgd_t pgd)

{
pgd_t *fixmap_pgdp;
spin_lock(&swapper_pgdir_lock);
fixmap_pgdp = pgd_set_fixmap(pa(pgdp));
WRITE_ONCE(*fixmap_pgdp, pgd);
pgd_clear_fixmap();
spin_unlock(&swapper_pgdir_lock);
}

47
The SMA mitigation
• CONFIG_SLAB_FREELIST_HARDENED[1]
 Not enabled in the kernel 4.9
 Not enabled on the Google Pixel (4.14)

• CONFIG_INIT_ON_FREE_DEFAULT_ON[2]
 Not enabled in the Android kernel

[1] https://hardenedlinux.github.io/system-security/2017/12/02/linux_kernel_4.14%E7%9A%84SLAB_FREELIS
T_HARDENED%E7%9A%84%E7%AE%80%E8%A6%81%E5%88%86%E6%9E%90.html
[2] https://outflux.net/blog/archives/2019/11/14/security-things-in-linux-v5-3/
48
SLAB_FREELIST_HARDENED
• Generate a random number

mm/slub.c
int kmem_cache_open(struct kmem_cache *s, unsigned long flags)
{
s->flags = kmem_cache_flags(s->size, flags, s->name, s->ctor);
s->reserved = 0;
#ifdef CONFIG_SLAB_FREELIST_HARDENED
s->random = get_random_long();
#endif
}

49
SLAB_FREELIST_HARDENED
• Obfuscate the address of SLAB

mm/slub.c
void *freelist_ptr(const struct kmem_cache *s, void *ptr, unsigned long ptr_addr)
{
#ifdef CONFIG_SLAB_FREELIST_HARDENED
return (void *)((unsigned long)ptr ^ s->random ^
(unsigned long)kasan_reset_tag((void *)ptr_addr));
#else
return ptr;
#endif
}

50
SLAB_FREELIST_HARDENED
• The obfuscation has weaknesses

kmalloc-32 freelist walk, before:

ptr ptr_addr stored value random number
ffff90c22e019020@ffff90c22e019000 is 86528eb656b3b5bd (86528eb656b3b59d)
ffff90c22e019040@ffff90c22e019020 is 86528eb656b3b5fd (86528eb656b3b59d)
ffff90c22e019060@ffff90c22e019040 is 86528eb656b3b5bd (86528eb656b3b59d)

https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1ad53d9fa3f6168ebcf48a50e08b170
432da2257
51
SLAB_FREELIST_HARDENED
• Improve the obfuscation

mm/slub.c

void *freelist_ptr(const struct kmem_cache *s, void *ptr, unsigned long ptr_addr)
{
#ifdef CONFIG_SLAB_FREELIST_HARDENED
return (void *)((unsigned long)ptr ^ s->random ^
- (unsigned long)kasan_reset_tag((void *)ptr_addr));
+ swab((unsigned long)kasan_reset_tag((void *)ptr_addr)));
#else
return ptr;
#endif
}

52
SLAB_FREELIST_HARDENED
• Check the double free

mm/slub.c
void set_freepointer(struct kmem_cache *s, void *object, void *fp)
{
unsigned long freeptr_addr = (unsigned long)object + s->offset;
#ifdef CONFIG_SLAB_FREELIST_HARDENED
BUG_ON(object == fp); // Double free
#endif
*(void **)freeptr_addr = freelist_ptr(s, fp, freeptr_addr);
}

53
INIT_ON_FREE_DEFAULT_ON
• Clear the data in the released SLAB

mm/slub.c

bool slab_free_freelist_hook(struct kmem_cache *s, void **head, void **tail)

{
do {
object = next;
next = get_freepointer(s, object);
if (slab_want_init_on_free(s)) {
memset(object, 0, s->object_size);
rsize = (s->flags & SLAB_RED_ZONE) ? s->red_left_pad : 0;
memset((char *)object + s->inuse, 0, s->size - s->inuse - rsize);
}
} while (object != old_tail);
}

54
Contents

01. Three Dark Clouds

02. Thunder and Lightning

03. Dispel the Clouds and See the Sun

04. Conclusion

55
Conclusion
• The combination of the SMA and the KSMA is powerful

• In order to harden the kernel, we need:

1. Mitigate known attacks (the ret2dir)
2. Fill the gap between Android and the mainline (the
KSMA patch)
3. Prevent kernel fragmentation (the SMA)

56
 Thank You

Jun Yao @ Alpha Lab

[email protected]