Vulnerabilities

In the Linux kernel, the following vulnerability has been resolved:<br /> <br /> eventfs: Fix use-after-free in eventfs_remove_rec()<br /> <br /> eventfs_remove_rec() recursively removes the child at the current loop<br /> position. After the recursive call returns, list_for_each_entry() advances<br /> by reading list.next from the removed child.<br /> <br /> If free_ei() drops the final reference, release_ei() reuses the list/rcu<br /> union to queue an SRCU callback. The child may be freed before that read.<br /> The eventfs_mutex serializes list updates, but it does not keep the removed<br /> child alive or prevent the SRCU callback from running.<br /> <br /> Use list_for_each_entry_safe() to save the next sibling before recursively<br /> removing the current child.

In the Linux kernel, the following vulnerability has been resolved:<br /> <br /> KVM: SVM: Serialize accesses to the owner and mirror list with separate lock<br /> <br /> Interaction between KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM and<br /> KVM_CAP_VM_COPY_ENC_CONTEXT_FROM can cause two separate issues:<br /> <br /> - in sev_migrate_from(), when the destination KVM is a mirror, the mirror<br /> entry is moved from the source&amp;#39;s list to the owner&amp;#39;s mirror_vms list,<br /> without holding the owner&amp;#39;s lock unlike other writers of the owner&amp;#39;s<br /> mirror list (sev_vm_copy_enc_context_from(), sev_vm_destroy()).<br /> A concurrent COPY or destroy can race with sev_migrate_from() and<br /> corrupt the list.<br /> <br /> - In sev_vm_destroy(), the *owner* is still active and could receive<br /> concurrently a KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM that causes<br /> sev-&gt;enc_context_owner to change. In this case the incorrect VM<br /> receives kvm_put_kvm().<br /> <br /> The second issue needs particular care because the owner could disappear<br /> altogether (even though the race window is impossibly small) between<br /> reading it and locking it. There is thus no way to perform the checks<br /> under the owner lock without putting struct kvm under SLAB_TYPESAFE_BY_RCU<br /> (which would allow kvm_get_kvm_safe() under RCU critical section).<br /> <br /> It is much simpler to just use a global lock, since the critical<br /> sections are so small and the new lock is always a leaf lock.

In the Linux kernel, the following vulnerability has been resolved:<br /> <br /> smb: client: Fix use-after-free in cifs_try_adding_channels()<br /> <br /> cifs_try_adding_channels() takes a temporary reference to an interface<br /> before dropping iface_lock. If cifs_ses_add_channel() fails, it drops<br /> that reference and then increments iface-&gt;weight_fulfilled.<br /> <br /> A concurrent interface list refresh can remove the list reference while<br /> channel creation is in progress. In that case, the failure-path<br /> kref_put() releases the last reference and frees iface. Updating<br /> weight_fulfilled afterward then accesses freed memory.<br /> <br /> Increment weight_fulfilled before dropping the temporary reference,<br /> keeping iface alive for the final access.

