net: fastopen: robustness and endianness fixes for SipHash

Some changes to the TCP fastopen code to make it more robust against future changes in the choice of key/cookie size, etc. - Instead of keeping the SipHash key in an untyped u8[] buffer and casting it to the right type upon use, use the correct type directly. This ensures that the key will appear at the correct alignment if we ever change the way these data structures are allocated. (Currently, they are only allocated via kmalloc so they always appear at the correct alignment) - Use DIV_ROUND_UP when sizing the u64[] array to hold the cookie, so it is always of sufficient size, even if TCP_FASTOPEN_COOKIE_MAX is no longer a multiple of 8. - Drop the 'len' parameter from the tcp_fastopen_reset_cipher() function, which is no longer used. - Add endian swabbing when setting the keys and calculating the hash, to ensure that cookie values are the same for a given key and source/destination address pair regardless of the endianness of the server. Note that none of these are functional changes wrt the current state of the code, with the exception of the swabbing, which only affects big endian systems.

Ard Biesheuvel committed 7 years ago

Commit 438ac881 parent 92ad6325 files · +24 −27Browse files

Unified · Split

5 files

include/linux/tcp.h +1 −1
include/net/tcp.h +4 −4
net/ipv4/sysctl_net_ipv4.c +1 −2
net/ipv4/tcp.c +1 −2
net/ipv4/tcp_fastopen.c +17 −18

include/linux/tcp.h+1−1

@@ -58,7 +58,7 @@ static inline unsigned int tcp_optlen(const struct sk_buff *skb) · 57 unmodified lines
58		58
59	/* TCP Fast Open Cookie as stored in memory */	59	/* TCP Fast Open Cookie as stored in memory */
60	struct tcp_fastopen_cookie {	60	struct tcp_fastopen_cookie {
61	u64 val[TCP_FASTOPEN_COOKIE_MAX / sizeof(u64)];	61	__le64 val[DIV_ROUND_UP(TCP_FASTOPEN_COOKIE_MAX, sizeof(u64))];
62	s8 len;	62	s8 len;
63	bool exp; /* In RFC6994 experimental option format */	63	bool exp; /* In RFC6994 experimental option format */
64	};	64	};

include/net/tcp.h+4−4

 #include <linux/seq_file.h>
 #include <linux/memcontrol.h>
 #include <linux/bpf-cgroup.h>
+#include <linux/siphash.h>
 extern struct inet_hashinfo tcp_hashinfo;
 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 *primary_key, void *backup_key,
+			      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,
 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_LENGTH sizeof(siphash_key_t)
 #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 {
-	__u8		key[TCP_FASTOPEN_KEY_MAX][TCP_FASTOPEN_KEY_LENGTH];
+	siphash_key_t	key[TCP_FASTOPEN_KEY_MAX];
 	int		num;
 	struct rcu_head	rcu;
 };

net/ipv4/sysctl_net_ipv4.c+1−2

@@ -365,8 +365,7 @@ static int proc_tcp_fastopen_key(struct ctl_table *table, int write, · 364 unmodified lines
365	}	365	}
366	}	366	}
367	tcp_fastopen_reset_cipher(net, NULL, key,	367	tcp_fastopen_reset_cipher(net, NULL, key,
368	backup_data ? key + 4 : NULL,	368	backup_data ? key + 4 : NULL);
369	TCP_FASTOPEN_KEY_LENGTH);
370	}	369	}
371		370
372	bad_key:	371	bad_key:

net/ipv4/tcp.c+1−2

@@ -2822,8 +2822,7 @@ static int do_tcp_setsockopt(struct sock *sk, int level, · 2821 unmodified lines
2822	if (optlen == TCP_FASTOPEN_KEY_BUF_LENGTH)	2822	if (optlen == TCP_FASTOPEN_KEY_BUF_LENGTH)
2823	backup_key = key + TCP_FASTOPEN_KEY_LENGTH;	2823	backup_key = key + TCP_FASTOPEN_KEY_LENGTH;
2824		2824
2825	return tcp_fastopen_reset_cipher(net, sk, key, backup_key,	2825	return tcp_fastopen_reset_cipher(net, sk, key, backup_key);
2826	TCP_FASTOPEN_KEY_LENGTH);
2827	}	2826	}
2828	default:	2827	default:
2829	/* fallthru */	2828	/* fallthru */

