Linux进程读越界后果,【CVE-2017-7184】Linux xfrm模块越界读写提权漏洞分析

主要参考和补充p4nda的分析，非常详细。

一、漏洞分析

漏洞位于内核xfrm模块，该模块是IPSEC协议的实现模块。

1.简介

(1)IPSEC协议简介

IPSEC是一个协议组合，它包含AH、ESP、IKE协议，提供对数据包的认证和加密功能，能帮助IP层建立安全可信的数据包传输通道。

SA(Security Associstion)：安全关联。SA由spi、ip、安全协议标识(AH或ESP)这三个参数唯一确定。SA定义了ipsec双方的ip地址、ipsec协议、加密算法、密钥、模式、抗重放窗口等。其实SA就是用xfrm_state结构体表示。

AH(Authentication Header)：认证。AH为ip包提供数据完整性校验和身份认证功能，提供抗重放能力，验证算法由SA指定。

ESP(Encapsulating security payload)：加密。ESP为ip数据包提供完整性检查、认证和加密。

(2)Linux内核的IPSEC实现

在linux内核中的IPSEC实现即是xfrm这个框架(读作transform转换，表示内核协议栈收到的IPsec报文需要经过转换才能还原为原始报文)，很多解决方案如StrongSwan、OpenSwan都使用XFRM框架进行报文接收发送，关于xfrm的代码主要在net/xfrm以及net/ipv4下。

// 以下是/net/xfrm下的代码的大概功能

xfrm_state.c 状态管理

xfrm_policy.c xfrm策略管理

xfrm_algo.c 算法管理

xfrm_hash.c 哈希计算函数

xfrm_input.c 安全路径(sec_path)处理， 用于处理进入的ipsec包

xfrm_user.c netlink接口的SA和SP(安全策略)管理

其中xfrm_user.c中的代码允许我们向内核发送netlink消息来调用相关handler实现对SA和SP的配置，其中涉及处理函数如下。

xfrm_dispatch[XFRM_NR_MSGTYPES] = {

[XFRM_MSG_NEWSA - XFRM_MSG_BASE] = { .doit = xfrm_add_sa },

[XFRM_MSG_DELSA - XFRM_MSG_BASE] = { .doit = xfrm_del_sa },

[XFRM_MSG_GETSA - XFRM_MSG_BASE] = { .doit = xfrm_get_sa,

.dump = xfrm_dump_sa,

.done = xfrm_dump_sa_done },

[XFRM_MSG_NEWPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_add_policy },

[XFRM_MSG_DELPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_get_policy },

[XFRM_MSG_GETPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_get_policy,

.dump = xfrm_dump_policy,

.done = xfrm_dump_policy_done },

[XFRM_MSG_ALLOCSPI - XFRM_MSG_BASE] = { .doit = xfrm_alloc_userspi },

[XFRM_MSG_ACQUIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_acquire },

[XFRM_MSG_EXPIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_sa_expire },

[XFRM_MSG_UPDPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_add_policy },

[XFRM_MSG_UPDSA - XFRM_MSG_BASE] = { .doit = xfrm_add_sa },

[XFRM_MSG_POLEXPIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_pol_expire},

[XFRM_MSG_FLUSHSA - XFRM_MSG_BASE] = { .doit = xfrm_flush_sa },

[XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_flush_policy },

[XFRM_MSG_NEWAE - XFRM_MSG_BASE] = { .doit = xfrm_new_ae },

[XFRM_MSG_GETAE - XFRM_MSG_BASE] = { .doit = xfrm_get_ae },

[XFRM_MSG_MIGRATE - XFRM_MSG_BASE] = { .doit = xfrm_do_migrate },

[XFRM_MSG_GETSADINFO - XFRM_MSG_BASE] = { .doit = xfrm_get_sadinfo },

[XFRM_MSG_NEWSPDINFO - XFRM_MSG_BASE] = { .doit = xfrm_set_spdinfo,

.nla_pol = xfrma_spd_policy,

.nla_max = XFRMA_SPD_MAX },

[XFRM_MSG_GETSPDINFO - XFRM_MSG_BASE] = { .doit = xfrm_get_spdinfo },

};

