Information Disclosure

Heap memory disclosure in Cyrus IMAP before 3.12.4 allows authenticated users to leak adjacent heap contents via a crafted JMAP blob ID. By issuing a JMAP blob download request using the internal format H<emailid>-<index> with an index value that exceeds the length of the blob_headers array, an attacker triggers an out-of-bounds read (CWE-125) and receives whatever heap memory follows the array in the server's response. The CVSS 3.1 score of 3.1 (Low) reflects the authentication requirement, high attack complexity, and limited confidentiality impact; no public exploit has been identified at time of analysis.

WeasyPrint ≤v69.0 silently bypasses application-configured url_fetcher restrictions in two write_pdf() channels, enabling arbitrary local file read and SSRF in server-side PDF rendering pipelines. The xmp_metadata parameter fetches attacker-controlled URLs using the default unrestricted URLFetcher and embeds the response bytes verbatim in the generated PDF, while the stylesheets parameter applies fetched CSS with transitive propagation through @import chains - both ignoring any restrictive fetcher set on HTML(). No public exploit is listed in KEV, but the advisory includes complete working PoC code demonstrating credential file exfiltration.

Unauthenticated remote attackers can exploit sqladmin's `ModelView` list view to probe hidden model column values via an ordering oracle, bypassing the UI-level `column_sortable_list` restriction. The `sortBy` HTTP query parameter is resolved through `getattr(model, ...)` and fed directly into ORM `ORDER BY` clauses without server-side validation, meaning any column - including those deliberately hidden from `column_list` - and related-model columns via dotted paths can be sorted. By observing row-order changes across ascending and descending requests, an attacker incrementally infers relative values of unexposed fields. No public exploit code and no CISA KEV listing exist at time of analysis; vendor-released patch is available in 0.27.1.

In the Linux kernel, the following vulnerability has been resolved: vlan: fix skb_under_panic and races when toggling HW VLAN offload Toggling hardware VLAN TX offload (NETIF_F_HW_VLAN_CTAG_TX or NETIF_F_HW_VLAN_STAG_TX) on a lower device invokes vlan_transfer_features(), which dynamically changed vlandev->hard_header_len. This causes two issues: 1. Lockless TX paths (e.g. packet_snd in af_packet.c, ip6_finish_output2) read dev->hard_header_len without holding RTNL lock. Mutating hard_header_len dynamically under RTNL creates a data race where upper layers reserve insufficient headroom based on a stale hard_header_len, resulting in skb_under_panic when vlan_dev_hard_header() is called. 2. In addition, vlan_transfer_features() updated hard_header_len without updating header_ops, causing a mismatch between allocated headroom and header creation. Always setting dev->hard_header_len = real_dev->hard_header_len and dev->needed_headroom = real_dev->needed_headroom + VLAN_HLEN unconditionally ensures: - dev->hard_header_len remains 100% static and immutable at real_dev->hard_header_len, eliminating all dynamic runtime updates and data races on hard_header_len. - Upper layers allocating skbs via LL_RESERVED_SPACE() will always reserve sufficient headroom for software VLAN tag insertion (real_dev->hard_header_len + real_dev->needed_headroom + VLAN_HLEN). - vlandev inherits real_dev->needed_tailroom so underlying trailer/padding/ICV requirements are honored. - AF_PACKET SOCK_RAW network header offsets remain correctly aligned at real_dev->hard_header_len. - vlan_header_ops is used unconditionally. Note to stable teams: Make sure to backport these commits: e16e960d55a4 ("ipvlan: inherit needed_headroom and needed_tailroom from phy_dev") cef51860becd ("macvlan: inherit needed_headroom and needed_tailroom from lowerdev")

In the Linux kernel, the following vulnerability has been resolved: xhci: dbgtty: Fix unregister on tty_register_driver() failure If tty_register_driver() fails, it drops the reference, but fails to set the global dbc_tty_driver to NULL, causing the unregister to be called again when module exits. On module unload dbc_tty_exit() only gates its cleanup on the driver pointer being non-NULL, so it operates on the already-freed driver: module_init(xhci_hcd_init) xhci_hcd_init() xhci_dbc_init() [return value ignored] dbc_tty_init() tty_register_driver() fails tty_driver_kref_put() -> driver freed (dbc_tty_driver left dangling) ... module_exit(xhci_hcd_fini) xhci_hcd_fini() xhci_dbc_exit() dbc_tty_exit() if (dbc_tty_driver) -> true (dangling) tty_unregister_driver() -> use-after-free

In the Linux kernel, the following vulnerability has been resolved: crypto: qcom-rng - Allow zero as a random number Zero is a valid random number and needs to be allowed. Otherwise the output is distinguishable from random.

In the Linux kernel, the following vulnerability has been resolved: io_uring: defer eventfd signaling when queued from a wakeup handler io_req_local_work_add() signals the CQ ring eventfd inline when it is the one to push the first entry onto ->work_list. For DEFER_TASKRUN rings that add is frequently done from a waitqueue wakeup handler, where an arbitrary waitqueue lock is held. eventfd_signal_mask() only refuses to recurse when current->in_eventfd is set, but that bit is set by eventfd_signal_mask() itself. If the wake chain starts somewhere else, signal goes out inline and can feed back into epoll. Add IOU_F_TWQ_IN_WAKE, set it on the task_work add done from the three waitqueue callbacks, and use it to force io_eventfd_signal() down the existing call_rcu_hurry() deferral instead of signaling inline.

