Information Disclosure

Memory corruption in the Linux kernel's VMware graphics (vmwgfx) DRM driver allows a local, low-privileged user on a VMware guest system to corrupt MOB (Memory Object Buffer) allocation metadata, leading to out-of-bounds reads or writes with high confidentiality, integrity, and availability impact. A field-naming bug in vmwgfx_resource.c writes boolean literals (0/false and 1/true) to the guest_memory_size unsigned-long field instead of the adjacent guest_memory_dirty bitfield, causing subsequent size-dependent operations to compute zero-length or wrap-around memory ranges on the MOB bitmap. No public exploit has been identified at time of analysis; EPSS is very low at 0.17% (6th percentile), though the CVSS 7.8 score reflects meaningful severity if triggered locally on a VMware guest.

Use-after-free in the Linux kernel Bluetooth HCI sync subsystem exposes systems running vulnerable kernel versions (6.6.51-pre-6.7 and 6.8.9-pre-6.9) to potential kernel-context memory corruption from an adjacent attacker with no privileges required. The race condition occurs when hci_connect_acl/le_sync() callbacks dereference a freed hci_conn object during concurrent connection teardown, yielding a theoretical path to arbitrary code execution or kernel panic. No public exploit code has been identified at time of analysis, and EPSS at 0.15% (5th percentile) indicates very low observed exploitation activity.

Null pointer dereference in the Linux kernel's SCSI target iblock driver crashes the kernel when processing Persistent Reservation PREEMPT or RELEASE operations against storage backends with unimplemented PR hooks. Systems running the kernel as an iSCSI target are vulnerable - an attacker who can issue SCSI Persistent Reservation commands can trigger a kernel panic, causing a complete denial of service. No public exploit has been identified and EPSS sits at 0.17% (6th percentile), but patches are available across multiple stable branches and should be applied promptly on iSCSI target infrastructure.

Out-of-bounds vmemmap read in the Linux kernel's mm/util snapshot_page() crashes or leaks kernel memory during page isolation on memory-remove paths. The function incorrectly reads __page_2 when nr_pages > 1 rather than the correct threshold of nr_pages > 2, causing an illegal access into an adjacent, unmapped vmemmap section when an order-1 folio sits at a vmemmap section boundary. This was observed producing a kernel oops on ppc64le systems during DLPAR memory remove on a 22 TB LPAR. No public exploit is identified and EPSS is 0.17%, but the defect can cause a local denial-of-service or kernel memory disclosure. Patches are available across multiple stable kernel branches.

Denial-of-service in the Linux kernel's KVM subsystem on IBM Z (s390) mainframes stems from an unchecked airq_iv_create() return value in the zPCI adaptive-interrupt path. When AIBV allocation fails, zdev->aibv is left NULL and later dereferenced in kvm_zpci_set_airq(), crashing the host kernel. No public exploit identified at time of analysis and it is not in CISA KEV; EPSS is low at 0.17% (7th percentile), consistent with a hard-to-trigger, resource-exhaustion-dependent bug rather than a broadly weaponizable flaw.

Use-after-free in the Linux kernel Bluetooth SCO subsystem allows an adjacent unauthenticated attacker to corrupt freed kernel memory by exploiting a reference-counting race between socket close() and Bluetooth controller Disconnection Complete events. The race causes sco_conn_del() to perform a double put on a kref, confirmed by KASAN as slab-use-after-free, with potential to escalate privileges or crash the system. No public exploit or CISA KEV listing exists; EPSS is 0.17% (6th percentile), consistent with the race condition complexity limiting practical exploitation.

Incorrect unit conversion in the RISC-V memory management subsystem causes vmemmap_start_pfn to be computed with a physically misaligned base, violating the mask-alignment requirement for compound_info encoding in the sparse memory model. Linux kernel versions incorporating commit 476849b0fba4 on RISC-V hardware where DRAM base is not aligned to MAX_FOLIO_NR_PAGES × PAGE_SIZE are affected - a condition confirmed on QEMU virt machines and potentially other RISC-V platforms. CVSS 7.8 (AV:L/PR:L/C:H/I:H/A:H) reflects potential local privilege escalation via kernel memory corruption; EPSS of 0.17% (7th percentile) and no CISA KEV listing indicate no observed exploitation activity. No public exploit is identified at time of analysis.

Use-after-free in the Linux kernel's VXLAN transmit path (vxlan_xmit) lets a stale Ethernet header pointer be dereferenced after route_shortcircuit() calls pskb_may_pull() and reallocates skb->head, corrupting or reading freed memory when accessing eth->h_dest. The flaw affects systems using a VXLAN overlay interface and is most realistically a denial-of-service (kernel crash) with potential information disclosure; no public exploit identified at time of analysis and EPSS is low (0.18%). It is not listed in CISA KEV and no proof-of-concept is known.

Use-after-free in the Linux kernel's AMD MP2 I2C driver (i2c-amd-mp2) enables local low-privileged users to corrupt kernel memory, potentially achieving privilege escalation or system crash on AMD hardware. The flaw occurs during driver probe: when i2c_add_adapter() fails, devres frees the platform I2C context, but the MP2 PCI driver retains a stale pointer in its IRQ and system-sleep callback table, allowing subsequent dereference of freed memory. No public exploit exists and EPSS is 0.18% (7th percentile), reflecting the hardware-specific and error-path-dependent nature of this flaw; vendor-released patches are available across all major stable kernel branches.

Race condition in the Linux kernel's driver core `dev_has_sync_state()` exposes a TOCTOU (Time-of-Check Time-of-Use) flaw allowing local low-privileged users to potentially trigger kernel memory corruption, information disclosure, or a system crash. The function reads `dev->driver` twice without holding `device_lock()`, enabling a concurrent device unbind operation to clear the pointer between the NULL check and its subsequent dereference, resulting in use of a stale or NULL pointer in kernel context. No active exploitation has been identified (no CISA KEV listing, EPSS 0.18%), but the kernel-level impact class warrants prompt patching on affected stable branches.

