Information Disclosure

Local file inclusion in the AncoraThemes Ludos Paradise WordPress theme up to version 2.1.3 permits unauthenticated remote attackers to include arbitrary local files, exposing sensitive server data such as configuration files or credentials. The vulnerability is not known to be actively exploited, and no public exploit code is available. Despite a high CVSS rating, the low EPSS probability and high attack complexity suggest a limited real-world risk.

Local file inclusion in the Kings & Queens WordPress theme by AncoraThemes (through version 1.1.16) enables unauthenticated attackers

Unauthenticated local file inclusion in the Gracioza WordPress theme versions up to 1.0.15 lets remote attackers read arbitrary files and potentially execute code. The flaw stems from improper sanitization of filenames used in include statements (CWE-98). No known public exploit or active exploitation is confirmed at the time of analysis.

Local File Inclusion in the Mamita WordPress theme (AncoraThemes, versions ≤ 1.0.9) exposes sites to unauthenticated path-traversal attacks where unsanitized input is passed directly to a PHP include() or require() call, enabling inclusion of arbitrary server-local files. Under the right server conditions, this can expose sensitive configuration files such as wp-config.php and escalate to remote code execution through techniques like log poisoning; the CVSS scorer's C:H/I:H/A:H ratings reflect this full-chain potential. No public exploit code has been identified and EPSS probability is 0.08% (23rd percentile), indicating low opportunistic exploitation risk at this time.

Local file inclusion in Militarology WordPress theme versions up to 1.0.15 allows unauthenticated remote attackers to include arbitrary local files, potentially exposing sensitive data and achieving remote code execution. The vulnerability carries a CVSS 3.1 score of 8.1 (high) but EPSS exploitation probability is low (0.08%), with no public exploit or active exploitation reported.

Local file inclusion in AncoraThemes ShieldGroup WordPress theme versions up to 2.13 enables unauthenticated remote attackers to include arbitrary local files. Despite high CVSS severity, EPSS indicates very low real-world exploitation probability; no active exploitation or public exploit code has been identified at time of analysis.

Code injection in RuoYi up to version 4.8.1 via the /monitor/cache/getnames endpoint allows authenticated remote attackers to inject arbitrary code through the fragment parameter with low impact to confidentiality, integrity, and availability. The vulnerability requires valid user authentication (PR:L per CVSS 4.0 vector) and has publicly available exploit code, though EPSS scoring at 0.08% percentile (22nd percentile) indicates low real-world exploitation probability despite public disclosure.

Code injection in ZZCMS 2025 Backend Website Settings Module allows authenticated remote attackers to inject arbitrary code via the icp parameter in the stripfxg function (/admin/siteconfig.php), with limited confidentiality impact. Public exploit code is available, but exploitation requires high-privilege administrative access, significantly limiting practical attack surface despite network-accessible vector.

Information disclosure in Storybook for Node.js versions 7.0.0 through 10.1.9 exposes environment variables from `.env` files when using `storybook build` command. Unpatched projects building Storybook in directories containing `.env` files risk bundling sensitive credentials into publicly viewable artifacts. Unauthenticated attackers accessing published Storybook bundles can extract secrets from source code. Runtime dev mode, CI builds using platform environment variables, and co-located applications remain unaffected. No public exploit identified at time of analysis.

Arbitrary file overwrite in mcp-server-git prior to version 2025.12.17 allows unauthenticated remote attackers with user interaction to overwrite files via unsanitized command-line arguments passed to git CLI functions. The vulnerability affects git_diff and git_checkout operations where flag-like values (e.g., --output=/path/to/file) are interpreted as git options rather than validated references, enabling attackers to redirect output to arbitrary filesystem locations. CVSS 6.3 reflects high integrity impact with low availability impact; EPSS signal and active exploitation status not independently confirmed at analysis time.

ZZCMS 2025 stores sensitive user data in cleartext within the User Data Storage Module at /reg/user_save.php, allowing remote attackers with high-level privileges to retrieve unencrypted credentials or personal information from disk. The vulnerability has a published exploit available, though the extremely low EPSS score (0.02%) and requirement for authenticated high-privilege access suggest minimal real-world exploitation risk despite public proof-of-concept availability.

Local authenticated applications on iOS and iPadOS can access user-sensitive data due to insufficient entitlement checks, affecting iOS 18.7.2 and earlier and iPadOS 18.7.2 and earlier (as well as iOS 26.1 and iPadOS 26.1 and earlier). An attacker with app installation capability can exploit this vulnerability to bypass privacy controls and exfiltrate protected user information. No public exploit identified at time of analysis, though the 5.5 CVSS score and information disclosure classification indicate moderate real-world risk in targeted attack scenarios.

Local privilege escalation in Apple operating systems (iOS, iPadOS, macOS Tahoe, visionOS, watchOS) allows authenticated applications to bypass payment token access restrictions and obtain sensitive payment credentials. The vulnerability affects all versions prior to the 26.2 release across affected platforms. CVSS 5.5 with low real-world exploitation risk (EPSS 0.01%), no public exploit identified, not listed in CISA KEV.

A logic validation flaw in macOS Sonoma and Tahoe allows local authenticated apps to access sensitive user data through improved validation mechanisms that were previously insufficient. The vulnerability affects macOS Sonoma versions prior to 14.8.4 and macOS Tahoe prior to 26.2, requiring local access and valid user privileges (PR:L) to exploit. With an EPSS score of 0.02% and no public exploit code identified, the real-world exploitation probability remains minimal despite the CVSS 5.5 rating, though the high confidentiality impact (C:H) warrants timely patching for systems handling sensitive information.

Safari and macOS allow local authenticated applications to access sensitive user data through improper permission enforcement. The vulnerability affects Safari versions prior to 26.2 and macOS versions prior to Tahoe 26.2, exploitable by apps running with user-level privileges that can bypass authorization checks to read protected user information. Apple has released patched versions with additional permission validation; EPSS data indicates minimal real-world exploitation likelihood despite the authenticated local attack vector.

Sandbox escape in Apple macOS allows a locally executing app with standard user privileges to break out of its sandbox confinement and access host system resources beyond its permitted scope. Affects macOS Sequoia prior to 15.7.4, macOS Sonoma prior to 14.8.4, and macOS Tahoe prior to 26.2, with all versions covered by CPE cpe:2.3:o:apple:macos:*:*:*:*:*:*:*:*. No public exploit code and no CISA KEV listing have been identified at time of analysis, though the CVSS 8.8 score with Scope:Changed reflects the significant cross-boundary impact potential once a malicious app gains execution.

