gso: fix GSO_DODGY bit handling for related protocols
Subsystems (4)
PATCH 1/1 gso: fix GSO_DODGY bit handling for related protocols
SKB_GSO_DODGY bit indicates a GSO packet comes from an untrusted source. The canonical way is to recompute the gso_segs to avoid device driver issues. Afterwards, the DODGY bit can be removed to avoid re-check at the egress of later devices, e.g. packets can egress to a vlan device backed by a real NIC.
Commit 1fd54773c267 ("udp: allow header check for dodgy GSO_UDP_L4 packets.") checks DODGY bit for UDP, but for packets that can be fed directly to the device after gso_segs reset, it actually falls through to fragmentation [1].
Commit 90017accff61 ("sctp: Add GSO support") and commit 3820c3f3e417 ("[TCP]: Reset gso_segs if packet is dodgy") both didn't remove the DODGY bit after recomputing gso_segs.
This change fixes the GSO_UDP_L4 handling case, and remove the DODGY bit at other places.
---
[1]:
https://lore.kernel.org/all/CAJPywTKDdjtwkLVUW6LRA2FU912qcDmQOQGt2WaDo28KzYDg+A@mail.gmail.com/
--- net/ipv4/tcp_offload.c | 1 + net/ipv4/udp_offload.c | 19 +++++++++++++++---- net/ipv6/udp_offload.c | 19 +++++++++++++++---- net/sctp/offload.c | 2 ++ 4 files changed, 33 insertions(+), 8 deletions(-)
net/ipv4/tcp_offload.c +1 -0
@@ -87,6 +87,7 @@ struct sk_buff *tcp_gso_segment(struct sk_buff *skb,/* Packet is from an untrusted source, reset gso_segs. */ skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len, mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; segs =NULL ; goto out;
net/ipv4/udp_offload.c +15 -4
@@ -388,11 +388,22 @@ static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out; -if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, false); - mss =skb_shinfo (skb)->gso_size; + +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) { +if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ +skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len -sizeof (*uh), + mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; + + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, false); + } + } +if (unlikely (skb->len <= mss)) goto out;
net/ipv6/udp_offload.c +15 -4
@@ -43,11 +43,22 @@ static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out; -if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, true); - mss =skb_shinfo (skb)->gso_size; + +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) { +if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ +skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len -sizeof (*uh), + mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; + + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, true); + } + } +if (unlikely (skb->len <= mss)) goto out;
net/sctp/offload.c +2 -0
@@ -65,6 +65,8 @@ static struct sk_buff *sctp_gso_segment(struct sk_buff *skb,skb_walk_frags (skb, frag_iter) pinfo->gso_segs++; + pinfo->gso_type &= ~SKB_GSO_DODGY ; + segs =NULL ; goto out; }
Signature · 1 line
2.30.2
Quoted 12 lines · Yan Zhai
SKB_GSO_DODGYbit indicates a GSO packet comes from an untrusted source. The canonical way is to recompute thegso_segsto avoid device driver issues. Afterwards, the DODGY bit can be removed to avoid re-check at the egress of later devices, e.g. packets can egress to a vlan device backed by a real NIC.Commit
1fd54773c267("udp: allow header check for dodgyGSO_UDP_L4packets.") checks DODGY bit for UDP, but for packets that can be fed directly to the device aftergso_segsreset, it actually falls through to fragmentation [1].
Quoted 6 lines
Commit
90017accff61("sctp: Add GSO support") and commit3820c3f3e417("[TCP]: Resetgso_segsif packet is dodgy") both didn't remove the DODGY bit after recomputinggso_segs.This change fixes the
GSO_UDP_L4handling case, and remove the DODGY bit at other places.
These two things should not be conflated.
Only the USO fix is strictly needed to fix the reported issue.
Quoted 3 lines
Fixes 90017accff61 ("sctp: Add GSO support")Fixes 3820c3f3e417 ("[TCP]: Reset gso_segs if packet is dodgy")Fixes 1fd54773c267 ("udp: allow header check for dodgy GSO_UDP_L4 packets.")
Quoted 30 lines
Signed-off-by Yan Zhai <[email protected]>---
[1]:
https://lore.kernel.org/all/CAJPywTKDdjtwkLVUW6LRA2FU912qcDmQOQGt2WaDo28KzYDg+A@mail.gmail.com/--- net/ipv4/tcp_offload.c | 1 + net/ipv4/udp_offload.c | 19 +++++++++++++++---- net/ipv6/udp_offload.c | 19 +++++++++++++++---- net/sctp/offload.c | 2 ++ 4 files changed, 33 insertions(+), 8 deletions(-)net/ipv4/tcp_offload.c +1
-0@@ -87,6 +87,7 @@ struct sk_buff *tcp_gso_segment(struct sk_buff *skb,/* Packet is from an untrusted source, reset gso_segs. */ skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len, mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; segs =NULL ; goto out;net/ipv4/udp_offload.c +0
-0
net/ipv4/udp_offload.c static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, · line 391
Quoted 8 lines
net/ipv4/udp_offload.c +0
-4@@ -388,11 +388,22 @@ static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out; -if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, false); - mss =skb_shinfo (skb)->gso_size;
Why move the block below this line?
Quoted 5 lines
net/ipv4/udp_offload.c +5
-0+ +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) { +if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ + skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len - sizeof(*uh),
net/ipv4/udp_offload.c static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, · line 406
Quoted 10 lines
net/ipv4/udp_offload.c +10
-0+ mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; + + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, false); + } + } +
The validation should take place inside __udp_gso_segment.
Revert the previous patch to always enter that function for USO packets:
if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4)
return __udp_gso_segment(skb, features, false);And in that function decide to return NULL after validation.
Quoted 50 lines
net/ipv4/udp_offload.c +0
-0if (unlikely (skb->len <= mss)) goto out;net/ipv6/udp_offload.c +15
-4@@ -43,11 +43,22 @@ static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out; -if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, true); - mss =skb_shinfo (skb)->gso_size; + +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) { +if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ +skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len -sizeof (*uh), + mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; + + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, true); + } + } +if (unlikely (skb->len <= mss)) goto out;net/sctp/offload.c +2
-1@@ -65,6 +65,8 @@ static struct sk_buff *sctp_gso_segment(struct sk_buff *skb,skb_walk_frags (skb, frag_iter) pinfo->gso_segs++; + pinfo->gso_type &= ~SKB_GSO_DODGY ; + segs =NULL ; goto out; } --2.30.2
Quoted 90 lines · Willem de Bruijn
Quoted 12 lines · Yan Zhai
SKB_GSO_DODGYbit indicates a GSO packet comes from an untrusted source. The canonical way is to recompute thegso_segsto avoid device driver issues. Afterwards, the DODGY bit can be removed to avoid re-check at the egress of later devices, e.g. packets can egress to a vlan device backed by a real NIC.Commit
1fd54773c267("udp: allow header check for dodgyGSO_UDP_L4packets.") checks DODGY bit for UDP, but for packets that can be fed directly to the device aftergso_segsreset, it actually falls through to fragmentation [1].Quoted 6 lines
Commit
90017accff61("sctp: Add GSO support") and commit3820c3f3e417("[TCP]: Resetgso_segsif packet is dodgy") both didn't remove the DODGY bit after recomputinggso_segs.This change fixes the
GSO_UDP_L4handling case, and remove the DODGY bit at other places.These two things should not be conflated.
Only the USO fix is strictly needed to fix the reported issue.
Quoted 3 lines
Fixes 90017accff61 ("sctp: Add GSO support")Fixes 3820c3f3e417 ("[TCP]: Reset gso_segs if packet is dodgy")Fixes 1fd54773c267 ("udp: allow header check for dodgy GSO_UDP_L4 packets.")Quoted 30 lines
Signed-off-by Yan Zhai <[email protected]>---
[1]:
https://lore.kernel.org/all/CAJPywTKDdjtwkLVUW6LRA2FU912qcDmQOQGt2WaDo28KzYDg+A@mail.gmail.com/--- net/ipv4/tcp_offload.c | 1 + net/ipv4/udp_offload.c | 19 +++++++++++++++---- net/ipv6/udp_offload.c | 19 +++++++++++++++---- net/sctp/offload.c | 2 ++ 4 files changed, 33 insertions(+), 8 deletions(-)net/ipv4/tcp_offload.c +1
-0@@ -87,6 +87,7 @@ struct sk_buff *tcp_gso_segment(struct sk_buff *skb,/* Packet is from an untrusted source, reset gso_segs. */ skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len, mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; segs =NULL ; goto out;net/ipv4/udp_offload.c +0
-0net/ipv4/udp_offload.c static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, · line 391
Quoted 8 lines
net/ipv4/udp_offload.c +0
-4@@ -388,11 +388,22 @@ static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out; -if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, false); - mss =skb_shinfo (skb)->gso_size;Why move the block below this line?
Quoted 5 lines
net/ipv4/udp_offload.c +5
-0+ +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) { +if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ + skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len - sizeof(*uh),net/ipv4/udp_offload.c static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, · line 406
Quoted 10 lines
net/ipv4/udp_offload.c +10
-0+ mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; + + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, false); + } + } +The validation should take place inside
__udp_gso_segment.
Quoted 6 lines
Revert the previous patch to always enter that function for USO packets:
if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4) return __udp_gso_segment(skb, features, false);And in that function decide to return NULL after validation.
+1
Thanks
Quoted 53 lines
Quoted 52 lines
net/ipv4/udp_offload.c +0
-0if (unlikely (skb->len <= mss)) goto out;net/ipv6/udp_offload.c +15
-4@@ -43,11 +43,22 @@ static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out; -if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, true); - mss =skb_shinfo (skb)->gso_size; + +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) { +if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ +skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len -sizeof (*uh), + mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; + + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, true); + } + } +if (unlikely (skb->len <= mss)) goto out;net/sctp/offload.c +2
-1@@ -65,6 +65,8 @@ static struct sk_buff *sctp_gso_segment(struct sk_buff *skb,skb_walk_frags (skb, frag_iter) pinfo->gso_segs++; + pinfo->gso_type &= ~SKB_GSO_DODGY ; + segs =NULL ; goto out; } --2.30.2
Quoted 18 lines · Willem de Bruijn
Quoted 16 lines · Yan Zhai
SKB_GSO_DODGYbit indicates a GSO packet comes from an untrusted source. The canonical way is to recompute thegso_segsto avoid device driver issues. Afterwards, the DODGY bit can be removed to avoid re-check at the egress of later devices, e.g. packets can egress to a vlan device backed by a real NIC.Commit
1fd54773c267("udp: allow header check for dodgyGSO_UDP_L4packets.") checks DODGY bit for UDP, but for packets that can be fed directly to the device aftergso_segsreset, it actually falls through to fragmentation [1].Commit
90017accff61("sctp: Add GSO support") and commit3820c3f3e417("[TCP]: Resetgso_segsif packet is dodgy") both didn't remove the DODGY bit after recomputinggso_segs.
Quoted 7 lines
Quoted 2 lines
This change fixes the
GSO_UDP_L4handling case, and remove the DODGY bit at other places.These two things should not be conflated.
Only the USO fix is strictly needed to fix the reported issue.
It's my OCD of wanting to avoid a cover letter for two patches... Let's address just this UDP issue then this time. The removal of DODGY is in fact more suitable as RFC for small improvements.
Quoted 39 lines
Quoted 3 lines
Fixes 90017accff61 ("sctp: Add GSO support")Fixes 3820c3f3e417 ("[TCP]: Reset gso_segs if packet is dodgy")Fixes 1fd54773c267 ("udp: allow header check for dodgy GSO_UDP_L4 packets.")Quoted 33 lines
Signed-off-by Yan Zhai <[email protected]>---
[1]:
https://lore.kernel.org/all/CAJPywTKDdjtwkLVUW6LRA2FU912qcDmQOQGt2WaDo28KzYDg+A@mail.gmail.com/--- net/ipv4/tcp_offload.c | 1 + net/ipv4/udp_offload.c | 19 +++++++++++++++---- net/ipv6/udp_offload.c | 19 +++++++++++++++---- net/sctp/offload.c | 2 ++ 4 files changed, 33 insertions(+), 8 deletions(-)net/ipv4/tcp_offload.c +1
-0@@ -87,6 +87,7 @@ struct sk_buff *tcp_gso_segment(struct sk_buff *skb,/* Packet is from an untrusted source, reset gso_segs. */ skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len, mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; segs =NULL ; goto out;net/ipv4/udp_offload.c +0
-0@@ -388,11 +388,22 @@ static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out;
Quoted 8 lines
net/ipv4/udp_offload.c static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, · line 391
Quoted 5 lines
net/ipv4/udp_offload.c +0
-4-if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, false); - mss =skb_shinfo (skb)->gso_size;Why move the block below this line?
if we move the dodgy handling into __udp_gso_segment then it does not need to move below this line.
Quoted 18 lines
Quoted 5 lines
net/ipv4/udp_offload.c +5
-0+ +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) { +if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ + skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len - sizeof(*uh),net/ipv4/udp_offload.c static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, · line 406
Quoted 10 lines
net/ipv4/udp_offload.c +10
-0+ mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; + + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, false); + } + } +The validation should take place inside
__udp_gso_segment.
Quoted 7 lines
Revert the previous patch to always enter that function for USO packets:
if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4) return __udp_gso_segment(skb, features, false);And in that function decide to return NULL after validation.
Good call, that's indeed better. Thanks
Quoted 51 lines
Quoted 51 lines
net/ipv4/udp_offload.c +0
-0if (unlikely (skb->len <= mss)) goto out;net/ipv6/udp_offload.c +15
-4@@ -43,11 +43,22 @@ static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out; -if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, true); - mss =skb_shinfo (skb)->gso_size; + +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) { +if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ +skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len -sizeof (*uh), + mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; + + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, true); + } + } +if (unlikely (skb->len <= mss)) goto out;net/sctp/offload.c +2
-1@@ -65,6 +65,8 @@ static struct sk_buff *sctp_gso_segment(struct sk_buff *skb,skb_walk_frags (skb, frag_iter) pinfo->gso_segs++; + pinfo->gso_type &= ~SKB_GSO_DODGY ; + segs =NULL ; goto out; } --2.30.2
Signature · 1 line
Yan
Quoted 7 lines · Yan Zhai
SKB_GSO_DODGYbit indicates a GSO packet comes from an untrusted source. The canonical way is to recompute thegso_segsto avoid device driver issues. Afterwards, the DODGY bit can be removed to avoid re-check at the egress of later devices, e.g. packets can egress to a vlan device backed by a real NIC.
Quoted 8 lines
Commit
1fd54773c267("udp: allow header check for dodgyGSO_UDP_L4packets.") checks DODGY bit for UDP, but for packets that can be fed directly to the device aftergso_segsreset, it actually falls through to fragmentation [1].Commit
90017accff61("sctp: Add GSO support") and commit3820c3f3e417("[TCP]: Resetgso_segsif packet is dodgy") both didn't remove the DODGY bit after recomputinggso_segs.
If we try to fix two issues, we'd better use separate patches.
Quoted 47 lines
This change fixes the
GSO_UDP_L4handling case, and remove the DODGY bit at other places.Fixes 90017accff61 ("sctp: Add GSO support")Fixes 3820c3f3e417 ("[TCP]: Reset gso_segs if packet is dodgy")Fixes 1fd54773c267 ("udp: allow header check for dodgy GSO_UDP_L4 packets.")Signed-off-by Yan Zhai <[email protected]>---
[1]:
https://lore.kernel.org/all/CAJPywTKDdjtwkLVUW6LRA2FU912qcDmQOQGt2WaDo28KzYDg+A@mail.gmail.com/--- net/ipv4/tcp_offload.c | 1 + net/ipv4/udp_offload.c | 19 +++++++++++++++---- net/ipv6/udp_offload.c | 19 +++++++++++++++---- net/sctp/offload.c | 2 ++ 4 files changed, 33 insertions(+), 8 deletions(-)net/ipv4/tcp_offload.c +1
-0@@ -87,6 +87,7 @@ struct sk_buff *tcp_gso_segment(struct sk_buff *skb,/* Packet is from an untrusted source, reset gso_segs. */ skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len, mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; segs =NULL ; goto out;net/ipv4/udp_offload.c +2
-4@@ -388,11 +388,22 @@ static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out; -if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, false); - mss =skb_shinfo (skb)->gso_size; + +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) {
net/ipv4/udp_offload.c static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, · line 403
Quoted 10 lines
net/ipv4/udp_offload.c +10
-0+if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ +skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len -sizeof (*uh), + mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; + + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, false);
I think it's better and cleaner to move those changes in __udp_gso_segment() as Willem suggests.
Quoted 16 lines
net/ipv4/udp_offload.c +3
-0+ } + } +if (unlikely (skb->len <= mss)) goto out;net/ipv6/udp_offload.c +0
-2@@ -43,11 +43,22 @@ static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out; -if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST ))
net/ipv6/udp_offload.c static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb, · line 53
Quoted 10 lines
net/ipv6/udp_offload.c +7
-2-return __udp_gso_segment (skb, features, true); - mss =skb_shinfo (skb)->gso_size; + +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) { +if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ +skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len -sizeof (*uh), + mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ;
Any reason you want to remove the DODGY here? Is this an optimization? We will lose the chance to recognize/validate it elsewhere.
Thanks
Quoted 27 lines
net/ipv6/udp_offload.c +8
-0+ + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, true); + } + } +if (unlikely (skb->len <= mss)) goto out;net/sctp/offload.c +2
-1@@ -65,6 +65,8 @@ static struct sk_buff *sctp_gso_segment(struct sk_buff *skb,skb_walk_frags (skb, frag_iter) pinfo->gso_segs++; + pinfo->gso_type &= ~SKB_GSO_DODGY ; + segs =NULL ; goto out; } --2.30.2
Quoted 95 lines · Jason Wang
Quoted 7 lines · Yan Zhai
SKB_GSO_DODGYbit indicates a GSO packet comes from an untrusted source. The canonical way is to recompute thegso_segsto avoid device driver issues. Afterwards, the DODGY bit can be removed to avoid re-check at the egress of later devices, e.g. packets can egress to a vlan device backed by a real NIC.Quoted 8 lines
Commit
1fd54773c267("udp: allow header check for dodgyGSO_UDP_L4packets.") checks DODGY bit for UDP, but for packets that can be fed directly to the device aftergso_segsreset, it actually falls through to fragmentation [1].Commit
90017accff61("sctp: Add GSO support") and commit3820c3f3e417("[TCP]: Resetgso_segsif packet is dodgy") both didn't remove the DODGY bit after recomputinggso_segs.If we try to fix two issues, we'd better use separate patches.
Quoted 47 lines
This change fixes the
GSO_UDP_L4handling case, and remove the DODGY bit at other places.Fixes 90017accff61 ("sctp: Add GSO support")Fixes 3820c3f3e417 ("[TCP]: Reset gso_segs if packet is dodgy")Fixes 1fd54773c267 ("udp: allow header check for dodgy GSO_UDP_L4 packets.")Signed-off-by Yan Zhai <[email protected]>---
[1]:
https://lore.kernel.org/all/CAJPywTKDdjtwkLVUW6LRA2FU912qcDmQOQGt2WaDo28KzYDg+A@mail.gmail.com/--- net/ipv4/tcp_offload.c | 1 + net/ipv4/udp_offload.c | 19 +++++++++++++++---- net/ipv6/udp_offload.c | 19 +++++++++++++++---- net/sctp/offload.c | 2 ++ 4 files changed, 33 insertions(+), 8 deletions(-)net/ipv4/tcp_offload.c +1
-0@@ -87,6 +87,7 @@ struct sk_buff *tcp_gso_segment(struct sk_buff *skb,/* Packet is from an untrusted source, reset gso_segs. */ skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len, mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; segs =NULL ; goto out;net/ipv4/udp_offload.c +2
-4@@ -388,11 +388,22 @@ static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out; -if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, false); - mss =skb_shinfo (skb)->gso_size; + +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) {net/ipv4/udp_offload.c static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, · line 403
Quoted 10 lines
net/ipv4/udp_offload.c +10
-0+if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ +skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len -sizeof (*uh), + mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; + + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, false);I think it's better and cleaner to move those changes in
__udp_gso_segment()as Willem suggests.Quoted 14 lines
net/ipv4/udp_offload.c +3
-0+ } + } +if (unlikely (skb->len <= mss)) goto out;net/ipv6/udp_offload.c +0
-0@@ -43,11 +43,22 @@ static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out;
Quoted 16 lines
net/ipv6/udp_offload.c static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb, · line 53
Quoted 12 lines
net/ipv6/udp_offload.c +7
-4-if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, true); - mss =skb_shinfo (skb)->gso_size; + +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) { +if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ +skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len -sizeof (*uh), + mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ;Any reason you want to remove the DODGY here? Is this an optimization? We will lose the chance to recognize/validate it elsewhere.
It is intended as a small optimization. And this is in fact the piece I am not fully confident about: after validating the gso_segs at a trusted location (i.e. assuming the kernel is the trusted computing base), do we need to validate it somewhere else? For example, in our scenario, we have a tun/tap device in a net namespace, so the packet going out will enter from the tap, get forwarded through an veth, and then a vlan backed by a real ethernet interface. If the bit is carried over, then at each egress of these devices, we need to enter the GSO code, which feels pretty redundant as long as the packet does not leave kernel space. WDYT?
thanks
Quoted 30 lines
Thanks
Quoted 27 lines
net/ipv6/udp_offload.c +8
-0+ + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, true); + } + } +if (unlikely (skb->len <= mss)) goto out;net/sctp/offload.c +2
-1@@ -65,6 +65,8 @@ static struct sk_buff *sctp_gso_segment(struct sk_buff *skb,skb_walk_frags (skb, frag_iter) pinfo->gso_segs++; + pinfo->gso_type &= ~SKB_GSO_DODGY ; + segs =NULL ; goto out; } --2.30.2
Signature · 1 line
Yan
Paolo Abeni
maintainerQuoted 112 lines · Yan Zhai
Quoted 95 lines · Jason Wang
Quoted 7 lines · Yan Zhai
SKB_GSO_DODGYbit indicates a GSO packet comes from an untrusted source. The canonical way is to recompute thegso_segsto avoid device driver issues. Afterwards, the DODGY bit can be removed to avoid re-check at the egress of later devices, e.g. packets can egress to a vlan device backed by a real NIC.Quoted 8 lines
Commit
1fd54773c267("udp: allow header check for dodgyGSO_UDP_L4packets.") checks DODGY bit for UDP, but for packets that can be fed directly to the device aftergso_segsreset, it actually falls through to fragmentation [1].Commit
90017accff61("sctp: Add GSO support") and commit3820c3f3e417("[TCP]: Resetgso_segsif packet is dodgy") both didn't remove the DODGY bit after recomputinggso_segs.If we try to fix two issues, we'd better use separate patches.
Quoted 47 lines
This change fixes the
GSO_UDP_L4handling case, and remove the DODGY bit at other places.Fixes 90017accff61 ("sctp: Add GSO support")Fixes 3820c3f3e417 ("[TCP]: Reset gso_segs if packet is dodgy")Fixes 1fd54773c267 ("udp: allow header check for dodgy GSO_UDP_L4 packets.")Signed-off-by Yan Zhai <[email protected]>---
[1]:
https://lore.kernel.org/all/CAJPywTKDdjtwkLVUW6LRA2FU912qcDmQOQGt2WaDo28KzYDg+A@mail.gmail.com/--- net/ipv4/tcp_offload.c | 1 + net/ipv4/udp_offload.c | 19 +++++++++++++++---- net/ipv6/udp_offload.c | 19 +++++++++++++++---- net/sctp/offload.c | 2 ++ 4 files changed, 33 insertions(+), 8 deletions(-)net/ipv4/tcp_offload.c +1
-0@@ -87,6 +87,7 @@ struct sk_buff *tcp_gso_segment(struct sk_buff *skb,/* Packet is from an untrusted source, reset gso_segs. */ skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len, mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; segs =NULL ; goto out;net/ipv4/udp_offload.c +2
-4@@ -388,11 +388,22 @@ static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out; -if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, false); - mss =skb_shinfo (skb)->gso_size; + +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) {net/ipv4/udp_offload.c static struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, · line 403
Quoted 10 lines
net/ipv4/udp_offload.c +10
-0+if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ +skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len -sizeof (*uh), + mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ; + + segs =NULL ; + goto out; + }else { +return __udp_gso_segment (skb, features, false);I think it's better and cleaner to move those changes in
__udp_gso_segment()as Willem suggests.Quoted 14 lines
net/ipv4/udp_offload.c +3
-0+ } + } +if (unlikely (skb->len <= mss)) goto out;net/ipv6/udp_offload.c +0
-0@@ -43,11 +43,22 @@ static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb,if (!pskb_may_pull (skb,sizeof (struct udphdr ))) goto out;Quoted 16 lines
net/ipv6/udp_offload.c static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb, · line 53
Quoted 12 lines
net/ipv6/udp_offload.c +7
-4-if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 && - !skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) -return __udp_gso_segment (skb, features, true); - mss =skb_shinfo (skb)->gso_size; + +if (skb_shinfo (skb)->gso_type &SKB_GSO_UDP_L4 ) { +if (skb_gso_ok (skb, features |NETIF_F_GSO_ROBUST )) { +/* Packet is from an untrusted source, reset actual gso_segs */ +skb_shinfo (skb)->gso_segs =DIV_ROUND_UP (skb->len -sizeof (*uh), + mss); +skb_shinfo (skb)->gso_type &= ~SKB_GSO_DODGY ;Any reason you want to remove the DODGY here? Is this an optimization? We will lose the chance to recognize/validate it elsewhere.
Quoted 10 lines
It is intended as a small optimization. And this is in fact the piece I am not fully confident about: after validating the
gso_segsat a trusted location (i.e. assuming the kernel is the trusted computing base), do we need to validate it somewhere else? For example, in our scenario, we have a tun/tap device in a net namespace, so the packet going out will enter from the tap, get forwarded through an veth, and then a vlan backed by a real ethernet interface. If the bit is carried over, then at each egress of these devices, we need to enter the GSO code, which feels pretty redundant as long as the packet does not leave kernel space. WDYT?
As an optimization, I think it should land on a different (net-next) patch. Additionally I think it should be possible to get a greater gain adding the ROBUST feature to virtual devices (but I'm not sure if syzkaller will be able to use that in nasty ways).
Cheers,
Paolo