The BPF signed loader in the Linux kernel fails to enforce map exclusivity before performing SHA-based integrity validation of metadata maps, allowing a local attacker with BPF privileges to race a mutation of the shared map's contents after the hash is computed but before validation completes. Systems running Linux kernel between commit fb2b0e290147ba01a53dfd92cf91058c9d2ee254 and the patched stable releases (6.18.40, 7.1.5, 7.2) are affected. Exploitation bypasses the integrity guarantees of the signed BPF loader, enabling the attacker to make the check pass on stale, attacker-controlled data; no public exploit exists and EPSS is 0.17% (6th percentile), indicating low current exploitation probability.

Use-after-free / stale-pointer race in the Linux kernel netfilter nf_conntrack_expect subsystem was resolved by replacing the per-expectation timer API with the conntrack garbage-collection worker. Under the old timer scheme, expectation removal could lose a race with an expiring timer (timer_del() returning false), leaving an expectation referencing an already-released exp->master conntrack, enabling stale-pointer access. The issue affects systems using connection-tracking helpers/expectations (e.g. FTP, SIP, or nft_ct expectations); no public exploit identified at time of analysis and it is not listed in CISA KEV, with a very low EPSS of 0.15% (5th percentile).

Symlink-based file clobbering in the Linux kernel's intel-speed-select daemon allows a local low-privileged user to redirect root-process writes to an attacker-chosen file by pre-positioning a symlink at the daemon's fixed /tmp pidfile path. Affected systems are those running Linux 5.18 through unpatched 6.x and 7.x branches on Intel Speed Select Technology hardware with the daemon active. No public exploit is identified at time of analysis and EPSS is low (0.17%, 7th percentile), but the attack is mechanically simple and requires only a local shell account.

Kernel stack disclosure and potential denial-of-service affect Linux systems with CXL hardware due to an off-by-8 size constant in the CXL RAS capability subsystem introduced in Linux 6.2. A local user who can trigger a CXL AER uncorrectable error and read tracefs can obtain up to 448 bytes of adjacent kernel stack data - potentially including code pointers and sensitive in-flight values - from the tracefs ring buffer. No public exploit identified at time of analysis; EPSS at 0.17% (6th percentile) reflects the niche CXL hardware dependency and local-only attack vector.

Uninitialized-value access in the Linux kernel's HFS+ filesystem driver allows a local attacker with mount privileges to trigger kernel memory corruption or information disclosure by supplying a crafted disk image containing an invalid btree node_size. The flaw is reached during the mount path - specifically in hfsplus_bnode_find() while loading the HFS+ catalog B-tree - when a corrupted node_size value (e.g., 1) causes an excessively large offset to be passed to hfs_bnode_read_u16(), resulting in use of uninitialized stack memory. No public exploit has been identified and EPSS is 0.15% (5th percentile); upstream stable patches are available at git.kernel.org.

Race condition in the Linux kernel's hisi_sas v3 hardware driver triggers a kernel WARNING and potential memory corruption when SAS phy link reset and driver removal (rmmod) execute simultaneously. Specifically, during SAS phy bring-up, device_links_driver_bound sets the link status to DL_STATE_AVAILABLE, and a concurrent rmmod then causes __device_links_no_driver() to encounter an inconsistent device-link state. No public exploit exists and EPSS sits at 0.17% (6th percentile), reflecting this is a hardware-specific, privilege-intensive, timing-dependent flaw with very low exploitation likelihood in practice.

NULL pointer dereference in the Linux kernel IPv6 subsystem - specifically in `__in6_dev_stats_get()` - can crash the kernel and cause a denial of service when a physical network device is unregistered while IPv6 statistics are being collected. The vulnerability affects a wide range of stable kernel branches, from 4.19 through 7.x, and has been patched across all active LTS trees. No active exploitation is confirmed (not in CISA KEV) and EPSS at 0.18% (7th percentile) reflects low current real-world exploitation interest, though the ubiquitous deployment of the Linux kernel makes patch cadence important.

Invalid pointer dereference in the Linux kernel's RapidIO TSI721 driver allows an unauthenticated attacker on an adjacent RapidIO network to crash the kernel or corrupt memory by sending a crafted doorbell message. The root cause is a logic error in tsi721_db_dpc(): the 'found' flag is not reset at the start of each list_for_each() iteration, causing every doorbell after the first match to be treated as found, and causing list-end traversal with an invalid iterator pointer when no match exists. No public exploit exists and EPSS is 0.18% (7th percentile), consistent with the highly constrained physical attack surface; patches are available across multiple stable kernel branches.

Out-of-bounds stack read in the Linux kernel's netfilter flowtable (nf_flow_table / nft_dev_forward_path) affects the bridge VLAN-untag fast path, where a u8 num_encaps counter can underflow from 0 to 255 and cause the kernel to walk a fixed 2-entry encap[] array far past its bounds. Affected are kernels from 5.13 onward that use netfilter flowtable offload over bridge devices; the flaw leaks adjacent kernel stack memory into a route descriptor and copies a bogus encap count. No public exploit is identified at time of analysis, EPSS is low (0.15%), and it is not in CISA KEV.

Missing dma_resv lock acquisition before dma_buf_unpin() in the Linux kernel iommufd subsystem causes a kernel WARN on every IOAS destruction or unmap path that releases the last reference to a DMABUF-backed iopt_pages object. Affected are kernel versions from the commit introducing DMABUF pinning in iommufd (8c5f9645c389) through the fix commits in the 7.1 and 7.2 stable trees, with patches confirmed at Linux 7.1.5 and 7.2. No public exploit or active exploitation has been identified; EPSS is 0.15% (5th percentile), indicating negligible automated exploitation probability at time of analysis.

Memory corruption in the Linux kernel's net/sched fq_codel queueing discipline lets a local actor with traffic-control privileges trigger a wild kernel memory access and crash. When fq_codel drops packets during a peek operation, it calls qdisc_tree_reduce_backlog before restoring qlen; if qlen momentarily hits zero while peek still holds an skb, the parent class (e.g. qfq) is wrongly deactivated, producing a general-protection fault against a poisoned list pointer (0xdead000000000100 range) as seen under KASAN. No public exploit identified at time of analysis, EPSS is low (0.18%), and it is not in CISA KEV.

