net/netfilter/nft_exthdr.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 <asm/unaligned.h>
   9 #include <linux/kernel.h>
  10 #include <linux/netlink.h>
  11 #include <linux/netfilter.h>
  12 #include <linux/netfilter/nf_tables.h>
  13 #include <linux/sctp.h>
  14 #include <net/netfilter/nf_tables_core.h>
  15 #include <net/netfilter/nf_tables.h>
  16 #include <net/sctp/sctp.h>
  17 #include <net/tcp.h>
  18
  19 struct nft_exthdr {
  20         u8                      type;
  21         u8                      offset;
  22         u8                      len;
  23         u8                      op;
  24         u8                      dreg;
  25         u8                      sreg;
  26         u8                      flags;
  27 };
  28
  29 static unsigned int optlen(const u8 *opt, unsigned int offset)
  30 {
  31         /* Beware zero-length options: make finite progress */
  32         if (opt[offset] <= TCPOPT_NOP || opt[offset + 1] == 0)
  33                 return 1;
  34         else
  35                 return opt[offset + 1];
  36 }
  37
  38 static void nft_exthdr_ipv6_eval(const struct nft_expr *expr,
  39                                  struct nft_regs *regs,
  40                                  const struct nft_pktinfo *pkt)
  41 {
  42         struct nft_exthdr *priv = nft_expr_priv(expr);
  43         u32 *dest = &regs->data[priv->dreg];
  44         unsigned int offset = 0;
  45         int err;
  46
  47         err = ipv6_find_hdr(pkt->skb, &offset, priv->type, NULL, NULL);
  48         if (priv->flags & NFT_EXTHDR_F_PRESENT) {
  49                 nft_reg_store8(dest, err >= 0);
  50                 return;
  51         } else if (err < 0) {
  52                 goto err;
  53         }
  54         offset += priv->offset;
  55
  56         dest[priv->len / NFT_REG32_SIZE] = 0;
  57         if (skb_copy_bits(pkt->skb, offset, dest, priv->len) < 0)
  58                 goto err;
  59         return;
  60 err:
  61         regs->verdict.code = NFT_BREAK;
  62 }
  63
  64 /* find the offset to specified option.
  65  *
  66  * If target header is found, its offset is set in *offset and return option
  67  * number. Otherwise, return negative error.
  68  *
  69  * If the first fragment doesn't contain the End of Options it is considered
  70  * invalid.
  71  */
  72 static int ipv4_find_option(struct net *net, struct sk_buff *skb,
  73                             unsigned int *offset, int target)
  74 {
  75         unsigned char optbuf[sizeof(struct ip_options) + 40];
  76         struct ip_options *opt = (struct ip_options *)optbuf;
  77         struct iphdr *iph, _iph;
  78         unsigned int start;
  79         bool found = false;
  80         __be32 info;
  81         int optlen;
  82
  83         iph = skb_header_pointer(skb, 0, sizeof(_iph), &_iph);
  84         if (!iph)
  85                 return -EBADMSG;
  86         start = sizeof(struct iphdr);
  87
  88         optlen = iph->ihl * 4 - (int)sizeof(struct iphdr);
  89         if (optlen <= 0)
  90                 return -ENOENT;
  91
  92         memset(opt, 0, sizeof(struct ip_options));
  93         /* Copy the options since __ip_options_compile() modifies
  94          * the options.
  95          */
  96         if (skb_copy_bits(skb, start, opt->__data, optlen))
  97                 return -EBADMSG;
  98         opt->optlen = optlen;
  99
 100         if (__ip_options_compile(net, opt, NULL, &info))
 101                 return -EBADMSG;
 102
 103         switch (target) {
 104         case IPOPT_SSRR:
 105         case IPOPT_LSRR:
 106                 if (!opt->srr)
 107                         break;
 108                 found = target == IPOPT_SSRR ? opt->is_strictroute :
 109                                                !opt->is_strictroute;
 110                 if (found)
 111                         *offset = opt->srr + start;
 112                 break;
 113         case IPOPT_RR:
 114                 if (!opt->rr)
 115                         break;
 116                 *offset = opt->rr + start;
 117                 found = true;
 118                 break;
 119         case IPOPT_RA:
 120                 if (!opt->router_alert)
 121                         break;
 122                 *offset = opt->router_alert + start;
 123                 found = true;
 124                 break;
 125         default:
 126                 return -EOPNOTSUPP;
 127         }
 128         return found ? target : -ENOENT;
 129 }
 130
 131 static void nft_exthdr_ipv4_eval(const struct nft_expr *expr,
 132                                  struct nft_regs *regs,
 133                                  const struct nft_pktinfo *pkt)
 134 {
 135         struct nft_exthdr *priv = nft_expr_priv(expr);
 136         u32 *dest = &regs->data[priv->dreg];
 137         struct sk_buff *skb = pkt->skb;
 138         unsigned int offset;
 139         int err;
 140
 141         if (skb->protocol != htons(ETH_P_IP))
 142                 goto err;
 143
 144         err = ipv4_find_option(nft_net(pkt), skb, &offset, priv->type);
 145         if (priv->flags & NFT_EXTHDR_F_PRESENT) {
 146                 nft_reg_store8(dest, err >= 0);
 147                 return;
 148         } else if (err < 0) {
 149                 goto err;
 150         }
 151         offset += priv->offset;
 152
 153         dest[priv->len / NFT_REG32_SIZE] = 0;
 154         if (skb_copy_bits(pkt->skb, offset, dest, priv->len) < 0)
 155                 goto err;
 156         return;
 157 err:
 158         regs->verdict.code = NFT_BREAK;
 159 }
 160
 161 static void *
 162 nft_tcp_header_pointer(const struct nft_pktinfo *pkt,
 163                        unsigned int len, void *buffer, unsigned int *tcphdr_len)
 164 {
 165         struct tcphdr *tcph;
 166
 167         if (!pkt->tprot_set || pkt->tprot != IPPROTO_TCP)
 168                 return NULL;
 169
 170         tcph = skb_header_pointer(pkt->skb, nft_thoff(pkt), sizeof(*tcph), buffer);
 171         if (!tcph)
 172                 return NULL;
 173
 174         *tcphdr_len = __tcp_hdrlen(tcph);
 175         if (*tcphdr_len < sizeof(*tcph) || *tcphdr_len > len)
 176                 return NULL;
 177
 178         return skb_header_pointer(pkt->skb, nft_thoff(pkt), *tcphdr_len, buffer);
 179 }
 180
 181 static void nft_exthdr_tcp_eval(const struct nft_expr *expr,
 182                                 struct nft_regs *regs,
 183                                 const struct nft_pktinfo *pkt)
 184 {
 185         u8 buff[sizeof(struct tcphdr) + MAX_TCP_OPTION_SPACE];
 186         struct nft_exthdr *priv = nft_expr_priv(expr);
 187         unsigned int i, optl, tcphdr_len, offset;
 188         u32 *dest = &regs->data[priv->dreg];
 189         struct tcphdr *tcph;
 190         u8 *opt;
 191
 192         tcph = nft_tcp_header_pointer(pkt, sizeof(buff), buff, &tcphdr_len);
 193         if (!tcph)
 194                 goto err;
 195
 196         opt = (u8 *)tcph;
 197         for (i = sizeof(*tcph); i < tcphdr_len - 1; i += optl) {
 198                 optl = optlen(opt, i);
 199
 200                 if (priv->type != opt[i])
 201                         continue;
 202
 203                 if (i + optl > tcphdr_len || priv->len + priv->offset > optl)
 204                         goto err;
 205
 206                 offset = i + priv->offset;
 207                 if (priv->flags & NFT_EXTHDR_F_PRESENT) {
 208                         *dest = 1;
 209                 } else {
 210                         dest[priv->len / NFT_REG32_SIZE] = 0;
 211                         memcpy(dest, opt + offset, priv->len);
 212                 }
 213
 214                 return;
 215         }
 216
 217 err:
 218         if (priv->flags & NFT_EXTHDR_F_PRESENT)
 219                 *dest = 0;
 220         else
 221                 regs->verdict.code = NFT_BREAK;
 222 }
 223
 224 static void nft_exthdr_tcp_set_eval(const struct nft_expr *expr,
 225                                     struct nft_regs *regs,
 226                                     const struct nft_pktinfo *pkt)
 227 {
 228         u8 buff[sizeof(struct tcphdr) + MAX_TCP_OPTION_SPACE];
 229         struct nft_exthdr *priv = nft_expr_priv(expr);
 230         unsigned int i, optl, tcphdr_len, offset;
 231         struct tcphdr *tcph;
 232         u8 *opt;
 233
 234         tcph = nft_tcp_header_pointer(pkt, sizeof(buff), buff, &tcphdr_len);
 235         if (!tcph)
 236                 return;
 237
 238         opt = (u8 *)tcph;
 239         for (i = sizeof(*tcph); i < tcphdr_len - 1; i += optl) {
 240                 union {
 241                         __be16 v16;
 242                         __be32 v32;
 243                 } old, new;
 244
 245                 optl = optlen(opt, i);
 246
 247                 if (priv->type != opt[i])
 248                         continue;
 249
 250                 if (i + optl > tcphdr_len || priv->len + priv->offset > optl)
 251                         return;
 252
 253                 if (skb_ensure_writable(pkt->skb,
 254                                         nft_thoff(pkt) + i + priv->len))
 255                         return;
 256
 257                 tcph = nft_tcp_header_pointer(pkt, sizeof(buff), buff,
 258                                               &tcphdr_len);
 259                 if (!tcph)
 260                         return;
 261
 262                 offset = i + priv->offset;
 263
 264                 switch (priv->len) {
 265                 case 2:
 266                         old.v16 = get_unaligned((u16 *)(opt + offset));
 267                         new.v16 = (__force __be16)nft_reg_load16(
 268                                 &regs->data[priv->sreg]);
 269
 270                         switch (priv->type) {
 271                         case TCPOPT_MSS:
 272                                 /* increase can cause connection to stall */
 273                                 if (ntohs(old.v16) <= ntohs(new.v16))
 274                                         return;
 275                         break;
 276                         }
 277
 278                         if (old.v16 == new.v16)
 279                                 return;
 280
 281                         put_unaligned(new.v16, (u16*)(opt + offset));
 282                         inet_proto_csum_replace2(&tcph->check, pkt->skb,
 283                                                  old.v16, new.v16, false);
 284                         break;
 285                 case 4:
 286                         new.v32 = regs->data[priv->sreg];
 287                         old.v32 = get_unaligned((u32 *)(opt + offset));
 288
 289                         if (old.v32 == new.v32)
 290                                 return;
 291
 292                         put_unaligned(new.v32, (u32*)(opt + offset));
 293                         inet_proto_csum_replace4(&tcph->check, pkt->skb,
 294                                                  old.v32, new.v32, false);
 295                         break;
 296                 default:
 297                         WARN_ON_ONCE(1);
 298                         break;
 299                 }
 300
 301                 return;
 302         }
 303 }
 304
 305 static void nft_exthdr_sctp_eval(const struct nft_expr *expr,
 306                                  struct nft_regs *regs,
 307                                  const struct nft_pktinfo *pkt)
 308 {
 309         unsigned int offset = nft_thoff(pkt) + sizeof(struct sctphdr);
 310         struct nft_exthdr *priv = nft_expr_priv(expr);
 311         u32 *dest = &regs->data[priv->dreg];
 312         const struct sctp_chunkhdr *sch;
 313         struct sctp_chunkhdr _sch;
 314
 315         do {
 316                 sch = skb_header_pointer(pkt->skb, offset, sizeof(_sch), &_sch);
 317                 if (!sch || !sch->length)
 318                         break;
 319
 320                 if (sch->type == priv->type) {
 321                         if (priv->flags & NFT_EXTHDR_F_PRESENT) {
 322                                 nft_reg_store8(dest, true);
 323                                 return;
 324                         }
 325                         if (priv->offset + priv->len > ntohs(sch->length) ||
 326                             offset + ntohs(sch->length) > pkt->skb->len)
 327                                 break;
 328
 329                         dest[priv->len / NFT_REG32_SIZE] = 0;
 330                         if (skb_copy_bits(pkt->skb, offset + priv->offset,
 331                                           dest, priv->len) < 0)
 332                                 break;
 333                         return;
 334                 }
 335                 offset += SCTP_PAD4(ntohs(sch->length));
 336         } while (offset < pkt->skb->len);
 337
 338         if (priv->flags & NFT_EXTHDR_F_PRESENT)
 339                 nft_reg_store8(dest, false);
 340         else
 341                 regs->verdict.code = NFT_BREAK;
 342 }
 343
 344 static const struct nla_policy nft_exthdr_policy[NFTA_EXTHDR_MAX + 1] = {
 345         [NFTA_EXTHDR_DREG]              = { .type = NLA_U32 },
 346         [NFTA_EXTHDR_TYPE]              = { .type = NLA_U8 },
 347         [NFTA_EXTHDR_OFFSET]            = { .type = NLA_U32 },
 348         [NFTA_EXTHDR_LEN]               = { .type = NLA_U32 },
 349         [NFTA_EXTHDR_FLAGS]             = { .type = NLA_U32 },
 350         [NFTA_EXTHDR_OP]                = { .type = NLA_U32 },
 351         [NFTA_EXTHDR_SREG]              = { .type = NLA_U32 },
 352 };
 353
 354 static int nft_exthdr_init(const struct nft_ctx *ctx,
 355                            const struct nft_expr *expr,
 356                            const struct nlattr * const tb[])
 357 {
 358         struct nft_exthdr *priv = nft_expr_priv(expr);
 359         u32 offset, len, flags = 0, op = NFT_EXTHDR_OP_IPV6;
 360         int err;
 361
 362         if (!tb[NFTA_EXTHDR_DREG] ||
 363             !tb[NFTA_EXTHDR_TYPE] ||
 364             !tb[NFTA_EXTHDR_OFFSET] ||
 365             !tb[NFTA_EXTHDR_LEN])
 366                 return -EINVAL;
 367
 368         err = nft_parse_u32_check(tb[NFTA_EXTHDR_OFFSET], U8_MAX, &offset);
 369         if (err < 0)
 370                 return err;
 371
 372         err = nft_parse_u32_check(tb[NFTA_EXTHDR_LEN], U8_MAX, &len);
 373         if (err < 0)
 374                 return err;
 375
 376         if (tb[NFTA_EXTHDR_FLAGS]) {
 377                 err = nft_parse_u32_check(tb[NFTA_EXTHDR_FLAGS], U8_MAX, &flags);
 378                 if (err < 0)
 379                         return err;
 380
 381                 if (flags & ~NFT_EXTHDR_F_PRESENT)
 382                         return -EINVAL;
 383         }
 384
 385         if (tb[NFTA_EXTHDR_OP]) {
 386                 err = nft_parse_u32_check(tb[NFTA_EXTHDR_OP], U8_MAX, &op);
 387                 if (err < 0)
 388                         return err;
 389         }
 390
 391         priv->type   = nla_get_u8(tb[NFTA_EXTHDR_TYPE]);
 392         priv->offset = offset;
 393         priv->len    = len;
 394         priv->flags  = flags;
 395         priv->op     = op;
 396
 397         return nft_parse_register_store(ctx, tb[NFTA_EXTHDR_DREG],
 398                                         &priv->dreg, NULL, NFT_DATA_VALUE,
 399                                         priv->len);
 400 }
 401
 402 static int nft_exthdr_tcp_set_init(const struct nft_ctx *ctx,
 403                                    const struct nft_expr *expr,
 404                                    const struct nlattr * const tb[])
 405 {
 406         struct nft_exthdr *priv = nft_expr_priv(expr);
 407         u32 offset, len, flags = 0, op = NFT_EXTHDR_OP_IPV6;
 408         int err;
 409
 410         if (!tb[NFTA_EXTHDR_SREG] ||
 411             !tb[NFTA_EXTHDR_TYPE] ||
 412             !tb[NFTA_EXTHDR_OFFSET] ||
 413             !tb[NFTA_EXTHDR_LEN])
 414                 return -EINVAL;
 415
 416         if (tb[NFTA_EXTHDR_DREG] || tb[NFTA_EXTHDR_FLAGS])
 417                 return -EINVAL;
 418
 419         err = nft_parse_u32_check(tb[NFTA_EXTHDR_OFFSET], U8_MAX, &offset);
 420         if (err < 0)
 421                 return err;
 422
 423         err = nft_parse_u32_check(tb[NFTA_EXTHDR_LEN], U8_MAX, &len);
 424         if (err < 0)
 425                 return err;
 426
 427         if (offset < 2)
 428                 return -EOPNOTSUPP;
 429
 430         switch (len) {
 431         case 2: break;
 432         case 4: break;
 433         default:
 434                 return -EOPNOTSUPP;
 435         }
 436
 437         err = nft_parse_u32_check(tb[NFTA_EXTHDR_OP], U8_MAX, &op);
 438         if (err < 0)
 439                 return err;
 440
 441         priv->type   = nla_get_u8(tb[NFTA_EXTHDR_TYPE]);
 442         priv->offset = offset;
 443         priv->len    = len;
 444         priv->flags  = flags;
 445         priv->op     = op;
 446
 447         return nft_parse_register_load(tb[NFTA_EXTHDR_SREG], &priv->sreg,
 448                                        priv->len);
 449 }
 450
 451 static int nft_exthdr_ipv4_init(const struct nft_ctx *ctx,
 452                                 const struct nft_expr *expr,
 453                                 const struct nlattr * const tb[])
 454 {
 455         struct nft_exthdr *priv = nft_expr_priv(expr);
 456         int err = nft_exthdr_init(ctx, expr, tb);
 457
 458         if (err < 0)
 459                 return err;
 460
 461         switch (priv->type) {
 462         case IPOPT_SSRR:
 463         case IPOPT_LSRR:
 464         case IPOPT_RR:
 465         case IPOPT_RA:
 466                 break;
 467         default:
 468                 return -EOPNOTSUPP;
 469         }
 470         return 0;
 471 }
 472
 473 static int nft_exthdr_dump_common(struct sk_buff *skb, const struct nft_exthdr *priv)
 474 {
 475         if (nla_put_u8(skb, NFTA_EXTHDR_TYPE, priv->type))
 476                 goto nla_put_failure;
 477         if (nla_put_be32(skb, NFTA_EXTHDR_OFFSET, htonl(priv->offset)))
 478                 goto nla_put_failure;
 479         if (nla_put_be32(skb, NFTA_EXTHDR_LEN, htonl(priv->len)))
 480                 goto nla_put_failure;
 481         if (nla_put_be32(skb, NFTA_EXTHDR_FLAGS, htonl(priv->flags)))
 482                 goto nla_put_failure;
 483         if (nla_put_be32(skb, NFTA_EXTHDR_OP, htonl(priv->op)))
 484                 goto nla_put_failure;
 485         return 0;
 486
 487 nla_put_failure:
 488         return -1;
 489 }
 490
 491 static int nft_exthdr_dump(struct sk_buff *skb, const struct nft_expr *expr)
 492 {
 493         const struct nft_exthdr *priv = nft_expr_priv(expr);
 494
 495         if (nft_dump_register(skb, NFTA_EXTHDR_DREG, priv->dreg))
 496                 return -1;
 497
 498         return nft_exthdr_dump_common(skb, priv);
 499 }
 500
 501 static int nft_exthdr_dump_set(struct sk_buff *skb, const struct nft_expr *expr)
 502 {
 503         const struct nft_exthdr *priv = nft_expr_priv(expr);
 504
 505         if (nft_dump_register(skb, NFTA_EXTHDR_SREG, priv->sreg))
 506                 return -1;
 507
 508         return nft_exthdr_dump_common(skb, priv);
 509 }
 510
 511 static const struct nft_expr_ops nft_exthdr_ipv6_ops = {
 512         .type           = &nft_exthdr_type,
 513         .size           = NFT_EXPR_SIZE(sizeof(struct nft_exthdr)),
 514         .eval           = nft_exthdr_ipv6_eval,
 515         .init           = nft_exthdr_init,
 516         .dump           = nft_exthdr_dump,
 517 };
 518
 519 static const struct nft_expr_ops nft_exthdr_ipv4_ops = {
 520         .type           = &nft_exthdr_type,
 521         .size           = NFT_EXPR_SIZE(sizeof(struct nft_exthdr)),
 522         .eval           = nft_exthdr_ipv4_eval,
 523         .init           = nft_exthdr_ipv4_init,
 524         .dump           = nft_exthdr_dump,
 525 };
 526
 527 static const struct nft_expr_ops nft_exthdr_tcp_ops = {
 528         .type           = &nft_exthdr_type,
 529         .size           = NFT_EXPR_SIZE(sizeof(struct nft_exthdr)),
 530         .eval           = nft_exthdr_tcp_eval,
 531         .init           = nft_exthdr_init,
 532         .dump           = nft_exthdr_dump,
 533 };
 534
 535 static const struct nft_expr_ops nft_exthdr_tcp_set_ops = {
 536         .type           = &nft_exthdr_type,
 537         .size           = NFT_EXPR_SIZE(sizeof(struct nft_exthdr)),
 538         .eval           = nft_exthdr_tcp_set_eval,
 539         .init           = nft_exthdr_tcp_set_init,
 540         .dump           = nft_exthdr_dump_set,
 541 };
 542
 543 static const struct nft_expr_ops nft_exthdr_sctp_ops = {
 544         .type           = &nft_exthdr_type,
 545         .size           = NFT_EXPR_SIZE(sizeof(struct nft_exthdr)),
 546         .eval           = nft_exthdr_sctp_eval,
 547         .init           = nft_exthdr_init,
 548         .dump           = nft_exthdr_dump,
 549 };
 550
 551 static const struct nft_expr_ops *
 552 nft_exthdr_select_ops(const struct nft_ctx *ctx,
 553                       const struct nlattr * const tb[])
 554 {
 555         u32 op;
 556
 557         if (!tb[NFTA_EXTHDR_OP])
 558                 return &nft_exthdr_ipv6_ops;
 559
 560         if (tb[NFTA_EXTHDR_SREG] && tb[NFTA_EXTHDR_DREG])
 561                 return ERR_PTR(-EOPNOTSUPP);
 562
 563         op = ntohl(nla_get_be32(tb[NFTA_EXTHDR_OP]));
 564         switch (op) {
 565         case NFT_EXTHDR_OP_TCPOPT:
 566                 if (tb[NFTA_EXTHDR_SREG])
 567                         return &nft_exthdr_tcp_set_ops;
 568                 if (tb[NFTA_EXTHDR_DREG])
 569                         return &nft_exthdr_tcp_ops;
 570                 break;
 571         case NFT_EXTHDR_OP_IPV6:
 572                 if (tb[NFTA_EXTHDR_DREG])
 573                         return &nft_exthdr_ipv6_ops;
 574                 break;
 575         case NFT_EXTHDR_OP_IPV4:
 576                 if (ctx->family != NFPROTO_IPV6) {
 577                         if (tb[NFTA_EXTHDR_DREG])
 578                                 return &nft_exthdr_ipv4_ops;
 579                 }
 580                 break;
 581         case NFT_EXTHDR_OP_SCTP:
 582                 if (tb[NFTA_EXTHDR_DREG])
 583                         return &nft_exthdr_sctp_ops;
 584                 break;
 585         }
 586
 587         return ERR_PTR(-EOPNOTSUPP);
 588 }
 589
 590 struct nft_expr_type nft_exthdr_type __read_mostly = {
 591         .name           = "exthdr",
 592         .select_ops     = nft_exthdr_select_ops,
 593         .policy         = nft_exthdr_policy,
 594         .maxattr        = NFTA_EXTHDR_MAX,
 595         .owner          = THIS_MODULE,
 596 };