Skip to contentSkip to conversation

bpf: tcp: Support arbitrary SYN Cookie at TC.

PATCH Superseded Kuniyuki Iwashima 4 participants 15 messages Dec 21, 2023 – Jan 15, 2024

Subsystems (8)

v7 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#0 lore raw

v7 cover bpf: tcp: Support arbitrary SYN Cookie at TC.

Under SYN Flood, the TCP stack generates SYN Cookie to remain stateless for the connection request until a valid ACK is responded to the SYN+ACK.

The cookie contains two kinds of host-specific bits, a timestamp and secrets, so only can it be validated by the generator. It means SYN Cookie consumes network resources between the client and the server; intermediate nodes must remember which nodes to route ACK for the cookie.

SYN Proxy reduces such unwanted resource allocation by handling 3WHS at the edge network. After SYN Proxy completes 3WHS, it forwards SYN to the backend server and completes another 3WHS. However, since the server's ISN differs from the cookie, the proxy must manage the ISN mappings and fix up SEQ/ACK numbers in every packet for each connection. If a proxy node goes down, all the connections through it are terminated. Keeping a state at proxy is painful from that perspective.

At AWS, we use a dirty hack to build truly stateless SYN Proxy at scale. Our SYN Proxy consists of the front proxy layer and the backend kernel module. (See slides of LPC2023 [0], p37 - p48)

The cookie that SYN Proxy generates differs from the kernel's cookie in that it contains a secret (called rolling salt) (i) shared by all the proxy nodes so that any node can validate ACK and (ii) updated periodically so that old cookies cannot be validated and we need not encode a timestamp for the cookie. Also, ISN contains WScale, SACK, and ECN, not in TS val. This is not to sacrifice any connection quality, where some customers turn off TCP timestamps option due to retro CVE.

After 3WHS, the proxy restores SYN, encapsulates ACK into SYN, and forward the TCP-in-TCP packet to the backend server. Our kernel module works at Netfilter input/output hooks and first feeds SYN to the TCP stack to initiate 3WHS. When the module is triggered for SYN+ACK, it looks up the corresponding request socket and overwrites tcp_rsk(req)->snt_isn with the proxy's cookie. Then, the module can complete 3WHS with the original ACK as is.

This way, our SYN Proxy does not manage the ISN mappings nor wait for SYN+ACK from the backend thus can remain stateless. It's working very well for high-bandwidth services like multiple Tbps, but we are looking for a way to drop the dirty hack and further optimise the sequences.

If we could validate an arbitrary SYN Cookie on the backend server with BPF, the proxy would need not restore SYN nor pass it. After validating ACK, the proxy node just needs to forward it, and then the server can do the lightweight validation (e.g. check if ACK came from proxy nodes, etc) and create a connection from the ACK.

This series allows us to create a full sk from an arbitrary SYN Cookie, which is done in 3 steps.

1) At tc, BPF prog calls a new kfunc to create a reqsk and configure

     it based on the argument populated from SYN Cookie.  The reqsk has
     its listener as req->rsk_listener and is passed to the TCP stack as
     skb->sk.

2) During TCP socket lookup for the skb, skb_steal_sock() returns a

     listener in the reuseport group that inet_reqsk(skb->sk)->rsk_listener
     belongs to.

3) In cookie_v[46]_check(), the reqsk (skb->sk) is fully initialised and a full sk is created.

The kfunc usage is as follows:

    struct bpf_tcp_req_attrs attrs = {
        .mss = mss,
        .wscale_ok = wscale_ok,
        .rcv_wscale = rcv_wscale, /* Server's WScale < 15 */
        .snd_wscale = snd_wscale, /* Client's WScale < 15 */
        .tstamp_ok = tstamp_ok,
        .rcv_tsval = tsval,
        .rcv_tsecr = tsecr, /* Server's Initial TSval */
        .usec_ts_ok = usec_ts_ok,
        .sack_ok = sack_ok,
        .ecn_ok = ecn_ok,
    }

    skc = bpf_skc_lookup_tcp(...);
    sk = (struct sock *)bpf_skc_to_tcp_sock(skc);
    bpf_sk_assign_tcp_reqsk(skb, sk, attrs, sizeof(attrs));
    bpf_sk_release(skc);

[0]: https://lpc.events/event/17/contributions/1645/attachments/1350/2701/SYN_Proxy_at_Scale_with_BPF.pdf

Changes:
v7:
* Patch 5 & 6
* Drop MPTCP support

v6: https://lore.kernel.org/bpf/[email protected]/
* Patch 5 & 6
* /struct /s/tcp_cookie_attributes/bpf_tcp_req_attrs/
* Don't reuse struct tcp_options_received and use u8 for each attrs
* Patch 6
* Check retval of test__start_subtest()

v5: https://lore.kernel.org/netdev/[email protected]/
* Split patch 1-3
* Patch 3
* Clear req->rsk_listener in skb_steal_sock()
* Patch 4 & 5
* Move sysctl validation and tsoff init from cookie_bpf_check() to kfunc
* Patch 5
* Do not increment LINUX_MIB_SYNCOOKIES(RECV|FAILED)
* Patch 6
* Remove __always_inline
* Test if tcp_handle_{syn,ack}() is executed
* Move some definition to bpf_tracing_net.h
* s/BPF_F_CURRENT_NETNS/-1/

v4: https://lore.kernel.org/bpf/[email protected]/
* Patch 1 & 2
* s/CONFIG_SYN_COOKIE/CONFIG_SYN_COOKIES/
* Patch 1
* Don't set rcv_wscale for BPF SYN Cookie case.
* Patch 2
* Add test for tcp_opt.{unused,rcv_wscale} in kfunc
* Modify skb_steal_sock() to avoid resetting skb-sk
* Support SO_REUSEPORT lookup
* Patch 3
* Add CONFIG_SYN_COOKIES to Kconfig for CI
* Define BPF_F_CURRENT_NETNS

v3: https://lore.kernel.org/netdev/[email protected]/
* Guard kfunc and req->syncookie part in inet6?_steal_sock() with CONFIG_SYN_COOKIE

v2: https://lore.kernel.org/netdev/[email protected]/
* Drop SOCK_OPS and move SYN Cookie validation logic to TC with kfunc.
* Add cleanup patches to reduce discrepancy between cookie_v[46]_check()

v1: https://lore.kernel.org/bpf/[email protected]/

Kuniyuki Iwashima (6):
tcp: Move tcp_ns_to_ts() to tcp.h
tcp: Move skb_steal_sock() to request_sock.h
bpf: tcp: Handle BPF SYN Cookie in skb_steal_sock().
bpf: tcp: Handle BPF SYN Cookie in cookie_v[46]_check().
bpf: tcp: Support arbitrary SYN Cookie.
selftest: bpf: Test bpf_sk_assign_tcp_reqsk().

 include/net/request_sock.h                    |  39 ++
 include/net/sock.h                            |  25 -
 include/net/tcp.h                             |  42 ++
 net/core/filter.c                             | 113 +++-
 net/core/sock.c                               |  14 +-
 net/ipv4/syncookies.c                         |  40 +-
 net/ipv6/syncookies.c                         |  13 +-
 tools/testing/selftests/bpf/bpf_kfuncs.h      |  10 +
 tools/testing/selftests/bpf/config            |   1 +
 .../bpf/prog_tests/tcp_custom_syncookie.c     | 154 +++++
 .../selftests/bpf/progs/bpf_tracing_net.h     |  16 +
 .../selftests/bpf/progs/test_siphash.h        |  64 ++
 .../bpf/progs/test_tcp_custom_syncookie.c     | 572 ++++++++++++++++++
 .../bpf/progs/test_tcp_custom_syncookie.h     | 140 +++++
 14 files changed, 1197 insertions(+), 46 deletions(-)
 create mode 100644 tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c
 create mode 100644 tools/testing/selftests/bpf/progs/test_siphash.h
 create mode 100644 tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c
 create mode 100644 tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.h
Signature · 1 line
2.30.2
#1 lore raw

PATCH v7 1/6 tcp: Move tcp_ns_to_ts() to tcp.h

We will support arbitrary SYN Cookie with BPF.

When BPF prog validates ACK and kfunc allocates a reqsk, we need to call tcp_ns_to_ts() to calculate an offset of TSval for later use:

time
t0 : Send SYN+ACK

       -> tsval = Initial TSval (Random Number)

t1 : Recv ACK of 3WHS
-> tsoff = TSecr - tcp_ns_to_ts(usec_ts_ok, tcp_clock_ns())
= Initial TSval - t1

t2 : Send ACK

       -> tsval = t2 + tsoff
                = Initial TSval + (t2 - t1)
                = Initial TSval + Time Delta (x)

(x) Note that the time delta does not include the initial RTT from t0 to t1.

Let's move tcp_ns_to_ts() to tcp.h.

---
 include/net/tcp.h     | 9 +++++++++
 net/ipv4/syncookies.c | 9 ---------
 2 files changed, 9 insertions(+), 9 deletions(-)
