netfilter: add SYNPROXY core/target
Add a SYNPROXY for netfilter. The code is split into two parts, the synproxy core with common functions and an address family specific target. The SYNPROXY receives the connection request from the client, responds with a SYN/ACK containing a SYN cookie and announcing a zero window and checks whether the final ACK from the client contains a valid cookie. It then establishes a connection to the original destination and, if successful, sends a window update to the client with the window size announced by the server. Support for timestamps, SACK, window scaling and MSS options can be statically configured as target parameters if the features of the server are known. If timestamps are used, the timestamp value sent back to the client in the SYN/ACK will be different from the real timestamp of the server. In order to now break PAWS, the timestamps are translated in the direction server->client. Signed-off-by: Patrick McHardy <kaber@trash.net> Tested-by: Martin Topholm <mph@one.com> Signed-off-by: Jesper Dangaard Brouer <brouer@redhat.com> Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
This commit is contained in:
Patrick McHardy
Pablo Neira Ayuso
parent
0198230b77
commit
48b1de4c11
|
|
@ -9,8 +9,8 @@ enum nf_ct_ext_id {
|
|||
NF_CT_EXT_HELPER,
|
||||
#if defined(CONFIG_NF_NAT) || defined(CONFIG_NF_NAT_MODULE)
|
||||
NF_CT_EXT_NAT,
|
||||
NF_CT_EXT_SEQADJ,
|
||||
#endif
|
||||
NF_CT_EXT_SEQADJ,
|
||||
NF_CT_EXT_ACCT,
|
||||
#ifdef CONFIG_NF_CONNTRACK_EVENTS
|
||||
NF_CT_EXT_ECACHE,
|
||||
|
|
@ -26,6 +26,9 @@ enum nf_ct_ext_id {
|
|||
#endif
|
||||
#ifdef CONFIG_NF_CONNTRACK_LABELS
|
||||
NF_CT_EXT_LABELS,
|
||||
#endif
|
||||
#if IS_ENABLED(CONFIG_NETFILTER_SYNPROXY)
|
||||
NF_CT_EXT_SYNPROXY,
|
||||
#endif
|
||||
NF_CT_EXT_NUM,
|
||||
};
|
||||
|
|
@ -39,6 +42,7 @@ enum nf_ct_ext_id {
|
|||
#define NF_CT_EXT_TSTAMP_TYPE struct nf_conn_tstamp
|
||||
#define NF_CT_EXT_TIMEOUT_TYPE struct nf_conn_timeout
|
||||
#define NF_CT_EXT_LABELS_TYPE struct nf_conn_labels
|
||||
#define NF_CT_EXT_SYNPROXY_TYPE struct nf_conn_synproxy
|
||||
|
||||
/* Extensions: optional stuff which isn't permanently in struct. */
|
||||
struct nf_ct_ext {
|
||||
|
|
|
|||
|
|
@ -30,6 +30,8 @@ static inline struct nf_conn_seqadj *nfct_seqadj_ext_add(struct nf_conn *ct)
|
|||
return nf_ct_ext_add(ct, NF_CT_EXT_SEQADJ, GFP_ATOMIC);
|
||||
}
|
||||
|
||||
extern int nf_ct_seqadj_init(struct nf_conn *ct, enum ip_conntrack_info ctinfo,
|
||||
s32 off);
|
||||
extern int nf_ct_seqadj_set(struct nf_conn *ct, enum ip_conntrack_info ctinfo,
|
||||
__be32 seq, s32 off);
|
||||
extern void nf_ct_tcp_seqadj_set(struct sk_buff *skb,
|
||||
|
|
|
|||
|
|
@ -0,0 +1,77 @@
|
|||
#ifndef _NF_CONNTRACK_SYNPROXY_H
|
||||
#define _NF_CONNTRACK_SYNPROXY_H
|
||||
|
||||
#include <net/netns/generic.h>
|
||||
|
||||
struct nf_conn_synproxy {
|
||||
u32 isn;
|
||||
u32 its;
|
||||
u32 tsoff;
|
||||
};
|
||||
|
||||
static inline struct nf_conn_synproxy *nfct_synproxy(const struct nf_conn *ct)
|
||||
{
|
||||
#if IS_ENABLED(CONFIG_NETFILTER_SYNPROXY)
|
||||
return nf_ct_ext_find(ct, NF_CT_EXT_SYNPROXY);
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline struct nf_conn_synproxy *nfct_synproxy_ext_add(struct nf_conn *ct)
|
||||
{
|
||||
#if IS_ENABLED(CONFIG_NETFILTER_SYNPROXY)
|
||||
return nf_ct_ext_add(ct, NF_CT_EXT_SYNPROXY, GFP_ATOMIC);
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
struct synproxy_stats {
|
||||
unsigned int syn_received;
|
||||
unsigned int cookie_invalid;
|
||||
unsigned int cookie_valid;
|
||||
unsigned int cookie_retrans;
|
||||
unsigned int conn_reopened;
|
||||
};
|
||||
|
||||
struct synproxy_net {
|
||||
struct nf_conn *tmpl;
|
||||
struct synproxy_stats __percpu *stats;
|
||||
};
|
||||
|
||||
extern int synproxy_net_id;
|
||||
static inline struct synproxy_net *synproxy_pernet(struct net *net)
|
||||
{
|
||||
return net_generic(net, synproxy_net_id);
|
||||
}
|
||||
|
||||
struct synproxy_options {
|
||||
u8 options;
|
||||
u8 wscale;
|
||||
u16 mss;
|
||||
u32 tsval;
|
||||
u32 tsecr;
|
||||
};
|
||||
|
||||
struct tcphdr;
|
||||
struct xt_synproxy_info;
|
||||
extern void synproxy_parse_options(const struct sk_buff *skb, unsigned int doff,
|
||||
const struct tcphdr *th,
|
||||
struct synproxy_options *opts);
|
||||
extern unsigned int synproxy_options_size(const struct synproxy_options *opts);
|
||||
extern void synproxy_build_options(struct tcphdr *th,
|
||||
const struct synproxy_options *opts);
|
||||
|
||||
extern void synproxy_init_timestamp_cookie(const struct xt_synproxy_info *info,
|
||||
struct synproxy_options *opts);
|
||||
extern void synproxy_check_timestamp_cookie(struct synproxy_options *opts);
|
||||
|
||||
extern unsigned int synproxy_tstamp_adjust(struct sk_buff *skb,
|
||||
unsigned int protoff,
|
||||
struct tcphdr *th,
|
||||
struct nf_conn *ct,
|
||||
enum ip_conntrack_info ctinfo,
|
||||
const struct nf_conn_synproxy *synproxy);
|
||||
|
||||
#endif /* _NF_CONNTRACK_SYNPROXY_H */
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
#ifndef _XT_SYNPROXY_H
|
||||
#define _XT_SYNPROXY_H
|
||||
|
||||
#define XT_SYNPROXY_OPT_MSS 0x01
|
||||
#define XT_SYNPROXY_OPT_WSCALE 0x02
|
||||
#define XT_SYNPROXY_OPT_SACK_PERM 0x04
|
||||
#define XT_SYNPROXY_OPT_TIMESTAMP 0x08
|
||||
#define XT_SYNPROXY_OPT_ECN 0x10
|
||||
|
||||
struct xt_synproxy_info {
|
||||
__u8 options;
|
||||
__u8 wscale;
|
||||
__u16 mss;
|
||||
};
|
||||
|
||||
#endif /* _XT_SYNPROXY_H */
|
||||
|
|
@ -110,6 +110,19 @@ config IP_NF_TARGET_REJECT
|
|||
|
||||
To compile it as a module, choose M here. If unsure, say N.
|
||||
|
||||
config IP_NF_TARGET_SYNPROXY
|
||||
tristate "SYNPROXY target support"
|
||||
depends on NF_CONNTRACK && NETFILTER_ADVANCED
|
||||
select NETFILTER_SYNPROXY
|
||||
select SYN_COOKIES
|
||||
help
|
||||
The SYNPROXY target allows you to intercept TCP connections and
|
||||
establish them using syncookies before they are passed on to the
|
||||
server. This allows to avoid conntrack and server resource usage
|
||||
during SYN-flood attacks.
|
||||
|
||||
To compile it as a module, choose M here. If unsure, say N.
|
||||
|
||||
config IP_NF_TARGET_ULOG
|
||||
tristate "ULOG target support (obsolete)"
|
||||
default m if NETFILTER_ADVANCED=n
|
||||
|
|
|
|||
|
|
@ -46,6 +46,7 @@ obj-$(CONFIG_IP_NF_TARGET_CLUSTERIP) += ipt_CLUSTERIP.o
|
|||
obj-$(CONFIG_IP_NF_TARGET_ECN) += ipt_ECN.o
|
||||
obj-$(CONFIG_IP_NF_TARGET_MASQUERADE) += ipt_MASQUERADE.o
|
||||
obj-$(CONFIG_IP_NF_TARGET_REJECT) += ipt_REJECT.o
|
||||
obj-$(CONFIG_IP_NF_TARGET_SYNPROXY) += ipt_SYNPROXY.o
|
||||
obj-$(CONFIG_IP_NF_TARGET_ULOG) += ipt_ULOG.o
|
||||
|
||||
# generic ARP tables
|
||||
|
|
|
|||
|
|
@ -0,0 +1,472 @@
|
|||
/*
|
||||
* Copyright (c) 2013 Patrick McHardy <kaber@trash.net>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/skbuff.h>
|
||||
#include <net/tcp.h>
|
||||
|
||||
#include <linux/netfilter_ipv4/ip_tables.h>
|
||||
#include <linux/netfilter/x_tables.h>
|
||||
#include <linux/netfilter/xt_SYNPROXY.h>
|
||||
#include <net/netfilter/nf_conntrack.h>
|
||||
#include <net/netfilter/nf_conntrack_seqadj.h>
|
||||
#include <net/netfilter/nf_conntrack_synproxy.h>
|
||||
|
||||
static struct iphdr *
|
||||
synproxy_build_ip(struct sk_buff *skb, u32 saddr, u32 daddr)
|
||||
{
|
||||
struct iphdr *iph;
|
||||
|
||||
skb_reset_network_header(skb);
|
||||
iph = (struct iphdr *)skb_put(skb, sizeof(*iph));
|
||||
iph->version = 4;
|
||||
iph->ihl = sizeof(*iph) / 4;
|
||||
iph->tos = 0;
|
||||
iph->id = 0;
|
||||
iph->frag_off = htons(IP_DF);
|
||||
iph->ttl = sysctl_ip_default_ttl;
|
||||
iph->protocol = IPPROTO_TCP;
|
||||
iph->check = 0;
|
||||
iph->saddr = saddr;
|
||||
iph->daddr = daddr;
|
||||
|
||||
return iph;
|
||||
}
|
||||
|
||||
static void
|
||||
synproxy_send_tcp(const struct sk_buff *skb, struct sk_buff *nskb,
|
||||
struct nf_conntrack *nfct, enum ip_conntrack_info ctinfo,
|
||||
struct iphdr *niph, struct tcphdr *nth,
|
||||
unsigned int tcp_hdr_size)
|
||||
{
|
||||
nth->check = ~tcp_v4_check(tcp_hdr_size, niph->saddr, niph->daddr, 0);
|
||||
nskb->ip_summed = CHECKSUM_PARTIAL;
|
||||
nskb->csum_start = (unsigned char *)nth - nskb->head;
|
||||
nskb->csum_offset = offsetof(struct tcphdr, check);
|
||||
|
||||
skb_dst_set_noref(nskb, skb_dst(skb));
|
||||
nskb->protocol = htons(ETH_P_IP);
|
||||
if (ip_route_me_harder(nskb, RTN_UNSPEC))
|
||||
goto free_nskb;
|
||||
|
||||
if (nfct) {
|
||||
nskb->nfct = nfct;
|
||||
nskb->nfctinfo = ctinfo;
|
||||
nf_conntrack_get(nfct);
|
||||
}
|
||||
|
||||
ip_local_out(nskb);
|
||||
return;
|
||||
|
||||
free_nskb:
|
||||
kfree_skb(nskb);
|
||||
}
|
||||
|
||||
static void
|
||||
synproxy_send_client_synack(const struct sk_buff *skb, const struct tcphdr *th,
|
||||
const struct synproxy_options *opts)
|
||||
{
|
||||
struct sk_buff *nskb;
|
||||
struct iphdr *iph, *niph;
|
||||
struct tcphdr *nth;
|
||||
unsigned int tcp_hdr_size;
|
||||
u16 mss = opts->mss;
|
||||
|
||||
iph = ip_hdr(skb);
|
||||
|
||||
tcp_hdr_size = sizeof(*nth) + synproxy_options_size(opts);
|
||||
nskb = alloc_skb(sizeof(*niph) + tcp_hdr_size + MAX_TCP_HEADER,
|
||||
GFP_ATOMIC);
|
||||
if (nskb == NULL)
|
||||
return;
|
||||
skb_reserve(nskb, MAX_TCP_HEADER);
|
||||
|
||||
niph = synproxy_build_ip(nskb, iph->daddr, iph->saddr);
|
||||
|
||||
skb_reset_transport_header(nskb);
|
||||
nth = (struct tcphdr *)skb_put(nskb, tcp_hdr_size);
|
||||
nth->source = th->dest;
|
||||
nth->dest = th->source;
|
||||
nth->seq = htonl(__cookie_v4_init_sequence(iph, th, &mss));
|
||||
nth->ack_seq = htonl(ntohl(th->seq) + 1);
|
||||
tcp_flag_word(nth) = TCP_FLAG_SYN | TCP_FLAG_ACK;
|
||||
if (opts->options & XT_SYNPROXY_OPT_ECN)
|
||||
tcp_flag_word(nth) |= TCP_FLAG_ECE;
|
||||
nth->doff = tcp_hdr_size / 4;
|
||||
nth->window = 0;
|
||||
nth->check = 0;
|
||||
nth->urg_ptr = 0;
|
||||
|
||||
synproxy_build_options(nth, opts);
|
||||
|
||||
synproxy_send_tcp(skb, nskb, skb->nfct, IP_CT_ESTABLISHED_REPLY,
|
||||
niph, nth, tcp_hdr_size);
|
||||
}
|
||||
|
||||
static void
|
||||
synproxy_send_server_syn(const struct synproxy_net *snet,
|
||||
const struct sk_buff *skb, const struct tcphdr *th,
|
||||
const struct synproxy_options *opts, u32 recv_seq)
|
||||
{
|
||||
struct sk_buff *nskb;
|
||||
struct iphdr *iph, *niph;
|
||||
struct tcphdr *nth;
|
||||
unsigned int tcp_hdr_size;
|
||||
|
||||
iph = ip_hdr(skb);
|
||||
|
||||
tcp_hdr_size = sizeof(*nth) + synproxy_options_size(opts);
|
||||
nskb = alloc_skb(sizeof(*niph) + tcp_hdr_size + MAX_TCP_HEADER,
|
||||
GFP_ATOMIC);
|
||||
if (nskb == NULL)
|
||||
return;
|
||||
skb_reserve(nskb, MAX_TCP_HEADER);
|
||||
|
||||
niph = synproxy_build_ip(nskb, iph->saddr, iph->daddr);
|
||||
|
||||
skb_reset_transport_header(nskb);
|
||||
nth = (struct tcphdr *)skb_put(nskb, tcp_hdr_size);
|
||||
nth->source = th->source;
|
||||
nth->dest = th->dest;
|
||||
nth->seq = htonl(recv_seq - 1);
|
||||
/* ack_seq is used to relay our ISN to the synproxy hook to initialize
|
||||
* sequence number translation once a connection tracking entry exists.
|
||||
*/
|
||||
nth->ack_seq = htonl(ntohl(th->ack_seq) - 1);
|
||||
tcp_flag_word(nth) = TCP_FLAG_SYN;
|
||||
if (opts->options & XT_SYNPROXY_OPT_ECN)
|
||||
tcp_flag_word(nth) |= TCP_FLAG_ECE | TCP_FLAG_CWR;
|
||||
nth->doff = tcp_hdr_size / 4;
|
||||
nth->window = th->window;
|
||||
nth->check = 0;
|
||||
nth->urg_ptr = 0;
|
||||
|
||||
synproxy_build_options(nth, opts);
|
||||
|
||||
synproxy_send_tcp(skb, nskb, &snet->tmpl->ct_general, IP_CT_NEW,
|
||||
niph, nth, tcp_hdr_size);
|
||||
}
|
||||
|
||||
static void
|
||||
synproxy_send_server_ack(const struct synproxy_net *snet,
|
||||
const struct ip_ct_tcp *state,
|
||||
const struct sk_buff *skb, const struct tcphdr *th,
|
||||
const struct synproxy_options *opts)
|
||||
{
|
||||
struct sk_buff *nskb;
|
||||
struct iphdr *iph, *niph;
|
||||
struct tcphdr *nth;
|
||||
unsigned int tcp_hdr_size;
|
||||
|
||||
iph = ip_hdr(skb);
|
||||
|
||||
tcp_hdr_size = sizeof(*nth) + synproxy_options_size(opts);
|
||||
nskb = alloc_skb(sizeof(*niph) + tcp_hdr_size + MAX_TCP_HEADER,
|
||||
GFP_ATOMIC);
|
||||
if (nskb == NULL)
|
||||
return;
|
||||
skb_reserve(nskb, MAX_TCP_HEADER);
|
||||
|
||||
niph = synproxy_build_ip(nskb, iph->daddr, iph->saddr);
|
||||
|
||||
skb_reset_transport_header(nskb);
|
||||
nth = (struct tcphdr *)skb_put(nskb, tcp_hdr_size);
|
||||
nth->source = th->dest;
|
||||
nth->dest = th->source;
|
||||
nth->seq = htonl(ntohl(th->ack_seq));
|
||||
nth->ack_seq = htonl(ntohl(th->seq) + 1);
|
||||
tcp_flag_word(nth) = TCP_FLAG_ACK;
|
||||
nth->doff = tcp_hdr_size / 4;
|
||||
nth->window = htons(state->seen[IP_CT_DIR_ORIGINAL].td_maxwin);
|
||||
nth->check = 0;
|
||||
nth->urg_ptr = 0;
|
||||
|
||||
synproxy_build_options(nth, opts);
|
||||
|
||||
synproxy_send_tcp(skb, nskb, NULL, 0, niph, nth, tcp_hdr_size);
|
||||
}
|
||||
|
||||
static void
|
||||
synproxy_send_client_ack(const struct synproxy_net *snet,
|
||||
const struct sk_buff *skb, const struct tcphdr *th,
|
||||
const struct synproxy_options *opts)
|
||||
{
|
||||
struct sk_buff *nskb;
|
||||
struct iphdr *iph, *niph;
|
||||
struct tcphdr *nth;
|
||||
unsigned int tcp_hdr_size;
|
||||
|
||||
iph = ip_hdr(skb);
|
||||
|
||||
tcp_hdr_size = sizeof(*nth) + synproxy_options_size(opts);
|
||||
nskb = alloc_skb(sizeof(*niph) + tcp_hdr_size + MAX_TCP_HEADER,
|
||||
GFP_ATOMIC);
|
||||
if (nskb == NULL)
|
||||
return;
|
||||
skb_reserve(nskb, MAX_TCP_HEADER);
|
||||
|
||||
niph = synproxy_build_ip(nskb, iph->saddr, iph->daddr);
|
||||
|
||||
skb_reset_transport_header(nskb);
|
||||
nth = (struct tcphdr *)skb_put(nskb, tcp_hdr_size);
|
||||
nth->source = th->source;
|
||||
nth->dest = th->dest;
|
||||
nth->seq = htonl(ntohl(th->seq) + 1);
|
||||
nth->ack_seq = th->ack_seq;
|
||||
tcp_flag_word(nth) = TCP_FLAG_ACK;
|
||||
nth->doff = tcp_hdr_size / 4;
|
||||
nth->window = ntohs(htons(th->window) >> opts->wscale);
|
||||
nth->check = 0;
|
||||
nth->urg_ptr = 0;
|
||||
|
||||
synproxy_build_options(nth, opts);
|
||||
|
||||
synproxy_send_tcp(skb, nskb, NULL, 0, niph, nth, tcp_hdr_size);
|
||||
}
|
||||
|
||||
static bool
|
||||
synproxy_recv_client_ack(const struct synproxy_net *snet,
|
||||
const struct sk_buff *skb, const struct tcphdr *th,
|
||||
struct synproxy_options *opts, u32 recv_seq)
|
||||
{
|
||||
int mss;
|
||||
|
||||
mss = __cookie_v4_check(ip_hdr(skb), th, ntohl(th->ack_seq) - 1);
|
||||
if (mss == 0) {
|
||||
this_cpu_inc(snet->stats->cookie_invalid);
|
||||
return false;
|
||||
}
|
||||
|
||||
this_cpu_inc(snet->stats->cookie_valid);
|
||||
opts->mss = mss;
|
||||
|
||||
if (opts->options & XT_SYNPROXY_OPT_TIMESTAMP)
|
||||
synproxy_check_timestamp_cookie(opts);
|
||||
|
||||
synproxy_send_server_syn(snet, skb, th, opts, recv_seq);
|
||||
return true;
|
||||
}
|
||||
|
||||
static unsigned int
|
||||
synproxy_tg4(struct sk_buff *skb, const struct xt_action_param *par)
|
||||
{
|
||||
const struct xt_synproxy_info *info = par->targinfo;
|
||||
struct synproxy_net *snet = synproxy_pernet(dev_net(par->in));
|
||||
struct synproxy_options opts = {};
|
||||
struct tcphdr *th, _th;
|
||||
|
||||
if (nf_ip_checksum(skb, par->hooknum, par->thoff, IPPROTO_TCP))
|
||||
return NF_DROP;
|
||||
|
||||
th = skb_header_pointer(skb, par->thoff, sizeof(_th), &_th);
|
||||
if (th == NULL)
|
||||
return NF_DROP;
|
||||
|
||||
synproxy_parse_options(skb, par->thoff, th, &opts);
|
||||
|
||||
if (th->syn && !th->ack) {
|
||||
/* Initial SYN from client */
|
||||
this_cpu_inc(snet->stats->syn_received);
|
||||
|
||||
if (th->ece && th->cwr)
|
||||
opts.options |= XT_SYNPROXY_OPT_ECN;
|
||||
|
||||
opts.options &= info->options;
|
||||
if (opts.options & XT_SYNPROXY_OPT_TIMESTAMP)
|
||||
synproxy_init_timestamp_cookie(info, &opts);
|
||||
else
|
||||
opts.options &= ~(XT_SYNPROXY_OPT_WSCALE |
|
||||
XT_SYNPROXY_OPT_SACK_PERM |
|
||||
XT_SYNPROXY_OPT_ECN);
|
||||
|
||||
synproxy_send_client_synack(skb, th, &opts);
|
||||
} else if (th->ack && !(th->fin || th->rst))
|
||||
/* ACK from client */
|
||||
synproxy_recv_client_ack(snet, skb, th, &opts, ntohl(th->seq));
|
||||
|
||||
return NF_DROP;
|
||||
}
|
||||
|
||||
static unsigned int ipv4_synproxy_hook(unsigned int hooknum,
|
||||
struct sk_buff *skb,
|
||||
const struct net_device *in,
|
||||
const struct net_device *out,
|
||||
int (*okfn)(struct sk_buff *))
|
||||
{
|
||||
struct synproxy_net *snet = synproxy_pernet(dev_net(in ? : out));
|
||||
enum ip_conntrack_info ctinfo;
|
||||
struct nf_conn *ct;
|
||||
struct nf_conn_synproxy *synproxy;
|
||||
struct synproxy_options opts = {};
|
||||
const struct ip_ct_tcp *state;
|
||||
struct tcphdr *th, _th;
|
||||
unsigned int thoff;
|
||||
|
||||
ct = nf_ct_get(skb, &ctinfo);
|
||||
if (ct == NULL)
|
||||
return NF_ACCEPT;
|
||||
|
||||
synproxy = nfct_synproxy(ct);
|
||||
if (synproxy == NULL)
|
||||
return NF_ACCEPT;
|
||||
|
||||
if (nf_is_loopback_packet(skb))
|
||||
return NF_ACCEPT;
|
||||
|
||||
thoff = ip_hdrlen(skb);
|
||||
th = skb_header_pointer(skb, thoff, sizeof(_th), &_th);
|
||||
if (th == NULL)
|
||||
return NF_DROP;
|
||||
|
||||
state = &ct->proto.tcp;
|
||||
switch (state->state) {
|
||||
case TCP_CONNTRACK_CLOSE:
|
||||
if (th->rst && !test_bit(IPS_SEEN_REPLY_BIT, &ct->status)) {
|
||||
nf_ct_seqadj_init(ct, ctinfo, synproxy->isn -
|
||||
ntohl(th->seq) + 1);
|
||||
break;
|
||||
}
|
||||
|
||||
if (!th->syn || th->ack ||
|
||||
CTINFO2DIR(ctinfo) != IP_CT_DIR_ORIGINAL)
|
||||
break;
|
||||
|
||||
/* Reopened connection - reset the sequence number and timestamp
|
||||
* adjustments, they will get initialized once the connection is
|
||||
* reestablished.
|
||||
*/
|
||||
nf_ct_seqadj_init(ct, ctinfo, 0);
|
||||
synproxy->tsoff = 0;
|
||||
this_cpu_inc(snet->stats->conn_reopened);
|
||||
|
||||
/* fall through */
|
||||
case TCP_CONNTRACK_SYN_SENT:
|
||||
synproxy_parse_options(skb, thoff, th, &opts);
|
||||
|
||||
if (!th->syn && th->ack &&
|
||||
CTINFO2DIR(ctinfo) == IP_CT_DIR_ORIGINAL) {
|
||||
/* Keep-Alives are sent with SEG.SEQ = SND.NXT-1,
|
||||
* therefore we need to add 1 to make the SYN sequence
|
||||
* number match the one of first SYN.
|
||||
*/
|
||||
if (synproxy_recv_client_ack(snet, skb, th, &opts,
|
||||
ntohl(th->seq) + 1))
|
||||
this_cpu_inc(snet->stats->cookie_retrans);
|
||||
|
||||
return NF_DROP;
|
||||
}
|
||||
|
||||
synproxy->isn = ntohl(th->ack_seq);
|
||||
if (opts.options & XT_SYNPROXY_OPT_TIMESTAMP)
|
||||
synproxy->its = opts.tsecr;
|
||||
break;
|
||||
case TCP_CONNTRACK_SYN_RECV:
|
||||
if (!th->syn || !th->ack)
|
||||
break;
|
||||
|
||||
synproxy_parse_options(skb, thoff, th, &opts);
|
||||
if (opts.options & XT_SYNPROXY_OPT_TIMESTAMP)
|
||||
synproxy->tsoff = opts.tsval - synproxy->its;
|
||||
|
||||
opts.options &= ~(XT_SYNPROXY_OPT_MSS |
|
||||
XT_SYNPROXY_OPT_WSCALE |
|
||||
XT_SYNPROXY_OPT_SACK_PERM);
|
||||
|
||||
swap(opts.tsval, opts.tsecr);
|
||||
synproxy_send_server_ack(snet, state, skb, th, &opts);
|
||||
|
||||
nf_ct_seqadj_init(ct, ctinfo, synproxy->isn - ntohl(th->seq));
|
||||
|
||||
swap(opts.tsval, opts.tsecr);
|
||||
synproxy_send_client_ack(snet, skb, th, &opts);
|
||||
|
||||
consume_skb(skb);
|
||||
return NF_STOLEN;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
synproxy_tstamp_adjust(skb, thoff, th, ct, ctinfo, synproxy);
|
||||
return NF_ACCEPT;
|
||||
}
|
||||
|
||||
static int synproxy_tg4_check(const struct xt_tgchk_param *par)
|
||||
{
|
||||
const struct ipt_entry *e = par->entryinfo;
|
||||
|
||||
if (e->ip.proto != IPPROTO_TCP ||
|
||||
e->ip.invflags & XT_INV_PROTO)
|
||||
return -EINVAL;
|
||||
|
||||
return nf_ct_l3proto_try_module_get(par->family);
|
||||
}
|
||||
|
||||
static void synproxy_tg4_destroy(const struct xt_tgdtor_param *par)
|
||||
{
|
||||
nf_ct_l3proto_module_put(par->family);
|
||||
}
|
||||
|
||||
static struct xt_target synproxy_tg4_reg __read_mostly = {
|
||||
.name = "SYNPROXY",
|
||||
.family = NFPROTO_IPV4,
|
||||
.target = synproxy_tg4,
|
||||
.targetsize = sizeof(struct xt_synproxy_info),
|
||||
.checkentry = synproxy_tg4_check,
|
||||
.destroy = synproxy_tg4_destroy,
|
||||
.me = THIS_MODULE,
|
||||
};
|
||||
|
||||
static struct nf_hook_ops ipv4_synproxy_ops[] __read_mostly = {
|
||||
{
|
||||
.hook = ipv4_synproxy_hook,
|
||||
.owner = THIS_MODULE,
|
||||
.pf = NFPROTO_IPV4,
|
||||
.hooknum = NF_INET_LOCAL_IN,
|
||||
.priority = NF_IP_PRI_CONNTRACK_CONFIRM - 1,
|
||||
},
|
||||
{
|
||||
.hook = ipv4_synproxy_hook,
|
||||
.owner = THIS_MODULE,
|
||||
.pf = NFPROTO_IPV4,
|
||||
.hooknum = NF_INET_POST_ROUTING,
|
||||
.priority = NF_IP_PRI_CONNTRACK_CONFIRM - 1,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init synproxy_tg4_init(void)
|
||||
{
|
||||
int err;
|
||||
|
||||
err = nf_register_hooks(ipv4_synproxy_ops,
|
||||
ARRAY_SIZE(ipv4_synproxy_ops));
|
||||
if (err < 0)
|
||||
goto err1;
|
||||
|
||||
err = xt_register_target(&synproxy_tg4_reg);
|
||||
if (err < 0)
|
||||
goto err2;
|
||||
|
||||
return 0;
|
||||
|
||||
err2:
|
||||
nf_unregister_hooks(ipv4_synproxy_ops, ARRAY_SIZE(ipv4_synproxy_ops));
|
||||
err1:
|
||||
return err;
|
||||
}
|
||||
|
||||
static void __exit synproxy_tg4_exit(void)
|
||||
{
|
||||
xt_unregister_target(&synproxy_tg4_reg);
|
||||
nf_unregister_hooks(ipv4_synproxy_ops, ARRAY_SIZE(ipv4_synproxy_ops));
|
||||
}
|
||||
|
||||
module_init(synproxy_tg4_init);
|
||||
module_exit(synproxy_tg4_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
|
||||
|
|
@ -408,6 +408,9 @@ config NF_NAT_TFTP
|
|||
depends on NF_CONNTRACK && NF_NAT
|
||||
default NF_NAT && NF_CONNTRACK_TFTP
|
||||
|
||||
config NETFILTER_SYNPROXY
|
||||
tristate
|
||||
|
||||
endif # NF_CONNTRACK
|
||||
|
||||
config NETFILTER_XTABLES
|
||||
|
|
|
|||
|
|
@ -61,6 +61,9 @@ obj-$(CONFIG_NF_NAT_IRC) += nf_nat_irc.o
|
|||
obj-$(CONFIG_NF_NAT_SIP) += nf_nat_sip.o
|
||||
obj-$(CONFIG_NF_NAT_TFTP) += nf_nat_tftp.o
|
||||
|
||||
# SYNPROXY
|
||||
obj-$(CONFIG_NETFILTER_SYNPROXY) += nf_synproxy_core.o
|
||||
|
||||
# generic X tables
|
||||
obj-$(CONFIG_NETFILTER_XTABLES) += x_tables.o xt_tcpudp.o
|
||||
|
||||
|
|
|
|||
|
|
@ -48,6 +48,7 @@
|
|||
#include <net/netfilter/nf_conntrack_timestamp.h>
|
||||
#include <net/netfilter/nf_conntrack_timeout.h>
|
||||
#include <net/netfilter/nf_conntrack_labels.h>
|
||||
#include <net/netfilter/nf_conntrack_synproxy.h>
|
||||
#include <net/netfilter/nf_nat.h>
|
||||
#include <net/netfilter/nf_nat_core.h>
|
||||
#include <net/netfilter/nf_nat_helper.h>
|
||||
|
|
@ -799,6 +800,11 @@ init_conntrack(struct net *net, struct nf_conn *tmpl,
|
|||
if (IS_ERR(ct))
|
||||
return (struct nf_conntrack_tuple_hash *)ct;
|
||||
|
||||
if (tmpl && nfct_synproxy(tmpl)) {
|
||||
nfct_seqadj_ext_add(ct);
|
||||
nfct_synproxy_ext_add(ct);
|
||||
}
|
||||
|
||||
timeout_ext = tmpl ? nf_ct_timeout_find(tmpl) : NULL;
|
||||
if (timeout_ext)
|
||||
timeouts = NF_CT_TIMEOUT_EXT_DATA(timeout_ext);
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
#include <net/netfilter/nf_conntrack_l4proto.h>
|
||||
#include <net/netfilter/nf_conntrack_ecache.h>
|
||||
#include <net/netfilter/nf_conntrack_seqadj.h>
|
||||
#include <net/netfilter/nf_conntrack_synproxy.h>
|
||||
#include <net/netfilter/nf_log.h>
|
||||
#include <net/netfilter/ipv4/nf_conntrack_ipv4.h>
|
||||
#include <net/netfilter/ipv6/nf_conntrack_ipv6.h>
|
||||
|
|
@ -946,6 +947,21 @@ static int tcp_packet(struct nf_conn *ct,
|
|||
"state %s ", tcp_conntrack_names[old_state]);
|
||||
return NF_ACCEPT;
|
||||
case TCP_CONNTRACK_MAX:
|
||||
/* Special case for SYN proxy: when the SYN to the server or
|
||||
* the SYN/ACK from the server is lost, the client may transmit
|
||||
* a keep-alive packet while in SYN_SENT state. This needs to
|
||||
* be associated with the original conntrack entry in order to
|
||||
* generate a new SYN with the correct sequence number.
|
||||
*/
|
||||
if (nfct_synproxy(ct) && old_state == TCP_CONNTRACK_SYN_SENT &&
|
||||
index == TCP_ACK_SET && dir == IP_CT_DIR_ORIGINAL &&
|
||||
ct->proto.tcp.last_dir == IP_CT_DIR_ORIGINAL &&
|
||||
ct->proto.tcp.seen[dir].td_end - 1 == ntohl(th->seq)) {
|
||||
pr_debug("nf_ct_tcp: SYN proxy client keep alive\n");
|
||||
spin_unlock_bh(&ct->lock);
|
||||
return NF_ACCEPT;
|
||||
}
|
||||
|
||||
/* Invalid packet */
|
||||
pr_debug("nf_ct_tcp: Invalid dir=%i index=%u ostate=%u\n",
|
||||
dir, get_conntrack_index(th), old_state);
|
||||
|
|
|
|||
|
|
@ -6,6 +6,26 @@
|
|||
#include <net/netfilter/nf_conntrack_extend.h>
|
||||
#include <net/netfilter/nf_conntrack_seqadj.h>
|
||||
|
||||
int nf_ct_seqadj_init(struct nf_conn *ct, enum ip_conntrack_info ctinfo,
|
||||
s32 off)
|
||||
{
|
||||
enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
|
||||
struct nf_conn_seqadj *seqadj;
|
||||
struct nf_ct_seqadj *this_way;
|
||||
|
||||
if (off == 0)
|
||||
return 0;
|
||||
|
||||
set_bit(IPS_SEQ_ADJUST_BIT, &ct->status);
|
||||
|
||||
seqadj = nfct_seqadj(ct);
|
||||
this_way = &seqadj->seq[dir];
|
||||
this_way->offset_before = off;
|
||||
this_way->offset_after = off;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(nf_ct_seqadj_init);
|
||||
|
||||
int nf_ct_seqadj_set(struct nf_conn *ct, enum ip_conntrack_info ctinfo,
|
||||
__be32 seq, s32 off)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -0,0 +1,432 @@
|
|||
/*
|
||||
* Copyright (c) 2013 Patrick McHardy <kaber@trash.net>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/skbuff.h>
|
||||
#include <asm/unaligned.h>
|
||||
#include <net/tcp.h>
|
||||
#include <net/netns/generic.h>
|
||||
|
||||
#include <linux/netfilter_ipv4/ip_tables.h>
|
||||
#include <linux/netfilter/x_tables.h>
|
||||
#include <linux/netfilter/xt_tcpudp.h>
|
||||
#include <linux/netfilter/xt_SYNPROXY.h>
|
||||
#include <net/netfilter/nf_conntrack.h>
|
||||
#include <net/netfilter/nf_conntrack_extend.h>
|
||||
#include <net/netfilter/nf_conntrack_seqadj.h>
|
||||
#include <net/netfilter/nf_conntrack_synproxy.h>
|
||||
|
||||
int synproxy_net_id;
|
||||
EXPORT_SYMBOL_GPL(synproxy_net_id);
|
||||
|
||||
void
|
||||
synproxy_parse_options(const struct sk_buff *skb, unsigned int doff,
|
||||
const struct tcphdr *th, struct synproxy_options *opts)
|
||||
{
|
||||
int length = (th->doff * 4) - sizeof(*th);
|
||||
u8 buf[40], *ptr;
|
||||
|
||||
ptr = skb_header_pointer(skb, doff + sizeof(*th), length, buf);
|
||||
BUG_ON(ptr == NULL);
|
||||
|
||||
opts->options = 0;
|
||||
while (length > 0) {
|
||||
int opcode = *ptr++;
|
||||
int opsize;
|
||||
|
||||
switch (opcode) {
|
||||
case TCPOPT_EOL:
|
||||
return;
|
||||
case TCPOPT_NOP:
|
||||
length--;
|
||||
continue;
|
||||
default:
|
||||
opsize = *ptr++;
|
||||
if (opsize < 2)
|
||||
return;
|
||||
if (opsize > length)
|
||||
return;
|
||||
|
||||
switch (opcode) {
|
||||
case TCPOPT_MSS:
|
||||
if (opsize == TCPOLEN_MSS) {
|
||||
opts->mss = get_unaligned_be16(ptr);
|
||||
opts->options |= XT_SYNPROXY_OPT_MSS;
|
||||
}
|
||||
break;
|
||||
case TCPOPT_WINDOW:
|
||||
if (opsize == TCPOLEN_WINDOW) {
|
||||
opts->wscale = *ptr;
|
||||
if (opts->wscale > 14)
|
||||
opts->wscale = 14;
|
||||
opts->options |= XT_SYNPROXY_OPT_WSCALE;
|
||||
}
|
||||
break;
|
||||
case TCPOPT_TIMESTAMP:
|
||||
if (opsize == TCPOLEN_TIMESTAMP) {
|
||||
opts->tsval = get_unaligned_be32(ptr);
|
||||
opts->tsecr = get_unaligned_be32(ptr + 4);
|
||||
opts->options |= XT_SYNPROXY_OPT_TIMESTAMP;
|
||||
}
|
||||
break;
|
||||
case TCPOPT_SACK_PERM:
|
||||
if (opsize == TCPOLEN_SACK_PERM)
|
||||
opts->options |= XT_SYNPROXY_OPT_SACK_PERM;
|
||||
break;
|
||||
}
|
||||
|
||||
ptr += opsize - 2;
|
||||
length -= opsize;
|
||||
}
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(synproxy_parse_options);
|
||||
|
||||
unsigned int synproxy_options_size(const struct synproxy_options *opts)
|
||||
{
|
||||
unsigned int size = 0;
|
||||
|
||||
if (opts->options & XT_SYNPROXY_OPT_MSS)
|
||||
size += TCPOLEN_MSS_ALIGNED;
|
||||
if (opts->options & XT_SYNPROXY_OPT_TIMESTAMP)
|
||||
size += TCPOLEN_TSTAMP_ALIGNED;
|
||||
else if (opts->options & XT_SYNPROXY_OPT_SACK_PERM)
|
||||
size += TCPOLEN_SACKPERM_ALIGNED;
|
||||
if (opts->options & XT_SYNPROXY_OPT_WSCALE)
|
||||
size += TCPOLEN_WSCALE_ALIGNED;
|
||||
|
||||
return size;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(synproxy_options_size);
|
||||
|
||||
void
|
||||
synproxy_build_options(struct tcphdr *th, const struct synproxy_options *opts)
|
||||
{
|
||||
__be32 *ptr = (__be32 *)(th + 1);
|
||||
u8 options = opts->options;
|
||||
|
||||
if (options & XT_SYNPROXY_OPT_MSS)
|
||||
*ptr++ = htonl((TCPOPT_MSS << 24) |
|
||||
(TCPOLEN_MSS << 16) |
|
||||
opts->mss);
|
||||
|
||||
if (options & XT_SYNPROXY_OPT_TIMESTAMP) {
|
||||
if (options & XT_SYNPROXY_OPT_SACK_PERM)
|
||||
*ptr++ = htonl((TCPOPT_SACK_PERM << 24) |
|
||||
(TCPOLEN_SACK_PERM << 16) |
|
||||
(TCPOPT_TIMESTAMP << 8) |
|
||||
TCPOLEN_TIMESTAMP);
|
||||
else
|
||||
*ptr++ = htonl((TCPOPT_NOP << 24) |
|
||||
(TCPOPT_NOP << 16) |
|
||||
(TCPOPT_TIMESTAMP << 8) |
|
||||
TCPOLEN_TIMESTAMP);
|
||||
|
||||
*ptr++ = htonl(opts->tsval);
|
||||
*ptr++ = htonl(opts->tsecr);
|
||||
} else if (options & XT_SYNPROXY_OPT_SACK_PERM)
|
||||
*ptr++ = htonl((TCPOPT_NOP << 24) |
|
||||
(TCPOPT_NOP << 16) |
|
||||
(TCPOPT_SACK_PERM << 8) |
|
||||
TCPOLEN_SACK_PERM);
|
||||
|
||||
if (options & XT_SYNPROXY_OPT_WSCALE)
|
||||
*ptr++ = htonl((TCPOPT_NOP << 24) |
|
||||
(TCPOPT_WINDOW << 16) |
|
||||
(TCPOLEN_WINDOW << 8) |
|
||||
opts->wscale);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(synproxy_build_options);
|
||||
|
||||
void synproxy_init_timestamp_cookie(const struct xt_synproxy_info *info,
|
||||
struct synproxy_options *opts)
|
||||
{
|
||||
opts->tsecr = opts->tsval;
|
||||
opts->tsval = tcp_time_stamp & ~0x3f;
|
||||
|
||||
if (opts->options & XT_SYNPROXY_OPT_WSCALE)
|
||||
opts->tsval |= info->wscale;
|
||||
else
|
||||
opts->tsval |= 0xf;
|
||||
|
||||
if (opts->options & XT_SYNPROXY_OPT_SACK_PERM)
|
||||
opts->tsval |= 1 << 4;
|
||||
|
||||
if (opts->options & XT_SYNPROXY_OPT_ECN)
|
||||
opts->tsval |= 1 << 5;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(synproxy_init_timestamp_cookie);
|
||||
|
||||
void synproxy_check_timestamp_cookie(struct synproxy_options *opts)
|
||||
{
|
||||
opts->wscale = opts->tsecr & 0xf;
|
||||
if (opts->wscale != 0xf)
|
||||
opts->options |= XT_SYNPROXY_OPT_WSCALE;
|
||||
|
||||
opts->options |= opts->tsecr & (1 << 4) ? XT_SYNPROXY_OPT_SACK_PERM : 0;
|
||||
|
||||
opts->options |= opts->tsecr & (1 << 5) ? XT_SYNPROXY_OPT_ECN : 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(synproxy_check_timestamp_cookie);
|
||||
|
||||
unsigned int synproxy_tstamp_adjust(struct sk_buff *skb,
|
||||
unsigned int protoff,
|
||||
struct tcphdr *th,
|
||||
struct nf_conn *ct,
|
||||
enum ip_conntrack_info ctinfo,
|
||||
const struct nf_conn_synproxy *synproxy)
|
||||
{
|
||||
unsigned int optoff, optend;
|
||||
u32 *ptr, old;
|
||||
|
||||
if (synproxy->tsoff == 0)
|
||||
return 1;
|
||||
|
||||
optoff = protoff + sizeof(struct tcphdr);
|
||||
optend = protoff + th->doff * 4;
|
||||
|
||||
if (!skb_make_writable(skb, optend))
|
||||
return 0;
|
||||
|
||||
while (optoff < optend) {
|
||||
unsigned char *op = skb->data + optoff;
|
||||
|
||||
switch (op[0]) {
|
||||
case TCPOPT_EOL:
|
||||
return 1;
|
||||
case TCPOPT_NOP:
|
||||
optoff++;
|
||||
continue;
|
||||
default:
|
||||
if (optoff + 1 == optend ||
|
||||
optoff + op[1] > optend ||
|
||||
op[1] < 2)
|
||||
return 0;
|
||||
if (op[0] == TCPOPT_TIMESTAMP &&
|
||||
op[1] == TCPOLEN_TIMESTAMP) {
|
||||
if (CTINFO2DIR(ctinfo) == IP_CT_DIR_REPLY) {
|
||||
ptr = (u32 *)&op[2];
|
||||
old = *ptr;
|
||||
*ptr = htonl(ntohl(*ptr) -
|
||||
synproxy->tsoff);
|
||||
} else {
|
||||
ptr = (u32 *)&op[6];
|
||||
old = *ptr;
|
||||
*ptr = htonl(ntohl(*ptr) +
|
||||
synproxy->tsoff);
|
||||
}
|
||||
inet_proto_csum_replace4(&th->check, skb,
|
||||
old, *ptr, 0);
|
||||
return 1;
|
||||
}
|
||||
optoff += op[1];
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(synproxy_tstamp_adjust);
|
||||
|
||||
static struct nf_ct_ext_type nf_ct_synproxy_extend __read_mostly = {
|
||||
.len = sizeof(struct nf_conn_synproxy),
|
||||
.align = __alignof__(struct nf_conn_synproxy),
|
||||
.id = NF_CT_EXT_SYNPROXY,
|
||||
};
|
||||
|
||||
#ifdef CONFIG_PROC_FS
|
||||
static void *synproxy_cpu_seq_start(struct seq_file *seq, loff_t *pos)
|
||||
{
|
||||
struct synproxy_net *snet = synproxy_pernet(seq_file_net(seq));
|
||||
int cpu;
|
||||
|
||||
if (*pos == 0)
|
||||
return SEQ_START_TOKEN;
|
||||
|
||||
for (cpu = *pos - 1; cpu < nr_cpu_ids; cpu++) {
|
||||
if (!cpu_possible(cpu))
|
||||
continue;
|
||||
*pos = cpu + 1;
|
||||
return per_cpu_ptr(snet->stats, cpu);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void *synproxy_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
||||
{
|
||||
struct synproxy_net *snet = synproxy_pernet(seq_file_net(seq));
|
||||
int cpu;
|
||||
|
||||
for (cpu = *pos; cpu < nr_cpu_ids; cpu++) {
|
||||
if (!cpu_possible(cpu))
|
||||
continue;
|
||||
*pos = cpu + 1;
|
||||
return per_cpu_ptr(snet->stats, cpu);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void synproxy_cpu_seq_stop(struct seq_file *seq, void *v)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
static int synproxy_cpu_seq_show(struct seq_file *seq, void *v)
|
||||
{
|
||||
struct synproxy_stats *stats = v;
|
||||
|
||||
if (v == SEQ_START_TOKEN) {
|
||||
seq_printf(seq, "entries\t\tsyn_received\t"
|
||||
"cookie_invalid\tcookie_valid\t"
|
||||
"cookie_retrans\tconn_reopened\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
seq_printf(seq, "%08x\t%08x\t%08x\t%08x\t%08x\t%08x\n", 0,
|
||||
stats->syn_received,
|
||||
stats->cookie_invalid,
|
||||
stats->cookie_valid,
|
||||
stats->cookie_retrans,
|
||||
stats->conn_reopened);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct seq_operations synproxy_cpu_seq_ops = {
|
||||
.start = synproxy_cpu_seq_start,
|
||||
.next = synproxy_cpu_seq_next,
|
||||
.stop = synproxy_cpu_seq_stop,
|
||||
.show = synproxy_cpu_seq_show,
|
||||
};
|
||||
|
||||
static int synproxy_cpu_seq_open(struct inode *inode, struct file *file)
|
||||
{
|
||||
return seq_open_net(inode, file, &synproxy_cpu_seq_ops,
|
||||
sizeof(struct seq_net_private));
|
||||
}
|
||||
|
||||
static const struct file_operations synproxy_cpu_seq_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = synproxy_cpu_seq_open,
|
||||
.read = seq_read,
|
||||
.llseek = seq_lseek,
|
||||
.release = seq_release_net,
|
||||
};
|
||||
|
||||
static int __net_init synproxy_proc_init(struct net *net)
|
||||
{
|
||||
if (!proc_create("synproxy", S_IRUGO, net->proc_net_stat,
|
||||
&synproxy_cpu_seq_fops))
|
||||
return -ENOMEM;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __net_exit synproxy_proc_exit(struct net *net)
|
||||
{
|
||||
remove_proc_entry("synproxy", net->proc_net_stat);
|
||||
}
|
||||
#else
|
||||
static int __net_init synproxy_proc_init(struct net *net)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __net_exit synproxy_proc_exit(struct net *net)
|
||||
{
|
||||
return;
|
||||
}
|
||||
#endif /* CONFIG_PROC_FS */
|
||||
|
||||
static int __net_init synproxy_net_init(struct net *net)
|
||||
{
|
||||
struct synproxy_net *snet = synproxy_pernet(net);
|
||||
struct nf_conntrack_tuple t;
|
||||
struct nf_conn *ct;
|
||||
int err = -ENOMEM;
|
||||
|
||||
memset(&t, 0, sizeof(t));
|
||||
ct = nf_conntrack_alloc(net, 0, &t, &t, GFP_KERNEL);
|
||||
if (IS_ERR(ct)) {
|
||||
err = PTR_ERR(ct);
|
||||
goto err1;
|
||||
}
|
||||
|
||||
__set_bit(IPS_TEMPLATE_BIT, &ct->status);
|
||||
__set_bit(IPS_CONFIRMED_BIT, &ct->status);
|
||||
if (!nfct_seqadj_ext_add(ct))
|
||||
goto err2;
|
||||
if (!nfct_synproxy_ext_add(ct))
|
||||
goto err2;
|
||||
|
||||
snet->tmpl = ct;
|
||||
|
||||
snet->stats = alloc_percpu(struct synproxy_stats);
|
||||
if (snet->stats == NULL)
|
||||
goto err2;
|
||||
|
||||
err = synproxy_proc_init(net);
|
||||
if (err < 0)
|
||||
goto err3;
|
||||
|
||||
return 0;
|
||||
|
||||
err3:
|
||||
free_percpu(snet->stats);
|
||||
err2:
|
||||
nf_conntrack_free(ct);
|
||||
err1:
|
||||
return err;
|
||||
}
|
||||
|
||||
static void __net_exit synproxy_net_exit(struct net *net)
|
||||
{
|
||||
struct synproxy_net *snet = synproxy_pernet(net);
|
||||
|
||||
nf_conntrack_free(snet->tmpl);
|
||||
synproxy_proc_exit(net);
|
||||
free_percpu(snet->stats);
|
||||
}
|
||||
|
||||
static struct pernet_operations synproxy_net_ops = {
|
||||
.init = synproxy_net_init,
|
||||
.exit = synproxy_net_exit,
|
||||
.id = &synproxy_net_id,
|
||||
.size = sizeof(struct synproxy_net),
|
||||
};
|
||||
|
||||
static int __init synproxy_core_init(void)
|
||||
{
|
||||
int err;
|
||||
|
||||
err = nf_ct_extend_register(&nf_ct_synproxy_extend);
|
||||
if (err < 0)
|
||||
goto err1;
|
||||
|
||||
err = register_pernet_subsys(&synproxy_net_ops);
|
||||
if (err < 0)
|
||||
goto err2;
|
||||
|
||||
return 0;
|
||||
|
||||
err2:
|
||||
nf_ct_extend_unregister(&nf_ct_synproxy_extend);
|
||||
err1:
|
||||
return err;
|
||||
}
|
||||
|
||||
static void __exit synproxy_core_exit(void)
|
||||
{
|
||||
unregister_pernet_subsys(&synproxy_net_ops);
|
||||
nf_ct_extend_unregister(&nf_ct_synproxy_extend);
|
||||
}
|
||||
|
||||
module_init(synproxy_core_init);
|
||||
module_exit(synproxy_core_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
|
||||
Loading…
Reference in New Issue