netfilter: nf_tables: add connlimit support
This features which allows you to limit the maximum number of connections per arbitrary key. The connlimit expression is stateful, therefore it can be used from meters to dynamically populate a set, this provides a mapping to the iptables' connlimit match. This patch also comes that allows you define static connlimit policies. This extension depends on the nf_conncount infrastructure. Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
This commit is contained in:
Pablo Neira Ayuso
parent
371ebcbb9e
commit
290180e244
@ -1043,6 +1043,24 @@ enum nft_limit_attributes {
|
||||
};
|
||||
#define NFTA_LIMIT_MAX (__NFTA_LIMIT_MAX - 1)
|
||||
|
||||
enum nft_connlimit_flags {
|
||||
NFT_CONNLIMIT_F_INV = (1 << 0),
|
||||
};
|
||||
|
||||
/**
|
||||
* enum nft_connlimit_attributes - nf_tables connlimit expression netlink attributes
|
||||
*
|
||||
* @NFTA_CONNLIMIT_COUNT: number of connections (NLA_U32)
|
||||
* @NFTA_CONNLIMIT_FLAGS: flags (NLA_U32: enum nft_connlimit_flags)
|
||||
*/
|
||||
enum nft_connlimit_attributes {
|
||||
NFTA_CONNLIMIT_UNSPEC,
|
||||
NFTA_CONNLIMIT_COUNT,
|
||||
NFTA_CONNLIMIT_FLAGS,
|
||||
__NFTA_CONNLIMIT_MAX
|
||||
};
|
||||
#define NFTA_CONNLIMIT_MAX (__NFTA_CONNLIMIT_MAX - 1)
|
||||
|
||||
/**
|
||||
* enum nft_counter_attributes - nf_tables counter expression netlink attributes
|
||||
*
|
||||
@ -1357,7 +1375,8 @@ enum nft_ct_helper_attributes {
|
||||
#define NFT_OBJECT_QUOTA 2
|
||||
#define NFT_OBJECT_CT_HELPER 3
|
||||
#define NFT_OBJECT_LIMIT 4
|
||||
#define __NFT_OBJECT_MAX 5
|
||||
#define NFT_OBJECT_CONNLIMIT 5
|
||||
#define __NFT_OBJECT_MAX 6
|
||||
#define NFT_OBJECT_MAX (__NFT_OBJECT_MAX - 1)
|
||||
|
||||
/**
|
||||
|
||||
@ -517,6 +517,15 @@ config NFT_COUNTER
|
||||
This option adds the "counter" expression that you can use to
|
||||
include packet and byte counters in a rule.
|
||||
|
||||
config NFT_CONNLIMIT
|
||||
tristate "Netfilter nf_tables connlimit module"
|
||||
depends on NF_CONNTRACK
|
||||
depends on NETFILTER_ADVANCED
|
||||
select NETFILTER_CONNCOUNT
|
||||
help
|
||||
This option adds the "connlimit" expression that you can use to
|
||||
ratelimit rule matchings per connections.
|
||||
|
||||
config NFT_LOG
|
||||
tristate "Netfilter nf_tables log module"
|
||||
help
|
||||
|
||||
@ -80,6 +80,7 @@ nf_tables-objs := nf_tables_core.o nf_tables_api.o nft_chain_filter.o \
|
||||
|
||||
obj-$(CONFIG_NF_TABLES) += nf_tables.o
|
||||
obj-$(CONFIG_NFT_COMPAT) += nft_compat.o
|
||||
obj-$(CONFIG_NFT_CONNLIMIT) += nft_connlimit.o
|
||||
obj-$(CONFIG_NFT_NUMGEN) += nft_numgen.o
|
||||
obj-$(CONFIG_NFT_CT) += nft_ct.o
|
||||
obj-$(CONFIG_NFT_FLOW_OFFLOAD) += nft_flow_offload.o
|
||||
|
||||
297
net/netfilter/nft_connlimit.c
Normal file
297
net/netfilter/nft_connlimit.c
Normal file
@ -0,0 +1,297 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0 */
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/netlink.h>
|
||||
#include <linux/netfilter.h>
|
||||
#include <linux/netfilter/nf_tables.h>
|
||||
#include <net/netfilter/nf_tables.h>
|
||||
#include <net/netfilter/nf_conntrack.h>
|
||||
#include <net/netfilter/nf_conntrack_count.h>
|
||||
#include <net/netfilter/nf_conntrack_core.h>
|
||||
#include <net/netfilter/nf_conntrack_tuple.h>
|
||||
#include <net/netfilter/nf_conntrack_zones.h>
|
||||
|
||||
struct nft_connlimit {
|
||||
spinlock_t lock;
|
||||
struct hlist_head hhead;
|
||||
u32 limit;
|
||||
bool invert;
|
||||
};
|
||||
|
||||
static inline void nft_connlimit_do_eval(struct nft_connlimit *priv,
|
||||
struct nft_regs *regs,
|
||||
const struct nft_pktinfo *pkt,
|
||||
const struct nft_set_ext *ext)
|
||||
{
|
||||
const struct nf_conntrack_zone *zone = &nf_ct_zone_dflt;
|
||||
const struct nf_conntrack_tuple *tuple_ptr;
|
||||
struct nf_conntrack_tuple tuple;
|
||||
enum ip_conntrack_info ctinfo;
|
||||
const struct nf_conn *ct;
|
||||
unsigned int count;
|
||||
bool addit;
|
||||
|
||||
tuple_ptr = &tuple;
|
||||
|
||||
ct = nf_ct_get(pkt->skb, &ctinfo);
|
||||
if (ct != NULL) {
|
||||
tuple_ptr = &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple;
|
||||
zone = nf_ct_zone(ct);
|
||||
} else if (!nf_ct_get_tuplepr(pkt->skb, skb_network_offset(pkt->skb),
|
||||
nft_pf(pkt), nft_net(pkt), &tuple)) {
|
||||
regs->verdict.code = NF_DROP;
|
||||
return;
|
||||
}
|
||||
|
||||
spin_lock_bh(&priv->lock);
|
||||
count = nf_conncount_lookup(nft_net(pkt), &priv->hhead, tuple_ptr, zone,
|
||||
&addit);
|
||||
|
||||
if (!addit)
|
||||
goto out;
|
||||
|
||||
if (!nf_conncount_add(&priv->hhead, tuple_ptr)) {
|
||||
regs->verdict.code = NF_DROP;
|
||||
spin_unlock_bh(&priv->lock);
|
||||
return;
|
||||
}
|
||||
count++;
|
||||
out:
|
||||
spin_unlock_bh(&priv->lock);
|
||||
|
||||
if ((count > priv->limit) ^ priv->invert) {
|
||||
regs->verdict.code = NFT_BREAK;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
static int nft_connlimit_do_init(const struct nft_ctx *ctx,
|
||||
const struct nlattr * const tb[],
|
||||
struct nft_connlimit *priv)
|
||||
{
|
||||
bool invert = false;
|
||||
u32 flags, limit;
|
||||
|
||||
if (!tb[NFTA_CONNLIMIT_COUNT])
|
||||
return -EINVAL;
|
||||
|
||||
limit = ntohl(nla_get_be32(tb[NFTA_CONNLIMIT_COUNT]));
|
||||
|
||||
if (tb[NFTA_CONNLIMIT_FLAGS]) {
|
||||
flags = ntohl(nla_get_be32(tb[NFTA_CONNLIMIT_FLAGS]));
|
||||
if (flags & ~NFT_CONNLIMIT_F_INV)
|
||||
return -EOPNOTSUPP;
|
||||
if (flags & NFT_CONNLIMIT_F_INV)
|
||||
invert = true;
|
||||
}
|
||||
|
||||
spin_lock_init(&priv->lock);
|
||||
INIT_HLIST_HEAD(&priv->hhead);
|
||||
priv->limit = limit;
|
||||
priv->invert = invert;
|
||||
|
||||
return nf_ct_netns_get(ctx->net, ctx->family);
|
||||
}
|
||||
|
||||
static void nft_connlimit_do_destroy(const struct nft_ctx *ctx,
|
||||
struct nft_connlimit *priv)
|
||||
{
|
||||
nf_ct_netns_put(ctx->net, ctx->family);
|
||||
nf_conncount_cache_free(&priv->hhead);
|
||||
}
|
||||
|
||||
static int nft_connlimit_do_dump(struct sk_buff *skb,
|
||||
struct nft_connlimit *priv)
|
||||
{
|
||||
if (nla_put_be32(skb, NFTA_CONNLIMIT_COUNT, htonl(priv->limit)))
|
||||
goto nla_put_failure;
|
||||
if (priv->invert &&
|
||||
nla_put_be32(skb, NFTA_CONNLIMIT_FLAGS, htonl(NFT_CONNLIMIT_F_INV)))
|
||||
goto nla_put_failure;
|
||||
|
||||
return 0;
|
||||
|
||||
nla_put_failure:
|
||||
return -1;
|
||||
}
|
||||
|
||||
static inline void nft_connlimit_obj_eval(struct nft_object *obj,
|
||||
struct nft_regs *regs,
|
||||
const struct nft_pktinfo *pkt)
|
||||
{
|
||||
struct nft_connlimit *priv = nft_obj_data(obj);
|
||||
|
||||
nft_connlimit_do_eval(priv, regs, pkt, NULL);
|
||||
}
|
||||
|
||||
static int nft_connlimit_obj_init(const struct nft_ctx *ctx,
|
||||
const struct nlattr * const tb[],
|
||||
struct nft_object *obj)
|
||||
{
|
||||
struct nft_connlimit *priv = nft_obj_data(obj);
|
||||
|
||||
return nft_connlimit_do_init(ctx, tb, priv);
|
||||
}
|
||||
|
||||
static void nft_connlimit_obj_destroy(const struct nft_ctx *ctx,
|
||||
struct nft_object *obj)
|
||||
{
|
||||
struct nft_connlimit *priv = nft_obj_data(obj);
|
||||
|
||||
nft_connlimit_do_destroy(ctx, priv);
|
||||
}
|
||||
|
||||
static int nft_connlimit_obj_dump(struct sk_buff *skb,
|
||||
struct nft_object *obj, bool reset)
|
||||
{
|
||||
struct nft_connlimit *priv = nft_obj_data(obj);
|
||||
|
||||
return nft_connlimit_do_dump(skb, priv);
|
||||
}
|
||||
|
||||
static const struct nla_policy nft_connlimit_policy[NFTA_CONNLIMIT_MAX + 1] = {
|
||||
[NFTA_CONNLIMIT_COUNT] = { .type = NLA_U32 },
|
||||
[NFTA_CONNLIMIT_FLAGS] = { .type = NLA_U32 },
|
||||
};
|
||||
|
||||
static struct nft_object_type nft_connlimit_obj_type;
|
||||
static const struct nft_object_ops nft_connlimit_obj_ops = {
|
||||
.type = &nft_connlimit_obj_type,
|
||||
.size = sizeof(struct nft_connlimit),
|
||||
.eval = nft_connlimit_obj_eval,
|
||||
.init = nft_connlimit_obj_init,
|
||||
.destroy = nft_connlimit_obj_destroy,
|
||||
.dump = nft_connlimit_obj_dump,
|
||||
};
|
||||
|
||||
static struct nft_object_type nft_connlimit_obj_type __read_mostly = {
|
||||
.type = NFT_OBJECT_CONNLIMIT,
|
||||
.ops = &nft_connlimit_obj_ops,
|
||||
.maxattr = NFTA_CONNLIMIT_MAX,
|
||||
.policy = nft_connlimit_policy,
|
||||
.owner = THIS_MODULE,
|
||||
};
|
||||
|
||||
static void nft_connlimit_eval(const struct nft_expr *expr,
|
||||
struct nft_regs *regs,
|
||||
const struct nft_pktinfo *pkt)
|
||||
{
|
||||
struct nft_connlimit *priv = nft_expr_priv(expr);
|
||||
|
||||
nft_connlimit_do_eval(priv, regs, pkt, NULL);
|
||||
}
|
||||
|
||||
static int nft_connlimit_dump(struct sk_buff *skb, const struct nft_expr *expr)
|
||||
{
|
||||
struct nft_connlimit *priv = nft_expr_priv(expr);
|
||||
|
||||
return nft_connlimit_do_dump(skb, priv);
|
||||
}
|
||||
|
||||
static int nft_connlimit_init(const struct nft_ctx *ctx,
|
||||
const struct nft_expr *expr,
|
||||
const struct nlattr * const tb[])
|
||||
{
|
||||
struct nft_connlimit *priv = nft_expr_priv(expr);
|
||||
|
||||
return nft_connlimit_do_init(ctx, tb, priv);
|
||||
}
|
||||
|
||||
static void nft_connlimit_destroy(const struct nft_ctx *ctx,
|
||||
const struct nft_expr *expr)
|
||||
{
|
||||
struct nft_connlimit *priv = nft_expr_priv(expr);
|
||||
|
||||
nft_connlimit_do_destroy(ctx, priv);
|
||||
}
|
||||
|
||||
static int nft_connlimit_clone(struct nft_expr *dst, const struct nft_expr *src)
|
||||
{
|
||||
struct nft_connlimit *priv_dst = nft_expr_priv(dst);
|
||||
struct nft_connlimit *priv_src = nft_expr_priv(src);
|
||||
|
||||
spin_lock_init(&priv_dst->lock);
|
||||
INIT_HLIST_HEAD(&priv_dst->hhead);
|
||||
priv_dst->limit = priv_src->limit;
|
||||
priv_dst->invert = priv_src->invert;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void nft_connlimit_destroy_clone(const struct nft_ctx *ctx,
|
||||
const struct nft_expr *expr)
|
||||
{
|
||||
struct nft_connlimit *priv = nft_expr_priv(expr);
|
||||
|
||||
nf_conncount_cache_free(&priv->hhead);
|
||||
}
|
||||
|
||||
static bool nft_connlimit_gc(struct net *net, const struct nft_expr *expr)
|
||||
{
|
||||
struct nft_connlimit *priv = nft_expr_priv(expr);
|
||||
bool addit, ret;
|
||||
|
||||
spin_lock_bh(&priv->lock);
|
||||
nf_conncount_lookup(net, &priv->hhead, NULL, &nf_ct_zone_dflt, &addit);
|
||||
|
||||
ret = hlist_empty(&priv->hhead);
|
||||
spin_unlock_bh(&priv->lock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct nft_expr_type nft_connlimit_type;
|
||||
static const struct nft_expr_ops nft_connlimit_ops = {
|
||||
.type = &nft_connlimit_type,
|
||||
.size = NFT_EXPR_SIZE(sizeof(struct nft_connlimit)),
|
||||
.eval = nft_connlimit_eval,
|
||||
.init = nft_connlimit_init,
|
||||
.destroy = nft_connlimit_destroy,
|
||||
.clone = nft_connlimit_clone,
|
||||
.destroy_clone = nft_connlimit_destroy_clone,
|
||||
.dump = nft_connlimit_dump,
|
||||
.gc = nft_connlimit_gc,
|
||||
};
|
||||
|
||||
static struct nft_expr_type nft_connlimit_type __read_mostly = {
|
||||
.name = "connlimit",
|
||||
.ops = &nft_connlimit_ops,
|
||||
.policy = nft_connlimit_policy,
|
||||
.maxattr = NFTA_CONNLIMIT_MAX,
|
||||
.flags = NFT_EXPR_STATEFUL | NFT_EXPR_GC,
|
||||
.owner = THIS_MODULE,
|
||||
};
|
||||
|
||||
static int __init nft_connlimit_module_init(void)
|
||||
{
|
||||
int err;
|
||||
|
||||
err = nft_register_obj(&nft_connlimit_obj_type);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
err = nft_register_expr(&nft_connlimit_type);
|
||||
if (err < 0)
|
||||
goto err1;
|
||||
|
||||
return 0;
|
||||
err1:
|
||||
nft_unregister_obj(&nft_connlimit_obj_type);
|
||||
return err;
|
||||
}
|
||||
|
||||
static void __exit nft_connlimit_module_exit(void)
|
||||
{
|
||||
nft_unregister_expr(&nft_connlimit_type);
|
||||
nft_unregister_obj(&nft_connlimit_obj_type);
|
||||
}
|
||||
|
||||
module_init(nft_connlimit_module_init);
|
||||
module_exit(nft_connlimit_module_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("Pablo Neira Ayuso");
|
||||
MODULE_ALIAS_NFT_EXPR("connlimit");
|
||||
MODULE_ALIAS_NFT_OBJ(NFT_OBJECT_CONNLIMIT);
|
||||
Loading…
Reference in New Issue
Block a user