In the Linux kernel, the following vulnerability has been resolved:<br /> <br /> tipc: read le-&gt;link under the node lock in tipc_node_link_down()<br /> <br /> tipc_node_link_down() caches the link pointer before taking n-&gt;lock:<br /> <br /> struct tipc_link *l = le-&gt;link; /* unlocked */<br /> <br /> if (!l)<br /> return;<br /> tipc_node_write_lock(n);<br /> if (!tipc_link_is_establishing(l)) { /* deref l */<br /> ...<br /> tipc_link_reset(l); /* write into l */<br /> if (delete) {<br /> kfree(l);<br /> le-&gt;link = NULL;<br /> <br /> The delete=true caller frees that very object under n-&gt;lock, so the lock<br /> does not protect the cached pointer against it:<br /> <br /> - CPU A, delete=false: tipc_rcv() on TIPC_LINK_DOWN_EVT, or the link<br /> supervision timer via tipc_node_timeout(), reads l unlocked and then<br /> dereferences it under n-&gt;lock;<br /> - CPU B, delete=true: netlink TIPC_NL_BEARER_DISABLE -&gt; bearer_disable()<br /> -&gt; tipc_node_delete_links() -&gt; tipc_node_link_down(n, bearer_id, true)<br /> -&gt; kfree(l).<br /> <br /> The link is freed with plain kfree(), not kfree_rcu(), and for UDP bearers<br /> disable_media() only schedules the asynchronous cleanup_bearer() work, so<br /> its synchronize_net() runs after the links are already gone. An in-flight<br /> CPU A that has read l therefore dereferences freed memory once B frees it:<br /> a use-after-free read in tipc_link_is_establishing(), and a use-after-free<br /> write via tipc_link_reset() on the establishing branch.<br /> <br /> The following trace was captured on 7.2.0-rc5-00284-gaf39eb111ce6:<br /> <br /> BUG: KASAN: slab-use-after-free in tipc_link_is_establishing (net/tipc/link.c:285)<br /> Read of size 4 at addr ffff88802e2aa068 by task swapper/2/0<br /> tipc_link_is_establishing (net/tipc/link.c:285)<br /> tipc_node_link_down (net/tipc/node.c:1076)<br /> tipc_node_timeout (net/tipc/node.c:843)<br /> Allocated by task 9549:<br /> tipc_link_create (net/tipc/link.c:490)<br /> tipc_node_check_dest (net/tipc/node.c:1279)<br /> tipc_disc_rcv (net/tipc/discover.c:252)<br /> tipc_udp_recv (net/tipc/udp_media.c:389)<br /> Freed by task 9549:<br /> tipc_node_link_down (net/tipc/node.c:1084)<br /> tipc_node_delete_links (net/tipc/node.c:1320)<br /> bearer_disable (net/tipc/bearer.c:414)<br /> __tipc_nl_bearer_disable (net/tipc/bearer.c:992)<br /> <br /> Move the le-&gt;link read inside tipc_node_write_lock(), so it is serialised<br /> against the kfree() in the delete path. A racing teardown now either has<br /> not run yet, and we see a valid link, or has already run, and we see NULL.

In the Linux kernel, the following vulnerability has been resolved:<br /> <br /> tls: don&amp;#39;t leave a full plaintext sk_msg ring unpushed<br /> <br /> When the copy path in tls_sw_sendmsg_locked() adds the fragment that fills<br /> the plaintext sk_msg ring, it does not set full_record, so the record is<br /> left full and unpushed. A later splice() then adds to an already full<br /> ring: sk_msg_page_add() has no fullness check of its own, so sg.end wraps<br /> onto sg.start and the ring appears empty. Fragments added after that<br /> overwrite live entries, and sg.size no longer matches what is reachable<br /> between sg.start and sg.end, so pushing the record runs the scatterwalk off<br /> the end of the scatterlist.<br /> <br /> An unprivileged user can trigger this on a loopback TCP socket with the<br /> "tls" ULP attached:<br /> <br /> BUG: kernel NULL pointer dereference, address: 0000000000000008<br /> RIP: 0010:memcpy_from_scatterwalk+0x32/0xc0<br /> Call Trace:<br /> skcipher_walk_next+0x1d1/0x2c0<br /> gcm_encrypt_aesni_avx+0x1e9/0x220<br /> bpf_exec_tx_verdict+0x3bb/0x860<br /> tls_sw_sendmsg+0xa1a/0xca0<br /> __sys_sendto+0x1da/0x1f0<br /> <br /> Set full_record in the copy path when the ring becomes full, and push a<br /> record that is already full on entry to the sendmsg loop.

In the Linux kernel, the following vulnerability has been resolved:<br /> <br /> tls: rx: restore msg_iter before TLS 1.3 optimistic retry<br /> <br /> tls_decrypt_sg() advances msg-&gt;msg_iter when it maps user pages for<br /> the optimistic TLS 1.3 zero-copy path. If the decrypted record turns<br /> out not to be unpadded application data, tls_decrypt_sw() retries into<br /> a kernel skb, but leaves the iterator advanced.<br /> <br /> The subsequent copy from the skb then writes decrypted bytes again at<br /> a later point in the caller iovecs while recvmsg() reports only the<br /> post-retry length. A TLS peer can trigger this after the receiver<br /> enables TLS_RX_EXPECT_NO_PAD.<br /> <br /> Revert the iterator by the number of bytes consumed by the optimistic<br /> mapping before retrying without zero-copy.<br /> <br /> Add a selftest which sends a TLS 1.3 control record with<br /> TLS_RX_EXPECT_NO_PAD enabled and verifies that recvmsg() does not<br /> overwrite later iovecs beyond the returned length.

In the Linux kernel, the following vulnerability has been resolved:<br /> <br /> veth: fix skb length accounting after XDP frag adjustment<br /> <br /> veth exposes non-linear skb fragments through an xdp_buff. If an XDP<br /> program adjusts the fragment area, veth_xdp_rcv_skb() copies<br /> xdp_frags_size back to skb-&gt;data_len but leaves skb-&gt;len containing the<br /> old fragment contribution.<br /> <br /> After a fragment shrink, this makes skb_headlen() larger than the actual<br /> linear area. In the reproduced UDP receive path, __skb_datagram_iter()<br /> copied 1024 bytes past the actual linear tail to userspace, starting at<br /> struct skb_shared_info. The copied bytes included the affected skb&amp;#39;s<br /> nr_frags, xdp_frags_size, and a kernel pointer from<br /> skb_shinfo(skb)-&gt;frags[0]. Real packet data was displaced by the same<br /> amount and truncated at the end.<br /> <br /> Subtract the old data_len before replacing it and add the new data_len<br /> afterwards, keeping skb-&gt;len and skb-&gt;data_len synchronized.<br /> <br /> Additionally, bpf_xdp_pull_data() can advance data_end while leaving<br /> frags present. The skb is then still non-linear, so the old<br /> __skb_put(skb, off) triggers SKB_LINEAR_ASSERT().<br /> <br /> Use skb_set_tail_pointer() and update skb-&gt;len explicitly instead,<br /> following bpf_prog_run_generic_xdp(). Unlike __skb_put(),<br /> skb_set_tail_pointer() does not require a linear skb.<br /> <br /> A 60000-byte UDP datagram on a veth pair with MTU 64000 was shortened by<br /> 1024 bytes from its fragment area. Before the fix, all 10 runs produced<br /> corrupted payloads. After the fix, all 10 runs matched the expected<br /> payload exactly. A forced-tailroom reproducer also exercises<br /> bpf_xdp_pull_data() with frags still present; the old code triggers<br /> SKB_LINEAR_ASSERT(), while this fix passes 10/10 runs.

In the Linux kernel, the following vulnerability has been resolved:<br /> <br /> vsock/virtio: avoid refilling the RX queue after teardown<br /> <br /> Commit b917507e5ad9 ("vsock/virtio: stop workers during the .remove()")<br /> made the RX worker jump to its common exit when rx_run is clear. That<br /> exit still refills the RX queue when the buffer count is low, so work<br /> queued across virtio_vsock_vqs_del() can add buffers after the virtqueues<br /> have been deleted.<br /> <br /> BUG: KASAN: slab-use-after-free in virtqueue_add_sgs<br /> Read of size 4 by task kworker/0:1<br /> Workqueue: virtio_vsock virtio_transport_rx_work<br /> Call Trace:<br /> virtqueue_add_sgs (drivers/virtio/virtio_ring.c:2796)<br /> virtio_vsock_rx_fill (net/vmw_vsock/virtio_transport.c:332)<br /> virtio_transport_rx_work (net/vmw_vsock/virtio_transport.c:701)<br /> process_one_work (kernel/workqueue.c:3314)<br /> worker_thread (kernel/workqueue.c:3478)<br /> kthread (kernel/kthread.c:436)<br /> ret_from_fork (arch/x86/kernel/process.c:158)<br /> ret_from_fork_asm (arch/x86/entry/entry_64.S:245)<br /> ...<br /> Freed by task 141:<br /> kfree (mm/slub.c:6566)<br /> vp_del_vq (drivers/virtio/virtio_pci_common.c:259)<br /> vp_del_vqs (drivers/virtio/virtio_pci_common.c:285)<br /> virtio_vsock_freeze (net/vmw_vsock/virtio_transport.c:912)<br /> virtio_device_freeze (drivers/virtio/virtio.c:658)<br /> virtio_pci_freeze (drivers/virtio/virtio_pci_common.c:601)<br /> pci_pm_freeze (drivers/pci/pci-driver.c:1098)<br /> device_suspend (drivers/base/power/main.c:1968)<br /> Kernel panic - not syncing: KASAN: panic_on_warn set ...<br /> <br /> Jump to a no-refill exit when rx_run is clear, leaving the normal exit<br /> to replenish a running queue.

In the Linux kernel, the following vulnerability has been resolved:<br /> <br /> ip6_tunnel: clear skb2-&gt;cb[] in ip6ip6_err()<br /> <br /> ip6ip6_err() clones an outer IPv6 ICMP error skb, pulls it to the<br /> quoted inner IPv6 packet, and then passes the clone to icmpv6_send().<br /> The clone still carries the outer packet&amp;#39;s inet6_skb_parm in skb-&gt;cb.<br /> <br /> If the outer packet had a Home Address Option, IP6CB(skb2)-&gt;dsthao<br /> remains non-zero after skb_pull(). icmpv6_send() later calls<br /> mip6_addr_swap(), which uses that stale dsthao offset against the quoted<br /> inner packet. A malformed inner destination-options header can then make<br /> the HAO lookup and address swap run past the end of the quoted packet<br /> and corrupt skb_shared_info.<br /> <br /> Clear skb2-&gt;cb[] before pulling the quoted inner IPv6 packet so the<br /> reply path does not reuse metadata left by the outer IPv6 stack.

In the Linux kernel, the following vulnerability has been resolved:<br /> <br /> ipv6: fix Route Information option length validation<br /> <br /> rt6_route_rcv() validates the Route Information option (RFC 4191) length<br /> against the prefix length, but both checks are off by one.<br /> <br /> rinfo-&gt;length is the ND option length in units of 8 octets and it<br /> *includes* the 8-byte option header, so an option carrying N bytes of<br /> prefix has length == 1 + N/8. RFC 4191 section 2.3 requires length 3<br /> when Prefix Length is greater than 64, and 2 or 3 when it is greater<br /> than 0. The code accepts length &gt;= 2 and length &gt;= 1 respectively.<br /> <br /> ipv6_addr_prefix() then copies prefix_len/8 bytes out of rinfo-&gt;prefix,<br /> so a Router Advertisement with (prefix_len=128, length=2) or<br /> (prefix_len=64, length=1) makes the kernel read up to 8 bytes past the<br /> end of the option. Those bytes end up in the prefix of the route that<br /> gets installed, so they are visible to userspace:<br /> <br /> # RA with a Route Information option (prefix_len=128, length=2)<br /> # followed by a source link-layer address option, 01 01 de ad be ef ca fe<br /> $ ip -6 route show<br /> 2001:db8:dead:beef:101:dead:beef:cafe via fe80::1234 dev veth0 proto ra<br /> ^^^^^^^^^^^^^^^^^^ the next option, read out of bounds<br /> <br /> When the Route Information option is the last one in the packet, those<br /> eight bytes come from the skb tail room instead.<br /> <br /> Reject the option lengths RFC 4191 does not allow.

In the Linux kernel, the following vulnerability has been resolved:<br /> <br /> mm/ptdump: always stabilise against page table freeing using init_mm<br /> <br /> Previous commits have established the invariant that kernel page table<br /> freeing is performed while an mmap read lock on init_mm is held, which<br /> fixes races between ptdump and kernel page table freeing over init_mm.<br /> <br /> However, x86 and arm64 can perform a ptdump over an mm other than init_mm<br /> via ptdump_walk_pgd() and since kernel memory ranges are shared across<br /> non-kernel mm&amp;#39;s, this means that the race still exists for these cases.<br /> <br /> Fix this by acquiring a nested mmap write lock for init_mm in<br /> ptdump_walk_pgd().<br /> <br /> This is safe as we take this after mmap write locking the mm, and nothing<br /> acquires the init_mm lock first before locking an arbitrary mm, so no<br /> deadlock is possible.<br /> <br /> Also update walk_page_range_debug() to assert that init_mm is write<br /> locked, add a comment explaining why and remove some redundant code, and<br /> eliminate the unnecessary and confusing invocation of<br /> walk_kernel_page_table_range().<br /> <br /> We can safely remove the non-NULL check for walk.mm, as the mmap lock<br /> asserts would NULL pointer deref if it was (and of course no callers do<br /> this).<br /> <br /> The first point at which ptdump can race kernel page table freeing is<br /> commit b6bdb7517c3d ("mm/vmalloc: add interfaces to free unmapped page<br /> table"), so we target this in the Fixes tag.

In the Linux kernel, the following vulnerability has been resolved:<br /> <br /> mm/page_table_check: skip special zero mappings<br /> <br /> page_table_check_set() and page_table_check_clear() account mappings based<br /> on PageAnon(). Shared zero-page PTEs and huge zero PMDs are special<br /> mappings, but page_table_check can still account them as file-backed<br /> pages.<br /> <br /> An unprivileged process can populate enough zero mappings to overflow<br /> file_map_count and hit the existing BUG_ON(). The PTE path can do this<br /> with the shared zero page, and the PMD path can do the same with huge zero<br /> mappings.<br /> <br /> Skip special zero mappings in the user page-table accounting paths. Keep<br /> the PTE-side pte_special() check, and identify huge zero PMDs from the<br /> mapped folio instead of pmd_special(). That covers architectures where<br /> pmd_special() is a no-op without adding huge_zero_pfn checks to the<br /> generic counter helpers.