Information Disclosure

In the Linux kernel, the following vulnerability has been resolved: Input: synaptics-rmi4 - propagate F54 worker errors to V4L2 queue Previously, rmi_f54_buffer_queue() waited for the worker thread to finish but ignored whether it succeeded. If the worker failed (e.g., due to a timeout or register read failure), the queue thread would silently return success, delivering stale or uninitialized memory to userspace. Add a 'report_error' field to struct f54_data to store the worker's exit status. Check this field in rmi_f54_buffer_queue() after the worker finishes, and mark the buffer as VB2_BUF_STATE_ERROR if an error occurred.

In the Linux kernel, the following vulnerability has been resolved: Input: hynitron_cstxxx - validate touch count and finger IDs The driver allocates max_touch_num input slots, which are indexed from zero through max_touch_num - 1. The current check allows a finger ID equal to max_touch_num to reach cst3xx_report_contact(). While the input core ignores out-of-range slot indices, reporting touch data without a valid slot change corrupts the touch state of the previously active slot. The touch count is read from the controller's report and is used to index the fixed-size report buffer without first checking its range. Reject counts larger than the supported number of touch slots before checking the trailing byte or parsing touch data. Reject finger IDs equal to or greater than max_touch_num, and return immediately when an invalid finger ID is encountered so that corrupt touch frames are discarded instead of reporting partial contact state. The V821 Avaota F1 board configures the vendor driver with one touch slot, so finger ID 1 is already invalid on that device.

In the Linux kernel, the following vulnerability has been resolved: gpio: sloppy-logic-analyzer: fix use-after-free via debugfs trigger on unbind The "trigger" debugfs file has a hand-rolled ->write handler (trigger_write()) that dereferences the per-device gpio_la_poll_priv. The file is created with debugfs_create_file_unsafe(), and the handler never takes a debugfs reference. Nothing keeps the object alive while the handler runs. priv is allocated with devm_kzalloc(). devres frees it when the platform device is unbound. debugfs_create_file_unsafe() installs no full_proxy wrapper, so debugfs_remove_recursive() in gpio_la_poll_remove() does not wait for an in-flight trigger_write(). The blob_lock taken there does not help, because trigger_write() never takes it. A write that races an unbind therefore writes into freed memory: trigger_write() gpio_la_poll_remove() priv = m->private buf = memdup_user() [may sleep] mutex_lock(&priv->blob_lock) debugfs_remove_recursive() [no wait] mutex_unlock(&priv->blob_lock) (remove returns; devres frees priv) priv->trig_data = buf <-- use-after-free write priv->trig_len = count The race is reachable by root via /sys/bus/platform/drivers/gpio-sloppy-logic-analyzer/unbind. Create "trigger" with debugfs_create_file() instead. Its full_proxy wrapper makes debugfs_remove_recursive() drain any in-flight ->write before it returns. The use-after-free is confirmed under KASAN with a minimal reproducer of the same debugfs_create_file_unsafe() plus devm_kzalloc() pattern (available on request); it produces a slab-use-after-free write in the handler.

In the Linux kernel, the following vulnerability has been resolved: gpio: ml-ioh: use raw_spinlock_t for the register lock ioh_irq_type() is registered as the irq_chip .irq_set_type callback and takes chip->spinlock with spin_lock_irqsave(). This callback is reached from __setup_irq() -> __irq_set_trigger() -> chip->irq_set_type() while the caller holds desc->lock, a raw_spinlock_t, with hardirqs disabled. That context is not sleepable, but on PREEMPT_RT a regular spinlock_t is an rtmutex-backed sleeping lock, so acquiring it there is invalid. ioh_irq_enable() and ioh_irq_disable() take the same lock from the .irq_enable/.irq_disable callbacks, which are likewise invoked with desc->lock held. Convert the register lock to raw_spinlock_t. The same lock also serializes the GPIO direction/value callbacks and the suspend/resume register save/restore, and those critical sections only perform short sequences of MMIO register accesses (ioread32()/iowrite32()); the .irq_set_type callback additionally emits a dev_warn() on an unsupported type. None of these are sleepable operations, so keeping this register lock non-sleeping is appropriate for the irqchip callbacks and does not change the GPIO-side locking contract. This is the same fix as commit a02b8950d619 ("gpio: pch: use raw_spinlock_t for the register lock"); this driver shares the same structure as gpio-pch.

In the Linux kernel, the following vulnerability has been resolved: s390/zcrypt: Pad trailing CCA or EP11 message with zeros The both functions xcrb_msg_to_type6cprb_msgx() and xcrb_msg_to_type6_ep11cprb_msgx() copy the user space message into a kernel buffer based on the message length. But on further processing the message is supposed to be 4 byte length adjusted. Thus up to 3 bytes of uninitialized kernel memory are forwarded to further processing steps and may unwanted expose kernel memory to the crypto card firmware. This patch contains code to pad the gap between user space copied message and message buffer length sent down to further processing of the CCA or EP11 message to zeros.

In the Linux kernel, the following vulnerability has been resolved: drm/amdgpu: disallow multiple FENCE chunks in one submit amdgpu_cs_pass1() dispatches on chunk_id once per chunk without rejecting repeated ids. p->uf_bo is a single-slot field, so a submission carrying two AMDGPU_CHUNK_ID_FENCE chunks runs amdgpu_cs_p1_user_fence() twice, and the second run overwrites p->uf_bo with a freshly referenced BO without dropping the reference taken by the first. amdgpu_cs_parser_fini() only unrefs the final p->uf_bo, so every FENCE chunk but the last leaks a BO reference. The leaked BO outlives handle close and process exit. Reject duplicate FENCE chunks the same way commit fec5f8e8c6bc ("drm/amdgpu: disallow multiple BO_HANDLES chunks in one submit") did for p->bo_list. (cherry picked from commit 665b1fc2a1845206408f9a2c6da67101789edb82)

In the Linux kernel, the following vulnerability has been resolved: xfs: don't double-lock when deleting a self-referential directory LOLLM notices that the dirtree scrubber can detect a directory that refers to itself. In this case, it's not correct for the directory tree repair code to try to iolock/ilock both sc->ip and dp, because they're the same inode. Fix this by detecting that corner case and handling it appropriately.