In the Linux kernel, the following vulnerability has been resolved: drm/amdgpu: fix recursive ww_mutex acquire in amdgpu_devcoredump_format When dumping IB contents from a hung job, amdgpu_devcoredump_format() acquired the VM root PD's reservation via amdgpu_vm_lock_by_pasid() and then, for each IB, called amdgpu_bo_reserve() on the BO backing the IB. Both reservations are reservation_ww_class_mutex objects and neither used a ww_acquire_ctx, which trips lockdep: WARNING: possible recursive locking detected -------------------------------------------- kworker/u128:0 is trying to acquire lock: ffff88838b16e1f0 (reservation_ww_class_mutex){+.+.}-{4:4}, at: amdgpu_devcoredump_format+0x1594/0x23f0 [amdgpu] but task is already holding lock: ffff8882f82681f0 (reservation_ww_class_mutex){+.+.}-{4:4}, at: amdgpu_devcoredump_format+0x1594/0x23f0 [amdgpu] Possible unsafe locking scenario: CPU0 ---- lock(reservation_ww_class_mutex); lock(reservation_ww_class_mutex); *** DEADLOCK *** May be due to missing lock nesting notation Workqueue: events_unbound amdgpu_devcoredump_deferred_work [amdgpu] Call Trace: __ww_mutex_lock.constprop.0 ww_mutex_lock amdgpu_bo_reserve amdgpu_devcoredump_format+0x1594 [amdgpu] amdgpu_devcoredump_deferred_work+0xea [amdgpu] The two reservations are on different BOs in the captured trace, so the splat is a lockdep-correctness warning, not an observed deadlock. It becomes a real self-deadlock whenever the IB BO shares its dma_resv with the root PD (the always-valid case, see amdgpu_vm_is_bo_always_valid()): amdgpu_bo_reserve(abo) re-acquires the same ww_mutex without a ticket and blocks forever. With amdgpu.gpu_recovery=0 the timeout handler refires every ~2 s and each invocation produces this splat, drowning the kernel ring buffer. Now that amdgpu_vm_lock_by_pasid() takes a drm_exec context, move the IB dumping into a separate helper that locks the root PD and every IB BO together in a single drm_exec ticket. DRM_EXEC_IGNORE_DUPLICATES handles IB BOs that share a dma_resv (e.g. always-valid BOs, or two IBs backed by the same BO). Every lock is now a top-level acquire under one ww_acquire_ctx, so the recursive ww_mutex condition is gone, and the per-IB amdgpu_bo_reserve()/amdgpu_bo_unref() dance -- including a BO refcount leak on the amdgpu_bo_reserve() failure path -- is removed. (cherry picked from commit d6bf4242731219ee08ce54c365631e395486651e)

In the Linux kernel, the following vulnerability has been resolved: HID: core: fix number/pointer type confusion on long items When fetch_item() is called by hid_scan_report() on an item with HID_ITEM_TAG_LONG, it stores a pointer to the item data in item->data.longdata instead of storing a value directly in item->data.{u8/u16/u32}. When item_udata() or item_sdata() encounters such an item, it incorrectly assumes that the item is in short format, and therefore returns the lower part of a kernel pointer reinterpreted as a number. When a HID device is connected whose descriptor contains a HID_GLOBAL_ITEM_TAG_REPORT_SIZE encoded in long format with size=4, this causes the lower half of a kernel pointer to be printed into dmesg as a number, like this: hid (null): invalid report_size 107953555 To fix it, let item_udata() and item_sdata() verify that the item is in short format. Note that this bug only affects hid_scan_report(), while the main parsing pass hid_parse_collections() will always bail out when encountering a long item. Sidenote: There are currently no users of data.longdata; maybe we should just remove any parsing of long-format descriptors as a follow-up.

In the Linux kernel, the following vulnerability has been resolved: drm/xe: Fix DPT allocation paths. Remove the fallback for VRAM to system memory, I tested it and that doesn't work at all, only a black screen with pipe fault errors were observed. On systems with media GT, extra latency is added when accessing stolen memory when the GT is in MC6. Since we additionally aren't counting how much memory is used for stolen and we could in theory fill up the entire stolen area with DPT's, avoid using stolen and only use the default memory region. Using stolen may also result in random system hangs under load. (cherry picked from commit a196406a3831291598fe8e73245914f7acffdfe0)

Case-insensitive username comparisons in two code paths of the CUPS scheduler - printer ACL validation and private-attribute filtering - allow an authenticated adjacent-network attacker to bypass username-based access controls in configurations that rely on those ACLs. The bypass exposes private print attributes to users who should be excluded by ACL policy. Affected deployments span Red Hat Enterprise Linux 6 through 10, Red Hat Hardened Images, and OpenShift Container Platform 4. No public exploit or active exploitation has been identified at time of analysis, consistent with the low CVSS base score of 3.0.

Unconditional TLS certificate validation disabling in the OCAPI modules (ocapi_command, ocapi_info) of the community.general Ansible collection exposes HTTP Basic-Auth credentials to interception and permits response tampering against any managed OCAPI storage or enclosure device. Because the shared request helper disables certificate validation on every call with no parameter to re-enable it, a network-adjacent attacker performing a MITM attack can present any certificate, silently capture credentials, and inject falsified device responses back to the Ansible controller. Red Hat bundles the affected collection in Ceph Storage 5 and 9 and OpenStack Platform 17.1 and 18.0; no public exploit has been identified at time of analysis.

Heap out-of-bounds read in CUPS's cupsUTF32ToUTF8() transcoding function exposes partial daemon heap memory to adjacent-network attackers without authentication. The vulnerable code path is reachable via SNMP supply-description parsing, meaning any attacker who can spoof or inject crafted SNMP responses on the same network segment as a CUPS host can trigger the read and potentially leak heap contents from the printing daemon. No active exploitation has been identified, and the adjacent-network attack vector significantly limits the exposure surface.

Hard-coded cryptographic key exposure in Dell Secure Connect Gateway (SCG) 5.0 enables remote information disclosure by allowing an attacker who extracts the embedded key to decrypt protected communications or data stores. Both the Appliance (versions prior to 5.36.00.16) and Application (versions prior to 5.36.00.00) variants of SCG 5.0 are affected per Dell advisory DSA-2026-382. No public exploit code has been identified at time of analysis, and the vendor has released patches.

Hard-coded credentials embedded in Dell Secure Connect Gateway 5.0 (both Appliance and Application deployment forms) allow a remote attacker who discovers those credentials to authenticate without legitimate access and retrieve sensitive information. Dell advisory DSA-2026-382 confirms patches for both variants: Appliance fixed at 5.36.00.16 and Application at 5.36.00.00. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.

