nf_tables: remove explicit register zeroing
Subsystems (3)
Florian Westphal
maintainercover nf_tables: remove explicit register zeroing
Hi,
I'd like to propose this again.
First patch is preparation work.
Second patch is the actual change I'd like to get into nf-next.
The third patch partially un-does the second:
Instead of rejecting a rule that triggers uninitialised register access detection, do explicit zeroing from blob generator.
Please see patch 3 for a rationale why I think that we should just go with patch 1+2.
Patch 4 reverts the explicit zeroing.
Florian Westphal (4):
netfilter: nf_tables: pass context structure to
nft_parse_register_load
netfilter: nf_tables: allow loads only when register is initialized
netfilter: nf_tables: insert register zeroing instructions for dodgy
chains
netfilter: nf_tables: don't initialize registers in nft_do_chain()
include/net/netfilter/nf_tables.h | 14 ++- net/bridge/netfilter/nft_meta_bridge.c | 2 +- net/ipv4/netfilter/nft_dup_ipv4.c | 4 +- net/ipv6/netfilter/nft_dup_ipv6.c | 4 +- net/netfilter/nf_tables_api.c | 119 +++++++++++++++++++++++-- net/netfilter/nf_tables_core.c | 2 +- net/netfilter/nft_bitwise.c | 4 +- net/netfilter/nft_byteorder.c | 2 +- net/netfilter/nft_cmp.c | 6 +- net/netfilter/nft_ct.c | 2 +- net/netfilter/nft_dup_netdev.c | 2 +- net/netfilter/nft_dynset.c | 4 +- net/netfilter/nft_exthdr.c | 2 +- net/netfilter/nft_fwd_netdev.c | 6 +- net/netfilter/nft_hash.c | 2 +- net/netfilter/nft_lookup.c | 2 +- net/netfilter/nft_masq.c | 4 +- net/netfilter/nft_meta.c | 2 +- net/netfilter/nft_nat.c | 8 +- net/netfilter/nft_objref.c | 2 +- net/netfilter/nft_payload.c | 2 +- net/netfilter/nft_queue.c | 2 +- net/netfilter/nft_range.c | 2 +- net/netfilter/nft_redir.c | 4 +- net/netfilter/nft_tproxy.c | 4 +- 25 files changed, 159 insertions(+), 48 deletions(-)
Signature · 1 line
2.44.2
Florian Westphal
maintainerRFC 1/4 netfilter: nf_tables: pass context structure to nft_parse_register_load
Mechanical transformation, no logical changes intended.
--- include/net/netfilter/nf_tables.h | 3 ++- net/bridge/netfilter/nft_meta_bridge.c | 2 +- net/ipv4/netfilter/nft_dup_ipv4.c | 4 ++-- net/ipv6/netfilter/nft_dup_ipv6.c | 4 ++-- net/netfilter/nf_tables_api.c | 3 ++- net/netfilter/nft_bitwise.c | 4 ++-- net/netfilter/nft_byteorder.c | 2 +- net/netfilter/nft_cmp.c | 6 +++--- net/netfilter/nft_ct.c | 2 +- net/netfilter/nft_dup_netdev.c | 2 +- net/netfilter/nft_dynset.c | 4 ++-- net/netfilter/nft_exthdr.c | 2 +- net/netfilter/nft_fwd_netdev.c | 6 +++--- net/netfilter/nft_hash.c | 2 +- net/netfilter/nft_lookup.c | 2 +- net/netfilter/nft_masq.c | 4 ++-- net/netfilter/nft_meta.c | 2 +- net/netfilter/nft_nat.c | 8 ++++---- net/netfilter/nft_objref.c | 2 +- net/netfilter/nft_payload.c | 2 +- net/netfilter/nft_queue.c | 2 +- net/netfilter/nft_range.c | 2 +- net/netfilter/nft_redir.c | 4 ++-- net/netfilter/nft_tproxy.c | 4 ++-- 24 files changed, 40 insertions(+), 38 deletions(-)
include/net/netfilter/nf_tables.h +2 -1
@@ -254,7 +254,8 @@ static inline enum nft_registers nft_type_to_reg(enum nft_data_types type)int nft_parse_u32_check (const struct nlattr *attr,int max,u32 *dest);int nft_dump_register (struct sk_buff *skb,unsigned int attr,unsigned int reg); -int nft_parse_register_load (const struct nlattr *attr,u8 *sreg,u32 len); +int nft_parse_register_load (const struct nft_ctx *ctx, +const struct nlattr *attr,u8 *sreg,u32 len); int nft_parse_register_store(const struct nft_ctx *ctx, const struct nlattr *attr, u8 *dreg, const struct nft_data *data,
net/bridge/netfilter/nft_meta_bridge.c +1 -1
@@ -142,7 +142,7 @@ static int nft_meta_bridge_set_init(const struct nft_ctx *ctx, } priv->len = len; - err =nft_parse_register_load (tb[NFTA_META_SREG ], &priv->sreg, len); + err =nft_parse_register_load (ctx, tb[NFTA_META_SREG ], &priv->sreg, len);if (err <0 )return err;
net/ipv4/netfilter/nft_dup_ipv4.c +2 -2
@@ -40,13 +40,13 @@ static int nft_dup_ipv4_init(const struct nft_ctx *ctx,if (tb[NFTA_DUP_SREG_ADDR ] ==NULL )return -EINVAL ; - err =nft_parse_register_load (tb[NFTA_DUP_SREG_ADDR ], &priv->sreg_addr, + err =nft_parse_register_load (ctx, tb[NFTA_DUP_SREG_ADDR ], &priv->sreg_addr,sizeof (struct in_addr ));if (err <0 )return err;if (tb[NFTA_DUP_SREG_DEV ]) - err =nft_parse_register_load (tb[NFTA_DUP_SREG_DEV ], + err =nft_parse_register_load (ctx, tb[NFTA_DUP_SREG_DEV ], &priv->sreg_dev,sizeof (int ));return err;
net/ipv6/netfilter/nft_dup_ipv6.c +2 -2
@@ -38,13 +38,13 @@ static int nft_dup_ipv6_init(const struct nft_ctx *ctx,if (tb[NFTA_DUP_SREG_ADDR ] ==NULL )return -EINVAL ; - err =nft_parse_register_load (tb[NFTA_DUP_SREG_ADDR ], &priv->sreg_addr, + err =nft_parse_register_load (ctx, tb[NFTA_DUP_SREG_ADDR ], &priv->sreg_addr,sizeof (struct in6_addr ));if (err <0 )return err;if (tb[NFTA_DUP_SREG_DEV ]) - err =nft_parse_register_load (tb[NFTA_DUP_SREG_DEV ], + err =nft_parse_register_load (ctx, tb[NFTA_DUP_SREG_DEV ], &priv->sreg_dev,sizeof (int ));return err;
net/netfilter/nf_tables_api.c +2 -1
@@ -11102,7 +11102,8 @@ static int nft_validate_register_load(enum nft_registers reg, unsigned int len)return 0 ; } -int nft_parse_register_load (const struct nlattr *attr,u8 *sreg,u32 len) +int nft_parse_register_load (const struct nft_ctx *ctx, +const struct nlattr *attr,u8 *sreg,u32 len) {u32 reg;int err;
net/netfilter/nft_bitwise.c +2 -2
@@ -171,7 +171,7 @@ static int nft_bitwise_init(const struct nft_ctx *ctx, priv->len = len; - err =nft_parse_register_load (tb[NFTA_BITWISE_SREG ], &priv->sreg, + err =nft_parse_register_load (ctx, tb[NFTA_BITWISE_SREG ], &priv->sreg, priv->len);if (err <0 )return err;
@@ -365,7 +365,7 @@ static int nft_bitwise_fast_init(const struct nft_ctx *ctx,struct nft_bitwise_fast_expr *priv =nft_expr_priv (expr);int err; - err =nft_parse_register_load (tb[NFTA_BITWISE_SREG ], &priv->sreg, + err =nft_parse_register_load (ctx, tb[NFTA_BITWISE_SREG ], &priv->sreg,sizeof (u32));if (err <0 )return err;
net/netfilter/nft_byteorder.c +1 -1
@@ -139,7 +139,7 @@ static int nft_byteorder_init(const struct nft_ctx *ctx, priv->len = len; - err =nft_parse_register_load (tb[NFTA_BYTEORDER_SREG ], &priv->sreg, + err =nft_parse_register_load (ctx, tb[NFTA_BYTEORDER_SREG ], &priv->sreg, priv->len);if (err <0 )return err;
net/netfilter/nft_cmp.c +3 -3
@@ -83,7 +83,7 @@ static int nft_cmp_init(const struct nft_ctx *ctx, const struct nft_expr *expr,if (err <0 )return err; - err =nft_parse_register_load (tb[NFTA_CMP_SREG ], &priv->sreg, desc.len); + err =nft_parse_register_load (ctx, tb[NFTA_CMP_SREG ], &priv->sreg, desc.len);if (err <0 )return err;
@@ -222,7 +222,7 @@ static int nft_cmp_fast_init(const struct nft_ctx *ctx,if (err <0 )return err; - err =nft_parse_register_load (tb[NFTA_CMP_SREG ], &priv->sreg, desc.len); + err =nft_parse_register_load (ctx, tb[NFTA_CMP_SREG ], &priv->sreg, desc.len);if (err <0 )return err;
@@ -323,7 +323,7 @@ static int nft_cmp16_fast_init(const struct nft_ctx *ctx,if (err <0 )return err; - err =nft_parse_register_load (tb[NFTA_CMP_SREG ], &priv->sreg, desc.len); + err =nft_parse_register_load (ctx, tb[NFTA_CMP_SREG ], &priv->sreg, desc.len);if (err <0 )return err;
net/netfilter/nft_ct.c +1 -1
@@ -606,7 +606,7 @@ static int nft_ct_set_init(const struct nft_ctx *ctx, } priv->len = len; - err =nft_parse_register_load (tb[NFTA_CT_SREG ], &priv->sreg, len); + err =nft_parse_register_load (ctx, tb[NFTA_CT_SREG ], &priv->sreg, len);if (err <0 ) goto err1;
net/netfilter/nft_dup_netdev.c +1 -1
@@ -40,7 +40,7 @@ static int nft_dup_netdev_init(const struct nft_ctx *ctx,if (tb[NFTA_DUP_SREG_DEV ] ==NULL )return -EINVAL ; -return nft_parse_register_load (tb[NFTA_DUP_SREG_DEV ], &priv->sreg_dev, +return nft_parse_register_load (ctx, tb[NFTA_DUP_SREG_DEV ], &priv->sreg_dev,sizeof (int )); }
net/netfilter/nft_dynset.c +2 -2
@@ -215,7 +215,7 @@ static int nft_dynset_init(const struct nft_ctx *ctx,return err; } - err =nft_parse_register_load (tb[NFTA_DYNSET_SREG_KEY ], &priv->sreg_key, + err =nft_parse_register_load (ctx, tb[NFTA_DYNSET_SREG_KEY ], &priv->sreg_key, set->klen);if (err <0 )return err;
@@ -226,7 +226,7 @@ static int nft_dynset_init(const struct nft_ctx *ctx,if (set->dtype ==NFT_DATA_VERDICT )return -EOPNOTSUPP ; - err =nft_parse_register_load (tb[NFTA_DYNSET_SREG_DATA ], + err =nft_parse_register_load (ctx, tb[NFTA_DYNSET_SREG_DATA ], &priv->sreg_data, set->dlen);if (err <0 )return err;
net/netfilter/nft_exthdr.c +1 -1
@@ -588,7 +588,7 @@ static int nft_exthdr_tcp_set_init(const struct nft_ctx *ctx, priv->flags = flags; priv->op = op; -return nft_parse_register_load (tb[NFTA_EXTHDR_SREG ], &priv->sreg, +return nft_parse_register_load (ctx, tb[NFTA_EXTHDR_SREG ], &priv->sreg, priv->len); }
net/netfilter/nft_fwd_netdev.c +3 -3
@@ -52,7 +52,7 @@ static int nft_fwd_netdev_init(const struct nft_ctx *ctx,if (tb[NFTA_FWD_SREG_DEV ] ==NULL )return -EINVAL ; -return nft_parse_register_load (tb[NFTA_FWD_SREG_DEV ], &priv->sreg_dev, +return nft_parse_register_load (ctx, tb[NFTA_FWD_SREG_DEV ], &priv->sreg_dev,sizeof (int )); }
@@ -178,12 +178,12 @@ static int nft_fwd_neigh_init(const struct nft_ctx *ctx,return -EOPNOTSUPP ; } - err =nft_parse_register_load (tb[NFTA_FWD_SREG_DEV ], &priv->sreg_dev, + err =nft_parse_register_load (ctx, tb[NFTA_FWD_SREG_DEV ], &priv->sreg_dev,sizeof (int ));if (err <0 )return err; -return nft_parse_register_load (tb[NFTA_FWD_SREG_ADDR ], &priv->sreg_addr, +return nft_parse_register_load (ctx, tb[NFTA_FWD_SREG_ADDR ], &priv->sreg_addr, addr_len); }
net/netfilter/nft_hash.c +1 -1
@@ -92,7 +92,7 @@ static int nft_jhash_init(const struct nft_ctx *ctx, priv->len = len; - err =nft_parse_register_load (tb[NFTA_HASH_SREG ], &priv->sreg, len); + err =nft_parse_register_load (ctx, tb[NFTA_HASH_SREG ], &priv->sreg, len);if (err <0 )return err;
net/netfilter/nft_lookup.c +1 -1
@@ -113,7 +113,7 @@ static int nft_lookup_init(const struct nft_ctx *ctx,if (IS_ERR (set))return PTR_ERR (set); - err =nft_parse_register_load (tb[NFTA_LOOKUP_SREG ], &priv->sreg, + err =nft_parse_register_load (ctx, tb[NFTA_LOOKUP_SREG ], &priv->sreg, set->klen);if (err <0 )return err;
net/netfilter/nft_masq.c +2 -2
@@ -52,13 +52,13 @@ static int nft_masq_init(const struct nft_ctx *ctx, priv->flags =ntohl (nla_get_be32 (tb[NFTA_MASQ_FLAGS ]));if (tb[NFTA_MASQ_REG_PROTO_MIN ]) { - err =nft_parse_register_load (tb[NFTA_MASQ_REG_PROTO_MIN ], + err =nft_parse_register_load (ctx, tb[NFTA_MASQ_REG_PROTO_MIN ], &priv->sreg_proto_min, plen);if (err <0 )return err;if (tb[NFTA_MASQ_REG_PROTO_MAX ]) { - err =nft_parse_register_load (tb[NFTA_MASQ_REG_PROTO_MAX ], + err =nft_parse_register_load (ctx, tb[NFTA_MASQ_REG_PROTO_MAX ], &priv->sreg_proto_max, plen);if (err <0 )
net/netfilter/nft_meta.c +1 -1
@@ -657,7 +657,7 @@ int nft_meta_set_init(const struct nft_ctx *ctx, } priv->len = len; - err =nft_parse_register_load (tb[NFTA_META_SREG ], &priv->sreg, len); + err =nft_parse_register_load (ctx, tb[NFTA_META_SREG ], &priv->sreg, len);if (err <0 )return err;
net/netfilter/nft_nat.c +4 -4
@@ -214,13 +214,13 @@ static int nft_nat_init(const struct nft_ctx *ctx, const struct nft_expr *expr, priv->family = family;if (tb[NFTA_NAT_REG_ADDR_MIN ]) { - err =nft_parse_register_load (tb[NFTA_NAT_REG_ADDR_MIN ], + err =nft_parse_register_load (ctx, tb[NFTA_NAT_REG_ADDR_MIN ], &priv->sreg_addr_min, alen);if (err <0 )return err;if (tb[NFTA_NAT_REG_ADDR_MAX ]) { - err =nft_parse_register_load (tb[NFTA_NAT_REG_ADDR_MAX ], + err =nft_parse_register_load (ctx, tb[NFTA_NAT_REG_ADDR_MAX ], &priv->sreg_addr_max, alen);if (err <0 )
@@ -234,13 +234,13 @@ static int nft_nat_init(const struct nft_ctx *ctx, const struct nft_expr *expr, plen = sizeof_field(struct nf_nat_range, min_proto.all);if (tb[NFTA_NAT_REG_PROTO_MIN ]) { - err =nft_parse_register_load (tb[NFTA_NAT_REG_PROTO_MIN ], + err =nft_parse_register_load (ctx, tb[NFTA_NAT_REG_PROTO_MIN ], &priv->sreg_proto_min, plen);if (err <0 )return err;if (tb[NFTA_NAT_REG_PROTO_MAX ]) { - err =nft_parse_register_load (tb[NFTA_NAT_REG_PROTO_MAX ], + err =nft_parse_register_load (ctx, tb[NFTA_NAT_REG_PROTO_MAX ], &priv->sreg_proto_max, plen);if (err <0 )
net/netfilter/nft_objref.c +1 -1
@@ -143,7 +143,7 @@ static int nft_objref_map_init(const struct nft_ctx *ctx,if (!(set->flags &NFT_SET_OBJECT ))return -EINVAL ; - err =nft_parse_register_load (tb[NFTA_OBJREF_SET_SREG ], &priv->sreg, + err =nft_parse_register_load (ctx, tb[NFTA_OBJREF_SET_SREG ], &priv->sreg, set->klen);if (err <0 )return err;
net/netfilter/nft_payload.c +1 -1
@@ -981,7 +981,7 @@ static int nft_payload_set_init(const struct nft_ctx *ctx, } priv->csum_type = csum_type; -return nft_parse_register_load (tb[NFTA_PAYLOAD_SREG ], &priv->sreg, +return nft_parse_register_load (ctx, tb[NFTA_PAYLOAD_SREG ], &priv->sreg, priv->len); }
net/netfilter/nft_queue.c +1 -1
@@ -136,7 +136,7 @@ static int nft_queue_sreg_init(const struct nft_ctx *ctx,struct nft_queue *priv =nft_expr_priv (expr);int err; - err =nft_parse_register_load (tb[NFTA_QUEUE_SREG_QNUM ], + err =nft_parse_register_load (ctx, tb[NFTA_QUEUE_SREG_QNUM ], &priv->sreg_qnum,sizeof (u32));if (err <0 )return err;
net/netfilter/nft_range.c +1 -1
@@ -83,7 +83,7 @@ static int nft_range_init(const struct nft_ctx *ctx, const struct nft_expr *expr goto err2; } - err =nft_parse_register_load (tb[NFTA_RANGE_SREG ], &priv->sreg, + err =nft_parse_register_load (ctx, tb[NFTA_RANGE_SREG ], &priv->sreg, desc_from.len);if (err <0 ) goto err2;
net/netfilter/nft_redir.c +2 -2
@@ -51,13 +51,13 @@ static int nft_redir_init(const struct nft_ctx *ctx, plen = sizeof_field(struct nf_nat_range, min_proto.all);if (tb[NFTA_REDIR_REG_PROTO_MIN ]) { - err =nft_parse_register_load (tb[NFTA_REDIR_REG_PROTO_MIN ], + err =nft_parse_register_load (ctx, tb[NFTA_REDIR_REG_PROTO_MIN ], &priv->sreg_proto_min, plen);if (err <0 )return err;if (tb[NFTA_REDIR_REG_PROTO_MAX ]) { - err =nft_parse_register_load (tb[NFTA_REDIR_REG_PROTO_MAX ], + err =nft_parse_register_load (ctx, tb[NFTA_REDIR_REG_PROTO_MAX ], &priv->sreg_proto_max, plen);if (err <0 )
net/netfilter/nft_tproxy.c +2 -2
@@ -254,14 +254,14 @@ static int nft_tproxy_init(const struct nft_ctx *ctx, }if (tb[NFTA_TPROXY_REG_ADDR ]) { - err =nft_parse_register_load (tb[NFTA_TPROXY_REG_ADDR ], + err =nft_parse_register_load (ctx, tb[NFTA_TPROXY_REG_ADDR ], &priv->sreg_addr, alen);if (err <0 )return err; }if (tb[NFTA_TPROXY_REG_PORT ]) { - err =nft_parse_register_load (tb[NFTA_TPROXY_REG_PORT ], + err =nft_parse_register_load (ctx, tb[NFTA_TPROXY_REG_PORT ], &priv->sreg_port,sizeof (u16));if (err <0 )return err;
Signature · 1 line
2.44.2
Florian Westphal
maintainerRFC 2/4 netfilter: nf_tables: allow loads only when register is initialized
In reply to Florian WestphalReject rules where a load occurs from a register that has not seen a store early in the same rule.
commit 4c905f6740a3 ("netfilter: nf_tables: initialize registers in nft_do_chain()")
had to add a unconditional memset to the nftables register space to avoid leaking stack information to userspace.
This memset shows up in benchmarks. After this change, this commit can be reverted again.
Note that this breaks userspace compatibility, because theoretically you can do
rule 1: reg2 := meta load iif, reg2 == 1 jump ...
rule 2: reg2 == 2 jump ... // read access with no store in this rule
... after this change this is rejected.
Neither nftables nor iptables-nft generate such rules, each rule is always standalone.
This resuts in a small increase of nft_ctx structure by sizeof(long).
To cope with hypothetical rulesets like the example above we could emit on-demand "reg[x] = 0" store when generating the datapath blob in nf_tables_commit_chain_prepare(). Followup patch adds this.
--- include/net/netfilter/nf_tables.h | 1 + net/netfilter/nf_tables_api.c | 38 +++++++++++++++++++++++++++---- 2 files changed, 35 insertions(+), 4 deletions(-)
include/net/netfilter/nf_tables.h +1 -0
@@ -221,6 +221,7 @@ struct nft_ctx {u8 family;u8 level;bool report; +DECLARE_BITMAP (reg_inited,NFT_REG32_NUM ); };enum nft_data_desc_flags {
net/netfilter/nf_tables_api.c +34 -4
@@ -146,6 +146,8 @@ static void nft_ctx_init(struct nft_ctx *ctx, ctx->report =nlmsg_report (nlh); ctx->flags = nlh->nlmsg_flags; ctx->seq = nlh->nlmsg_seq; + +bitmap_zero (ctx->reg_inited,NFT_REG32_NUM ); } static struct nft_trans *nft_trans_alloc_gfp(const struct nft_ctx *ctx,
@@ -11105,8 +11107,8 @@ static int nft_validate_register_load(enum nft_registers reg, unsigned int len)int nft_parse_register_load (const struct nft_ctx *ctx,const struct nlattr *attr,u8 *sreg,u32 len) { -u32 reg; -int err; +int err, invalid_reg; +u32 reg, next_register; err =nft_parse_register (attr, ®);if (err <0 )
@@ -11116,11 +11118,36 @@ int nft_parse_register_load(const struct nft_ctx *ctx,if (err <0 )return err; + next_register =DIV_ROUND_UP (len,NFT_REG32_SIZE ) + reg; + +/* Can't happen: nft_validate_register_load() should have failed */ +if (WARN_ON_ONCE (next_register >NFT_REG32_NUM )) +return -EINVAL ; + +/* find first register that did not see an earlier store. */ + invalid_reg =find_next_zero_bit (ctx->reg_inited,NFT_REG32_NUM , reg); + +/* invalid register within the range that we're loading from? */ +if (invalid_reg < next_register) +return -ENODATA ; + *sreg = reg;return 0 ; }EXPORT_SYMBOL_GPL (nft_parse_register_load); +static void nft_saw_register_store (const struct nft_ctx *__ctx, +int reg,unsigned int len) +{ +unsigned int registers =DIV_ROUND_UP (len,NFT_REG32_SIZE ); +struct nft_ctx *ctx = (struct nft_ctx *)__ctx; + +if (WARN_ON_ONCE (len ==0 || reg <0 )) +return ; + +bitmap_set (ctx->reg_inited, reg, registers); +} + static int nft_validate_register_store(const struct nft_ctx *ctx, enum nft_registers reg, const struct nft_data *data,
@@ -11142,7 +11169,7 @@ static int nft_validate_register_store(const struct nft_ctx *ctx,return err; } -return 0 ; +break ;default :if (reg <NFT_REG_1 *NFT_REG_SIZE /NFT_REG32_SIZE )return -EINVAL ;
@@ -11154,8 +11181,11 @@ static int nft_validate_register_store(const struct nft_ctx *ctx,if (data !=NULL && type !=NFT_DATA_VALUE )return -EINVAL ; -return 0 ; +break ; } + +nft_saw_register_store (ctx, reg, len); +return 0 ; } int nft_parse_register_store(const struct nft_ctx *ctx,
Signature · 1 line
2.44.2
Pablo Neira Ayuso
maintainerRe: [RFC nf-next 2/4] netfilter: nf_tables: allow loads only when register is initialized
Quoted 13 lines · Florian Westphal
net/netfilter/nf_tables_api.c +2
-2@@ -11105,8 +11107,8 @@ static int nft_validate_register_load(enum nft_registers reg, unsigned int len)int nft_parse_register_load (const struct nft_ctx *ctx,const struct nlattr *attr,u8 *sreg,u32 len) { -u32 reg; -int err; +int err, invalid_reg; +u32 reg, next_register; err =nft_parse_register (attr, ®);if (err <0 )@@ -11116,11 +11118,36 @@ int nft_parse_register_load(const struct nft_ctx *ctx,if (err <0 )
net/netfilter/nf_tables_api.c int nft_parse_register_load(const struct nft_ctx *ctx, · line 11128
Quoted 10 lines
net/netfilter/nf_tables_api.c +8
-0return err; + next_register =DIV_ROUND_UP (len,NFT_REG32_SIZE ) + reg; + +/* Can't happen: nft_validate_register_load() should have failed */ +if (WARN_ON_ONCE (next_register >NFT_REG32_NUM )) +return -EINVAL ; + +/* find first register that did not see an earlier store. */ + invalid_reg =find_next_zero_bit (ctx->reg_inited,NFT_REG32_NUM , reg);
Is this assuming that register allocation from userspace is done secuencially?
Quoted 8 lines
net/netfilter/nf_tables_api.c +4
-0+/* invalid register within the range that we're loading from? */ +if (invalid_reg < next_register) +return -ENODATA ; + *sreg = reg;return 0 ; }EXPORT_SYMBOL_GPL (nft_parse_register_load);
Florian Westphal
maintainerRe: [RFC nf-next 2/4] netfilter: nf_tables: allow loads only when register is initialized
Quoted 10 lines · Pablo Neira Ayuso
net/netfilter/nf_tables_api.c int nft_parse_register_load(const struct nft_ctx *ctx, · line 11128
Quoted 8 lines
net/netfilter/nf_tables_api.c +8
-0+ next_register =DIV_ROUND_UP (len,NFT_REG32_SIZE ) + reg; + +/* Can't happen: nft_validate_register_load() should have failed */ +if (WARN_ON_ONCE (next_register >NFT_REG32_NUM )) +return -EINVAL ; + +/* find first register that did not see an earlier store. */ + invalid_reg =find_next_zero_bit (ctx->reg_inited,NFT_REG32_NUM , reg);Is this assuming that register allocation from userspace is done secuencially?
No, that would be a bug.
Each set bit represents a register, if the bit is 1, the register saw a store.
The above is the load check: load is from register "reg", and we check the first reg that did not see a store (is 0), starting from reg. The result (register with undefined content) needs to be larger than next_register, which is the register coming after the current access (can be NFT_REG32_NUM, in that case no furhter registers exist and access is ok).
Quoted 4 lines
net/netfilter/nf_tables_api.c int nft_parse_register_load(const struct nft_ctx *ctx, · line 11133
Quoted 4 lines
net/netfilter/nf_tables_api.c +4
-0+/* invalid register within the range that we're loading from? */ +if (invalid_reg < next_register) +return -ENODATA ; +
This means that in range the relevant access range [reg,next_reg) the is at least on register that did not see a store.
Florian Westphal
maintainerRFC 3/4 netfilter: nf_tables: insert register zeroing instructions for dodgy chains
In reply to Florian WestphalInstead of rejecting rules that read from registers that saw no store, insert nft_imm instruction preamble when building the ruleset blob.
Once any rule triggers 'uninitied access', table gets marked as need-rebuild, then all base-chains in the affected table are regenerated.
Known drawback: 'nft monitor trace' may show 'unkown rule handle 0 verdict continue' when this auto-zero is active.
If this is unwanted, the trace infra in kernel could be patched to suppress notification for handle-0 rules.
As normal rulesets generated by nft or iptables-nft never cause such uninitialised reads this allows to revert the forced zeroing in the next patch.
I would not add this patch and keep the reject behaviour, as the nftables uapi is specifically built around the rule being a standalone object. I also question if it makes real sense to do such preload from userspace, it has little benefit for well-formed (non-repetitive) rulesets.
--- include/net/netfilter/nf_tables.h | 10 +++- net/netfilter/nf_tables_api.c | 82 ++++++++++++++++++++++++++++--- 2 files changed, 85 insertions(+), 7 deletions(-)
include/net/netfilter/nf_tables.h +9 -1
@@ -221,6 +221,7 @@ struct nft_ctx {u8 family;u8 level;bool report; +bool reg_bad;DECLARE_BITMAP (reg_inited,NFT_REG32_NUM ); };
@@ -1247,6 +1248,12 @@ static inline void nft_use_inc_restore(u32 *use)#define nft_use_dec_restore nft_use_dec +enum nft_need_reg_zeroing { +NFT_REG_ZERO_NO , +NFT_REG_ZERO_NEED , +NFT_REG_ZERO_ON , +}; +/** * struct nft_table - nf_tables table *
@@ -1283,9 +1290,10 @@ struct nft_table { genmask:2 ;u32 nlpid;char *name; -u16 udlen;u8 *udata; +u16 udlen;u8 validate_state; + enum nft_need_reg_zeroing zero_basechains:8; };static inline bool nft_table_has_owner (const struct nft_table *table)
net/netfilter/nf_tables_api.c +76 -6
133 lines not on this page · raw message
Signature · 1 line
2.44.2
Pablo Neira Ayuso
maintainerRe: [RFC nf-next 3/4] netfilter: nf_tables: insert register zeroing instructions for dodgy chains
Quoted 11 lines · Florian Westphal
Instead of rejecting rules that read from registers that saw no store, insert
nft_imminstruction preamble when building the ruleset blob.Once any rule triggers 'uninitied access', table gets marked as need-rebuild, then all base-chains in the affected table are regenerated.
Known drawback: 'nft monitor trace' may show 'unkown rule handle 0 verdict continue' when this auto-zero is active.
If this is unwanted, the trace infra in kernel could be patched to suppress notification for handle-0 rules.
Quoted 8 lines
As normal rulesets generated by nft or iptables-nft never cause such uninitialised reads this allows to revert the forced zeroing in the next patch.
I would not add this patch and keep the reject behaviour, as the nftables uapi is specifically built around the rule being a standalone object. I also question if it makes real sense to do such preload from userspace, it has little benefit for well-formed (non-repetitive) rulesets.
I am afraid there won't be an easy way to revert this in this future?
Is there any specific concern you have? Buggy validation allowing to access uninitialized registers? In that case, there is a need to improve test infrastructure to exercise this code more.
Thanks.
Florian Westphal
maintainerRe: [RFC nf-next 3/4] netfilter: nf_tables: insert register zeroing instructions for dodgy chains
Quoted 10 lines · Pablo Neira Ayuso
Quoted 4 lines
I would not add this patch and keep the reject behaviour, as the nftables uapi is specifically built around the rule being a standalone object. I also question if it makes real sense to do such preload from userspace, it has little benefit for well-formed (non-repetitive) rulesets.
I am afraid there won't be an easy way to revert this in this future?
Is there any specific concern you have? Buggy validation allowing to access uninitialized registers? In that case, there is a need to improve test infrastructure to exercise this code more.
Yes, for one thing, but I also do not see how we can ever move to a model where registers are re-used by subsequent rules, its incompatible with the rule-is-smallest-replaceable-object design.
(Meaning: userspace needs to be fully cooperative and aware that
it cannot insert a random rule at location x).
Pablo Neira Ayuso
maintainerRe: [RFC nf-next 3/4] netfilter: nf_tables: insert register zeroing instructions for dodgy chains
Quoted 8 lines · Florian Westphal
Quoted 7 lines · Pablo Neira Ayuso
Quoted 4 lines
I would not add this patch and keep the reject behaviour, as the nftables uapi is specifically built around the rule being a standalone object. I also question if it makes real sense to do such preload from userspace, it has little benefit for well-formed (non-repetitive) rulesets.
I am afraid there won't be an easy way to revert this in this future?
Quoted 7 lines
Quoted 3 lines
Is there any specific concern you have? Buggy validation allowing to access uninitialized registers? In that case, there is a need to improve test infrastructure to exercise this code more.
Yes, for one thing, but I also do not see how we can ever move to a model where registers are re-used by subsequent rules, its incompatible with the rule-is-smallest-replaceable-object design.
Yes, incremental updates are an issue. Another possibility is to add support for static rulesets, so there is a simple way for userspace to recycle registers (this would be fully performed from userspace).
And users can still inject raw bytecode to make their own programs. We have been discussing that dumping a listing with bytecode that cannot be interpreted is an option to deal with "forward compatibility", similar approach could help deal with this.
If your concern is the register tracking from the kernel, I am not pursuing that approach anymore and I can make a patch to ditch it after this series.
Quoted 2 lines
(Meaning: userspace needs to be fully cooperative and aware that
it cannot insert a random rule at location x).
Florian Westphal
maintainerRFC 4/4 netfilter: nf_tables: don't initialize registers in nft_do_chain()
In reply to Florian Westphalrevert commit 4c905f6740a3 ("netfilter: nf_tables: initialize registers in nft_do_chain()").
Previous patch makes sure that loads from uninitialized registers are detected from the control plane. in this case rule blob auto-zeroes registers. Thus the explicit zeroing is not needed anymore.
--- net/netfilter/nf_tables_core.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
net/netfilter/nf_tables_core.c +1 -1
@@ -256,7 +256,7 @@ nft_do_chain(struct nft_pktinfo *pkt, void *priv)const struct net *net =nft_net (pkt);const struct nft_expr *expr, *last;const struct nft_rule_dp *rule; -struct nft_regs regs = {}; +struct nft_regs regs;unsigned int stackptr =0 ;struct nft_jumpstack jumpstack[NFT_JUMP_STACK_SIZE ];bool genbit =READ_ONCE (net->nft.gencursor);
Signature · 1 line
2.44.2