In the Linux kernel, the following vulnerability has been resolved: xfs: fix ilock leak on error in xfs_dq_get_next_id xfs_dq_get_next_id() takes the quota inode ILOCK before calling xfs_iread_extents(). If xfs_iread_extents() fails, the function returns immediately without releasing the lock, leaking the quota inode ILOCK. This can leave the quota inode locked and cause subsequent quota operations to hang. Fix this by jumping to a common unlock path on error instead of returning directly.

In the Linux kernel, the following vulnerability has been resolved: xfs: don't walk off the end of a null sc->sa.agi_bp in AGI repair LOLLM noticed a longstanding bug where xrep_iunlink_walk_ondisk_bucket tries to walk ragi->sc->sa.agi_bp to rebuild the unlinked inode lists. Unfortunately, it's possible for agi_bp to be null if the buffer verifier fails, so we have to use ragi->agi_bp (which skips verifier checks) instead.

In the Linux kernel, the following vulnerability has been resolved: xfs: don't swallow dquot recovery verification errors xlog_recover_dquot_commit_pass2() validates the recovered dquot with xfs_dqblk_verify() and, on failure, sets error = -EFSCORRUPTED and jumps to out_release. But out_release unconditionally returns 0, so the corruption error is discarded: the caller xlog_recover_items_pass2() sees success, log recovery proceeds as if the dquot were valid, and the corrupt quota buffer can be written back to disk.

In the Linux kernel, the following vulnerability has been resolved: optee: ffa: Add NULL check in optee_ffa_lend_protmem Sashiko (locally) reports a possible null dereference under memory pressure due to the lack of validation of the allocated pointer. Fix that by adding the missing check.

In the Linux kernel, the following vulnerability has been resolved: scsi: core: pair EH runtime PM get and put shost->eh_noresume is currently consulted twice in one error handling iteration: once before scsi_autopm_get_host() and once again before scsi_autopm_put_host(). That is racy when a PM-triggered error path flips shost->eh_noresume while the SCSI EH thread is still running. The problem flow looks like this: PM path ufshcd_set_dev_pwr_mode() shost->eh_noresume = 1 ufshcd_execute_start_stop <-- trigger EH ... shost->eh_noresume = 0 EH path scsi_error_handler() if (!shost->eh_noresume) scsi_autopm_get_host() <-- skipped ... if (!shost->eh_noresume) scsi_autopm_put_host() <-- executed later In that case one EH iteration can skip autoresume on entry and still drop a runtime PM reference on exit. That leaves an unmatched runtime PM put and can trigger a runtime PM usage count underflow. Fix this by making eh_noresume a regular bool so it can be accessed with READ_ONCE() and WRITE_ONCE(). Snapshot it once per EH iteration and use that snapshot for both runtime PM get and put decisions.

In the Linux kernel, the following vulnerability has been resolved: rseq: Prevent hard lockup on granted time slice extension __exit_to_user_mode_loop() invokes rseq_grant_timeslice_extension() with interrupts enabled. If the extension is granted it invokes hrtimer_rearm_deferred_tif() to ensure that a pending deferred hrtimer rearm is handled before exiting to user space. Though this invokes __hrtimer_rearm_deferred() which expects to be invoked with interrupts disabled as it takes hrtimer_cpu_base::lock with raw_spin_lock(). That's a livelock waiting to happen and caught by lockdep: WARNING: ./include/linux/hrtimer_rearm.h:17 at irqentry_exit, CPU#1: slice_test WARNING: inconsistent lock state inconsistent {IN-HARDIRQ-W} -> {HARDIRQ-ON-W} usage. Prevent this by disabling interrupts around the invocation of hrtimer_rearm_deferred_tif() in rseq_grant_timeslice_extension(). [ tglx: Massaged change log ]

In the Linux kernel, the following vulnerability has been resolved: net/sched: act_api: fix TOCTOU NULL deref on a->goto_chain tcf_action_exec() handles TC_ACT_GOTO_CHAIN by first checking rcu_access_pointer(a->goto_chain) and then calling tcf_action_goto_chain_exec(), which does a second, independent rcu_dereference_bh(a->goto_chain) read and immediately dereferences chain->filter_chain. A concurrent tcf_action_set_ctrlact() (e.g. the gact replace path) can clear a->goto_chain between the two reads, so the second read returns NULL and tcf_action_goto_chain_exec() dereferences NULL. Fix the race by doing a single rcu_dereference_bh() read of a->goto_chain in tcf_action_exec(), checking it once for NULL, and passing the resulting chain pointer into tcf_action_goto_chain_exec(). This turns the split check/use into a single check/use on one value.

In the Linux kernel, the following vulnerability has been resolved: regmap: sdw-mbq: don't call an unset readable_reg callback regmap_sdw_mbq_poll_busy() decides whether to poll the Function Busy bit by calling ctx->readable_reg(), which is a straight copy of config->readable_reg. That callback is optional: regmap_readable() treats a NULL ->readable_reg as "every register is readable", and drivers rely on that. es9356 and tac5xx2-sdw both build an MBQ regmap without one. Since commit ca1b11b36d82 ("regmap: sdw-mbq: Allow defers on undeferrable controls") the poll runs on every -ENODATA, not only for Controls the driver marked deferrable, so any of those devices answering COMMAND_IGNORED takes the kernel through a NULL function pointer. Treat a missing callback the way the rest of regmap does and poll.

In the Linux kernel, the following vulnerability has been resolved: l2tp: fix tunnel and session refcount leak on seq_file release In pppol2tp_proc_open() and l2tp_dfs_seq_open(), iteration state (pd->tunnel and pd->session) is kept in seq_file private data to allow iteration across multiple read() system calls. However, if userspace closes /proc/net/pppol2tp or /sys/kernel/debug/l2tp/tunnels before reading to end-of-file (EOF), any tunnel or session reference stored in pd->tunnel / pd->session is left un-dropped when seq_file private data is freed. Fix this by dropping any remaining pd->tunnel and pd->session references in pppol2tp_proc_release() and l2tp_dfs_seq_release() when closing the file.