Race condition in the Linux kernel's ALSA OSS sequencer layer exposes local low-privilege attackers to kernel ring-buffer state corruption via unsynchronized reset operations. Specifically, snd_seq_oss_readq_clear() modifies qlen, head, and tail fields without holding q->lock, racing against reader and producer paths that correctly acquire the spinlock, potentially leaving stale or dropped MIDI events and corrupted readiness state. No public exploit identified at time of analysis; EPSS at 0.17% (6th percentile) indicates negligible current exploitation interest despite the CVSS 7.8 score reflecting theoretical kernel memory corruption severity.

Use-after-free and race condition vulnerabilities in the Linux kernel's tlclk (Telecom Clock) character driver expose local low-privileged users to potential kernel-space memory corruption, privilege escalation, or system crash. The module cleanup function tlclk_cleanup() frees alarm_events memory before awakening blocked waitqueue readers and before the switchover_timer completes, creating a use-after-free window during concurrent module unload. Additionally, the missing .owner field in file_operations allowed module unloading while userspace held the device open. No public exploit exists and EPSS is 0.18%, but patched kernel versions are confirmed across all active stable branches.

Use-after-free in the Linux kernel AppArmor subsystem's aa_replace_profiles function exposes kernelspace memory to corruption by a local low-privileged attacker. The defect arises from reading udata->size after aa_put_loaddata(udata) has released the reference - if that release triggers a free, the subsequent read constitutes a UAF that can be leveraged for privilege escalation or arbitrary kernel memory manipulation. EPSS sits at 0.18% (7th percentile) and no CISA KEV listing exists, indicating no confirmed widespread exploitation, though the local-access, low-complexity nature makes this a realistic intrahost threat on AppArmor-enabled systems.

Use-after-free in the Linux kernel's veth driver XDP error path allows a local attacker with network interface configuration privileges to corrupt kernel memory, potentially achieving privilege escalation. The flaw stems from an off-by-one error in the rollback loop during XDP enablement: when xdp_rxq_info_reg() or xdp_rxq_info_reg_mem_model() fails, the loop skips netif_napi_del() for the failing queue index, leaving a dangling napi_struct in the device's napi_list. On subsequent device teardown, the freed - and potentially reallocated - queue memory is traversed via the stale NAPI list, resulting in UAF with full C/I/A impact. No public exploit or CISA KEV listing has been identified at time of analysis; EPSS is 0.17% (7th percentile), reflecting low current exploitation probability.

Metadata corruption in the Linux kernel's lightweight tunnel (LWT) subsystem affects forwarded packets that carry XDP/TC skb metadata when they pass through LWT encapsulation (seg6, rpl, ila, mpls, ioam6, or BPF LWT xmit). Because encapsulation prepends outer headers over the skb headroom where metadata lives, non-BPF encaps silently overwrite it while BPF LWT xmit triggers a skb_data_move() WARNING and clears it; the fix drops metadata at the three LWT dispatch chokepoints before handing the skb to the encap op. There is no public exploit identified at time of analysis, EPSS is low (0.15%), and the nominal CVSS 9.8 appears substantially overstated for what is fundamentally a kernel data-path robustness fix.

Use-after-free race condition in the Linux kernel's amdxdna AMD AI accelerator driver allows a local low-privileged user to trigger kernel memory corruption by racing device removal against GEM object deallocation, potentially achieving full kernel privilege escalation. The flaw is specific to deployments where force_iova mode is enabled in the amdxdna driver, limiting the real-world exposure to systems with AMD XDna-capable hardware. No CISA KEV listing and no public proof-of-concept exist; EPSS of 0.15% (5th percentile) confirms this remains a theoretical priority rather than an active exploitation concern.

Use-after-free in the Linux kernel's batman-adv mesh networking gateway module exposes systems on batman-adv mesh segments to kernel memory corruption via crafted Ethernet frames. The flaw occurs because pskb_may_pull(), called within batadv_get_vid(), can reallocate the socket buffer backing store, leaving the ethernet header pointer stale; the code then dereferences this freed pointer before the fix reassigns it. No public exploit exists and EPSS sits at 0.18% (7th percentile) with no CISA KEV listing, but kernel-level UAF carries theoretical escalation-to-privilege-or-crash potential on any system actively running batman-adv.

Use-after-free in the Linux kernel's batman-adv (B.A.T.M.A.N. advanced) distributed ARP table (DAT) code lets an attacker on the same mesh corrupt kernel memory: batadv_get_vid() calls pskb_may_pull(), which can reallocate the skb buffer, leaving the previously-cached ARP hardware-source pointer dangling and later dereferenced. The flaw affects systems running batman-adv mesh networking across numerous stable kernel branches; a vendor fix reorders the pointer acquisition to occur after the realloc. No public exploit is identified at time of analysis, EPSS is low (0.18%, 7th percentile), and it is not on CISA KEV.

Corrupted xattr entry handling in the Linux kernel's f2fs filesystem driver exposes local users to kernel memory disclosure and potential corruption. When f2fs_listxattr() processes a crafted or corrupted filesystem image containing malformed extended attribute entries that fall outside the valid xattr storage area, the kernel previously returned a partial success result without validating entry boundaries. This flaw affects a wide range of kernel stable branches from the commit introducing the bug (688078e7f36c293dae25b338ddc9e0a2790f6e06) through the backported fixes. No public exploit code exists and EPSS is 0.18% (7th percentile), indicating low exploitation probability at time of analysis.

Kernel panic vulnerability in the Linux kernel's IP fragment reassembly path allows an unprivileged user in their own user namespace to crash the host kernel by writing two specially crafted packets with GSO (Generic Segmentation Offload) metadata to a tun/tap device. The flaw exists because inet_frag_queue_insert() - shared by IPv4, IPv6, nf_conntrack_reasm, and 6lowpan reassembly - fails to strip GSO state from fragments before queuing, causing the reassembled skb to reach skb_segment() with SKB_GSO_DODGY state and trigger BUG_ON() assertions. The vulnerability is also reachable with CAP_NET_RAW in a netns where a defrag point precedes a GSO point, and from a guest VM whose VMM forwards virtio_net_hdr to a host tap; KEV status is unconfirmed and EPSS is low at 0.18% (7th percentile), though the CVE description contains a working reproducer.

