Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider.
Critical: 0 · High: 1 · Medium: 0 · Low: 0 If you believe none of the issues are legitimate, please reply to each issue of Medium severity or higher and explain why the AI is wrong. If any of them are legitimate and you plan to respin, please let patchwork know by including "pw-bot: cr" as a separate line at the end of your reply (one such reply per series is enough). - [High] This patch caps extension headers per IPv6 GRO layer. -- ipv6: gro: limit the number of extension headers The patch caps the number of extension headers that ipv6_gro_pull_exthdrs() walks at IP6_MAX_EXT_HDRS_CNT, matching ip6_protocol_deliver_rcu(). The goal is to keep the GRO transport header offset from overflowing the 16-bit skb->transport_header and causing an out-of-bounds read in gro_receive_network_flush(). Link: https://lore.kernel.org/netdev/avTTQNyvwPP6LtGx@v4bel/ > diff --git a/net/ipv6/ip6_offload.c b/net/ipv6/ip6_offload.c > index 700f1861d8eb7..01642900c0fa3 100644 > --- a/net/ipv6/ip6_offload.c > +++ b/net/ipv6/ip6_offload.c > @@ -26,6 +26,7 @@ static int ipv6_gro_pull_exthdrs(struct sk_buff *skb, int > off, int proto) > { > const struct net_offload *ops = NULL; > struct ipv6_opt_hdr *opth; > + int exthdr_cnt = 0; > > for (;;) { > int len; > @@ -38,6 +39,13 @@ static int ipv6_gro_pull_exthdrs(struct sk_buff *skb, int > off, int proto) > if (!(ops->flags & INET6_PROTO_GSO_EXTHDR)) > break; > > + /* Same limit as ip6_protocol_deliver_rcu(). > + * @proto is left pointing to an extension header, > + * so that the caller does not aggregate this packet. > + */ > + if (unlikely(exthdr_cnt++ >= IP6_MAX_EXT_HDRS_CNT)) > + break; [Severity: High] Does this fully close the out-of-bounds read in gro_receive_network_flush()? exthdr_cnt is local and starts at 0 on every call. That bounds each ipv6_gro_receive() pass to roughly 40 + 12 * 2048 bytes, but it does not bound the transport offset of the whole packet. Within a single GRO pass, sit_ip6ip6_gro_receive() sets encap_mark and calls back into ipv6_gro_receive() for an inner IPv6 header. Each layer's ipv6_gro_pull_exthdrs() call is allowed another 12 extension headers: ipv6_gro_receive() ipv6_gro_pull_exthdrs() /* up to 12 exthdrs */ sit_ip6ip6_gro_receive() ipv6_gro_receive() ipv6_gro_pull_exthdrs() /* another 12 exthdrs */ skb->transport_header is also measured from skb->head, so headroom counts toward it. __ip6_tnl_rcv() in net/ipv6/ip6_tunnel.c hands the decapsulated skb back to GRO: gro_cells_receive(&tunnel->gro_cells, skb); The outer headers stay in the buffer as headroom. That outer layer was only checked by ip6_protocol_deliver_rcu(), which also allows 12 extension headers. Put together, headroom + outer + inner + inner-inner headers can add up to more than 65535 bytes inside one IPv6 datagram. At that point, this store in ipv6_gro_receive() silently wraps the __u16: skb_set_transport_header(skb, skb_gro_offset(skb)); inet_gro_receive() in net/ipv4/af_inet.c has the same pattern for an inner IPv4 header. Suppose a second packet of the same flow then arrives. tcp_gro_receive() takes th2 = tcp_hdr(p) at the wrapped offset. That offset lands in outer header bytes the sender controls, so the port check in tcp_gro_lookup() can be made to match. gro_receive_network_flush() then runs: int off = skb_transport_offset(p); ... flush = __gro_receive_network_flush(th, th2, p, off - NAPI_GRO_CB(p)->network_offset, false); off is negative here, so the u16 diff ends up large. In __gro_receive_network_flush(), nh2 = th2 - diff then points tens of KB before p->head. Isn't that the same out-of-bounds read this patch is meant to fix? The commit message notes that "offsets can still accumulate over nested encapsulations, so the places storing them should be hardened separately". The rest of the series adds skb_set_transport_header_careful() in ipv6_mc_check_exthdrs(), parse_ipv6hdr(), sctp_v6_err() and __udp6_lib_err_encap(). It does not touch the two GRO store sites in ipv6_gro_receive() and inet_gro_receive() that feed gro_receive_network_flush(). The patch carries Fixes: and Cc: stable. Should those two GRO sites also use skb_set_transport_header_careful(), and flush when it fails, so that backports close the reported read as well? > opth = skb_gro_header(skb, off + sizeof(*opth), off); > if (unlikely(!opth)) > break; -- Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261113124625.4010206-1-edumazet%40kernel.org _______________________________________________ dev mailing list [email protected] https://mail.openvswitch.org/mailman/listinfo/ovs-dev
