CVE-2026-69921 is a heap-based buffer overflow vulnerability in the Windows Print Spooler components of Microsoft Windows 10 Version 21H2. This flaw allows an authorized local attacker to elevate privileges on the affected system. The vulnerability has been assigned a high severity rating with a CVSS score of 7.8. Microsoft has issued official fixes for multiple affected Windows 10 builds. No known exploits are reported in the wild at this time.
CVE-2026-77899 is a use-after-free vulnerability in the Windows Security Center component of Microsoft Windows 11 Version 24H2. This flaw allows an authorized local attacker to elevate privileges on the affected system. The vulnerability affects specific builds of Windows 11 and earlier Windows versions, with fixes released in later builds. The CVSS score is 7.0, indicating high severity. No known exploits are reported in the wild at this time.
CVE-2026-72948 is a relative path traversal vulnerability in the Windows DNS component affecting multiple versions of Microsoft Windows including Windows 10 Version 1607. This flaw allows an authorized local attacker to elevate privileges by exploiting improper handling of file paths. The vulnerability has been assigned a CVSS 3.1 base score of 6.7, indicating a medium severity level. Microsoft has issued official fixes for all affected versions. No known exploits are reported in the wild at this time.
Multiple security vulnerabilities were discovered in the Linux kernel, including a critical issue affecting some Arm processors where a broadcast TLB invalidation could complete before memory writes were globally observed. This flaw could allow a local attacker to write to memory after permissions were revoked, potentially bypassing memory protections or escalating privileges. The update addresses numerous flaws across a wide range of kernel subsystems and architectures. Users must update to fixed kernel versions and reboot to apply the patches. Due to ABI changes, third-party kernel modules require recompilation and reinstallation.
An AI model named Cyberkimi claims to have autonomously developed a live exploit for a recently patched V8 JavaScript engine vulnerability in under 24 hours. The exploit targets Chrome Stable versions that still contain the unpatched bugs. The AI reportedly analyzed recent V8 security patches, identified incomplete fixes, and generated a working exploit chain demonstrated in a local Chromium environment. No official CVE has been assigned to these specific bugs yet, and independent confirmation is lacking. The exploit reportedly leverages a combination of aliasing bugs, race conditions, and control flow hijacking to achieve arbitrary code execution. Google has released Chrome updates addressing some V8 vulnerabilities around the same time, but it is unclear if these fixes cover the bugs exploited by Cyberkimi. This development highlights the shrinking window between patch release and exploit weaponization, potentially accelerating the risk exposure for users of affected Chrome versions.
CVE-2026-76925 is a Time-of-check to Time-of-use (TOCTOU) race condition vulnerability in the Flatpak component org.freedesktop.Flatpak.SystemHelper used by Red Hat Enterprise Linux 10. The flaw arises because a privileged chmod operation occurs before OSTree repository validation in the Deploy() function. A local attacker with limited privileges who can win the timing race may redirect symlinks to arbitrary files, potentially causing unauthorized file manipulation or information disclosure. Exploitation requires local access and is difficult due to the narrow timing window. Red Hat has deferred the fix, citing limited residual risk and lack of suitable mitigations.
In the Linux kernel, the following vulnerability has been resolved: RDMA/rxe: Fix responder UAF on IB_QP_MAX_DEST_RD_ATOMIC modify_qp rxe_qp_from_attr() handles IB_QP_MAX_DEST_RD_ATOMIC outside the IB_QP_STATE path, so it holds no state_lock and runs while the responder task rxe_receiver() (recv_task on rxe_wq) is live. A modify_qp() setting only that attribute calls free_rd_atomic_resources() then alloc_rd_atomic_resources(), swapping qp->resp.resources[] while rxe_prepare_res()/find_resource() walk it; free_rd_atomic_resources() also leaves the cached pointer qp->resp.res dangling. A local unprivileged user can race the free/realloc into a use-after-free in rxe_receiver() (local DoS). Drain recv_task around the swap with rxe_disable_task()/rxe_enable_task(), as rxe_qp_reset() already does when tearing this array down, re-enabling only after alloc_rd_atomic_resources() succeeds so the responder never resumes against a NULL qp->resp.resources on the ENOMEM path. Also clear qp->resp.res in free_rd_atomic_resources(), like the rxe_resp.c completion paths. Reproduced under KASAN; the slab-use-after-free in rxe_receiver() is gone.
In the Linux kernel, the following vulnerability has been resolved: erofs: remove fscache backend entirely EROFS over fscache was introduced to provide image lazy pulling functionality. After the feature landed, the fscache subsystem made netfs a new hard dependency, which is unexpected for a local filesystem and has an kernel-defined caching hierarchy which could be inflexible compared to the fanotify pre-content hooks. Therefore, this feature has been deprecated for almost two years. As EROFS file-backed mounts and fanotify pre-content hooks both upstream for a while and already providing equivalent functionality (erofs-utils has supported fanotify pre-content hooks), let's remove the fscache backend now. The main application of this feature is Nydus [1], and they plan to move to use fanotify pre-content hooks in the near future too. I hope this patch can be merged into Linux 7.2, which is also motivated by newly found implementation issues [2][3] that are not worth investigating given the deprecation and limited development resources. The associated fscache/cachefiles cleanup patch will follow separately through the vfs tree (netfs) later: it seems fine since the codebase is isolated by CONFIG_CACHEFILES_ONDEMAND. [1] https://github.com/dragonflyoss/nydus/blob/v2.1.0/docs/nydus-fscache.md [2] https://github.com/dragonflyoss/nydus/pull/1824 [3] https://lore.kernel.org/r/20260619135800.1594811-1-michael.bommarito@gmail.com
GitPython versions up to 3.1.58 have an incomplete denylist for unsafe git revision options in the Repo.blame() and Repo.blame_incremental() methods. This allows an attacker to use the --contents or -S options to read arbitrary local files, as these options are not blocked and cause the file's lines to be included in the blame output. The vulnerability results in arbitrary local file read at the privileges of the host process. A fix is available in version 0.7.2_7.
CVE-2026-73738 is a medium severity vulnerability in the underlying operating system of HPE Networking Fabric Composer. It allows an authenticated low privilege operator user with local access to view sensitive information. Exploitation could enable an attacker to retrieve data that might be used to escalate privileges on the affected system. There is no indication of known exploits in the wild or available patches at this time.
CVE-2026-73740 is a local privilege escalation vulnerability in HPE Networking Fabric Composer. It allows an authenticated privileged user on the underlying host to elevate their privileges to a higher role, enabling changes to certain system settings. The vulnerability has a CVSS score of 4.4, indicating medium severity. No specific affected versions or patches are currently documented. There are no known exploits in the wild at this time.
A weakness has been identified in extension.vn 2FA Authenticator Extension 1.0.0.2 on Chrome. The impacted element is the function chrome.runtime.onMessageExternal.addListener of the component Background Service Worker. Executing a manipulation of the argument sender.id can lead to information disclosure. The attack requires local access. The exploit has been made available to the public and could be used for attacks. The vendor was contacted early about this disclosure.
JSCeal is a sophisticated cryptocurrency-focused stealer malware delivered as compiled V8 bytecode executed by a bundled Node.js runtime. It employs multiple layers of JavaScript obfuscation and encryption, including RC4 and AES-256-CBC, to protect its payload. The malware's capabilities include keylogging, browser credential theft, cryptocurrency collection, HTTPS traffic interception via a local man-in-the-middle proxy, and session replay using stolen cookies. Recent variants target macOS and newer V8 versions, showing active development. Check Point Research developed a fully static deobfuscation pipeline to analyze JSCeal without executing it, enabling detailed understanding of its behavior. The toolkit is publicly available and supports analysis of multiple samples.
CVE-2026-80716 is a high-severity vulnerability in the Linux kernel's ALSA PCM subsystem affecting linked stream drain waiters. The flaw involves improper handling of wait entries on the drained peer's runtime sleep list during snd_pcm_drain() unlink operations, which can lead to use-after-free conditions when group membership changes during the wait. This can cause kernel memory corruption and potentially allow local attackers to compromise system integrity. The issue affects multiple Linux kernel versions prior to 5.15.0-1117.124~20.04.1 and related builds. A fix has been released in updated kernel versions.
A vulnerability in the Linux kernel coresight subsystem (ETE component) was fixed to ensure state is always saved on CPU power down. The issue involved system registers for ETMs and ETE not being preserved during CPU power down, causing potential state loss and errors when using Coresight with ACPI on certain platforms. The fix hardcodes settings to preserve state and uses local variables to avoid concurrency issues during device probing.
In openssl_encrypt (pip package openssl-encrypt) versions <= 1.4.8, the desktop GUI passes the steganography password to the CLI child process on the command line via the --stego-password argument (on both encrypt and decrypt paths) instead of via an environment variable as done for the main password. Any local user can read the steganography password from /proc/<pid>/cmdline for the lifetime of the subprocess. Fixed in 1.4.9.
CVE-2026-81099 is a high-severity vulnerability in the timescale tiger-slack product where the MCP HTTP transport did not enable host allow-listing, allowing DNS rebinding attacks. This flaw allows an attacker to craft a request with a controlled hostname to interact with the local Slack MCP server via a victim's browser. The issue was fixed by explicitly setting the DNS-rebinding-protection option alongside a dependency update. No official release version brackets the fix, so the affected versions are those prior to the commit containing the fix.
CVE-2026-81573 is a high-severity vulnerability in Wibu-Systems-AG CodeMeter Runtime versions before 8.41a or 9.10 when configured as a server. The configuration command handler fails to enforce network-origin restrictions, allowing remote attackers to execute commands intended only for local or same-network clients. This can lead to unauthorized reading of sensitive configuration data and overwriting values in Server.ini, including the hash of credentials for the CodeMeter WebAdmin, potentially enabling WebAdmin takeover.
In the Linux kernel, the following vulnerability has been resolved: ceph: fix hanging __ceph_get_caps() with stale mds_wanted A reader can hang forever in __ceph_get_caps() when the client no longer holds `FILE_RD`, but local cap state still says that the capability is already wanted (via `mds_wanted`). One way to trigger this is through MDS cap revocation. If another client performs a conflicting operation, the MDS can revoke `FILE_RD` from the reader; the next read then has to reacquire `FILE_RD`. If the cap update that should request `FILE_RD` never reaches the MDS after `cap->mds_wanted` was raised, the reader is left holding only non-file caps while local `mds_wanted` still includes the file read caps. In that state, try_get_cap_refs() sees `need <= mds_wanted` and returns 0, so __ceph_get_caps() just waits on `i_cap_wq`. If the cap update that was supposed to request `FILE_RD never reaches the MDS after `cap->mds_wanted was` raised, no further request is sent and the waiter can sleep indefinitely until unrelated cap traffic happens to wake it up. The ordering issue is that `cap->mds_wanted` is updated in __prep_cap() before the `CEPH_MSG_CLIENT_CAPS message` is actually queued for send. That makes one field serve two different meanings at once: what this client wants, and what the client believes the MDS already knows it wants. A proper fix would be to split those states and track whether a cap update is actually in flight or has been observed by the MDS. However, simply moving the `cap->mds_wanted assignment` later would not be sufficient: queueing the message in the messenger does not guarantee that the MDS processed that specific wanted set, and reconnect or message loss can still invalidate that assumption. Fixing that properly would require a larger rework of the cap state machine. To allow simpler backports to stable kernels, this patch implements a simpler workaround: - stop waiting forever in __ceph_get_caps(); after a bounded wait, fall back to the renew path - make ceph_renew_caps() issue a synchronous `OPEN` request whenever the inode still does not actually hold the wanted caps, instead of only calling ceph_check_caps() The extra issued-vs-wanted check in ceph_renew_caps() is necessary because the previous test only checked whether the inode still had any real caps at all. That is not enough after revocation: the client can still hold something like `pLs` and yet be missing `FILE_RD` completely. In that case, falling back to ceph_check_caps() is not sufficient, because it still trusts `cap->mds_wanted` and may resend nothing. By requiring `(issued & wanted) == wanted` before taking the asynchronous path, the code only uses ceph_check_caps() when the `wanted caps` are already actually issued. Otherwise, it sends the synchronous `OPEN` renew. This preserves the existing asynchronous fast path when the wanted caps are already issued, avoids changing cap-state semantics, and fixes the hang by guaranteeing that a stalled waiter eventually retries through a path that does not rely on the stale `mds_wanted` state. [ idryomov: move CEPH_GET_CAPS_WAIT_TIMEOUT from libceph.h to mds_client.h, formatting ]