下面简单介绍一下其中几个函数的功能:

xfrm_add_sa：创建一个新的SA，并可以指定相关attr，在内核中，是用一个xfrm_state结构来表示一个SA的。

xfrm_del_sa：删除一个SA，也即删除一个指定的xfrm_state。

xfrm_new_ae：根据传入参数，更新指定xfrm_state结构中的内容。

xfrm_get_ae：根据传入参数，查询指定xfrm_state结构中的内容(包括attr)。

(3)Netlink介绍

简介：Netlink是linux提供的用于内核和用户态进程之间的通信方式，也能用于用户空间的两个进程通信(很少)。一般来说用户空间和内核空间的通信方式有三种：/proc、ioctl、Netlink。而前两种都是单向的，但是Netlink可以实现双工通信。

Netlink 是一种特殊的 socket，它是 Linux 所特有的，类似于 BSD 中的AF_ROUTE 但又远比它的功能强大。目前在Linux 内核中使用netlink 进行应用与内核通信的应用很多; 包括：路由 daemon(NETLINK_ROUTE)，用户态 socket 协议(NETLINK_USERSOCK)，防火墙(NETLINK_FIREWALL)，netfilter 子系统(NETLINK_NETFILTER)，内核事件向用户态通知(NETLINK_KOBJECT_UEVENT)， 通用 netlink(NETLINK_GENERIC)等。

通信方式：基于netlink的内核通信与socket的通信方式一致，都是通过sendto()，recvfrom()； sendmsg(), recvmsg()的用户态API。内核便可以调用 xfrm_netlink_rcv() 来接收和处理。

2.漏洞分析

(1)xfrm_state结构体生成

struct xfrm_id id用于标识一个SA身份，包含daddr、spi、proto三个参数；

struct xfrm_id {

xfrm_address_t daddr;

__be32 spi;

__u8 proto;

};

两xfrm_replay_state_esn结构体(replay_esn和preplay_esn)，bmp是一个边长的内存区域，是一块bitmap，用于标识数据包的seq是否被重放过，其中bmp_len表示变长结构体的大小，replay_window用于seq索引的模数，即索引的范围，此结构体在创建xfrm_state结构体时根据用户输入参数动态被创建，而程序漏洞存在于这个结构体的读写过程中。bmp_len决定整个结构体的具体大小. 而replay_window则决定了bmp数组的索引范围。

struct xfrm_replay_state_esn {

unsigned int bmp_len;

__u32 oseq;

__u32 seq;

__u32 oseq_hi;

__u32 seq_hi;

__u32 replay_window;

__u32 bmp[0];

};

static int xfrm_add_sa(struct sk_buff *skb, struct nlmsghdr *nlh, struct nlattr **attrs)

(1)verify_newsa_info(p, attrs); // 协议及参数检查

verify_replay(p, attrs) // xfrm_replay_state_esn结构参数检查

/*检查：[1]bmp_len是否超过最大值，最大值定义为4096/4/8。[2]检查参数长度定义是否正确。[3]是否为IPPROTO_ESP或者IPPROTO_AH协议。*/

(2)xfrm_state_construct(net, p, attrs, &err) // 根据用户输入对结构体进行构造

- struct xfrm_state *x=xfrm_state_alloc(net); // 调用kzalloc函数新建xfrm_state结构

- copy_from_user_state(x, p); // 拷贝用户数据

- xfrm_alloc_replay_state_esn(); // 申请xfrm_replay_state_esn结构体

/*通过kzalloc函数分别申请了两块同样大小的内存(replay_esn和preplay_esn)，大小为sizeof(*replay_esn) + replay_esn->bmp_len * sizeof(__u32)，并将用户数据中attr[XFRMA_REPLAY_ESN_VAL]内容复制过去。*/