Cross-tenant information disclosure in Snipe-IT before 8.7.0 allows authenticated users with standard assets.view permission to read pending asset request records belonging to other companies when the Full Multiple Company Support feature is enabled. The GET /hardware/requested endpoint omits company scope filtering entirely, returning cross-tenant data including asset names, requester display names and profile links, locations, and expected check-in dates without requiring any parameter manipulation. No public exploit has been identified and no active exploitation is listed in CISA KEV; impact is bounded by what the endpoint exposes - operational metadata rather than credentials or full asset inventories.

CSV formula injection in Snipe-IT's location-scoping report export allows an authenticated low-privileged user to plant spreadsheet formulas in free-text asset fields that execute when a superuser downloads and opens the report in Excel, LibreOffice Calc, or Google Sheets. The vulnerable endpoint GET /admin/settings/location-scoping-report.csv uses a bare fputcsv() call without the League\Csv\EscapeFormula sanitization that all other CSV exports in the application apply, creating an inconsistency exploitable for data exfiltration via HYPERLINK or WEBSERVICE formulas, or command execution via legacy DDE on Windows Excel. The flaw exists only in master-branch builds after 8.6.3 - it was never included in a tagged release - and is fixed in version 8.7.0.

Silent deletion failure in Snipe-IT before 8.7.0 causes attachment files to persist on disk despite administrators receiving success responses from both the web UI and REST API controllers. The root cause is an unchecked return value from Storage::delete() in UploadedFilesController::destroy() and Api\UploadedFilesController::destroy(), meaning file records are marked deleted and hidden from listings while the physical files remain on the server filesystem. Anyone with direct filesystem or backup access - including system administrators, backup operators, or post-compromise threat actors - can retrieve files an authorized admin believed had been permanently removed. No public exploit or active exploitation has been identified at time of analysis.

Heap out-of-bounds read in VLC Media Player 3.0.0 through 3.0.23 allows a hostile RTSP server to extract adjacent heap memory from a connecting client. The flaw lies in the realrtsp access module: `RtspReadLine` in `modules/access/rtsp/access.c` uses `strncpy` with the full buffer length into a 4096-byte allocation, omitting the null terminator when the source is at least as long; `rtsp_get` in `modules/access/rtsp/rtsp.c` then passes that unterminated buffer to `strdup`, which walks heap memory until an incidental zero byte. The disclosed bytes are retained as the RTSP Session identifier and echoed back to the server on every subsequent request, giving the server operator a continuous read of arbitrary heap contents from the victim process. No public exploit code has been identified at time of analysis, and the module is disabled in some distribution packages.

Sensitive information insertion into log files in Dell Secure Connect Gateway (SCG) 5.0 exposes confidential data to local low-privileged users. Both the Appliance variant (versions prior to 5.36.00.16) and the Application variant (versions prior to 5.36.00.00) are affected, with the vulnerability covered under Dell advisory DSA-2026-382 alongside additional CVEs. No public exploit code or active exploitation has been identified, and the low CVSS score of 3.3 accurately reflects the constrained local access requirement and limited confidentiality impact.

Sensitive information insertion into log files in Dell Secure Connect Gateway (SCG) 5.0 exposes confidential data to local low-privileged users. Both the Appliance variant (prior to 5.36.00.16) and the Application variant (prior to 5.36.00.00) are affected. A local attacker with standard OS-level access can read log files containing sensitive data, potentially including credentials or configuration secrets. No active exploitation or public proof-of-concept has been identified at time of analysis.

Improper neutralization of escape, meta, or control sequences (CWE-116) in Dell Secure Connect Gateway (SCG) 5.0 enables unauthenticated remote attackers to inject malformed sequences into server responses, facilitating phishing attacks against SCG users. Both the Appliance variant (prior to 5.36.00.16) and the Application variant (prior to 5.36.00.00) are affected. Dell has released patched versions per advisory DSA-2026-382; no active exploitation or public exploit code has been identified at time of analysis.

Improper output encoding in Dell Secure Connect Gateway (SCG) 5.0 - both the Appliance (prior to 5.36.00.16) and Application (prior to 5.36.00.00) variants - allows unauthenticated remote attackers to inject unescaped content into application output, enabling phishing campaigns targeting users of the gateway. The vulnerability is classified as CWE-116 (Improper Encoding or Escaping of Output) and carries a CVSS 5.3 medium score, reflecting network-accessible, zero-authentication exploitation with limited confidentiality impact. Dell has released patches for both product variants under advisory DSA-2026-382; no active exploitation or public proof-of-concept has been identified.

Sensitive information exposure in Dell Secure Connect Gateway (SCG) 5.0 - both Appliance and Application deployment variants - results from debugging code retained in production builds that exposes confidential data to locally authenticated low-privileged users. The flaw covers Appliance versions prior to 5.36.00.16 and Application versions prior to 5.36.00.00, with patches available under Dell Security Advisory DSA-2026-382. No public exploit code or active exploitation has been identified at time of analysis.

CyberPanel versions 2.4.3 through 2.4.5 expose unauthenticated AI Scanner callback and status-update endpoints that return administrator usernames, API-key prefixes, scan identifiers, target domains, and account metadata without requiring any credentials. Unauthenticated network attackers can systematically enumerate panel administrators and recent scanner activity across multi-tenant hosting installations, enabling reconnaissance for follow-on credential attacks or phishing. No public exploit code has been identified at time of analysis; vendor-released patch version 2.4.6 is available.

Information disclosure in Siyuan note-taking software before v3.8.2 allows unauthenticated publish-mode readers to probe the existence and quantity of private or unpublished content via the full-text search API. The POST /api/search/fullTextSearchBlock endpoint correctly withholds actual block content from hidden documents but leaks unfiltered match counts - the number of matching blocks and pages - enabling attackers to use the search API as an oracle to systematically map the structure of private content without ever seeing it. No public exploit code has been identified at time of analysis, and the vendor has released a patch in v3.8.2.

Insufficient entropy in the PRNG used by Dell Secure Connect Gateway (SCG) 5.0 allows a local low-privileged attacker to predict pseudo-random values - session tokens, authentication nonces, or cryptographic keys - generated by the system, ultimately enabling elevation of privileges. Both the virtual Appliance form factor (prior to 5.36.00.16) and the Application form factor (prior to 5.36.00.00) are affected. No public exploit code or CISA KEV listing has been identified at time of analysis, but the confidentiality-only CVSS vector (C:H/I:N) conflicts with the description's claimed elevation-of-privileges outcome, which warrants independent verification.