net/ipv4/tcp_fastopen.c+17−18

 #include <linux/tcp.h>
 #include <linux/rcupdate.h>
 #include <linux/rculist.h>
-#include <linux/siphash.h>
 #include <net/inetpeer.h>
 #include <net/tcp.h>
 	 * for a valid cookie, so this is an acceptable risk.
 	 */
 	get_random_bytes(key, sizeof(key));
-	tcp_fastopen_reset_cipher(net, NULL, key, NULL, sizeof(key));
+	tcp_fastopen_reset_cipher(net, NULL, key, NULL);
 }
 static void tcp_fastopen_ctx_free(struct rcu_head *head)
 }
 int tcp_fastopen_reset_cipher(struct net *net, struct sock *sk,
-			      void *primary_key, void *backup_key,
+			      void *primary_key, void *backup_key)
-			      unsigned int len)
 {
 	struct tcp_fastopen_context *ctx, *octx;
 	struct fastopen_queue *q;
 		goto out;
 	}
-	memcpy(ctx->key[0], primary_key, len);
+	ctx->key[0].key[0] = get_unaligned_le64(primary_key);
+	ctx->key[0].key[1] = get_unaligned_le64(primary_key + 8);
 	if (backup_key) {
-		memcpy(ctx->key[1], backup_key, len);
+		ctx->key[1].key[0] = get_unaligned_le64(backup_key);
+		ctx->key[1].key[1] = get_unaligned_le64(backup_key + 8);
 		ctx->num = 2;
 	} else {
 		ctx->num = 1;
 static bool __tcp_fastopen_cookie_gen_cipher(struct request_sock *req,
 					     struct sk_buff *syn,
-					     const u8 *key,
+					     const siphash_key_t *key,
 					     struct tcp_fastopen_cookie *foc)
 {
-	BUILD_BUG_ON(TCP_FASTOPEN_KEY_LENGTH != sizeof(siphash_key_t));
 	BUILD_BUG_ON(TCP_FASTOPEN_COOKIE_SIZE != sizeof(u64));
 	if (req->rsk_ops->family == AF_INET) {
 		const struct iphdr *iph = ip_hdr(syn);
-		foc->val[0] = siphash(&iph->saddr,
+		foc->val[0] = cpu_to_le64(siphash(&iph->saddr,
-				      sizeof(iph->saddr) +
+					  sizeof(iph->saddr) +
-				      sizeof(iph->daddr),
+					  sizeof(iph->daddr),
-				      (const siphash_key_t *)key);
+					  key));
 		foc->len = TCP_FASTOPEN_COOKIE_SIZE;
 		return true;
 	}
 	if (req->rsk_ops->family == AF_INET6) {
 		const struct ipv6hdr *ip6h = ipv6_hdr(syn);
-		foc->val[0] = siphash(&ip6h->saddr,
+		foc->val[0] = cpu_to_le64(siphash(&ip6h->saddr,
-				      sizeof(ip6h->saddr) +
+					  sizeof(ip6h->saddr) +
-				      sizeof(ip6h->daddr),
+					  sizeof(ip6h->daddr),
-				      (const siphash_key_t *)key);
+					  key));
 		foc->len = TCP_FASTOPEN_COOKIE_SIZE;
 		return true;
 	}
 	rcu_read_lock();
 	ctx = tcp_fastopen_get_ctx(sk);
 	if (ctx)
-		__tcp_fastopen_cookie_gen_cipher(req, syn, ctx->key[0], foc);
+		__tcp_fastopen_cookie_gen_cipher(req, syn, &ctx->key[0], foc);
 	rcu_read_unlock();
 }
 	if (!ctx)
 		goto out;
 	for (i = 0; i < tcp_fastopen_context_len(ctx); i++) {
-		__tcp_fastopen_cookie_gen_cipher(req, syn, ctx->key[i], foc);
+		__tcp_fastopen_cookie_gen_cipher(req, syn, &ctx->key[i], foc);
 		if (tcp_fastopen_cookie_match(foc, orig)) {
 			ret = i + 1;
 			goto out;

net: fastopen: robustness and endianness fixes for SipHash

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code