- xfrm_init_replay(); // 检查滑动窗口replay_window大小及flag，确定检测使用的函数

/*对上述申请的结构体数据进行检查，replay_window不大于定义的bmp_len大小，并对x->repl进行初始化，该成员是一个函数虚表，作用是在收到AH或ESP协议数据包时进行数据重放检查。*/

x->repl = &xfrm_replay_esn;

(2)xfrm_replay_state_esn结构体更新

目的：修改replay_esn成员，也即xfrm_alloc_replay_state_esn申请的第1个内存块。

static int xfrm_new_ae(struct sk_buff *skb, struct nlmsghdr *nlh, struct nlattr **attrs)

(1)xfrm_state_lookup() //循环查找hash表，得到xfrm_state结构体

(2)xfrm_replay_verify_len() //对用户输入的attr[XFRMA_REPLAY_ESN_VAL]参数进行检查，也就是修改后的replay_esn 成员内容。

/*主要检查了修改部分的bmp_len长度，该检查是因为replay_esn成员内存是直接进行复制的，不再二次分配。但缺少了对replay_window变量的检测，导致引用replay_window变量进行bitmap读写时造成的数组越界问题。*/

(3)xfrm_update_ae_params() //利用memcpy进行成员内容修改。

(3)数组越界写定位

// 对xfrm模块代码中，replay_window关键字的查找，可以发现主要对这个关键字的操作位于xfrm_replay_advance_esn和xfrm_replay_check_esn函数中

static const struct xfrm_replay xfrm_replay_esn = {

.advance = xfrm_replay_advance_esn, // 越界读写

.check = xfrm_replay_check_esn, // 越界读写

.recheck = xfrm_replay_recheck_esn,

.notify = xfrm_replay_notify_esn,

.overflow = xfrm_replay_overflow_esn,

};

xfrm_replay_esn结构体在xfrm_init_replay函数中被使用，并赋值给x->repl，x->repl被xfrm_input函数调用。xfrm_input函数之前被xfrm4_rcv_spi <= xfrm4_rcv <= xfrm4_ah_rcv ，最终追溯到AH协议的内核协议栈中。

static const struct net_protocol ah4_protocol = {

.handler = xfrm4_ah_rcv,

.err_handler = xfrm4_ah_err,

.no_policy = 1,

.netns_ok = 1,

};

可见，通过发送AH数据包可以触发越界读写。

int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type)

(1)x = xfrm_state_lookup(net, mark, daddr, spi, nexthdr, family);//利用AH数据包数据找到对应的SA-xfrm_state

(2)x->repl->check(x, skb, seq) //x->repl 在 xfrm_init_replay赋值，可调用xfrm_replay_check_esn。调用xfrm_replay_check_esn进行检查，再调用xfrm_replay_recheck_esn再次检查

*replay_esn = x->replay_esn; // 找到的还是x->replay_esn成员

if (replay_esn->bmp[nr] & (1U << bitnr)) // 检查[1]处某bit是否为1，否则退出。即AH中的seq是否被处理过。

(3)x->repl->advance(x, seq); //调用xfrm_replay_advance_esn

replay_esn->bmp[nr] &= ~(1U << bitnr); //if 对于某一个bit执行&0，将导致某一个bit被置零

nr = (replay_esn->replay_window - 1) >> 5;

for (i = 0; i <= nr; i++)

replay_esn->bmp[i] = 0; // else 对从bmp[0]到bmp[(replay_esn->replay_window - 1) >> 5]块内存均置零

replay_esn->bmp[nr] |= (1U << bitnr); // 对某一个bit写1。

因此，通过用户态空间发送一个AH数据包将导致，一个bit的内存写，或者一段空间的置零。

二、漏洞触发与利用

1.Netlink内核协议解析

xfrm数据包的协议格式

