net/netfilter/nft_meta.c

   1 /*
   2  * Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
   3  * Copyright (c) 2014 Intel Corporation
   4  * Author: Tomasz Bursztyka <tomasz.bursztyka@linux.intel.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * Development of this code funded by Astaro AG (http://www.astaro.com/)
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/netlink.h>
  15 #include <linux/netfilter.h>
  16 #include <linux/netfilter/nf_tables.h>
  17 #include <linux/in.h>
  18 #include <linux/ip.h>
  19 #include <linux/ipv6.h>
  20 #include <linux/smp.h>
  21 #include <linux/static_key.h>
  22 #include <net/dst.h>
  23 #include <net/sock.h>
  24 #include <net/tcp_states.h> /* for TCP_TIME_WAIT */
  25 #include <net/netfilter/nf_tables.h>
  26 #include <net/netfilter/nf_tables_core.h>
  27
  28 #include <uapi/linux/netfilter_bridge.h> /* NF_BR_PRE_ROUTING */
  29
  30 struct nft_meta {
  31         enum nft_meta_keys      key:8;
  32         union {
  33                 u8              dreg;
  34                 u8              sreg;
  35         };
  36 };
  37
  38 static DEFINE_PER_CPU(struct rnd_state, nft_prandom_state);
  39
  40 #ifdef CONFIG_NF_TABLES_BRIDGE
  41 #include "../bridge/br_private.h"
  42 #endif
  43
  44 void nft_meta_get_eval(const struct nft_expr *expr,
  45                        struct nft_regs *regs,
  46                        const struct nft_pktinfo *pkt)
  47 {
  48         const struct nft_meta *priv = nft_expr_priv(expr);
  49         const struct sk_buff *skb = pkt->skb;
  50         const struct net_device *in = nft_in(pkt), *out = nft_out(pkt);
  51         struct sock *sk;
  52         u32 *dest = &regs->data[priv->dreg];
  53 #ifdef CONFIG_NF_TABLES_BRIDGE
  54         const struct net_bridge_port *p;
  55 #endif
  56
  57         switch (priv->key) {
  58         case NFT_META_LEN:
  59                 *dest = skb->len;
  60                 break;
  61         case NFT_META_PROTOCOL:
  62                 nft_reg_store16(dest, (__force u16)skb->protocol);
  63                 break;
  64         case NFT_META_NFPROTO:
  65                 nft_reg_store8(dest, nft_pf(pkt));
  66                 break;
  67         case NFT_META_L4PROTO:
  68                 if (!pkt->tprot_set)
  69                         goto err;
  70                 nft_reg_store8(dest, pkt->tprot);
  71                 break;
  72         case NFT_META_PRIORITY:
  73                 *dest = skb->priority;
  74                 break;
  75         case NFT_META_MARK:
  76                 *dest = skb->mark;
  77                 break;
  78         case NFT_META_IIF:
  79                 if (in == NULL)
  80                         goto err;
  81                 *dest = in->ifindex;
  82                 break;
  83         case NFT_META_OIF:
  84                 if (out == NULL)
  85                         goto err;
  86                 *dest = out->ifindex;
  87                 break;
  88         case NFT_META_IIFNAME:
  89                 if (in == NULL)
  90                         goto err;
  91                 strncpy((char *)dest, in->name, IFNAMSIZ);
  92                 break;
  93         case NFT_META_OIFNAME:
  94                 if (out == NULL)
  95                         goto err;
  96                 strncpy((char *)dest, out->name, IFNAMSIZ);
  97                 break;
  98         case NFT_META_IIFTYPE:
  99                 if (in == NULL)
 100                         goto err;
 101                 nft_reg_store16(dest, in->type);
 102                 break;
 103         case NFT_META_OIFTYPE:
 104                 if (out == NULL)
 105                         goto err;
 106                 nft_reg_store16(dest, out->type);
 107                 break;
 108         case NFT_META_SKUID:
 109                 sk = skb_to_full_sk(skb);
 110                 if (!sk || !sk_fullsock(sk) ||
 111                     !net_eq(nft_net(pkt), sock_net(sk)))
 112                         goto err;
 113
 114                 read_lock_bh(&sk->sk_callback_lock);
 115                 if (sk->sk_socket == NULL ||
 116                     sk->sk_socket->file == NULL) {
 117                         read_unlock_bh(&sk->sk_callback_lock);
 118                         goto err;
 119                 }
 120
 121                 *dest = from_kuid_munged(&init_user_ns,
 122                                 sk->sk_socket->file->f_cred->fsuid);
 123                 read_unlock_bh(&sk->sk_callback_lock);
 124                 break;
 125         case NFT_META_SKGID:
 126                 sk = skb_to_full_sk(skb);
 127                 if (!sk || !sk_fullsock(sk) ||
 128                     !net_eq(nft_net(pkt), sock_net(sk)))
 129                         goto err;
 130
 131                 read_lock_bh(&sk->sk_callback_lock);
 132                 if (sk->sk_socket == NULL ||
 133                     sk->sk_socket->file == NULL) {
 134                         read_unlock_bh(&sk->sk_callback_lock);
 135                         goto err;
 136                 }
 137                 *dest = from_kgid_munged(&init_user_ns,
 138                                  sk->sk_socket->file->f_cred->fsgid);
 139                 read_unlock_bh(&sk->sk_callback_lock);
 140                 break;
 141 #ifdef CONFIG_IP_ROUTE_CLASSID
 142         case NFT_META_RTCLASSID: {
 143                 const struct dst_entry *dst = skb_dst(skb);
 144
 145                 if (dst == NULL)
 146                         goto err;
 147                 *dest = dst->tclassid;
 148                 break;
 149         }
 150 #endif
 151 #ifdef CONFIG_NETWORK_SECMARK
 152         case NFT_META_SECMARK:
 153                 *dest = skb->secmark;
 154                 break;
 155 #endif
 156         case NFT_META_PKTTYPE:
 157                 if (skb->pkt_type != PACKET_LOOPBACK) {
 158                         nft_reg_store8(dest, skb->pkt_type);
 159                         break;
 160                 }
 161
 162                 switch (nft_pf(pkt)) {
 163                 case NFPROTO_IPV4:
 164                         if (ipv4_is_multicast(ip_hdr(skb)->daddr))
 165                                 nft_reg_store8(dest, PACKET_MULTICAST);
 166                         else
 167                                 nft_reg_store8(dest, PACKET_BROADCAST);
 168                         break;
 169                 case NFPROTO_IPV6:
 170                         nft_reg_store8(dest, PACKET_MULTICAST);
 171                         break;
 172                 case NFPROTO_NETDEV:
 173                         switch (skb->protocol) {
 174                         case htons(ETH_P_IP): {
 175                                 int noff = skb_network_offset(skb);
 176                                 struct iphdr *iph, _iph;
 177
 178                                 iph = skb_header_pointer(skb, noff,
 179                                                          sizeof(_iph), &_iph);
 180                                 if (!iph)
 181                                         goto err;
 182
 183                                 if (ipv4_is_multicast(iph->daddr))
 184                                         nft_reg_store8(dest, PACKET_MULTICAST);
 185                                 else
 186                                         nft_reg_store8(dest, PACKET_BROADCAST);
 187
 188                                 break;
 189                         }
 190                         case htons(ETH_P_IPV6):
 191                                 nft_reg_store8(dest, PACKET_MULTICAST);
 192                                 break;
 193                         default:
 194                                 WARN_ON_ONCE(1);
 195                                 goto err;
 196                         }
 197                         break;
 198                 default:
 199                         WARN_ON_ONCE(1);
 200                         goto err;
 201                 }
 202                 break;
 203         case NFT_META_CPU:
 204                 *dest = raw_smp_processor_id();
 205                 break;
 206         case NFT_META_IIFGROUP:
 207                 if (in == NULL)
 208                         goto err;
 209                 *dest = in->group;
 210                 break;
 211         case NFT_META_OIFGROUP:
 212                 if (out == NULL)
 213                         goto err;
 214                 *dest = out->group;
 215                 break;
 216 #ifdef CONFIG_CGROUP_NET_CLASSID
 217         case NFT_META_CGROUP:
 218                 sk = skb_to_full_sk(skb);
 219                 if (!sk || !sk_fullsock(sk) ||
 220                     !net_eq(nft_net(pkt), sock_net(sk)))
 221                         goto err;
 222                 *dest = sock_cgroup_classid(&sk->sk_cgrp_data);
 223                 break;
 224 #endif
 225         case NFT_META_PRANDOM: {
 226                 struct rnd_state *state = this_cpu_ptr(&nft_prandom_state);
 227                 *dest = prandom_u32_state(state);
 228                 break;
 229         }
 230 #ifdef CONFIG_XFRM
 231         case NFT_META_SECPATH:
 232                 nft_reg_store8(dest, !!skb->sp);
 233                 break;
 234 #endif
 235 #ifdef CONFIG_NF_TABLES_BRIDGE
 236         case NFT_META_BRI_IIFNAME:
 237                 if (in == NULL || (p = br_port_get_rcu(in)) == NULL)
 238                         goto err;
 239                 strncpy((char *)dest, p->br->dev->name, IFNAMSIZ);
 240                 return;
 241         case NFT_META_BRI_OIFNAME:
 242                 if (out == NULL || (p = br_port_get_rcu(out)) == NULL)
 243                         goto err;
 244                 strncpy((char *)dest, p->br->dev->name, IFNAMSIZ);
 245                 return;
 246 #endif
 247         default:
 248                 WARN_ON(1);
 249                 goto err;
 250         }
 251         return;
 252
 253 err:
 254         regs->verdict.code = NFT_BREAK;
 255 }
 256
 257 static void nft_meta_set_eval(const struct nft_expr *expr,
 258                               struct nft_regs *regs,
 259                                const struct nft_pktinfo *pkt)
 260 {
 261         const struct nft_meta *meta = nft_expr_priv(expr);
 262         struct sk_buff *skb = pkt->skb;
 263         u32 *sreg = &regs->data[meta->sreg];
 264         u32 value = *sreg;
 265         u8 value8;
 266
 267         switch (meta->key) {
 268         case NFT_META_MARK:
 269                 skb->mark = value;
 270                 break;
 271         case NFT_META_PRIORITY:
 272                 skb->priority = value;
 273                 break;
 274         case NFT_META_PKTTYPE:
 275                 value8 = nft_reg_load8(sreg);
 276
 277                 if (skb->pkt_type != value8 &&
 278                     skb_pkt_type_ok(value8) &&
 279                     skb_pkt_type_ok(skb->pkt_type))
 280                         skb->pkt_type = value8;
 281                 break;
 282         case NFT_META_NFTRACE:
 283                 value8 = nft_reg_load8(sreg);
 284
 285                 skb->nf_trace = !!value8;
 286                 break;
 287         default:
 288                 WARN_ON(1);
 289         }
 290 }
 291
 292 static const struct nla_policy nft_meta_policy[NFTA_META_MAX + 1] = {
 293         [NFTA_META_DREG]        = { .type = NLA_U32 },
 294         [NFTA_META_KEY]         = { .type = NLA_U32 },
 295         [NFTA_META_SREG]        = { .type = NLA_U32 },
 296 };
 297
 298 static int nft_meta_get_init(const struct nft_ctx *ctx,
 299                              const struct nft_expr *expr,
 300                              const struct nlattr * const tb[])
 301 {
 302         struct nft_meta *priv = nft_expr_priv(expr);
 303         unsigned int len;
 304
 305         priv->key = ntohl(nla_get_be32(tb[NFTA_META_KEY]));
 306         switch (priv->key) {
 307         case NFT_META_PROTOCOL:
 308         case NFT_META_IIFTYPE:
 309         case NFT_META_OIFTYPE:
 310                 len = sizeof(u16);
 311                 break;
 312         case NFT_META_NFPROTO:
 313         case NFT_META_L4PROTO:
 314         case NFT_META_LEN:
 315         case NFT_META_PRIORITY:
 316         case NFT_META_MARK:
 317         case NFT_META_IIF:
 318         case NFT_META_OIF:
 319         case NFT_META_SKUID:
 320         case NFT_META_SKGID:
 321 #ifdef CONFIG_IP_ROUTE_CLASSID
 322         case NFT_META_RTCLASSID:
 323 #endif
 324 #ifdef CONFIG_NETWORK_SECMARK
 325         case NFT_META_SECMARK:
 326 #endif
 327         case NFT_META_PKTTYPE:
 328         case NFT_META_CPU:
 329         case NFT_META_IIFGROUP:
 330         case NFT_META_OIFGROUP:
 331 #ifdef CONFIG_CGROUP_NET_CLASSID
 332         case NFT_META_CGROUP:
 333 #endif
 334                 len = sizeof(u32);
 335                 break;
 336         case NFT_META_IIFNAME:
 337         case NFT_META_OIFNAME:
 338                 len = IFNAMSIZ;
 339                 break;
 340         case NFT_META_PRANDOM:
 341                 prandom_init_once(&nft_prandom_state);
 342                 len = sizeof(u32);
 343                 break;
 344 #ifdef CONFIG_XFRM
 345         case NFT_META_SECPATH:
 346                 len = sizeof(u8);
 347                 break;
 348 #endif
 349 #ifdef CONFIG_NF_TABLES_BRIDGE
 350         case NFT_META_BRI_IIFNAME:
 351         case NFT_META_BRI_OIFNAME:
 352                 if (ctx->family != NFPROTO_BRIDGE)
 353                         return -EOPNOTSUPP;
 354                 len = IFNAMSIZ;
 355                 break;
 356 #endif
 357         default:
 358                 return -EOPNOTSUPP;
 359         }
 360
 361         return nft_parse_register_store(ctx, tb[NFTA_META_DREG], &priv->dreg,
 362                                         NULL, NFT_DATA_VALUE, len);
 363 }
 364
 365 static int nft_meta_get_validate(const struct nft_ctx *ctx,
 366                                  const struct nft_expr *expr,
 367                                  const struct nft_data **data)
 368 {
 369 #ifdef CONFIG_XFRM
 370         const struct nft_meta *priv = nft_expr_priv(expr);
 371         unsigned int hooks;
 372
 373         if (priv->key != NFT_META_SECPATH)
 374                 return 0;
 375
 376         switch (ctx->family) {
 377         case NFPROTO_NETDEV:
 378                 hooks = 1 << NF_NETDEV_INGRESS;
 379                 break;
 380         case NFPROTO_IPV4:
 381         case NFPROTO_IPV6:
 382         case NFPROTO_INET:
 383                 hooks = (1 << NF_INET_PRE_ROUTING) |
 384                         (1 << NF_INET_LOCAL_IN) |
 385                         (1 << NF_INET_FORWARD);
 386                 break;
 387         default:
 388                 return -EOPNOTSUPP;
 389         }
 390
 391         return nft_chain_validate_hooks(ctx->chain, hooks);
 392 #else
 393         return 0;
 394 #endif
 395 }
 396
 397 static int nft_meta_set_validate(const struct nft_ctx *ctx,
 398                                  const struct nft_expr *expr,
 399                                  const struct nft_data **data)
 400 {
 401         struct nft_meta *priv = nft_expr_priv(expr);
 402         unsigned int hooks;
 403
 404         if (priv->key != NFT_META_PKTTYPE)
 405                 return 0;
 406
 407         switch (ctx->family) {
 408         case NFPROTO_BRIDGE:
 409                 hooks = 1 << NF_BR_PRE_ROUTING;
 410                 break;
 411         case NFPROTO_NETDEV:
 412                 hooks = 1 << NF_NETDEV_INGRESS;
 413                 break;
 414         case NFPROTO_IPV4:
 415         case NFPROTO_IPV6:
 416         case NFPROTO_INET:
 417                 hooks = 1 << NF_INET_PRE_ROUTING;
 418                 break;
 419         default:
 420                 return -EOPNOTSUPP;
 421         }
 422
 423         return nft_chain_validate_hooks(ctx->chain, hooks);
 424 }
 425
 426 static int nft_meta_set_init(const struct nft_ctx *ctx,
 427                              const struct nft_expr *expr,
 428                              const struct nlattr * const tb[])
 429 {
 430         struct nft_meta *priv = nft_expr_priv(expr);
 431         unsigned int len;
 432         int err;
 433
 434         priv->key = ntohl(nla_get_be32(tb[NFTA_META_KEY]));
 435         switch (priv->key) {
 436         case NFT_META_MARK:
 437         case NFT_META_PRIORITY:
 438                 len = sizeof(u32);
 439                 break;
 440         case NFT_META_NFTRACE:
 441                 len = sizeof(u8);
 442                 break;
 443         case NFT_META_PKTTYPE:
 444                 len = sizeof(u8);
 445                 break;
 446         default:
 447                 return -EOPNOTSUPP;
 448         }
 449
 450         err = nft_parse_register_load(tb[NFTA_META_SREG], &priv->sreg, len);
 451         if (err < 0)
 452                 return err;
 453
 454         if (priv->key == NFT_META_NFTRACE)
 455                 static_branch_inc(&nft_trace_enabled);
 456
 457         return 0;
 458 }
 459
 460 static int nft_meta_get_dump(struct sk_buff *skb,
 461                              const struct nft_expr *expr)
 462 {
 463         const struct nft_meta *priv = nft_expr_priv(expr);
 464
 465         if (nla_put_be32(skb, NFTA_META_KEY, htonl(priv->key)))
 466                 goto nla_put_failure;
 467         if (nft_dump_register(skb, NFTA_META_DREG, priv->dreg))
 468                 goto nla_put_failure;
 469         return 0;
 470
 471 nla_put_failure:
 472         return -1;
 473 }
 474
 475 static int nft_meta_set_dump(struct sk_buff *skb, const struct nft_expr *expr)
 476 {
 477         const struct nft_meta *priv = nft_expr_priv(expr);
 478
 479         if (nla_put_be32(skb, NFTA_META_KEY, htonl(priv->key)))
 480                 goto nla_put_failure;
 481         if (nft_dump_register(skb, NFTA_META_SREG, priv->sreg))
 482                 goto nla_put_failure;
 483
 484         return 0;
 485
 486 nla_put_failure:
 487         return -1;
 488 }
 489
 490 static void nft_meta_set_destroy(const struct nft_ctx *ctx,
 491                                  const struct nft_expr *expr)
 492 {
 493         const struct nft_meta *priv = nft_expr_priv(expr);
 494
 495         if (priv->key == NFT_META_NFTRACE)
 496                 static_branch_dec(&nft_trace_enabled);
 497 }
 498
 499 static const struct nft_expr_ops nft_meta_get_ops = {
 500         .type           = &nft_meta_type,
 501         .size           = NFT_EXPR_SIZE(sizeof(struct nft_meta)),
 502         .eval           = nft_meta_get_eval,
 503         .init           = nft_meta_get_init,
 504         .dump           = nft_meta_get_dump,
 505         .validate       = nft_meta_get_validate,
 506 };
 507
 508 static const struct nft_expr_ops nft_meta_set_ops = {
 509         .type           = &nft_meta_type,
 510         .size           = NFT_EXPR_SIZE(sizeof(struct nft_meta)),
 511         .eval           = nft_meta_set_eval,
 512         .init           = nft_meta_set_init,
 513         .destroy        = nft_meta_set_destroy,
 514         .dump           = nft_meta_set_dump,
 515         .validate       = nft_meta_set_validate,
 516 };
 517
 518 static const struct nft_expr_ops *
 519 nft_meta_select_ops(const struct nft_ctx *ctx,
 520                     const struct nlattr * const tb[])
 521 {
 522         if (tb[NFTA_META_KEY] == NULL)
 523                 return ERR_PTR(-EINVAL);
 524
 525         if (tb[NFTA_META_DREG] && tb[NFTA_META_SREG])
 526                 return ERR_PTR(-EINVAL);
 527
 528         if (tb[NFTA_META_DREG])
 529                 return &nft_meta_get_ops;
 530
 531         if (tb[NFTA_META_SREG])
 532                 return &nft_meta_set_ops;
 533
 534         return ERR_PTR(-EINVAL);
 535 }
 536
 537 struct nft_expr_type nft_meta_type __read_mostly = {
 538         .name           = "meta",
 539         .select_ops     = nft_meta_select_ops,
 540         .policy         = nft_meta_policy,
 541         .maxattr        = NFTA_META_MAX,
 542         .owner          = THIS_MODULE,
 543 };