Introduce a BPF helper to generate SYN cookies
Subsystems (7)
v2 cover Introduce a BPF helper to generate SYN cookies
From: Petar Penkov <[email protected]>
This patch series introduces a BPF helper function that allows generating SYN cookies from BPF. Currently, this helper is enabled at both the TC hook and the XDP hook.
The first two patches in the series add/modify several TCP helper functions to allow for SKB-less operation, as is the case at the XDP hook.
The third patch introduces the bpf_tcp_gen_syncookie helper function which generates a SYN cookie for either XDP or TC programs. The return value of this function contains both the MSS value, encoded in the cookie, and the cookie itself.
The last three patches sync tools/ and add a test.
Performance evaluation:
I sent 10Mpps to a fixed port on a host with 2 10G bonded Mellanox 4 NICs from random IPv6 source addresses. Without XDP I observed 7.2Mpps (syn-acks) being sent out if the IPv6 packets carry 20 bytes of TCP options or 7.6Mpps if they carry no options. If I attached a simple program that checks if a packet is IPv6/TCP/SYN, looks up the socket, issues a cookie, and sends it back out after swapping src/dest, recomputing the checksum, and setting the ACK flag, I observed 10Mpps being sent back out.
Changes since v1:
1/ Added performance numbers to the cover letter
2/ Patch 2: Refactored a bit to fix compilation issues 3/ Patch 3: Changed ENOTSUPP to EOPNOTSUPP at Toke's suggestion
Changes since RFC:
1/ Cookie is returned in host order at Alexei's suggestion
2/ If cookies are not enabled via a sysctl, the helper function returns
-ENOENT instead of -EINVAL at Lorenz's suggestion
3/ Fixed documentation to properly reflect that MSS is 16 bits at
Lorenz's suggestion
4/ BPF helper requires TCP length to match ->doff field, rather than to simply
be no more than 20 bytes at Eric and Alexei's suggestion
5/ Packet type is looked up from the packet version field, rather than from the
socket. v4 packets are rejected on v6-only sockets but should work with dual stack listeners at Eric's suggestion
6/ Removed unnecessary net argument from helper function in patch 2 at
Lorenz's suggestion
7/ Changed test to only pass MSS option so we can convince the verifier that the
memory access is not out of bounds
Note that 7/ below illustrates the verifier might need to be extended to allow passing a variable tcph->doff to the helper function like below:
__u32 thlen = tcph->doff * 4;
if (thlen < sizeof(*tcph))
return;
__s64 cookie = bpf_tcp_gen_syncookie(sk, ipv4h, 20, tcph, thlen);
Petar Penkov (6):
tcp: tcp_syn_flood_action read port from socket
tcp: add skb-less helpers to retrieve SYN cookie
bpf: add bpf_tcp_gen_syncookie helper
bpf: sync bpf.h to tools/
selftests/bpf: bpf_tcp_gen_syncookie->bpf_helpers selftests/bpf: add test for bpf_tcp_gen_syncookie
include/net/tcp.h | 10 +++ include/uapi/linux/bpf.h | 30 ++++++- net/core/filter.c | 73 +++++++++++++++++ net/ipv4/tcp_input.c | 81 +++++++++++++++++-- net/ipv4/tcp_ipv4.c | 15 ++++ net/ipv6/tcp_ipv6.c | 15 ++++ tools/include/uapi/linux/bpf.h | 37 ++++++++- tools/testing/selftests/bpf/bpf_helpers.h | 3 + .../bpf/progs/test_tcp_check_syncookie_kern.c | 48 +++++++++-- .../selftests/bpf/test_tcp_check_syncookie.sh | 3 + .../bpf/test_tcp_check_syncookie_user.c | 61 ++++++++++++-- 11 files changed, 354 insertions(+), 22 deletions(-)
Signature · 1 line
2.22.0.709.g102302147b-goog
PATCH v2 1/6 tcp: tcp_syn_flood_action read port from socket
From: Petar Penkov <[email protected]>
This allows us to call this function before an SKB has been allocated.
--- net/ipv4/tcp_input.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
net/ipv4/tcp_input.c +3 -5
@@ -6422,9 +6422,7 @@ EXPORT_SYMBOL(inet_reqsk_alloc);/* * Return true if a syncookie should be sent */ -static bool tcp_syn_flood_action (const struct sock *sk, -const struct sk_buff *skb, -const char *proto) +static bool tcp_syn_flood_action (const struct sock *sk,const char *proto) {struct request_sock_queue *queue = &inet_csk (sk)->icsk_accept_queue;const char *msg ="Dropping request" ;
@@ -6444,7 +6442,7 @@ static bool tcp_syn_flood_action(const struct sock *sk, net->ipv4.sysctl_tcp_syncookies != 2 && xchg(&queue->synflood_warned, 1) == 0)net_info_ratelimited ("%s: Possible SYN flooding on port %d. %s. Check SNMP counters.\n" , - proto,ntohs (tcp_hdr (skb)->dest), msg); + proto, sk->sk_num, msg);return want_cookie; }
@@ -6487,7 +6485,7 @@ int tcp_conn_request(struct request_sock_ops *rsk_ops,*/ if ((net->ipv4.sysctl_tcp_syncookies ==2 ||inet_csk_reqsk_queue_is_full (sk)) && !isn) { - want_cookie =tcp_syn_flood_action (sk, skb, rsk_ops->slab_name); + want_cookie =tcp_syn_flood_action (sk, rsk_ops->slab_name);if (!want_cookie) goto drop; }
Signature · 1 line
2.22.0.709.g102302147b-goog
PATCH v2 2/6 tcp: add skb-less helpers to retrieve SYN cookie
In reply to Petar PenkovFrom: Petar Penkov <[email protected]>
This patch allows generation of a SYN cookie before an SKB has been allocated, as is the case at XDP.
--- include/net/tcp.h | 10 ++++++ net/ipv4/tcp_input.c | 73 ++++++++++++++++++++++++++++++++++++++++++++ net/ipv4/tcp_ipv4.c | 15 +++++++++ net/ipv6/tcp_ipv6.c | 15 +++++++++ 4 files changed, 113 insertions(+)
include/net/tcp.h +10 -0
@@ -414,6 +414,16 @@ void tcp_parse_options(const struct net *net, const struct sk_buff *skb, int estab, struct tcp_fastopen_cookie *foc);const u8 *tcp_parse_md5sig_option (const struct tcphdr *th); +/* +* BPF SKB-less helpers +*/ +u16 tcp_v4_get_syncookie (struct sock *sk,struct iphdr *iph, +struct tcphdr *th,u32 *cookie); +u16 tcp_v6_get_syncookie (struct sock *sk,struct ipv6hdr *iph, +struct tcphdr *th,u32 *cookie); +u16 tcp_get_syncookie_mss (struct request_sock_ops *rsk_ops, +const struct tcp_request_sock_ops *af_ops, +struct sock *sk,struct tcphdr *th);/* * TCP v4 functions exported for the inet6 API */
net/ipv4/tcp_input.c +73 -0
85 lines not on this page · raw message
net/ipv4/tcp_ipv4.c +15 -0
@@ -1515,6 +1515,21 @@ static struct sock *tcp_v4_cookie_check(struct sock *sk, struct sk_buff *skb)return sk; } +u16 tcp_v4_get_syncookie (struct sock *sk,struct iphdr *iph, +struct tcphdr *th,u32 *cookie) +{ +u16 mss =0 ; +#ifdef CONFIG_SYN_COOKIES + mss =tcp_get_syncookie_mss (&tcp_request_sock_ops, + &tcp_request_sock_ipv4_ops, sk, th); +if (mss) { + *cookie =__cookie_v4_init_sequence (iph, th, &mss); +tcp_synq_overflow (sk); + } +#endif +return mss; +} +/* The socket must have it's spinlock held when we get * here, unless it is a TCP_LISTEN socket. *
net/ipv6/tcp_ipv6.c +15 -0
@@ -1063,6 +1063,21 @@ static struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb)return sk; } +u16 tcp_v6_get_syncookie (struct sock *sk,struct ipv6hdr *iph, +struct tcphdr *th,u32 *cookie) +{ +u16 mss =0 ; +#ifdef CONFIG_SYN_COOKIES + mss =tcp_get_syncookie_mss (&tcp6_request_sock_ops, + &tcp_request_sock_ipv6_ops, sk, th); +if (mss) { + *cookie =__cookie_v6_init_sequence (iph, th, &mss); +tcp_synq_overflow (sk); + } +#endif +return mss; +} +static int tcp_v6_conn_request (struct sock *sk,struct sk_buff *skb) {if (skb->protocol ==htons (ETH_P_IP ))
Signature · 1 line
2.22.0.709.g102302147b-goog
PATCH v2 5/6 selftests/bpf: bpf_tcp_gen_syncookie->bpf_helpers
In reply to Petar PenkovFrom: Petar Penkov <[email protected]>
Expose bpf_tcp_gen_syncookie to selftests.
--- tools/testing/selftests/bpf/bpf_helpers.h | 3 +++ 1 file changed, 3 insertions(+)
tools/testing/selftests/bpf/bpf_helpers.h +3 -0
@@ -228,6 +228,9 @@ static void *(*bpf_sk_storage_get)(void *map, struct bpf_sock *sk,static int (*bpf_sk_storage_delete)(void *map,struct bpf_sock *sk) = (void *)BPF_FUNC_sk_storage_delete;static int (*bpf_send_signal)(unsigned sig) = (void *)BPF_FUNC_send_signal; +static long long (*bpf_tcp_gen_syncookie)(struct bpf_sock *sk,void *ip, +int ip_len,void *tcp,int tcp_len) = + (void *) BPF_FUNC_tcp_gen_syncookie;/* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions
Signature · 1 line
2.22.0.709.g102302147b-goog
PATCH v2 4/6 bpf: sync bpf.h to tools/
In reply to Petar PenkovFrom: Petar Penkov <[email protected]>
Sync updated documentation for bpf_redirect_map.
Sync the bpf_tcp_gen_syncookie helper function definition with the one in tools/uapi.
--- tools/include/uapi/linux/bpf.h | 37 +++++++++++++++++++++++++++++++--- 1 file changed, 34 insertions(+), 3 deletions(-)
tools/include/uapi/linux/bpf.h +34 -3
@@ -1571,8 +1571,11 @@ union bpf_attr {* but this is only implemented for native XDP (with driver * support) as of this writing). * -* All values for *flags* are reserved for future usage, and must -* be left at zero. +* The lower two bits of *flags* are used as the return code if +* the map lookup fails. This is so that the return value can be +* one of the XDP program return codes up to XDP_TX, as chosen by +* the caller. Any higher bits in the *flags* argument must be +* unset. * * When used to redirect packets to net devices, this helper * provides a high performance increase over **bpf_redirect**\ ().
@@ -2710,6 +2713,33 @@ union bpf_attr {* **-EPERM** if no permission to send the *sig*. * * **-EAGAIN** if bpf program can try again. +* +* s64 bpf_tcp_gen_syncookie(struct bpf_sock *sk, void *iph, u32 iph_len, struct tcphdr *th, u32 th_len) +* Description +* Try to issue a SYN cookie for the packet with corresponding +* IP/TCP headers, *iph* and *th*, on the listening socket in *sk*. +* +* *iph* points to the start of the IPv4 or IPv6 header, while +* *iph_len* contains **sizeof**\ (**struct iphdr**) or +* **sizeof**\ (**struct ip6hdr**). +* +* *th* points to the start of the TCP header, while *th_len* +* contains the length of the TCP header. +* +* Return +* On success, lower 32 bits hold the generated SYN cookie in +* followed by 16 bits which hold the MSS value for that cookie, +* and the top 16 bits are unused. +* +* On failure, the returned value is one of the following: +* +* **-EINVAL** SYN cookie cannot be issued due to error +* +* **-ENOENT** SYN cookie should not be issued (no SYN flood) +* +* **-EOPNOTSUPP** kernel configuration does not enable SYN cookies +* +* **-EPROTONOSUPPORT** IP packet version is not 4 or 6 */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -2821,7 +2851,8 @@ union bpf_attr {FN (strtoul), \FN (sk_storage_get), \FN (sk_storage_delete), \ -FN (send_signal), +FN (send_signal), \ +FN (tcp_gen_syncookie),/* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call
Signature · 1 line
2.22.0.709.g102302147b-goog
PATCH v2 6/6 selftests/bpf: add test for bpf_tcp_gen_syncookie
In reply to Petar PenkovFrom: Petar Penkov <[email protected]>
Modify the existing bpf_tcp_check_syncookie test to also generate a SYN cookie, pass the packet to the kernel, and verify that the two cookies are the same (and both valid). Since cloned SKBs are skipped during generic XDP, this test does not issue a SYN cookie when run in XDP mode. We therefore only check that a valid SYN cookie was issued at the TC hook.
Additionally, verify that the MSS for that SYN cookie is within expected range.
--- .../bpf/progs/test_tcp_check_syncookie_kern.c | 48 +++++++++++++-- .../selftests/bpf/test_tcp_check_syncookie.sh | 3 + .../bpf/test_tcp_check_syncookie_user.c | 61 ++++++++++++++++--- 3 files changed, 99 insertions(+), 13 deletions(-)
tools/testing/selftests/bpf/progs/test_tcp_check_syncookie_kern.c +43 -5
@@ -19,10 +19,29 @@ struct bpf_map_def SEC("maps") results = { .type = BPF_MAP_TYPE_ARRAY, .key_size = sizeof(__u32), - .value_size = sizeof(__u64), - .max_entries = 1, + .value_size = sizeof(__u32), + .max_entries = 3, }; +static __always_inline __s64 gen_syncookie(void *data_end, struct bpf_sock *sk, +void *iph,__u32 ip_size, +struct tcphdr *tcph) +{ +__u32 thlen = tcph->doff *4 ; + +if (tcph->syn && !tcph->ack) { +// packet should only have an MSS option +if (thlen !=24 ) +return 0 ; + +if ((void *)tcph + thlen > data_end) +return 0 ; + +return bpf_tcp_gen_syncookie (sk, iph, ip_size, tcph, thlen); + } +return 0 ; +} + static __always_inline void check_syncookie(void *ctx, void *data,void *data_end) {
@@ -33,8 +52,10 @@ static __always_inline void check_syncookie(void *ctx, void *data,struct ipv6hdr *ipv6h;struct tcphdr *tcph;int ret; +__u32 key_mss =2 ; +__u32 key_gen =1 ;__u32 key =0 ; -__u64 value =1 ; +__s64 seq_mss; ethh = data;if (ethh +1 > data_end)
@@ -66,6 +87,9 @@ static __always_inline void check_syncookie(void *ctx, void *data,if (sk->state !=BPF_TCP_LISTEN ) goto release; + seq_mss =gen_syncookie (data_end, sk, ipv4h,sizeof (*ipv4h), + tcph); + ret =bpf_tcp_check_syncookie (sk, ipv4h,sizeof (*ipv4h), tcph,sizeof (*tcph));break ;
@@ -95,6 +119,9 @@ static __always_inline void check_syncookie(void *ctx, void *data,if (sk->state !=BPF_TCP_LISTEN ) goto release; + seq_mss =gen_syncookie (data_end, sk, ipv6h,sizeof (*ipv6h), + tcph); + ret =bpf_tcp_check_syncookie (sk, ipv6h,sizeof (*ipv6h), tcph,sizeof (*tcph));break ;
@@ -103,8 +130,19 @@ static __always_inline void check_syncookie(void *ctx, void *data,return ; } -if (ret ==0 ) -bpf_map_update_elem (&results, &key, &value,0 ); +if (seq_mss >0 ) { +__u32 cookie = (__u32 )seq_mss; +__u32 mss = seq_mss >>32 ; + +bpf_map_update_elem (&results, &key_gen, &cookie,0 ); +bpf_map_update_elem (&results, &key_mss, &mss,0 ); + } + +if (ret ==0 ) { +__u32 cookie =bpf_ntohl (tcph->ack_seq) -1 ; + +bpf_map_update_elem (&results, &key, &cookie,0 ); + } release:bpf_sk_release (sk);
tools/testing/selftests/bpf/test_tcp_check_syncookie.sh +3 -0
@@ -37,6 +37,9 @@ setup() ns1_exec ip link set lo up ns1_exec sysctl -w net.ipv4.tcp_syncookies=2 + ns1_exec sysctl -w net.ipv4.tcp_window_scaling=0 + ns1_exec sysctl -w net.ipv4.tcp_timestamps=0 + ns1_exec sysctl -w net.ipv4.tcp_sack=0 wait_for_ip 127.0.0.1 wait_for_ip ::1
tools/testing/selftests/bpf/test_tcp_check_syncookie_user.c +53 -8
121 lines not on this page · raw message
Signature · 1 line
2.22.0.709.g102302147b-goog
PATCH v2 3/6 bpf: add bpf_tcp_gen_syncookie helper
In reply to Petar PenkovFrom: Petar Penkov <[email protected]>
This helper function allows BPF programs to try to generate SYN cookies, given a reference to a listener socket. The function works from XDP and with an skb context since bpf_skc_lookup_tcp can lookup a socket in both cases.
--- include/uapi/linux/bpf.h | 30 ++++++++++++++++- net/core/filter.c | 73 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 102 insertions(+), 1 deletion(-)
include/uapi/linux/bpf.h +29 -1
@@ -2713,6 +2713,33 @@ union bpf_attr {* **-EPERM** if no permission to send the *sig*. * * **-EAGAIN** if bpf program can try again. +* +* s64 bpf_tcp_gen_syncookie(struct bpf_sock *sk, void *iph, u32 iph_len, struct tcphdr *th, u32 th_len) +* Description +* Try to issue a SYN cookie for the packet with corresponding +* IP/TCP headers, *iph* and *th*, on the listening socket in *sk*. +* +* *iph* points to the start of the IPv4 or IPv6 header, while +* *iph_len* contains **sizeof**\ (**struct iphdr**) or +* **sizeof**\ (**struct ip6hdr**). +* +* *th* points to the start of the TCP header, while *th_len* +* contains the length of the TCP header. +* +* Return +* On success, lower 32 bits hold the generated SYN cookie in +* followed by 16 bits which hold the MSS value for that cookie, +* and the top 16 bits are unused. +* +* On failure, the returned value is one of the following: +* +* **-EINVAL** SYN cookie cannot be issued due to error +* +* **-ENOENT** SYN cookie should not be issued (no SYN flood) +* +* **-EOPNOTSUPP** kernel configuration does not enable SYN cookies +* +* **-EPROTONOSUPPORT** IP packet version is not 4 or 6 */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -2824,7 +2851,8 @@ union bpf_attr {FN (strtoul), \FN (sk_storage_get), \FN (sk_storage_delete), \ -FN (send_signal), +FN (send_signal), \ +FN (tcp_gen_syncookie),/* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call
net/core/filter.c +73 -0
91 lines not on this page · raw message
Signature · 1 line
2.22.0.709.g102302147b-goog
Quoted 16 lines · Petar Penkov
From: Petar Penkov <[email protected]>
This patch series introduces a BPF helper function that allows generating SYN cookies from BPF. Currently, this helper is enabled at both the TC hook and the XDP hook.
The first two patches in the series add/modify several TCP helper functions to allow for SKB-less operation, as is the case at the XDP hook.
The third patch introduces the
bpf_tcp_gen_syncookiehelper function which generates a SYN cookie for either XDP or TC programs. The return value of this function contains both the MSS value, encoded in the cookie, and the cookie itself.The last three patches sync
tools/and add a test.
Quoted 8 lines
Performance evaluation:
I sent 10Mpps to a fixed port on a host with 2 10G bonded Mellanox 4 NICs from random IPv6 source addresses. Without XDP I observed 7.2Mpps (syn-acks) being sent out if the IPv6 packets carry 20 bytes of TCP options or 7.6Mpps if they carry no options. If I attached a simple program that checks if a packet is IPv6/TCP/SYN, looks up the socket, issues a cookie, and sends it back out after swapping src/dest, recomputing the checksum, and setting the ACK flag, I observed 10Mpps being sent back out.
Is it 10m because trafic gen is 10m?
What is cpu utilization at this rate?
Is it cpu or nic limited if you crank up the syn flood? Original 7M with all cores or single core?
The patch set looks good to me.
I'd like Eric to review it one more time before applying.
Quoted 18 lines · Alexei Starovoitov
Quoted 16 lines · Petar Penkov
From: Petar Penkov <[email protected]>
This patch series introduces a BPF helper function that allows generating SYN cookies from BPF. Currently, this helper is enabled at both the TC hook and the XDP hook.
The first two patches in the series add/modify several TCP helper functions to allow for SKB-less operation, as is the case at the XDP hook.
The third patch introduces the
bpf_tcp_gen_syncookiehelper function which generates a SYN cookie for either XDP or TC programs. The return value of this function contains both the MSS value, encoded in the cookie, and the cookie itself.The last three patches sync
tools/and add a test.
Quoted 9 lines
Quoted 8 lines
Performance evaluation:
I sent 10Mpps to a fixed port on a host with 2 10G bonded Mellanox 4 NICs from random IPv6 source addresses. Without XDP I observed 7.2Mpps (syn-acks) being sent out if the IPv6 packets carry 20 bytes of TCP options or 7.6Mpps if they carry no options. If I attached a simple program that checks if a packet is IPv6/TCP/SYN, looks up the socket, issues a cookie, and sends it back out after swapping src/dest, recomputing the checksum, and setting the ACK flag, I observed 10Mpps being sent back out.
Thank you for reviewing this so quickly!
Quoted 1 line
Is it 10m because trafic gen is 10m?
Yes, I believe so.
Quoted 3 lines
What is cpu utilization at this rate?
Is it cpu or nic limited if you crank up the syn flood? Original 7M with all cores or single core?
My receiver was configured with 16rx queues and 16 cores. 7M all cores are at 100% so I believe this case is CPU limited. At XDP, all cores are at roughly 40%. I couldn't reliably generate higher SYN flood rate than that, and the highest numbers I could see for XDP did not go past 10.65Mpps with ~42% utilization on each core. I think I am hitting a NIC limit here since the CPUs are free.
Quoted 4 lines
The patch set looks good to me.
I'd like Eric to review it one more time before applying.
Alexei Starovoitov
AppliedQuoted 10 lines · Petar Penkov
Quoted 4 lines
What is cpu utilization at this rate?
Is it cpu or nic limited if you crank up the syn flood? Original 7M with all cores or single core?My receiver was configured with 16rx queues and 16 cores. 7M all cores are at 100% so I believe this case is CPU limited. At XDP, all cores are at roughly 40%. I couldn't reliably generate higher SYN flood rate than that, and the highest numbers I could see for XDP did not go past 10.65Mpps with ~42% utilization on each core. I think I am hitting a NIC limit here since the CPUs are free.
Applied. Thanks!