Unauthenticated arbitrary file read in the Shared Files Pro WordPress plugin (all versions before 1.7.70) allows remote attackers to supply an unvalidated path parameter during featured image creation, causing the plugin to read and republish any file accessible to the web server process at a public URL. This compound impact - read plus republication - means sensitive data such as wp-config.php database credentials or secret keys can be exfiltrated and exposed to any internet user, not just the attacker. A publicly available proof-of-concept exists, and the CVSS vector confirms no authentication or user interaction is required against any default installation of the affected plugin.

Unauthenticated network access to the getCloudSrvCheckStatus function on TOTOLINK T6 firmware 4.1.5cu.748_B20211015 exposes cloud firmware check status information to any remote attacker who sends a crafted POST to /cgi-bin/cstecgi.cgi. The CWE-284 improper access control flaw requires no credentials or session token, though the leaked data - firmware update check status - is of modest sensitivity compared to credentials or full configuration disclosure. No public exploit code has been independently confirmed; technical details are publicly available via researcher coordination repositories, and EPSS at 0.18% reflects limited observed exploitation pressure at this time.

Privilege escalation to account takeover in WatchGuard Dimension allows a low-privileged Dimension Administrator to hijack a Super Administrator account by harvesting that user's session token from a diagnostic log in the web UI. Because session identifiers are written unredacted, any authenticated administrator who can read the diagnostic log can impersonate a Super Administrator while that user is logged in, gaining full control of the management platform. No public exploit identified at time of analysis, and the flaw is not listed in CISA KEV.

Remote code execution in WatchGuard Fireware OS affects the iked IKE/IPsec VPN daemon, where a memory-safety defect lets a remote unauthenticated attacker run arbitrary code by sending specially crafted network traffic to the appliance's VPN listener. The CVSS 4.0 base score of 9.3 reflects network-reachable, no-privilege, no-interaction exploitation with high confidentiality, integrity, and availability impact. No public exploit is identified at time of analysis and it is not listed in CISA KEV, but the pre-authentication RCE profile on an internet-facing firewall makes this high priority.

Out-of-bounds read in the WatchGuard Fireware OS iked (Internet Key Exchange daemon) process enables remote unauthenticated attackers to crash VPN processing by sending specially crafted network traffic, resulting in a Denial of Service condition. All Fireware OS versions appear affected per the wildcard CPE, and the vulnerability is reachable without authentication from any network path to the iked listener. No public exploit code or CISA KEV listing has been identified at time of analysis, but the low attack complexity makes this a realistic target for disrupting VPN availability on WatchGuard appliances.

Out-of-bounds read in the WatchGuard Fireware OS iked (IKE daemon) process allows remote unauthenticated attackers to disrupt VPN operations by sending specially crafted network packets. The flaw resides in VPN processing logic and can crash or destabilize the IKE service, cutting off IPsec/IKEv2 tunnels for connected clients and sites. No public exploit has been identified at time of analysis and CISA KEV listing is not confirmed; however, the unauthenticated network attack vector and CVSS 4.0 score of 8.7 place this in the priority triage tier for organizations relying on WatchGuard Firebox VPN connectivity.

Cluster secret exposure in Wazuh 4.14.0-4.14.6 stems from a logic inversion in the RBAC masking gate that counterintuitively makes hardened accounts more exposed than default ones. Any authenticated low-privilege user whose role includes an explicit DENY on config-update actions can issue a single GET request to the manager configuration API with `raw=true` and receive the full `ossec.conf` XML with `cluster.key` in cleartext - because the broken gate treats the mere presence of a deny-rule entry as proof of update permission, disabling masking entirely. No public exploit has been identified at time of analysis, but the fix is available in 4.14.7 and the root cause is confirmed by vendor advisory and merged commit.

Out-of-bounds read in V8, Chrome's JavaScript engine, enables remote code execution confined within the renderer sandbox on all platforms running Chrome prior to 151.0.7922.72. The flaw is triggered by a specially crafted HTML page, requiring only that a user visit a malicious site - no authentication or elevated privileges are needed from the attacker. No public exploit code has been identified and no active exploitation is confirmed; EPSS probability stands at 0.30%, aligning with SSVC's 'exploitation: none' classification despite the high CVSS score.

Use-after-free in cpp-httplib's TLS WebSocket client (versions 0.33.0 through 0.50.0) corrupts process memory during ordinary secure WebSocket teardown, causing denial of service in any application that embeds this header-only C++ library with wss:// connections. The SSL/TLS session object is freed in `WebSocketClient::shutdown_and_close` before the WebSocket close frame is transmitted, but the underlying `SSLSocketStream` retains a raw pointer to the freed session and dereferences it during the close handshake. The defect is reachable through three distinct paths - the client destructor, an explicit `shutdown_and_close` call, and the `connect()` reconnect path - meaning routine connection lifecycle events, not crafted adversarial input, reliably trigger the corruption. No KEV listing or standalone public exploit exists at time of analysis; vendor-released patch version 0.50.1 is available.

Improper access control on the Synergis Softwire installation folder exposes sensitive files to any low-privileged local user on Windows Server deployments and Genetec Streamvault SV-100E and SV-300E all-in-one appliances. The CVSS scope change (S:C) is particularly consequential in this context: Synergis Softwire is a physical access control server, meaning credentials or configuration material extracted from the installation directory could allow an attacker to manipulate physical security decisions or pivot into backend systems. No public exploit has been identified at time of analysis, and Genetec has released remediated versions in the 12.0.2 and 12.2.0 branches.

Cleartext transmission of MQTT credentials and control traffic in Ebyte NE2-D11 firmware allows network-positioned attackers to intercept authentication material and message payloads, then impersonate devices and disrupt messaging. The flaw affects the NE2-D11 serial-to-Ethernet/MQTT gateway and was disclosed via CISA ICS advisory ICSA-26-237-06 (reported by ICS-CERT). No public exploit is identified at time of analysis, and it is not listed in CISA KEV; EPSS was not provided.

Unrestricted authentication attempts in Ebyte NE2-D11 firmware expose password-protected deployments to automated brute-force credential attacks. The device, classified as an industrial OT product and covered by ICS-CERT advisory ICSA-26-237-06, lacks both rate limiting and account lockout controls - two standard defenses against credential guessing. A remote unauthenticated attacker who successfully brute-forces the login interface gains high-confidence read access to device configuration and data, reflected in the CVSS 4.0 VC:H rating. No public exploit code or CISA KEV listing has been identified at time of analysis.