SSH host key verification is persistently disabled in Siemens kas versions prior to 5.4 when the tool's internal SSH key setup path is triggered via SSH_PRIVATE_KEY or SSH_PRIVATE_KEY_FILE and the invoking user has no pre-existing ~/.ssh/config. The tool writes a global Host * rule with StrictHostKeyChecking no to ~/.ssh/config and does not remove it upon exit, leaving all subsequent SSH sessions of that local user silently accepting unverified host keys. No public exploit code exists and this vulnerability is not listed in CISA KEV; the low CVSS score of 3.3 correctly reflects a constrained local, multi-condition attack path, though the persistence of the misconfiguration indefinitely extends the exposure window beyond any single kas invocation.

Starlette-Admin, the Python ASGI-based administrative UI framework, fails to validate sort and filter parameters against configured field allowlists on its backend API, allowing any authenticated user to bypass the frontend field restrictions and query hidden or non-sortable columns as an information-disclosure oracle. Additionally, passing special Python attribute names such as `__class__` or `metadata` as field values triggers unhandled exceptions that return HTTP 500 responses, creating a limited denial-of-service condition against targeted list endpoints. All versions prior to 0.16.1 are affected; no public exploit code has been identified and this vulnerability is not in CISA KEV.

Out-of-bounds read and in-object write in the Zephyr RTOS IEEE 1588 PTP stack affects all Zephyr versions with CONFIG_PTP enabled, exploitable by any unauthenticated attacker with Layer 2 adjacency. The PTP_MGMT_TIME management-id case in tlv_mgmt_post_recv() omits the length guard present for every sibling case, allowing a crafted short TLV to drive an 8-byte over-read and bounded write-back within the same struct ptp_msg allocation. No public exploit has been identified at time of analysis, and impact is constrained to minor adjacent-memory disclosure and corruption of the device's parsed management timestamp - no crash or past-allocation corruption is reachable.

Out-of-bounds read in Zephyr RTOS's LoRaWAN clock synchronization service allows a malicious or compromised LoRaWAN application server to corrupt the target device's internal time offset by sending a crafted short AppTimeAns frame. The over-read is bounded by a 255-byte static backing buffer so no crash occurs, and the stray bytes are never transmitted back to the attacker, eliminating any information disclosure. Impact is confined to a minor, device-local clock integrity issue - the device's time estimate may silently diverge if a garbage time-correction value happens to match the pending token. No public exploit identified at time of analysis, and no CISA KEV listing.

Improper authorization in GitLab Enterprise Edition allows an authenticated project Maintainer to access the interactive terminal of a protected environment they are explicitly excluded from, bypassing environment-level access controls enforced separately from project roles. Affected versions span a wide range - all EE releases from 11.3 through 19.3.0 - meaning the exposure window is substantial across the enterprise install base. A publicly available exploit exists via a disclosed HackerOne report; no active exploitation (CISA KEV) has been confirmed at time of analysis.

Improper authorization in GitLab Enterprise Edition allows an authenticated reporter-level user who authored a merge request to reset that MR's approval rules, potentially bypassing mandatory code-review controls enforced by administrators. All GitLab EE versions from 13.1 through 19.3.0 are affected, with remediated releases published. A publicly available exploit exists via HackerOne, though the vulnerability is not listed in CISA KEV and the low CVSS score (3.5) reflects the constrained attack conditions requiring authentication and prior MR authorship.

Improper job dependency handling in GitLab Enterprise Edition's Pipeline Execution Policy enforcement allows an authenticated developer-role user to influence the execution environment of policy enforcement jobs. Affected versions span the 19.1, 19.2, and 19.3 release trains prior to their respective patches. While CVSS rates this a moderate 4.3, a publicly available exploit exists via HackerOne, and the security significance is elevated because Pipeline Execution Policies are a deliberate administrative security control - undermining their enforcement environment erodes a defense-in-depth layer in CI/CD pipelines. No active exploitation has been confirmed (not in CISA KEV).

Missing authentication on a specific API endpoint in CAYIN CMS-WS and CMS-SE allows unauthenticated remote attackers to retrieve media file lists, resulting in partial information disclosure. All versions of both products are affected per CPE data, and the vulnerability requires no credentials, no user interaction, and no special network position - only HTTP reachability to the CMS instance. No public exploit code or CISA KEV listing has been identified at time of analysis, and the confidentiality impact is limited to media asset enumeration rather than credential or configuration exposure.

Kids Mode on Vivo devices exposes local gallery photos through a control logic defect in a specific built-in webpage, bypassing the sandboxed environment's access restrictions. All versions of Vivo Kids Mode are affected per the wildcard CPE (cpe:2.3:a:vivo:kids_mode:*:*:*:*:*:*:*:*). Exploitation requires physical access to the device; no public exploit code and no CISA KEV listing exist at time of analysis.

Simple Newsletter Plugin for WordPress (versions 4.0.0 through 4.3.2) fails to verify that a public requester matches the subscriber whose record is being fetched, exposing stored personal data and the authorization key that controls changes to that subscriber's record to any unauthenticated caller. A publicly available proof-of-concept documented by WPScan demonstrates the attack path, though EPSS at 0.18% (7th percentile) suggests exploitation has remained limited in observed telemetry. Vendor-released patch version 4.3.3 is available and should be applied immediately given the zero-complexity, unauthenticated exploit path.

Stripe Payment Forms by WP Full Pay plugin for WordPress (all versions before 8.5.1) exposes customer subscription and billing data to unauthenticated network attackers due to a missing session-confirmation check in the customer portal workflow. The plugin returns sensitive financial records before verifying that a portal session has completed its confirmation step, enabling any unauthenticated user to read billing information belonging to a different customer. A publicly available exploit exists per WPScan intelligence, though EPSS sits at 0.18% (7th percentile), indicating limited observed exploitation despite the low-barrier attack path.

Kirki WordPress Customizer Framework plugin before 6.0.14 exposes registered user email addresses, comment author emails, non-public page content, and site settings to unauthenticated remote attackers via missing capability checks on public AJAX action endpoints. Every WordPress site running any Kirki version prior to 6.0.14 is affected regardless of configuration. A publicly available proof-of-concept exists per WPScan reporting; exploitation probability is currently low (EPSS 0.18%, 7th percentile) and no active exploitation is confirmed in CISA KEV, though the data harvested enables downstream phishing and credential-stuffing campaigns.