Dell Secure Connect Gateway (SCG) 5.0 exposes sensitive system information through uncleared debug artifacts accessible to local low-privileged users, affecting both the Appliance variant (prior to 5.36.00.16) and the Application variant (prior to 5.36.00.00). The root cause is CWE-1258: debug data containing sensitive system details is not purged and remains readable on the local filesystem. No public exploit code has been identified and exploitation requires local authenticated access, making real-world impact limited to insider threat scenarios or post-compromise reconnaissance.

Uncleared debug information in Dell Secure Connect Gateway (SCG) 5.0 exposes sensitive system data to physically present unauthenticated attackers. Both the Appliance variant (versions prior to 5.36.00.16) and the Application variant (versions prior to 5.36.00.00) are affected, per CPE data and the Dell advisory DSA-2026-382. The CVSS vector (AV:P) confirms exploitation is constrained to physical access, yielding a low overall severity of 2.4, and no public exploit or active exploitation has been identified at time of analysis.

Insufficient session expiration in Dell Secure Connect Gateway 5.0 (both Appliance and Application deployments) enables a low-privileged remote attacker to capture and replay session tokens that remain valid beyond their intended lifetime, resulting in session theft and unauthorized access to sensitive data. Both form factors are affected: Application versions prior to 5.36.00.00 and Appliance versions prior to 5.36.00.16. Dell has released patched versions via advisory DSA-2026-382; no public exploit or active exploitation has been identified at time of analysis.

Unauthenticated information disclosure in AlchemyCMS affects all 7.x versions before 7.4.16 and all 8.x versions before 8.3.6 via the GET /api/nodes REST endpoint, which returned the full navigation node dataset without any authorization check. Any network-reachable attacker could enumerate restricted page names, internal URL paths, and cross-site navigation structures across all languages. No public exploit identified at time of analysis, but the attack requires only a single unauthenticated HTTP request, making automated scanning trivial.

Sensitive information disclosure in SUSE NeuVector Manager before version 5.4.5 exposes security-critical data by inserting it into the manager container's log files during normal or error-path operation. The scope-changed CVSS vector (S:C) indicates the leaked material - likely credentials, tokens, or API keys - can compromise systems beyond NeuVector itself. No public exploit has been identified at time of analysis, but the low privilege bar and high confidentiality impact make this a meaningful risk for Kubernetes environments where NeuVector is deployed.

Sensitive data written to log files in Dell Secure Connect Gateway (SCG) 5.0 is readable by low-privileged local users, resulting in high-confidence confidentiality exposure. Affected products are SCG 5.0 Appliance versions prior to 5.36.00.16 and SCG 5.0 Application versions prior to 5.36.00.00, with a vendor-released patch available under advisory DSA-2026-382. No public exploit code exists and no active exploitation has been identified at time of analysis.

Dell Secure Connect Gateway (SCG) 5.0 - both the Appliance and Application editions - writes sensitive information into files or directories that are externally accessible on the local system (CWE-538). A local attacker with low privileges who can read those files gains access to information they should not be authorized to see. No public exploit code exists and no active exploitation has been reported; the low CVSS base score of 3.3 reflects the local, low-privilege access requirement and limited confidentiality impact.

Shortcode injection in the Hustle WordPress plugin (versions prior to 7.8.14.2) allows unauthenticated remote attackers to execute any shortcode registered on the target site by embedding nested shortcode syntax in form submission field values. The plugin substitutes submitted values into its post-submission success message, and while a guard exists to prevent shortcode execution, it can be defeated through shortcode nesting - causing WordPress to process and execute arbitrary registered shortcodes in the response. A publicly available proof-of-concept exploit exists, and a vendor patch is available in version 7.8.14.2.

Missing authorization on a cookie-scanner AJAX endpoint in the WPLP Cookie Consent WordPress plugin before 4.4.2 allows any authenticated user with subscriber-level access to read the automated scan schedule configured by an administrator. The flaw (CWE-862) stems from the absence of both nonce validation and WordPress capability checks on the AJAX action handler. While impact is limited to information disclosure of scheduling configuration, a publicly available exploit via WPScan and low barrier to exploitation (any registered user) make patching advisable for all affected sites.

Unauthenticated content disclosure in the Kirki WordPress plugin before 6.3.0 allows any remote attacker to retrieve the full rendered page content of posts that are in private, draft, pending, or trashed states. The plugin renders and returns post content without first verifying whether the requesting party holds read permissions for that post, effectively bypassing WordPress's built-in visibility controls. A publicly available proof-of-concept exists via WPScan, though EPSS probability remains low at 0.14%, and the flaw has not been added to CISA KEV as of this analysis.

Enrollment record exposure in the Masteriyo LMS WordPress plugin (versions 1.3.1 through below 3.4.0) lets unauthenticated attackers retrieve any learner's enrollment status, progress data, and timestamps by iterating sequential integer record identifiers against the plugin's REST API - a classic IDOR pattern with no authorization gate. A secondary gap extends the exposure to authenticated enrolled users, who can similarly read other learners' records without restriction. A publicly available proof-of-concept is documented by WPScan, though no confirmed active exploitation (CISA KEV) has been recorded.

SupportCandy WordPress plugin before version 3.5.3 allows unauthenticated users to read the full contents of any support ticket by exploiting a missing pre-validation step on per-ticket authorization codes. The plugin discloses the genuine authorization code to any requester before verifying whether the submitted code is valid, effectively inverting the access control check and rendering the protection mechanism moot. A publicly available exploit exists via WPScan; no active exploitation has been confirmed by CISA KEV, and EPSS sits at 0.14%.

Unauthenticated information disclosure in SupportCandy WordPress plugin before 3.5.3 exposes protected customer-uploaded support ticket attachments to any remote attacker. The attachment download endpoint lacks an authorization check and uses sequential numeric identifiers, enabling trivial enumeration of all attachments across all tickets regardless of ticket visibility or customer ownership. A publicly available exploit exists per WPScan, though EPSS at 0.14% (4th percentile) indicates limited observed exploitation activity at time of analysis.