include/net/tcp.h +9 -0
index f5ca4abaee8b..07dd18e2f3af 100644
@@ -577,6 +577,15 @@ static inline u32 tcp_cookie_time(void)
 	return val;
 }
 
+/* Convert one nsec 64bit timestamp to ts (ms or usec resolution) */
+static inline u64 tcp_ns_to_ts(bool usec_ts, u64 val)
+{
+	if (usec_ts)
+		return div_u64(val, NSEC_PER_USEC);
+
+	return div_u64(val, NSEC_PER_MSEC);
+}
+
 u32 __cookie_v4_init_sequence(const struct iphdr *iph, const struct tcphdr *th,
 			      u16 *mssp);
 __u32 cookie_v4_init_sequence(const struct sk_buff *skb, __u16 *mss);
net/ipv4/syncookies.c +0 -9
index 61f1c96cfe63..981944c22820 100644
@@ -51,15 +51,6 @@ static u32 cookie_hash(__be32 saddr, __be32 daddr, __be16 sport, __be16 dport,
 			    count, &syncookie_secret[c]);
 }
 
-/* Convert one nsec 64bit timestamp to ts (ms or usec resolution) */
-static u64 tcp_ns_to_ts(bool usec_ts, u64 val)
-{
-	if (usec_ts)
-		return div_u64(val, NSEC_PER_USEC);
-
-	return div_u64(val, NSEC_PER_MSEC);
-}
-
 /*
  * when syncookies are in effect and tcp timestamps are enabled we encode
  * tcp options in the lower bits of the timestamp value that will be
Signature · 1 line
2.30.2
#2 lore raw

PATCH v7 2/6 tcp: Move skb_steal_sock() to request_sock.h

In reply to Kuniyuki Iwashima

We will support arbitrary SYN Cookie with BPF.

If BPF prog validates ACK and kfunc allocates a reqsk, it will be carried to TCP stack as skb->sk with req->syncookie 1.

In skb_steal_sock(), we need to check inet_reqsk(sk)->syncookie to see if the reqsk is created by kfunc. However, inet_reqsk() is not available in sock.h.

Let's move skb_steal_sock() to request_sock.h.

While at it, we refactor skb_steal_sock() so it returns early if skb->sk is NULL to minimise the following patch.

---
 include/net/request_sock.h | 28 ++++++++++++++++++++++++++++
 include/net/sock.h         | 25 -------------------------
 2 files changed, 28 insertions(+), 25 deletions(-)
include/net/request_sock.h +28 -0
index 144c39db9898..26c630c40abb 100644
@@ -83,6 +83,34 @@ static inline struct sock *req_to_sk(struct request_sock *req)
 	return (struct sock *)req;
 }
 
+/**
+ * skb_steal_sock - steal a socket from an sk_buff
+ * @skb: sk_buff to steal the socket from
+ * @refcounted: is set to true if the socket is reference-counted
+ * @prefetched: is set to true if the socket was assigned from bpf
+ */
+static inline struct sock *skb_steal_sock(struct sk_buff *skb,
+					  bool *refcounted, bool *prefetched)
+{
+	struct sock *sk = skb->sk;
+
+	if (!sk) {
+		*prefetched = false;
+		*refcounted = false;
+		return NULL;
+	}
+
+	*prefetched = skb_sk_is_prefetched(skb);
+	if (*prefetched)
+		*refcounted = sk_is_refcounted(sk);
+	else
+		*refcounted = true;
+
+	skb->destructor = NULL;
+	skb->sk = NULL;
+	return sk;
+}
+
 static inline struct request_sock *
 reqsk_alloc(const struct request_sock_ops *ops, struct sock *sk_listener,
 	    bool attach_listener)
include/net/sock.h +0 -25
index 8b6fe164b218..1aa19c8510cc 100644
@@ -2838,31 +2838,6 @@ sk_is_refcounted(struct sock *sk)
 	return !sk_fullsock(sk) || !sock_flag(sk, SOCK_RCU_FREE);
 }
 
-/**
- * skb_steal_sock - steal a socket from an sk_buff
- * @skb: sk_buff to steal the socket from
- * @refcounted: is set to true if the socket is reference-counted
- * @prefetched: is set to true if the socket was assigned from bpf
- */
-static inline struct sock *
-skb_steal_sock(struct sk_buff *skb, bool *refcounted, bool *prefetched)
-{
-	if (skb->sk) {
-		struct sock *sk = skb->sk;
-
-		*refcounted = true;
-		*prefetched = skb_sk_is_prefetched(skb);
-		if (*prefetched)
-			*refcounted = sk_is_refcounted(sk);
-		skb->destructor = NULL;
-		skb->sk = NULL;
-		return sk;
-	}
-	*prefetched = false;
-	*refcounted = false;
-	return NULL;
-}
-
 /* Checks if this SKB belongs to an HW offloaded socket
  * and whether any SW fallbacks are required based on dev.
  * Check decrypted mark in case skb_orphan() cleared socket.
Signature · 1 line
2.30.2
#3 lore raw

PATCH v7 3/6 bpf: tcp: Handle BPF SYN Cookie in skb_steal_sock().

In reply to Kuniyuki Iwashima

We will support arbitrary SYN Cookie with BPF.

If BPF prog validates ACK and kfunc allocates a reqsk, it will be carried to TCP stack as skb->sk with req->syncookie 1. Also, the reqsk has its listener as req->rsk_listener with no refcnt taken.

When the TCP stack looks up a socket from the skb, we steal inet_reqsk(skb->sk)->rsk_listener in skb_steal_sock() so that the skb will be processed in cookie_v[46]_check() with the listener.

Note that we do not clear skb->sk and skb->destructor so that we can carry the reqsk to cookie_v[46]_check().

---
 include/net/request_sock.h | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)
include/net/request_sock.h +13 -2
index 26c630c40abb..8839133d6f6b 100644
@@ -101,10 +101,21 @@ static inline struct sock *skb_steal_sock(struct sk_buff *skb,
 	}
 
 	*prefetched = skb_sk_is_prefetched(skb);
-	if (*prefetched)
+	if (*prefetched) {
+#if IS_ENABLED(CONFIG_SYN_COOKIES)
+		if (sk->sk_state == TCP_NEW_SYN_RECV && inet_reqsk(sk)->syncookie) {
+			struct request_sock *req = inet_reqsk(sk);
+
+			*refcounted = false;
+			sk = req->rsk_listener;
+			req->rsk_listener = NULL;
+			return sk;
+		}
+#endif
 		*refcounted = sk_is_refcounted(sk);
-	else
+	} else {
 		*refcounted = true;
+	}
 
 	skb->destructor = NULL;
 	skb->sk = NULL;
Signature · 1 line
2.30.2
#4 lore raw

PATCH v7 4/6 bpf: tcp: Handle BPF SYN Cookie in cookie_v[46]_check().

In reply to Kuniyuki Iwashima

We will support arbitrary SYN Cookie with BPF in the following patch.

If BPF prog validates ACK and kfunc allocates a reqsk, it will be carried to cookie_[46]_check() as skb->sk. If skb->sk is not NULL, we call cookie_bpf_check().

Then, we clear skb->sk and skb->destructor, which are needed not to hold refcnt for reqsk and the listener. See the following patch for details.

After that, we finish initialisation for the remaining fields with cookie_tcp_reqsk_init().

Note that the server side WScale is set only for non-BPF SYN Cookie.

---
 include/net/tcp.h     | 20 ++++++++++++++++++++
 net/ipv4/syncookies.c | 31 +++++++++++++++++++++++++++----
 net/ipv6/syncookies.c | 13 +++++++++----
 3 files changed, 56 insertions(+), 8 deletions(-)
include/net/tcp.h +20 -0
index 07dd18e2f3af..a63916f41f77 100644
@@ -599,6 +599,26 @@ static inline bool cookie_ecn_ok(const struct net *net, const struct dst_entry *
 		dst_feature(dst, RTAX_FEATURE_ECN);
 }
 
+#if IS_ENABLED(CONFIG_BPF)
+static inline bool cookie_bpf_ok(struct sk_buff *skb)
+{
+	return skb->sk;
+}
+
+struct request_sock *cookie_bpf_check(struct sock *sk, struct sk_buff *skb);
+#else
+static inline bool cookie_bpf_ok(struct sk_buff *skb)
+{
+	return false;
+}
+
+static inline struct request_sock *cookie_bpf_check(struct net *net, struct sock *sk,
+						    struct sk_buff *skb)
+{
+	return NULL;
+}
+#endif
+
 /* From net/ipv6/syncookies.c */
 int __cookie_v6_check(const struct ipv6hdr *iph, const struct tcphdr *th);
 struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb);
net/ipv4/syncookies.c +27 -4
index 981944c22820..be88bf586ff9 100644
@@ -295,6 +295,24 @@ static int cookie_tcp_reqsk_init(struct sock *sk, struct sk_buff *skb,
 	return 0;
 }
 
