[1/2] net: fastopen: make key handling more robust against future changes

Message ID 20190618093207.13436-2-ard.biesheuvel@linaro.org
State New
Headers show
Series
  • [1/2] net: fastopen: make key handling more robust against future changes
Related show

Commit Message

Ard Biesheuvel June 18, 2019, 9:32 a.m.
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
  siphash_key_t 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 when
  TCP_FASTOPEN_COOKIE_MAX is no longer a multiple of 8.

- Add a key length check to tcp_fastopen_reset_cipher(). No
  callers exist currently that fail this check (they all pass
  compile constant values that equal TCP_FASTOPEN_KEY_LENGTH),
  but future changes might create problems, e.g., by leaving part
  of the key uninitialized, or overflowing the key buffers.

Note that none of these are functional changes wrt the current
state of the code.

Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>

---
 include/linux/tcp.h     |  2 +-
 include/net/tcp.h       |  5 +++--
 net/ipv4/tcp_fastopen.c | 22 ++++++++++++--------
 3 files changed, 17 insertions(+), 12 deletions(-)

-- 
2.17.1

Comments

Eric Dumazet June 18, 2019, 9:53 a.m. | #1
On Tue, Jun 18, 2019 at 2:41 AM Ard Biesheuvel
<ard.biesheuvel@linaro.org> wrote:
>

> On Tue, 18 Jun 2019 at 11:39, Eric Dumazet <edumazet@google.com> wrote:

> >

> > On Tue, Jun 18, 2019 at 2:32 AM Ard Biesheuvel

> > <ard.biesheuvel@linaro.org> wrote:

> > >

> > > 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

> > >   siphash_key_t 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 when

> > >   TCP_FASTOPEN_COOKIE_MAX is no longer a multiple of 8.

> > >

> > > - Add a key length check to tcp_fastopen_reset_cipher(). No

> > >   callers exist currently that fail this check (they all pass

> > >   compile constant values that equal TCP_FASTOPEN_KEY_LENGTH),

> > >   but future changes might create problems, e.g., by leaving part

> > >   of the key uninitialized, or overflowing the key buffers.

> > >

> > > Note that none of these are functional changes wrt the current

> > > state of the code.

> > >

> > ...

> >

> > > -       memcpy(ctx->key[0], primary_key, len);

> > > +       if (unlikely(len != TCP_FASTOPEN_KEY_LENGTH)) {

> > > +               pr_err("TCP: TFO key length %u invalid\n", len);

> > > +               err = -EINVAL;

> > > +               goto out;

> > > +       }

> >

> >

> > Why a pr_err() is there ?

> >

> > Can unpriv users flood the syslog ?

>

> They can if they could do so before: there was a call to

> crypto_cipher_setkey() in the original pre-SipHash code which would

> also result in a pr_err() on an invalid key length. That call got

> removed along with the AES cipher handling, and this basically

> reinstates it, as suggested by EricB.


This tcp_fastopen_reset_cipher() function is internal to TCP stack, all callers
always pass the correct length.

We could add checks all over the place, and end up having a TCP stack
full of defensive
checks and 10,000 additional lines of code :/

I would prefer not reinstating this.
Eric Biggers June 18, 2019, 6:18 p.m. | #2
On Tue, Jun 18, 2019 at 02:53:05AM -0700, Eric Dumazet wrote:
> On Tue, Jun 18, 2019 at 2:41 AM Ard Biesheuvel

> <ard.biesheuvel@linaro.org> wrote:

> >

> > On Tue, 18 Jun 2019 at 11:39, Eric Dumazet <edumazet@google.com> wrote:

> > >

> > > On Tue, Jun 18, 2019 at 2:32 AM Ard Biesheuvel

> > > <ard.biesheuvel@linaro.org> wrote:

> > > >

> > > > 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

> > > >   siphash_key_t 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 when

> > > >   TCP_FASTOPEN_COOKIE_MAX is no longer a multiple of 8.

> > > >

> > > > - Add a key length check to tcp_fastopen_reset_cipher(). No

> > > >   callers exist currently that fail this check (they all pass

> > > >   compile constant values that equal TCP_FASTOPEN_KEY_LENGTH),

> > > >   but future changes might create problems, e.g., by leaving part

> > > >   of the key uninitialized, or overflowing the key buffers.

> > > >

> > > > Note that none of these are functional changes wrt the current

> > > > state of the code.

> > > >

> > > ...

> > >

> > > > -       memcpy(ctx->key[0], primary_key, len);