Unauthenticated order data exposure in the Payment Plugins for PayPal WooCommerce WordPress plugin before version 2.0.26 allows remote attackers to harvest customer PII from any WooCommerce order. The plugin outputs order secrets into frontend JavaScript configuration without first validating the supplied order key, and because WooCommerce order identifiers are sequential integers, an attacker can iterate through IDs to retrieve the secret for each order and subsequently access that customer's billing address, shipping address, and associated personal details. A publicly available proof-of-concept exists; no active exploitation is confirmed by CISA KEV at time of analysis.

Unauthenticated billing data exposure in Payment Plugins for Stripe WooCommerce (versions before 4.0.12) allows any remote attacker to enumerate all WooCommerce orders and retrieve their full billing details plus the per-order secret key embedded in front-end JavaScript. The root cause is missing order key validation before order data is serialized into the plugin's client-side configuration, combined with WooCommerce's use of sequential, predictable order identifiers that make enumeration trivial. A publicly available exploit exists per WPScan, and the SSVC assessment confirms the attack is automatable, though EPSS remains low (0.14%) suggesting no widespread active exploitation at time of analysis.

Improper input validation in Samsung Tips prior to Android 17 allows a local, low-privileged attacker to launch arbitrary Android activities under Samsung Tips' privileges. The attack requires user interaction to trigger the flaw, limiting its severity, but successful exploitation grants the attacker access to functionality and data scoped to the Samsung Tips application. No public exploit code or active exploitation has been identified at time of analysis.

Improper export of Android application components in Samsung Bixby Touch prior to version 4.3.01.17 allows any co-installed application on the same device to access sensitive information without requiring special Android permissions. The vulnerability stems from one or more app components being declared exported in the application manifest without enforcing appropriate permission checks, giving locally present adversarial apps direct access to data the Bixby Touch service handles. Samsung Mobile has released a patched version (4.3.01.17) via its monthly security bulletin; no public exploit or active exploitation has been identified at time of analysis.

Improper access control in Samsung's SettingsProvider component on Android allows local attackers to read sensitive device settings without holding any special permissions. Affected devices run Android 15, 16, or 17 with Samsung firmware prior to the SMR Sep-2026 Release 1 patch bundle. No public exploit has been identified at time of analysis, and the CVSS 4.0 score of 5.1 with VC:L reflects the limited (though real) confidentiality exposure from a purely local attack surface.

Improper authorization in the ProxyHandler component of Samsung Android devices allows a locally-executing, low-privileged attacker to read proxy configuration without proper access controls. Devices running Android 14 through 17 are affected and patched in the SMR September 2026 release cycle. No public exploit code exists and no active exploitation has been identified; the CVSS 4.0 score of 4.8 accurately reflects the constrained local-only attack surface.

Timing side-channel in mirage-crypto-ec before 2.4.0 for OCaml enables remote cryptographic key recovery by exploiting secret-dependent timing variations during NIST elliptic-curve scalar multiplication table lookups. Affected applications performing ECDH key agreement or ECDSA signing - including TLS endpoints built on this library - leak private key material through measurable latency differences. No active exploitation is confirmed (no CISA KEV listing), but the C:H CVSS impact rating accurately reflects that successful key recovery constitutes full confidentiality compromise of the cryptographic material.

Out-of-bounds read in the mirage-crypto-ec OCaml cryptographic library (versions before 2.3.0) allows low-privileged network attackers to crash or disrupt services that parse compressed elliptic curve public keys. The flaw arises from insufficient bounds checking during compressed EC point deserialization, classified under CWE-125. No public exploit has been identified at time of analysis; a vendor-released patch is available in version 2.3.0.

Out-of-bounds read (CWE-125) in the HarmonyOS graphics module affects version 6.1.0 across multiple device categories including smartphones, wearables, and laptops. A local attacker without special privileges can trigger the flaw to cause partial availability loss, limited information disclosure, or a crash of the graphics subsystem. No public exploit code or active exploitation has been identified at time of analysis, and Huawei has released a security bulletin addressing the issue.

Authenticated information disclosure in Tanium Server across three supported release branches (7.7.3, 7.8.2, and 7.8.4) allows a low-privilege network user to access data they are not authorized to view, as described in vendor advisory TAN-2026-033. The CVSS 4.3 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N) confirms the flaw is network-reachable, low-complexity, and requires only standard credentials with no user interaction. Vendor-released patches are available for all affected branches; no public exploit code or CISA KEV listing exists at time of analysis.

Information disclosure in Tanium Comply allows authenticated low-privilege network users to access data beyond their authorization level. Versions in the 2.37 branch prior to 2.37.308 are confirmed affected per the EUVD advisory tied to vendor bulletin TAN-2026-032. No public exploit code or active exploitation has been identified; Tanium self-reported and patched the issue.

Sensitive information disclosure in Google Chrome's Editing subsystem allows a remote unauthenticated attacker to exfiltrate browser-accessible data by luring a user to a crafted HTML page. All Chrome versions prior to 153.0.8010.36 on desktop are affected. No public exploit has been identified and SSVC assigns no active exploitation, making this a low operational priority despite the CVSS 6.5 score.

Out-of-bounds read in Chrome's ANGLE graphics abstraction layer on Windows (prior to 153.0.8010.36) can expose limited memory content outside the Chrome sandbox to a remote attacker via a crafted HTML page. The vulnerability is platform-specific to Windows and requires user interaction to trigger, carrying a Chromium-assigned severity of Low and a CVSS score of 4.7. No public exploit or active exploitation has been identified; EPSS at 0.16% (6th percentile) confirms very low real-world exploitation probability, making this a routine patch priority rather than an emergency.

Sensitive information leak via the Frames component in Google Chrome prior to 153.0.8010.36 allows a remote, unauthenticated attacker to obtain cross-origin data by enticing a user to visit a crafted HTML page. Exploitation requires user interaction but no privileges, delivering high confidentiality impact (C:H) despite Chromium's own 'Low' internal severity rating - a notable discrepancy suggesting the leaked data may be narrowly scoped in practice. No public exploit code or CISA KEV listing exists at time of analysis, and EPSS sits at 0.27% (19th percentile), indicating low current exploitation pressure.