+#if IS_ENABLED(CONFIG_BPF)
+struct request_sock *cookie_bpf_check(struct sock *sk, struct sk_buff *skb)
+{
+	struct request_sock *req = inet_reqsk(skb->sk);
+
+	skb->sk = NULL;
+	skb->destructor = NULL;
+
+	if (cookie_tcp_reqsk_init(sk, skb, req)) {
+		reqsk_free(req);
+		req = NULL;
+	}
+
+	return req;
+}
+EXPORT_SYMBOL_GPL(cookie_bpf_check);
+#endif
+
 struct request_sock *cookie_tcp_reqsk_alloc(const struct request_sock_ops *ops,
 					    struct sock *sk, struct sk_buff *skb,
 					    struct tcp_options_received *tcp_opt,
@@ -395,9 +413,13 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb)
 	    !th->ack || th->rst)
 		goto out;
 
-	req = cookie_tcp_check(net, sk, skb);
-	if (IS_ERR(req))
-		goto out;
+	if (cookie_bpf_ok(skb)) {
+		req = cookie_bpf_check(sk, skb);
+	} else {
+		req = cookie_tcp_check(net, sk, skb);
+		if (IS_ERR(req))
+			goto out;
+	}
 	if (!req)
 		goto out_drop;
 
@@ -445,7 +467,8 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb)
 				  ireq->wscale_ok, &rcv_wscale,
 				  dst_metric(&rt->dst, RTAX_INITRWND));
 
-	ireq->rcv_wscale  = rcv_wscale;
+	if (!req->syncookie)
+		ireq->rcv_wscale = rcv_wscale;
 	ireq->ecn_ok &= cookie_ecn_ok(net, &rt->dst);
 
 	ret = tcp_get_cookie_sock(sk, skb, req, &rt->dst);
net/ipv6/syncookies.c +9 -4
index c8d2ca27220c..6b9c69278819 100644
@@ -182,9 +182,13 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb)
 	    !th->ack || th->rst)
 		goto out;
 
-	req = cookie_tcp_check(net, sk, skb);
-	if (IS_ERR(req))
-		goto out;
+	if (cookie_bpf_ok(skb)) {
+		req = cookie_bpf_check(sk, skb);
+	} else {
+		req = cookie_tcp_check(net, sk, skb);
+		if (IS_ERR(req))
+			goto out;
+	}
 	if (!req)
 		goto out_drop;
 
@@ -247,7 +251,8 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb)
 				  ireq->wscale_ok, &rcv_wscale,
 				  dst_metric(dst, RTAX_INITRWND));
 
-	ireq->rcv_wscale = rcv_wscale;
+	if (!req->syncookie)
+		ireq->rcv_wscale = rcv_wscale;
 	ireq->ecn_ok &= cookie_ecn_ok(net, dst);
 
 	ret = tcp_get_cookie_sock(sk, skb, req, dst);
Signature · 1 line
2.30.2
#5 lore raw

PATCH v7 5/6 bpf: tcp: Support arbitrary SYN Cookie.

In reply to Kuniyuki Iwashima

This patch adds a new kfunc available at TC hook to support arbitrary SYN Cookie.

The basic usage is as follows:

    struct bpf_tcp_req_attrs attrs = {
        .mss = mss,
        .wscale_ok = wscale_ok,
        .rcv_wscale = rcv_wscale, /* Server's WScale < 15 */
        .snd_wscale = snd_wscale, /* Client's WScale < 15 */
        .tstamp_ok = tstamp_ok,
        .rcv_tsval = tsval,
        .rcv_tsecr = tsecr, /* Server's Initial TSval */
        .usec_ts_ok = usec_ts_ok,
        .sack_ok = sack_ok,
        .ecn_ok = ecn_ok,
    }

    skc = bpf_skc_lookup_tcp(...);
    sk = (struct sock *)bpf_skc_to_tcp_sock(skc);
    bpf_sk_assign_tcp_reqsk(skb, sk, attrs, sizeof(attrs));
    bpf_sk_release(skc);

bpf_sk_assign_tcp_reqsk() takes skb, a listener sk, and struct bpf_tcp_req_attrs and allocates reqsk and configures it. Then, bpf_sk_assign_tcp_reqsk() links reqsk with skb and the listener.

The notable thing here is that we do not hold refcnt for both reqsk and listener. To differentiate that, we mark reqsk->syncookie, which is only used in TX for now. So, if reqsk->syncookie is 1 in RX, it means that the reqsk is allocated by kfunc.

When skb is freed, sock_pfree() checks if reqsk->syncookie is 1, and in that case, we set NULL to reqsk->rsk_listener before calling reqsk_free() as reqsk does not hold a refcnt of the listener.

When the TCP stack looks up a socket from the skb, we steal the listener from the reqsk in skb_steal_sock() and create a full sk in cookie_v[46]_check().

The refcnt of reqsk will finally be set to 1 in tcp_get_cookie_sock() after creating a full sk.

Note that we can extend struct bpf_tcp_req_attrs in the future when we add a new attribute that is determined in 3WHS.

---
 include/net/tcp.h |  13 ++++++
 net/core/filter.c | 113 +++++++++++++++++++++++++++++++++++++++++++++-
 net/core/sock.c   |  14 +++++-
 3 files changed, 136 insertions(+), 4 deletions(-)
include/net/tcp.h +13 -0
index a63916f41f77..20619df8819e 100644
@@ -600,6 +600,19 @@ static inline bool cookie_ecn_ok(const struct net *net, const struct dst_entry *
 }
 
 #if IS_ENABLED(CONFIG_BPF)
