Skip to contentSkip to conversation

net: Do not accept packets with invalid huge size

RFC In review Philippe Mathieu-Daudé 5 participants 12 messages Nov 27, 2020 – Dec 4, 2020 Networking

lore
Share & tools
lore
#0 lore raw

cover net: Do not accept packets with invalid huge size

Hi,

This is a simple attempt to avoid the following pattern:

ssize_t pkt_size = get_pkt_size(); // returns errno

// no check

send_packet(size_t size=pkt_size); // size casted to unsigned

                                     // -> overflow

Regards,

Phil.

Philippe Mathieu-Daudé (2):
net: Do not accept packets bigger then NET_BUFSIZE
net: Assert no packet bigger than NET_BUFSIZE is queued

 net/net.c   | 4 ++++
 net/queue.c | 7 +++++++
 2 files changed, 11 insertions(+)
Signature · 1 line
2.26.2
#1 lore raw

RFC 1/2 net: Do not accept packets bigger then NET_BUFSIZE

Do not allow qemu_send_packet*() and qemu_net_queue_send() functions to accept packets bigger then NET_BUFSIZE.

---
We have to put a limit somewhere. NET_BUFSIZE is defined as:

/* Maximum GSO packet size (64k) plus plenty of room for
* the ethernet and virtio_net headers
*/
#define NET_BUFSIZE (4096 + 65536)

If we do want to accept bigger packets (i.e. multiple GSO packets in a IOV), we could use INT32_MAX as limit...

---
 net/net.c   | 4 ++++
 net/queue.c | 4 ++++
 2 files changed, 8 insertions(+)
net/net.c +4 -0
index 6a2c3d95670..f29bfac2b11 100644
@@ -644,6 +644,10 @@ static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
     qemu_hexdump(stdout, "net", buf, size);
 #endif
 
+    if (size > NET_BUFSIZE) {
+        return -1;
+    }
+
     if (sender->link_down || !sender->peer) {
         return size;
     }