Installed app enumeration via permissions bypass in Apple operating systems allows a locally authenticated app to discover what other applications a user has installed through insufficient access controls. Affects iOS 18.7.2 and earlier, iPadOS 18.7.2 and earlier, macOS Tahoe 26.1 and earlier, tvOS 26.1 and earlier, visionOS 26.1 and earlier, and watchOS 26.1 and earlier. The vulnerability has a low CVSS score (3.3) with extremely low exploitation probability (EPSS 0.02%) and no public exploit identified at time of analysis.

Local apps on Apple devices can access a user's Safari browsing history due to insufficient data redaction in system logging, affecting iOS, iPadOS, macOS Tahoe, and watchOS prior to version 26.2. An attacker with local app execution privileges can extract sensitive Safari history from system logs without user interaction. This vulnerability carries a 3.3 CVSS score with minimal real-world exploitation probability (EPSS 0.01%) and no known public exploits.

Unauthenticated access to Hidden Photos Album in Apple iOS, iPadOS, macOS, and visionOS allows remote attackers to view protected photos without authentication due to a configuration flaw. Fixed in iOS/iPadOS 26.2, macOS Tahoe 26.2, and visionOS 26.2. CVSS 9.8 (Critical) reflects network-based unauthenticated access, though EPSS of 0.13% (32nd percentile) suggests low observed exploitation probability. No public exploit identified at time of analysis, and not listed in CISA KEV. This represents a privacy-critical authentication bypass affecting Apple's Photos app across all major platforms.

Denial-of-service hardening in the Linux kernel's page_pool subsystem addresses noisy allocation-failure handling on the network receive datapath. Because driver authors frequently omit GFP_NOWARN, ATOMIC page allocations that fail under memory pressure emit full allocation-failure warnings/backtraces; the fix makes page_pool add GFP_NOWARN by default for ATOMIC allocations. Rated CVSS 7.5 for availability impact only (C:N/I:N), with no public exploit identified at time of analysis and a low EPSS score (0.17%, 6th percentile).

Denial of service in the Linux kernel's lan966x Ethernet switch driver (Microchip LAN966x SoC) allows a potential deadlock and kernel warning when network statistics are read while holding an atomic context. The driver incorrectly used a sleeping mutex (lan966x_stats_get) inside an atomic/spinlock-held path, tripping a 'sleeping function called from invalid context' BUG and risking system instability; the fix replaces the mutex with a spinlock. No public exploit identified at time of analysis, and the EPSS score is negligible (0.16%, 6th percentile).

Local privilege-context memory corruption in the Linux kernel's io_uring zero-copy send (zctx) path allows a local user to trigger unsafe handling of chained notification (ubuf_info) contexts. The flaw stems from send-zerocopy operations linking ubuf_info structures that may originate from a different io_uring context than assumed, and the fix adds a check enforcing that only same-context notifications are chained. No public exploit has been identified at time of analysis; EPSS is very low (0.16%, 6th percentile) and the issue is not on the CISA KEV list, but the CVSS base score of 7.8 reflects high confidentiality, integrity, and availability impact for a successful local trigger.

Improper validation of node identifiers (nid) in the Linux kernel's F2FS filesystem allows a crafted or corrupted on-disk image to pass an out-of-range nid (where footer.ino equals footer.nid and both exceed valid bounds) through f2fs_alloc_nid() and free_nid_list, potentially causing out-of-bounds access, memory corruption, or a kernel crash. The upstream fix adds a sanity check to detect this corruption. There is no public exploit identified at time of analysis, and the EPSS score is very low (0.02%, 6th percentile). Note the published CVSS 9.8 network vector appears inconsistent with the local, filesystem-image-driven nature of this bug.

Privilege-relevant use-after-free in the Linux kernel's drm/msm (Qualcomm Adreno GPU) driver allows a local user with GPU access to trigger kernel faults because last_fence is not waited on at VM-bind context close, freeing GPU resources while they are still in use. Affected systems run the msm DRM driver on Qualcomm SoCs and use vm_bind contexts. There is no public exploit identified at time of analysis, and the EPSS score is very low (0.15%, 5th percentile), consistent with an in-tree kernel fix rather than an in-the-wild threat.

Weakened cryptographic randomness affects the Linux kernel on AMD Zen5 processors, where the RDSEED instruction's 16-bit and 32-bit register variants can return a zero value while falsely reporting success (CF=1), tracked upstream as AMD-SB-7055. Kernel and userspace consumers that rely on RDSEED for entropy can silently receive predictable seed material, undermining key generation and other cryptographic operations. There is no public exploit identified at time of analysis and EPSS is low (0.16%, 6th percentile); the kernel resolves this by adding a microcode-revision check that works around the faulty hardware behavior.

In the Linux kernel, the following vulnerability has been resolved: Bluetooth: hci_sock: Prevent race in socket write iter and sock bind There is a potential race condition between sock bind and socket write iter. bind may free the same cmd via mgmt_pending before write iter sends the cmd, just as syzbot reported in UAF[1]. Here we use hci_dev_lock to synchronize the two, thereby avoiding the UAF mentioned in [1]. [1] syzbot reported: BUG: KASAN: slab-use-after-free in mgmt_pending_remove+0x3b/0x210 net/bluetooth/mgmt_util.c:316 Read of size 8 at addr ffff888077164818 by task syz.0.17/5989 Call Trace: mgmt_pending_remove+0x3b/0x210 net/bluetooth/mgmt_util.c:316 set_link_security+0x5c2/0x710 net/bluetooth/mgmt.c:1918 hci_mgmt_cmd+0x9c9/0xef0 net/bluetooth/hci_sock.c:1719 hci_sock_sendmsg+0x6ca/0xef0 net/bluetooth/hci_sock.c:1839 sock_sendmsg_nosec net/socket.c:727 [inline] __sock_sendmsg+0x21c/0x270 net/socket.c:742 sock_write_iter+0x279/0x360 net/socket.c:1195 Allocated by task 5989: mgmt_pending_add+0x35/0x140 net/bluetooth/mgmt_util.c:296 set_link_security+0x557/0x710 net/bluetooth/mgmt.c:1910 hci_mgmt_cmd+0x9c9/0xef0 net/bluetooth/hci_sock.c:1719 hci_sock_sendmsg+0x6ca/0xef0 net/bluetooth/hci_sock.c:1839 sock_sendmsg_nosec net/socket.c:727 [inline] __sock_sendmsg+0x21c/0x270 net/socket.c:742 sock_write_iter+0x279/0x360 net/socket.c:1195 Freed by task 5991: mgmt_pending_free net/bluetooth/mgmt_util.c:311 [inline] mgmt_pending_foreach+0x30d/0x380 net/bluetooth/mgmt_util.c:257 mgmt_index_removed+0x112/0x2f0 net/bluetooth/mgmt.c:9477 hci_sock_bind+0xbe9/0x1000 net/bluetooth/hci_sock.c:1314

