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>

6 files changed, 480 insertions, 0 deletions

diff --git a/net/netfilter/Kconfig b/net/netfilter/Kconfig
index c45fc1a60e0d..62a171ab204f 100644
--- a/net/netfilter/Kconfig
+++ b/net/netfilter/Kconfig
@@ -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
diff --git a/net/netfilter/Makefile b/net/netfilter/Makefile
index 89a9c1658f5e..c3a0a12907f6 100644
--- a/net/netfilter/Makefile
+++ b/net/netfilter/Makefile
@@ -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
 
diff --git a/net/netfilter/nf_conntrack_core.c b/net/netfilter/nf_conntrack_core.c
index 00a7a94d4132..5d892febd64c 100644
--- a/net/netfilter/nf_conntrack_core.c
+++ b/net/netfilter/nf_conntrack_core.c
@@ -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);
diff --git a/net/netfilter/nf_conntrack_proto_tcp.c b/net/netfilter/nf_conntrack_proto_tcp.c
index 984a8d1a3359..44d1ea32570a 100644
--- a/net/netfilter/nf_conntrack_proto_tcp.c
+++ b/net/netfilter/nf_conntrack_proto_tcp.c
@@ -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);
diff --git a/net/netfilter/nf_conntrack_seqadj.c b/net/netfilter/nf_conntrack_seqadj.c
index 483eb9ce3216..5f9bfd060dea 100644
--- a/net/netfilter/nf_conntrack_seqadj.c
+++ b/net/netfilter/nf_conntrack_seqadj.c
@@ -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)
 {
diff --git a/net/netfilter/nf_synproxy_core.c b/net/netfilter/nf_synproxy_core.c
new file mode 100644
index 000000000000..d23dc791aca7
--- /dev/null
+++ b/net/netfilter/nf_synproxy_core.c
@@ -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>");