git.itanic.dy.fi Git - linux-stable/blob - net/netfilter/nft_payload.c

   1 /*
   2  * Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
   3  * Copyright (c) 2016 Pablo Neira Ayuso <pablo@netfilter.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Development of this code funded by Astaro AG (http://www.astaro.com/)
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/if_vlan.h>
  14 #include <linux/init.h>
  15 #include <linux/module.h>
  16 #include <linux/netlink.h>
  17 #include <linux/netfilter.h>
  18 #include <linux/netfilter/nf_tables.h>
  19 #include <net/netfilter/nf_tables_core.h>
  20 #include <net/netfilter/nf_tables.h>
  21 /* For layer 4 checksum field offset. */
  22 #include <linux/tcp.h>
  23 #include <linux/udp.h>
  24 #include <linux/icmpv6.h>
  25
  26 /* add vlan header into the user buffer for if tag was removed by offloads */
  27 static bool
  28 nft_payload_copy_vlan(u32 *d, const struct sk_buff *skb, u8 offset, u8 len)
  29 {
  30         int mac_off = skb_mac_header(skb) - skb->data;
  31         u8 vlan_len, *vlanh, *dst_u8 = (u8 *) d;
  32         struct vlan_ethhdr veth;
  33
  34         vlanh = (u8 *) &veth;
  35         if (offset < ETH_HLEN) {
  36                 u8 ethlen = min_t(u8, len, ETH_HLEN - offset);
  37
  38                 if (skb_copy_bits(skb, mac_off, &veth, ETH_HLEN))
  39                         return false;
  40
  41                 veth.h_vlan_proto = skb->vlan_proto;
  42
  43                 memcpy(dst_u8, vlanh + offset, ethlen);
  44
  45                 len -= ethlen;
  46                 if (len == 0)
  47                         return true;
  48
  49                 dst_u8 += ethlen;
  50                 offset = ETH_HLEN;
  51         } else if (offset >= VLAN_ETH_HLEN) {
  52                 offset -= VLAN_HLEN;
  53                 goto skip;
  54         }
  55
  56         veth.h_vlan_TCI = htons(skb_vlan_tag_get(skb));
  57         veth.h_vlan_encapsulated_proto = skb->protocol;
  58
  59         vlanh += offset;
  60
  61         vlan_len = min_t(u8, len, VLAN_ETH_HLEN - offset);
  62         memcpy(dst_u8, vlanh, vlan_len);
  63
  64         len -= vlan_len;
  65         if (!len)
  66                 return true;
  67
  68         dst_u8 += vlan_len;
  69  skip:
  70         return skb_copy_bits(skb, offset + mac_off, dst_u8, len) == 0;
  71 }
  72
  73 static void nft_payload_eval(const struct nft_expr *expr,
  74                              struct nft_regs *regs,
  75                              const struct nft_pktinfo *pkt)
  76 {
  77         const struct nft_payload *priv = nft_expr_priv(expr);
  78         const struct sk_buff *skb = pkt->skb;
  79         u32 *dest = &regs->data[priv->dreg];
  80         int offset;
  81
  82         if (priv->len % NFT_REG32_SIZE)
  83                 dest[priv->len / NFT_REG32_SIZE] = 0;
  84
  85         switch (priv->base) {
  86         case NFT_PAYLOAD_LL_HEADER:
  87                 if (!skb_mac_header_was_set(skb))
  88                         goto err;
  89
  90                 if (skb_vlan_tag_present(skb)) {
  91                         if (!nft_payload_copy_vlan(dest, skb,
  92                                                    priv->offset, priv->len))
  93                                 goto err;
  94                         return;
  95                 }
  96                 offset = skb_mac_header(skb) - skb->data;
  97                 break;
  98         case NFT_PAYLOAD_NETWORK_HEADER:
  99                 offset = skb_network_offset(skb);
 100                 break;
 101         case NFT_PAYLOAD_TRANSPORT_HEADER:
 102                 if (!pkt->tprot_set)
 103                         goto err;
 104                 offset = pkt->xt.thoff;
 105                 break;
 106         default:
 107                 BUG();
 108         }
 109         offset += priv->offset;
 110
 111         if (skb_copy_bits(skb, offset, dest, priv->len) < 0)
 112                 goto err;
 113         return;
 114 err:
 115         regs->verdict.code = NFT_BREAK;
 116 }
 117
 118 static const struct nla_policy nft_payload_policy[NFTA_PAYLOAD_MAX + 1] = {
 119         [NFTA_PAYLOAD_SREG]             = { .type = NLA_U32 },
 120         [NFTA_PAYLOAD_DREG]             = { .type = NLA_U32 },
 121         [NFTA_PAYLOAD_BASE]             = { .type = NLA_U32 },
 122         [NFTA_PAYLOAD_OFFSET]           = { .type = NLA_U32 },
 123         [NFTA_PAYLOAD_LEN]              = { .type = NLA_U32 },
 124         [NFTA_PAYLOAD_CSUM_TYPE]        = { .type = NLA_U32 },
 125         [NFTA_PAYLOAD_CSUM_OFFSET]      = { .type = NLA_U32 },
 126         [NFTA_PAYLOAD_CSUM_FLAGS]       = { .type = NLA_U32 },
 127 };
 128
 129 static int nft_payload_init(const struct nft_ctx *ctx,
 130                             const struct nft_expr *expr,
 131                             const struct nlattr * const tb[])
 132 {
 133         struct nft_payload *priv = nft_expr_priv(expr);
 134
 135         priv->base   = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_BASE]));
 136         priv->offset = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_OFFSET]));
 137         priv->len    = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_LEN]));
 138
 139         return nft_parse_register_store(ctx, tb[NFTA_PAYLOAD_DREG],
 140                                         &priv->dreg, NULL, NFT_DATA_VALUE,
 141                                         priv->len);
 142 }
 143
 144 static int nft_payload_dump(struct sk_buff *skb, const struct nft_expr *expr)
 145 {
 146         const struct nft_payload *priv = nft_expr_priv(expr);
 147
 148         if (nft_dump_register(skb, NFTA_PAYLOAD_DREG, priv->dreg) ||
 149             nla_put_be32(skb, NFTA_PAYLOAD_BASE, htonl(priv->base)) ||
 150             nla_put_be32(skb, NFTA_PAYLOAD_OFFSET, htonl(priv->offset)) ||
 151             nla_put_be32(skb, NFTA_PAYLOAD_LEN, htonl(priv->len)))
 152                 goto nla_put_failure;
 153         return 0;
 154
 155 nla_put_failure:
 156         return -1;
 157 }
 158
 159 static const struct nft_expr_ops nft_payload_ops = {
 160         .type           = &nft_payload_type,
 161         .size           = NFT_EXPR_SIZE(sizeof(struct nft_payload)),
 162         .eval           = nft_payload_eval,
 163         .init           = nft_payload_init,
 164         .dump           = nft_payload_dump,
 165 };
 166
 167 const struct nft_expr_ops nft_payload_fast_ops = {
 168         .type           = &nft_payload_type,
 169         .size           = NFT_EXPR_SIZE(sizeof(struct nft_payload)),
 170         .eval           = nft_payload_eval,
 171         .init           = nft_payload_init,
 172         .dump           = nft_payload_dump,
 173 };
 174
 175 static inline void nft_csum_replace(__sum16 *sum, __wsum fsum, __wsum tsum)
 176 {
 177         *sum = csum_fold(csum_add(csum_sub(~csum_unfold(*sum), fsum), tsum));
 178         if (*sum == 0)
 179                 *sum = CSUM_MANGLED_0;
 180 }
 181
 182 static bool nft_payload_udp_checksum(struct sk_buff *skb, unsigned int thoff)
 183 {
 184         struct udphdr *uh, _uh;
 185
 186         uh = skb_header_pointer(skb, thoff, sizeof(_uh), &_uh);
 187         if (!uh)
 188                 return false;
 189
 190         return (__force bool)uh->check;
 191 }
 192
 193 static int nft_payload_l4csum_offset(const struct nft_pktinfo *pkt,
 194                                      struct sk_buff *skb,
 195                                      unsigned int *l4csum_offset)
 196 {
 197         if (pkt->xt.fragoff)
 198                 return -1;
 199
 200         switch (pkt->tprot) {
 201         case IPPROTO_TCP:
 202                 *l4csum_offset = offsetof(struct tcphdr, check);
 203                 break;
 204         case IPPROTO_UDP:
 205                 if (!nft_payload_udp_checksum(skb, pkt->xt.thoff))
 206                         return -1;
 207                 /* Fall through. */
 208         case IPPROTO_UDPLITE:
 209                 *l4csum_offset = offsetof(struct udphdr, check);
 210                 break;
 211         case IPPROTO_ICMPV6:
 212                 *l4csum_offset = offsetof(struct icmp6hdr, icmp6_cksum);
 213                 break;
 214         default:
 215                 return -1;
 216         }
 217
 218         *l4csum_offset += pkt->xt.thoff;
 219         return 0;
 220 }
 221
 222 static int nft_payload_l4csum_update(const struct nft_pktinfo *pkt,
 223                                      struct sk_buff *skb,
 224                                      __wsum fsum, __wsum tsum)
 225 {
 226         int l4csum_offset;
 227         __sum16 sum;
 228
 229         /* If we cannot determine layer 4 checksum offset or this packet doesn't
 230          * require layer 4 checksum recalculation, skip this packet.
 231          */
 232         if (nft_payload_l4csum_offset(pkt, skb, &l4csum_offset) < 0)
 233                 return 0;
 234
 235         if (skb_copy_bits(skb, l4csum_offset, &sum, sizeof(sum)) < 0)
 236                 return -1;
 237
 238         /* Checksum mangling for an arbitrary amount of bytes, based on
 239          * inet_proto_csum_replace*() functions.
 240          */
 241         if (skb->ip_summed != CHECKSUM_PARTIAL) {
 242                 nft_csum_replace(&sum, fsum, tsum);
 243                 if (skb->ip_summed == CHECKSUM_COMPLETE) {
 244                         skb->csum = ~csum_add(csum_sub(~(skb->csum), fsum),
 245                                               tsum);
 246                 }
 247         } else {
 248                 sum = ~csum_fold(csum_add(csum_sub(csum_unfold(sum), fsum),
 249                                           tsum));
 250         }
 251
 252         if (!skb_make_writable(skb, l4csum_offset + sizeof(sum)) ||
 253             skb_store_bits(skb, l4csum_offset, &sum, sizeof(sum)) < 0)
 254                 return -1;
 255
 256         return 0;
 257 }
 258
 259 static int nft_payload_csum_inet(struct sk_buff *skb, const u32 *src,
 260                                  __wsum fsum, __wsum tsum, int csum_offset)
 261 {
 262         __sum16 sum;
 263
 264         if (skb_copy_bits(skb, csum_offset, &sum, sizeof(sum)) < 0)
 265                 return -1;
 266
 267         nft_csum_replace(&sum, fsum, tsum);
 268         if (!skb_make_writable(skb, csum_offset + sizeof(sum)) ||
 269             skb_store_bits(skb, csum_offset, &sum, sizeof(sum)) < 0)
 270                 return -1;
 271
 272         return 0;
 273 }
 274
 275 static void nft_payload_set_eval(const struct nft_expr *expr,
 276                                  struct nft_regs *regs,
 277                                  const struct nft_pktinfo *pkt)
 278 {
 279         const struct nft_payload_set *priv = nft_expr_priv(expr);
 280         struct sk_buff *skb = pkt->skb;
 281         const u32 *src = &regs->data[priv->sreg];
 282         int offset, csum_offset;
 283         __wsum fsum, tsum;
 284
 285         switch (priv->base) {
 286         case NFT_PAYLOAD_LL_HEADER:
 287                 if (!skb_mac_header_was_set(skb))
 288                         goto err;
 289                 offset = skb_mac_header(skb) - skb->data;
 290                 break;
 291         case NFT_PAYLOAD_NETWORK_HEADER:
 292                 offset = skb_network_offset(skb);
 293                 break;
 294         case NFT_PAYLOAD_TRANSPORT_HEADER:
 295                 if (!pkt->tprot_set)
 296                         goto err;
 297                 offset = pkt->xt.thoff;
 298                 break;
 299         default:
 300                 BUG();
 301         }
 302
 303         csum_offset = offset + priv->csum_offset;
 304         offset += priv->offset;
 305
 306         if ((priv->csum_type == NFT_PAYLOAD_CSUM_INET || priv->csum_flags) &&
 307             (priv->base != NFT_PAYLOAD_TRANSPORT_HEADER ||
 308              skb->ip_summed != CHECKSUM_PARTIAL)) {
 309                 fsum = skb_checksum(skb, offset, priv->len, 0);
 310                 tsum = csum_partial(src, priv->len, 0);
 311
 312                 if (priv->csum_type == NFT_PAYLOAD_CSUM_INET &&
 313                     nft_payload_csum_inet(skb, src, fsum, tsum, csum_offset))
 314                         goto err;
 315
 316                 if (priv->csum_flags &&
 317                     nft_payload_l4csum_update(pkt, skb, fsum, tsum) < 0)
 318                         goto err;
 319         }
 320
 321         if (!skb_make_writable(skb, max(offset + priv->len, 0)) ||
 322             skb_store_bits(skb, offset, src, priv->len) < 0)
 323                 goto err;
 324
 325         return;
 326 err:
 327         regs->verdict.code = NFT_BREAK;
 328 }
 329
 330 static int nft_payload_set_init(const struct nft_ctx *ctx,
 331                                 const struct nft_expr *expr,
 332                                 const struct nlattr * const tb[])
 333 {
 334         struct nft_payload_set *priv = nft_expr_priv(expr);
 335         u32 csum_offset, csum_type = NFT_PAYLOAD_CSUM_NONE;
 336         int err;
 337
 338         priv->base        = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_BASE]));
 339         priv->offset      = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_OFFSET]));
 340         priv->len         = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_LEN]));
 341
 342         if (tb[NFTA_PAYLOAD_CSUM_TYPE])
 343                 csum_type = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_CSUM_TYPE]));
 344         if (tb[NFTA_PAYLOAD_CSUM_OFFSET]) {
 345                 err = nft_parse_u32_check(tb[NFTA_PAYLOAD_CSUM_OFFSET], U8_MAX,
 346                                           &csum_offset);
 347                 if (err < 0)
 348                         return err;
 349
 350                 priv->csum_offset = csum_offset;
 351         }
 352         if (tb[NFTA_PAYLOAD_CSUM_FLAGS]) {
 353                 u32 flags;
 354
 355                 flags = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_CSUM_FLAGS]));
 356                 if (flags & ~NFT_PAYLOAD_L4CSUM_PSEUDOHDR)
 357                         return -EINVAL;
 358
 359                 priv->csum_flags = flags;
 360         }
 361
 362         switch (csum_type) {
 363         case NFT_PAYLOAD_CSUM_NONE:
 364         case NFT_PAYLOAD_CSUM_INET:
 365                 break;
 366         default:
 367                 return -EOPNOTSUPP;
 368         }
 369         priv->csum_type = csum_type;
 370
 371         return nft_parse_register_load(tb[NFTA_PAYLOAD_SREG], &priv->sreg,
 372                                        priv->len);
 373 }
 374
 375 static int nft_payload_set_dump(struct sk_buff *skb, const struct nft_expr *expr)
 376 {
 377         const struct nft_payload_set *priv = nft_expr_priv(expr);
 378
 379         if (nft_dump_register(skb, NFTA_PAYLOAD_SREG, priv->sreg) ||
 380             nla_put_be32(skb, NFTA_PAYLOAD_BASE, htonl(priv->base)) ||
 381             nla_put_be32(skb, NFTA_PAYLOAD_OFFSET, htonl(priv->offset)) ||
 382             nla_put_be32(skb, NFTA_PAYLOAD_LEN, htonl(priv->len)) ||
 383             nla_put_be32(skb, NFTA_PAYLOAD_CSUM_TYPE, htonl(priv->csum_type)) ||
 384             nla_put_be32(skb, NFTA_PAYLOAD_CSUM_OFFSET,
 385                          htonl(priv->csum_offset)) ||
 386             nla_put_be32(skb, NFTA_PAYLOAD_CSUM_FLAGS, htonl(priv->csum_flags)))
 387                 goto nla_put_failure;
 388         return 0;
 389
 390 nla_put_failure:
 391         return -1;
 392 }
 393
 394 static const struct nft_expr_ops nft_payload_set_ops = {
 395         .type           = &nft_payload_type,
 396         .size           = NFT_EXPR_SIZE(sizeof(struct nft_payload_set)),
 397         .eval           = nft_payload_set_eval,
 398         .init           = nft_payload_set_init,
 399         .dump           = nft_payload_set_dump,
 400 };
 401
 402 static const struct nft_expr_ops *
 403 nft_payload_select_ops(const struct nft_ctx *ctx,
 404                        const struct nlattr * const tb[])
 405 {
 406         enum nft_payload_bases base;
 407         unsigned int offset, len;
 408         int err;
 409
 410         if (tb[NFTA_PAYLOAD_BASE] == NULL ||
 411             tb[NFTA_PAYLOAD_OFFSET] == NULL ||
 412             tb[NFTA_PAYLOAD_LEN] == NULL)
 413                 return ERR_PTR(-EINVAL);
 414
 415         base = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_BASE]));
 416         switch (base) {
 417         case NFT_PAYLOAD_LL_HEADER:
 418         case NFT_PAYLOAD_NETWORK_HEADER:
 419         case NFT_PAYLOAD_TRANSPORT_HEADER:
 420                 break;
 421         default:
 422                 return ERR_PTR(-EOPNOTSUPP);
 423         }
 424
 425         if (tb[NFTA_PAYLOAD_SREG] != NULL) {
 426                 if (tb[NFTA_PAYLOAD_DREG] != NULL)
 427                         return ERR_PTR(-EINVAL);
 428                 return &nft_payload_set_ops;
 429         }
 430
 431         if (tb[NFTA_PAYLOAD_DREG] == NULL)
 432                 return ERR_PTR(-EINVAL);
 433
 434         err = nft_parse_u32_check(tb[NFTA_PAYLOAD_OFFSET], U8_MAX, &offset);
 435         if (err < 0)
 436                 return ERR_PTR(err);
 437
 438         err = nft_parse_u32_check(tb[NFTA_PAYLOAD_LEN], U8_MAX, &len);
 439         if (err < 0)
 440                 return ERR_PTR(err);
 441
 442         if (len <= 4 && is_power_of_2(len) && IS_ALIGNED(offset, len) &&
 443             base != NFT_PAYLOAD_LL_HEADER)
 444                 return &nft_payload_fast_ops;
 445         else
 446                 return &nft_payload_ops;
 447 }
 448
 449 struct nft_expr_type nft_payload_type __read_mostly = {
 450         .name           = "payload",
 451         .select_ops     = nft_payload_select_ops,
 452         .policy         = nft_payload_policy,
 453         .maxattr        = NFTA_PAYLOAD_MAX,
 454         .owner          = THIS_MODULE,
 455 };