Guard against gso_segs overflows
Subsystems (4)
v2 cover Guard against gso_segs overflows
From: Alice Mikityanska <[email protected]>
This series is a follow-up on the discussion:
skb_segment is patched to avoid possible overflows in partial GSO. The primary possible source of too many GSO segments is also addressed:
virtio-net clamps gso_size to >=8 in TCP, as suggested by Eric.
v2 changes: dropped new checks in fastpath from skb_gro_receive and __virtio_net_hdr_to_skb, replaced the latter with a silent clamp for gso_size, kept the cheap guard in skb_segment.
v1: https://lore.kernel.org/netdev/[email protected]/
Alice Mikityanska (2):
net: Guard for gso_segs overflow in skb_segment
virtio-net: Ensure that TCP packets don't overflow gso_segs
include/linux/virtio_net.h | 4 ++++ net/core/skbuff.c | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-)
Signature · 1 line
2.55.0
PATCH v2 1/2 net: Guard for gso_segs overflow in skb_segment
From: Alice Mikityanska <[email protected]>
skb_segment calculates 32-bit partial_segs as len / gso_size, and then assigns it to the 16-bit gso_segs field. The division might overflow in some edge cases where the SKB is BIG TCP (65536 <= len <= 8*65535), and gso_size < TCP_MIN_GSO_SIZE = 8. While normally this can't happen due to TCP_MIN_GSO_SIZE, an AF_PACKET PACKET_VNET_HDR socket can generate such a malformed packet.
Blocking malformed virtio_net packets is implemented in the next patch, but this patch clamps partial_segs in skb_segment itself for more generic robustness. Should len / gso_size happen to be bigger than 65535 in partial GSO, skb_segment will now just produce more than two output SKBs, all of which will be valid with gso_segs <= 65535.
--- net/core/skbuff.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
net/core/skbuff.c +1 -1
@@ -4860,7 +4860,7 @@ struct sk_buff *skb_segment(struct sk_buff *head_skb,* doesn't fit into an MSS sized block, so take care of that * now. */ - partial_segs = len / mss; + partial_segs =min (len / mss,GSO_MAX_SEGS );if (partial_segs >1 ) mss *= partial_segs;else
Signature · 1 line
2.55.0
Paolo Abeni
maintainerRe: [PATCH net-next v2 1/2] net: Guard for gso_segs overflow in skb_segment
Quoted 9 lines · Alice Mikityanska
From: Alice Mikityanska <[email protected]>
skb_segmentcalculates 32-bitpartial_segsas len /gso_size, and then assigns it to the 16-bitgso_segsfield. The division might overflow in some edge cases where the SKB is BIG TCP (65536 <= len <= 8*65535), andgso_size<TCP_MIN_GSO_SIZE= 8. While normally this can't happen due toTCP_MIN_GSO_SIZE, anAF_PACKETPACKET_VNET_HDRsocket can generate such a malformed packet.
Quoted 5 lines
Blocking malformed
virtio_netpackets is implemented in the next patch, but this patch clampspartial_segsinskb_segmentitself for more generic robustness. Should len /gso_sizehappen to be bigger than 65535 in partial GSO,skb_segmentwill now just produce more than two output SKBs, all of which will be valid withgso_segs<= 65535.
Minor nit: I think it would make sense to re-order the patches.
Quoted 10 lines
Signed-off-by Alice Mikityanska <[email protected]>--- net/core/skbuff.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)net/core/skbuff.c +0
-0
net/core/skbuff.c struct sk_buff *skb_segment(struct sk_buff *head_skb, · line 4863
Quoted 5 lines
net/core/skbuff.c +1
-1@@ -4860,7 +4860,7 @@ struct sk_buff *skb_segment(struct sk_buff *head_skb,* doesn't fit into an MSS sized block, so take care of that * now. */ - partial_segs = len / mss; + partial_segs =min (len / mss,GSO_MAX_SEGS );
Since on top of patch 2/2 the min() should always be a no-op, what about instead:
if (WARN_ON_ONCE(len/mss > GSO_MAX_SEGS)) return ERR_PTR(-EINVAL);
?
/P
Re: [PATCH net-next v2 1/2] net: Guard for gso_segs overflow in skb_segment
Quoted 23 lines · Paolo Abeni
Quoted 9 lines · Alice Mikityanska
From: Alice Mikityanska <[email protected]>
skb_segmentcalculates 32-bitpartial_segsas len /gso_size, and then assigns it to the 16-bitgso_segsfield. The division might overflow in some edge cases where the SKB is BIG TCP (65536 <= len <= 8*65535), andgso_size<TCP_MIN_GSO_SIZE= 8. While normally this can't happen due toTCP_MIN_GSO_SIZE, anAF_PACKETPACKET_VNET_HDRsocket can generate such a malformed packet.Quoted 5 lines
Blocking malformed
virtio_netpackets is implemented in the next patch, but this patch clampspartial_segsinskb_segmentitself for more generic robustness. Should len /gso_sizehappen to be bigger than 65535 in partial GSO,skb_segmentwill now just produce more than two output SKBs, all of which will be valid withgso_segs<= 65535.Minor nit: I think it would make sense to re-order the patches.
Quoted 5 lines
Signed-off-by Alice Mikityanska <[email protected]>--- net/core/skbuff.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
Quoted 12 lines
net/core/skbuff.c struct sk_buff *skb_segment(struct sk_buff *head_skb, · line 4863
Quoted 10 lines
net/core/skbuff.c +1
-1@@ -4860,7 +4860,7 @@ struct sk_buff *skb_segment(struct sk_buff *head_skb,* doesn't fit into an MSS sized block, so take care of that * now. */ - partial_segs = len / mss; + partial_segs =min (len / mss,GSO_MAX_SEGS );Since on top of patch 2/2 the
min()should always be a no-op,
Not sure; it'll be a no-op in this specific virtio_net scenario, but what if there are more?
Quoted 4 lines
what about instead:
if (WARN_ON_ONCE(len/mss > GSO_MAX_SEGS)) return ERR_PTR(-EINVAL);
Yeah, it looks like a good idea to add a WARN to let syzbot uncover more possible cases, but:
1. I'd keep it non-failing rather than return an error: partial GSO can deal with smaller segment size pretty well, no need to fail.
2. I'd make it DEBUG_NET_WARN_ON_ONCE to avoid the penalty in production.
I can do that if it passes Eric's filter for too much code in fastpath.
Quoted 3 lines
?
/P
PATCH v2 2/2 virtio-net: Ensure that TCP packets don't overflow gso_segs
In reply to Alice MikityanskaFrom: Alice Mikityanska <[email protected]>
The user can specify any gso_size in a packet crafted with an AF_PACKET PACKET_VNET_HDR socket, even smaller than TCP_MIN_GSO_SIZE = 8. At the same time, GSO_MAX_SIZE = 8 * GSO_MAX_SEGS = 8 * 65535. When the user crafts a packet with gso_size < 8, there is a risk for partial GSO to overflow the 16-bit gso_segs field when dividing the SKB length by gso_size.
Adjust gso_size of TCP packets to be at least TCP_MIN_GSO_SIZE = 8. Keep gso_size of UDP GSO packets, as gso_size=1 is valid and explicitly tested at tools/testing/selftests/net/tun.c:649.
--- include/linux/virtio_net.h | 4 ++++ 1 file changed, 4 insertions(+)
include/linux/virtio_net.h +4 -0
@@ -6,6 +6,7 @@#include <linux/ip.h> #include <linux/ipv6.h> #include <linux/udp.h> +#include <net/tcp.h> #include <uapi/linux/tcp.h> #include <uapi/linux/virtio_net.h>
@@ -179,6 +180,9 @@ static inline int __virtio_net_hdr_to_skb(struct sk_buff *skb,if (skb->ip_summed ==CHECKSUM_PARTIAL && skb->csum_offset != offsetof(struct tcphdr , check))return -EINVAL ; + +BUILD_BUG_ON (TCP_MIN_GSO_SIZE *GSO_MAX_SEGS <GSO_MAX_SIZE ); + gso_size =max (gso_size,TCP_MIN_GSO_SIZE );break ; }
Signature · 1 line
2.55.0