/* ========================================================================

* Netlink Messages and Attributes Interface (As Seen On TV)

* ------------------------------------------------------------------------

* Messages Interface

* ------------------------------------------------------------------------

*

* Message Format:

*

*

* +----------+- - -+-------------+- - -+-------- - -

* | nlmsghdr | Pad | Payload | Pad | nlmsghdr

* +----------+- - -+-------------+- - -+-------- - -

* nlmsg_data(nlh)---^ ^

* nlmsg_next(nlh)-----------------------+

*

* Payload Format:

*

*

* +----------------------+- - -+--------------------------------+

* | Family Header | Pad | Attributes |

* +----------------------+- - -+--------------------------------+

* nlmsg_attrdata(nlh, hdrlen)---^

*

* Data Structures:

* struct nlmsghdr netlink message header

* ------------------------------------------------------------------------

* Attributes Interface

* ------------------------------------------------------------------------

*

* Attribute Format:

*

*

* +----------+- - -+- - - - - - - - - +- - -+-------- - -

* | Header | Pad | Payload | Pad | Header

* +----------+- - -+- - - - - - - - - +- - -+-------- - -

* ^

* nla_data(nla)----^ |

* nla_next(nla)-----------------------------'

*

* Data Structures:

* struct nlattr netlink attribute header

从上图可以看出，发送到内核的数据需要如下形式nlmsghdr + Family Header + n * (nla + data)。

首先从xfrm_netlink_rcv函数中调用netlink_rcv_skb函数，会检查nlmsg_type及nlmsg_len范围，并交由cb函数处理，其赋值为xfrm_user_rcv_msg。

int netlink_rcv_skb(struct sk_buff *skb, int (*cb)(struct sk_buff *,

struct nlmsghdr *))

{

struct nlmsghdr *nlh;

int err;

while (skb->len >= nlmsg_total_size(0)) {

int msglen;

nlh = nlmsg_hdr(skb);

err = 0;

if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len)

return 0;

/* Only requests are handled by the kernel */

if (!(nlh->nlmsg_flags & NLM_F_REQUEST))

goto ack;

/* Skip control messages */

if (nlh->nlmsg_type < NLMSG_MIN_TYPE)

goto ack;

err = cb(skb, nlh);

if (err == -EINTR)

goto skip;

ack:

if (nlh->nlmsg_flags & NLM_F_ACK || err)

netlink_ack(skb, nlh, err);

skip:

msglen = NLMSG_ALIGN(nlh->nlmsg_len);

if (msglen > skb->len)

msglen = skb->len;

skb_pull(skb, msglen);

}

return 0;

}

在xfrm_user_rcv_msg函数中，会根据nlmsg_type到xfrm_dispatch中查找对应要调用的函数，并在[2]处检查对应需要的权限，而在[3]处会根据nla中参数类型，来初始化一个** attr，作为用户输入参数的索引。最终调用link->doit去执行。

static int xfrm_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)

{

struct net *net = sock_net(skb->sk);

struct nlattr *attrs[XFRMA_MAX+1];

const struct xfrm_link *link;

int type, err;

#ifdef CONFIG_COMPAT

if (in_compat_syscall())

return -EOPNOTSUPP;

#endif

type = nlh->nlmsg_type;

if (type > XFRM_MSG_MAX)

return -EINVAL;

type -= XFRM_MSG_BASE;

[1] link = &xfrm_dispatch[type];

/* All operations require privileges, even GET */

[2] if (!netlink_net_capable(skb, CAP_NET_ADMIN)) //检查进程权限

return -EPERM;

if ((type == (XFRM_MSG_GETSA - XFRM_MSG_BASE) ||

type == (XFRM_MSG_GETPOLICY - XFRM_MSG_BASE)) &&

(nlh->nlmsg_flags & NLM_F_DUMP)) {

if (link->dump == NULL)

return -EINVAL;

{

struct netlink_dump_control c = {

.dump = link->dump,

.done = link->done,

};

return netlink_dump_start(net->xfrm.nlsk, skb, nlh, &c);

}

}

[3] err = nlmsg_parse(nlh, xfrm_msg_min[type], attrs,

link->nla_max ? : XFRMA_MAX,

link->nla_pol ? : xfrma_policy);

if (err < 0)

return err;

if (link->doit == NULL)

return -EINVAL;

return link->doit(skb, nlh, attrs);

}