net/queue.c +4 -0
index 19e32c80fda..221a1c87961 100644
@@ -191,6 +191,10 @@ ssize_t qemu_net_queue_send(NetQueue *queue,
 {
     ssize_t ret;
 
+    if (size > NET_BUFSIZE) {
+        return -1;
+    }
+
     if (queue->delivering || !qemu_can_send_packet(sender)) {
         qemu_net_queue_append(queue, sender, flags, data, size, sent_cb);
         return 0;
Signature · 1 line
2.26.2
#2 lore raw

Re: [RFC PATCH-for-5.2 1/2] net: Do not accept packets bigger then NET_BUFSIZE

Quoted 7 lines · Philippe Mathieu-Daudé

Do not allow qemu_send_packet*() and qemu_net_queue_send() functions to accept packets bigger then NET_BUFSIZE.

---
We have to put a limit somewhere. NET_BUFSIZE is defined as:

Quoted 7 lines

/* Maximum GSO packet size (64k) plus plenty of room for
* the ethernet and virtio_net headers
*/
#define NET_BUFSIZE (4096 + 65536)

If we do want to accept bigger packets (i.e. multiple GSO packets in a IOV), we could use INT32_MAX as limit...

This looks like a complaint for:

commit 25c01bd19d0e4b66f357618aeefda1ef7a41e21a
Author: Jason Wang <[email protected]>
Date:   Tue Dec 4 11:53:43 2018 +0800

    net: drop too large packet early

which only fixes the iov version of the function.

If you don't see any real bug, I suggest to merge the fix in next release.

Thanks

Quoted 35 lines
---
  net/net.c   | 4 ++++
  net/queue.c | 4 ++++
  2 files changed, 8 insertions(+)
net/net.c +4 -0
index 6a2c3d95670..f29bfac2b11 100644
@@ -644,6 +644,10 @@ static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
      qemu_hexdump(stdout, "net", buf, size);
  #endif
 
+    if (size > NET_BUFSIZE) {
+        return -1;
+    }
+
      if (sender->link_down || !sender->peer) {
          return size;
      }
net/queue.c +4 -0
index 19e32c80fda..221a1c87961 100644
@@ -191,6 +191,10 @@ ssize_t qemu_net_queue_send(NetQueue *queue,
  {
      ssize_t ret;
 
+    if (size > NET_BUFSIZE) {
+        return -1;
+    }
+
      if (queue->delivering || !qemu_can_send_packet(sender)) {
          qemu_net_queue_append(queue, sender, flags, data, size, sent_cb);
          return 0;
#3 lore raw

Re: [RFC PATCH-for-5.2 1/2] net: Do not accept packets bigger then NET_BUFSIZE

Hello,

Quoted 25 lines · Jason Wang
Quoted 7 lines · Philippe Mathieu-Daudé

Do not allow qemu_send_packet*() and qemu_net_queue_send() functions to accept packets bigger then NET_BUFSIZE.

---
We have to put a limit somewhere. NET_BUFSIZE is defined as:

Quoted 7 lines

/* Maximum GSO packet size (64k) plus plenty of room for
* the ethernet and virtio_net headers
*/
#define NET_BUFSIZE (4096 + 65536)

If we do want to accept bigger packets (i.e. multiple GSO packets in a IOV), we could use INT32_MAX as limit...

This looks like a complaint for:

commit 25c01bd19d0e4b66f357618aeefda1ef7a41e21a

Author: Jason Wang <[email protected]>
Date:   Tue Dec 4 11:53:43 2018 +0800
Quoted 9 lines

net: drop too large packet early

which only fixes the iov version of the function.

If you don't see any real bug, I suggest to merge the fix in next release.

Thanks

Following is the reference bug along with a proposed patch, although I guess the patch [2] is not strictly required once this patchset is merged.

[1] https://bugzilla.redhat.com/show_bug.cgi?id=1899722
[2] https://lists.nongnu.org/archive/html/qemu-devel/2020-11/msg05935.html

Thank you,
--
Mauro Matteo Cascella
Red Hat Product Security
PGP-Key ID: BB3410B0

#4 lore raw

Re: [RFC PATCH-for-5.2 1/2] net: Do not accept packets bigger then NET_BUFSIZE

Quoted 33 lines · Mauro Matteo Cascella

Hello,

Quoted 30 lines · Jason Wang
Quoted 7 lines · Philippe Mathieu-Daudé

Do not allow qemu_send_packet*() and qemu_net_queue_send() functions to accept packets bigger then NET_BUFSIZE.

---
We have to put a limit somewhere. NET_BUFSIZE is defined as:

Quoted 7 lines

/* Maximum GSO packet size (64k) plus plenty of room for
* the ethernet and virtio_net headers
*/
#define NET_BUFSIZE (4096 + 65536)

If we do want to accept bigger packets (i.e. multiple GSO packets in a IOV), we could use INT32_MAX as limit...

This looks like a complaint for:

commit 25c01bd19d0e4b66f357618aeefda1ef7a41e21a

Author: Jason Wang <[email protected]>
Date:   Tue Dec 4 11:53:43 2018 +0800

net: drop too large packet early

which only fixes the iov version of the function.

If you don't see any real bug, I suggest to merge the fix in next release.

Fine by me, I don't have access to the big picture.

Quoted 6 lines

Following is the reference bug along with a proposed patch, although I guess the patch [2] is not strictly required once this patchset is merged.

[1] https://bugzilla.redhat.com/show_bug.cgi?id=1899722
[2] https://lists.nongnu.org/archive/html/qemu-devel/2020-11/msg05935.html

I didn't noticed your patch. While it prevents this kind of error on a particular device, it doesn't for the rest.

#5 lore raw

Re: [RFC PATCH-for-5.2 1/2] net: Do not accept packets bigger then NET_BUFSIZE

In reply to Philippe Mathieu-Daudé
+-- On Fri, 27 Nov 2020, Philippe Mathieu-Daudé wrote --+
| Do not allow qemu_send_packet*() and qemu_net_queue_send()
| functions to accept packets bigger then NET_BUFSIZE.
| 
| We have to put a limit somewhere. NET_BUFSIZE is defined as:
|  /* Maximum GSO packet size (64k) plus plenty of room for
|   * the ethernet and virtio_net headers
|   */
|  #define NET_BUFSIZE (4096 + 65536)
| 
| +    if (size > NET_BUFSIZE) {
| +        return -1;
| +    }
| +

/usr/include/linux/if_ether.h
#define ETH_MIN_MTU 68 /* Min IPv4 MTU per RFC791 */
#define ETH_MAX_MTU 0xFFFFU /* 65535, same as IP_MAX_MTU */

  if (size < ETH_MIN_MTU || size > ETH_MAX_MTU) {
      return -1;
  }

Should there be similar check for minimum packet size?

Thank you.
--
Prasad J Pandit / Red Hat Product Security Team
8685 545E B54C 486B C6EB 271E E285 8B5A F050 DE8D

#6 lore raw

Re: [RFC PATCH-for-5.2 1/2] net: Do not accept packets bigger then NET_BUFSIZE

Quoted 19 lines · P J P
+-- On Fri, 27 Nov 2020, Philippe Mathieu-Daudé wrote --+
| Do not allow qemu_send_packet*() and qemu_net_queue_send()
| functions to accept packets bigger then NET_BUFSIZE.
| 
| We have to put a limit somewhere. NET_BUFSIZE is defined as:
|  /* Maximum GSO packet size (64k) plus plenty of room for
|   * the ethernet and virtio_net headers
|   */
|  #define NET_BUFSIZE (4096 + 65536)
| 
| +    if (size > NET_BUFSIZE) {
| +        return -1;
| +    }
| +

/usr/include/linux/if_ether.h
#define ETH_MIN_MTU 68 /* Min IPv4 MTU per RFC791 */
#define ETH_MAX_MTU 0xFFFFU /* 65535, same as IP_MAX_MTU */

Quoted 5 lines
  if (size < ETH_MIN_MTU || size > ETH_MAX_MTU) {
      return -1;
  }

Should there be similar check for minimum packet size?

I don't think so, because this API is not restricted to Ethernet frames (i.e. CAN frames are much shorter).
We also want developers be able to experiment with new protocols.

I'd rather not relate this with any protocol. Using an upper limit doesn't hurt. Maybe not accepting frames bigger than 1 GiB is enough from a security point of view.

Quoted 6 lines

Thank you.
--
Prasad J Pandit / Red Hat Product Security Team
8685 545E B54C 486B C6EB 271E E285 8B5A F050 DE8D

#7 lore raw
In reply to Philippe Mathieu-Daudé
Quoted 5 lines · Philippe Mathieu-Daudé

Hi,

This is a simple attempt to avoid the following pattern:

ssize_t pkt_size = get_pkt_size(); // returns errno

Sorry, I meant: returns "-errno" (< 0).

Quoted 18 lines

// no check

send_packet(size_t size=pkt_size); // size casted to unsigned

                                     // -> overflow

Regards,

Phil.

Philippe Mathieu-Daudé (2):
net: Do not accept packets bigger then NET_BUFSIZE
net: Assert no packet bigger than NET_BUFSIZE is queued

 net/net.c   | 4 ++++
 net/queue.c | 7 +++++++
 2 files changed, 11 insertions(+)
#8 lore raw

RFC 2/2 net: Assert no packet bigger than NET_BUFSIZE is queued

In reply to Philippe Mathieu-Daudé

Ensure no packet bigger then NET_BUFSIZE is queued via qemu_net_queue_append*() by adding assertions.

---
 net/queue.c | 3 +++
 1 file changed, 3 insertions(+)
net/queue.c +3 -0
index 221a1c87961..94b98b19ef9 100644
@@ -102,6 +102,8 @@ static void qemu_net_queue_append(NetQueue *queue,
     if (queue->nq_count >= queue->nq_maxlen && !sent_cb) {
         return; /* drop if queue full and no callback */
     }
+
+    assert(size <= NET_BUFSIZE);
     packet = g_malloc(sizeof(NetPacket) + size);
     packet->sender = sender;
     packet->flags = flags;
@@ -131,6 +133,7 @@ void qemu_net_queue_append_iov(NetQueue *queue,
         max_len += iov[i].iov_len;
     }
 
+    assert(max_len <= NET_BUFSIZE);
     packet = g_malloc(sizeof(NetPacket) + max_len);
     packet->sender = sender;
     packet->sent_cb = sent_cb;
Signature · 1 line
2.26.2
#9 lore raw

Re: [RFC PATCH-for-5.2 2/2] net: Assert no packet bigger than NET_BUFSIZE is queued

Quoted 22 lines · Philippe Mathieu-Daudé

Ensure no packet bigger then NET_BUFSIZE is queued via qemu_net_queue_append*() by adding assertions.

---
  net/queue.c | 3 +++
  1 file changed, 3 insertions(+)
net/queue.c +2 -0
index 221a1c87961..94b98b19ef9 100644
@@ -102,6 +102,8 @@ static void qemu_net_queue_append(NetQueue *queue,
      if (queue->nq_count >= queue->nq_maxlen && !sent_cb) {
          return; /* drop if queue full and no callback */
      }
+
+    assert(size <= NET_BUFSIZE);
      packet = g_malloc(sizeof(NetPacket) + size);
      packet->sender = sender;
      packet->flags = flags;

net/queue.c void qemu_net_queue_append_iov(NetQueue *queue, · line 139

Quoted 7 lines
net/queue.c +1 -0
@@ -131,6 +133,7 @@ void qemu_net_queue_append_iov(NetQueue *queue,
          max_len += iov[i].iov_len;
      }
 
+    assert(max_len <= NET_BUFSIZE);
      packet = g_malloc(sizeof(NetPacket) + max_len);
      packet->sender = sender;
      packet->sent_cb = sent_cb;

Anyway to avoid the assert here?

Thanks

#10 lore raw
In reply to Philippe Mathieu-Daudé
Quoted 11 lines · Philippe Mathieu-Daudé

Hi,

This is a simple attempt to avoid the following pattern:

ssize_t pkt_size = get_pkt_size(); // returns errno

// no check

send_packet(size_t size=pkt_size); // size casted to unsigned

                                     // -> overflow

"RFC" and "for-5.2" are not a great combination at this point :-( What are the consequences if we don't put this patchset in 5.2?

thanks
-- PMM

#11 lore raw
Quoted 6 lines · Peter Maydell
Quoted 5 lines · Philippe Mathieu-Daudé

Hi,

This is a simple attempt to avoid the following pattern:

Quoted 8 lines
Quoted 6 lines

ssize_t pkt_size = get_pkt_size(); // returns errno

// no check

send_packet(size_t size=pkt_size); // size casted to unsigned

                                     // -> overflow

"RFC" and "for-5.2" are not a great combination at this point :-(

"RFC" because I don't understand all the effects this assert can have. "for-5.2" because it was raised as a security bug, but I don't have access to the information, so I can not see the big picture.

Quoted 1 line

What are the consequences if we don't put this patchset in 5.2?

Jason suggested to postpone this. If this is security important, we can release a 5.2.1-stable tag early I suppose.

Regards,

Phil.