SAML response tampering in HPE IceWall identity and access management products enables a low-privileged attacker to forge authentication assertions and impersonate arbitrary users across federated SSO sessions. The flaw (CWE-347) reflects improper cryptographic signature verification on SAML responses, meaning a tampered assertion can be accepted as legitimate by the IceWall service provider. No public exploit has been identified at time of analysis, but the low attack complexity and fully network-accessible attack surface make this a high-priority remediation for any organization running IceWall-based SSO.
Stored cross-site scripting in the Gutenverse News WordPress plugin (before 3.3.3) enables unauthenticated attackers to inject persistent JavaScript via the comment submission form. The plugin registers additional HTML elements into WordPress's global sanitization allowlist rather than scoping them to the block editor context, causing the relaxed ruleset to be applied to untrusted comment input. The payload executes in two distinct phases: immediately when an administrator opens the comment moderation queue, enabling pre-approval admin session hijacking, and again for every visitor once the comment is approved. A public proof-of-concept exploit is available via WPScan.
Missing brute-force protection in Kingdom Communication Associated's Smart Video Intercom System (models EH3040, EH4200, EH1000B, EH2070) allows unauthenticated remote attackers to systematically guess credentials across all login attempts without rate-limiting or account lockout. Successful credential compromise grants access to valid accounts, exposing video surveillance feeds and intercom functionality. No public exploit code or active exploitation has been identified at time of analysis, but the trivial attack mechanics and high confidentiality impact make this a significant risk for internet-exposed deployments.
Unauthenticated blind SQL injection in SPIP's public sitemap endpoint (all versions before 4.4.18) allows remote attackers to extract arbitrary database contents without any credentials or prior authentication. The flaw resides in spip_mysql_cite() in ecrire/req/mysql.php, which silently omits escaping when the target column is a date type and the attacker-supplied value matches a word-character-followed-by-open-parenthesis pattern, permitting raw SQL embedding via the annee parameter of squelettes-dist/sitemap.xml.html. Publicly available exploit code exists, including a published Lexfo Research chain demonstrating escalation from this SQLi to remote code execution by recovering the alea_ephemere session secret used to sign SPIP action nonces. Vendor-released patch: SPIP 4.4.18.
Unauthenticated arbitrary comment deletion in MoguBlog through 6.2 allows remote attackers to permanently remove any comment or reply thread on the platform without credentials. The comment delete endpoint (CommentRestApi.java) validates ownership by comparing attacker-supplied authorUid/ownerUid values from the HTTP request body against stored records - a CWE-639 IDOR - instead of checking against the server-side authenticated session principal. Because public unauthenticated listing endpoints expose the comment and author UIDs needed to construct a valid forged request, an attacker can fully enumerate targets and destroy comments at will. A public Python PoC is available via VulnCheck.
Unauthenticated XML external entity injection in MoguBlog through version 6.2 allows remote attackers to read arbitrary files from the server filesystem and trigger outbound SSRF requests via the public WeChat callback endpoint. The WechatRestApi.index() method passes raw POST body XML directly to SignUtil.xmlToMap(), which instantiates a dom4j SAXReader without any DTD or external-entity restrictions, enabling full XXE exploitation with entity resolution reflected in error responses. A publicly available Python proof-of-concept exploit exists; no vendor-released patch has been confirmed at time of analysis.
Denial-of-service in libp2p-rendezvous ≤0.17.1 (Rust) allows a malicious rendezvous server to crash any connecting client node by sending a discovery response containing an unbounded TTL value. The client fails to validate the TTL before computing an expiry timer, triggering a CWE-190 integer arithmetic overflow that causes a Rust process panic. A proof-of-concept gist has been published; no confirmed active exploitation has been identified at time of analysis.
Missing authorization controls in Shopper Framework's CollectionProducts Livewire component allow any authenticated admin-panel user - including those holding only read-only `browse_collections` permission - to detach individual products or bulk-detach all products from any collection in the database. A compounding issue exposes the `$collection` public Livewire property without the `#[Locked]` attribute, enabling client-side mutation of the collection ID in the wire payload, so the attacker is not limited to collections they have legitimately accessed. A full Python proof-of-concept is included in the public GitHub advisory; no active exploitation has been confirmed in CISA KEV at time of analysis.
Inventory stock manipulation in Shopper Framework allows any authenticated admin-panel user - including roles limited to browse_products with zero edit rights - to set stock levels for any product variant in the database to an arbitrary value. The attack combines two compounding failures in the Livewire VariantStock component: the public $variant property lacks the #[Locked] attribute, making the variant ID client-substitutable via wire payload, and the stockAction() method carries no ->authorize() chain, so PHP's permission gate is never consulted. A detailed Python proof-of-concept is publicly embedded in GitHub Security Advisory GHSA-g3f9-g5vj-p62f; the fix is available in version 2.9.2.
Missing authorization gates on Filament `groupedBulkActions` in five Shopper admin Livewire pages allow authenticated low-privilege staff users to execute unauthorized bulk mutations against catalog data. An authenticated user holding only a read-only `browse_*` permission (e.g., `browse_attributes`) can invoke `callTableBulkAction` to permanently delete every product attribute - cascading into all dependent product variants - or mass-toggle visibility of brands, categories, and suppliers, effectively sabotaging the storefront catalog. A working proof-of-concept (seven Pest tests, all passing on master commit `ac9a760`) was published with the advisory. No public exploit identified at time of analysis beyond the reporter-provided PoC.
Privilege escalation in MultiVendorX WordPress plugin before 5.0.16 allows authenticated vendor-role users to grant administrator-level WordPress capabilities to the vendor role, enabling full site takeover. The plugin's role and capability settings update mechanism fails to enforce access boundaries, letting any vendor - a legitimately registered but low-privileged marketplace seller - rewrite role permissions without restriction. A publicly available exploit exists via WPScan, and the vendor has released a patch in version 5.0.16.
Unauthenticated arbitrary file write in WAVLINK WN535M1 and WN535M3 routers (firmware before M35M1_V250922) exposes any file on the device to remote overwrite via the sync_server daemon on TCP port 13136, which runs as root and performs no client authentication. The daemon's 100-byte protocol filename field lacks path canonicalization, allowing absolute path traversal (CWE-36) that enables attackers to overwrite startup scripts or credential stores and achieve persistent root-level compromise. A public proof-of-concept repository (camdsmith/wavlink-sync_server-rce) is available on GitHub, substantially lowering the exploitation bar.
Out-of-bounds stack write in `sensor_hub_get_feature()` within the Linux kernel HID sensor-hub subsystem allows an attacker controlling a malicious HID device to corrupt kernel memory. A crafted HID descriptor that advertises an oversized feature field size exploits a mismatch between the function's return-value clamping logic and its unclamped per-value copy loop: when IIO subsystem callers (e.g., pressure or ambient-light sensor drivers) pass a small stack buffer such as a single s32, the copy loop writes beyond the buffer boundary by the full `field->report_size / 8` bytes per value. No public exploit is identified at time of analysis; EPSS is 0.20% (10th percentile), indicating low observed exploitation probability.
Incomplete error-path cleanup in the Linux kernel HID custom sensor driver (`hid-sensor-custom`) creates a use-after-free condition: when `hid_sensor_custom_add_attributes()` fails partway through sysfs group creation, previously created groups are not removed and `sensor_inst->fields` can be freed while `enable_sensor` sysfs attributes retain stale pointers into that array. Systems running Linux kernel from commit 4a7de051 through versions prior to 6.12.109, 6.18.50, 7.2.4, and 7.3-rc1 are affected wherever the `hid-sensor-custom` module is loaded. No public exploit code exists and no CISA KEV listing is present, but kernel-space use-after-free conditions carry inherent privilege-escalation potential.
Use-after-free in the Linux kernel Bluetooth RFCOMM subsystem allows an adjacent Bluetooth peer to trigger kernel memory corruption via a race condition in rfcomm_security_cfm(). The function looks up a session and iterates its DLC list without holding rfcomm_mutex, so a concurrent krfcommd teardown (which does hold the mutex) can free the session and its DLCs while hci_rx_work is still traversing them. KASAN confirmed slab-use-after-free at rfcomm_security_cfm+0x41c. No public exploit or CISA KEV entry exists at time of analysis, and EPSS is 0.20%.
Out-of-bounds read and write in the Linux kernel's ocfs2 refcount block validator allows a local privileged attacker to corrupt kernel memory via a crafted or corrupted filesystem image. The `ocfs2_validate_refcount_block()` function fails to validate `rl_used` and `rl_count` fields against the actual fixed per-block capacity before refcount/reflink/CoW operations walk the record array, allowing a crafted `rl_used == 0xffff` to drive the loop 65534 iterations past the end of the 4096-byte metadata block. A subsequent `memmove()` of up to ~1 MiB from an already out-of-bounds offset in `ocfs2_insert_refcount_rec()` can corrupt arbitrary kernel memory. No public exploit and no KEV listing; EPSS is 0.20% reflecting realistic low exploitation probability.
State machine corruption in the Linux kernel's Thunderbolt networking (tbnet) subsystem allows an adjacent attacker to trigger a double-teardown sequence that causes kernel panics or silently frees HopIDs still in use by other connections. The bug lies in tbnet_connected_work(): every failure path returns without clearing login_sent, so the connection appears established to tbnet_tear_down(), which then re-executes teardown on an already-unwound state - stopping rings already stopped (a dev_WARN, fatal under panic_on_warn) and potentially double-freeing net->remote_transmit_path on HopID mismatch paths. No public exploit code has been identified at time of analysis; EPSS stands at 0.20%.
Use-after-free in the Linux kernel's iommufd selftest IOPF reporting enables local privilege escalation from low-privileged users to kernel-level code execution. The race condition exists between TRIGGER_IOPF's unsynchronized borrow of a PASID attach handle and a concurrent PASID detach that frees the backing iommufd_attach_handle struct, leaving iommu_report_device_fault() dereferencing freed memory. No public exploit code exists and EPSS is low (0.20%), but kernel UAF primitives of this class are routinely leveraged for privilege escalation on affected systems.
Unchecked device-controlled address in the mt7915 WiFi driver's EEPROM copy path allows a malicious or compromised MT7915 MCU to trigger a 16-byte out-of-bounds heap write in the host kernel. The driver's mt7915_mcu_get_eeprom() trusts the MCU response field res->addr (a device-supplied __le32) as a destination offset into eeprom.data without validating it against the buffer's bounds, enabling arbitrary kernel heap corruption. No public exploit has been identified at time of analysis, and EPSS probability is 0.20%; however, successful exploitation of the OOB write could yield kernel code execution or denial of service on any Linux host equipped with an MT7915-based adapter.
Out-of-bounds write in the STM32 CEC driver (media/cec/platform/stm32) allows an adjacent attacker on the same HDMI CEC bus to corrupt kernel memory by sending an overlong CEC frame. The stm32_rx_done() IRQ handler appends each received byte to a fixed 16-byte rx_msg.msg[] buffer using rx_msg.len as an unsanitized write index; a peer device that withholds the EOM signal drives RXBR interrupts indefinitely, writing attacker-controlled bytes past the end of the array into adjacent kernel structures. This vulnerability is reachable as soon as the STM32 CEC driver has probed and reception is enabled, with no local privilege or prior authentication on the CEC bus. No public exploit is identified at time of analysis; the fix is available in stable releases.
Use-after-free in Linux kernel NFSD's copy-notify stateid management (NFSv4.2 server-to-server copy) allows an authenticated NFS client to trigger a KASAN-detectable UAF at nfs4_put_cpntf_state() by racing OFFLOAD_CANCEL or laundromat expiry against concurrent stateid readers. Three separate revoke paths were affected: the parent-stid drain (nfs4_free_cpntf_statelist()), OFFLOAD_CANCEL via manage_cpntf_state(), and laundromat tick expiry. No public exploit or CISA KEV listing exists; EPSS is 0.17% (6th percentile), and real-world impact is DoS-leaning with theoretical memory disclosure.
IOMMU Stream ID aliasing in the Linux kernel's Tegra241 CMDQV driver allows a guest-controlled VMM to break IOMMU isolation by supplying an oversized virtual Stream ID. The bounds check in tegra241_vintf_init_vsid() only rejects values exceeding UINT_MAX, but the SID_MATCH register's VIRT_SID field is only 20 bits wide; the 'virt_sid << 1 | 0x1' encoding silently truncates bits above position 20, causing a value like 0x80000000 to alias SID_MATCH to vSID 0 and route the IOMMU entry to the wrong DMA Stream ID. Because vdev->virt_id is guest-controlled under CMDQV virtualization, an attacker with guest VM access can break tenant isolation and gain C:H/I:H/A:H access across the IOMMU boundary to host memory and devices. No public exploit is identified at time of analysis; EPSS is 0.17%, consistent with the narrow Tegra241 hardware-specific attack surface.
Silent inode metadata loss in the Linux kernel ext2 filesystem affects all systems using ext2 with IS_SYNC inodes: calls to `sync_inode_metadata()` in `ext2_setsize()` and `ext2_xattr_set2()` were guarded by an IS_SYNC branch that skipped `mark_inode_dirty()`, meaning that if the inode was not already dirty, the sync was a no-op and metadata changes were silently discarded. Affected operations include file truncation and extended attribute writes on synchronous ext2 mounts. No public exploit code exists and EPSS is 0.15%, consistent with a data-integrity correctness fix rather than a security-critical attack surface.
Use-after-free in the Linux kernel NFS-over-RDMA server (svcrdma) allows an adjacent-network attacker to trigger kernel memory corruption when an RDMA_CM_EVENT_ADDR_CHANGE event coincides with a replacement listener cm_id allocation failure, leaving sc_cm_id pointing to a destroyed object. Subsequent kernel operations that dereference sc_cm_id - most immediately rdma_disconnect() in svc_rdma_detach() - read or write freed kernel memory, with potential impacts on confidentiality, integrity, and availability. No public exploit or CISA KEV listing exists at time of analysis; EPSS is 0.15% (5th percentile), consistent with the niche NFS-over-RDMA server attack surface.
Integer overflow in RISC-V KVM's SBI PMU EVENT_GET_INFO handler allows a guest VM to trigger out-of-bounds heap reads and writes on the host kernel, with scope-changed impact (C:H/I:H/A:H). A malicious or compromised guest on a RISC-V host running KVM can supply a crafted num_events value (e.g., 0x10000001 on RV64) that overflows a 32-bit multiplication, causing under-allocation of the event-info array while the subsequent loop iterates over the original large count - resulting in slab-out-of-bounds memory corruption confirmed by KASAN traces. No public exploit code exists and EPSS is 0.15%, but the scope change to the host kernel makes this a VM-escape class finding for RISC-V KVM deployments.
Out-of-bounds write in the Linux kernel mt76/mt7996 WiFi driver allows a malicious or malfunctioning MediaTek mt7996 chip to corrupt kernel heap memory. The vulnerability exists in mt7996_mcu_get_eeprom(), which derives a destination offset into dev->mt76.eeprom.data from a device-controlled field (event->addr, a __le32 in the MCU response) without bounding that offset before performing the EFUSE/EXT block copy. A compromised or deliberately crafted mt7996 device can trigger an OOB write of up to MT7996_EXT_EEPROM_BLOCK_SIZE bytes into kernel memory, with potential for privilege escalation or denial of service. No public exploit is identified at time of analysis and EPSS is 0.15%, consistent with the narrow attack surface requiring hardware-level adversarial control.
Heap buffer overflow in stb_vorbis through 1.22 allows remote attackers to crash or corrupt the heap of any application that parses attacker-supplied Ogg Vorbis audio. The root cause is an integer truncation bug in start_decoder() where the codebook multiplicands allocation size is computed as a size_t but narrowed to int before being passed to the allocator, enabling a heap undersizing condition triggerable by crafting codebook entries and dimensions values that overflow the int range. No public exploit code or active exploitation is confirmed, but the no-interaction network vector makes this impactful for any service that accepts Ogg Vorbis input from untrusted sources.
Privilege escalation in Shopper Framework v2.8.0-v2.9.1 allows any authenticated staff member holding only the read-only view_users permission to perform three critical administrative actions: self-escalate by granting arbitrary permissions to their own role, create new admin-privileged team members with attacker-chosen credentials, and delete RBAC roles causing cascading privilege loss for all affected users. The flaw is a direct regression of the partially-applied security fix in PR #511 (GHSA-f946-9qp6-vgch) - three Livewire component authorization gates were left checking view_users instead of access_setting, including one gate in a file introduced by the security fix commit itself. No external exploit tooling has been identified at time of analysis, but Shopper's own regression test suite at commit fcd0c59 functions as documented proof-of-concept, with view_users-only actors passing all three attack-path tests.
PHP Object Injection in the Masteriyo LMS WordPress plugin (versions <= 3.4.0) allows remote attackers to inject a crafted serialized PHP payload, potentially enabling arbitrary code execution via a PHP gadget chain present in the environment. The vulnerability is described as unauthenticated in the Patchstack disclosure title, though the supplied CVSS vector specifies PR:L - a discrepancy that materially affects real-world risk assessment and requires vendor clarification. No public exploit code or CISA KEV listing has been identified at time of analysis.
Privilege escalation in the SMS Alert Order Notifications WordPress plugin (versions ≤ 3.9.9) allows any authenticated subscriber - the lowest standard WordPress role - to elevate their account privileges, potentially gaining full administrative control over the affected site. The CVSS 8.8 score with PR:L confirms that only a low-privileged account is required, making exploitation accessible to any registered user on the platform. No public exploit code or active exploitation via CISA KEV has been identified at time of analysis.
Privilege escalation in the Gato GraphQL WordPress plugin (versions ≤ 19.2.3) allows authenticated subscribers - the lowest registered-user role in WordPress - to elevate their access beyond their assigned privileges. The root cause is CWE-266 (Incorrect Privilege Assignment), where the plugin's GraphQL endpoint handling fails to properly gate privileged operations against low-privilege requestors. No confirmed active exploitation or public POC is identified at time of analysis, but the trivially low access bar of a subscriber account combined with full CIA impact makes this a high-priority finding for any WordPress installation running this plugin.
Cross-origin WebSocket hijacking in Headroom's proxy layer (prior to v0.35.0) allows an unauthenticated attacker-controlled webpage to issue arbitrary LLM requests through the victim's Headroom instance without authentication. Because the WebSocket server forwards requests to the upstream LLM provider without validating the Origin header, any browser with network access to the proxy-standard or headless-can be weaponized as a relay. The primary concrete impact is unauthorized consumption of the stored OpenAI API key and potential exposure of LLM response content; no public exploit code or CISA KEV listing has been identified at time of analysis.
XXE injection via the XSLT Transformer Step in NextGen Mirth Connect (versions ≤4.7.1) allows unauthenticated network attackers to exfiltrate arbitrary server-local files through an out-of-band HTTP callback, and to deny service to the targeted processing channel. The root cause is a bare Java TransformerFactory instantiated without disabling external entity resolution (CWE-611). Full public proof-of-concept code exists at GitHub; CISA published ICS-Medical advisory ICSMA-26-253-01 on 2026-09-10, and the vendor-confirmed fix ships in version 4.7.2.
Command injection in Puppet Enterprise's java_keystore_passwd parameter handling allows authenticated Puppet administrators to execute arbitrary OS commands with root privileges. The parameter value is passed to a shell execution context without sanitization, enabling full system compromise from a high-trust but network-accessible role. No public exploit code or CISA KEV listing has been identified at time of analysis.
Unauthenticated remote denial of service in Net-SNMP through 5.9.5.2 allows any network-reachable attacker to permanently suspend all SNMP processing by connecting to the SMUX listener and withholding data. The root cause is smux_accept() issuing a blocking recv() call with no timeout on every newly accepted SMUX connection, stalling snmpd's single-threaded main loop indefinitely. Because the block is permanent and snmpd performs all SNMP agent work in that same thread, the entire agent - monitoring, traps, polling - ceases until the process is manually restarted. No public exploit identified at time of analysis, though a researcher gist documenting the behavior is publicly linked in the advisory.
WeenyGenius, a computer lab management system by Howyar Technologies, exposes its endpoint communication protocol without any authentication, allowing any adjacent-network attacker to impersonate either student or teacher roles. The teacher-impersonation path is the critical vector: posing as a teacher causes student workstations to initiate management connections back to the attacker, yielding remote control over every student endpoint in the lab. No public exploit code and no CISA KEV listing have been identified at time of analysis, but the zero-privilege, zero-interaction requirement within a reachable network makes exploitation straightforward for any insider or network-adjacent threat actor.
Server-Side Request Forgery in Google Cloud Gemini Enterprise Agent Platform App Builder (all versions prior to the 2026-06-01 deployment date) enables unauthenticated remote attackers to exfiltrate the Compute Engine default service account access token by forcing the application to issue requests to the GCP instance metadata service. The stolen OAuth 2.0 bearer token carries the IAM permissions of the default service account, potentially enabling lateral movement across GCP project resources. Vendor-released patch was deployed on 1 June 2026, but existing app deployments require a manual redeployment to receive the fix - creating remediation lag risk for unmanaged deployments.
Improper authorization in OpenMRS allows any authenticated low-privilege user to invoke the `startHl7ArchiveMigration` DWR service, an administrative method that should be restricted to admin-level accounts. Affected versions are OpenMRS core prior to 1.23.0 (1.x branch) and prior to 2.10.0 (2.x branch), both patched by their respective releases. No public exploit has been identified at time of analysis, though exploitation requires only a valid session, keeping the practical barrier low for any credentialed system user.
OS command injection via filename manipulation in an ICS file-transfer interface allows authenticated network attackers to execute arbitrary commands with the privileges of an automated processing service. The flaw, tracked under ICSA-26-254-01 and reported by CISA ICS-CERT, affects a log-ingestion workflow where attacker-supplied filenames containing shell metacharacters are passed unsanitized to a system call. Successful exploitation enables read and write access to ingested operational log data and may serve as a pivot point for lateral movement within the operational technology network segment.
Origin validation failure in WeenyGenius, Howyar Technologies' computer lab management system, allows any unauthenticated attacker adjacent to the school network to impersonate the teacher workstation by sending spoofed broadcast packets. Student machines running the WeenyGenius client accept these packets without verifying their source, causing them to initiate management connections to the attacker's host. No public exploit has been identified at time of analysis, but the zero-complexity adjacent-network attack makes exploitation trivially feasible by any insider - including students - on the same LAN.
WeenyGenius computer lab management software by Howyar Technologies transmits control commands over ZMTP Null mode - ZeroMQ's no-authentication, no-encryption transport - leaving all management traffic exposed on the local network. Unauthenticated adjacent-network attackers can passively capture plaintext session data or actively replay forged classroom commands to disrupt exams and lesson control. No public exploit has been identified and the vulnerability is not listed in CISA KEV, but the attack requires only standard network tooling and network adjacency.
Remote Code Inclusion in Brainzcompany Zenius EMS 8.0 (through OAM Build 109) is achievable by unauthenticated attackers on an adjacent network who bypass authentication via an alternate path or channel (CWE-288) compounded by improper syntactic input validation. The two-weakness combination allows an attacker to cause the server to include and execute attacker-controlled remote code, yielding full compromise of confidentiality, integrity, and availability. No public exploit code or CISA KEV listing has been identified at time of analysis.
Unauthenticated arbitrary file read in Dolibarr 23.0.4 through 24.0.0 allows remote attackers to exfiltrate sensitive data by exploiting a hardcoded bypass value in the document access endpoints. Supplying hashp=shared in requests to htdocs/document.php and htdocs/viewimage.php satisfies the authorization condition without a valid token, granting read access to application logs, uploaded business documents, database backups containing password hashes, and files across multicompany tenant boundaries. No public exploit has been identified at time of analysis, but the VulnCheck advisory fully discloses the bypass mechanism and exact parameter value.
XXE injection in NextGen Mirth Connect allows unauthenticated remote attackers to exfiltrate arbitrary files from the server and trigger denial-of-service conditions when XML batch processing is enabled with the XPath option selected. The vulnerability stems from the absence of entity restrictions in the default XPath/JAXP XML parser configuration, permitting malicious external entity declarations to be resolved. A CISA ICS Medical advisory (ICSMA-26-253-01) and a researcher blog post confirm this affects healthcare integration infrastructure; no public exploit identified at time of analysis.
Unauthenticated file read in WWBN AVideo's getRecordedFile.php endpoint exposes recorded live-stream FLV files to any network attacker without authentication or authorization. All AVideo deployments through commit c3edcc274c389816d434acadac07ee78eaf330c1 are affected. An attacker who can reach the web interface and supply a known or guessed stream key can silently download private recorded video content, with no public exploit or KEV status confirmed at time of analysis.
Use-after-free in Microsoft Edge (Chromium-based) enables an authenticated network attacker to achieve remote code execution with scope change across all supported platforms including Windows, Linux, macOS, Android, and iOS. The vulnerability carries a CVSS 8.5 with high complexity and scope change (S:C), indicating that successful exploitation escapes the browser's sandboxing boundary and affects the underlying host. No public exploit or CISA KEV listing is present at time of analysis, though patch-available status from Microsoft confirms vendor acknowledgment.
Sensitive credential hash exposure in ST Engineering iDirect VSAT terminals allows any authenticated web user to retrieve the complete device configuration - including MD5-crypt password hashes for root SSH and web admin accounts - from a single API endpoint. The iQ-series, 3315-series, and 9-series terminal families are all confirmed affected, with no patched version currently identified. Because MD5-crypt is computationally weak against modern GPU-based cracking tools, successful hash extraction typically escalates to full root-level device compromise. Reported by ICS-CERT under advisory ICSA-26-183-01; no public exploit code or active exploitation has been identified at time of analysis.
SSRF fix bypass in FrontMCP v1.2.1 and its dependency mcp-from-openapi 2.3.0 allows authenticated users of hosted deployments to reach internal network services by supplying crafted OpenAPI specs containing external `$ref` URLs. The previous patch for CVE-2026-39885 introduced a hostname-string denylist that is circumvented via DNS names resolving to loopback (e.g., 127.0.0.1.nip.io), HTTP redirect chains to loopback after an initially allowed host, and IPv4-mapped IPv6 syntax (::ffff:127.0.0.1). A working proof-of-concept with five confirmed bypass vectors is included in the advisory; no CISA KEV listing exists at time of analysis.
Out-of-bounds read in Linux kernel ACPI APEI GHES ARM hardware error handler arises from using pointer size instead of structure size when accounting for remaining CPER buffer after skipping the cper_sec_proc_arm header. Affected are stable branches 6.12.x through 6.12.109, 6.18.x through 6.18.50, 7.x through 7.2.4, and pre-7.3-rc1, on ARM systems with ACPI APEI support. No public exploit identified at time of analysis; EPSS is 0.20% (10th percentile), and there is no CISA KEV listing, consistent with a low automated exploitation probability.
Out-of-bounds read and write in the Linux kernel's Chrome EC sensorhub driver exposes Chromebook-class systems to kernel heap corruption via an unvalidated 8-bit sensor number in EC FIFO events. The cros_ec_sensor_ring_process_event() function indexes batch_state[] using the sensor_num field from embedded-controller events without checking it against the allocated array size, allowing any event carrying sensor_num >= sensorhub->sensor_num to access arbitrary adjacent kernel heap memory. No public exploit or CISA KEV listing exists; EPSS is 0.20%, but the C:H/I:H/A:H CIA impact reflects the potential for kernel memory corruption on affected Chrome EC hardware.