A use-after-free vulnerability in the Linux kernel's dmaengine subsystem was fixed by adding a synchronize_rcu() call before freeing dma_device structures. The issue arose because dma_device_release() could free a device while concurrent RCU readers were still accessing it, leading to potential memory corruption.
A use-after-free vulnerability in the Linux kernel's netlink subsystem was fixed. The flaw involved freeing the nlk->groups bitmap while lockless readers could still access it, leading to potential use of freed memory. The fix involves deferring freeing until after an RCU grace period and adjusting memory publication order to ensure safe lockless reads.
SiYuan before 3.8.5 contains an information disclosure vulnerability that allows publish readers to read password-protected and publish-disabled database rows via the /api/export/preview endpoint. Attackers can request an export preview of a public document embedding a database view to obtain protected rows' primary-key text and cell values.
SiYuan before v3.8.5 contains an information disclosure vulnerability that allows read-only publish readers to learn metadata of publish-excluded documents through the getNotebookInfo endpoint. Attackers, including anonymous visitors when no reader password is set, can query publish-visible notebooks to obtain document count, size and modification timestamps of hidden documents.
A use-after-free vulnerability in the Linux kernel's Open vSwitch (OVS) flow table mask array was resolved. The issue occurs because the old mask array is retired before it is no longer reachable, causing a window where readers may access freed memory. This can lead to memory corruption and potential system instability.
A vulnerability in the Linux kernel's IPv6 multicast source filter removal function ip6_mc_del1_src() could cause concurrent readers to miss active sources and improperly examine deleted tombstone entries due to unsafe list pointer manipulation under RCU. This issue has been fixed by changing the handling of tombstone nodes to avoid mutating pointers before the RCU grace period elapses.
A vulnerability in the Linux kernel's IPv6 multicast source filter handling was fixed by changing to copy-on-write RCU updates in the ip6_mc_source() function. The flaw involved unsynchronized in-place mutation of source filter data structures, which could cause concurrent readers to observe torn IPv6 addresses or inconsistent source entries. This issue affects certain Linux kernel versions prior to 5.11 and version 5.13. The fix involves allocating and fully populating new filter data before publishing it, ensuring safe concurrent reads.
A vulnerability in the Linux kernel IPv6 multicast code involves improper use of pointer assignment for RCU-protected lists. The issue arises from direct pointer assignments instead of using rcu_assign_pointer(), which can cause race conditions with concurrent lockless readers. This flaw has been fixed by consistently applying rcu_assign_pointer() and appropriate dereference helpers.
A race condition vulnerability in the Linux kernel tracing subsystem (trace_pipe_raw) was fixed. The issue involved concurrent subbuffer resizes that could cause crashes or leak uninitialized memory to userspace. The fix involved changes to ring buffer read page handling to avoid race conditions and stale size values.
CVE-2026-97609 is a use-after-free vulnerability in the Linux kernel's netfilter cttimeout module. It occurs during module unload when the per-net operations are unregistered before clearing the timeout hook, allowing a race condition where a timeout hook may be dereferenced after its memory is freed. This flaw has been fixed by clearing the hook and waiting for existing readers to finish before unregistering per-net operations.
A vulnerability in the Linux kernel's netfilter nfnetlink_log component was resolved. The issue involved freeing per-network namespace state without waiting for an RCU grace period, potentially causing use-after-free conditions during concurrent packet processing. The fix ensures the pointer is cleared only after RCU readers have completed, preventing unsafe memory access.
In the Linux kernel, the following vulnerability has been resolved: rds: filter RDS_INFO_* getsockopt by caller's netns The RDS_INFO_* family of getsockopt(2) options reads several file-scope global lists that are not per-netns: rds_sock_info / rds6_sock_info, rds_sock_inc_info / rds6_sock_inc_info -> rds_sock_list rds_tcp_tc_info / rds6_tcp_tc_info -> rds_tcp_tc_list rds_conn_info / rds6_conn_info, rds_conn_message_info_cmn (for the *_SEND_MESSAGES and *_RETRANS_MESSAGES variants), rds_for_each_conn_info (for RDS_INFO_IB_CONNECTIONS) -> rds_conn_hash[] The handlers do not filter by the caller's network namespace. rds_info_getsockopt() has no netns or capable() check, and rds_create() has no capable() check, so AF_RDS is reachable from an unprivileged user namespace. As a result, an unprivileged caller in a fresh user_ns plus netns can read the bound address and sock inode of every RDS socket on the host, the peer address of incoming messages on every RDS socket on the host, the peer address and TCP sequence numbers of every rds-tcp connection on the host, and the peer address and RDS sequence numbers of every RDS connection on the host. The rds-tcp transport is reachable from a non-initial netns (see rds_set_transport()), so a one-shot init_net gate at rds_info_getsockopt() would deny legitimate per-netns visibility to rds-tcp callers. Instead, filter at each handler by comparing the netns of the caller's socket to the netns of the list entry, or to rds_conn_net(conn) for connection paths. Only copy entries whose netns matches the caller. Counters (RDS_INFO_COUNTERS) are aggregate statistics and remain global. Reproducer (KASAN VM, rds and rds_tcp loaded): an AF_RDS socket binds 127.0.0.1:4242 in init_net as root. A child process enters a fresh user_ns plus netns and opens AF_RDS there, then calls getsockopt(SOL_RDS, RDS_INFO_SOCKETS). Before this change, the child sees the init_net socket. After this change, the child sees zero entries. Drop the rds_sock_count, rds_tcp_tc_count, and rds6_tcp_tc_count globals. v2 used them for the size precheck and lens->nr; v3 replaced the precheck with a per-ns count from a first pass over the list, so the globals have no remaining readers. The matching increments and decrements in rds_create()/rds_destroy_sock() and rds_tcp_set_callbacks()/rds_tcp_restore_callbacks() go away with them. Reported by the kernel test robot under clang W=1.
Norwegian Cruise Line's door access controllers use RFID card readers that authenticate only by checking a static 7-byte UID from NFC credentials. This UID is not secret and does not involve cryptographic challenge-response, allowing attackers to clone keycards by capturing and replaying the UID. Such cloned cards grant unauthorized access to restricted areas on cruise ships, posing significant safety risks. No vendor fix or patch is currently available. Users are advised to use RFID-blocking wallets, shielded sleeves, or physical barriers like aluminum foil to reduce the risk of unauthorized scanning.