net/netfilter/nf_tables_core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2008 Patrick McHardy <kaber@trash.net>
   4  *
   5  * Development of this code funded by Astaro AG (http://www.astaro.com/)
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/module.h>
  10 #include <linux/init.h>
  11 #include <linux/list.h>
  12 #include <linux/rculist.h>
  13 #include <linux/skbuff.h>
  14 #include <linux/netlink.h>
  15 #include <linux/netfilter.h>
  16 #include <linux/static_key.h>
  17 #include <linux/netfilter/nfnetlink.h>
  18 #include <linux/netfilter/nf_tables.h>
  19 #include <net/netfilter/nf_tables_core.h>
  20 #include <net/netfilter/nf_tables.h>
  21 #include <net/netfilter/nf_log.h>
  22 #include <net/netfilter/nft_meta.h>
  23
  24 static noinline void __nft_trace_packet(struct nft_traceinfo *info,
  25                                         const struct nft_chain *chain,
  26                                         enum nft_trace_types type)
  27 {
  28         const struct nft_pktinfo *pkt = info->pkt;
  29
  30         if (!info->trace || !pkt->skb->nf_trace)
  31                 return;
  32
  33         info->chain = chain;
  34         info->type = type;
  35
  36         nft_trace_notify(info);
  37 }
  38
  39 static inline void nft_trace_packet(struct nft_traceinfo *info,
  40                                     const struct nft_chain *chain,
  41                                     const struct nft_rule *rule,
  42                                     enum nft_trace_types type)
  43 {
  44         if (static_branch_unlikely(&nft_trace_enabled)) {
  45                 info->rule = rule;
  46                 __nft_trace_packet(info, chain, type);
  47         }
  48 }
  49
  50 static void nft_bitwise_fast_eval(const struct nft_expr *expr,
  51                                   struct nft_regs *regs)
  52 {
  53         const struct nft_bitwise_fast_expr *priv = nft_expr_priv(expr);
  54         u32 *src = &regs->data[priv->sreg];
  55         u32 *dst = &regs->data[priv->dreg];
  56
  57         *dst = (*src & priv->mask) ^ priv->xor;
  58 }
  59
  60 static void nft_cmp_fast_eval(const struct nft_expr *expr,
  61                               struct nft_regs *regs)
  62 {
  63         const struct nft_cmp_fast_expr *priv = nft_expr_priv(expr);
  64
  65         if (((regs->data[priv->sreg] & priv->mask) == priv->data) ^ priv->inv)
  66                 return;
  67         regs->verdict.code = NFT_BREAK;
  68 }
  69
  70 static void nft_cmp16_fast_eval(const struct nft_expr *expr,
  71                                 struct nft_regs *regs)
  72 {
  73         const struct nft_cmp16_fast_expr *priv = nft_expr_priv(expr);
  74         const u64 *reg_data = (const u64 *)&regs->data[priv->sreg];
  75         const u64 *mask = (const u64 *)&priv->mask;
  76         const u64 *data = (const u64 *)&priv->data;
  77
  78         if (((reg_data[0] & mask[0]) == data[0] &&
  79             ((reg_data[1] & mask[1]) == data[1])) ^ priv->inv)
  80                 return;
  81         regs->verdict.code = NFT_BREAK;
  82 }
  83
  84 static noinline void __nft_trace_verdict(struct nft_traceinfo *info,
  85                                          const struct nft_chain *chain,
  86                                          const struct nft_regs *regs)
  87 {
  88         enum nft_trace_types type;
  89
  90         switch (regs->verdict.code) {
  91         case NFT_CONTINUE:
  92         case NFT_RETURN:
  93                 type = NFT_TRACETYPE_RETURN;
  94                 break;
  95         default:
  96                 type = NFT_TRACETYPE_RULE;
  97                 break;
  98         }
  99
 100         __nft_trace_packet(info, chain, type);
 101 }
 102
 103 static inline void nft_trace_verdict(struct nft_traceinfo *info,
 104                                      const struct nft_chain *chain,
 105                                      const struct nft_rule *rule,
 106                                      const struct nft_regs *regs)
 107 {
 108         if (static_branch_unlikely(&nft_trace_enabled)) {
 109                 info->rule = rule;
 110                 __nft_trace_verdict(info, chain, regs);
 111         }
 112 }
 113
 114 static bool nft_payload_fast_eval(const struct nft_expr *expr,
 115                                   struct nft_regs *regs,
 116                                   const struct nft_pktinfo *pkt)
 117 {
 118         const struct nft_payload *priv = nft_expr_priv(expr);
 119         const struct sk_buff *skb = pkt->skb;
 120         u32 *dest = &regs->data[priv->dreg];
 121         unsigned char *ptr;
 122
 123         if (priv->base == NFT_PAYLOAD_NETWORK_HEADER)
 124                 ptr = skb_network_header(skb);
 125         else {
 126                 if (!(pkt->flags & NFT_PKTINFO_L4PROTO))
 127                         return false;
 128                 ptr = skb_network_header(skb) + nft_thoff(pkt);
 129         }
 130
 131         ptr += priv->offset;
 132
 133         if (unlikely(ptr + priv->len > skb_tail_pointer(skb)))
 134                 return false;
 135
 136         *dest = 0;
 137         if (priv->len == 2)
 138                 *(u16 *)dest = *(u16 *)ptr;
 139         else if (priv->len == 4)
 140                 *(u32 *)dest = *(u32 *)ptr;
 141         else
 142                 *(u8 *)dest = *(u8 *)ptr;
 143         return true;
 144 }
 145
 146 DEFINE_STATIC_KEY_FALSE(nft_counters_enabled);
 147
 148 static noinline void nft_update_chain_stats(const struct nft_chain *chain,
 149                                             const struct nft_pktinfo *pkt)
 150 {
 151         struct nft_base_chain *base_chain;
 152         struct nft_stats __percpu *pstats;
 153         struct nft_stats *stats;
 154
 155         base_chain = nft_base_chain(chain);
 156
 157         rcu_read_lock();
 158         pstats = READ_ONCE(base_chain->stats);
 159         if (pstats) {
 160                 local_bh_disable();
 161                 stats = this_cpu_ptr(pstats);
 162                 u64_stats_update_begin(&stats->syncp);
 163                 stats->pkts++;
 164                 stats->bytes += pkt->skb->len;
 165                 u64_stats_update_end(&stats->syncp);
 166                 local_bh_enable();
 167         }
 168         rcu_read_unlock();
 169 }
 170
 171 struct nft_jumpstack {
 172         const struct nft_chain  *chain;
 173         struct nft_rule *const *rules;
 174 };
 175
 176 static void expr_call_ops_eval(const struct nft_expr *expr,
 177                                struct nft_regs *regs,
 178                                struct nft_pktinfo *pkt)
 179 {
 180 #ifdef CONFIG_RETPOLINE
 181         unsigned long e = (unsigned long)expr->ops->eval;
 182 #define X(e, fun) \
 183         do { if ((e) == (unsigned long)(fun)) \
 184                 return fun(expr, regs, pkt); } while (0)
 185
 186         X(e, nft_payload_eval);
 187         X(e, nft_cmp_eval);
 188         X(e, nft_meta_get_eval);
 189         X(e, nft_lookup_eval);
 190         X(e, nft_range_eval);
 191         X(e, nft_immediate_eval);
 192         X(e, nft_byteorder_eval);
 193         X(e, nft_dynset_eval);
 194         X(e, nft_rt_get_eval);
 195         X(e, nft_bitwise_eval);
 196 #undef  X
 197 #endif /* CONFIG_RETPOLINE */
 198         expr->ops->eval(expr, regs, pkt);
 199 }
 200
 201 unsigned int
 202 nft_do_chain(struct nft_pktinfo *pkt, void *priv)
 203 {
 204         const struct nft_chain *chain = priv, *basechain = chain;
 205         const struct net *net = nft_net(pkt);
 206         struct nft_rule *const *rules;
 207         const struct nft_rule *rule;
 208         const struct nft_expr *expr, *last;
 209         struct nft_regs regs = {};
 210         unsigned int stackptr = 0;
 211         struct nft_jumpstack jumpstack[NFT_JUMP_STACK_SIZE];
 212         bool genbit = READ_ONCE(net->nft.gencursor);
 213         struct nft_traceinfo info;
 214
 215         info.trace = false;
 216         if (static_branch_unlikely(&nft_trace_enabled))
 217                 nft_trace_init(&info, pkt, &regs.verdict, basechain);
 218 do_chain:
 219         if (genbit)
 220                 rules = rcu_dereference(chain->rules_gen_1);
 221         else
 222                 rules = rcu_dereference(chain->rules_gen_0);
 223
 224 next_rule:
 225         rule = *rules;
 226         regs.verdict.code = NFT_CONTINUE;
 227         for (; *rules ; rules++) {
 228                 rule = *rules;
 229                 nft_rule_for_each_expr(expr, last, rule) {
 230                         if (expr->ops == &nft_cmp_fast_ops)
 231                                 nft_cmp_fast_eval(expr, &regs);
 232                         else if (expr->ops == &nft_cmp16_fast_ops)
 233                                 nft_cmp16_fast_eval(expr, &regs);
 234                         else if (expr->ops == &nft_bitwise_fast_ops)
 235                                 nft_bitwise_fast_eval(expr, &regs);
 236                         else if (expr->ops != &nft_payload_fast_ops ||
 237                                  !nft_payload_fast_eval(expr, &regs, pkt))
 238                                 expr_call_ops_eval(expr, &regs, pkt);
 239
 240                         if (regs.verdict.code != NFT_CONTINUE)
 241                                 break;
 242                 }
 243
 244                 switch (regs.verdict.code) {
 245                 case NFT_BREAK:
 246                         regs.verdict.code = NFT_CONTINUE;
 247                         continue;
 248                 case NFT_CONTINUE:
 249                         nft_trace_packet(&info, chain, rule,
 250                                          NFT_TRACETYPE_RULE);
 251                         continue;
 252                 }
 253                 break;
 254         }
 255
 256         nft_trace_verdict(&info, chain, rule, &regs);
 257
 258         switch (regs.verdict.code & NF_VERDICT_MASK) {
 259         case NF_ACCEPT:
 260         case NF_DROP:
 261         case NF_QUEUE:
 262         case NF_STOLEN:
 263                 return regs.verdict.code;
 264         }
 265
 266         switch (regs.verdict.code) {
 267         case NFT_JUMP:
 268                 if (WARN_ON_ONCE(stackptr >= NFT_JUMP_STACK_SIZE))
 269                         return NF_DROP;
 270                 jumpstack[stackptr].chain = chain;
 271                 jumpstack[stackptr].rules = rules + 1;
 272                 stackptr++;
 273                 fallthrough;
 274         case NFT_GOTO:
 275                 chain = regs.verdict.chain;
 276                 goto do_chain;
 277         case NFT_CONTINUE:
 278         case NFT_RETURN:
 279                 break;
 280         default:
 281                 WARN_ON(1);
 282         }
 283
 284         if (stackptr > 0) {
 285                 stackptr--;
 286                 chain = jumpstack[stackptr].chain;
 287                 rules = jumpstack[stackptr].rules;
 288                 goto next_rule;
 289         }
 290
 291         nft_trace_packet(&info, basechain, NULL, NFT_TRACETYPE_POLICY);
 292
 293         if (static_branch_unlikely(&nft_counters_enabled))
 294                 nft_update_chain_stats(basechain, pkt);
 295
 296         return nft_base_chain(basechain)->policy;
 297 }
 298 EXPORT_SYMBOL_GPL(nft_do_chain);
 299
 300 static struct nft_expr_type *nft_basic_types[] = {
 301         &nft_imm_type,
 302         &nft_cmp_type,
 303         &nft_lookup_type,
 304         &nft_bitwise_type,
 305         &nft_byteorder_type,
 306         &nft_payload_type,
 307         &nft_dynset_type,
 308         &nft_range_type,
 309         &nft_meta_type,
 310         &nft_rt_type,
 311         &nft_exthdr_type,
 312         &nft_last_type,
 313 };
 314
 315 static struct nft_object_type *nft_basic_objects[] = {
 316 #ifdef CONFIG_NETWORK_SECMARK
 317         &nft_secmark_obj_type,
 318 #endif
 319 };
 320
 321 int __init nf_tables_core_module_init(void)
 322 {
 323         int err, i, j = 0;
 324
 325         for (i = 0; i < ARRAY_SIZE(nft_basic_objects); i++) {
 326                 err = nft_register_obj(nft_basic_objects[i]);
 327                 if (err)
 328                         goto err;
 329         }
 330
 331         for (j = 0; j < ARRAY_SIZE(nft_basic_types); j++) {
 332                 err = nft_register_expr(nft_basic_types[j]);
 333                 if (err)
 334                         goto err;
 335         }
 336
 337         return 0;
 338
 339 err:
 340         while (j-- > 0)
 341                 nft_unregister_expr(nft_basic_types[j]);
 342
 343         while (i-- > 0)
 344                 nft_unregister_obj(nft_basic_objects[i]);
 345
 346         return err;
 347 }
 348
 349 void nf_tables_core_module_exit(void)
 350 {
 351         int i;
 352
 353         i = ARRAY_SIZE(nft_basic_types);
 354         while (i-- > 0)
 355                 nft_unregister_expr(nft_basic_types[i]);
 356
 357         i = ARRAY_SIZE(nft_basic_objects);
 358         while (i-- > 0)
 359                 nft_unregister_obj(nft_basic_objects[i]);
 360 }