Sensitive information leak in the Core component of Google Chrome prior to version 153.0.8010.36 allows a remote unauthenticated attacker to exfiltrate confidential browser or cross-origin data by inducing a user to visit a crafted HTML page. The CVSS vector rates confidentiality impact as High (C:H), yet Chromium's own internal severity is 'Low,' suggesting the leaked data may be bounded in scope or practical exploitability is constrained by the mandatory user-interaction requirement. No public exploit code or CISA KEV listing exists at time of analysis, and EPSS probability is well below average at 0.27%.

Cross-origin data leakage in Google Chrome's Core component (all versions prior to 153.0.8010.36) enables a remote attacker to exfiltrate data from origins other than the attacker-controlled context via a specially crafted Chrome extension. The extension acts as the delivery mechanism, causing Chrome's Core to expose cross-origin content it should otherwise isolate. EPSS sits at 0.15% and Chromium's own severity rating is Low, consistent with the limited, read-only confidentiality impact and the user-interaction requirement for extension installation. No public exploit code and no active exploitation (CISA KEV) have been identified at time of analysis.

UI spoofing in Google Chrome's Passwords component on Android (prior to 153.0.8010.36) enables a remote attacker to misrepresent password-related UI elements by delivering a crafted HTML page to a victim. The CVSS 5.4 (Medium) rating contrasts with Chromium's own 'Low' severity classification, a common divergence for UI-redressing issues. No public exploit code or active exploitation (CISA KEV) has been identified, and EPSS of 0.16% (6th percentile) confirms negligible near-term exploitation probability.

Sensitive information disclosure in Google Chrome's Transactions Platform component prior to version 153.0.8010.36 enables remote attackers to extract unspecified sensitive data by directing a user to a crafted HTML page. The Transactions Platform is likely tied to Chrome's Web Payments API or payment handler subsystem, making transaction-context data a plausible disclosure surface. No public exploit code exists and EPSS sits at 0.16% (6th percentile); however, the vendor-assigned CVSS C:H metric indicates the leaked data carries meaningful sensitivity, creating a tension with Chromium's own 'Low' internal severity classification.

UI spoofing in the Passwords component of Google Chrome on Android (versions prior to 153.0.8010.36) enables an attacker who has already compromised the renderer process to display falsified password-manager interface elements via a crafted HTML page. Exploitation is constrained by a hard prerequisite - a separate renderer compromise must precede this attack - and requires user interaction with the malicious page. No public exploit code exists and EPSS sits at 0.16% (6th percentile), in line with Chromium's own 'Low' severity classification.

Address bar spoofing in Google Chrome's CustomTabs feature on Android (prior to 153.0.8010.36) allows a remote attacker to display a falsified URL by leveraging a co-installed application on the victim's device. The flaw, rooted in CWE-451 (User Interface Misrepresentation of Critical Information), enables phishing attacks where users are deceived into believing they are visiting a trusted origin while interacting with attacker-controlled content. Chromium rates this 'Low' severity; EPSS is 0.16% (6th percentile), no public exploits are identified, and no active exploitation is confirmed.

Sensitive credential information leak in the Passwords component of Google Chrome on Android (prior to 153.0.8010.36) enables a remote unauthenticated attacker to extract password data by luring a victim to a crafted HTML page. Despite Chromium classifying the severity as 'Low', the NVD CVSS vector assigns C:H reflecting that full credential disclosure is possible. No public exploit code or active exploitation (CISA KEV) has been identified, and the EPSS score of 0.21% (11th percentile) signals low automated exploitation pressure at time of analysis.

Information disclosure in Google Chrome's DataTransfer API via a TOCTOU race condition allows a remote attacker to obtain sensitive data from a victim's browser session. Affected versions are all Chrome releases prior to 153.0.8010.36 on desktop platforms. Exploitation requires social engineering to induce user interaction with a crafted HTML page - no active exploitation has been identified and EPSS sits at the 9th percentile, indicating very low real-world exploitation probability at this time.

Sensitive information disclosure in Google Chrome's Mobile component on iOS (versions prior to 153.0.8010.36) allows remote unauthenticated attackers to leak confidential browser data by luring victims to a crafted HTML page through social engineering. The flaw is platform-specific - affecting only the iOS Mobile code path, not desktop or Android - and is fixed in the 153.0.8010.36 stable channel release. No active exploitation is confirmed (not in CISA KEV) and EPSS probability is 0.17% (7th percentile), consistent with Chromium's own 'Low' severity rating, which contrasts with the NVD CVSS 6.5 Medium score.

Cross-origin information leakage in Google Chrome's Select element (all versions prior to 153.0.8010.36) allows a remote unauthenticated attacker to infer sensitive user state by observing behavioral discrepancies in how the `<select>` element renders when a victim browses to a crafted HTML page. The root cause is CWE-203 (Observable Discrepancy), a classic browser side-channel class that enables cross-site information inference - for example, whether a user is authenticated to a third-party origin or has visited specific URLs. No public exploit has been identified at time of analysis, and EPSS sits at 0.17% (7th percentile), consistent with the Chromium team's own 'Low' severity rating despite NVD's CVSS 6.5.

UI spoofing via a confused deputy flaw in Google Chrome's Fullscreen API (all versions prior to 153.0.8010.36) enables a remote attacker who has already compromised the renderer process to impersonate browser-trusted UI elements using a crafted HTML page and social engineering. This is a secondary exploitation step - it does not provide initial access - and becomes relevant only after a separate, higher-severity renderer compromise has been achieved. No public exploit code or CISA KEV listing exists; EPSS of 0.17% (6th percentile) reflects very low automated exploitation probability consistent with the chained, human-dependent attack path.

Observable SVG discrepancy in Google Chrome prior to 153.0.8010.36 enables remote attackers to infer sensitive cross-origin information by inducing measurable rendering behavioral differences via a crafted HTML page. The root cause is CWE-203, a side-channel class where an attacker observes system behavior variations to deduce protected state. No public exploit code or active exploitation is identified; Chromium's own 'Low' severity designation and an EPSS of 0.17% (7th percentile) together indicate limited real-world exploitation likelihood despite the NVD's C:H confidentiality metric.

