Description

In the Linux kernel, the following vulnerability has been resolved: RDMA/rxe: insert mcg into mcg_tree only after rxe_mcast_add() succeeds rxe_get_mcg() publishes a newly allocated multicast group in rxe->mcg_tree before programming the backing Ethernet multicast address with rxe_mcast_add(), which runs outside mcg_lock. A local userspace RDMA client reaches this path with ATTACH_MCAST on a UD QP; if rxe_mcast_add() then returns an error (for example -ENODEV when the backing netdev has been removed, or a propagated dev_mc_add() error), the unwind frees the published group without removing it from the tree. A later lookup of the same MGID dereferences the freed struct rxe_mcg from __rxe_lookup_mcg(). Fix this by keeping the new mcg private until rxe_mcast_add() succeeds. Split the tree publication into __rxe_publish_mcg(), call rxe_mcast_add() before taking the tree reference, and free the still-private mcg on failure. Because the group is never visible in mcg_tree until the multicast address is programmed, no concurrent caller can look it up or attach a QP to a group that is about to be torn down, so the error path needs no conditional unwind. If another caller publishes the same MGID while the address is being programmed, the post-add re-check under mcg_lock finds the winner; this caller then drops its private object and balances its own rxe_mcast_add() with rxe_mcast_del() before returning the winner. Reproduced by forcing the rxe_mcast_add() error return under KASAN: without the change the next attach to the same MGID reports a slab-use-after-free in __rxe_lookup_mcg(); with it the forced failure returns cleanly. A no-injection attach/detach regression, including a two-QP shared join/leave and re-attach, stays KASAN- and leak-clean.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "7.0",
  "pubDate": "2026-10-06T09:18:29.803Z",
  "pubdate": "2026-10-06T09:18:29.803Z",
  "executiveSummary": "A Use-After-Free (UAF) vulnerability exists in the Linux kernel's RDMA/rxe (Soft RoCE) implementation, specifically within the multicast group management logic. The vulnerability arises from an race condition during the attachment of a multicast group (MCG) to a UD Queue Pair (QP).\nThe flaw allows a local, authenticated userspace RDMA client to trigger a kernel-level memory corruption. When rxe_mcast_add() fails after a new MCG has already been published to the global mcg_tree, the system fails to remove the now-freed object from the tree. Subsequent lookups of the same MGID retrieve a pointer to freed memory, leading to a UAF condition.\nThis vulnerability poses a significant risk of kernel instability, including system crashes (kernel panic) or potential arbitrary code execution if an attacker can manipulate the heap state effectively. The exploitation requires local access and the ability to issue RDMA ATTACH_MCAST requests, typically available to users with access to RDMA device interfaces.",
  "technicalDetails": "The root cause of this vulnerability is improper synchronization and lifecycle management of the rxe_mcg structure within the RDMA/rxe driver. The original implementation followed an flawed sequence: it allocated and published a new multicast group (MCG) to the rxe->mcg_tree before confirming the successful programming of the backing Ethernet multicast address via rxe_mcast_add().\nUnder normal execution, rxe_mcast_add() may return an error, such as -ENODEV in scenarios where the underlying network interface has been hot-removed or due to internal failures in dev_mc_add(). Because the MCG was already inserted into the mcg_tree, the error handling path (unwind) failed to remove the MCG from the tree, leaving a dangling pointer in the tree's internal structure.\nThe exploitation flow proceeds as follows: 1) An attacker initiates an ATTACH_MCAST command for a specific MGID. 2) The kernel allocates an rxe_mcg object and prematurely publishes it to mcg_tree. 3) The kernel attempts to call rxe_mcast_add(); if this operation fails, the kernel proceeds to free the rxe_mcg memory, but the pointer remains resident in the global mcg_tree. 4) The attacker subsequently triggers another lookup for the same MGID using __rxe_lookup_mcg(). 5) The function retrieves the pointer to the now-freed memory, leading to a Use-After-Free condition when the code dereferences the struct rxe_mcg.\nThis vulnerability is reachable through the standard RDMA userspace API, specifically when interacting with a Soft RoCE (rxe) device. Because the lookup function performs operations on the object derived from the tree, it operates on a stale reference without any validation checks regarding the object's lifecycle state.\nThe fix necessitates decoupling the tree publication from the memory allocation. By keeping the new mcg private (local scope) until rxe_mcast_add() returns successfully, the kernel ensures that no other concurrent process can find or attach to a partially initialized or failing group. Upon success, the group is then published to the mcg_tree via __rxe_publish_mcg(). If the addition fails, the private memory is simply discarded, eliminating the possibility of a dangling pointer in the global lookup table."
}