从xfrm_dispatch可见，我们所需的XFRM_MSG_NEWSA及XFRM_MSG_NEWAE，仅需将nlmsg_type设置为相应值即可。 xfrm_dispatch见上述Linux内核的IPSEC实现。

而Family Header需要到对应的处理函数中找，以xfrm_add_sa为例，其调用nlmsg_data函数的赋值变量类型为xfrm_usresa_info，即为Family Header。

struct xfrm_usersa_info *p = nlmsg_data(nlh);

2.利用思路

(1)权限限制

权限限制：即是在上文中提到的netlink_net_capable(skb, CAP_NET_ADMIN)检查，所需为CAP_NET_ADMIN权限。但在Linux操作系统中存在命名空间这样的权限隔离机制，在每一个NET沙箱中，非ROOT进程可以具有CAP_NET_ADMIN权限。查看命名空间开启的方式为cat /boot/config* | grep CONFIG_USER_NS，若为「y」，则启用了命名空间。

namespace 是 Linux 内核用来隔离内核资源的方式(为虚拟化而生)。通过 namespace 可以让一些进程只能看到与自己相关的一部分资源，而另外一些进程也只能看到与它们自己相关的资源，这两拨进程根本就感觉不到对方的存在。具体的实现方式是把一个或多个进程的相关资源指定在同一个 namespace 中。 Linux namespaces 是对全局系统资源的一种封装隔离，使得处于不同 namespace 的进程拥有独立的全局系统资源，改变一个 namespace 中的系统资源只会影响当前 namespace 里的进程，对其他 namespace 中的进程没有影响。

绕过限制的两种方法：一是使用setcap命令为EXP赋予权限，即执行sudo setcap cap_net_raw,cap_net_admin=eip ./exp。二是仿照CVE-2017-7308中设置namespace sandbox，但注意此时无法利用getuid来判断是否为root用户。

(2)利用方法

绕过权限限制：在ubuntu，Fedora等发行版，User namespace是默认开启的。非特权用户可以创建用户命名空间、网络命名空间。在命名空间内部，我们就可以触发漏洞了。

越界写：xfrm_replay_advance_esn()函数对bitmap操作是清除[last seq, current seq)的bit；设置bmp[current seq] = 1。可以指定好spi、seq等参数(内核是根据spi的哈希值以及ip地址来确定SA的)，并让内核来处理我们发出的ESP数据包，多次进行这个操作即可达到对越界任意长度进行写入任意值。

越界读：本例不需要。构造两个相邻的replay_state结构(首先分配足够多的同样大小的replay_state结构把堆上原来的坑填满，之后便可大概率保证连续分配的replay_state结构是相邻的)，使用越界写，改大下一个replay_state_esn的结构中的bmp_len，之后利用下一个bitmap结构进行越界读。如下所示，为被改掉bmp_len的bitmap结构：

pwndbg> p *(struct xfrm_repaly_state_esn*)(0xffff9a6a28262b00+0x200)

$1 = {

bmp_len = 1024,

oseq = 0,

seq = 0,

oseq_hi = 0,

replay_window = 64,

bmp = 0xffff9a6a8262d18

}

绕过kASLR：利用xfrm_del_sa函数删除没用的xfrm_state，再向内核喷射很多struct file结构体填在这些坑里，最后利用越界读能力，可以泄露一些内核里的指针来算出内核的加载地址和bitmap的位置。

代码执行：构造内核rop，先在bitmap中伪造一个file_operations结构；再利用越界写改写刚在内核中喷射的struct file结构体的file_operations指针，使其指向合适的ROPgadget；调用llseek函数(实际上已经是rop gadget)；多次改写file_operations结构中的llseek函数指针来实现多次执行ROPgadget实现提权。 ？？？方法存疑，还能多次改seek指针？？？