Denial of service in the Linux kernel's Samsung sxgbe 10G Ethernet driver stems from a NULL pointer dereference in sxgbe_rx(), where the receive path logs an error when an skb is NULL but then dereferences that same NULL skb on the following line. The fix adds a 'break' so the code falls through to sxgbe_rx_refill() instead of crashing, mirroring the handling already used by other NIC drivers such as Calxeda's xgmac_rx(). There is no public exploit identified at time of analysis, and EPSS is low (0.17%, 6th percentile); the bug was found during code review rather than in-the-wild.

In the Linux kernel, the following vulnerability has been resolved: afs: Fix delayed allocation of a cell's anonymous key The allocation of a cell's anonymous key is done in a background thread along with other cell setup such as doing a DNS upcall. In the reported bug, this is triggered by afs_parse_source() parsing the device name given to mount() and calling afs_lookup_cell() with the name of the cell. The normal key lookup then tries to use the key description on the anonymous authentication key as the reference for request_key() - but it may not yet be set and so an oops can happen. This has been made more likely to happen by the fix for dynamic lookup failure. Fix this by firstly allocating a reference name and attaching it to the afs_cell record when the record is created. It can share the memory allocation with the cell name (unfortunately it can't just overlap the cell name by prepending it with "afs@" as the cell name already has a '.' prepended for other purposes). This reference name is then passed to request_key(). Secondly, the anon key is now allocated on demand at the point a key is requested in afs_request_key() if it is not already allocated. A mutex is used to prevent multiple allocation for a cell. Thirdly, make afs_request_key_rcu() return NULL if the anonymous key isn't yet allocated (if we need it) and then the caller can return -ECHILD to drop out of RCU-mode and afs_request_key() can be called. Note that the anonymous key is kind of necessary to make the key lookup cache work as that doesn't currently cache a negative lookup, but it's probably worth some investigation to see if NULL can be used instead.

Local privilege escalation and memory corruption in the Linux kernel's io_uring networking subsystem stems from vectored registered buffer imports being tied to the wrong io_kiocb (the request 'req' instead of the notification 'sr->notif'), creating an object-lifetime mismatch. Local low-privileged users on affected kernels can trigger use-after-free-style conditions leading to information disclosure or code execution in kernel context. No public exploit identified at time of analysis, and EPSS is low (0.16%).

In the Linux kernel, the following vulnerability has been resolved: mptcp: Initialise rcv_mss before calling tcp_send_active_reset() in mptcp_do_fastclose(). syzbot reported divide-by-zero in __tcp_select_window() by MPTCP socket. [0] We had a similar issue for the bare TCP and fixed in commit 499350a5a6e7 ("tcp: initialize rcv_mss to TCP_MIN_MSS instead of 0"). Let's apply the same fix to mptcp_do_fastclose(). [0]: Oops: divide error: 0000 [#1] SMP KASAN PTI CPU: 0 UID: 0 PID: 6068 Comm: syz.0.17 Not tainted syzkaller #0 PREEMPT(full) Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 10/25/2025 RIP: 0010:__tcp_select_window+0x824/0x1320 net/ipv4/tcp_output.c:3336 Code: ff ff ff 44 89 f1 d3 e0 89 c1 f7 d1 41 01 cc 41 21 c4 e9 a9 00 00 00 e8 ca 49 01 f8 e9 9c 00 00 00 e8 c0 49 01 f8 44 89 e0 99 <f7> 7c 24 1c 41 29 d4 48 bb 00 00 00 00 00 fc ff df e9 80 00 00 00 RSP: 0018:ffffc90003017640 EFLAGS: 00010293 RAX: 0000000000000000 RBX: 0000000000000000 RCX: ffff88807b469e40 RDX: 0000000000000000 RSI: 0000000000000000 RDI: 0000000000000000 RBP: ffffc90003017730 R08: ffff888033268143 R09: 1ffff1100664d028 R10: dffffc0000000000 R11: ffffed100664d029 R12: 0000000000000000 R13: 0000000000000000 R14: 0000000000000000 R15: 0000000000000000 FS: 000055557faa0500(0000) GS:ffff888126135000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00007f64a1912ff8 CR3: 0000000072122000 CR4: 00000000003526f0 Call Trace: <TASK> tcp_select_window net/ipv4/tcp_output.c:281 [inline] __tcp_transmit_skb+0xbc7/0x3aa0 net/ipv4/tcp_output.c:1568 tcp_transmit_skb net/ipv4/tcp_output.c:1649 [inline] tcp_send_active_reset+0x2d1/0x5b0 net/ipv4/tcp_output.c:3836 mptcp_do_fastclose+0x27e/0x380 net/mptcp/protocol.c:2793 mptcp_disconnect+0x238/0x710 net/mptcp/protocol.c:3253 mptcp_sendmsg_fastopen+0x2f8/0x580 net/mptcp/protocol.c:1776 mptcp_sendmsg+0x1774/0x1980 net/mptcp/protocol.c:1855 sock_sendmsg_nosec net/socket.c:727 [inline] __sock_sendmsg+0xe5/0x270 net/socket.c:742 __sys_sendto+0x3bd/0x520 net/socket.c:2244 __do_sys_sendto net/socket.c:2251 [inline] __se_sys_sendto net/socket.c:2247 [inline] __x64_sys_sendto+0xde/0x100 net/socket.c:2247 do_syscall_x64 arch/x86/entry/syscall_64.c:63 [inline] do_syscall_64+0xfa/0xfa0 arch/x86/entry/syscall_64.c:94 entry_SYSCALL_64_after_hwframe+0x77/0x7f RIP: 0033:0x7f66e998f749 Code: ff ff c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 40 00 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 a8 ff ff ff f7 d8 64 89 01 48 RSP: 002b:00007ffff9acedb8 EFLAGS: 00000246 ORIG_RAX: 000000000000002c RAX: ffffffffffffffda RBX: 00007f66e9be5fa0 RCX: 00007f66e998f749 RDX: 0000000000000000 RSI: 0000000000000000 RDI: 0000000000000003 RBP: 00007ffff9acee10 R08: 0000000000000000 R09: 0000000000000000 R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000001 R13: 00007f66e9be5fa0 R14: 00007f66e9be5fa0 R15: 0000000000000006 </TASK>

Use-after-free in the Linux kernel's libceph client (the in-kernel Ceph transport shared by CephFS and RBD) lets the mount-time wait loop in __ceph_open_session() read a monmap or osdmap structure after a worker thread has freed and replaced it. The flaw is a race between a mounting task polling have_mon_and_osd_map() without locks and ceph_monc_handle_map()/handle_one_map() swapping in a fresh map under their respective locks, producing a KASAN slab-use-after-free (reproducible with xfstests generic/395 and generic/397). There is no public exploit identified at time of analysis and it is not in CISA KEV; EPSS is very low at 0.18% (8th percentile).

Remote denial-of-service in the Linux kernel's libceph (Ceph client) module allows a malicious or compromised Ceph OSD/monitor to crash the kernel by sending OSDMap packets containing out-of-bounds OSD indexes. Because libceph previously used BUG_ON assertions on OSD index values drawn directly from untrusted network data, an attacker-controlled index exceeding map->max_osd triggers a kernel panic. This is a fixed issue with upstream stable-tree commits; no public exploit has been identified and EPSS exploitation probability is low (0.17%, 7th percentile).

Unauthenticated remote brute-force of the Dbit N300 T1 Pro wireless router (firmware V1.0.0) is trivially achievable because the /api/login endpoint imposes no rate limiting, account lockout, or throttling of any kind. Any attacker with network access to the management interface can attempt unlimited password guesses until admin credentials are found. A publicly available proof-of-concept exploit exists on GitHub; however, EPSS at 0.29% (21st percentile) and absence from CISA KEV suggest exploitation remains limited in practice, likely constrained by the product's small market footprint.

In the Linux kernel, the following vulnerability has been resolved: bfs: Reconstruct file type when loading from disk syzbot is reporting that S_IFMT bits of inode->i_mode can become bogus when the S_IFMT bits of the 32bits "mode" field loaded from disk are corrupted or when the 32bits "attributes" field loaded from disk are corrupted. A documentation says that BFS uses only lower 9 bits of the "mode" field. But I can't find an explicit explanation that the unused upper 23 bits (especially, the S_IFMT bits) are initialized with 0. Therefore, ignore the S_IFMT bits of the "mode" field loaded from disk. Also, verify that the value of the "attributes" field loaded from disk is either BFS_VREG or BFS_VDIR (because BFS supports only regular files and the root directory).

Local privilege escalation and memory corruption in the Linux kernel's NVMe driver arises from a use-after-free in admin request_queue lifetime management, where namespaces retain stale references to a controller's admin request_queue that can be dereferenced after the controller is torn down. Confirmed via a KASAN slab-use-after-free report in blk_queue_enter() triggered through an nvme ioctl (nvme_submit_user_cmd), the flaw affects hosts running NVMe storage and is fixed upstream by reordering the controller 'put' until after all references are released. EPSS is very low (0.03%, 7th percentile) and there is no public exploit identified at time of analysis; exploitation requires local access and a race against controller teardown.

Local denial-of-service in the Linux kernel ext4 filesystem allows a low-privileged user to crash the system by racing inline-data destruction against block mapping. The function ext4_destroy_inline_data_nolock() flips an inode from EXT4_INODE_INLINE_DATA to EXT4_INODE_EXTENTS without holding i_data_sem, so a concurrent ext4_map_blocks() can enter ext4_ind_map_blocks() on an inode that already advertises extents, tripping a BUG_ON at fs/ext4/indirect.c:546 and panicking the kernel. No public exploit identified at time of analysis; EPSS is low (0.18%, 8th percentile) and the flaw is availability-only (kernel oops), not information disclosure despite the input tag.

Spurious kernel warnings in the Linux kernel hung_task blocker-tracking mechanism arise on architectures that align 32-bit values on 2-byte boundaries (e.g., m68k), where the code incorrectly assumes lock pointers are always 4-byte aligned so it can pack a type tag into the lower two pointer bits. The mismatch trips two WARN_ON_ONCE checks; the fix silently ignores non-4-byte-aligned locks, disabling the feature on those platforms. This is an internal kernel robustness fix rather than a remotely reachable attack primitive, with no public exploit identified at time of analysis and a low EPSS score of 0.15% (5th percentile).

Remote unauthenticated denial of service in the Linux kernel's ksmbd in-kernel SMB server allows an attacker to exhaust kernel socket resources by repeatedly tripping the per-IP connection limit. When ksmbd_kthread_fn() rejects a connection that exceeds the per-IP limit, it sets ret = -EAGAIN and continues the accept loop without releasing the just-accepted socket, leaking one socket per rejected attempt from a single source IP. This is a resource-leak DoS with no public exploit identified at time of analysis and a low EPSS score (0.16%, 6th percentile).

Client-identity confusion in the Linux kernel's NFS client allows a low-privileged local user to have an NFS mount silently reuse an existing RPC connection established under a different TLS X.509 client certificate. Because nfs_match_client() failed to compare the cert_serial and privkey_serial fields that define the client's presented identity, a mount intended to use one certificate could be bound to a connection authenticated with another, enabling access to data under the wrong identity. This is an information-disclosure/identity-mismatch flaw (CVSS 7.0); it is not in CISA KEV, has no public exploit identified at time of analysis, and carries a very low EPSS score of 0.10% (1st percentile).

Denial of service in the Linux kernel IPv4 routing subsystem allows a permanent device reference-count leak through a race condition in FIB next-hop exception (fnhe) handling. On systems using tunnel drivers such as sit or gretap, concurrent transmit paths can bind a soon-to-be-freed fnhe to a new dst, leaking the dst and its device reference so the interface can never be unregistered (visible as 'unregister_netdevice: waiting for sitX to become free'). This is availability-only, has no public exploit identified at time of analysis, and carries a low EPSS score of 0.17%.

Local privilege-relevant memory corruption in the Linux kernel's io_uring cmd_net timestamp-retrieval path arises from transposed arguments to skb_queue_splice(), causing SKBs to be spliced in the wrong direction between the socket queue and an on-stack list. Any local user able to issue io_uring network commands with timestamp retrieval could trigger the flawed splice, potentially leading to information disclosure (per source tagging) or broader list/memory corruption. There is no public exploit identified at time of analysis and EPSS is low (0.15%), so this is a code-quality/security hardening fix rather than an actively exploited threat.

Denial of service in the Linux kernel's veth (virtual Ethernet) driver allows a permanently stalled transmit queue and halted network traffic once a lost-wakeup race is triggered under load. The flaw is a regression introduced by commit dc82a33297fc ('veth: apply qdisc backpressure on full ptr_ring'), where the producer in veth_xmit() misuses the __ptr_ring_empty() API to decide whether to re-wake a stopped TXQ; when a consumer on another CPU empties the ring concurrently, the wakeup is lost and the queue stays in QUEUE_STATE_DRV_XOFF. It was observed in production on ARM64 (Ampere Altra Max) systems. There is no public exploit identified at time of analysis, EPSS is low (0.16%), and it is not in CISA KEV.

Use-after-free in the Linux kernel's SMB/CIFS client (cifs module) arises from an incomplete backport of commit bdb596ceb4b7, which left a stale kref_put() call in cfids_invalidation_worker() instead of converting it to close_cached_dir(). The flaw affects the cached-directory (cfid) invalidation path used when a Linux system mounts remote SMB shares, and with a CVSS of 8.8 (C:H/I:H/A:H) could allow memory corruption leading to information disclosure or code execution. There is no public exploit identified at time of analysis and the EPSS probability is low (0.15%).

Denial of service in the Linux kernel's NVMe multipath subsystem allows a lockdep-detected deadlock among disk->open_mutex, the kblockd workqueue, and partition_scan_work completion, which can hang block-device operations. The fix moves partition_scan_work off the kblockd workqueue onto nvme_wq to break the lock-dependency cycle. No public exploit identified at time of analysis; the issue surfaces intermittently during NVMe partition scanning on systems using NVMe multipath.

Improper resource cleanup in the Linux kernel's Intel ice Ethernet driver leaves PTP (Precision Time Protocol) resources leaked when driver probe, PTP initialization, or PTP restart hits an error path. On subsequent driver removal the leaked PF PTP state and un-deinitialized 'ps_lock' mutex trigger a kernel WARNING in ice_adapter_put, and the PTP clock is left registered. No public exploit identified at time of analysis, EPSS is low (0.17%, 7th percentile), and there is no CISA KEV listing; this is a robustness/error-handling defect requiring local privileged access to the NIC driver.

Local privilege-level information disclosure and memory corruption in the Linux kernel's VFS statmount() implementation arises from an uninitialized output-offset pointer ('offp') in statmount_string(). When a caller requests the STATMOUNT_MNT_UIDMAP or STATMOUNT_MNT_GIDMAP fields, those code paths write directly to the struct fields and never assign 'offp', so a later dereference of the uninitialized pointer can leak kernel memory or corrupt state. The CVSS 3.1 vector (AV:L/PR:L) indicates a local, low-privileged attacker is required; there is no public exploit identified at time of analysis and EPSS is low (0.16%, 6th percentile).

Out-of-bounds memory access in the Linux kernel's eBPF verifier (widen_imprecise_scalars()) allows a local actor able to load eBPF programs to read or corrupt kernel memory beyond the bpf_verifier_state stack array. The flaw arises because the verifier assumed an ancestor state (prev_st) shares the same allocated_stack depth as a newly queued state (queued_st), which is false when the same callsite is invoked with differently sized stack frames. No public exploit has been identified at time of analysis; EPSS risk is low (0.17%, 7th percentile) and the issue has been resolved upstream.

Local privilege escalation and memory corruption in the Linux kernel's Intel Xe GPU driver (drm/xe/guc) arises from a use-after-free race during device unbind: the GuC 'Dead CT' worker is not synchronized with the unbind path, so it can access GuC communication-transport resources after they have already been freed. Exploitation requires local access with low privileges (CVSS 7.8, AV:L/PR:L) and can result in high impact to confidentiality, integrity, and availability. There is no public exploit identified at time of analysis, and the low EPSS (0.17%) reflects the niche, timing-dependent nature of the flaw.

Denial of service in the Linux kernel's netfilter nftables connection-tracking (nft_ct) code allows disruption of FTP passive-mode (PASV/EPSV) sessions on hosts acting as NAT gateways. When an nftables FTP conntrack helper is assigned to a connection that already has a NAT binding (helper set after DNAT), the required nfct_seqadj sequence-adjustment extension is never allocated, so the FTP payload mangling path hits a kernel WARNING and tears down the control connection ("Service not available, remote server has closed connection"); on kernels built with panic_on_warn this escalates to a full crash. There is no public exploit identified at time of analysis, EPSS is negligible (0.03%), and it is not in CISA KEV.

Out-of-bounds memory access in the Linux kernel's AMD CPU microcode-matching logic affects systems running on AMD Zen5 processors, where the zen5_rdseed_microcode revision table lacks a terminating sentinel entry. When x86_match_min_microcode_rev() iterates this array during CPU initialization on a Zen5 part, it reads past the array bounds, tripping KASAN and potentially disclosing adjacent kernel memory or causing instability. No public exploit identified at time of analysis, and EPSS risk is low (0.16%, 6th percentile).

Improper GEM object cleanup in the Linux kernel's drm/msm (Qualcomm Adreno) graphics driver mishandles imported dma-bufs, because the free path only checked object flags without accounting for imported buffers whose reservation object differs from the embedded default. A local user with DRM/GPU access can trigger the faulty path (reproduced during hardware-accelerated IRIS video playback under GNOME Shell) by closing a GEM handle backed by an imported dma-buf, producing a kernel WARNING at msm_gem.c:1127 and potential incorrect reservation-object handling during buffer teardown. There is no public exploit identified at time of analysis; EPSS is low (0.16%, 6th percentile) and this is not on CISA KEV.

Broken AFBC (Arm Frame Buffer Compression) handling in the Linux kernel's Mediatek DRM driver on MT8188 (Genio 700) SoCs causes constant vblank timeouts and garbled display output when the 32x8/split/sparse AFBC modifier is used, which Mesa v25.0+ enables by default. A local user with GPU/display access can trigger a hung display pipeline (denial of service) and rendering of stale/garbled framebuffer contents (limited information disclosure). No public exploit identified at time of analysis, and EPSS is very low (0.17%, 7th percentile), consistent with a hardware-specific reliability bug rather than a widely weaponizable flaw.

Integrity protection weakening in the Linux kernel's IMA (Integrity Measurement Architecture) subsystem allows a stored IMA file signature to be silently downgraded to a plain IMA hash. When IMA and EVM run in fix mode (e.g. booting with 'ima_appraise=fix evm=fix ima_policy=appraise_tcb'), the kernel incorrectly clears the IMA_DIGSIG flag whenever a non-IMA security xattr (such as security.selinux or security.evm) or an ACL is set or removed after security.ima was written, so on file close a hash is generated instead of preserving the intended signature. A full C reproducer is embedded in the report, but there is no CISA KEV listing and no public weaponized exploit identified at time of analysis; EPSS is 0.17% (7th percentile).

Local privilege-escalation-class use-after-free in the Linux kernel's radeon (AMD GPU) DRM driver, triggered on the probe-error and device-removal paths. After the driver switched its main structure to devm_drm_dev_alloc(), the leftover drm_put_dev() calls cause devres to release the already-freed device a second time, producing a refcount underflow ('refcount_t: underflow; use-after-free') and dangling reference. No public exploit identified at time of analysis; EPSS is low at 0.17% (7th percentile) and the issue is not listed in CISA KEV.

Local denial-of-service (and potential memory corruption) in the Linux kernel's NXP i.MX8 ISI media capture driver (imx8-isi) allows a low-privileged user with access to an ISI /dev/videoX device to trigger a WARNING and driver error state by simply querying device controls while a capture stream is active. The flaw stems from mxc_isi_video_release() unconditionally tearing down streaming state, so any release call (e.g. from `v4l2-ctl -l`) can free a queue that is still streaming. No public exploit is identified at time of analysis and EPSS risk is negligible (0.03%), though a deterministic crash-reproduction recipe is published in the fix commit.

Local denial-of-service (and potential memory corruption) in the AMD amdkfd (Kernel Fusion Driver) component of the Linux kernel arises from a race between GPU compute-partition switching and asynchronous KFD process teardown. Because the driver's partition-switch path only checks whether the kfd_processes_table is empty - while the actual kfd_process teardown runs later in the kfd_process_wq workqueue - a partition switch can free kfd_node structures still being accessed by an in-flight release, producing a divide-by-zero kernel oops (observed in kfd_get_num_sdma_engines). No public exploit identified at time of analysis, EPSS is low (0.16%), and it is not listed in CISA KEV.

Cross-task FPU state leakage in the Linux kernel x86 XFD (Extended Feature Disable) handling allows a local low-privileged task to trigger an inconsistent AMX/dynamic-feature register state during signal delivery. When a non-AMX task is preempted by an AMX-enabled task that changes the XFD MSR, fpu__clear_user_states() failed to re-synchronize XFD, producing a state mismatch (kernel WARNING) and potential exposure of dynamic FPU register contents. Tagged as an information-disclosure issue; no public exploit identified at time of analysis and EPSS is low (0.17%, 7th percentile).

Kernel memory corruption in the Linux drm/radeon GPU driver occurs because the driver calls kfree() on the rdev main structure that is now managed by devres (via devm_drm_dev_alloc()), causing a double-free when the driver probe fails and devres later cleans up the already-freed allocation. Local users on systems with AMD/ATI Radeon hardware may trigger memory corruption during a failed driver probe, most directly resulting in a kernel crash. There is no public exploit identified at time of analysis, and the EPSS score is low (0.17%, 7th percentile), consistent with an error-path bug rather than a broadly exploitable flaw.

Denial-of-service via invalid pointer access exists in the Linux kernel gpiolib debugfs interface, where a failed memory allocation in gpiolib_seq_start() leaves s->private uninitialized and later dereferenced in gpiolib_seq_stop(), crashing the kernel. The flaw affects systems exposing the GPIO debugfs seq_file (/sys/kernel/debug/gpio) and is triggerable only under memory-allocation failure. No public exploit identified at time of analysis; EPSS is low (0.17%, 7th percentile) and it is not on CISA KEV.

Authorization bypass in the Linux kernel CephFS client (ceph module) lets an authenticated Ceph user exercise MDS auth capabilities granted for one filesystem against a different filesystem in a multi-filesystem (multifs) Ceph cluster. Because the kernel client failed to validate the fsname alongside the associated caps, a user holding read-only rights on 'fsname1' but read-write rights on 'fsname2' would incorrectly gain read-write on 'fsname1', enabling file creation and deletion they should not be permitted. No public exploit identified at time of analysis, and the EPSS score is low (0.25%, 16th percentile), consistent with a specialized storage-cluster condition rather than mass exploitation.

Local privilege-relevant memory corruption/disclosure risk exists in the Linux kernel's Rockchip SFC (Serial Flash Controller) SPI driver (spi-rockchip-sfc), where improper DMA-API usage - deriving DMA addresses via virt_to_phys() instead of dma_map_single() - causes the driver to sync DMA memory it never properly mapped. On affected Rockchip-based systems (e.g. ODROID-M1), this triggers a DMA-API debug warning and reflects an underlying unsafe memory-transfer path during SPI-NOR flash operations. No public exploit identified at time of analysis; EPSS probability is low (0.16%, 6th percentile).

Memory mishandling in the Linux kernel's mlx5e (NVIDIA/Mellanox ConnectX) RX path lets a loaded XDP program corrupt skb generation on striding RQ, causing kernel warnings, a BUG_ON crash, or erroneous packet buffers. The flaw affects systems using mlx5 NICs where a multi-buffer XDP program calls bpf_xdp_adjust_head() or bpf_xdp_adjust_tail() to change the xdp_buff layout, which the driver wrongly assumed was static. This is a resolved upstream kernel fix with no public exploit identified at time of analysis; EPSS is low at 0.17% (7th percentile) and it is not in CISA KEV.

Denial of service in the Linux kernel's NXP ENETC Ethernet driver (enetc) on Layerscape LS1028A platforms allows the CPU to hang under normal network load, causing RCU stalls on PREEMPT_RT kernels. The flaw stems from recursive acquisition of the read-side enetc_mdio_lock in the enetc_poll NAPI path, which deadlocks when a higher-priority writer is queued between two reader acquisitions. No public exploit identified at time of analysis; EPSS is very low (0.03%, 8th percentile) and it is not CISA KEV listed, consistent with a reliability/self-triggered availability bug rather than an attacker-weaponized flaw.

Local file inclusion in the Stockholm Core WordPress plugin (≤2.4.6) allows authenticated users with low privileges to include arbitrary local files, potentially leading to sensitive data exposure or remote code execution. No active exploitation or public exploit code is known at this time, though the low EPSS score indicates limited real-world risk despite the high CVSS impact.

Local file inclusion in PenciDesign Soledad WordPress theme versions through 8.7.0 allows authenticated attackers with low privileges to include and execute arbitrary PHP files via improper filename control in include/require statements. Attack complexity is high (AC:H), requiring specific server configuration or authenticated access to exploit. No active exploitation confirmed at time of analysis, but vulnerability class (CWE-98) is commonly targeted once POC becomes available. EPSS data not provided; exploitation status unknown beyond vendor disclosure.

Local File Inclusion in the Hub Core WordPress plugin (LiquidThemes, versions through 5.0.8) allows an authenticated network attacker with low privileges to supply a crafted filename parameter that is passed unsanitized to a PHP include/require statement, enabling inclusion of arbitrary server-side files. Successful exploitation can expose sensitive configuration data (wp-config.php, credentials) or, under favorable server conditions such as log poisoning, escalate to remote code execution and full site compromise. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis; EPSS sits at 0.08%, reflecting low current exploitation activity.

Local file inclusion in ThemeMove EduMall WordPress theme up to version 4.4.7 allows authenticated attackers to read arbitrary files on the server. Exploitation requires low-privilege access and high attack complexity, with no user interaction needed; CVSS base score is 7.5. No active exploitation reported; EPSS probability is very low at 0.08%.

Information disclosure in wowpress.host Fix Media Library up to version 2.0 allows unauthenticated attackers to retrieve sensitive data embedded in sent data. The vulnerability, disclosed by Patchstack, has a CVSS 5.3 (medium) and a low EPSS exploitation probability (0.05%), with no known public exploits at this time.

Sensitive information disclosure in WordPress Ultimate Auction plugin up to version 4.3.3 allows unauthenticated remote attackers to retrieve embedded sensitive data from the application's responses. No authentication is required, making exploitation simple with only network access needed. Current threat intelligence indicates a very low risk of exploitation, with no active attacks observed.

Improper access controls in Ningyuanda TC155 firmware 57.0.2.0 ONVIF PTZ Control Interface (/onvif/device_service) allow unauthenticated local network attackers to gain unauthorized access with low confidentiality, integrity, and availability impact. Publicly available exploit code exists; the vendor has not responded to disclosure efforts despite early contact.

Improper access controls in Ningyuanda TC155 firmware 57.0.2.0 ONVIF Device Management Service allows unauthenticated local network attackers to trigger a factory reset by manipulating the FactoryDefault argument with 'Hard' input, resulting in information disclosure and configuration loss. Publicly available exploit code exists; vendor has not responded to disclosure attempts.

Template injection in CTCMS up to version 2.1.2 allows authenticated remote attackers to bypass template engine protections via improper neutralization of special elements in the Frontend/Template Management Module. The vulnerability affects the CT_Parser.php library and enables information disclosure with low confidentiality, integrity, and availability impact. Publicly available exploit code exists, though EPSS exploitation probability remains low at 0.09% (26th percentile), suggesting limited real-world weaponization despite POC availability.

Heap-based buffer overflow in Autodesk Shared Components - the shared file-parsing libraries used by multiple Autodesk applications to read CATIA V5 CATPRODUCT product/assembly files - allows an attacker who convinces a user to open a crafted file to crash the application, read sensitive memory contents, or execute arbitrary code in the context of the current process. The CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 7.8) describes a local, user-interaction-driven attack: no authentication to the host is required, but the attacker must first deliver the file to the victim and the victim must explicitly open it, and impact stays within the privileges of the user running the Autodesk product. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV.