Improper authorization in Myna Point's Android Intent handler allows a co-installed malicious application to invoke the app's custom URL scheme handler without caller validation, triggering arbitrary JavaScript execution within the app's WebView context. All versions of the Japanese government digital identity application (Digital Agency, CPE wildcard) appear affected per JVN advisory JVN67155805. No public exploit identified at time of analysis, though the attack surface is inherently local and requires a malicious app on the same device.

Information disclosure in the OpenRISC OR1200 processor soft-core (commit 83ac6b) arises from a mismatch between the RTL source and the synthesized netlist, meaning the fabricated/synthesized hardware behaves differently than the verified design and can leak confidential state or misbehave. The flaw was surfaced by the academic SynFuzz RTL-vs-netlist fuzzing research (arXiv:2504.18812) rather than by field exploitation; no public exploit identified at time of analysis and EPSS is low (0.15%, 5th percentile). The NVD CVSS of 9.1 (C:H/A:H) is far more alarming than the vague one-line description supports, so the score should be treated skeptically.

Unauthenticated information disclosure in Cohere North AI v1.1.5 exposes sensitive data through an improperly secured WebSocket endpoint. The CVSS vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N) confirms high confidentiality impact accessible without credentials or user interaction over a network. No public exploit has been identified at time of analysis, and the EPSS score of 0.14% at the 4th percentile indicates negligible observed exploitation activity across the threat landscape.

Sensitive-data exposure in Cohere North AI v1.1.5 stems from the server accepting cross-origin requests without validating the Origin header, letting any untrusted website read authenticated API responses in a victim's browser. Affects the North enterprise AI platform; tagged as CORS misconfiguration / information disclosure. No public exploit or active exploitation is identified, and EPSS is low (0.14%, 4th percentile), though the NVD-published CVSS of 9.8 likely overstates real-world impact.

Man-in-the-middle interception in CTFd v3.7.6, a widely-used Capture The Flag competition platform, exposes high-confidentiality data to adjacent-network attackers with no authentication required. Rooted in CWE-300 (Channel Accessible by Non-Endpoint), the flaw allows an attacker sharing the same network segment to intercept communications, capturing sensitive data such as session tokens or credentials, with limited integrity modification also possible. No active exploitation is confirmed - EPSS sits at 0.15% (4th percentile) and no CISA KEV listing exists - but the attack surface is acutely relevant in live CTF event environments where competitors and organizers routinely share the same LAN or Wi-Fi.

Timing oracle in Kimai's TokenAuthenticator (all 2.x versions before 2.54.0) allows unauthenticated network attackers to enumerate valid usernames by measuring a consistent ~25ms response time differential - argon2id password hashing executes only when a matched user record exists, leaking username validity despite identical HTTP 403 response bodies. No authentication, API token, or session cookie is required to exploit this flaw against default Kimai deployments. A fully functional proof-of-concept Python script is publicly available in the GitHub Security Advisory (GHSA-jrc6-fmhw-fpq2), making this a low-barrier reconnaissance primitive for follow-on credential attacks; no confirmed active exploitation (CISA KEV) has been recorded at time of analysis.

Improper input validation in the Drupal contributed module Email Login OTP (all released versions) exposes sites to high confidentiality and integrity impacts under specific conditions involving high-privilege access and user interaction. The vulnerability, tracked under CWE-20, could allow a privileged actor to manipulate OTP-related input handling in ways that compromise authentication integrity or expose sensitive login-flow data. No active exploitation has been confirmed (EPSS 0.14%, 4th percentile; SSVC exploitation status: none), and the Drupal security team has published advisory SA-CONTRIB-2026-085 addressing the issue.

Improper input validation in the Drupal Lunr Exposed Filters contributed module (all versions) can yield high confidentiality and integrity impact under a restrictive set of preconditions. The CVSS vector (AV:N/AC:H/PR:H/UI:R) constrains exploitation to attackers already holding high-privilege Drupal access who can also induce user interaction, making opportunistic or mass exploitation implausible. No public exploit code exists and EPSS sits at 0.14% (4th percentile), consistent with no observed exploitation pressure at time of analysis.

Improper input validation in the Drupal Development Environment contributed module (all versions, CPE cpe:2.3:a:drupal:development_environment) allows a highly privileged, authenticated network attacker - with user interaction - to compromise both confidentiality and integrity of the affected system. The CVSS vector (AV:N/AC:H/PR:H/UI:R) constrains real-world impact significantly: exploitation requires administrative credentials, a complex attack scenario, and victim interaction. EPSS stands at 0.14% (4th percentile), no public exploit code has been identified, and no CISA KEV listing exists at time of analysis.

Improper input validation in the Drupal 'Disable Login Page' contrib module (all versions) enables a network-delivered attack that can achieve high confidentiality and integrity compromise within a Drupal site. Exploitation is substantially constrained by the requirement for high-privilege (administrator-level) access, high attack complexity, and mandatory user interaction - making this a meaningful internal-threat or privilege-abuse scenario rather than an opportunistic remote attack. No public exploit code has been identified and no CISA KEV listing exists; the EPSS score of 0.14% (4th percentile) confirms negligible observed exploitation activity at time of analysis.

Improper input validation in the Powerful Surveys contributed module for Drupal exposes all published versions to confidentiality and integrity compromise under a constrained set of conditions requiring high privileges and user interaction. The flaw, classified under CWE-20, allows a high-privileged authenticated attacker - under high-complexity conditions with mandatory user interaction - to bypass input validation controls and potentially disclose or manipulate survey data. No public exploit exists and EPSS stands at 0.14% (4th percentile), indicating negligible observed exploitation pressure despite the High C and I impact ratings.

Insufficient session expiration in Apache Tomcat allows an authenticated attacker to maintain an active WebSocket connection after the underlying HTTP session has been invalidated, violating the Jakarta WebSocket specification's requirement that WebSocket sessions close when their parent HTTP session ends. Affected are all supported branches from 9.0.0.M1 through 9.0.120, 10.1.0-M1 through 10.1.57, and 11.0.0-M1 through 11.0.24, plus EOL branches 7.0.43-7.0.109 and 8.5.0-8.5.100. No public exploit or CISA KEV listing has been identified at time of analysis, and the low EPSS score (0.28%, 19th percentile) reflects limited real-world exploitation probability.

