net/netfilter/xt_u32.c

   1 /*
   2  *      xt_u32 - kernel module to match u32 packet content
   3  *
   4  *      Original author: Don Cohen <don@isis.cs3-inc.com>
   5  *      (C) CC Computer Consultants GmbH, 2007
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/moduleparam.h>
  10 #include <linux/spinlock.h>
  11 #include <linux/skbuff.h>
  12 #include <linux/types.h>
  13 #include <linux/netfilter/x_tables.h>
  14 #include <linux/netfilter/xt_u32.h>
  15
  16 static bool u32_match_it(const struct xt_u32 *data,
  17                          const struct sk_buff *skb)
  18 {
  19         const struct xt_u32_test *ct;
  20         unsigned int testind;
  21         unsigned int nnums;
  22         unsigned int nvals;
  23         unsigned int i;
  24         __be32 n;
  25         u_int32_t pos;
  26         u_int32_t val;
  27         u_int32_t at;
  28
  29         /*
  30          * Small example: "0 >> 28 == 4 && 8 & 0xFF0000 >> 16 = 6, 17"
  31          * (=IPv4 and (TCP or UDP)). Outer loop runs over the "&&" operands.
  32          */
  33         for (testind = 0; testind < data->ntests; ++testind) {
  34                 ct  = &data->tests[testind];
  35                 at  = 0;
  36                 pos = ct->location[0].number;
  37
  38                 if (skb->len < 4 || pos > skb->len - 4)
  39                         return false;
  40
  41                 if (skb_copy_bits(skb, pos, &n, sizeof(n)) < 0)
  42                         BUG();
  43                 val   = ntohl(n);
  44                 nnums = ct->nnums;
  45
  46                 /* Inner loop runs over "&", "<<", ">>" and "@" operands */
  47                 for (i = 1; i < nnums; ++i) {
  48                         u_int32_t number = ct->location[i].number;
  49                         switch (ct->location[i].nextop) {
  50                         case XT_U32_AND:
  51                                 val &= number;
  52                                 break;
  53                         case XT_U32_LEFTSH:
  54                                 val <<= number;
  55                                 break;
  56                         case XT_U32_RIGHTSH:
  57                                 val >>= number;
  58                                 break;
  59                         case XT_U32_AT:
  60                                 if (at + val < at)
  61                                         return false;
  62                                 at += val;
  63                                 pos = number;
  64                                 if (at + 4 < at || skb->len < at + 4 ||
  65                                     pos > skb->len - at - 4)
  66                                         return false;
  67
  68                                 if (skb_copy_bits(skb, at + pos, &n,
  69                                                     sizeof(n)) < 0)
  70                                         BUG();
  71                                 val = ntohl(n);
  72                                 break;
  73                         }
  74                 }
  75
  76                 /* Run over the "," and ":" operands */
  77                 nvals = ct->nvalues;
  78                 for (i = 0; i < nvals; ++i)
  79                         if (ct->value[i].min <= val && val <= ct->value[i].max)
  80                                 break;
  81
  82                 if (i >= ct->nvalues)
  83                         return false;
  84         }
  85
  86         return true;
  87 }
  88
  89 static bool u32_mt(const struct sk_buff *skb, struct xt_action_param *par)
  90 {
  91         const struct xt_u32 *data = par->matchinfo;
  92         bool ret;
  93
  94         ret = u32_match_it(data, skb);
  95         return ret ^ data->invert;
  96 }
  97
  98 static int u32_mt_checkentry(const struct xt_mtchk_param *par)
  99 {
 100         const struct xt_u32 *data = par->matchinfo;
 101         const struct xt_u32_test *ct;
 102         unsigned int i;
 103
 104         if (data->ntests > ARRAY_SIZE(data->tests))
 105                 return -EINVAL;
 106
 107         for (i = 0; i < data->ntests; ++i) {
 108                 ct = &data->tests[i];
 109
 110                 if (ct->nnums > ARRAY_SIZE(ct->location) ||
 111                     ct->nvalues > ARRAY_SIZE(ct->value))
 112                         return -EINVAL;
 113         }
 114
 115         return 0;
 116 }
 117
 118 static struct xt_match xt_u32_mt_reg __read_mostly = {
 119         .name       = "u32",
 120         .revision   = 0,
 121         .family     = NFPROTO_UNSPEC,
 122         .match      = u32_mt,
 123         .checkentry = u32_mt_checkentry,
 124         .matchsize  = sizeof(struct xt_u32),
 125         .me         = THIS_MODULE,
 126 };
 127
 128 static int __init u32_mt_init(void)
 129 {
 130         return xt_register_match(&xt_u32_mt_reg);
 131 }
 132
 133 static void __exit u32_mt_exit(void)
 134 {
 135         xt_unregister_match(&xt_u32_mt_reg);
 136 }
 137
 138 module_init(u32_mt_init);
 139 module_exit(u32_mt_exit);
 140 MODULE_AUTHOR("Jan Engelhardt <jengelh@medozas.de>");
 141 MODULE_DESCRIPTION("Xtables: arbitrary byte matching");
 142 MODULE_LICENSE("GPL");
 143 MODULE_ALIAS("ipt_u32");
 144 MODULE_ALIAS("ip6t_u32");