net/netfilter/nft_masq.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2014 Arturo Borrero Gonzalez <arturo@debian.org>
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/init.h>
   8 #include <linux/module.h>
   9 #include <linux/netlink.h>
  10 #include <linux/netfilter.h>
  11 #include <linux/netfilter/nf_tables.h>
  12 #include <net/netfilter/nf_tables.h>
  13 #include <net/netfilter/nf_nat.h>
  14 #include <net/netfilter/nf_nat_masquerade.h>
  15
  16 struct nft_masq {
  17         u32                     flags;
  18         u8                      sreg_proto_min;
  19         u8                      sreg_proto_max;
  20 };
  21
  22 static const struct nla_policy nft_masq_policy[NFTA_MASQ_MAX + 1] = {
  23         [NFTA_MASQ_FLAGS]               =
  24                 NLA_POLICY_MASK(NLA_BE32, NF_NAT_RANGE_MASK),
  25         [NFTA_MASQ_REG_PROTO_MIN]       = { .type = NLA_U32 },
  26         [NFTA_MASQ_REG_PROTO_MAX]       = { .type = NLA_U32 },
  27 };
  28
  29 static int nft_masq_validate(const struct nft_ctx *ctx,
  30                              const struct nft_expr *expr)
  31 {
  32         int err;
  33
  34         err = nft_chain_validate_dependency(ctx->chain, NFT_CHAIN_T_NAT);
  35         if (err < 0)
  36                 return err;
  37
  38         return nft_chain_validate_hooks(ctx->chain,
  39                                         (1 << NF_INET_POST_ROUTING));
  40 }
  41
  42 static int nft_masq_init(const struct nft_ctx *ctx,
  43                          const struct nft_expr *expr,
  44                          const struct nlattr * const tb[])
  45 {
  46         u32 plen = sizeof_field(struct nf_nat_range, min_proto.all);
  47         struct nft_masq *priv = nft_expr_priv(expr);
  48         int err;
  49
  50         if (tb[NFTA_MASQ_FLAGS])
  51                 priv->flags = ntohl(nla_get_be32(tb[NFTA_MASQ_FLAGS]));
  52
  53         if (tb[NFTA_MASQ_REG_PROTO_MIN]) {
  54                 err = nft_parse_register_load(ctx, tb[NFTA_MASQ_REG_PROTO_MIN],
  55                                               &priv->sreg_proto_min, plen);
  56                 if (err < 0)
  57                         return err;
  58
  59                 if (tb[NFTA_MASQ_REG_PROTO_MAX]) {
  60                         err = nft_parse_register_load(ctx, tb[NFTA_MASQ_REG_PROTO_MAX],
  61                                                       &priv->sreg_proto_max,
  62                                                       plen);
  63                         if (err < 0)
  64                                 return err;
  65                 } else {
  66                         priv->sreg_proto_max = priv->sreg_proto_min;
  67                 }
  68         }
  69
  70         return nf_ct_netns_get(ctx->net, ctx->family);
  71 }
  72
  73 static int nft_masq_dump(struct sk_buff *skb,
  74                          const struct nft_expr *expr, bool reset)
  75 {
  76         const struct nft_masq *priv = nft_expr_priv(expr);
  77
  78         if (priv->flags != 0 &&
  79             nla_put_be32(skb, NFTA_MASQ_FLAGS, htonl(priv->flags)))
  80                 goto nla_put_failure;
  81
  82         if (priv->sreg_proto_min) {
  83                 if (nft_dump_register(skb, NFTA_MASQ_REG_PROTO_MIN,
  84                                       priv->sreg_proto_min) ||
  85                     nft_dump_register(skb, NFTA_MASQ_REG_PROTO_MAX,
  86                                       priv->sreg_proto_max))
  87                         goto nla_put_failure;
  88         }
  89
  90         return 0;
  91
  92 nla_put_failure:
  93         return -1;
  94 }
  95
  96 static void nft_masq_eval(const struct nft_expr *expr,
  97                           struct nft_regs *regs,
  98                           const struct nft_pktinfo *pkt)
  99 {
 100         const struct nft_masq *priv = nft_expr_priv(expr);
 101         struct nf_nat_range2 range;
 102
 103         memset(&range, 0, sizeof(range));
 104         range.flags = priv->flags;
 105         if (priv->sreg_proto_min) {
 106                 range.min_proto.all = (__force __be16)
 107                         nft_reg_load16(&regs->data[priv->sreg_proto_min]);
 108                 range.max_proto.all = (__force __be16)
 109                         nft_reg_load16(&regs->data[priv->sreg_proto_max]);
 110         }
 111
 112         switch (nft_pf(pkt)) {
 113         case NFPROTO_IPV4:
 114                 regs->verdict.code = nf_nat_masquerade_ipv4(pkt->skb,
 115                                                             nft_hook(pkt),
 116                                                             &range,
 117                                                             nft_out(pkt));
 118                 break;
 119 #ifdef CONFIG_NF_TABLES_IPV6
 120         case NFPROTO_IPV6:
 121                 regs->verdict.code = nf_nat_masquerade_ipv6(pkt->skb, &range,
 122                                                             nft_out(pkt));
 123                 break;
 124 #endif
 125         default:
 126                 WARN_ON_ONCE(1);
 127                 break;
 128         }
 129 }
 130
 131 static void
 132 nft_masq_ipv4_destroy(const struct nft_ctx *ctx, const struct nft_expr *expr)
 133 {
 134         nf_ct_netns_put(ctx->net, NFPROTO_IPV4);
 135 }
 136
 137 static struct nft_expr_type nft_masq_ipv4_type;
 138 static const struct nft_expr_ops nft_masq_ipv4_ops = {
 139         .type           = &nft_masq_ipv4_type,
 140         .size           = NFT_EXPR_SIZE(sizeof(struct nft_masq)),
 141         .eval           = nft_masq_eval,
 142         .init           = nft_masq_init,
 143         .destroy        = nft_masq_ipv4_destroy,
 144         .dump           = nft_masq_dump,
 145         .validate       = nft_masq_validate,
 146         .reduce         = NFT_REDUCE_READONLY,
 147 };
 148
 149 static struct nft_expr_type nft_masq_ipv4_type __read_mostly = {
 150         .family         = NFPROTO_IPV4,
 151         .name           = "masq",
 152         .ops            = &nft_masq_ipv4_ops,
 153         .policy         = nft_masq_policy,
 154         .maxattr        = NFTA_MASQ_MAX,
 155         .owner          = THIS_MODULE,
 156 };
 157
 158 #ifdef CONFIG_NF_TABLES_IPV6
 159 static void
 160 nft_masq_ipv6_destroy(const struct nft_ctx *ctx, const struct nft_expr *expr)
 161 {
 162         nf_ct_netns_put(ctx->net, NFPROTO_IPV6);
 163 }
 164
 165 static struct nft_expr_type nft_masq_ipv6_type;
 166 static const struct nft_expr_ops nft_masq_ipv6_ops = {
 167         .type           = &nft_masq_ipv6_type,
 168         .size           = NFT_EXPR_SIZE(sizeof(struct nft_masq)),
 169         .eval           = nft_masq_eval,
 170         .init           = nft_masq_init,
 171         .destroy        = nft_masq_ipv6_destroy,
 172         .dump           = nft_masq_dump,
 173         .validate       = nft_masq_validate,
 174         .reduce         = NFT_REDUCE_READONLY,
 175 };
 176
 177 static struct nft_expr_type nft_masq_ipv6_type __read_mostly = {
 178         .family         = NFPROTO_IPV6,
 179         .name           = "masq",
 180         .ops            = &nft_masq_ipv6_ops,
 181         .policy         = nft_masq_policy,
 182         .maxattr        = NFTA_MASQ_MAX,
 183         .owner          = THIS_MODULE,
 184 };
 185
 186 static int __init nft_masq_module_init_ipv6(void)
 187 {
 188         return nft_register_expr(&nft_masq_ipv6_type);
 189 }
 190
 191 static void nft_masq_module_exit_ipv6(void)
 192 {
 193         nft_unregister_expr(&nft_masq_ipv6_type);
 194 }
 195 #else
 196 static inline int nft_masq_module_init_ipv6(void) { return 0; }
 197 static inline void nft_masq_module_exit_ipv6(void) {}
 198 #endif
 199
 200 #ifdef CONFIG_NF_TABLES_INET
 201 static void
 202 nft_masq_inet_destroy(const struct nft_ctx *ctx, const struct nft_expr *expr)
 203 {
 204         nf_ct_netns_put(ctx->net, NFPROTO_INET);
 205 }
 206
 207 static struct nft_expr_type nft_masq_inet_type;
 208 static const struct nft_expr_ops nft_masq_inet_ops = {
 209         .type           = &nft_masq_inet_type,
 210         .size           = NFT_EXPR_SIZE(sizeof(struct nft_masq)),
 211         .eval           = nft_masq_eval,
 212         .init           = nft_masq_init,
 213         .destroy        = nft_masq_inet_destroy,
 214         .dump           = nft_masq_dump,
 215         .validate       = nft_masq_validate,
 216         .reduce         = NFT_REDUCE_READONLY,
 217 };
 218
 219 static struct nft_expr_type nft_masq_inet_type __read_mostly = {
 220         .family         = NFPROTO_INET,
 221         .name           = "masq",
 222         .ops            = &nft_masq_inet_ops,
 223         .policy         = nft_masq_policy,
 224         .maxattr        = NFTA_MASQ_MAX,
 225         .owner          = THIS_MODULE,
 226 };
 227
 228 static int __init nft_masq_module_init_inet(void)
 229 {
 230         return nft_register_expr(&nft_masq_inet_type);
 231 }
 232
 233 static void nft_masq_module_exit_inet(void)
 234 {
 235         nft_unregister_expr(&nft_masq_inet_type);
 236 }
 237 #else
 238 static inline int nft_masq_module_init_inet(void) { return 0; }
 239 static inline void nft_masq_module_exit_inet(void) {}
 240 #endif
 241
 242 static int __init nft_masq_module_init(void)
 243 {
 244         int ret;
 245
 246         ret = nft_masq_module_init_ipv6();
 247         if (ret < 0)
 248                 return ret;
 249
 250         ret = nft_masq_module_init_inet();
 251         if (ret < 0) {
 252                 nft_masq_module_exit_ipv6();
 253                 return ret;
 254         }
 255
 256         ret = nft_register_expr(&nft_masq_ipv4_type);
 257         if (ret < 0) {
 258                 nft_masq_module_exit_inet();
 259                 nft_masq_module_exit_ipv6();
 260                 return ret;
 261         }
 262
 263         ret = nf_nat_masquerade_inet_register_notifiers();
 264         if (ret < 0) {
 265                 nft_masq_module_exit_ipv6();
 266                 nft_masq_module_exit_inet();
 267                 nft_unregister_expr(&nft_masq_ipv4_type);
 268                 return ret;
 269         }
 270
 271         return ret;
 272 }
 273
 274 static void __exit nft_masq_module_exit(void)
 275 {
 276         nft_masq_module_exit_ipv6();
 277         nft_masq_module_exit_inet();
 278         nft_unregister_expr(&nft_masq_ipv4_type);
 279         nf_nat_masquerade_inet_unregister_notifiers();
 280 }
 281
 282 module_init(nft_masq_module_init);
 283 module_exit(nft_masq_module_exit);
 284
 285 MODULE_LICENSE("GPL");
 286 MODULE_AUTHOR("Arturo Borrero Gonzalez <arturo@debian.org>");
 287 MODULE_ALIAS_NFT_EXPR("masq");
 288 MODULE_DESCRIPTION("Netfilter nftables masquerade expression support");