Sensitive information disclosure in Hitron HI3120 firmware 7.2.4.5.2b1 exposes credentials or session data to a local low-privileged attacker through the device's web management interface Logout function in index.html. The root cause, indicated by the 'Insufficient Session Expiration' tag, is that the logout action fails to fully invalidate or clear sensitive session artifacts, leaving them recoverable post-logout. No active exploitation is confirmed (EPSS 0.11%, 1st percentile), and the attack surface is constrained to local access with low privileges, significantly limiting real-world impact despite the High confidentiality rating.

Sixun Shanghui Group Business Management System 4.10.24.3 allows unauthenticated remote attackers to access files and directories through the /ExportFiles/ endpoint due to improper access controls, resulting in information disclosure of sensitive data. The vulnerability requires high attack complexity and has publicly available exploit code, but remains difficult to exploit in practice with an EPSS score of 0.06% indicating minimal real-world exploitation probability.

Remote code execution via dynamic code resource manipulation in SamuNatsu HaloBot's Inter-plugin API allows authenticated remote attackers to execute arbitrary code by manipulating the action argument in the html_renderer plugin. The vulnerability affects unsupported legacy versions of the product (commit hash 026b01d4a896d93eaaf9d5163a287dc9f267515b and earlier), with publicly available exploit code disclosed but no vendor-released patch, as the maintainer has abandoned the project and did not respond to early disclosure.