TLS peer impersonation in Applied Systems Engineering's ASE2000 v2 (versions 2.35 through 2.37) lets a network-positioned attacker complete the TLS handshake as a fraudulent trusted peer because the client fails to properly validate the server certificate (CWE-295). Successful exploitation exposes and allows tampering with protected SCADA/RTU communications carried over the ostensibly secure channel. Reported through CISA ICS-CERT (ICSA-26-239-04); no public exploit identified at time of analysis and it is not listed in CISA KEV.

Unauthenticated content exfiltration in Trilium up to 0.103.0 is possible through the public share-search endpoint, which applies authorization only to the ancestor note supplied in the request rather than to each result it returns. Any visitor with HTTP access to the instance can query `/share/api/notes` to enumerate titles, tree paths, and share identifiers of notes protected by `shareCredentials` passwords or hidden via `shareHiddenFromTree`, and can use the endpoint as a boolean substring oracle to iteratively reconstruct the full plaintext of password-gated notes. No public exploit has been identified at time of analysis, and the issue is patched in version 0.104.0.

Namespace injection in the MongoDB PHP Library allows attackers with application-level access to silently redirect database operations to unintended collections or databases by supplying identifiers containing '.' or NUL byte characters. Applications using the MongoDB PHP Library before 2.4.1 or the MongoDB PHP Driver before 1.21.7 that incorporate untrusted text into namespace identifiers are affected, with high confidentiality and integrity risk confirmed by the CVSS 4.0 score of 8.6. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.

Namespace injection in MongoDB Go Driver's Client.BulkWrite API allows an attacker who controls the database name argument to redirect bulk write operations to an unintended database and collection. When an application passes untrusted, user-supplied input directly as a database name, the driver fails to escape reserved MongoDB namespace separator characters before constructing the target namespace string. The impact is a high-integrity write misdirection - data is silently written to attacker-influenced storage targets. No public exploit and no CISA KEV listing exist at time of analysis.

Spring Integration's reactive message pipeline leaks reply routing and security headers across concurrent users when an IntegrationFlow uses .fluxTransform() with an asynchronous or reordering operator that emits raw payloads, causing one user's replyChannel, correlationId, and security or tenant headers to be applied to another concurrent user's response. Affected versions span the 5.5.x, 6.4.x, 6.5.x, 7.0.x, and 7.1.0 release lines across the core Spring Integration library, as confirmed by VMware via the spring.io security advisory. The CVSS 8.2 score reflects network exploitability with no authentication required and high confidentiality impact; no public exploit has been identified at time of analysis.

Server-Sent Events (SSE) stream corruption affects Spring MVC applications built on the functional web framework across Spring Framework 5.3.0-5.3.49, 6.0.0-6.0.30, 6.1.0-6.1.28, 6.2.0-6.2.19 and 7.0.0-7.0.8, where unneutralized CRLF sequences (CWE-93) let an attacker inject into or corrupt the event stream. Reported by VMware/Spring and tagged as Information Disclosure, the flaw can break stream framing and potentially leak or splice data across SSE responses. No public exploit identified at time of analysis, and EPSS is low (0.16%, 6th percentile), but the vendor-assigned CVSS of 9.8 (all-High impact) sits in tension with the information-disclosure framing and warrants scrutiny.

Cross-origin data exfiltration in Spring for GraphQL exposes confidential application data when a victim browses a crafted URL pointing to the bundled GraphiQL interface. The GraphiQL IDE, intended for development use, can be weaponized to direct the victim's authenticated browser session to send GraphQL queries whose responses are leaked to an attacker-controlled origin. All major release lines from 1.0.0 through 2.0.4 are affected; no public exploit has been identified and the EPSS score sits at the 4th percentile, but the high confidentiality impact (C:H) and scope change make this notable for any deployment with GraphiQL exposed beyond trusted networks.

Unrestricted property key injection via Spring Cloud Commons' writable /actuator/env endpoint allows authenticated administrators to POST arbitrary environment properties with no allow-list enforcement, affecting all currently maintained release lines (3.1.10 and earlier through 5.0.2). With CVSS PR:H and a scope change (S:C), exploitation requires admin-level access to the actuator endpoint but can cascade integrity impacts across the entire Spring application context. No public exploit has been identified at time of analysis, and exploitation is gated on a non-default configuration requiring deliberate enablement of write access to the actuator endpoint.

Grafana Alloy's prometheus.operator.servicemonitors component exposes an arbitrary local file read path that leads to credential theft and potential Kubernetes privilege escalation. Any Kubernetes user with ServiceMonitor create or modify rights in a namespace watched by Alloy can point the bearerTokenFile field at any file accessible to the Alloy process - most critically Alloy's own projected Kubernetes service account token - and receive that file's contents exfiltrated via HTTP Bearer token to an attacker-controlled scrape endpoint. The CVSS 7.7 Scope:Changed rating correctly reflects that successful exploitation transcends the compromised namespace, potentially granting the attacker cluster-level API access commensurate with Alloy's own RBAC permissions. No public exploit has been identified at time of analysis.

Unauthenticated arbitrary PHP function invocation in the Tutor LMS WordPress plugin before 4.0.6 lets remote attackers overwrite internal template variables via request data and call any zero-argument PHP function, returning its output to the attacker. This enables information disclosure and potentially broader compromise depending on which functions are reachable. Publicly available exploit code exists (reported by WPScan), though the flaw is not listed in CISA KEV.

Unauthenticated remote process termination in MongoDB Connector for BI (mongosqld) affects deployments explicitly configured with Kerberos authentication. An attacker with network access to the mongosqld listener can send a crafted GSSAPI authentication exchange that triggers a double-free condition in error-handling code, crashing the process and interrupting BI availability until restarted. No public exploit code has been identified at time of analysis, and the attack is constrained to the subset of deployments running Kerberos - a non-default configuration.