Port forwarding in GitHub CLI versions 2.28.0 through 2.97.0 binds its local TCP listener to all network interfaces (0.0.0.0) rather than loopback only, exposing forwarded Codespace services to any adjacent host that can route to the user's machine while `gh codespace ports forward` is active. Developers using this command on shared or untrusted networks - corporate Wi-Fi, conference networks, co-working LAN segments - may unintentionally expose Codespace services that were intended to remain private. The vulnerability is fixed in v2.98.0 per advisory GHSA-vfhh-p7hm-pxfh; no public exploit code and no CISA KEV listing have been identified at time of analysis.

Heap out-of-bounds read in GIMP's file-xwd plugin allows a crafted XWD image file to trigger an application crash or leak partial heap memory contents into the rendered image output. Users running GIMP on Red Hat Enterprise Linux 6 through 9 are affected when they open a malicious XWD file; the plugin fails to cross-validate image width and bytes-per-line parameters against the allocated buffer size, permitting an out-of-bounds read. No public exploit is identified at time of analysis and the vulnerability is not listed in CISA KEV, placing real-world urgency in the low-to-moderate range.

CPU exhaustion in libsoup's HTTP Range header processing affects any SoupServer deployment carrying the CVE-2025-32907 fix but not MR !550. Supplying a Range header with approximately 25,000 repeated satisfiable byte ranges triggers an O(N²) coalescing loop - each g_array_remove_index() call induces an O(N) memmove on GArray - blocking the server's event loop for roughly 90 ms per request from a single unauthenticated client. The description explicitly rules out memory corruption and information disclosure; this is a pure availability issue with no public exploit identified at time of analysis.

Sensitive information disclosure in NVIDIA NemoClaw arises from process invocation that exposes secrets - such as API keys or authentication tokens - through visible command-line arguments or environment variables, observable by other local users via standard tools like `ps`. All versions are affected per the wildcard CPE (`cpe:2.3:a:nvidia:nemoclaw:*:*:*:*:*:*:*:*`), and exploitation requires only a low-privileged local account on the same system. No active exploitation has been confirmed (not in CISA KEV), and no public proof-of-concept exploit code has been identified at time of analysis.

Credential exposure in NVIDIA NemoClaw allows a local low-privileged user, upon triggering user interaction, to access insufficiently protected credential material stored or accessible within the application's runtime context. The CVSS 5.6 Medium score reflects the constrained local attack vector (AV:L), but the high confidentiality impact (C:H) indicates that successfully harvested credentials could enable meaningful lateral movement or downstream access beyond the initial system. No public exploit code has been identified and no CISA KEV listing exists at time of analysis.

OS command injection in NVIDIA OpenShell for Linux's sandbox exec handler allows a low-privileged, network-accessible attacker to inject and execute arbitrary OS commands outside the intended sandbox boundary. All versions are affected per CPE data (cpe:2.3:a:nvidia:openshell:*:*:*:*:*:*:*:*), with confirmed potential impact spanning code execution, information disclosure, and data tampering. No public exploit code has been identified and the vulnerability is not listed in the CISA KEV catalog at time of analysis.

Improper output encoding in NVIDIA OpenShell's inference proxy on Linux allows a local low-privileged attacker to cause information disclosure and data tampering across component boundaries. The CVSS scope-change flag (S:C) indicates impact extending beyond the vulnerable component itself, suggesting the inference proxy mediates data between trust zones. No public exploit code exists and this vulnerability has not been confirmed in CISA KEV, but the scope change elevates practical risk above the 5.2 base score suggests.

Skia, the 2D graphics rendering library embedded in Google Chrome's renderer process, contains an uninitialized resource flaw that allows remote attackers to read stale sandbox memory contents by inducing a victim to visit a crafted HTML page. All Chrome versions prior to 152.0.7977.65 are affected across desktop platforms, with confidentiality impact confined to the renderer sandbox. The EPSS score of 0.19% (9th percentile) and absence from CISA KEV reflect low observed exploitation pressure, though such memory-read primitives are classically useful as components in multi-stage exploit chains targeting browser memory.

Sensitive information disclosure in Google Chrome on Windows prior to 152.0.7977.65 exposes confidential browser or system data to remote attackers who trick users into visiting a crafted HTML page. The root cause is improper input validation in Chrome's Network component (CWE-20), enabling a network-accessible attacker to exploit the flaw without privileges, though social engineering is required to achieve user interaction. No public exploit code or CISA KEV listing is confirmed, and the EPSS score of 0.17% (7th percentile) reflects low current exploitation probability despite the High confidentiality impact in the CVSS rating.

Proxy functionality in Google Chrome on Windows prior to 152.0.7977.65 incorrectly implements specified behavior, enabling an adjacent-network attacker to intercept or infer sensitive information by sending crafted network traffic. The flaw is Windows-platform-specific and is classified by the Chromium security team as Low severity, consistent with the high attack complexity and adjacency requirement that constrain realistic exploitation. No public exploit code or active exploitation has been identified at time of analysis; EPSS probability is 0.13%, placing this in the 3rd percentile of exploitability.

Information disclosure in Google Chrome's Mobile component on iOS (all versions prior to 152.0.7977.65) allows a local attacker to read sensitive information by inducing the user to open a crafted file. Exploitation requires physical or logical local access to the device and user interaction, limiting the practical attack surface significantly. No public exploit code has been identified at time of analysis, and CISA SSVC rates exploitation as none with only partial technical impact.

Information disclosure in Google Chrome's Mobile component on iOS exposes sensitive data to local attackers operating via a local program, affecting all Chrome for iOS versions prior to 152.0.7977.65. The vulnerability is classified CWE-200 (Exposure of Sensitive Information) and carries a Chromium internal severity of Low, which aligns with SSVC's assessment of partial technical impact and non-automatable exploitation. No public exploit code exists and no active exploitation has been confirmed; the EPSS score of 0.18% (7th percentile) reflects minimal real-world exploitation pressure.