Symlink following in the USB Handler of Ugreen DH2100+ firmware up to 5.3.0 enables a physically present attacker with high privileges to achieve full system compromise. Exploit code is publicly available but the attack cannot be executed remotely and requires administrative access. The low EPSS score (0.01%) reflects the limited exploitation conditions.

Improper access controls in DecoCMS Mesh up to 1.0.0-alpha.31 allow remote attackers to manipulate the domain argument in the createTool function of the Workspace Domain Handler, resulting in unauthorized information disclosure. The vulnerability requires high attack complexity and has published exploit code available, though real-world exploitation appears difficult. CVSS score of 2.9 reflects low severity with limited confidentiality impact, while EPSS scoring at 25th percentile suggests minimal real-world exploitation probability.

MartialBE one-hub up to version 0.14.27 uses a hard-coded cryptographic key in the SESSION_SECRET environment variable of its default docker-compose.yml configuration, allowing remote attackers to potentially decrypt or forge session tokens with high attack complexity. The vulnerability requires non-standard deployment configurations and affects confidentiality rather than integrity or availability. Exploit code has been disclosed publicly, though active exploitation remains unconfirmed by CISA, and the vendor explicitly recommends against using the default Docker Compose example in production environments.

Weak cryptographic hashing in the image_check function of Tenda AX9 firmware 22.03.01.46 allows remote attackers to compromise firmware integrity validation without authentication. The vulnerability has a CVSS score of 2.9 (very low severity) and publicly available exploit code exists, but the high attack complexity and difficult exploitability rating indicate practical barriers to successful exploitation. Real-world risk is minimal: while the vulnerability permits information disclosure related to hash values, it does not enable remote code execution or device takeover.