Remote code execution in Craft CMS allows authenticated users with Twig template access to escape the sandbox via permissive Yii framework functionality, achieving full confidentiality, integrity, and availability compromise on the host system. The root cause is CWE-693 (Protection Mechanism Failure): the Twig sandbox policy was configured to permit dangerous Yii framework methods capable of executing arbitrary code, rather than enforcing a tight allowlist. The vendor confirmed and patched this as a high-severity RCE in release 5.10.7; no public exploit code has been confirmed at time of analysis, though a Hackrate hacktivity report exists referencing the issue.

Inadequate PBKDF2-HMAC-SHA256 iteration counts in openssl_encrypt versions before 1.4.9 leave post-quantum cryptography keyfile private keys and dual-encryption file-password verification material vulnerable to offline brute-force attack. The library applies only 100,000 iterations for PQC keyfile wrapping and a critically low 10,000 iterations for file-password verification - far below current NIST SP 800-132 recommendations - enabling attackers who obtain keyfiles or encrypted files to recover wrapping passwords using commodity GPU or ASIC hardware at practical cost. No public exploit has been identified at time of analysis, but the attack is technically straightforward once the prerequisite protected material is acquired, and vendor-released patch 1.4.9 is available.

Cryptographic integrity bypass and weak key derivation in the openssl-encrypt Python package (jahlives) before 1.4.9 let an attacker with physical write access to a portable USB drive plant an undetected root-level autorun payload and precompute the drive encryption key offline. The integrity verifier only checks manifest-listed files, so added files pass verification, while a hard-coded fallback KDF salt (_LEGACY_FIXED_SALT) enables an offline rainbow-table attack against drives lacking a per-drive salt. No public exploit identified at time of analysis, and it is not listed in CISA KEV.

Credential exposure in the openssl-encrypt pip package (versions ≤ 1.4.8) leaks keyserver bearer tokens in cleartext to stderr when the --debug flag is active. The root cause is a gap in sanitize_argv_for_debug(), which fails to redact the token supplied as a positional argument to the 'keyserver set-token' subcommand, leaving it visible in terminal output, CI/CD build logs, and shell history. Fixed in version 1.4.9; no public exploit identified at time of analysis, but credential exposure is immediately actionable for any attacker with access to affected log sources.

Signature-trust bypass in the openssl_encrypt Python library (PyPI 'openssl-encrypt') versions 1.4.8 and earlier lets an attacker get a forged GPG key enrolled as a plugin-signing trust anchor. Because enroll_trust_key matches key fingerprints with a suffix-tolerant comparison, an operator who verifies only a short (~32-bit, forgeable) GPG key id can be tricked into trusting an attacker-controlled colliding key, which then validly signs malicious plugins even under the strict ENFORCE signature policy. No CISA KEV listing and no public exploit identified at time of analysis; the fix is in 1.4.9.

Silent cryptographic key substitution in jahlives openssl_encrypt before 1.4.9 lets attackers register 'shadow' contact entries in the IdentityStore whose namespace collides with a user's own identity, staying hidden until that own identity is deleted. Once the own identity is removed, the attacker-controlled contact surfaces and resolves to the attacker's keys, so files subsequently encrypted for that identity are protected with keys the attacker holds. No public exploit is identified at time of analysis, and the issue is not in CISA KEV; the high CVSS 4.0 score (9.3) reflects the severe confidentiality and integrity impact of undetected key substitution.

Weak key derivation in openssl_encrypt before 1.4.9 exposes all files encrypted via the D-Bus CryptoService.EncryptFile handler to accelerated offline password guessing attacks that shatter the tool's documented confidentiality guarantees. The handler uses a single-pass SHA-256 hash for key derivation instead of a memory-hard algorithm such as Argon2id, enabling any attacker who obtains an encrypted file to crack the password six to seven orders of magnitude faster than the product implies. No public exploit code or active exploitation has been identified at time of analysis, though the weakness is structurally trivial to exploit with commodity GPU cracking tooling.

Silent cryptographic key substitution affects openssl_encrypt (the jahlives Python encryption library) before 1.4.9, which loads identities from identity.json without re-deriving and validating their fingerprints. An attacker who can tamper with an identity store can swap in their own public keys while preserving the claimed fingerprint, so the library encrypts data to attacker-controlled keys and treats attacker signatures as valid without any visible warning. No public exploit has been identified at time of analysis, and the flaw is not listed in CISA KEV.

Terminal escape-sequence injection in jahlives openssl_encrypt before 1.4.9 lets an attacker embed control characters in a file's metadata that are emitted verbatim when a victim runs the tool's 'info' command, letting the attacker repaint the terminal and forge the integrity/verification output the tool displays. The practical impact is spoofing: a tampered or malicious file can be made to appear verified or trustworthy to the operator. No public exploit identified at time of analysis, and the flaw requires the victim to run 'info' on attacker-supplied input.

Terminal escape-sequence injection in jahlives' openssl_encrypt (a Python OpenSSL-based file encryption utility) before 1.4.9 lets an attacker embed ANSI/VT control sequences in the key_id field of a crafted encrypted file; because the tool prints this attacker-controlled value unescaped to stderr during decrypt key auto-detection, an attacker can repaint the terminal and forge authenticity-verification output to deceive the operator. Any user who decrypts a malicious file is affected. This is a CWE-117 output-neutralization flaw reported by VulnCheck with no public exploit identified at time of analysis and no CISA KEV listing.

Verdict spoofing in the openssl-encrypt pip package (versions <= 1.4.8) lets an attacker who controls the contents of a scanned drive forge a PASSED tamper-check result. Because filenames read from untrusted drive data are printed by the verify-usb command without neutralizing terminal control bytes, crafted names containing cursor-movement and erase-line sequences can repaint the screen to hide genuine tamper detection. There is no public exploit identified at time of analysis and it is not in CISA KEV; the issue is fixed in 1.4.9, which routes drive-derived names through sanitize_for_display().

Cleartext credential interception in jahlives/openssl_encrypt before 1.4.9 exposes client_id values, passwords, and JWTs to network-path attackers through the login and register_with_email functions. The library accepts unencrypted http:// URLs and unconfigured host values without validation, transmitting authentication material in cleartext to keyservers and enabling full keyserver account takeover. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis, though the network-accessible nature with no required privileges makes credential interception straightforward for anyone positioned on the traffic path.