> > > > +       if (unlikely(len != TCP_FASTOPEN_KEY_LENGTH)) {

> > > > +               pr_err("TCP: TFO key length %u invalid\n", len);

> > > > +               err = -EINVAL;

> > > > +               goto out;

> > > > +       }

> > >

> > >

> > > Why a pr_err() is there ?

> > >

> > > Can unpriv users flood the syslog ?

> >

> > They can if they could do so before: there was a call to

> > crypto_cipher_setkey() in the original pre-SipHash code which would

> > also result in a pr_err() on an invalid key length. That call got

> > removed along with the AES cipher handling, and this basically

> > reinstates it, as suggested by EricB.

> 

> This tcp_fastopen_reset_cipher() function is internal to TCP stack, all callers

> always pass the correct length.

> 

> We could add checks all over the place, and end up having a TCP stack

> full of defensive

> checks and 10,000 additional lines of code :/

> 

> I would prefer not reinstating this.


The length parameter makes no sense if it's not checked, though.  Either it
should exist and be checked, or it should be removed and the length should be
implicitly TCP_FASTOPEN_KEY_LENGTH.

- Eric

Patch

diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 2689b0b0b68a..3d3659c638a6 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -58,7 +58,7 @@  static inline unsigned int tcp_optlen(const struct sk_buff *skb)
 
 /* TCP Fast Open Cookie as stored in memory */
 struct tcp_fastopen_cookie {
-	u64	val[TCP_FASTOPEN_COOKIE_MAX / sizeof(u64)];
+	u64	val[DIV_ROUND_UP(TCP_FASTOPEN_COOKIE_MAX, sizeof(u64))];
 	s8	len;
 	bool	exp;	/* In RFC6994 experimental option format */
 };
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 573c9e9b0d72..9456b0834e21 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -43,6 +43,7 @@ 
 #include <linux/seq_file.h>
 #include <linux/memcontrol.h>
 #include <linux/bpf-cgroup.h>
+#include <linux/siphash.h>
 
 extern struct inet_hashinfo tcp_hashinfo;
 
@@ -1623,14 +1624,14 @@  void tcp_fastopen_init_key_once(struct net *net);
 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;
 };
diff --git a/net/ipv4/tcp_fastopen.c b/net/ipv4/tcp_fastopen.c
index 46b67128e1ca..61c15c3d3584 100644
--- a/net/ipv4/tcp_fastopen.c
+++ b/net/ipv4/tcp_fastopen.c
@@ -7,7 +7,6 @@ 
 #include <linux/tcp.h>
 #include <linux/rcupdate.h>
 #include <linux/rculist.h>
-#include <linux/siphash.h>
 #include <net/inetpeer.h>
 #include <net/tcp.h>
 
@@ -81,9 +80,15 @@  int tcp_fastopen_reset_cipher(struct net *net, struct sock *sk,
 		goto out;
 	}
 
-	memcpy(ctx->key[0], primary_key, len);
+	if (unlikely(len != TCP_FASTOPEN_KEY_LENGTH)) {
+		pr_err("TCP: TFO key length %u invalid\n", len);
+		err = -EINVAL;
+		goto out;
+	}
+
+	memcpy(&ctx->key[0], primary_key, len);
 	if (backup_key) {
-		memcpy(ctx->key[1], backup_key, len);
+		memcpy(&ctx->key[1], backup_key, len);
 		ctx->num = 2;
 	} else {
 		ctx->num = 1;
@@ -110,10 +115,9 @@  int tcp_fastopen_reset_cipher(struct net *net, struct sock *sk,
 
 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) {
@@ -122,7 +126,7 @@  static bool __tcp_fastopen_cookie_gen_cipher(struct request_sock *req,
 		foc->val[0] = siphash(&iph->saddr,
 				      sizeof(iph->saddr) +
 				      sizeof(iph->daddr),
-				      (const siphash_key_t *)key);
+				      key);
 		foc->len = TCP_FASTOPEN_COOKIE_SIZE;
 		return true;
 	}
@@ -133,7 +137,7 @@  static bool __tcp_fastopen_cookie_gen_cipher(struct request_sock *req,
 		foc->val[0] = siphash(&ip6h->saddr,
 				      sizeof(ip6h->saddr) +
 				      sizeof(ip6h->daddr),
-				      (const siphash_key_t *)key);
+				      key);
 		foc->len = TCP_FASTOPEN_COOKIE_SIZE;
 		return true;
 	}
@@ -154,7 +158,7 @@  static void tcp_fastopen_cookie_gen(struct sock *sk,
 	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();
 }
 
@@ -218,7 +222,7 @@  static int tcp_fastopen_cookie_gen_check(struct sock *sk,
 	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;