+struct bpf_tcp_req_attrs {
+	u32 rcv_tsval;
+	u32 rcv_tsecr;
+	u16 mss;
+	u8 rcv_wscale;
+	u8 snd_wscale;
+	u8 ecn_ok;
+	u8 wscale_ok;
+	u8 sack_ok;
+	u8 tstamp_ok;
+	u8 usec_ts_ok;
+};
+
 static inline bool cookie_bpf_ok(struct sk_buff *skb)
 {
 	return skb->sk;
net/core/filter.c +111 -2

137 lines not on this page · raw message

net/core/sock.c +12 -2
index 446e945f736b..1116338f8ff4 100644
@@ -2575,8 +2575,18 @@ EXPORT_SYMBOL(sock_efree);
 #ifdef CONFIG_INET
 void sock_pfree(struct sk_buff *skb)
 {
-	if (sk_is_refcounted(skb->sk))
-		sock_gen_put(skb->sk);
+	struct sock *sk = skb->sk;
+
+	if (!sk_is_refcounted(sk))
+		return;
+
+	if (sk->sk_state == TCP_NEW_SYN_RECV && inet_reqsk(sk)->syncookie) {
+		inet_reqsk(sk)->rsk_listener = NULL;
+		reqsk_free(inet_reqsk(sk));
+		return;
+	}
+
+	sock_gen_put(sk);
 }
 EXPORT_SYMBOL(sock_pfree);
 #endif /* CONFIG_INET */
Signature · 1 line
2.30.2
#6 lore raw

Re: [PATCH v7 bpf-next 5/6] bpf: tcp: Support arbitrary SYN Cookie.

Quoted 40 lines · Kuniyuki Iwashima

This patch adds a new kfunc available at TC hook to support arbitrary SYN Cookie.

The basic usage is as follows:

     struct bpf_tcp_req_attrs attrs = {
         .mss = mss,
         .wscale_ok = wscale_ok,
         .rcv_wscale = rcv_wscale, /* Server's WScale < 15 */
         .snd_wscale = snd_wscale, /* Client's WScale < 15 */
         .tstamp_ok = tstamp_ok,
         .rcv_tsval = tsval,
         .rcv_tsecr = tsecr, /* Server's Initial TSval */
         .usec_ts_ok = usec_ts_ok,
         .sack_ok = sack_ok,
         .ecn_ok = ecn_ok,
     }

     skc = bpf_skc_lookup_tcp(...);
     sk = (struct sock *)bpf_skc_to_tcp_sock(skc);
     bpf_sk_assign_tcp_reqsk(skb, sk, attrs, sizeof(attrs));
     bpf_sk_release(skc);

bpf_sk_assign_tcp_reqsk() takes skb, a listener sk, and struct bpf_tcp_req_attrs and allocates reqsk and configures it. Then, bpf_sk_assign_tcp_reqsk() links reqsk with skb and the listener.

The notable thing here is that we do not hold refcnt for both reqsk and listener. To differentiate that, we mark reqsk->syncookie, which is only used in TX for now. So, if reqsk->syncookie is 1 in RX, it means that the reqsk is allocated by kfunc.

When skb is freed, sock_pfree() checks if reqsk->syncookie is 1, and in that case, we set NULL to reqsk->rsk_listener before calling reqsk_free() as reqsk does not hold a refcnt of the listener.

When the TCP stack looks up a socket from the skb, we steal the listener from the reqsk in skb_steal_sock() and create a full sk in cookie_v[46]_check().

Quoted 5 lines

The refcnt of reqsk will finally be set to 1 in tcp_get_cookie_sock() after creating a full sk.

Note that we can extend struct bpf_tcp_req_attrs in the future when we add a new attribute that is determined in 3WHS.

Notice a few final details.

Quoted 17 lines
---
  include/net/tcp.h |  13 ++++++
  net/core/filter.c | 113 +++++++++++++++++++++++++++++++++++++++++++++-
  net/core/sock.c   |  14 +++++-
  3 files changed, 136 insertions(+), 4 deletions(-)
include/net/tcp.h +1 -0
index a63916f41f77..20619df8819e 100644
@@ -600,6 +600,19 @@ static inline bool cookie_ecn_ok(const struct net *net, const struct dst_entry *
  }
 
  #if IS_ENABLED(CONFIG_BPF)
+struct bpf_tcp_req_attrs {

include/net/tcp.h static inline bool cookie_ecn_ok(const struct net *net, const struct dst_entry * · line 613

Quoted 10 lines
include/net/tcp.h +10 -0
+	u32 rcv_tsval;
+	u32 rcv_tsecr;
+	u16 mss;
+	u8 rcv_wscale;
+	u8 snd_wscale;
+	u8 ecn_ok;
+	u8 wscale_ok;
+	u8 sack_ok;
+	u8 tstamp_ok;
+	u8 usec_ts_ok;

Add "u8 reserved[3];" for the 3 bytes tail padding.

Quoted 48 lines
include/net/tcp.h +2 -0
+};
+
  static inline bool cookie_bpf_ok(struct sk_buff *skb)
  {
  	return skb->sk;
net/core/filter.c +35 -0
index 24061f29c9dd..961c2d30bd72 100644
@@ -11837,6 +11837,105 @@ __bpf_kfunc int bpf_sock_addr_set_sun_path(struct bpf_sock_addr_kern *sa_kern,
 
  	return 0;
  }
+
+__bpf_kfunc int bpf_sk_assign_tcp_reqsk(struct sk_buff *skb, struct sock *sk,
+					struct bpf_tcp_req_attrs *attrs, int attrs__sz)
+{
+#if IS_ENABLED(CONFIG_SYN_COOKIES)
+	const struct request_sock_ops *ops;
+	struct inet_request_sock *ireq;
+	struct tcp_request_sock *treq;
+	struct request_sock *req;
+	struct net *net;
+	__u16 min_mss;
+	u32 tsoff = 0;
+
+	if (attrs__sz != sizeof(*attrs))
+		return -EINVAL;
+
+	if (!sk)
+		return -EINVAL;
+
+	if (!skb_at_tc_ingress(skb))
+		return -EINVAL;
+
+	net = dev_net(skb->dev);
+	if (net != sock_net(sk))
+		return -ENETUNREACH;
+
+	switch (skb->protocol) {
+	case htons(ETH_P_IP):
+		ops = &tcp_request_sock_ops;
+		min_mss = 536;
+		break;
+#if IS_BUILTIN(CONFIG_IPV6)
+	case htons(ETH_P_IPV6):
+		ops = &tcp6_request_sock_ops;
+		min_mss = IPV6_MIN_MTU - 60;

net/core/filter.c __bpf_kfunc int bpf_sock_addr_set_sun_path(struct bpf_sock_addr_kern *sa_kern, · line 11884

Quoted 10 lines
net/core/filter.c +10 -0
+		break;
+#endif
+	default:
+		return -EINVAL;
+	}
+
+	if (sk->sk_type != SOCK_STREAM || sk->sk_state != TCP_LISTEN ||
+	    sk_is_mptcp(sk))
+		return -EINVAL;
+

and check for:

	if (attrs->reserved[0] || attrs->reserved[1] || attrs->reserved[2])
		return -EINVAL;

It will be safer if it needs to extend "struct bpf_tcp_req_attrs". There is an existing example in __bpf_nf_ct_lookup() when checking the 'struct bpf_ct_opts *opts'.

#7 lore raw

Re: [PATCH v7 bpf-next 5/6] bpf: tcp: Support arbitrary SYN Cookie.

From: Martin KaFai Lau <[email protected]>
Date: Thu, 11 Jan 2024 17:44:55 -0800

Quoted 140 lines · Kuniyuki Iwashima
Quoted 40 lines

This patch adds a new kfunc available at TC hook to support arbitrary SYN Cookie.

The basic usage is as follows:

     struct bpf_tcp_req_attrs attrs = {
         .mss = mss,
         .wscale_ok = wscale_ok,
         .rcv_wscale = rcv_wscale, /* Server's WScale < 15 */
         .snd_wscale = snd_wscale, /* Client's WScale < 15 */
         .tstamp_ok = tstamp_ok,
         .rcv_tsval = tsval,
         .rcv_tsecr = tsecr, /* Server's Initial TSval */
         .usec_ts_ok = usec_ts_ok,
         .sack_ok = sack_ok,
         .ecn_ok = ecn_ok,
     }

     skc = bpf_skc_lookup_tcp(...);
     sk = (struct sock *)bpf_skc_to_tcp_sock(skc);
     bpf_sk_assign_tcp_reqsk(skb, sk, attrs, sizeof(attrs));
     bpf_sk_release(skc);

bpf_sk_assign_tcp_reqsk() takes skb, a listener sk, and struct bpf_tcp_req_attrs and allocates reqsk and configures it. Then, bpf_sk_assign_tcp_reqsk() links reqsk with skb and the listener.

The notable thing here is that we do not hold refcnt for both reqsk and listener. To differentiate that, we mark reqsk->syncookie, which is only used in TX for now. So, if reqsk->syncookie is 1 in RX, it means that the reqsk is allocated by kfunc.

When skb is freed, sock_pfree() checks if reqsk->syncookie is 1, and in that case, we set NULL to reqsk->rsk_listener before calling reqsk_free() as reqsk does not hold a refcnt of the listener.

When the TCP stack looks up a socket from the skb, we steal the listener from the reqsk in skb_steal_sock() and create a full sk in cookie_v[46]_check().

Quoted 5 lines

The refcnt of reqsk will finally be set to 1 in tcp_get_cookie_sock() after creating a full sk.

Note that we can extend struct bpf_tcp_req_attrs in the future when we add a new attribute that is determined in 3WHS.

Notice a few final details.

Quoted 17 lines
---
  include/net/tcp.h |  13 ++++++
  net/core/filter.c | 113 +++++++++++++++++++++++++++++++++++++++++++++-
  net/core/sock.c   |  14 +++++-
  3 files changed, 136 insertions(+), 4 deletions(-)
include/net/tcp.h +1 -0
index a63916f41f77..20619df8819e 100644
@@ -600,6 +600,19 @@ static inline bool cookie_ecn_ok(const struct net *net, const struct dst_entry *
  }
 
  #if IS_ENABLED(CONFIG_BPF)
+struct bpf_tcp_req_attrs {

include/net/tcp.h static inline bool cookie_ecn_ok(const struct net *net, const struct dst_entry * · line 613

Quoted 10 lines
include/net/tcp.h +10 -0
+	u32 rcv_tsval;
+	u32 rcv_tsecr;
+	u16 mss;
+	u8 rcv_wscale;
+	u8 snd_wscale;
+	u8 ecn_ok;
+	u8 wscale_ok;
+	u8 sack_ok;
+	u8 tstamp_ok;
+	u8 usec_ts_ok;

Add "u8 reserved[3];" for the 3 bytes tail padding.

Quoted 48 lines
include/net/tcp.h +2 -0
+};
+
  static inline bool cookie_bpf_ok(struct sk_buff *skb)
  {
  	return skb->sk;
net/core/filter.c +35 -0
index 24061f29c9dd..961c2d30bd72 100644
@@ -11837,6 +11837,105 @@ __bpf_kfunc int bpf_sock_addr_set_sun_path(struct bpf_sock_addr_kern *sa_kern,
 
  	return 0;
  }
+
+__bpf_kfunc int bpf_sk_assign_tcp_reqsk(struct sk_buff *skb, struct sock *sk,
+					struct bpf_tcp_req_attrs *attrs, int attrs__sz)
+{
+#if IS_ENABLED(CONFIG_SYN_COOKIES)
+	const struct request_sock_ops *ops;
+	struct inet_request_sock *ireq;
+	struct tcp_request_sock *treq;
+	struct request_sock *req;
+	struct net *net;
+	__u16 min_mss;
+	u32 tsoff = 0;
+
+	if (attrs__sz != sizeof(*attrs))
+		return -EINVAL;
+
+	if (!sk)
+		return -EINVAL;
+
+	if (!skb_at_tc_ingress(skb))
+		return -EINVAL;
+
+	net = dev_net(skb->dev);
+	if (net != sock_net(sk))
+		return -ENETUNREACH;
+
+	switch (skb->protocol) {
+	case htons(ETH_P_IP):
+		ops = &tcp_request_sock_ops;
+		min_mss = 536;
+		break;
+#if IS_BUILTIN(CONFIG_IPV6)
+	case htons(ETH_P_IPV6):
+		ops = &tcp6_request_sock_ops;
+		min_mss = IPV6_MIN_MTU - 60;

net/core/filter.c __bpf_kfunc int bpf_sock_addr_set_sun_path(struct bpf_sock_addr_kern *sa_kern, · line 11884

Quoted 10 lines
net/core/filter.c +10 -0
+		break;
+#endif
+	default:
+		return -EINVAL;
+	}
+
+	if (sk->sk_type != SOCK_STREAM || sk->sk_state != TCP_LISTEN ||
+	    sk_is_mptcp(sk))
+		return -EINVAL;
+

and check for:

Quoted 6 lines
	if (attrs->reserved[0] || attrs->reserved[1] || attrs->reserved[2])
		return -EINVAL;

It will be safer if it needs to extend "struct bpf_tcp_req_attrs". There is an existing example in __bpf_nf_ct_lookup() when checking the 'struct bpf_ct_opts *opts'.

I'll add that test in v8.

Thank you!

#8 lore raw

PATCH v7 6/6 selftest: bpf: Test bpf_sk_assign_tcp_reqsk().

In reply to Kuniyuki Iwashima

This commit adds a sample selftest to demonstrate how we can use bpf_sk_assign_tcp_reqsk() as the backend of SYN Proxy.

The test creates IPv4/IPv6 x TCP connections and transfer messages over them on lo with BPF tc prog attached.

The tc prog will process SYN and returns SYN+ACK with the following ISN and TS. In a real use case, this part will be done by other hosts.

MSB LSB

  ISN:  | 31 ... 8 | 7 6 |   5 |    4 | 3 2 1 0 |
        |   Hash_1 | MSS | ECN | SACK |  WScale |
  TS:   | 31 ... 8 |          7 ... 0           |
        |   Random |           Hash_2           |

WScale in SYN is reused in SYN+ACK.

The client returns ACK, and tc prog will recalculate ISN and TS from ACK and validate SYN Cookie.

If it's valid, the prog calls kfunc to allocate a reqsk for skb and configure the reqsk based on the argument created from SYN Cookie.

Later, the reqsk will be processed in cookie_v[46]_check() to create a connection.

---
 tools/testing/selftests/bpf/bpf_kfuncs.h      |  10 +
 tools/testing/selftests/bpf/config            |   1 +
 .../bpf/prog_tests/tcp_custom_syncookie.c     | 154 +++++
 .../selftests/bpf/progs/bpf_tracing_net.h     |  16 +
 .../selftests/bpf/progs/test_siphash.h        |  64 ++
 .../bpf/progs/test_tcp_custom_syncookie.c     | 572 ++++++++++++++++++
 .../bpf/progs/test_tcp_custom_syncookie.h     | 140 +++++
 7 files changed, 957 insertions(+)
 create mode 100644 tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c
 create mode 100644 tools/testing/selftests/bpf/progs/test_siphash.h
 create mode 100644 tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c
 create mode 100644 tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.h
tools/testing/selftests/bpf/bpf_kfuncs.h +10 -0
index b4e78c1eb37b..23c24f852f4f 100644
@@ -51,6 +51,16 @@ extern int bpf_dynptr_clone(const struct bpf_dynptr *ptr, struct bpf_dynptr *clo
 extern int bpf_sock_addr_set_sun_path(struct bpf_sock_addr_kern *sa_kern,
 				      const __u8 *sun_path, __u32 sun_path__sz) __ksym;
 
+/* Description
+ *  Allocate and configure a reqsk and link it with a listener and skb.
+ * Returns
+ *  Error code
+ */
+struct sock;
+struct bpf_tcp_req_attrs;
+extern int bpf_sk_assign_tcp_reqsk(struct __sk_buff *skb, struct sock *sk,
+				   struct bpf_tcp_req_attrs *attrs, int attrs__sz) __ksym;
+
 void *bpf_cast_to_kern_ctx(void *) __ksym;
 
 void *bpf_rdonly_cast(void *obj, __u32 btf_id) __ksym;
tools/testing/selftests/bpf/config +1 -0
index c125c441abc7..01f241ea2c67 100644
@@ -81,6 +81,7 @@ CONFIG_NF_NAT=y
 CONFIG_RC_CORE=y
 CONFIG_SECURITY=y
 CONFIG_SECURITYFS=y
+CONFIG_SYN_COOKIES=y
 CONFIG_TEST_BPF=m
 CONFIG_USERFAULTFD=y
 CONFIG_VSOCKETS=y
tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c new file +154 -0

154 lines not on this page · raw message

tools/testing/selftests/bpf/progs/bpf_tracing_net.h +16 -0
index 1bdc680b0e0e..49e525ad9856 100644
@@ -51,9 +51,25 @@
 #define ICSK_TIME_LOSS_PROBE	5
 #define ICSK_TIME_REO_TIMEOUT	6
 
+#define ETH_ALEN		6
 #define ETH_HLEN		14
+#define ETH_P_IP		0x0800
 #define ETH_P_IPV6		0x86DD
 
+#define NEXTHDR_TCP		6
+
+#define TCPOPT_NOP		1
+#define TCPOPT_EOL		0
+#define TCPOPT_MSS		2
+#define TCPOPT_WINDOW		3
+#define TCPOPT_TIMESTAMP	8
+#define TCPOPT_SACK_PERM	4
+
+#define TCPOLEN_MSS		4
+#define TCPOLEN_WINDOW		3
+#define TCPOLEN_TIMESTAMP	10
+#define TCPOLEN_SACK_PERM	2
+
 #define CHECKSUM_NONE		0
 #define CHECKSUM_PARTIAL	3
 
tools/testing/selftests/bpf/progs/test_siphash.h new file +64 -0

64 lines not on this page · raw message

tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +572 -0

572 lines not on this page · raw message

tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.h new file +140 -0

140 lines not on this page · raw message

Signature · 1 line
2.30.2
#9 lore raw

Re: [PATCH v7 bpf-next 6/6] selftest: bpf: Test bpf_sk_assign_tcp_reqsk().

Quoted 98 lines · Kuniyuki Iwashima
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +98 -0
+static int tcp_validate_header(struct tcp_syncookie *ctx)
+{
+	s64 csum;
+
+	if (tcp_reload_headers(ctx))
+		goto err;
+
+	csum = bpf_csum_diff(0, 0, (void *)ctx->tcp, ctx->tcp->doff * 4, 0);
+	if (csum < 0)
+		goto err;
+
+	if (ctx->ipv4) {
+		/* check tcp_v4_csum(csum) is 0 if not on lo. */
+
+		csum = bpf_csum_diff(0, 0, (void *)ctx->ipv4, ctx->ipv4->ihl * 4, 0);
+		if (csum < 0)
+			goto err;
+
+		if (csum_fold(csum) != 0)
+			goto err;
+	} else if (ctx->ipv6) {
+		/* check tcp_v6_csum(csum) is 0 if not on lo. */
+	}
+
+	return 0;
+err:
+	return -1;
+}
+
+static int tcp_parse_option(__u32 index, struct tcp_syncookie *ctx)
+{
+	char opcode, opsize;
+
+	if (ctx->ptr + 1 > ctx->data_end)
+		goto stop;
+
+	opcode = *ctx->ptr++;
+
+	if (opcode == TCPOPT_EOL)
+		goto stop;
+
+	if (opcode == TCPOPT_NOP)
+		goto next;
+
+	if (ctx->ptr + 1 > ctx->data_end)
+		goto stop;
+
+	opsize = *ctx->ptr++;
+
+	if (opsize < 2)
+		goto stop;
+
+	switch (opcode) {
+	case TCPOPT_MSS:
+		if (opsize == TCPOLEN_MSS && ctx->tcp->syn &&
+		    ctx->ptr + (TCPOLEN_MSS - 2) < ctx->data_end)
+			ctx->attrs.mss = get_unaligned_be16(ctx->ptr);
+		break;
+	case TCPOPT_WINDOW:
+		if (opsize == TCPOLEN_WINDOW && ctx->tcp->syn &&
+		    ctx->ptr + (TCPOLEN_WINDOW - 2) < ctx->data_end) {
+			ctx->attrs.wscale_ok = 1;
+			ctx->attrs.snd_wscale = *ctx->ptr;
+		}
+		break;
+	case TCPOPT_TIMESTAMP:
+		if (opsize == TCPOLEN_TIMESTAMP &&
+		    ctx->ptr + (TCPOLEN_TIMESTAMP - 2) < ctx->data_end) {
+			ctx->attrs.rcv_tsval = get_unaligned_be32(ctx->ptr);
+			ctx->attrs.rcv_tsecr = get_unaligned_be32(ctx->ptr + 4);
+
+			if (ctx->tcp->syn && ctx->attrs.rcv_tsecr)
+				ctx->attrs.tstamp_ok = 0;
+			else
+				ctx->attrs.tstamp_ok = 1;
+		}
+		break;
+	case TCPOPT_SACK_PERM:
+		if (opsize == TCPOLEN_SACK_PERM && ctx->tcp->syn &&
+		    ctx->ptr + (TCPOLEN_SACK_PERM - 2) < ctx->data_end)
+			ctx->attrs.sack_ok = 1;
+		break;
+	}
+
+	ctx->ptr += opsize - 2;
+next:
+	return 0;
+stop:
+	return 1;
+}
+
+static void tcp_parse_options(struct tcp_syncookie *ctx)
+{
+	ctx->ptr = (char *)(ctx->tcp + 1);
+
+	bpf_loop(40, tcp_parse_option, ctx, 0);
+}
+

tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c line 276

Quoted 10 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +10 -0
+static int tcp_validate_sysctl(struct tcp_syncookie *ctx)
+{
+	if ((ctx->ipv4 && ctx->attrs.mss != MSS_LOCAL_IPV4) ||
+	    (ctx->ipv6 && ctx->attrs.mss != MSS_LOCAL_IPV6))
+		goto err;
+
+	if (!ctx->attrs.wscale_ok || ctx->attrs.snd_wscale != 7)
+		goto err;
+
+	if (!ctx->attrs.tstamp_ok)

The bpf-ci reported error in cpuv4. The email from [email protected] has the link.

I tried the following:

	if (!ctx->attrs.tstamp_ok) {
		bpf_printk("ctx->attrs.tstamp_ok %u",
			ctx->attrs.tstamp_ok);
		goto err;
	}

The above prints tstamp_ok as 1 while there is a "if (!ctx->attrs.tstamp_ok)" test before it.

Yonghong and I debugged it quite a bit. verifier concluded the ctx->attrs.tstamp_ok is 0. We knew some red herring like cpuv4 has fewer register spilling but not able to root cause it yet.

In the mean time, there are existing selftests parsing the tcp header. For example, the test_parse_tcp_hdr_opt[_dynptr].c. Not as complete as your tcp_parse_option() but should be pretty close. It does not use bpf_loop. It uses a bounded loop + a subprog (the parse_hdr_opt in the selftests) instead. You can consider a similar construct to see if it works around the cpuv4 CI issue for the time being.

pw-bot: cr

Quoted 13 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +13 -0
+		goto err;
+
+	if (!ctx->attrs.sack_ok)
+		goto err;
+
+	if (!ctx->tcp->ece || !ctx->tcp->cwr)
+		goto err;
+
+	return 0;
+err:
+	return -1;
+}
+

[ ... ]

Quoted 12 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +12 -0
+static int tcp_handle_syn(struct tcp_syncookie *ctx)
+{
+	s64 csum;
+
+	if (tcp_validate_header(ctx))
+		goto err;
+
+	tcp_parse_options(ctx);
+
+	if (tcp_validate_sysctl(ctx))
+		goto err;
+
#10 lore raw

Re: [PATCH v7 bpf-next 6/6] selftest: bpf: Test bpf_sk_assign_tcp_reqsk().

From: Martin KaFai Lau <[email protected]>
Date: Wed, 20 Dec 2023 22:35:26 -0800

Quoted 104 lines · Kuniyuki Iwashima
Quoted 103 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +103 -0
+static int tcp_validate_header(struct tcp_syncookie *ctx)
+{
+	s64 csum;
+
+	if (tcp_reload_headers(ctx))
+		goto err;
+
+	csum = bpf_csum_diff(0, 0, (void *)ctx->tcp, ctx->tcp->doff * 4, 0);
+	if (csum < 0)
+		goto err;
+
+	if (ctx->ipv4) {
+		/* check tcp_v4_csum(csum) is 0 if not on lo. */
+
+		csum = bpf_csum_diff(0, 0, (void *)ctx->ipv4, ctx->ipv4->ihl * 4, 0);
+		if (csum < 0)
+			goto err;
+
+		if (csum_fold(csum) != 0)
+			goto err;
+	} else if (ctx->ipv6) {
+		/* check tcp_v6_csum(csum) is 0 if not on lo. */
+	}
+
+	return 0;
+err:
+	return -1;
+}
+
+static int tcp_parse_option(__u32 index, struct tcp_syncookie *ctx)
+{
+	char opcode, opsize;
+
+	if (ctx->ptr + 1 > ctx->data_end)
+		goto stop;
+
+	opcode = *ctx->ptr++;
+
+	if (opcode == TCPOPT_EOL)
+		goto stop;
+
+	if (opcode == TCPOPT_NOP)
+		goto next;
+
+	if (ctx->ptr + 1 > ctx->data_end)
+		goto stop;
+
+	opsize = *ctx->ptr++;
+
+	if (opsize < 2)
+		goto stop;
+
+	switch (opcode) {
+	case TCPOPT_MSS:
+		if (opsize == TCPOLEN_MSS && ctx->tcp->syn &&
+		    ctx->ptr + (TCPOLEN_MSS - 2) < ctx->data_end)
+			ctx->attrs.mss = get_unaligned_be16(ctx->ptr);
+		break;
+	case TCPOPT_WINDOW:
+		if (opsize == TCPOLEN_WINDOW && ctx->tcp->syn &&
+		    ctx->ptr + (TCPOLEN_WINDOW - 2) < ctx->data_end) {
+			ctx->attrs.wscale_ok = 1;
+			ctx->attrs.snd_wscale = *ctx->ptr;
+		}
+		break;
+	case TCPOPT_TIMESTAMP:
+		if (opsize == TCPOLEN_TIMESTAMP &&
+		    ctx->ptr + (TCPOLEN_TIMESTAMP - 2) < ctx->data_end) {
+			ctx->attrs.rcv_tsval = get_unaligned_be32(ctx->ptr);
+			ctx->attrs.rcv_tsecr = get_unaligned_be32(ctx->ptr + 4);
+
+			if (ctx->tcp->syn && ctx->attrs.rcv_tsecr)
+				ctx->attrs.tstamp_ok = 0;
+			else
+				ctx->attrs.tstamp_ok = 1;
+		}
+		break;
+	case TCPOPT_SACK_PERM:
+		if (opsize == TCPOLEN_SACK_PERM && ctx->tcp->syn &&
+		    ctx->ptr + (TCPOLEN_SACK_PERM - 2) < ctx->data_end)
+			ctx->attrs.sack_ok = 1;
+		break;
+	}
+
+	ctx->ptr += opsize - 2;
+next:
+	return 0;
+stop:
+	return 1;
+}
+
+static void tcp_parse_options(struct tcp_syncookie *ctx)
+{
+	ctx->ptr = (char *)(ctx->tcp + 1);
+
+	bpf_loop(40, tcp_parse_option, ctx, 0);
+}
+
+static int tcp_validate_sysctl(struct tcp_syncookie *ctx)
+{
+	if ((ctx->ipv4 && ctx->attrs.mss != MSS_LOCAL_IPV4) ||
+	    (ctx->ipv6 && ctx->attrs.mss != MSS_LOCAL_IPV6))
+		goto err;
Quoted 8 lines

tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c line 276

Quoted 5 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +5 -0
+
+	if (!ctx->attrs.wscale_ok || ctx->attrs.snd_wscale != 7)
+		goto err;
+
+	if (!ctx->attrs.tstamp_ok)

The bpf-ci reported error in cpuv4. The email from [email protected] has the link.

I like the mail from the bot, it's useful, but it seems that it's sent to the patch author only when the CI passes ?

But yeah, I found the failed test.
https://github.com/kernel-patches/bpf/actions/runs/7284164398/job/19849657597

Quoted 17 lines

I tried the following:

	if (!ctx->attrs.tstamp_ok) {
		bpf_printk("ctx->attrs.tstamp_ok %u",
			ctx->attrs.tstamp_ok);
		goto err;
	}

The above prints tstamp_ok as 1 while there is a "if (!ctx->attrs.tstamp_ok)" test before it.

Yonghong and I debugged it quite a bit. verifier concluded the ctx->attrs.tstamp_ok is 0. We knew some red herring like cpuv4 has fewer register spilling but not able to root cause it yet.

Quoted 6 lines

In the mean time, there are existing selftests parsing the tcp header. For example, the test_parse_tcp_hdr_opt[_dynptr].c. Not as complete as your tcp_parse_option() but should be pretty close. It does not use bpf_loop. It uses a bounded loop + a subprog (the parse_hdr_opt in the selftests) instead. You can consider a similar construct to see if it works around the cpuv4 CI issue for the time being.

Sure, I'll install the latest clang/llvm and check if the test passes without bpf_loop().

Thanks!

#11 lore raw

Re: [PATCH v7 bpf-next 6/6] selftest: bpf: Test bpf_sk_assign_tcp_reqsk().

From: Kuniyuki Iwashima <[email protected]>
Date: Thu, 21 Dec 2023 16:04:43 +0900

Quoted 146 lines

From: Martin KaFai Lau <[email protected]>
Date: Wed, 20 Dec 2023 22:35:26 -0800

Quoted 104 lines · Kuniyuki Iwashima
Quoted 103 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +103 -0
+static int tcp_validate_header(struct tcp_syncookie *ctx)
+{
+	s64 csum;
+
+	if (tcp_reload_headers(ctx))
+		goto err;
+
+	csum = bpf_csum_diff(0, 0, (void *)ctx->tcp, ctx->tcp->doff * 4, 0);
+	if (csum < 0)
+		goto err;
+
+	if (ctx->ipv4) {
+		/* check tcp_v4_csum(csum) is 0 if not on lo. */
+
+		csum = bpf_csum_diff(0, 0, (void *)ctx->ipv4, ctx->ipv4->ihl * 4, 0);
+		if (csum < 0)
+			goto err;
+
+		if (csum_fold(csum) != 0)
+			goto err;
+	} else if (ctx->ipv6) {
+		/* check tcp_v6_csum(csum) is 0 if not on lo. */
+	}
+
+	return 0;
+err:
+	return -1;
+}
+
+static int tcp_parse_option(__u32 index, struct tcp_syncookie *ctx)
+{
+	char opcode, opsize;
+
+	if (ctx->ptr + 1 > ctx->data_end)
+		goto stop;
+
+	opcode = *ctx->ptr++;
+
+	if (opcode == TCPOPT_EOL)
+		goto stop;
+
+	if (opcode == TCPOPT_NOP)
+		goto next;
+
+	if (ctx->ptr + 1 > ctx->data_end)
+		goto stop;
+
+	opsize = *ctx->ptr++;
+
+	if (opsize < 2)
+		goto stop;
+
+	switch (opcode) {
+	case TCPOPT_MSS:
+		if (opsize == TCPOLEN_MSS && ctx->tcp->syn &&
+		    ctx->ptr + (TCPOLEN_MSS - 2) < ctx->data_end)
+			ctx->attrs.mss = get_unaligned_be16(ctx->ptr);
+		break;
+	case TCPOPT_WINDOW:
+		if (opsize == TCPOLEN_WINDOW && ctx->tcp->syn &&
+		    ctx->ptr + (TCPOLEN_WINDOW - 2) < ctx->data_end) {
+			ctx->attrs.wscale_ok = 1;
+			ctx->attrs.snd_wscale = *ctx->ptr;
+		}
+		break;
+	case TCPOPT_TIMESTAMP:
+		if (opsize == TCPOLEN_TIMESTAMP &&
+		    ctx->ptr + (TCPOLEN_TIMESTAMP - 2) < ctx->data_end) {
+			ctx->attrs.rcv_tsval = get_unaligned_be32(ctx->ptr);
+			ctx->attrs.rcv_tsecr = get_unaligned_be32(ctx->ptr + 4);
+
+			if (ctx->tcp->syn && ctx->attrs.rcv_tsecr)
+				ctx->attrs.tstamp_ok = 0;
+			else
+				ctx->attrs.tstamp_ok = 1;
+		}
+		break;
+	case TCPOPT_SACK_PERM:
+		if (opsize == TCPOLEN_SACK_PERM && ctx->tcp->syn &&
+		    ctx->ptr + (TCPOLEN_SACK_PERM - 2) < ctx->data_end)
+			ctx->attrs.sack_ok = 1;
+		break;
+	}
+
+	ctx->ptr += opsize - 2;
+next:
+	return 0;
+stop:
+	return 1;
+}
+
+static void tcp_parse_options(struct tcp_syncookie *ctx)
+{
+	ctx->ptr = (char *)(ctx->tcp + 1);
+
+	bpf_loop(40, tcp_parse_option, ctx, 0);
+}
+
+static int tcp_validate_sysctl(struct tcp_syncookie *ctx)
+{
+	if ((ctx->ipv4 && ctx->attrs.mss != MSS_LOCAL_IPV4) ||
+	    (ctx->ipv6 && ctx->attrs.mss != MSS_LOCAL_IPV6))
+		goto err;
Quoted 8 lines

tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c line 276

Quoted 5 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +5 -0
+
+	if (!ctx->attrs.wscale_ok || ctx->attrs.snd_wscale != 7)
+		goto err;
+
+	if (!ctx->attrs.tstamp_ok)

The bpf-ci reported error in cpuv4. The email from [email protected] has the link.

I like the mail from the bot, it's useful, but it seems that it's sent to the patch author only when the CI passes ?

But yeah, I found the failed test.
https://github.com/kernel-patches/bpf/actions/runs/7284164398/job/19849657597

Quoted 17 lines

I tried the following:

	if (!ctx->attrs.tstamp_ok) {
		bpf_printk("ctx->attrs.tstamp_ok %u",
			ctx->attrs.tstamp_ok);
		goto err;
	}

The above prints tstamp_ok as 1 while there is a "if (!ctx->attrs.tstamp_ok)" test before it.

Yonghong and I debugged it quite a bit. verifier concluded the ctx->attrs.tstamp_ok is 0. We knew some red herring like cpuv4 has fewer register spilling but not able to root cause it yet.

Quoted 6 lines

In the mean time, there are existing selftests parsing the tcp header. For example, the test_parse_tcp_hdr_opt[_dynptr].c. Not as complete as your tcp_parse_option() but should be pretty close. It does not use bpf_loop. It uses a bounded loop + a subprog (the parse_hdr_opt in the selftests) instead. You can consider a similar construct to see if it works around the cpuv4 CI issue for the time being.

Quoted 2 lines

Sure, I'll install the latest clang/llvm and check if the test passes without bpf_loop().

I've tested a simple diff below and some more different patterns, but the prog cannot be loaded. Without bpf_loop(), the parser can loop only 4 times (s/40/4/), but then, it does not fully parse the necessary options, so the packet is dropped due to tcp_validate_sysctl(), and the test fails.

So it seems that tcp_parse_option() cannot work around the issue even without bpf_loop() and this series needs to wait the cpuv4 fix..

---8<---
@@ -259,9 +260,13 @@ static int tcp_parse_option(__u32 index, struct tcp_syncookie *ctx)

static void tcp_parse_options(struct tcp_syncookie *ctx) {
+ int i;
+
ctx->ptr = (char *)(ctx->tcp + 1);

- bpf_loop(40, tcp_parse_option, ctx, 0);
+ for (i = 0; i < 40; i++)
+ if (tcp_parse_option(i, ctx))
+ break;
}

static int tcp_validate_sysctl(struct tcp_syncookie *ctx)
---8<---

---8<---
BPF program is too large. Processed 1000001 insn
processed 1000001 insns (limit 1000000) max_states_per_insn 30 total_states 41159 peak_states 344 mark_read 55 -- END PROG LOAD LOG --
libbpf: prog 'tcp_custom_syncookie': failed to load: -7
---8<---

reviewer
#12 lore raw

Re: [PATCH v7 bpf-next 6/6] selftest: bpf: Test bpf_sk_assign_tcp_reqsk().

In reply to Martin KaFai Lau
Quoted 123 lines · Martin KaFai Lau
Quoted 100 lines · Kuniyuki Iwashima
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +8 -0
+static int tcp_validate_header(struct tcp_syncookie *ctx)
+{
+    s64 csum;
+
+    if (tcp_reload_headers(ctx))
+        goto err;
+
+    csum = bpf_csum_diff(0, 0, (void *)ctx->tcp, ctx->tcp->doff * 4, 

0);
+    if (csum < 0)
+        goto err;

tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +5 -0
+
+    if (ctx->ipv4) {
+        /* check tcp_v4_csum(csum) is 0 if not on lo. */
+
+        csum = bpf_csum_diff(0, 0, (void *)ctx->ipv4, ctx->ipv4->ihl 

* 4, 0);
+        if (csum < 0)
+            goto err;

tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +81 -0
+
+        if (csum_fold(csum) != 0)
+            goto err;
+    } else if (ctx->ipv6) {
+        /* check tcp_v6_csum(csum) is 0 if not on lo. */
+    }
+
+    return 0;
+err:
+    return -1;
+}
+
+static int tcp_parse_option(__u32 index, struct tcp_syncookie *ctx)
+{
+    char opcode, opsize;
+
+    if (ctx->ptr + 1 > ctx->data_end)
+        goto stop;
+
+    opcode = *ctx->ptr++;
+
+    if (opcode == TCPOPT_EOL)
+        goto stop;
+
+    if (opcode == TCPOPT_NOP)
+        goto next;
+
+    if (ctx->ptr + 1 > ctx->data_end)
+        goto stop;
+
+    opsize = *ctx->ptr++;
+
+    if (opsize < 2)
+        goto stop;
+
+    switch (opcode) {
+    case TCPOPT_MSS:
+        if (opsize == TCPOLEN_MSS && ctx->tcp->syn &&
+            ctx->ptr + (TCPOLEN_MSS - 2) < ctx->data_end)
+            ctx->attrs.mss = get_unaligned_be16(ctx->ptr);
+        break;
+    case TCPOPT_WINDOW:
+        if (opsize == TCPOLEN_WINDOW && ctx->tcp->syn &&
+            ctx->ptr + (TCPOLEN_WINDOW - 2) < ctx->data_end) {
+            ctx->attrs.wscale_ok = 1;
+            ctx->attrs.snd_wscale = *ctx->ptr;
+        }
+        break;
+    case TCPOPT_TIMESTAMP:
+        if (opsize == TCPOLEN_TIMESTAMP &&
+            ctx->ptr + (TCPOLEN_TIMESTAMP - 2) < ctx->data_end) {
+            ctx->attrs.rcv_tsval = get_unaligned_be32(ctx->ptr);
+            ctx->attrs.rcv_tsecr = get_unaligned_be32(ctx->ptr + 4);
+
+            if (ctx->tcp->syn && ctx->attrs.rcv_tsecr)
+                ctx->attrs.tstamp_ok = 0;
+            else
+                ctx->attrs.tstamp_ok = 1;
+        }
+        break;
+    case TCPOPT_SACK_PERM:
+        if (opsize == TCPOLEN_SACK_PERM && ctx->tcp->syn &&
+            ctx->ptr + (TCPOLEN_SACK_PERM - 2) < ctx->data_end)
+            ctx->attrs.sack_ok = 1;
+        break;
+    }
+
+    ctx->ptr += opsize - 2;
+next:
+    return 0;
+stop:
+    return 1;
+}
+
+static void tcp_parse_options(struct tcp_syncookie *ctx)
+{
+    ctx->ptr = (char *)(ctx->tcp + 1);
+
+    bpf_loop(40, tcp_parse_option, ctx, 0);
+}
+

tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c line 276

Quoted 10 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +10 -0
+static int tcp_validate_sysctl(struct tcp_syncookie *ctx)
+{
+    if ((ctx->ipv4 && ctx->attrs.mss != MSS_LOCAL_IPV4) ||
+        (ctx->ipv6 && ctx->attrs.mss != MSS_LOCAL_IPV6))
+        goto err;
+
+    if (!ctx->attrs.wscale_ok || ctx->attrs.snd_wscale != 7)
+        goto err;
+
+    if (!ctx->attrs.tstamp_ok)

The bpf-ci reported error in cpuv4. The email from [email protected] has the link.

I tried the following:

    if (!ctx->attrs.tstamp_ok) {
        bpf_printk("ctx->attrs.tstamp_ok %u",
            ctx->attrs.tstamp_ok);
        goto err;
    }

Quoted 5 lines

The above prints tstamp_ok as 1 while there is a "if (!ctx->attrs.tstamp_ok)" test before it.

Yonghong and I debugged it quite a bit. verifier concluded the ctx->attrs.tstamp_ok is 0. We knew some red herring like cpuv4 has fewer register spilling but not able to root cause it yet.

In the mean time, there are existing selftests parsing the tcp header. For example, the test_parse_tcp_hdr_opt[_dynptr].c. Not as complete as your tcp_parse_option() but should be pretty close. It does not use bpf_loop. It uses a bounded loop + a subprog (the parse_hdr_opt in the selftests) instead. You can consider a similar construct to see if it works around the cpuv4 CI issue for the time being.

I did some investigation and found some issues in verifier. I need to dig more into details. On the other hand, with the following patch
https://lore.kernel.org/bpf/[email protected]/
the selftest can run successfully with cpuv2/v3/v4.

Quoted 32 lines

pw-bot: cr

Quoted 13 lines

+        goto err;

tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +12 -0
+
+    if (!ctx->attrs.sack_ok)
+        goto err;
+
+    if (!ctx->tcp->ece || !ctx->tcp->cwr)
+        goto err;
+
+    return 0;
+err:
+    return -1;
+}
+

[ ... ]

Quoted 12 lines
tools/testing/selftests/bpf/progs/test_tcp_custom_syncookie.c new file +12 -0
+static int tcp_handle_syn(struct tcp_syncookie *ctx)
+{
+    s64 csum;
+
+    if (tcp_validate_header(ctx))
+        goto err;
+
+    tcp_parse_options(ctx);
+
+    if (tcp_validate_sysctl(ctx))
+        goto err;
+
#13 lore raw

Re: [PATCH v7 bpf-next 6/6] selftest: bpf: Test bpf_sk_assign_tcp_reqsk().

In reply to Kuniyuki Iwashima

Hi Kuniyuki,

Quoted 2 lines · Kuniyuki Iwashima

This commit adds a sample selftest to demonstrate how we can use bpf_sk_assign_tcp_reqsk() as the backend of SYN Proxy.

(...)

Quoted 12 lines
tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c new file +6 -0
new file mode 100644
index 000000000000..ec5ea2c85119
@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright Amazon.com Inc. or its affiliates. */
+
+#define _GNU_SOURCE
+#include <sched.h>
+#include <stdlib.h>

tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c line 16

Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/tcp_custom_syncookie.c new file +10 -0
+#include <net/if.h>
+
+#include "test_progs.h"
+#include "cgroup_helpers.h"
+#include "network_helpers.h"
+#include "test_tcp_custom_syncookie.skel.h"
+
+#ifndef IPPROTO_MPTCP
+#define IPPROTO_MPTCP 262
+#endif

A small detail if you need to send a new version: you can remove this now that MPTCP support has been dropped. If no new version is needed, that's OK to leave it, it doesn't hurt.

Cheers,
Matt

Signature · 1 line
Sponsored by the NGI0 Core fund.
#14 lore raw
In reply to Kuniyuki Iwashima
Quoted 82 lines · Kuniyuki Iwashima

Under SYN Flood, the TCP stack generates SYN Cookie to remain stateless for the connection request until a valid ACK is responded to the SYN+ACK.

The cookie contains two kinds of host-specific bits, a timestamp and secrets, so only can it be validated by the generator. It means SYN Cookie consumes network resources between the client and the server; intermediate nodes must remember which nodes to route ACK for the cookie.

SYN Proxy reduces such unwanted resource allocation by handling 3WHS at the edge network. After SYN Proxy completes 3WHS, it forwards SYN to the backend server and completes another 3WHS. However, since the server's ISN differs from the cookie, the proxy must manage the ISN mappings and fix up SEQ/ACK numbers in every packet for each connection. If a proxy node goes down, all the connections through it are terminated. Keeping a state at proxy is painful from that perspective.

At AWS, we use a dirty hack to build truly stateless SYN Proxy at scale. Our SYN Proxy consists of the front proxy layer and the backend kernel module. (See slides of LPC2023 [0], p37 - p48)

The cookie that SYN Proxy generates differs from the kernel's cookie in that it contains a secret (called rolling salt) (i) shared by all the proxy nodes so that any node can validate ACK and (ii) updated periodically so that old cookies cannot be validated and we need not encode a timestamp for the cookie. Also, ISN contains WScale, SACK, and ECN, not in TS val. This is not to sacrifice any connection quality, where some customers turn off TCP timestamps option due to retro CVE.

After 3WHS, the proxy restores SYN, encapsulates ACK into SYN, and forward the TCP-in-TCP packet to the backend server. Our kernel module works at Netfilter input/output hooks and first feeds SYN to the TCP stack to initiate 3WHS. When the module is triggered for SYN+ACK, it looks up the corresponding request socket and overwrites tcp_rsk(req)->snt_isn with the proxy's cookie. Then, the module can complete 3WHS with the original ACK as is.

This way, our SYN Proxy does not manage the ISN mappings nor wait for SYN+ACK from the backend thus can remain stateless. It's working very well for high-bandwidth services like multiple Tbps, but we are looking for a way to drop the dirty hack and further optimise the sequences.

If we could validate an arbitrary SYN Cookie on the backend server with BPF, the proxy would need not restore SYN nor pass it. After validating ACK, the proxy node just needs to forward it, and then the server can do the lightweight validation (e.g. check if ACK came from proxy nodes, etc) and create a connection from the ACK.

This series allows us to create a full sk from an arbitrary SYN Cookie, which is done in 3 steps.

1) At tc, BPF prog calls a new kfunc to create a reqsk and configure

      it based on the argument populated from SYN Cookie.  The reqsk has
      its listener as req->rsk_listener and is passed to the TCP stack as
      skb->sk.

2) During TCP socket lookup for the skb, skb_steal_sock() returns a

      listener in the reuseport group that inet_reqsk(skb->sk)->rsk_listener
      belongs to.

3) In cookie_v[46]_check(), the reqsk (skb->sk) is fully initialised and a full sk is created.

The kfunc usage is as follows:

     struct bpf_tcp_req_attrs attrs = {
         .mss = mss,
         .wscale_ok = wscale_ok,
         .rcv_wscale = rcv_wscale, /* Server's WScale < 15 */
         .snd_wscale = snd_wscale, /* Client's WScale < 15 */
         .tstamp_ok = tstamp_ok,
         .rcv_tsval = tsval,
         .rcv_tsecr = tsecr, /* Server's Initial TSval */
         .usec_ts_ok = usec_ts_ok,
         .sack_ok = sack_ok,
         .ecn_ok = ecn_ok,
     }

     skc = bpf_skc_lookup_tcp(...);
     sk = (struct sock *)bpf_skc_to_tcp_sock(skc);
     bpf_sk_assign_tcp_reqsk(skb, sk, attrs, sizeof(attrs));
     bpf_sk_release(skc);
Quoted 7 lines

[0]: https://lpc.events/event/17/contributions/1645/attachments/1350/2701/SYN_Proxy_at_Scale_with_BPF.pdf

Changes:
v7:
* Patch 5 & 6
* Drop MPTCP support

I think Yonghong's (thanks!) cpuv4 patch (https://lore.kernel.org/bpf/[email protected]/) has addressed the issue that the selftest in patch 6 has encountered.

There are some minor comments in v7. Please respin v8 when the cpuv4 patch has concluded so that it can kick off the CI also.