From c5a98195523416e4fa21fc649b4c61ef653eec32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?M=C3=A1t=C3=A9=20Eckl?= Date: Fri, 20 Jul 2018 09:38:24 +0200 Subject: expr: Add tproxy support MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Máté Eckl Signed-off-by: Pablo Neira Ayuso --- include/libnftnl/expr.h | 6 ++ include/linux/netfilter/nf_tables.h | 16 +++ src/Makefile.am | 1 + src/expr/tproxy.c | 205 ++++++++++++++++++++++++++++++++++++ src/expr_ops.c | 2 + 5 files changed, 230 insertions(+) create mode 100644 src/expr/tproxy.c diff --git a/include/libnftnl/expr.h b/include/libnftnl/expr.h index 219104e..141b04a 100644 --- a/include/libnftnl/expr.h +++ b/include/libnftnl/expr.h @@ -137,6 +137,12 @@ enum { NFTNL_EXPR_NAT_FLAGS, }; +enum { + NFTNL_EXPR_TPROXY_FAMILY = NFTNL_EXPR_BASE, + NFTNL_EXPR_TPROXY_REG_ADDR, + NFTNL_EXPR_TPROXY_REG_PORT, +}; + enum { NFTNL_EXPR_LOOKUP_SREG = NFTNL_EXPR_BASE, NFTNL_EXPR_LOOKUP_DREG, diff --git a/include/linux/netfilter/nf_tables.h b/include/linux/netfilter/nf_tables.h index eef157d..4b3a95e 100644 --- a/include/linux/netfilter/nf_tables.h +++ b/include/linux/netfilter/nf_tables.h @@ -1225,6 +1225,22 @@ enum nft_nat_attributes { }; #define NFTA_NAT_MAX (__NFTA_NAT_MAX - 1) +/** + * enum nft_tproxy_attributes - nf_tables tproxy expression netlink attributes + * + * NFTA_TPROXY_FAMILY: Target address family (NLA_U32: nft_registers) + * NFTA_TPROXY_REG_ADDR: Target address register (NLA_U32: nft_registers) + * NFTA_TPROXY_REG_PORT: Target port register (NLA_U32: nft_registers) + */ +enum nft_tproxy_attributes { + NFTA_TPROXY_UNSPEC, + NFTA_TPROXY_FAMILY, + NFTA_TPROXY_REG_ADDR, + NFTA_TPROXY_REG_PORT, + __NFTA_TPROXY_MAX +}; +#define NFTA_TPROXY_MAX (__NFTA_TPROXY_MAX - 1) + /** * enum nft_masq_attributes - nf_tables masquerade expression attributes * diff --git a/src/Makefile.am b/src/Makefile.am index c66a257..fc03661 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -45,6 +45,7 @@ libnftnl_la_SOURCES = utils.c \ expr/meta.c \ expr/numgen.c \ expr/nat.c \ + expr/tproxy.c \ expr/objref.c \ expr/payload.c \ expr/queue.c \ diff --git a/src/expr/tproxy.c b/src/expr/tproxy.c new file mode 100644 index 0000000..6fae172 --- /dev/null +++ b/src/expr/tproxy.c @@ -0,0 +1,205 @@ +/* + * Copyright (c) 2018 Máté Eckl + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#include "internal.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct nftnl_expr_tproxy { + enum nft_registers sreg_addr; + enum nft_registers sreg_port; + int family; +}; + +static int +nftnl_expr_tproxy_set(struct nftnl_expr *e, uint16_t type, + const void *data, uint32_t data_len) +{ + struct nftnl_expr_tproxy *tproxy = nftnl_expr_data(e); + + switch(type) { + case NFTNL_EXPR_TPROXY_FAMILY: + tproxy->family = *((uint32_t *)data); + break; + case NFTNL_EXPR_TPROXY_REG_ADDR: + tproxy->sreg_addr = *((uint32_t *)data); + break; + case NFTNL_EXPR_TPROXY_REG_PORT: + tproxy->sreg_port = *((uint32_t *)data); + break; + default: + return -1; + } + + return 0; +} + +static const void * +nftnl_expr_tproxy_get(const struct nftnl_expr *e, uint16_t type, + uint32_t *data_len) +{ + struct nftnl_expr_tproxy *tproxy = nftnl_expr_data(e); + + switch(type) { + case NFTNL_EXPR_TPROXY_FAMILY: + *data_len = sizeof(tproxy->family); + return &tproxy->family; + case NFTNL_EXPR_TPROXY_REG_ADDR: + *data_len = sizeof(tproxy->sreg_addr); + return &tproxy->sreg_addr; + case NFTNL_EXPR_TPROXY_REG_PORT: + *data_len = sizeof(tproxy->sreg_port); + return &tproxy->sreg_port; + } + return NULL; +} + +static int nftnl_expr_tproxy_cb(const struct nlattr *attr, void *data) +{ + const struct nlattr **tb = data; + int type = mnl_attr_get_type(attr); + + if (mnl_attr_type_valid(attr, NFTA_TPROXY_MAX) < 0) + return MNL_CB_OK; + + switch(type) { + case NFTA_TPROXY_FAMILY: + case NFTA_TPROXY_REG_ADDR: + case NFTA_TPROXY_REG_PORT: + if (mnl_attr_validate(attr, MNL_TYPE_U32) < 0) + abi_breakage(); + break; + } + + tb[type] = attr; + return MNL_CB_OK; +} + +static int +nftnl_expr_tproxy_parse(struct nftnl_expr *e, struct nlattr *attr) +{ + struct nftnl_expr_tproxy *tproxy = nftnl_expr_data(e); + struct nlattr *tb[NFTA_TPROXY_MAX + 1] = {}; + + if (mnl_attr_parse_nested(attr, nftnl_expr_tproxy_cb, tb) < 0) + return -1; + + if (tb[NFTA_TPROXY_FAMILY]) { + tproxy->family = ntohl(mnl_attr_get_u32(tb[NFTA_TPROXY_FAMILY])); + e->flags |= (1 << NFTNL_EXPR_TPROXY_FAMILY); + } + if (tb[NFTA_TPROXY_REG_ADDR]) { + tproxy->sreg_addr = + ntohl(mnl_attr_get_u32(tb[NFTA_TPROXY_REG_ADDR])); + e->flags |= (1 << NFTNL_EXPR_TPROXY_REG_ADDR); + } + if (tb[NFTA_TPROXY_REG_PORT]) { + tproxy->sreg_port = + ntohl(mnl_attr_get_u32(tb[NFTA_TPROXY_REG_PORT])); + e->flags |= (1 << NFTNL_EXPR_TPROXY_REG_PORT); + } + + return 0; +} + +static void +nftnl_expr_tproxy_build(struct nlmsghdr *nlh, const struct nftnl_expr *e) +{ + struct nftnl_expr_tproxy *tproxy = nftnl_expr_data(e); + + if (e->flags & (1 << NFTNL_EXPR_TPROXY_FAMILY)) + mnl_attr_put_u32(nlh, NFTA_TPROXY_FAMILY, htonl(tproxy->family)); + + if (e->flags & (1 << NFTNL_EXPR_TPROXY_REG_ADDR)) + mnl_attr_put_u32(nlh, NFTA_TPROXY_REG_ADDR, + htonl(tproxy->sreg_addr)); + + if (e->flags & (1 << NFTNL_EXPR_TPROXY_REG_PORT)) + mnl_attr_put_u32(nlh, NFTA_TPROXY_REG_PORT, + htonl(tproxy->sreg_port)); +} + +static int +nftnl_expr_tproxy_snprintf_default(char *buf, size_t size, + const struct nftnl_expr *e) +{ + struct nftnl_expr_tproxy *tproxy = nftnl_expr_data(e); + int remain = size, offset = 0, ret = 0; + + if (tproxy->family != NFTA_TPROXY_UNSPEC) { + ret = snprintf(buf + offset, remain, "%s ", + nftnl_family2str(tproxy->family)); + SNPRINTF_BUFFER_SIZE(ret, remain, offset); + } + + if (e->flags & (1 << NFTNL_EXPR_TPROXY_REG_ADDR)) { + ret = snprintf(buf + offset, remain, + "addr reg %u ", tproxy->sreg_addr); + SNPRINTF_BUFFER_SIZE(ret, remain, offset); + } + + if (e->flags & (1 << NFTNL_EXPR_TPROXY_REG_PORT)) { + ret = snprintf(buf + offset, remain, + "port reg %u ", tproxy->sreg_port); + SNPRINTF_BUFFER_SIZE(ret, remain, offset); + } + + return offset; +} + +static int +nftnl_expr_tproxy_snprintf(char *buf, size_t size, uint32_t type, + uint32_t flags, const struct nftnl_expr *e) +{ + switch (type) { + case NFTNL_OUTPUT_DEFAULT: + return nftnl_expr_tproxy_snprintf_default(buf, size, e); + default: + break; + } + return -1; +} + +static bool nftnl_expr_tproxy_cmp(const struct nftnl_expr *e1, + const struct nftnl_expr *e2) +{ + struct nftnl_expr_tproxy *n1 = nftnl_expr_data(e1); + struct nftnl_expr_tproxy *n2 = nftnl_expr_data(e2); + bool eq = true; + + if (e1->flags & (1 << NFTNL_EXPR_TPROXY_REG_ADDR)) + eq &= (n1->sreg_addr == n2->sreg_addr); + if (e1->flags & (1 << NFTNL_EXPR_TPROXY_REG_PORT)) + eq &= (n1->sreg_port == n2->sreg_port); + if (e1->flags & (1 << NFTNL_EXPR_TPROXY_FAMILY)) + eq &= (n1->family == n2->family); + + return eq; +} + +struct expr_ops expr_ops_tproxy = { + .name = "tproxy", + .alloc_len = sizeof(struct nftnl_expr_tproxy), + .max_attr = NFTA_TPROXY_MAX, + .cmp = nftnl_expr_tproxy_cmp, + .set = nftnl_expr_tproxy_set, + .get = nftnl_expr_tproxy_get, + .parse = nftnl_expr_tproxy_parse, + .build = nftnl_expr_tproxy_build, + .snprintf = nftnl_expr_tproxy_snprintf, +}; diff --git a/src/expr_ops.c b/src/expr_ops.c index cbb2a1b..72a4679 100644 --- a/src/expr_ops.c +++ b/src/expr_ops.c @@ -22,6 +22,7 @@ extern struct expr_ops expr_ops_match; extern struct expr_ops expr_ops_meta; extern struct expr_ops expr_ops_ng; extern struct expr_ops expr_ops_nat; +extern struct expr_ops expr_ops_tproxy; extern struct expr_ops expr_ops_objref; extern struct expr_ops expr_ops_payload; extern struct expr_ops expr_ops_range; @@ -60,6 +61,7 @@ static struct expr_ops *expr_ops[] = { &expr_ops_meta, &expr_ops_ng, &expr_ops_nat, + &expr_ops_tproxy, &expr_ops_notrack, &expr_ops_payload, &expr_ops_range, -- cgit v1.2.3