Weak pepper wrap key derivation in openssl_encrypt (versions before 1.4.9) allows fleet-wide offline password recovery against all users from a single precomputed dictionary table. The library derives its remote-pepper wrap key using unsalted HKDF-SHA256 or bare SHA-256 of the password, producing identical wrap keys across every user and every file - eliminating the per-user randomness that salting is designed to provide. Any attacker who obtains wrapped pepper blobs can precompute one lookup table and attack the entire user population at GPU-limited speed. No public exploit code has been identified at time of analysis, and this CVE is not listed in the CISA KEV catalog.

openssl_encrypt by jahlives (versions before 1.4.9) embeds an unkeyed SHA-256 digest of each plaintext document into the encrypted file's cleartext header, creating a passive plaintext-confirmation oracle. Any party who possesses an encrypted file - including unauthorized recipients of intercepted or leaked archives - can extract this hash without the encryption password and use it to verify guessed or known plaintexts via offline dictionary attacks. Additionally, because the hash is unkeyed and deterministic, identical source documents encrypted separately under different passwords produce matching header hashes, enabling cross-file correlation and fingerprinting that undermines the confidentiality guarantees users expect from file encryption. No public exploit code has been identified at time of analysis, and this vulnerability does not appear in CISA KEV.

Cleartext private key exposure in openssl-encrypt (pip package by jahlives) versions 1.4.8 and earlier allows any local user to read a stored mTLS client private key from a world-readable SharedPreferences file. The desktop GUI's Settings screen writes the combined certificate and private key PEM directly into a 0644-permissioned file, making it accessible to all local users on the system without elevated privileges. No public exploit or CISA KEV listing exists at time of analysis, but the trivial exploitation path (read a world-readable file) means any local user on an affected host can silently exfiltrate the private key and use it to impersonate the legitimate mTLS client.

Sensitive-file exposure in the openssl-encrypt pip package (openssl_encrypt) at versions <= 1.4.8 stems from its 'Encrypted USB Workspace' feature writing a marker that falsely declares the workspace AES-256-GCM encrypted while the derived key is never applied and the directory remains in cleartext. Users who trust the branding and store files in the workspace leave them fully readable on the removable media, so anyone with physical possession of the USB device can recover the data. No public exploit identified at time of analysis and the flaw is not in CISA KEV, but the failure silently defeats the product's core security promise.

Cross-realm information disclosure in OpenRemote's Notification REST API exposes all tenants' notification history - including full message bodies - to any authenticated tenant administrator on the platform. Any user holding read:admin credentials in one realm can issue a single zero-parameter GET request to retrieve sensitive notification data belonging to every other realm. No public exploit has been identified at time of analysis, but the attack is trivially simple and requires no technical sophistication beyond valid tenant admin credentials.

DNS rebinding in Timescale's tiger-gh-mcp-server allows an attacker-controlled web page to drive the victim's locally-bound GitHub MCP HTTP endpoint by exploiting the server's failure to validate Host headers. The src/httpServer.ts file called the shared httpServerFactory helper without passing the SDK's host allow-list option, meaning the server accepted any Host value - a prerequisite for classic DNS rebinding. An attacker who lures a developer running the server in HTTP mode to visit a malicious page can then invoke arbitrary GitHub MCP tools under the victim's authenticated session, including reading private repositories or issuing write operations. No public exploit has been identified and the vulnerability is not listed in CISA KEV.

DNS rebinding in tiger-slack's MCP HTTP transport exposes the locally running Slack MCP server to attacker-controlled browser requests. The root cause is that `mcp/src/httpServer.ts` invoked `httpServerFactory` without enabling the SDK's host allow-list option, leaving the server willing to honor any Host header value and making it trivially reachable via a DNS rebinding attack. Exploitation requires user interaction and a locally running tiger-slack instance; no public exploit code and no CISA KEV listing exist at time of analysis.

DNS rebinding against pg-aiguide's MCP HTTP transport (versions through 0.5.0) allows a remote unauthenticated attacker to access and control the locally-bound MCP server by exploiting the disabled host header allow-list in src/httpServer.ts. The underlying MCP SDK already provided DNS rebinding protection via a host allow-list option, but pg-aiguide's httpServerFactory call never enabled it, meaning every inbound Host header was accepted regardless of origin. No public exploit identified at time of analysis, though DNS rebinding is a well-documented attack class with readily available tooling.

DNS rebinding in mcp-go before 0.56.0 allows a malicious webpage to bypass localhost isolation and invoke tools or read resources on a victim's locally-running MCP server. Both StreamableHTTPServer and SSEServer accepted loopback connections without validating the Host header, and the SSE transport's permissive default CORS policy removed an additional browser-level barrier. No public exploit has been identified and no CISA KEV listing exists, but the attack is practical for any developer running an affected server while browsing the web.

Unsalted MD5 password hashing in FrontAccounting through 2.4.20 renders every stored credential recoverable in minutes if the database is compromised. All authentication-related code paths - user creation, password updates, self-service password change, forgotten-password reset, and login verification - use raw md5() with no per-user salt, so identical passwords produce identical digests and the entire user table can be cracked en masse with rainbow tables or GPU-accelerated tools. No active exploitation (CISA KEV) has been identified, but the CVSS 4.0 score of 8.2 with VC:H reflects that a single database breach translates directly to full plaintext credential exposure across all accounts.

Persistent session hijacking is possible in Flowintel version 3.3.0 and later because the application fails to invalidate existing authenticated sessions when a user changes their password. An attacker who already holds a valid session token (from prior access or theft) keeps full authenticated access to the account even after the victim resets the password, since the old session remains usable until natural expiry. No public exploit has been identified at time of analysis, and the issue is not in CISA KEV; a vendor fix commit exists.

SQL injection in Toools iSquad's '/ws/apiprensa/getVideoSubcanal' API endpoint lets remote unauthenticated attackers manipulate backend database queries via the unsanitized 'id_video' parameter. Failed injection attempts trigger the Slim framework's default error handler, which discloses internal file paths and full stack traces, compounding the SQLi with an information-disclosure primitive. No public exploit has been identified at time of analysis, but a vendor patch is available via INCIBE advisory INCIBE-CERT.