The Passwords (built-in credential manager) component of Google Chrome on iOS prior to version 152.0.7977.65 leaks sensitive password data to a local attacker who can supply a crafted file, enabling unauthorized retrieval of stored credentials. Only the iOS platform is affected, and the Chromium security team rates this as Low severity internally. No public exploit code exists and EPSS stands at 0.11% (1st percentile), indicating very low near-term exploitation likelihood despite the high confidentiality impact of the exposed data.

Information leak in Google Chrome's XR (WebXR) subsystem allows unauthenticated remote attackers to obtain sensitive browser-context information when a victim visits a crafted HTML page. All Chrome desktop versions prior to 152.0.7977.65 are affected, with the vendor classifying severity as Low internally despite a CVSS 3.1 base score of 6.5 driven by high confidentiality impact. No public exploit has been identified and EPSS exploitation probability is very low at 0.17% (7th percentile), suggesting real-world risk remains limited; however, the zero-friction delivery vector - a single malicious page visit - warrants prompt patching given Chrome's ubiquitous deployment.

Information disclosure via Chrome's DataTransfer API in versions prior to 152.0.7977.65 allows remote attackers to obtain sensitive information when a victim visits and interacts with a crafted HTML page. Chromium's own Low severity classification creates a notable tension with the CVSS C:H rating, likely indicating that the scope of leaked data is constrained despite the high confidentiality label. No public exploit code or active exploitation has been confirmed; EPSS at 0.21% (11th percentile) places this firmly in the routine patching category.

Out-of-bounds read in Chrome's Skia graphics library exposes sandbox memory to attackers who have already compromised the renderer process. Exploitation requires a prior renderer compromise plus user interaction with a crafted HTML page, making this a chained second-stage information disclosure rather than a standalone critical flaw. Chromium's own severity rating is Low; no public exploit or CISA KEV listing exists, and EPSS sits at just 0.17%.

Cross-origin information leakage in the FoldableAPIs component of Google Chrome prior to 152.0.7977.65 enables a remote attacker to read sensitive device-geometry data from foldable-form-factor devices by luring a user to a crafted HTML page. The affected API fails to enforce origin isolation, exposing data that should be inaccessible to untrusted cross-origin scripts. No public exploit has been identified and SSVC rates exploitation status as none; Chromium's own internal severity classification of 'Low' contrasts with the NVD-assigned 6.5 Medium, reflecting the bounded real-world impact.

Out-of-bounds memory read in Chrome's Tint graphics library on Android exposes sandbox-contained memory to remote attackers. Google Chrome for Android prior to 152.0.7977.65 is affected; an attacker who lures a user to a crafted HTML page can trigger the flaw and read arbitrary memory within the Chrome sandbox. No active exploitation has been identified - Chromium's own security team rates this as Low severity, consistent with the 0.17% EPSS score and the absence of a CISA KEV listing.

UI spoofing in Google Chrome prior to 152.0.7977.65 allows unauthenticated remote attackers to misrepresent browser interface elements through a crafted HTML page, requiring only that a user visit the malicious content. Classified as CWE-451 (UI Misrepresentation of Critical Information), the flaw breaks the trust contract between the browser and user by rendering deceptive interface states - a classic phishing-enabler primitive. No public exploit code has been identified and EPSS stands at 0.22% (12th percentile), consistent with Chromium's own Low severity rating; real-world exploitation impact is constrained by its dependence on social engineering and user interaction.

Cross-origin data exposure in Google Chrome's StorageAccessAPI implementation allows a remote attacker to read data across origin boundaries by directing a victim to a specially crafted HTML page. All Chrome desktop releases prior to 152.0.7977.65 are affected across all platforms. No public exploit code has been identified and CISA SSVC classifies current exploitation status as none, consistent with the Chromium team's own Low severity rating.

UI spoofing in Google Chrome on macOS prior to 152.0.7977.65 enables a remote attacker who has already compromised the renderer process to forge browser UI elements via a crafted HTML page, potentially deceiving users into believing they are interacting with a trusted interface. The vulnerability is macOS-specific and requires renderer process compromise as an explicit prerequisite, significantly limiting its standalone exploitability. No public exploit code or active exploitation (CISA KEV) has been identified; an EPSS score of 0.21% (11th percentile) reflects negligible likelihood of independent exploitation.

Memory disclosure via uninitialized GPU resource in Google Chrome on Android (prior to 152.0.7977.65) allows a remote attacker to read memory outside the browser sandbox by directing a user to a crafted HTML page. The CVSS vector (AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N) reflects a low-complexity network attack requiring no privileges but dependent on user interaction. No public exploit code has been identified at time of analysis, and the low EPSS score of 0.31% corroborates a currently low exploitation probability despite Chrome's enormous Android deployment footprint.

Memory disclosure in Google Chrome for Android (prior to 152.0.7977.65) exposes sandbox-contained memory via an uninitialized GPU resource, triggered when a victim loads a crafted HTML page. The flaw is platform-specific to Android and carries confidentiality-only impact bounded by Chrome's GPU sandbox isolation - no integrity or availability exposure. No public exploit code is identified at time of analysis, and EPSS at 0.31% (24th percentile) aligns with the vendor's own 'Low' Chromium severity rating, indicating low near-term exploitation probability.

Address bar spoofing in Google Chrome for Android's CustomTabs feature enables remote unauthenticated attackers to misrepresent the displayed URL to users through a crafted HTML page. All Chrome for Android versions prior to 152.0.7977.65 are affected on the Android platform only; desktop Chrome is not impacted. No public exploit identified at time of analysis, and the EPSS score of 0.17% (7th percentile) combined with Chromium's own 'Low' severity rating reflect limited real-world exploitation probability, though the phishing-enablement potential makes it worth patching promptly.

UI spoofing in Google Chrome's Transactions Platform prior to version 152.0.7977.65 enables remote attackers to misrepresent UI elements - such as payment confirmation dialogs or security indicators - through a crafted HTML page, relying on social engineering for delivery. Classified under CWE-451 (UI Misrepresentation of Critical Information), the flaw requires user interaction and carries no confidentiality or availability impact, confining harm to integrity via deception. No active exploitation is confirmed and EPSS probability is very low (0.29%), but the ubiquitous deployment footprint of Chrome means the absolute population of potential targets is large.