Out-of-bounds read in the Tint WGSL shader compiler in Google Chrome prior to 153.0.8010.36 allows a remote, unauthenticated attacker to read limited memory contents within the browser's renderer sandbox by directing a victim to a crafted HTML page. Scope is confined to the sandbox (S:U/C:L), with no integrity or availability impact and no sandbox escape; Chromium rates this 'Low' severity, consistent with the CVSS 4.3 score. No public exploit code exists and EPSS is negligible at 0.17% (7th percentile), indicating low exploitation probability; a vendor-released patch is available in Chrome 153.0.8010.36.

Cross-origin data leakage in Google Chrome's Prefetch subsystem (versions prior to 153.0.8010.36) enables a remote attacker to infer information about cross-origin resources via an observable discrepancy side-channel triggered by a crafted HTML page. The vulnerability affects unauthenticated users who visit the malicious page, requiring only passive user interaction (browsing). Chromium's own severity rating of 'Low' aligns with the CVSS 4.3 score; no public exploit or active exploitation has been identified at time of analysis.

Observable discrepancy in Chrome's Layout engine prior to version 153.0.8010.36 allows a remote attacker to infer sensitive cross-origin information by measuring rendering differences triggered by a crafted HTML page. The CWE-203 root cause - an attacker-observable behavioral difference that correlates with secret state - places this in the browser side-channel (XSLeak) family, where layout timing or geometry variations can reveal whether a user is authenticated to a third-party origin or whether specific cross-origin resources exist. No public exploit has been identified at time of analysis, and the EPSS score of 0.17% (7th percentile) reflects low observed exploitation interest.

Observable DOM discrepancy in Google Chrome prior to 153.0.8010.36 enables cross-origin information leakage via a CWE-203 side-channel, allowing a remote attacker to infer sensitive data from a victim's browser state. Exploitation requires social engineering to lure the target to a crafted HTML page, satisfying the required user interaction. No public exploit code or CISA KEV listing is associated with this vulnerability, and the EPSS score of 0.17% (7th percentile) reflects low observed exploitation interest at time of analysis.