Unauthenticated sensitive data exposure in the SureFeedback Client Site WordPress plugin (≤1.2.12) permits remote attackers to retrieve subscriber-level confidential data without any credentials. The root cause is CWE-862 (Missing Authorization), meaning the plugin exposes data endpoints that fail to enforce access control checks before returning sensitive subscriber information. No active exploitation has been confirmed and no public exploit code has been identified at time of analysis, but the CVSS:3.1 score of 7.5 with PR:N and AV:N reflects that the attack surface is fully accessible to unauthenticated internet-facing requests.

Arbitrary file read in the Workeera WordPress plugin (before 1.0.6) allows authenticated users with subscriber-level access to exfiltrate sensitive server files, including wp-config.php and authentication secrets. The plugin's candidate profile submission endpoint neither validates which fields a subscriber may populate nor confines file-serving operations to an approved directory, creating a path-traversal-adjacent disclosure path. No active exploitation has been identified (SSVC exploitation: none; EPSS 0.17%), but successful exploitation can fully compromise WordPress credentials and database connection strings, making the effective risk substantially higher than the low EPSS suggests for sites with open subscriber registration.

Arbitrary file deletion in the Workeera WordPress plugin before 1.0.6 lets any authenticated user with a role as low as subscriber remove files anywhere the web server can reach, because the plugin neither restricts which values a user may write to their own candidate profile nor validates/contains the stored file path before deletion. On a typical WordPress host this enables denial of service and, by deleting wp-config.php to force the installer into a fresh setup, potential full site takeover. No active exploitation is recorded (not in CISA KEV) and no public exploit has been identified; EPSS is low at 0.14%.

Path traversal in Spring Cloud Config Server's native environment repository allows unauthenticated remote attackers to read arbitrary files outside the configured search-locations directory on the server filesystem. Affected deployments span four release lines - 3.1.14 and earlier, 4.0.0-4.2.8, 4.3.0-4.3.4, and 5.0.0-5.0.4 - and are limited to the native filesystem backend mode. No public exploit code has been identified and CISA KEV does not list this vulnerability, though the centralized role of Config Server as a secrets store elevates real-world impact beyond the raw EPSS percentile.

Spring WebFlux applications that enable WebSocket connections leak request headers - potentially containing Authorization tokens, session cookies, or API keys - through exception reason messages exposed over the WebSocket channel. All maintained Spring Framework release trains from 5.2.x through 7.0.x are affected, covering the vast majority of actively deployed Spring reactive applications. The vulnerability is classified as information disclosure (CWE-209), and while the CVSS score is 7.5, the EPSS score of 0.14% (4th percentile) indicates very low observed exploitation probability; no public exploit or CISA KEV listing exists at time of analysis.

Cross-response information disclosure and stream corruption affects Spring Framework 6.2.0-6.2.19 and 7.0.0-7.0.8 (both MVC and WebFlux) when applications serve Server-Sent Events (SSE) together with view fragments, letting remote attackers corrupt the event stream and potentially bleed data across responses. No public exploit is identified at time of analysis and CISA has not listed the flaw in KEV; EPSS is low at 0.15% (5th percentile). The vendor-assigned 9.8 rating sits uneasily against the CWE-93 root cause, the 'Information Disclosure' tagging, and the SSVC 'exploitation: none' status, suggesting the paper severity outruns observed real-world risk.

WebFlux applications in Spring Framework running on the Jetty 12 Core reactive adapter omit the SameSite cookie attribute from serialized response cookies, exposing session and authentication cookies to cross-site request contexts. Affected versions span Spring Framework 6.2.0-6.2.19 and 7.0.0-7.0.8, covering a substantial footprint of reactive Java deployments on Jetty 12. The vulnerability carries a vendor CVSS of 7.5 with C:H reflecting potential session-token disclosure; no public exploit code or active exploitation (CISA KEV) has been identified, and EPSS places exploitation probability at 0.14% (4th percentile).

Memory exhaustion in Spring Framework's RSocket server implementation allows unauthenticated remote attackers to crash or degrade affected applications by sending malformed SETUP frames that trigger unreclaimed heap allocations. All actively maintained Spring Framework branches are affected - 5.2.x through 7.0.x - with the condition that the application must explicitly expose an RSocket endpoint. No public exploit code has been identified at time of analysis, and CISA SSVC confirms no current exploitation activity, though the attack is classified as automatable.

Spring Data REST fails to protect entity identifier (@Id) and optimistic-locking version (@Version) fields from mutation through RFC 6902 JSON Patch (application/json-patch+json) PATCH requests, allowing authenticated low-privilege network attackers to overwrite primary keys and version counters on exposed JPA entities. Affected versions span the full 3.x lineage through 5.1.0, representing a broad swath of the Spring ecosystem. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.

Unauthenticated access to a publicly reachable debug log file in the WP OAuth Server (Login with WordPress) WordPress plugin before 6.3.1 exposes sensitive credential material to any network attacker. When debug logging is enabled, the plugin writes OAuth tokens, authorization codes, and full user records including bcrypt password hashes to a fixed, predictable filesystem path that is served without access restriction. No public exploit has been identified at time of analysis, though the attack is fully automatable per SSVC assessment and requires no authentication.

go-wind-cms (GoWind) before 1.0.0 exposes all administrative APIs to any authenticated user because NewAuthorizer() returns a no-operation authorization engine (noop.State{}), rendering the authz middleware completely inert. Any account holder - regardless of assigned role or tenant membership - can invoke privileged operations including user deletion, password resets, and tenant creation. A publicly available proof-of-concept exploit exists; no confirmed active exploitation (CISA KEV) has been identified at time of analysis.

Information disclosure and in-app arbitrary code execution affect the EcoOnline EHS Android application (package com.airsweb.v10) version 0.2.499, where an improperly protected/exported AndroidManifest.xml component (a public PoC names it a DeepLink issue) lets a remote attacker access sensitive data and run code within the app's context. The MITRE-assigned record carries a CVSS of 9.8 and CWE-200, but EPSS is low (0.31%, 23rd percentile) and there is no CISA KEV listing. Publicly available exploit code exists (GitHub 'CVE-2026-26897-EcoOnline-DeepLink'), though this is not evidence of active exploitation.