Chrome's PermissionElement component can be visually spoofed via a crafted HTML page, allowing a remote attacker to mislead users into granting browser permissions they did not intend to approve. All Chrome desktop versions prior to 152.0.7977.65 are affected, as confirmed by the vendor's Stable Channel advisory and EUVD-2026-66037. No public exploit code has been identified at time of analysis, and EPSS at 0.17% reflects negligible observed exploitation interest.

Skia, the 2D graphics library embedded in Google Chrome prior to 152.0.7977.65, leaks sensitive information when an attacker who has already compromised the renderer process delivers a crafted HTML page to a victim. This CWE-200 flaw functions as a chaining component in a multi-stage exploit rather than a standalone entry point - it amplifies the impact of a prior renderer compromise rather than providing initial access. No public exploit code exists, EPSS is 0.17% (7th percentile), and Chrome's own severity classification is Low, all consistent with the mandatory pre-condition of a pre-compromised renderer.

Out-of-bounds memory read in Google Chrome's FileSystem component (versions prior to 152.0.7977.65) allows a remote unauthenticated attacker to leak memory contents from outside the browser's renderer sandbox by directing a victim to a specially crafted HTML page via social engineering. Exploitation is contingent on user interaction, limiting opportunistic or automated mass exploitation. No public exploit code exists and EPSS sits at 0.17% (7th percentile), though the Confidentiality impact is rated High, meaning successful exploitation could expose sensitive data from browser memory. Vendor-released patch is available in Chrome 152.0.7977.65.

Observable discrepancy in Chrome's Glic component allows remote information disclosure against users running versions prior to 152.0.7977.65. An attacker who persuades a victim to visit a crafted HTML page can exploit a behavioral or timing side-channel in the Glic AI-integration subsystem to extract sensitive information with high confidentiality impact, despite the medium overall CVSS score. No public exploit identified at time of analysis, and EPSS at 0.17% (7th percentile) indicates very low current exploitation probability.

Race condition in Google Chrome's Editing component prior to version 152.0.7977.65 enables remote attackers who successfully socially engineer a victim to visit a crafted HTML page to extract sensitive information from the browser. The CVSS vector (AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:N/A:N) shows the attack is network-delivered but requires high complexity timing and explicit user interaction, limiting real-world exploitability. No public exploit identified at time of analysis, and the extremely low EPSS score of 0.14% (4th percentile) corroborates the vendor's own Low Chromium severity designation.

Bluetooth information disclosure in Google Chrome on macOS (versions prior to 152.0.7977.65) enables a remote attacker - who has already compromised the renderer process - to extract sensitive Bluetooth-related information by combining a crafted HTML page with social engineering. This is a chained, multi-prerequisite vulnerability: successful exploitation requires a prior renderer compromise and active victim interaction, which the CVSS AC:H rating reflects. No public exploit code exists and no active exploitation has been observed (SSVC: Exploitation none; EPSS 0.29%), placing real-world risk substantially below what the C:H confidentiality impact alone might suggest. A vendor patch is available in Chrome 152.0.7977.65.

Sensitive information exposure in Google Chrome for Android (versions prior to 152.0.7977.65) via the Android Intents mechanism allows a remote attacker to leak confidential browser or device data by delivering a crafted HTML page to the victim. The vulnerability requires user interaction - the target must visit the malicious page - limiting opportunistic mass exploitation despite the network-accessible attack vector. No public exploit code has been identified at time of analysis, and EPSS probability is low at 0.17%, consistent with Chromium's own 'Low' severity classification, though the CVSS C:H rating reflects a meaningful confidentiality impact if triggered.

Chrome's Sharing feature on Android leaks sensitive information to local attackers in all versions prior to 152.0.7977.65, exploitable only when a malicious co-installed app is present on the target device combined with social engineering. Despite a High confidentiality impact in the CVSS vector, the overall score of 5.1 reflects severe practical constraints: local access, high complexity, and a social engineering dependency. No public exploit code has been identified, EPSS probability is 0.15% (4th percentile), and Chromium's own severity rating is Low - signals that align to suggest low near-term operational risk.

DOM information leak in Google Chrome before version 152.0.7977.65 enables remote attackers to bypass the Same-Origin Policy by luring a victim to a crafted HTML page, potentially exposing cross-origin data to the attacker. The CVSS 4.3 Medium score reflects network-exploitable, unauthenticated delivery limited to confidentiality impact with no integrity or availability consequences. No public exploit code has been identified at time of analysis, and an EPSS probability of 0.22% (12th percentile) indicates low near-term exploitation likelihood despite the broad affected product footprint.

Out-of-bounds read in Google Chrome's Media component prior to version 152.0.7977.65 enables a remote attacker who has already compromised the renderer process to leak memory contents across the Chrome sandbox boundary via a crafted HTML page. The attack is a chained, second-stage capability - it requires prior renderer code execution and user interaction - not a standalone entry point. No public exploit has been identified at time of analysis, and the EPSS score of 0.29% (21st percentile) reflects low observed exploitation likelihood.

Uninitialized GPU resource use in Google Chrome prior to 152.0.7977.65 enables an attacker who has already compromised the renderer process to read memory outside the Chrome sandbox boundary via a crafted HTML page. The vulnerability (CWE-908) is a second-stage primitive - it cannot be exploited in isolation and requires a pre-existing renderer process compromise as a hard prerequisite. No public exploit code has been identified and EPSS stands at 0.31%, consistent with its role as a chained exploitation component rather than a primary attack vector.

Cross-origin data exposure in Google Chrome's Extensions subsystem prior to version 152.0.7977.65 allows a remote attacker who successfully socially engineers a victim into installing a crafted malicious extension to read data from web origins the extension should not have access to. The high confidentiality impact (C:H) is real, but exploitation is gated on user interaction - the victim must install the malicious extension - which substantially limits opportunistic mass exploitation. No active exploitation has been confirmed (absent from CISA KEV), and the EPSS score of 0.27% (18th percentile) reflects low current exploitation probability consistent with no observed in-the-wild use.