Out-of-bounds read in ANGLE (Chrome's OpenGL ES translation layer) in Google Chrome prior to 153.0.8010.36 enables a remote unauthenticated attacker to read limited memory content outside the renderer sandbox by luring a user to a crafted HTML page. Unlike co-patched ANGLE issues in the same Chrome 153.0.8010.36 release that achieve full sandbox escape and remote code execution, this flaw is bounded to confidentiality impact only with no scope change - the read does not escape the renderer process. No public exploit code or active exploitation has been identified at time of analysis, and the EPSS score of 0.17% reflects minimal current attacker interest.

Cross-origin data exfiltration in Google Chrome's CORS implementation prior to 153.0.8010.36 is exploitable only as a second-stage technique by an attacker who has already compromised the renderer process, allowing them to read data from foreign origins the victim is authenticated to via a crafted HTML page. With a CVSS of 3.1, EPSS of 0.17% (7th percentile), no CISA KEV listing, and no public exploit code identified, this represents a low standalone risk - its relevance is as a data-harvesting primitive chained after a renderer RCE. Chromium rated it 'Medium,' consistent with the constrained exploitation path.

ControlledFrame in Google Chrome prior to 153.0.8010.36 exposes sensitive information to an attacker who has already achieved renderer process compromise, exploitable via a crafted HTML page (UI:R). This is a chained post-exploitation primitive rather than an initial access vector: it extends the damage of a separate renderer exploit by enabling cross-origin data exfiltration from the victim's session. No public exploit code exists, EPSS stands at 0.29% (21st percentile), and no CISA KEV listing is present, consistent with the high effective exploitation barrier imposed by the renderer pre-compromise requirement.

Cross-origin data disclosure in Google Chrome's Paint rendering component (versions prior to 153.0.8010.36) enables a remote attacker to read data belonging to a different web origin by directing a victim to a crafted HTML page. The root cause is an origin validation error (CWE-346) in the Paint pipeline, which under certain rendering conditions fails to enforce the Same-Origin Policy, leaking partial cross-origin data to the attacker-controlled page. EPSS is 0.14% (3rd percentile), Chromium rates this 'Medium,' and no public exploit or CISA KEV listing exists at time of analysis - placing this squarely in standard patch-cadence rather than emergency response territory.

UI misrepresentation in Google Chrome's Payments component prior to 153.0.8010.36 allows a remote attacker to spoof payment-related interface elements by serving a crafted HTML page. The spoofed UI can deceive users into believing they are interacting with legitimate Chrome payment dialogs, potentially facilitating credential or payment-data disclosure. No public exploit code has been identified and EPSS sits at 0.27% (19th percentile), placing real-world exploitation risk as low at this time.

Sensitive information disclosure in the Enterprise component of Google Chrome on Windows allows a remote attacker to obtain protected data by luring a user to a crafted HTML page. All Chrome releases on Windows prior to 153.0.8010.36 are affected. No public exploit has been identified at the time of analysis, and with an EPSS of 0.17% (7th percentile), opportunistic mass exploitation is unlikely in the near term despite the high confidentiality impact rating.

UI misrepresentation in Google Chrome's Geometry component (versions prior to 153.0.8010.36) enables remote attackers to spoof browser interface elements through a crafted HTML page, requiring social engineering to achieve user interaction. The flaw (CWE-451) permits an attacker to visually deceive victims about the true origin or nature of displayed content, creating a pathway for phishing and credential harvesting. No public exploit has been identified at time of analysis; vendor-released patch is available in the September 2026 stable channel update.

Observable discrepancy (CWE-203) in the Safebrowsing component of Google Chrome on iOS prior to 153.0.8010.36 enables a remote attacker with a pre-compromised renderer process to leak sensitive information through behavioral differences when processing a crafted HTML page. The vulnerability is iOS-platform-specific and is chained after renderer compromise rather than exploited standalone. No public exploit exists and EPSS probability is 0.24%, consistent with the multi-stage exploitation requirement.

ServiceWorker information leak in Google Chrome prior to 153.0.8010.36 enables a remote attacker who has already compromised the renderer process to extract sensitive information via a crafted HTML page. This is a chained exploitation technique rather than a standalone attack - requiring prior renderer process control as a hard prerequisite, making it a second-stage capability within a broader browser exploit chain. No public exploit code exists and EPSS sits at 0.29% (21st percentile), indicating low observed exploitation activity; the vulnerability is not listed in CISA KEV.

Uninitialized GPU resource use in Google Chrome on Android (prior to 153.0.8010.36) allows remote attackers to read process memory across the sandbox boundary via a crafted HTML page. The CVSS S:C (scope changed) metric confirms the vulnerability crosses Chrome's GPU sandbox, leaking partial memory contents outside the sandboxed GPU process to a network-positioned attacker. No public exploit or CISA KEV listing exists; EPSS of 0.31% (24th percentile) indicates low observed exploitation probability, consistent with Chromium's 'Medium' severity rating.

Cross-origin data leakage in the Chrome Downloads subsystem exposes sensitive information to attackers who have already established renderer process compromise. Chrome versions prior to 153.0.8010.36 are affected; exploitation requires a renderer-compromised context combined with user interaction via a crafted HTML page. Google rated this 'Medium' internally; the CVSS 3.1 score of 3.1 reflects its role as a second-stage exploitation step rather than a standalone critical flaw. No public exploit code or CISA KEV listing exists at time of analysis.

Navigation component information leak in Google Chrome prior to 153.0.8010.36 enables an attacker who has already compromised the renderer process to bypass site isolation and exfiltrate cross-origin data via a crafted HTML page. This is a second-stage exploit component: it cannot be chained without a prior renderer compromise, which significantly elevates the effective attack complexity despite the AV:N/AC:L CVSS surface reading. Chromium's own severity rating is 'Medium', consistent with the prerequisite constraint. No public exploit identified at time of analysis; EPSS at 0.18% (8th percentile) reflects the elevated bar for exploitation.

Cross-origin data exposure in Google Chrome's Scroll component (all versions prior to 153.0.8010.36) enables an attacker who has already achieved renderer process compromise to exfiltrate sensitive data from other web origins via a crafted HTML page. This is a secondary-stage vulnerability - it does not provide initial access but extends an existing renderer compromise into a cross-origin information leak. Chromium rated this Medium severity, consistent with the 4.3 CVSS score; no public exploit exists and EPSS at 0.17% (7th percentile) reflects the narrow, chained exploitation scenario.

Cross-origin data leakage via Google Chrome's ServiceWorker implementation allows remote attackers to obtain information from other origins by serving a crafted HTML page to a victim. Affected versions are all Chrome releases prior to 153.0.8010.36 across desktop platforms. No active exploitation is confirmed (absent from CISA KEV), and EPSS at 0.21% reflects low real-world exploitation activity.

UI element spoofing in Google Chrome's Geometry rendering component (versions prior to 153.0.8010.36) enables a remote attacker to misrepresent browser chrome and UI elements through a crafted HTML page, requiring the victim to visit the malicious page via social engineering. The vulnerability, classified under CWE-451 (User Interface Misrepresentation of Critical Information), allows an attacker to render fake address bars, security dialogs, or browser-level indicators in a way that deceives users into disclosing credentials or taking unintended actions. No public exploit code has been identified and no CISA KEV listing exists; EPSS at 0.21% (11th percentile) reflects negligible observed exploitation activity.

Google Chrome's browser UI component (all versions prior to 153.0.8010.36) is vulnerable to visual spoofing attacks where an attacker can manipulate how the browser presents security-critical interface elements to users. By serving a specially crafted HTML page combined with social engineering, a remote unauthenticated attacker can make Chrome display misleading UI indicators - such as deceptive origin representations or manipulated security signals - potentially enabling credential theft or unauthorized permission grants. No public exploit code exists and the EPSS score of 0.21% (11th percentile) indicates low near-term exploitation probability, consistent with Chromium's own Medium severity classification.

UI misrepresentation in Google Chrome's FedCM (Federated Credential Management) API prior to 153.0.8010.36 enables remote attackers to spoof identity-provider sign-in dialogs via crafted HTML pages, requiring user interaction. The flaw (CWE-451) allows a malicious page to manipulate how FedCM presents credential prompts, potentially misleading users into authorizing the wrong identity provider or disclosing credential context to an attacker-controlled endpoint. No public exploit code or active exploitation has been identified; EPSS is 0.17%, consistent with Chromium's 'Medium' severity classification.

UI spoofing in Google Chrome's FedCM (Federated Credential Management) implementation allows an attacker who has already compromised the renderer process to inject malformed identity-provider dialog elements via a crafted HTML page, potentially deceiving users into submitting credentials to an attacker-controlled endpoint. All Chrome desktop versions prior to 153.0.8010.36 are affected. The attack is two-stage: an independent renderer-compromise vulnerability must first be exploited, making this a chained post-exploitation capability rather than a standalone initial-access vector. No public exploit code and no CISA KEV listing are confirmed at time of analysis.

UI misrepresentation in Google Chrome prior to 153.0.8010.36 allows a remote attacker to spoof browser UI elements - such as the address bar, security indicators, or permission dialogs - via a specially crafted HTML page, requiring social engineering to lure the victim. Exploiting CWE-451, the attacker can deceive users into trusting a malicious or phishing page as legitimate, potentially leading to credential theft or other user-driven disclosures. No public exploit code has been identified and EPSS is 0.24% (15th percentile), consistent with the Chromium team's 'Medium' severity rating and the high-complexity social engineering prerequisite.

UI misrepresentation in Google Chrome's Downloads panel prior to version 153.0.8010.36 allows a remote attacker to spoof download-related UI elements, potentially deceiving users into accepting or running malicious content they believe to be legitimate. The vulnerability is triggered by a crafted HTML page and requires social engineering to lure a victim into visiting the attacker-controlled page. No public exploit has been identified at time of analysis, and EPSS at 0.24% (15th percentile) places real-world exploitation risk low; however, Chrome's ubiquitous deployment keeps the absolute exposure surface significant.