PHP object injection in Doubly Cross Domain Copy Paste plugin (≤1.0.46) allows authenticated attackers with Subscriber-level privileges to execute arbitrary code via deserialized untrusted input from uploaded ZIP archives. Exploitation requires administrators to explicitly enable Subscriber access. Available POP chains enable code execution, file deletion, and sensitive data retrieval. Attack vector requires low privilege (PR:L) authentication with network accessibility and no user interaction. No public exploit identified at time of analysis.

A buffer information disclosure vulnerability exists in the Aircompressor Java compression library affecting Snappy and LZ4 decompressor implementations. Versions 3.3 and below of Airlift Aircompressor allow remote attackers to read previous buffer contents through crafted compressed input, potentially leaking sensitive data from applications that reuse output buffers across multiple decompression operations. With an EPSS score of 0.19% (41st percentile), active exploitation appears low probability despite the network-accessible attack vector, and no public proof-of-concept is currently documented.

Improper file handling in macOS allows local applications to access protected user data through a logic flaw in the operating system's file access controls. The vulnerability affects macOS Sequoia, Sonoma, and Tahoe, requiring user interaction to trigger exploitation and resulting in unauthorized disclosure of sensitive information without the ability to modify or disable system access. Apple has released patched versions (macOS Sequoia 15.7.3, macOS Sonoma 14.8.3, macOS Tahoe 26.2), with no public exploit code identified at time of analysis.

