add TFO backup key
Subsystems (5)
v2 cover add TFO backup key
Hi,
Christoph, Igor, and I have worked on an API that facilitates TFO key rotation. This is a follow up to the series that Christoph previously posted, with an API that meets both of our use-cases. Here's a link to the previous work:
https://patchwork.ozlabs.org/cover/1013753/
Thanks,
-Jason
Changes in v2:
-spelling fixes in ip-sysctl.txt (Jeremy Sowden) -re-base to latest net-next
Christoph Paasch (1):
tcp: introduce __tcp_fastopen_cookie_gen_cipher()
Jason Baron (5):
tcp: add backup TFO key infrastructure
tcp: add support to TCP_FASTOPEN_KEY for optional backup key
tcp: add support for optional TFO backup key to
net.ipv4.tcp_fastopen_key
Documentation: ip-sysctl.txt: Document tcp_fastopen_key selftests/net: add TFO key rotation selftest
Documentation/networking/ip-sysctl.txt | 20 ++ include/net/tcp.h | 41 ++- include/uapi/linux/snmp.h | 1 + net/ipv4/proc.c | 1 + net/ipv4/sysctl_net_ipv4.c | 93 ++++-- net/ipv4/tcp.c | 29 +- net/ipv4/tcp_fastopen.c | 233 +++++++++----- tools/testing/selftests/net/.gitignore | 1 + tools/testing/selftests/net/Makefile | 2 + .../selftests/net/tcp_fastopen_backup_key.c | 336 +++++++++++++++++++++ .../selftests/net/tcp_fastopen_backup_key.sh | 55 ++++ 11 files changed, 694 insertions(+), 118 deletions(-) create mode 100644 tools/testing/selftests/net/tcp_fastopen_backup_key.c create mode 100755 tools/testing/selftests/net/tcp_fastopen_backup_key.sh
Signature · 1 line
2.7.4
PATCH v2 1/6 tcp: introduce __tcp_fastopen_cookie_gen_cipher()
From: Christoph Paasch <[email protected]>
Restructure __tcp_fastopen_cookie_gen() to take a 'struct crypto_cipher' argument and rename it as __tcp_fastopen_cookie_gen_cipher(). Subsequent patches will provide different ciphers based on which key is being used for the cookie generation.
--- net/ipv4/tcp_fastopen.c | 73 +++++++++++++++++++++++++------------------------ 1 file changed, 37 insertions(+), 36 deletions(-)
net/ipv4/tcp_fastopen.c +37 -36
@@ -111,25 +111,38 @@ error: kfree(ctx);return err; } -static bool __tcp_fastopen_cookie_gen (struct sock *sk,const void *path, -struct tcp_fastopen_cookie *foc) +static bool __tcp_fastopen_cookie_gen_cipher (struct request_sock *req, +struct sk_buff *syn, +struct crypto_cipher *tfm, +struct tcp_fastopen_cookie *foc) { -struct tcp_fastopen_context *ctx; -bool ok = false; - -rcu_read_lock (); +if (req->rsk_ops->family ==AF_INET ) { +const struct iphdr *iph =ip_hdr (syn); +__be32 path[4 ] = { iph->saddr, iph->daddr,0 ,0 }; - ctx =rcu_dereference (inet_csk (sk)->icsk_accept_queue.fastopenq.ctx); -if (!ctx) - ctx =rcu_dereference (sock_net (sk)->ipv4.tcp_fastopen_ctx); +crypto_cipher_encrypt_one (tfm, foc->val, (void *)path); + foc->len =TCP_FASTOPEN_COOKIE_SIZE ; +return true; + } -if (ctx) { -crypto_cipher_encrypt_one (ctx->tfm, foc->val, path); +#if IS_ENABLED (CONFIG_IPV6 ) +if (req->rsk_ops->family ==AF_INET6 ) { +const struct ipv6hdr *ip6h =ipv6_hdr (syn); +struct tcp_fastopen_cookie tmp; +struct in6_addr *buf; +int i; + +crypto_cipher_encrypt_one (tfm, tmp.val, + (void *)&ip6h->saddr); + buf = &tmp.addr; +for (i =0 ; i <4 ; i++) + buf->s6_addr32[i] ^= ip6h->daddr.s6_addr32[i]; +crypto_cipher_encrypt_one (tfm, foc->val, (void *)buf); foc->len =TCP_FASTOPEN_COOKIE_SIZE ; - ok = true; +return true; } -rcu_read_unlock (); -return ok; +#endif +return false; }/* Generate the fastopen cookie by doing aes128 encryption on both
@@ -143,29 +156,17 @@ static bool tcp_fastopen_cookie_gen(struct sock *sk,struct sk_buff *syn, struct tcp_fastopen_cookie *foc) { -if (req->rsk_ops->family ==AF_INET ) { -const struct iphdr *iph =ip_hdr (syn); - -__be32 path[4 ] = { iph->saddr, iph->daddr,0 ,0 }; -return __tcp_fastopen_cookie_gen (sk, path, foc); - } - -#if IS_ENABLED (CONFIG_IPV6 ) -if (req->rsk_ops->family ==AF_INET6 ) { -const struct ipv6hdr *ip6h =ipv6_hdr (syn); -struct tcp_fastopen_cookie tmp; - -if (__tcp_fastopen_cookie_gen (sk, &ip6h->saddr, &tmp)) { -struct in6_addr *buf = &tmp.addr; -int i; + struct tcp_fastopen_context *ctx; +bool ok = false; -for (i =0 ; i <4 ; i++) - buf->s6_addr32[i] ^= ip6h->daddr.s6_addr32[i]; -return __tcp_fastopen_cookie_gen (sk, buf, foc); - } - } -#endif -return false; +rcu_read_lock (); + ctx =rcu_dereference (inet_csk (sk)->icsk_accept_queue.fastopenq.ctx); +if (!ctx) + ctx =rcu_dereference (sock_net (sk)->ipv4.tcp_fastopen_ctx); +if (ctx) + ok =__tcp_fastopen_cookie_gen_cipher (req, syn, ctx->tfm, foc); +rcu_read_unlock (); +return ok; }
Signature · 1 line
2.7.4
PATCH v2 2/6 tcp: add backup TFO key infrastructure
In reply to Jason BaronWe would like to be able to rotate TFO keys while minimizing the number of client cookies that are rejected. Currently, we have only one key which can be used to generate and validate cookies, thus if we simply replace this key clients can easily have cookies rejected upon rotation.
We propose having the ability to have both a primary key and a backup key. The primary key is used to generate as well as to validate cookies. The backup is only used to validate cookies. Thus, keys can be rotated as:
1) generate new key
2) add new key as the backup key
3) swap the primary and backup key, thus setting the new key as the primary
We don't simply set the new key as the primary key and move the old key to the backup slot because the ip may be behind a load balancer and we further allow for the fact that all machines behind the load balancer will not be updated simultaneously.
We make use of this infrastructure in subsequent patches.
--- include/net/tcp.h | 41 ++++++++++- include/uapi/linux/snmp.h | 1 + net/ipv4/proc.c | 1 + net/ipv4/sysctl_net_ipv4.c | 2 +- net/ipv4/tcp.c | 3 +- net/ipv4/tcp_fastopen.c | 172 +++++++++++++++++++++++++++++++-------------- 6 files changed, 162 insertions(+), 58 deletions(-)
include/net/tcp.h +38 -3
@@ -1614,7 +1614,8 @@ void tcp_free_fastopen_req(struct tcp_sock *tp);void tcp_fastopen_destroy_cipher (struct sock *sk);void tcp_fastopen_ctx_destroy (struct net *net);int tcp_fastopen_reset_cipher (struct net *net,struct sock *sk, -void *key,unsigned int len); +void *primary_key,void *backup_key, +unsigned int len);void tcp_fastopen_add_skb (struct sock *sk,struct sk_buff *skb); struct sock *tcp_try_fastopen(struct sock *sk, struct sk_buff *skb, struct request_sock *req,
@@ -1625,11 +1626,14 @@ bool tcp_fastopen_cookie_check(struct sock *sk, u16 *mss, struct tcp_fastopen_cookie *cookie);bool tcp_fastopen_defer_connect (struct sock *sk,int *err);#define TCP_FASTOPEN_KEY_LENGTH 16 +#define TCP_FASTOPEN_KEY_MAX 2 +#define TCP_FASTOPEN_KEY_BUF_LENGTH \ + (TCP_FASTOPEN_KEY_LENGTH * TCP_FASTOPEN_KEY_MAX)/* Fastopen key context */ struct tcp_fastopen_context { -struct crypto_cipher *tfm; -__u8 key[TCP_FASTOPEN_KEY_LENGTH ]; +struct crypto_cipher *tfm[TCP_FASTOPEN_KEY_MAX ]; +__u8 key[TCP_FASTOPEN_KEY_BUF_LENGTH ];struct rcu_head rcu; };
@@ -1639,6 +1643,37 @@ bool tcp_fastopen_active_should_disable(struct sock *sk);void tcp_fastopen_active_disable_ofo_check (struct sock *sk);void tcp_fastopen_active_detect_blackhole (struct sock *sk,bool expired); +/* Caller needs to wrap with rcu_read_(un)lock() */ +static inline +struct tcp_fastopen_context *tcp_fastopen_get_ctx (const struct sock *sk) +{ +struct tcp_fastopen_context *ctx; + + ctx =rcu_dereference (inet_csk (sk)->icsk_accept_queue.fastopenq.ctx); +if (!ctx) + ctx =rcu_dereference (sock_net (sk)->ipv4.tcp_fastopen_ctx); +return ctx; +} + +static inline +bool tcp_fastopen_cookie_match (const struct tcp_fastopen_cookie *foc, +const struct tcp_fastopen_cookie *orig) +{ +if (orig->len ==TCP_FASTOPEN_COOKIE_SIZE && + orig->len == foc->len && + !memcmp (orig->val, foc->val, foc->len)) +return true; +return false; +} + +static inline +int tcp_fastopen_context_len (const struct tcp_fastopen_context *ctx) +{ +if (ctx->tfm[1 ]) +return 2 ; +return 1 ; +} +/* Latencies incurred by various limits for a sender. They are * chronograph-like stats that are mutually exclusive. */
include/uapi/linux/snmp.h +1 -0
@@ -283,6 +283,7 @@ enumLINUX_MIB_TCPACKCOMPRESSED ,/* TCPAckCompressed */ LINUX_MIB_TCPZEROWINDOWDROP ,/* TCPZeroWindowDrop */ LINUX_MIB_TCPRCVQDROP ,/* TCPRcvQDrop */ +LINUX_MIB_TCPFASTOPENPASSIVEALTKEY ,/* TCPFastOpenPassiveAltKey */ __LINUX_MIB_MAX };
net/ipv4/proc.c +1 -0
@@ -291,6 +291,7 @@ static const struct snmp_mib snmp4_net_list[] = {SNMP_MIB_ITEM ("TCPAckCompressed" ,LINUX_MIB_TCPACKCOMPRESSED ),SNMP_MIB_ITEM ("TCPZeroWindowDrop" ,LINUX_MIB_TCPZEROWINDOWDROP ),SNMP_MIB_ITEM ("TCPRcvQDrop" ,LINUX_MIB_TCPRCVQDROP ), +SNMP_MIB_ITEM ("TCPFastOpenPassiveAltKey" ,LINUX_MIB_TCPFASTOPENPASSIVEALTKEY ), SNMP_MIB_SENTINEL };
net/ipv4/sysctl_net_ipv4.c +1 -1
@@ -318,7 +318,7 @@ static int proc_tcp_fastopen_key(struct ctl_table *table, int write,for (i =0 ; i <ARRAY_SIZE (user_key); i++) key[i] =cpu_to_le32 (user_key[i]); -tcp_fastopen_reset_cipher (net,NULL , key, +tcp_fastopen_reset_cipher (net,NULL , key,NULL ,TCP_FASTOPEN_KEY_LENGTH ); }
net/ipv4/tcp.c +2 -1
@@ -2798,7 +2798,8 @@ static int do_tcp_setsockopt(struct sock *sk, int level,if (copy_from_user (key, optval, optlen))return -EFAULT ; -return tcp_fastopen_reset_cipher (net, sk, key,sizeof (key)); +return tcp_fastopen_reset_cipher (net, sk, key,NULL , +sizeof (key)); }default :/* fallthru */
net/ipv4/tcp_fastopen.c +119 -53
240 lines not on this page · raw message
Signature · 1 line
2.7.4
PATCH v2 3/6 tcp: add support to TCP_FASTOPEN_KEY for optional backup key
In reply to Jason BaronAdd support for get/set of an optional backup key via TCP_FASTOPEN_KEY, in addition to the current 'primary' key. The primary key is used to encrypt and decrypt TFO cookies, while the backup is only used to decrypt TFO cookies. The backup key is used to maximize successful TFO connections when TFO keys are rotated.
Currently, TCP_FASTOPEN_KEY allows a single 16-byte primary key to be set. This patch now allows a 32-byte value to be set, where the first 16 bytes are used as the primary key and the second 16 bytes are used for the backup key. Similarly, for getsockopt(), we can receive a 32-byte value as output if requested. If a 16-byte value is used to set the primary key via TCP_FASTOPEN_KEY, then any previously set backup key will be removed.
--- net/ipv4/tcp.c | 30 ++++++++++++++++++++---------- 1 file changed, 20 insertions(+), 10 deletions(-)
net/ipv4/tcp.c +20 -10
@@ -2790,16 +2790,24 @@ static int do_tcp_setsockopt(struct sock *sk, int level,return err; }case TCP_FASTOPEN_KEY : { -__u8 key[TCP_FASTOPEN_KEY_LENGTH ]; +__u8 key[TCP_FASTOPEN_KEY_BUF_LENGTH ]; +__u8 *backup_key =NULL ; -if (optlen !=sizeof (key)) +/* Allow a backup key as well to facilitate key rotation +* First key is the active one. +*/ +if (optlen !=TCP_FASTOPEN_KEY_LENGTH && + optlen !=TCP_FASTOPEN_KEY_BUF_LENGTH )return -EINVAL ;if (copy_from_user (key, optval, optlen))return -EFAULT ; -return tcp_fastopen_reset_cipher (net, sk, key,NULL , -sizeof (key)); +if (optlen ==TCP_FASTOPEN_KEY_BUF_LENGTH ) + backup_key = key +TCP_FASTOPEN_KEY_LENGTH ; + +return tcp_fastopen_reset_cipher (net, sk, key, backup_key, +TCP_FASTOPEN_KEY_LENGTH ); }default :/* fallthru */
@@ -3453,21 +3461,23 @@ static int do_tcp_getsockopt(struct sock *sk, int level,return 0 ;case TCP_FASTOPEN_KEY : { -__u8 key[TCP_FASTOPEN_KEY_LENGTH ]; +__u8 key[TCP_FASTOPEN_KEY_BUF_LENGTH ];struct tcp_fastopen_context *ctx; +unsigned int key_len =0 ;if (get_user (len, optlen))return -EFAULT ;rcu_read_lock (); ctx =rcu_dereference (icsk->icsk_accept_queue.fastopenq.ctx); -if (ctx) -memcpy (key, ctx->key,sizeof (key)); -else - len =0 ; +if (ctx) { + key_len =tcp_fastopen_context_len (ctx) * +TCP_FASTOPEN_KEY_LENGTH ; +memcpy (&key[0 ], &ctx->key[0 ], key_len); + }rcu_read_unlock (); - len = min_t(unsigned int, len, sizeof(key)); + len = min_t(unsigned int, len, key_len);if (put_user (len, optlen))return -EFAULT ;if (copy_to_user (optval, key, len))
Signature · 1 line
2.7.4
PATCH v2 4/6 tcp: add support for optional TFO backup key to net.ipv4.tcp_fastopen_key
In reply to Jason BaronAdd the ability to add a backup TFO key as:
# echo "x-x-x-x,x-x-x-x" > /proc/sys/net/ipv4/tcp_fastopen_key
The key before the comma acks as the primary TFO key and the key after the comma is the backup TFO key. This change is intended to be backwards compatible since if only one key is set, userspace will simply read back that single key as follows:
# echo "x-x-x-x" > /proc/sys/net/ipv4/tcp_fastopen_key # cat /proc/sys/net/ipv4/tcp_fastopen_key x-x-x-x
--- net/ipv4/sysctl_net_ipv4.c | 95 ++++++++++++++++++++++++++++++++++------------ 1 file changed, 71 insertions(+), 24 deletions(-)
net/ipv4/sysctl_net_ipv4.c +71 -24
@@ -277,55 +277,97 @@ static int proc_allowed_congestion_control(struct ctl_table *ctl,return ret; } +static int sscanf_key (char *buf,__le32 *key) +{ +u32 user_key[4 ]; +int i, ret =0 ; + +if (sscanf (buf,"%x-%x-%x-%x" , user_key, user_key +1 , + user_key +2 , user_key +3 ) !=4 ) { + ret = -EINVAL ; + }else { +for (i =0 ; i <ARRAY_SIZE (user_key); i++) + key[i] =cpu_to_le32 (user_key[i]); + } +pr_debug ("proc TFO key set 0x%x-%x-%x-%x <- 0x%s: %u\n" , + user_key[0 ], user_key[1 ], user_key[2 ], user_key[3 ], buf, ret); + +return ret; +} +static int proc_tcp_fastopen_key (struct ctl_table *table,int write,void __user *buffer,size_t *lenp,loff_t *ppos) { struct net *net = container_of(table->data, struct net, ipv4.sysctl_tcp_fastopen); -struct ctl_table tbl = { .maxlen = (TCP_FASTOPEN_KEY_LENGTH *2 +10 ) }; -struct tcp_fastopen_context *ctxt; -u32 user_key[4 ];/* 16 bytes, matching TCP_FASTOPEN_KEY_LENGTH */ -__le32 key[4 ]; -int ret, i; +/* maxlen to print the list of keys in hex (*2), with dashes +* separating doublewords and a comma in between keys. +*/ +struct ctl_table tbl = { .maxlen = ((TCP_FASTOPEN_KEY_LENGTH * +2 *TCP_FASTOPEN_KEY_MAX ) + + (TCP_FASTOPEN_KEY_MAX *5 )) }; +struct tcp_fastopen_context *ctx; +u32 user_key[TCP_FASTOPEN_KEY_MAX *4 ]; +__le32 key[TCP_FASTOPEN_KEY_MAX *4 ]; +char *backup_data; +int ret, i =0 , off =0 , n_keys =0 ; tbl.data =kmalloc (tbl.maxlen,GFP_KERNEL );if (!tbl.data)return -ENOMEM ;rcu_read_lock (); - ctxt =rcu_dereference (net->ipv4.tcp_fastopen_ctx); -if (ctxt) -memcpy (key, ctxt->key,TCP_FASTOPEN_KEY_LENGTH ); -else -memset (key,0 ,sizeof (key)); + ctx =rcu_dereference (net->ipv4.tcp_fastopen_ctx); +if (ctx) { + n_keys =tcp_fastopen_context_len (ctx); +memcpy (&key[0 ], &ctx->key[0 ],TCP_FASTOPEN_KEY_LENGTH * n_keys); + }rcu_read_unlock (); -for (i =0 ; i <ARRAY_SIZE (key); i++) +if (!n_keys) { +memset (&key[0 ],0 ,TCP_FASTOPEN_KEY_LENGTH ); + n_keys =1 ; + } + +for (i =0 ; i < n_keys *4 ; i++) user_key[i] =le32_to_cpu (key[i]); -snprintf (tbl.data, tbl.maxlen,"%08x-%08x-%08x-%08x" , - user_key[0 ], user_key[1 ], user_key[2 ], user_key[3 ]); +for (i =0 ; i < n_keys; i++) { + off +=snprintf (tbl.data + off, tbl.maxlen - off, +"%08x-%08x-%08x-%08x" , + user_key[i *4 ], + user_key[i *4 +1 ], + user_key[i *4 +2 ], + user_key[i *4 +3 ]); +if (i +1 < n_keys) + off +=snprintf (tbl.data + off, tbl.maxlen - off,"," ); + } + ret =proc_dostring (&tbl, write, buffer, lenp, ppos);if (write && ret ==0 ) { -if (sscanf (tbl.data,"%x-%x-%x-%x" , user_key, user_key +1 , - user_key +2 , user_key +3 ) !=4 ) { + backup_data =strchr (tbl.data,',' ); +if (backup_data) { + *backup_data ='\0' ; + backup_data++; + } +if (sscanf_key (tbl.data, key)) { ret = -EINVAL ; goto bad_key; } - -for (i =0 ; i <ARRAY_SIZE (user_key); i++) - key[i] =cpu_to_le32 (user_key[i]); - -tcp_fastopen_reset_cipher (net,NULL , key,NULL , +if (backup_data) { +if (sscanf_key (backup_data, key +4 )) { + ret = -EINVAL ; + goto bad_key; + } + } +tcp_fastopen_reset_cipher (net,NULL , key, + backup_data ? key +4 :NULL ,TCP_FASTOPEN_KEY_LENGTH ); } bad_key: -pr_debug ("proc FO key set 0x%x-%x-%x-%x <- 0x%s: %u\n" , - user_key[0 ], user_key[1 ], user_key[2 ], user_key[3 ], - (char *)tbl.data, ret);kfree (tbl.data);return ret; }
@@ -933,7 +975,12 @@ static struct ctl_table ipv4_net_table[] = { .procname = "tcp_fastopen_key", .mode = 0600, .data = &init_net.ipv4.sysctl_tcp_fastopen, - .maxlen = ((TCP_FASTOPEN_KEY_LENGTH * 2) + 10), +/* maxlen to print the list of keys in hex (*2), with dashes +* separating doublewords and a comma in between keys. +*/ + .maxlen = ((TCP_FASTOPEN_KEY_LENGTH * +2 *TCP_FASTOPEN_KEY_MAX ) + + (TCP_FASTOPEN_KEY_MAX * 5)), .proc_handler = proc_tcp_fastopen_key, }, {
Signature · 1 line
2.7.4
PATCH v2 5/6 Documentation: ip-sysctl.txt: Document tcp_fastopen_key
In reply to Jason BaronAdd docs for /proc/sys/net/ipv4/tcp_fastopen_key
--- Documentation/networking/ip-sysctl.txt | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+)
Documentation/networking/ip-sysctl.txt +20 -0
@@ -648,6 +648,26 @@ tcp_fastopen_blackhole_timeout_sec - INTEGER 0 to disable the blackhole detection. By default, it is set to 1hr. +tcp_fastopen_key - list of comma separated 32-digit hexadecimal INTEGERs + The list consists of a primary key and an optional backup key. The + primary key is used for both creating and validating cookies, while the + optional backup key is only used for validating cookies. The purpose of + the backup key is to maximize TFO validation when keys are rotated. + + A randomly chosen primary key may be configured by the kernel if + the tcp_fastopen sysctl is set to 0x400 (see above), or if the + TCP_FASTOPEN setsockopt() optname is set and a key has not been + previously configured via sysctl. If keys are configured via + setsockopt() by using the TCP_FASTOPEN_KEY optname, then those + per-socket keys will be used instead of any keys that are specified via + sysctl. + + A key is specified as 4 8-digit hexadecimal integers which are separated + by a '-' as: xxxxxxxx-xxxxxxxx-xxxxxxxx-xxxxxxxx. Leading zeros may be + omitted. A primary and a backup key may be specified by separating them + by a comma. If only one key is specified, it becomes the primary key and + any previously configured backup keys are removed. + tcp_syn_retries - INTEGER Number of times initial SYNs for an active TCP connection attempt will be retransmitted. Should not be higher than 127. Default value
Signature · 1 line
2.7.4
PATCH v2 6/6 selftests/net: add TFO key rotation selftest
In reply to Jason BaronDemonstrate how the primary and backup TFO keys can be rotated while minimizing the number of client cookies that are rejected.
--- tools/testing/selftests/net/.gitignore | 1 + tools/testing/selftests/net/Makefile | 2 + .../selftests/net/tcp_fastopen_backup_key.c | 336 +++++++++++++++++++++ .../selftests/net/tcp_fastopen_backup_key.sh | 55 ++++ 4 files changed, 394 insertions(+) create mode 100644 tools/testing/selftests/net/tcp_fastopen_backup_key.c create mode 100755 tools/testing/selftests/net/tcp_fastopen_backup_key.sh
tools/testing/selftests/net/.gitignore +1 -0
@@ -20,3 +20,4 @@ ip_defrag so_txtime flowlabel flowlabel_mgr +tcp_fastopen_backup_key
tools/testing/selftests/net/Makefile +2 -0
@@ -10,12 +10,14 @@ TEST_PROGS += fib_tests.sh fib-onlink-tests.sh pmtu.sh udpgso.sh ip_defrag.sh TEST_PROGS += udpgso_bench.sh fib_rule_tests.sh msg_zerocopy.sh psock_snd.sh TEST_PROGS += udpgro_bench.sh udpgro.sh test_vxlan_under_vrf.sh reuseport_addr_any.sh TEST_PROGS += test_vxlan_fdb_changelink.sh so_txtime.sh ipv6_flowlabel.sh +TEST_PROGS += tcp_fastopen_backup_key.sh TEST_PROGS_EXTENDED := in_netns.sh TEST_GEN_FILES = socket TEST_GEN_FILES += psock_fanout psock_tpacket msg_zerocopy reuseport_addr_any TEST_GEN_FILES += tcp_mmap tcp_inq psock_snd txring_overwrite TEST_GEN_FILES += udpgso udpgso_bench_tx udpgso_bench_rx ip_defrag TEST_GEN_FILES += so_txtime ipv6_flowlabel ipv6_flowlabel_mgr +TEST_GEN_FILES += tcp_fastopen_backup_key TEST_GEN_PROGS = reuseport_bpf reuseport_bpf_cpu reuseport_bpf_numa TEST_GEN_PROGS += reuseport_dualstack reuseaddr_conflict tls
tools/testing/selftests/net/tcp_fastopen_backup_key.c new file +336 -0
336 lines not on this page · raw message
tools/testing/selftests/net/tcp_fastopen_backup_key.sh new file +55 -0
55 lines not on this page · raw message
Signature · 1 line
2.7.4
David Miller
maintainerFrom: Jason Baron <[email protected]>
Date: Wed, 29 May 2019 12:33:55 -0400
Quoted 5 lines
Christoph, Igor, and I have worked on an API that facilitates TFO key rotation. This is a follow up to the series that Christoph previously posted, with an API that meets both of our use-cases. Here's a link to the previous work:
https://patchwork.ozlabs.org/cover/1013753/
...
Quoted 3 lines
Changes in v2:
-spelling fixes in ip-sysctl.txt (Jeremy Sowden) -re-base to latest net-next
Series applied, thank you.