net/netfilter/nft_socket.c

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #include <linux/module.h>
   3 #include <linux/netfilter/nf_tables.h>
   4 #include <net/netfilter/nf_tables.h>
   5 #include <net/netfilter/nf_tables_core.h>
   6 #include <net/netfilter/nf_socket.h>
   7 #include <net/inet_sock.h>
   8 #include <net/tcp.h>
   9
  10 struct nft_socket {
  11         enum nft_socket_keys            key:8;
  12         union {
  13                 enum nft_registers      dreg:8;
  14         };
  15 };
  16
  17 static struct sock *nft_socket_do_lookup(const struct nft_pktinfo *pkt)
  18 {
  19         const struct net_device *indev = nft_in(pkt);
  20         const struct sk_buff *skb = pkt->skb;
  21         struct sock *sk = NULL;
  22
  23         if (!indev)
  24                 return NULL;
  25
  26         switch (nft_pf(pkt)) {
  27         case NFPROTO_IPV4:
  28                 sk = nf_sk_lookup_slow_v4(nft_net(pkt), skb, indev);
  29                 break;
  30 #if IS_ENABLED(CONFIG_NF_TABLES_IPV6)
  31         case NFPROTO_IPV6:
  32                 sk = nf_sk_lookup_slow_v6(nft_net(pkt), skb, indev);
  33                 break;
  34 #endif
  35         default:
  36                 WARN_ON_ONCE(1);
  37                 break;
  38         }
  39
  40         return sk;
  41 }
  42
  43 static void nft_socket_eval(const struct nft_expr *expr,
  44                             struct nft_regs *regs,
  45                             const struct nft_pktinfo *pkt)
  46 {
  47         const struct nft_socket *priv = nft_expr_priv(expr);
  48         struct sk_buff *skb = pkt->skb;
  49         struct sock *sk = skb->sk;
  50         u32 *dest = &regs->data[priv->dreg];
  51
  52         if (sk && !net_eq(nft_net(pkt), sock_net(sk)))
  53                 sk = NULL;
  54
  55         if (!sk)
  56                 sk = nft_socket_do_lookup(pkt);
  57
  58         if (!sk) {
  59                 regs->verdict.code = NFT_BREAK;
  60                 return;
  61         }
  62
  63         switch(priv->key) {
  64         case NFT_SOCKET_TRANSPARENT:
  65                 nft_reg_store8(dest, inet_sk_transparent(sk));
  66                 break;
  67         case NFT_SOCKET_MARK:
  68                 if (sk_fullsock(sk)) {
  69                         *dest = sk->sk_mark;
  70                 } else {
  71                         regs->verdict.code = NFT_BREAK;
  72                         return;
  73                 }
  74                 break;
  75         default:
  76                 WARN_ON(1);
  77                 regs->verdict.code = NFT_BREAK;
  78         }
  79
  80         if (sk != skb->sk)
  81                 sock_gen_put(sk);
  82 }
  83
  84 static const struct nla_policy nft_socket_policy[NFTA_SOCKET_MAX + 1] = {
  85         [NFTA_SOCKET_KEY]               = { .type = NLA_U32 },
  86         [NFTA_SOCKET_DREG]              = { .type = NLA_U32 },
  87 };
  88
  89 static int nft_socket_init(const struct nft_ctx *ctx,
  90                            const struct nft_expr *expr,
  91                            const struct nlattr * const tb[])
  92 {
  93         struct nft_socket *priv = nft_expr_priv(expr);
  94         unsigned int len;
  95
  96         if (!tb[NFTA_SOCKET_DREG] || !tb[NFTA_SOCKET_KEY])
  97                 return -EINVAL;
  98
  99         switch(ctx->family) {
 100         case NFPROTO_IPV4:
 101 #if IS_ENABLED(CONFIG_NF_TABLES_IPV6)
 102         case NFPROTO_IPV6:
 103 #endif
 104         case NFPROTO_INET:
 105                 break;
 106         default:
 107                 return -EOPNOTSUPP;
 108         }
 109
 110         priv->key = ntohl(nla_get_u32(tb[NFTA_SOCKET_KEY]));
 111         switch(priv->key) {
 112         case NFT_SOCKET_TRANSPARENT:
 113                 len = sizeof(u8);
 114                 break;
 115         case NFT_SOCKET_MARK:
 116                 len = sizeof(u32);
 117                 break;
 118         default:
 119                 return -EOPNOTSUPP;
 120         }
 121
 122         priv->dreg = nft_parse_register(tb[NFTA_SOCKET_DREG]);
 123         return nft_validate_register_store(ctx, priv->dreg, NULL,
 124                                            NFT_DATA_VALUE, len);
 125 }
 126
 127 static int nft_socket_dump(struct sk_buff *skb,
 128                            const struct nft_expr *expr)
 129 {
 130         const struct nft_socket *priv = nft_expr_priv(expr);
 131
 132         if (nla_put_u32(skb, NFTA_SOCKET_KEY, htonl(priv->key)))
 133                 return -1;
 134         if (nft_dump_register(skb, NFTA_SOCKET_DREG, priv->dreg))
 135                 return -1;
 136         return 0;
 137 }
 138
 139 static int nft_socket_validate(const struct nft_ctx *ctx,
 140                                const struct nft_expr *expr,
 141                                const struct nft_data **data)
 142 {
 143         return nft_chain_validate_hooks(ctx->chain,
 144                                         (1 << NF_INET_PRE_ROUTING) |
 145                                         (1 << NF_INET_LOCAL_IN) |
 146                                         (1 << NF_INET_LOCAL_OUT));
 147 }
 148
 149 static struct nft_expr_type nft_socket_type;
 150 static const struct nft_expr_ops nft_socket_ops = {
 151         .type           = &nft_socket_type,
 152         .size           = NFT_EXPR_SIZE(sizeof(struct nft_socket)),
 153         .eval           = nft_socket_eval,
 154         .init           = nft_socket_init,
 155         .dump           = nft_socket_dump,
 156         .validate       = nft_socket_validate,
 157 };
 158
 159 static struct nft_expr_type nft_socket_type __read_mostly = {
 160         .name           = "socket",
 161         .ops            = &nft_socket_ops,
 162         .policy         = nft_socket_policy,
 163         .maxattr        = NFTA_SOCKET_MAX,
 164         .owner          = THIS_MODULE,
 165 };
 166
 167 static int __init nft_socket_module_init(void)
 168 {
 169         return nft_register_expr(&nft_socket_type);
 170 }
 171
 172 static void __exit nft_socket_module_exit(void)
 173 {
 174         nft_unregister_expr(&nft_socket_type);
 175 }
 176
 177 module_init(nft_socket_module_init);
 178 module_exit(nft_socket_module_exit);
 179
 180 MODULE_LICENSE("GPL");
 181 MODULE_AUTHOR("Máté Eckl");
 182 MODULE_DESCRIPTION("nf_tables socket match module");
 183 MODULE_ALIAS_NFT_EXPR("socket");