Local apps can access sensitive user data through improved privacy controls in Apple operating systems across iOS, iPadOS, macOS, visionOS, and watchOS. The vulnerability requires local network access and an authenticated user session (PR:L), limiting exposure to installed applications with explicit permissions. Confirmed patches are available across all affected platforms, and exploitation probability is very low (EPSS 0.02%), indicating this is a privacy-boundary issue rather than a critical security flaw.

Password field disclosure in Apple operating systems allows remote observation of credentials during FaceTime screen sharing sessions. Affects iOS/iPadOS 18.x through 18.7.2, iOS/iPadOS 26.0-26.1, macOS Sequoia through 15.7.2, macOS Tahoe through 26.1, and visionOS through 26.1. Attackers with network access to FaceTime sessions can view password fields that should be masked, creating credential exposure risk during remote support or collaboration scenarios. EPSS score of 0.03% (10th percentile) indicates low automated exploitation probability, and no public exploit identified at time of analysis.

Local apps can access sensitive user data through inadequate log redaction in Apple's operating systems, affecting iOS 18.7.2 and earlier, iPadOS 18.7.2 and earlier, iOS 26.1 and earlier, iPadOS 26.1 and earlier, macOS Sonoma 14.8.2 and earlier, macOS Tahoe 26.1 and earlier, visionOS 26.1 and earlier, and watchOS 26.1 and earlier. The vulnerability requires local app execution with limited user privileges but no interaction, resulting in unauthorized read access to sensitive data stored in application logs. While EPSS probability is minimal (0.01%), the local attack vector and high confidentiality impact warrant patching in environments where untrusted apps may be installed.