(3)注意

xfrm_replay_advance_esn()中，先清0，后续的还有一个置位操作，所以构造好 replay_window seq seq_no三个值，将cred结构体清0之后，再将cred->usage值还原(调试这个值为2)。

利用伪代码：

/* 用于向内核发送信息, 然后生成/更新xfrm_state结构体的套接字 */

xfrm_state_fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_XFRM);

/* 用于接收IPPROTO_AH信息, 触发xfrm_input的接收套接字 */

recvfd = socket(AF_INET, SOCK_RAW, IPPROTO_AH);

/* 用于发送自定义数据包的发送套接字 */

sendfd = socket(AF_INET, SOCK_RAW, IPPROTO_AH);

alloc_xfrm_state(...);

update_esn(...);

trigger_oob(...);

内存布局：

xfrm_alloc_replay_state_esn函数中, 连续申请了两个esn 也就是说, 在alloc_xfrm_state函数之后, 内存布局是这样的

内存低地址 | xfrm_replay_state_esn 结构0 | xfrm_replay_state_esn 结构1 | cred 结构 | 高地址

在测试系统中， cred对象的大小为0xa8，对齐到kmalloc-192的slab块中，也即每个对象大小为0xc0。那么cred结构的相对于esn->bmp偏移为0xc0-0x18+0xc0，对应32位数据的数组索引，cred->usage的nr值为 (0xc0-0x18+0xc0)/4。 查看POC点这里

(4)数据包构造

本漏洞属于一个利用条件比较宽松的漏洞。首先，xfrm_replay_state_esn是一个变长的数据结构，而其长度可以由用户输入的bmp_len来控制，并由kzalloc申请bmp_len *4 + 0x18大小的内存块。其次，越界读写可以每次写1bit大小的数据，同时也可以将(replay_windows -1)>>5比特大小的内存块清空。

并且cred结构体的申请是通过prepare_creds中的new = kmem_cache_alloc(cred_jar, GFP_KERNEL);得到的，但在调试中发现，本内核的cred_jar是kmalloc-192。

1.jpg

根据内核分配使用的slub+伙伴算法可以知道，对于同一个kmem_cache分配出来的内存块有一定概率是相邻。因此一种很取巧的思路，就是将xfrm_replay_state_esn结构体设置为192(0xc0)以内，以利用kmalloc-192进行分配，并利用fork新建大量进程，使申请大量cred，这样喷射之后有很大概率越界读写漏洞存在的位置之后就是一个cred结构体，这样利用之前提到过的置零一段内存的操作就可以将cred结构体中的部分成员(uid gid等)置零，从而对该进程提权，并通过反弹shell就可以得到一个root权限的shell。

因此对于数据包构造主要根据上述思路。

xfrm_add_sa

在触发xfrm_add_sa函数的数据包中，需要满足128 < bmp_len * 4 +0x18 < 192。并且需要参考之前源码分析中的各项flag及参数检查。

xfrm_new_ae

在触发xfrm_new_ae函数的数据包中，需要对seq_hi、seq及replay_window进行设定，replay_window即将要置零的长度大小，由于连续申请了两块大小相同的结构体，而置零的时候是从第一次申请的位置操作的，有可能出现二者相邻，因此需要将replay_window设置稍大一些。而seq_hi、seq两个数据需要结合之后发送的ah数据包中的seq参数，引导xfrm_replay_advance_esn走向置零bmp[0]~bmp[n]这个分支。

AH数据包

AH数据包的要求即spi需要和之前申请SA的spi相同用于寻找xfrm_state，并且需要满足

diff >= replay_esn->replay_window，其中diff的数据由xfrm_replay_state_esn中的seq、seq_hi及AH的seq共同决定。还行需在后续单字节写的位置，将cred结构体中usage置回原值。

在xfrm_replay_advance_esn函数执行前后发现，相邻cred中的成员被置零。

2.jpg

3.jpg

参考：