Information disclosure in Google Chrome's Geolocation component prior to version 152.0.7977.65 allows a remote attacker to obtain the victim's sensitive geolocation data by tricking them into visiting a crafted HTML page. The attack relies on social engineering as the delivery mechanism and results in a high-confidentiality-impact leak of physical location information, which may expose home or workplace addresses. No public exploit code or active exploitation has been identified; EPSS at 0.21% (11th percentile) confirms low automated exploitation probability at time of analysis.

Cross-origin data exposure in Google Chrome before 152.0.7977.65 enables a chained information leak when a renderer process has already been compromised by a separate exploit. Chrome's CORS implementation incorrectly permits cross-origin data access from within a compromised renderer, allowing a remote attacker to exfiltrate data from origins the victim is authenticated to via a crafted HTML page. No public exploit code exists and no CISA KEV listing has been issued; the EPSS score of 0.17% (7th percentile) confirms this is a low-probability, low-severity secondary element of multi-stage browser attack chains rather than a standalone threat.

Memory disclosure in Google Chrome's Dawn WebGPU component exposes uninitialized memory contents to remote attackers who can lure a user to a crafted HTML page. Affected are all Chrome versions prior to 152.0.7977.65 on desktop platforms, per the EUVD and Chrome release advisory. No public exploit code has been identified and EPSS sits at 0.19% (9th percentile), indicating low current exploitation probability despite Chrome's ubiquitous deployment footprint.

Cross-origin data leakage via an uninitialized resource in the WebXR API affects Google Chrome versions prior to 152.0.7977.65. An unauthenticated remote attacker who can socially engineer a user into visiting a crafted HTML page may trigger a read of uninitialized memory, potentially exposing data from other browser origins. Google has rated this Medium severity; a patched release (152.0.7977.65) is available, and no public exploit or active exploitation has been identified at time of analysis.

Cross-origin data exposure via a ServiceWorker flaw in Google Chrome prior to 152.0.7977.65 permits remote attackers to read data from origins they do not control. An attacker can exploit this by delivering a crafted HTML page to a victim user, leveraging Chrome's ServiceWorker API to bypass same-origin isolation and exfiltrate cross-origin responses. No public exploit code is identified at time of analysis, and the EPSS score of 0.17% (7th percentile) reflects low observed exploitation activity; the mandatory user-interaction requirement further constrains automated abuse.

Incomplete cleanup in Chrome's GetUserMedia API exposes sensitive information to remote attackers who have already compromised the renderer process. Affected versions are all Chrome releases prior to 152.0.7977.65 on desktop platforms. An attacker with an established renderer foothold and the ability to socially engineer a user into visiting a crafted HTML page can exploit this residual-data flaw to extract sensitive media or stream-related information - an information-disclosure step that may support privilege escalation or lateral movement within a broader attack chain. No public exploit code has been identified and EPSS sits at 0.23%, reflecting the high prerequisite bar.

Network-layer information disclosure in Google Chrome before 152.0.7977.65 enables a remote attacker who has already compromised the renderer process to exfiltrate sensitive data by directing a victim to a crafted HTML page. The attack is a multi-stage chain: the renderer compromise is a hard prerequisite not satisfied by this CVE alone, which materially constrains real-world exploitability. No public exploit code has been identified and the EPSS score of 0.21% (11th percentile) corroborates low observed exploitation probability; no CISA KEV listing exists.

Improper resource exposure in Google Chrome's StreamsAPI (versions prior to 152.0.7977.65) enables remote attackers to partially bypass the web origin policy and read limited data from privileged browser pages via a crafted HTML page. Exploitation requires user interaction - the victim must visit an attacker-controlled page - consistent with CVSS UI:R and S:U, confining impact to the victim's own browser context. No active exploitation is confirmed (not in CISA KEV), and an EPSS score of 0.18% (8th percentile) indicates very low real-world exploitation probability at time of analysis.

Cross-origin data exfiltration via the BFCache mechanism in Google Chrome prior to 152.0.7977.65 enables an attacker who has already compromised the renderer process to read data across origin boundaries using a crafted HTML page. This information disclosure (CWE-200) is a second-stage capability, not a standalone attack - it requires chaining with a separate renderer RCE vulnerability, constraining real-world risk significantly. No public exploit code or active exploitation has been confirmed; EPSS is 0.17% and the vulnerability is absent from CISA KEV. Vendor patch is available in Chrome 152.0.7977.65.

CSS injection in Google Chrome prior to version 152.0.7977.65 enables a remote attacker to extract sensitive information from a victim's browser session by delivering a crafted HTML page. The CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:N vector confirms unauthenticated network delivery requiring only that the victim navigate to attacker-controlled content, with high confidentiality impact and no integrity or availability consequences. No public exploit has been identified at time of analysis, and the EPSS score of 0.20% at the 10th percentile indicates very low observed exploitation probability; this is not listed in the CISA KEV catalog.

UI misrepresentation in Google Chrome's Geometry rendering component allows remote attackers to spoof browser interface elements by delivering a crafted HTML page to an unaware user. Versions prior to 152.0.7977.65 are affected across all desktop platforms where Chrome is installed. With CVSS 5.4, a low EPSS of 0.17% (7th percentile), and no CISA KEV listing, this is a moderate-severity phishing and social-engineering amplifier rather than a code-execution vector - but Chrome's near-ubiquitous deployment means the aggregate exposure is broad.

CSS information leak in Google Chrome before 152.0.7977.65 enables remote attackers to exfiltrate sensitive browser data by luring victims to a crafted HTML page. The flaw resides in Chrome's CSS rendering subsystem (CWE-200: Information Exposure) and carries a CVSS C:H rating, meaning confidentiality impact is assessed as high despite the medium-severity label. No public exploit code has been identified and EPSS probability sits at 0.17% (7th percentile), indicating very low observed exploitation activity; the vulnerability is not listed in the CISA KEV catalog.

Cross-origin data leakage in Google Chrome's CustomTabs feature on Android (versions prior to 152.0.7977.65) enables a local attacker to infer cross-origin information via a co-installed malicious application. The vulnerability stems from an observable discrepancy (CWE-203) - a measurable side-channel difference in Chrome's behavior that a co-resident app can detect and use to reconstruct protected web content. Impact is confined to limited confidentiality loss; no public exploit has been identified at time of analysis, and EPSS at 0.15% (4th percentile) signals very low real-world exploitation probability.