Local apps on Apple macOS and iPadOS can access sensitive user data through inadequate information disclosure controls, requiring local execution and low-level user privileges. Affected versions include iOS 18.7.2 and earlier, iPadOS 18.7.2 and earlier, macOS Sequoia 15.7.2 and earlier, macOS Sonoma 14.8.2 and earlier, and macOS Tahoe 26.1 and earlier. Apple has released patched versions (iOS 18.7.3, iPadOS 18.7.3, macOS Sequoia 15.7.3, macOS Sonoma 14.8.3, macOS Tahoe 26.2) with improved access controls to restrict unauthorized data exposure. With an EPSS score of 0.02% (4th percentile) and no public exploit code identified at time of analysis, this represents a low real-world exploitation probability despite the moderate CVSS score.

Local privilege escalation in macOS allows unprivileged applications to access sensitive user data through a permissions bypass. Affects macOS Sequoia versions prior to 15.7.3 and macOS Tahoe prior to 26.2. Attack requires local system access and user interaction (UI:R). EPSS exploitation probability is very low at 0.02%, and no public exploit code or active exploitation has been reported.

Intel-based Mac computers running macOS Sequoia prior to 15.7.3 or macOS Tahoe prior to 26.2 are vulnerable to a cryptographic downgrade attack that allows unprivileged local applications to bypass code-signing restrictions and access sensitive user data. The vulnerability exploits inadequate validation of signed components, enabling information disclosure through JWT or similar signed-data attacks. Active exploitation has not been confirmed, and the extremely low EPSS score (0.01%) indicates minimal real-world exploitation risk despite the local attack vector.

Local privilege escalation on Intel-based macOS systems allows unsigned or weakly-signed applications to access sensitive user data by downgrading code-signing protections through cryptographic validation bypass. The vulnerability affects macOS Sequoia prior to 15.7.3 and macOS Tahoe prior to 26.2, requires user interaction to execute a malicious app, and has an extremely low exploitation probability (EPSS 0.01%) despite moderate CVSS severity. No active exploitation or public exploit code has been identified.