Mitigate a side channel in routing exception caches
Subsystems (6)
Ido Schimmel
maintainerv2 cover Mitigate a side channel in routing exception caches
When an ICMP error that quotes a UDP packet is locally delivered, the kernel only creates a routing exception if the quoted packet matches a socket. This allows an off-path attacker to conduct a side-channel attack on the routing exception caches in order to discover the ephemeral ports used by connected UDP sockets.
Previous mitigations tried to make it harder for attackers to find hash collisions in these caches and make the eviction of exceptions less predictable. Amit Klein and Noam Caspi demonstrated that both of these mitigations can be bypassed.
This patchset tries to mitigate such attacks by always creating an exception, even before trying to find a matching socket. The exception is created by the same helpers that are used when the quoted packet did not originate from a socket, so that guesses (right or wrong) from an off-path attacker always result in an exception being created or updated in the cache that the attacker can observe.
Note that this mitigation does not make it easier for attackers to fill these caches, since they can already create exceptions with little to no validation. For example, by sending an ICMP error that quotes an ICMP Echo Reply or one that quotes a UDP source port that matches a wildcard socket.
In the good case (matched socket) this comes at the cost of an extra route lookup, as the exception is created before the one performed by the socket path. When the two lookups resolve to different nexthops, an exception is created in the cache of each.
Patch #1 fixes a pre-existing bug in the handling of ICMPv6 Redirect Message packets. Discovered while writing the selftest.
Patch #2 creates an exception from the IPv4 UDP code even before socket matching. Other socket types do not need this: raw sockets have no ports, and for TCP the ICMP error is discarded unless the quoted sequence number is in window.
Patch #3 does the same for IPv6.
Patch #4 adds a selftest.
v2:
- Patch #2: Create exceptions unconditionally.
- Patch #3: Same.
- Patch #4: Add error checking in topology_setup(). Check for the arrival of an ICMP error in pmtu_socket().
v1: https://lore.kernel.org/netdev/[email protected]/
Ido Schimmel (4):
ipv6: Fix redirect exception creation for UDP/RAW sockets
ipv4: udp: Create exceptions before socket matching
ipv6: udp: Create exceptions before socket matching
selftests: net: Add exception cache tests
net/ipv4/udp.c | 11 + net/ipv6/route.c | 2 +- net/ipv6/udp.c | 13 + tools/testing/selftests/net/Makefile | 1 + .../testing/selftests/net/exception_cache.sh | 521 ++++++++++++++++++ 5 files changed, 547 insertions(+), 1 deletion(-) create mode 100755 tools/testing/selftests/net/exception_cache.sh
Signature · 1 line
2.55.0
Ido Schimmel
maintainerPATCH v2 1/4 ipv6: Fix redirect exception creation for UDP/RAW sockets
When an ICMP Redirect Message is matched to a socket, both IPv4 and IPv6 verify that the source IP of the ICMP packet is the current gateway for the quoted packet. Both also pass the socket's bound device as the expected nexthop device.
The difference is that IPv4 treats "oif=0" as "any", whereas IPv6 always requires an exact match (see ip6_redirect_nh_match()), since the gateway address is usually a link-local address.
Therefore, when an IPv6 UDP/RAW socket is not bound to a device, the above verification fails and an exception is not created. This also happens when the socket is bound to a VRF, as l3mdev_update_flow() resets the oif to 0.
Fix this by passing the ifindex of the ingress device as the expected nexthop device. This is consistent with the existing callers of ip6_redirect(). Note that for ICMPv6 Redirect Message packets the VRF driver does not reset skb->dev to the VRF device, so skb->dev is correct, even when it is a VRF port.
--- net/ipv6/route.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
net/ipv6/route.c +1 -1
@@ -3255,7 +3255,7 @@ void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif)void ip6_sk_redirect (struct sk_buff *skb,struct sock *sk) { -ip6_redirect (skb,sock_net (sk), sk->sk_bound_dev_if, +ip6_redirect (skb,sock_net (sk), skb->dev->ifindex,READ_ONCE (sk->sk_mark),sk_uid (sk)); }
Signature · 1 line
2.55.0
Ido Schimmel
maintainerPATCH v2 2/4 ipv4: udp: Create exceptions before socket matching
In reply to Ido SchimmelCurrently, when ICMP Fragmentation Needed and Redirect Message packets are locally delivered and quote a UDP packet, a FIB nexthop exception (FNHE) is only created if the kernel can match the UDP packet to an existing socket.
This behavior allows off-path attackers to conduct a side-channel attack on the FNHE cache in order to discover the ephemeral port used by a connected UDP socket.
Commit 6457378fe796 ("ipv4: use siphash instead of Jenkins in fnhe_hashfun()") and commit 67d6d681e15b ("ipv4: make exception cache less predictible") tried to mitigate such attacks by making it harder for attackers to discover hash collisions in the FNHE cache and by randomizing the number of exceptions a hash bucket can hold, respectively. Unfortunately, both of the mitigations can be bypassed.
Instead, mitigate such attacks by always creating a FNHE, even before trying to find a matching socket. Do that by calling ipv4_update_pmtu() and ipv4_redirect(), the helpers used when the quoted packet did not originate from a socket.
This means that guesses (right or wrong) from an off-path attacker will always result in a FNHE being created or updated in the cache that the attacker can observe.
Pass an oif of 0, in a similar fashion to icmp_err(). This is also the oif used by the socket path for sockets that are not bound to a device.
Note that this does not allow attackers to create FNHEs that they could not create before, as both helpers can already be reached with little to no validation. For example, by sending an ICMP error that quotes an ICMP Echo Reply or one that quotes a UDP source port that matches a wildcard socket.
Also note that in the good case (matched socket) the above scheme comes at the cost of an extra route lookup, as the no socket helpers perform their own lookup before the one performed by ipv4_sk_update_pmtu() / ipv4_sk_redirect(). When the two resolve to different nexthops, it also results in two exceptions being created for the same destination IP. One in the FNHE cache of the nexthop resolved by the no socket helpers and another in the FNHE cache of the nexthop used by the socket.
--- net/ipv4/udp.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
net/ipv4/udp.c +11 -0
@@ -900,6 +900,15 @@ static struct sock *__udp4_lib_err_encap(struct net *net,return sk; } +static void udp_err_update_exception (struct net *net,struct sk_buff *skb, +int type,int code,u32 info) +{ +if (type ==ICMP_DEST_UNREACH && code ==ICMP_FRAG_NEEDED ) +ipv4_update_pmtu (skb, net, info,0 ,IPPROTO_UDP ); +else if (type ==ICMP_REDIRECT ) +ipv4_redirect (skb, net,0 ,IPPROTO_UDP ); +} +/* * This routine is called by the ICMP module when it gets some * sort of error condition. If err < 0 then the socket should
@@ -923,6 +932,8 @@ int udp_err(struct sk_buff *skb, u32 info)int harderr;int err; +udp_err_update_exception (net, skb, type, code, info); + uh = (struct udphdr *)(skb->data + (iph->ihl <<2 )); sk = __udp4_lib_lookup(net, iph->daddr, uh->dest, iph->saddr, uh->source, skb->dev->ifindex,
Signature · 1 line
2.55.0
Re: [PATCH net v2 2/4] ipv4: udp: Create exceptions before socket matching
Quoted 42 lines · Ido Schimmel
Currently, when ICMP Fragmentation Needed and Redirect Message packets are locally delivered and quote a UDP packet, a FIB nexthop exception (FNHE) is only created if the kernel can match the UDP packet to an existing socket.
This behavior allows off-path attackers to conduct a side-channel attack on the FNHE cache in order to discover the ephemeral port used by a connected UDP socket.
Commit
6457378fe796("ipv4: use siphash instead of Jenkins infnhe_hashfun()") and commit67d6d681e15b("ipv4: make exception cache less predictible") tried to mitigate such attacks by making it harder for attackers to discover hash collisions in the FNHE cache and by randomizing the number of exceptions a hash bucket can hold, respectively. Unfortunately, both of the mitigations can be bypassed.Instead, mitigate such attacks by always creating a FNHE, even before trying to find a matching socket. Do that by calling
ipv4_update_pmtu()andipv4_redirect(), the helpers used when the quoted packet did not originate from a socket.This means that guesses (right or wrong) from an off-path attacker will always result in a FNHE being created or updated in the cache that the attacker can observe.
Pass an oif of 0, in a similar fashion to
icmp_err(). This is also the oif used by the socket path for sockets that are not bound to a device.Note that this does not allow attackers to create FNHEs that they could not create before, as both helpers can already be reached with little to no validation. For example, by sending an ICMP error that quotes an ICMP Echo Reply or one that quotes a UDP source port that matches a wildcard socket.
Also note that in the good case (matched socket) the above scheme comes at the cost of an extra route lookup, as the no socket helpers perform their own lookup before the one performed by
ipv4_sk_update_pmtu()/ipv4_sk_redirect(). When the two resolve to different nexthops, it also results in two exceptions being created for the same destination IP. One in the FNHE cache of the nexthop resolved by the no socket helpers and another in the FNHE cache of the nexthop used by the socket.
Quoted 9 lines
Fixes 4895c771c7f0 ("ipv4: Add FIB nexthop exceptions.")Reported-by Amit Klein <[email protected]>Reported-by Noam Caspi <[email protected]>Signed-off-by Ido Schimmel <[email protected]>--- net/ipv4/udp.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
Ido Schimmel
maintainerRe: [PATCH net v2 2/4] ipv4: udp: Create exceptions before socket matching
In reply to Ido SchimmelQuoted 34 lines · Ido Schimmel
Currently, when ICMP Fragmentation Needed and Redirect Message packets are locally delivered and quote a UDP packet, a FIB nexthop exception (FNHE) is only created if the kernel can match the UDP packet to an existing socket.
This behavior allows off-path attackers to conduct a side-channel attack on the FNHE cache in order to discover the ephemeral port used by a connected UDP socket.
Commit
6457378fe796("ipv4: use siphash instead of Jenkins infnhe_hashfun()") and commit67d6d681e15b("ipv4: make exception cache less predictible") tried to mitigate such attacks by making it harder for attackers to discover hash collisions in the FNHE cache and by randomizing the number of exceptions a hash bucket can hold, respectively. Unfortunately, both of the mitigations can be bypassed.Instead, mitigate such attacks by always creating a FNHE, even before trying to find a matching socket. Do that by calling
ipv4_update_pmtu()andipv4_redirect(), the helpers used when the quoted packet did not originate from a socket.This means that guesses (right or wrong) from an off-path attacker will always result in a FNHE being created or updated in the cache that the attacker can observe.
Pass an oif of 0, in a similar fashion to
icmp_err(). This is also the oif used by the socket path for sockets that are not bound to a device.Note that this does not allow attackers to create FNHEs that they could not create before, as both helpers can already be reached with little to no validation. For example, by sending an ICMP error that quotes an ICMP Echo Reply or one that quotes a UDP source port that matches a wildcard socket.
Quoted 7 lines
Also note that in the good case (matched socket) the above scheme comes at the cost of an extra route lookup, as the no socket helpers perform their own lookup before the one performed by
ipv4_sk_update_pmtu()/ipv4_sk_redirect(). When the two resolve to different nexthops, it also results in two exceptions being created for the same destination IP. One in the FNHE cache of the nexthop resolved by the no socket helpers and another in the FNHE cache of the nexthop used by the socket.
tl;dr - I don't think anything needs to change here following the Sashiko feedback [1].
"Does the hard-coded oif of 0 leave the oracle intact for device-bound, VRF-bound and policy-routed sockets?"
No. An attacker needs to be able to populate the exception cache of the nexthop used by the socket. If this cache is not reachable via the no-socket helpers (e.g., because the socket is VRF bound), then the side channel doesn't exist.
"This isn't a bug, but the new call runs before any socket is known, so the per-socket opt-out that ipv4_sk_update_pmtu() honours is bypassed:
[...]
For a socket that set IP_PMTUDISC_INTERFACE or IP_PMTUDISC_OMIT, an ICMP Frag Needed quoting its traffic previously created no PMTU state; now an exception is installed on the nexthop resolved from the quoted packet.
The socket itself is unaffected, since ip_skb_dst_mtu() returns min(dst_dev(dst)->mtu, IP_MAX_MTU) when ip_sk_use_pmtu(sk) is false, and the same socket-less creation is already remotely reachable through icmp_err() -> ipv4_update_pmtu(skb, net, info, 0, IPPROTO_ICMP). The selftest patch in this series also asserts this as the intended behaviour ("a socket which disabled PMTU discovery using IP{,V6}_PMTUDISC_OMIT gets the same exception as the other cases").
Could a sentence be added to the changelog noting that the per-socket IP_PMTUDISC_INTERFACE / IP_PMTUDISC_OMIT opt-out no longer suppresses exception creation?"
I don't see a reason to mention this. Exceptions are per-destination constructs and they could have been created for destinations used by IP_PMTUDISC_OMIT sockets even before this patch.
[1] https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20260828192344.2596928-1-idosch%40nvidia.com
Ido Schimmel
maintainerPATCH v2 3/4 ipv6: udp: Create exceptions before socket matching
In reply to Ido SchimmelCurrently, when ICMPv6 Packet Too Big and Redirect Message packets are locally delivered and quote a UDP packet, an exception is only created in the IPv6 exception cache if the kernel can match the UDP packet to an existing socket.
This behavior allows off-path attackers to conduct a side-channel attack on the exception cache in order to discover the ephemeral port used by a connected UDP socket.
Commit 4785305c05b2 ("ipv6: use siphash in rt6_exception_hash()") and commit a00df2caffed ("ipv6: make exception cache less predictible") tried to mitigate such attacks by making it harder for attackers to discover hash collisions in the exception cache and by randomizing the number of exceptions a hash bucket can hold, respectively. Unfortunately, both of the mitigations can be bypassed.
Instead, mitigate such attacks by always creating an exception, even before trying to find a matching socket. Do that by calling ip6_update_pmtu() and ip6_redirect(), the helpers used when the quoted packet did not originate from a socket.
This means that guesses (right or wrong) from an off-path attacker will always result in an exception being created or updated in the cache that the attacker can observe.
Pass the ifindex of the ingress device and the default uid, in a similar fashion to icmpv6_err(). Unlike IPv4, an oif of 0 would not match any nexthop in ip6_redirect_nh_match() and no exception would be created in response to a Redirect Message.
Note that this does not allow attackers to create exceptions that they could not create before, as both helpers can already be reached with little to no validation. For example, by sending an ICMPv6 error that quotes an ICMPv6 Echo Reply or one that quotes a UDP source port that matches a wildcard socket.
Also note that in the good case (matched socket) the above scheme comes at the cost of an extra route lookup, as the no socket helpers perform their own lookup before the one performed by ip6_sk_update_pmtu() / ip6_sk_redirect(). When the two resolve to different nexthops, it also results in two exceptions being created for the same destination IP. One in the exception cache of the nexthop resolved by the no socket helpers and another in the exception cache of the nexthop used by the socket.
--- net/ipv6/udp.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
net/ipv6/udp.c +13 -0
@@ -690,6 +690,17 @@ static struct sock *__udp6_lib_err_encap(struct net *net,return sk; } +static void udpv6_err_update_exception (struct net *net,struct sk_buff *skb, +u8 type,__be32 info) +{ +if (type ==ICMPV6_PKT_TOOBIG ) +ip6_update_pmtu (skb, net, info, skb->dev->ifindex,0 , +sock_net_uid (net,NULL )); +else if (type ==NDISC_REDIRECT ) +ip6_redirect (skb, net, skb->dev->ifindex,0 , +sock_net_uid (net,NULL )); +} +static int udpv6_err (struct sk_buff *skb,struct inet6_skb_parm *opt,u8 type,u8 code,int offset,__be32 info) {
@@ -703,6 +714,8 @@ static int udpv6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,int harderr;int err; +udpv6_err_update_exception (net, skb, type, info); + daddr =seg6_get_daddr (skb, opt) ? : &hdr->daddr; saddr = &hdr->saddr; sk = __udp6_lib_lookup(net, daddr, uh->dest, saddr, uh->source,
Signature · 1 line
2.55.0
Re: [PATCH net v2 3/4] ipv6: udp: Create exceptions before socket matching
Quoted 44 lines · Ido Schimmel
Currently, when ICMPv6 Packet Too Big and Redirect Message packets are locally delivered and quote a UDP packet, an exception is only created in the IPv6 exception cache if the kernel can match the UDP packet to an existing socket.
This behavior allows off-path attackers to conduct a side-channel attack on the exception cache in order to discover the ephemeral port used by a connected UDP socket.
Commit
4785305c05b2("ipv6: use siphash inrt6_exception_hash()") and commita00df2caffed("ipv6: make exception cache less predictible") tried to mitigate such attacks by making it harder for attackers to discover hash collisions in the exception cache and by randomizing the number of exceptions a hash bucket can hold, respectively. Unfortunately, both of the mitigations can be bypassed.Instead, mitigate such attacks by always creating an exception, even before trying to find a matching socket. Do that by calling
ip6_update_pmtu()andip6_redirect(), the helpers used when the quoted packet did not originate from a socket.This means that guesses (right or wrong) from an off-path attacker will always result in an exception being created or updated in the cache that the attacker can observe.
Pass the ifindex of the ingress device and the default uid, in a similar fashion to
icmpv6_err(). Unlike IPv4, an oif of 0 would not match any nexthop inip6_redirect_nh_match()and no exception would be created in response to a Redirect Message.Note that this does not allow attackers to create exceptions that they could not create before, as both helpers can already be reached with little to no validation. For example, by sending an ICMPv6 error that quotes an ICMPv6 Echo Reply or one that quotes a UDP source port that matches a wildcard socket.
Also note that in the good case (matched socket) the above scheme comes at the cost of an extra route lookup, as the no socket helpers perform their own lookup before the one performed by
ip6_sk_update_pmtu()/ip6_sk_redirect(). When the two resolve to different nexthops, it also results in two exceptions being created for the same destination IP. One in the exception cache of the nexthop resolved by the no socket helpers and another in the exception cache of the nexthop used by the socket.
Quoted 9 lines
Fixes 2b760fcf5cfb ("ipv6: hook up exception table to store dst cache")Reported-by Amit Klein <[email protected]>Reported-by Noam Caspi <[email protected]>Signed-off-by Ido Schimmel <[email protected]>--- net/ipv6/udp.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
Ido Schimmel
maintainerRe: [PATCH net v2 3/4] ipv6: udp: Create exceptions before socket matching
In reply to Ido SchimmelQuoted 36 lines · Ido Schimmel
Currently, when ICMPv6 Packet Too Big and Redirect Message packets are locally delivered and quote a UDP packet, an exception is only created in the IPv6 exception cache if the kernel can match the UDP packet to an existing socket.
This behavior allows off-path attackers to conduct a side-channel attack on the exception cache in order to discover the ephemeral port used by a connected UDP socket.
Commit
4785305c05b2("ipv6: use siphash inrt6_exception_hash()") and commita00df2caffed("ipv6: make exception cache less predictible") tried to mitigate such attacks by making it harder for attackers to discover hash collisions in the exception cache and by randomizing the number of exceptions a hash bucket can hold, respectively. Unfortunately, both of the mitigations can be bypassed.Instead, mitigate such attacks by always creating an exception, even before trying to find a matching socket. Do that by calling
ip6_update_pmtu()andip6_redirect(), the helpers used when the quoted packet did not originate from a socket.This means that guesses (right or wrong) from an off-path attacker will always result in an exception being created or updated in the cache that the attacker can observe.
Pass the ifindex of the ingress device and the default uid, in a similar fashion to
icmpv6_err(). Unlike IPv4, an oif of 0 would not match any nexthop inip6_redirect_nh_match()and no exception would be created in response to a Redirect Message.Note that this does not allow attackers to create exceptions that they could not create before, as both helpers can already be reached with little to no validation. For example, by sending an ICMPv6 error that quotes an ICMPv6 Echo Reply or one that quotes a UDP source port that matches a wildcard socket.
Quoted 7 lines
Also note that in the good case (matched socket) the above scheme comes at the cost of an extra route lookup, as the no socket helpers perform their own lookup before the one performed by
ip6_sk_update_pmtu()/ip6_sk_redirect(). When the two resolve to different nexthops, it also results in two exceptions being created for the same destination IP. One in the exception cache of the nexthop resolved by the no socket helpers and another in the exception cache of the nexthop used by the socket.
tl;dr - Same as patch 2. No changes following the feedback from Sashiko.
"Can the Packet Too Big path still leave the guess/no-guess difference visible when the two lookups resolve to different nexthops?"
No. The side channel only exists if the attacker can populate the exception cache of the nexthop used by the socket.
Ido Schimmel
maintainerPATCH v2 4/4 selftests: net: Add exception cache tests
In reply to Ido SchimmelAdd a test for the IPv4 and IPv6 exception caches, covering the exceptions that are created in response to ICMP errors quoting a UDP packet.
The topology consists of a host (h1) that reaches a remote host (h2) via a router (r1), with a second router (r2) attached to the segment shared by h1 and r1. UDP packets are injected using a packet socket, so that an ICMP error quoting them is only matched to a socket when one was opened separately with the same source port. PMTU errors are provoked by lowering the MTU of the far end of the path and redirects by pointing r1's route towards h2 back over the segment it received the packet from.
The following is tested for both address families and for both PMTU and redirect exceptions:
* An error that is not matched to a socket creates an exception that carries the new MTU or gateway.
* An error that is matched to a socket creates the same exception.
The PMTU tests further verify that a lower PMTU replaces the one stored in the exception whereas a higher one does not, and that a socket which disabled PMTU discovery using IP{,V6}_PMTUDISC_OMIT gets the same exception as the other cases.
Without "ipv4: udp: Create exceptions before socket matching" and "ipv6:
udp: Create exceptions before socket matching", the tests that do not open a socket fail:
# ./exception_cache.sh
TEST: IPv4: PMTU: exception without a matching socket [FAIL]
No socket: exception does not carry an MTU of 1400
TEST: IPv6: PMTU: exception without a matching socket [FAIL]
No socket: exception does not carry an MTU of 1400
TEST: IPv4: PMTU: exception with a matching socket [ OK ]
TEST: IPv6: PMTU: exception with a matching socket [ OK ]
TEST: IPv4: PMTU: exception with a socket ignoring it [FAIL]
PMTU discovery disabled: exception does not carry an MTU of 1400
TEST: IPv6: PMTU: exception with a socket ignoring it [FAIL]
PMTU discovery disabled: exception does not carry an MTU of 1400
TEST: IPv4: Redirect: exception without a matching socket [FAIL]
No socket: exception does not carry the new gateway
TEST: IPv6: Redirect: exception without a matching socket [FAIL]
No socket: exception does not carry the new gateway
TEST: IPv4: Redirect: exception with a matching socket [ OK ]
TEST: IPv6: Redirect: exception with a matching socket [ OK ]--- tools/testing/selftests/net/Makefile | 1 + .../testing/selftests/net/exception_cache.sh | 521 ++++++++++++++++++ 2 files changed, 522 insertions(+) create mode 100755 tools/testing/selftests/net/exception_cache.sh
tools/testing/selftests/net/Makefile +1 -0
@@ -28,6 +28,7 @@ TEST_PROGS := \ double_udp_encap.sh \ drop_monitor_tests.sh \ ecmp_rehash.sh \ + exception_cache.sh \ fcnal-ipv4.sh \ fcnal-ipv6.sh \ fcnal-other.sh \
tools/testing/selftests/net/exception_cache.sh new file +521 -0
521 lines not on this page · raw message
Signature · 1 line
2.55.0
Ido Schimmel
maintainerRe: [PATCH net v2 4/4] selftests: net: Add exception cache tests
Quoted 19 lines · Ido Schimmel
Add a test for the IPv4 and IPv6 exception caches, covering the exceptions that are created in response to ICMP errors quoting a UDP packet.
The topology consists of a host (h1) that reaches a remote host (h2) via a router (r1), with a second router (r2) attached to the segment shared by h1 and r1. UDP packets are injected using a packet socket, so that an ICMP error quoting them is only matched to a socket when one was opened separately with the same source port. PMTU errors are provoked by lowering the MTU of the far end of the path and redirects by pointing r1's route towards h2 back over the segment it received the packet from.
The following is tested for both address families and for both PMTU and redirect exceptions:
* An error that is not matched to a socket creates an exception that carries the new MTU or gateway.
* An error that is matched to a socket creates the same exception.
Quoted 8 lines
The PMTU tests further verify that a lower PMTU replaces the one stored in the exception whereas a higher one does not, and that a socket which disabled PMTU discovery using IP{,V6}_PMTUDISC_OMIT gets the same exception as the other cases.
Without "ipv4: udp: Create exceptions before socket matching" and "ipv6:
udp: Create exceptions before socket matching", the tests that do not open a socket fail:
Both of the comments from Sashiko are nits. The test passes when it should and fails otherwise, so it's doing its job.
"
This isn't a bug, but a question about what the "with a socket" cases assert. pmtu_socket(), pmtu_omit() and redirect_socket() only look at the route exception, and with the two accompanying kernel changes that exception is created before the socket lookup:
"
It asserts that an exception is created regardless of whether the ICMP error matched a socket or not.
"
Is the ICMP input counter a strong enough barrier for this check? "
Yes.
This series was applied to netdev/net.git (main) by Jakub Kicinski <[email protected]>:
Hello:
This series was applied to netdev/net.git (main)
by Jakub Kicinski <[email protected]>:
Quoted 6 lines · On Fri, 28 Aug 2026 22:23:40 +0300 you wrote:
When an ICMP error that quotes a UDP packet is locally delivered, the kernel only creates a routing exception if the quoted packet matches a socket. This allows an off-path attacker to conduct a side-channel attack on the routing exception caches in order to discover the ephemeral ports used by connected UDP sockets.
Quoted 6 lines
Previous mitigations tried to make it harder for attackers to find hash collisions in these caches and make the eviction of exceptions less predictable. Amit Klein and Noam Caspi demonstrated that both of these mitigations can be bypassed.
[...]
Here is the summary with links:
- [net,v2,1/4] ipv6: Fix redirect exception creation for UDP/RAW sockets
https://git.kernel.org/netdev/net/c/cd51b74bdd0b - [net,v2,2/4] ipv4: udp: Create exceptions before socket matching https://git.kernel.org/netdev/net/c/4c3499f79f8c - [net,v2,3/4] ipv6: udp: Create exceptions before socket matching https://git.kernel.org/netdev/net/c/ac76cab50e89 - [net,v2,4/4] selftests: net: Add exception cache tests https://git.kernel.org/netdev/net/c/c923c14942b1
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html