Remote Code Execution

Reflected XSS in Netron desktop application versions ≤9.1.2 executes attacker-controlled JavaScript when a victim opens a crafted neural network model file containing malicious node names, type labels, or value descriptions. Because Netron runs on Electron (a Chromium-based runtime), the injected script operates within a privileged renderer process capable of port-scanning local networks and, with a separately-acquired Chrome n-day, achieving full remote code execution on the host machine. HiddenLayer reported the vulnerability and a vendor fix is available via GitHub commit cd14bad8c91; no public standalone exploit has been confirmed and this CVE does not appear in CISA KEV.

Arbitrary code execution across entire WordPress multisite networks is possible in the Defender Security plugin (versions 5.0.0 through 6.1.x) due to a missing access control check on a network-wide setting. Any site-level administrator on a multisite installation - a role with significantly lower trust than a network/super administrator - can modify this setting to inject and execute code affecting all sites on the network. No public exploit has been identified and EPSS stands at 0.17% (6th percentile), but SSVC rates technical impact as 'total', consistent with the network-wide RCE consequence if exploited by a malicious or compromised site admin.

OS command injection in Comfast CF-WR630AX firmware v.2.7.0.2 allows an adjacent-network attacker with administrator-level credentials to execute arbitrary OS commands through the device's web management interface and CGI endpoint via unsanitized parameters. A public proof-of-concept exploit is available on GitHub, though EPSS probability remains very low (0.19%, 9th percentile), indicating minimal observed exploitation activity. No active exploitation has been confirmed by CISA KEV, and the AV:A/PR:H CVSS vector materially constrains the realistic attacker population.

Cross-site scripting across three components of Cockpit CMS (item.php, field-select.js, and tags.js) enables remote attackers to inject and execute malicious JavaScript within authenticated users' browser sessions in versions 2.13.5 and prior. The CVSS Scope:Changed metric signals that impact extends beyond the vulnerable component - successful exploitation against an authenticated administrator can result in session hijacking, credential theft, or persistent content manipulation within the CMS. No active exploitation is confirmed (no CISA KEV listing; EPSS 0.30% / 23rd percentile), though a researcher repository at github.com/Securify-AI/CVE-2026-39275 exists as a potential POC reference.

Memory corruption in Das U-Boot's ZFS filesystem driver (all releases before 2026.04) lets an attacker who controls the on-disk ZFS metadata trigger an integer overflow (CWE-190) that leads to undersized allocation and out-of-bounds access, enabling a boot-time crash or arbitrary code execution in the pre-OS bootloader context. Rated CVSS 9.8 by the reporter, but the flaw is reached only when U-Boot parses attacker-supplied ZFS storage during boot, so realistic exploitation is local/physical rather than network-borne. EPSS is low (0.17%, 7th percentile) and there is no confirmed active exploitation.

Remote code execution in Cohere North AI v1.1.5 arises from an arbitrary file upload flaw in the /v1/my_drive/batch_upload endpoint, where insufficient validation of uploaded file type/content lets an attacker place a malicious file that the server subsequently executes. The affected component is part of Cohere's North enterprise AI knowledge platform, and successful exploitation yields full compromise of confidentiality, integrity, and availability. No public exploit is identified in the intelligence feeds, though a third-party technical write-up exists on GitHub; EPSS is low (0.15%, 5th percentile), indicating limited observed exploitation activity to date.

Heap-based buffer overflow in Das U-Boot (the Denx universal embedded bootloader) before 2026.04 allows an attacker who controls an ext4 filesystem image to trigger an integer overflow in the ext4fs_get_bgdtable() block-group descriptor table size calculation, resulting in an undersized allocation that is later overrun by memcpy(). Successful exploitation can lead to arbitrary code execution in the highly privileged pre-OS boot context, denial of service, or memory corruption. No public exploit identified at time of analysis (a referenced GitHub gist may contain a proof-of-concept but is unverified), EPSS is low at 0.18% (7th percentile), and it is not listed in CISA KEV.

Kimai's Twig invoice template sandbox fails to block the getApiToken() and getPlainApiToken() User methods, allowing admins with template creation permissions to exfiltrate hashed API tokens from any user who generates an invoice using that template. Affected are OnPremise deployments of Kimai before 2.53.0 where invoice template upload is enabled and admins hold the manage_invoice_template permission. No public exploit is independently confirmed, but the GHSA advisory includes complete proof-of-concept reproduction steps; the CVSS 4.0 score of 2.0 reflects the high prerequisite access level and limited confidentiality impact. Note: the 'RCE' tag present in source intelligence appears to be a mis-tag - the vulnerability is information disclosure, not remote code execution.

Unbounded recursive referrer traversal in ORAS CLI versions through 1.3.2 allows a malicious OCI registry to trigger client-side denial of service by returning a cyclic referrer graph. Because neither `fetchAllReferrers` in the discover path nor `RecursiveFindReferrers` in the backup/restore graph logic tracked visited descriptors, a minimal two-node cycle (A→B→A) is sufficient to exhaust heap memory and CPU on the connecting client. No public exploit has been identified at time of analysis, though the fix commit and its accompanying regression tests make the attack pattern trivially reproducible. A patched release, version 1.3.3, is available.

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.

Code injection in Google Chrome's Bisection component allows remote attackers to exfiltrate sensitive information by enticing a user to open a crafted file. Affected versions are all Chrome releases prior to 152.0.7977.65 across desktop platforms. The vulnerability carries a CVSS 6.5 Medium rating with high confidentiality impact; no public exploit has been identified and EPSS sits at 0.19% (8th percentile), indicating minimal active exploitation pressure at time of analysis. Vendor patch is confirmed available.

Command injection in NVIDIA UFM Enterprise's IBDiagnet API allows an authenticated administrator with adjacency-level network access to execute arbitrary OS commands on the host system, potentially achieving full compromise. All major release trains are affected - GA, LTS 2023, LTS 2024, and LTS 2025 - as confirmed by NVIDIA's own advisory and NVD CPE data. No public exploit code or CISA KEV listing has been identified at time of analysis, keeping real-world opportunistic risk constrained by the high privilege and network adjacency prerequisites.

Command injection in NVIDIA UFM Enterprise's user management component enables an authenticated administrator to execute arbitrary OS-level commands by sending a crafted API request, spanning all active release tracks (GA, LTS 2023, LTS 2024, LTS 2025). Successful exploitation can yield full code execution on the UFM host, privilege escalation beyond the administrative role, and disclosure of sensitive InfiniBand fabric management data. No public exploit code or CISA KEV listing has been identified at time of analysis, and the adjacent network attack vector (AV:A) constrains the realistic attacker population to those with both admin credentials and access to the management network segment.

Integer overflow leading to out-of-bounds write in NI LabVIEW 2026 Q3 and prior enables information disclosure or arbitrary code execution when a user opens a specially crafted VI file. The attack is file-based and requires social engineering to deliver a malicious Virtual Instrument file to a target, making it a credible threat in engineering, research, and industrial automation environments where VI files are routinely shared. No public exploit identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.

Out-of-bounds read in NI LabVIEW 2026 Q3 and all prior versions can result in information disclosure or arbitrary code execution when the application processes a maliciously crafted VI file containing a specially structured image. The root cause is a signed-to-unsigned integer conversion error (CWE-195) in the image-loading code path, causing the parser to read beyond intended memory boundaries. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA Known Exploited Vulnerabilities catalog.

Stack buffer overflow in Zephyr RTOS's virtio PCI driver (drivers/virtio/virtio_pci.c) allows a malicious virtio device to corrupt the kernel stack with up to ~228 bytes of device-controlled data, or trigger a near-unbounded write via unsigned underflow, during boot-time device probe. All Zephyr versions are potentially affected (CPE: cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:*) when compiled with CONFIG_ASSERT disabled, which is the production default. Exploitable scenarios are limited to bare-metal systems with untrusted physical or passthrough virtio PCIe devices, or confidential computing deployments where the Zephyr guest must be defended against a potentially malicious hypervisor. No public exploit identified at time of analysis; upstream patch is available at commit d98dacee.

Path traversal in SKYSEA Client View and SKYMEC IT Manager enables a locally-authenticated Windows user to execute arbitrary code on remote Windows systems running the same software via UDP communication channels. This is an incomplete-fix bypass of CVE-2024-41726, reported by JPCERT/CC, meaning the original remediation failed to neutralize all traversal variants. No public exploit has been identified at time of analysis, but the subsequent-system impact is maximal (SC:H/SI:H/SA:H per CVSS 4.0), indicating full lateral compromise potential within enterprise environments deploying these management agents.

Lateral code execution via path traversal in SKYSEA Client View and SKYMEC IT Manager allows a low-privileged user authenticated to one Windows host running the software to execute arbitrary code on other Windows hosts where the product is installed, provided those targets are reachable via UDP. The vulnerability (CWE-22) is a bypass of the incomplete patch for CVE-2024-41726, meaning prior remediation efforts are insufficient. No public exploit code or CISA KEV listing has been identified at time of analysis, but the RCE-class impact on subsequent systems - reflected in CVSS 4.0 SC:H/SI:H/SA:H - makes this a meaningful lateral movement risk in enterprise environments running SKY Co. products.

Stack-based buffer overflow in SKYSEA Client View and SKYMEC IT Manager (SKY Co., Ltd.) enables an authenticated attacker to remotely execute arbitrary code on other Windows hosts running the same software via crafted UDP packets. The vulnerability functions as a lateral movement primitive: an attacker who has already obtained a login on one managed endpoint can exploit the product's UDP listener on any other reachable managed host, without requiring further interaction from the target. Reported by JPCERT/CC via JVN#JVN33423625, no public exploit or CISA KEV listing has been identified at the time of analysis.

Out-of-bounds write in Zephyr RTOS's ext2 filesystem driver enables supervisor-mode memory corruption when a device mounts a crafted ext2 image from a physical storage medium such as an SD card. The driver's superblock validation function omits bounds-checking the s_log_block_size field, allowing an attacker-controlled value to produce an inflated block size that silently misconfigures the kernel memory slab allocator beyond its static backing buffer, with impact ranging from denial of service to potential code execution in kernel mode. No confirmed active exploitation or public POC is identified at time of analysis; a vendor patch is available as upstream commit f270f4bd0e59585da31e1fbaa79c5abf73f1364b.

Local File Inclusion in the Events Manager WordPress plugin (all versions through 7.3.7.4) allows an administrator-level attacker to store a malicious PHP file traversal path via the em_options_save function, which is then executed without any further authentication on every admin_init hook invocation - including unauthenticated admin-ajax.php requests. The two-phase attack converts a high-privilege write primitive into a persistent, unauthenticated code execution trigger that survives account remediation until the stored option is manually purged. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.

Cross-site scripting with CSP bypass in Adminer before 5.4.3 enables arbitrary JavaScript execution in the browser of any user who connects to an attacker-controlled MySQL server. The vulnerability stems from unsanitized MySQL server version strings being injected directly into script tags that carry valid Content Security Policy nonces, effectively nullifying CSP protections. No public exploit code or CISA KEV entry has been identified at time of analysis, but the attack is meaningful against administrators and developers who routinely connect Adminer instances to external or third-party MySQL servers.

Remote code injection in provectus kafka-ui up to version 0.7.2 allows a low-privileged authenticated attacker to execute arbitrary Groovy code on the server via the smart filter test endpoint. The vulnerability resides in the executeSmartFilterTest function of MessagesController.java, where user-supplied Groovy expressions are evaluated without adequate sandboxing or restriction. A publicly available proof-of-concept exploit exists, no vendor patch has been released, and the project maintainers have not responded to the responsible disclosure report.

Command injection in the D-Link DI-7001 MINI_5G router (firmware 19.10.31A1) allows unauthenticated attackers on the adjacent network to execute arbitrary OS commands via the `flag` parameter of the `msp_info` endpoint. The vulnerability is rooted in CWE-77 (improper neutralization of command-special elements), and a public proof-of-concept writeup has been published on GitHub, lowering the exploitation bar. No active exploitation has been confirmed by CISA KEV, and EPSS sits at 0.17% (6th percentile), indicating limited observed exploitation activity at time of analysis.

Remote code execution in D-Link DI-8100G firmware 17.12.20A1 is achievable by unauthenticated attackers positioned on the adjacent network via a crafted `flag` parameter in the `msp_info` CGI handler. The flaw (CWE-94, Code Injection) permits full compromise of device confidentiality and integrity with no privileges or user interaction required, yielding a CVSS 8.1 (High) rating. A researcher-published proof-of-concept exists on GitHub; however, no active exploitation has been confirmed by CISA KEV, and the EPSS score of 0.17% reflects low observed exploitation probability at the time of analysis.

In the Linux kernel, the following vulnerability has been resolved: mm/vmalloc: acquire init_mm lock on huge vmap to avoid ptdump UAF Patch series "mm: fix UAF caused by race between ptdump and vmap pgtable freeing", v6. Kernel page table walkers fall into two broad categories - those ranges where no exclusion is required via walk_kernel_page_table_range_lockless() and those where exclusion is required via walk_kernel_page_table_range() or walk_page_range_debug(). The former category is used only by arm64 arch code operating on ranges it both wholly owns and does not concurrently write. The latter category consists of kernel page table walkers operating on ranges that are wholly owned (but which need exclusion against concurrent writers). The lock used for exclusion is the mmap lock, and for kernel ranges this is the mmap lock on init_mm. ptdump is a special case being both the only user of walk_page_range_debug(), and the only case in which it walks ranges it does not own. This presents a problem, as page tables may be freed under ptdump. And indeed there is a use-after-free bug in the kernel as a result, which this series addresses. vmap promotes page tables to huge leaf entries where possible, freeing the lower page table when it does. It does this with no meaningful locks held against concurrent ptdump walks. As a result, use-after-free can currently occur. This series addresses the issue by having the vmap huge promotion logic acquire the mmap read lock while both setting the huge page table entry and freeing the prior leaf page table. The ptdump code already acquires the mmap write lock, so by doing so we ensure that the ptdump walker only ever observes either the huge page table entry or the existing page table entry, and nothing is freed underneath it. A mitigation for this issue was already applied for arm64 in commit fa93b45fd397 ("arm64: Enable vmalloc-huge with ptdump"), which this series has to deal with carefully. This mitigation resolves the issue by acquiring the mmap read lock on init_mm on vmap page table free if a ptdump is in progress. However the fix in this series would cause a deadlock if we were to simply apply it for arm64 without also reverting the change. This is because vmap may acquire the read lock before ptdump attempts to acquire the write lock, which then gets queued, and rwsem starvation rules mean that the (unacknowledged) nested mmap read lock in the arm64 code would also block, meaning the original read lock is never released and thus deadlock. This series works around this by #ifndef CONFIG_ARM64'ing the mmap read lock in vmap logic, then partially reverting commit fa93b45fd397 ("arm64: Enable vmalloc-huge with ptdump"), keeping the enablement of huge vmap support, and removing the ifdeffery with the partial revert patch. There are related issues that are also addressed in this series: * x86 page attribute logic, specifically Change Page Attributes (CPA), implements a feature whereby huge ranges can be collapsed into huge leaf entries. This can similarly cause a UAF when done in parallel with a ptdump walk, so similarly acquire the init_mm mmap lock to avoid this. * The CPA logic allows concurrent page table manipulation and CPA collapse, meaning the former risks accessing a page table the latter frees. Fix this by acquiring mmap write lock on init_mm across the whole CPA collapse operation and read lock on the page table manipulation. * x86 and arm64 permit walks of non-kernel mm's (both allowing efi mm walks, and in x86's case arbitrary mm's), so we ensure kernel mappings remain stable by locking the init_mm as well as the mm being walked. The ordering of patches is established for both strict dependencies (the arm64 partial revert in particular has to be done after the vmap changes) and logical ones (the non-kernel mm fix only makes sense once the vmap/CPA fixes are in place). This patch (of 3): Currently there is a nasty ra ---truncated---

Unauthenticated shortcode injection in the kk Star Ratings - Rate Post & Collect User Feedbacks WordPress plugin (all versions through 5.4.10.3) allows any remote, unauthenticated attacker to execute arbitrary WordPress shortcodes by supplying a crafted payload to the plugin's AJAX handler. The flaw exists because the wp_ajax_kk-star-ratings action passes a user-controlled 'payload' parameter directly to do_shortcode() without allowlisting or sanitizing which shortcode tags are permitted. No public exploit has been identified at time of analysis and this CVE does not appear in the CISA KEV catalog; however, threat intelligence sources tag this as RCE, indicating that practical impact can escalate significantly depending on what shortcodes co-installed plugins register.

Parser state isolation failure in misp-stix corrupts MISP event generation when the same parser instance is reused across independent STIX 1 and STIX 2 document conversions, causing retained artifacts - including galaxy clusters, passive DNS records, package titles, dates, and timestamps - from a prior document to contaminate subsequently generated MISP events. Applications directly consuming the misp-stix API with long-lived parser instances are at risk; the standard entry points that instantiate a fresh parser per file are not affected. No public exploit has been identified at time of analysis, and the CVSS 4.0 AT:P precondition metric confirms exploitation depends on a non-default deployment pattern compounded by attacker influence over document processing order.

Heap-based buffer overflow in IBM AIX 7.2, 7.3 and PowerVM VIOS 4.1 enables a local authenticated attacker with high privileges to execute arbitrary code on affected systems. The vulnerability is rooted in improper memory management (CWE-787) and carries a CVSS 3.1 score of 6.7, reflecting the local access requirement and elevated privilege prerequisite that constrain real-world exploitability. IBM has released a patch via its support portal; no public exploit code or CISA KEV listing has been identified at time of analysis.

Out-of-bounds read in Capstone's SuperH (SH) architecture disassembler crashes the host process when fed crafted SH2A or SH4A bytecode. Versions 6.0.0-Alpha9 and earlier are affected when the library handle is configured with CS_ARCH_SH plus CS_MODE_SH2A or CS_MODE_SH4A and CS_MODE_SHFPU; the disassembler derives an idx value from a raw 16-bit instruction and dereferences a mode-specific decode[] function-pointer table without a bounds check. The demonstrated impact is limited to process termination - no code execution or information disclosure was shown - and a vendor-released patch is available in 6.0.0-Alpha10.

CRLF injection in the bandit Elixir HTTP server (versions 1.4.0 through 1.12.4) allows unauthenticated remote attackers to smuggle carriage-return, line-feed, or NUL characters into application-visible HTTP/2 request headers. Because HPACK carries arbitrary octets and bandit's HTTP/2 stream handler never validated field values for these control characters - unlike the HTTP/1 path which rejected them - a crafted HEADERS frame decodes cleanly and the malicious values reach downstream application logic unchanged. No public exploit or CISA KEV listing is identified; real-world impact is context-dependent and limited to how consuming application code handles raw header values (e.g., log injection, upstream request smuggling).

Remote code execution in Laravel Backpack CRUD's upload handling allows authenticated administrators to place PHP webshells in web-accessible storage by exploiting the lack of file extension validation inside `HasUploadFields` and `FileNameGenerator`. Affected are installations on the 6.x series before 6.8.14 and the 7.x series before 7.0.38 where the `public` disk with `storage:link` is in use and no explicit `mimes:` or `mimetypes:` Laravel validation rule guards upload fields - conditions common in quickstart-following deployments. No public exploit code has been identified and no CISA KEV listing is present at time of analysis; vendor-confirmed patches are available in releases 6.8.14 and 7.0.38.

Terminal escape sequence injection in Ember's interactive TUI allows unauthenticated remote attackers to smuggle ANSI/OSC/CSI control bytes into an operator's terminal by embedding them in HTTP requests sent to the monitored Caddy server. Ember's ParseLogLine restores raw control bytes from Caddy's unicode-escaped JSON access log, and the render helpers fitCellLeft and fitCellRight pass them unfiltered to os.Stdout via bubbletea's View(), enabling clipboard hijacking (OSC 52), dashboard spoofing (CSI cursor/erase), and window-title manipulation (OSC 0/2). No CISA KEV listing or confirmed public exploit exists at time of analysis; the 'RCE' tag in the intelligence metadata conflicts with the advisory's explicit statement that this is not general-case RCE and should not drive incident response decisions without independent verification.

Heap buffer overflow in SumatraPDF 3.6.1 and earlier enables an attacker who delivers a crafted CHM file to corrupt parser heap memory via malformed LZX Huffman code lengths. The PRETREE path in make_decode_table writes internal Huffman tree nodes beyond the 104-entry PRETREE_table boundary into adjacent struct LZXstate heap memory, reachable through the chm_open → chm_retrieve_object → LZXdecompress → BUILD_TABLE call chain. No public exploit or active exploitation is confirmed; arbitrary code execution has not been demonstrated, though the upstream fix commit validates that reliable heap corruption is achievable.

Arbitrary code execution is possible on Sony XAV-9500ES car AV receiver devices through a buffer overflow in the gpsd daemon's NMEA data processing, requiring the attacker to be physically present with the device. The flaw (CWE-120) stems from the absence of length validation before copying externally supplied NMEA input into a fixed-size stack or heap buffer within gpsd. Exploitation requires chaining with at least one additional vulnerability to achieve meaningful code execution, and no public exploit code or CISA KEV listing has been identified at time of analysis.

Out-of-bounds read in the prh_l2_decode_packet function of Sony XAV-9500ES car head unit firmware 3.02.0.0 exposes device memory contents to network-adjacent attackers over Bluetooth. Exploitation requires a malicious Bluetooth device to be paired with the target unit, after which crafted L2CAP packets trigger a read past the end of an allocated buffer, leaking sensitive memory. While the standalone impact is information disclosure, ZDI notes this vulnerability can be chained with additional flaws to achieve arbitrary code execution on the device; no public exploit identified at time of analysis.

Privilege escalation to root on the Kenwood DNR1007XR car navigation/dashcam device is possible for physically present attackers who already hold low-privileged code execution on the device. The USB filesystem mount point is configured with incorrect default permissions (CWE-276), allowing a low-privileged process to write to or manipulate that directory and escalate to root with full code execution capability. No public exploit code or active exploitation has been identified at time of analysis; the attack surface is inherently constrained by the physical access prerequisite and the embedded nature of the device.

Command injection in the Kenwood DNR1007XR automotive head unit's startUpdateProcess method allows physically present, unauthenticated attackers to execute arbitrary OS commands as root. The flaw stems from unsanitized user-supplied input passed directly to a system call inside the firmware update handler, granting full device compromise. No public exploit code has been identified at time of analysis, and exploitation is constrained by the requirement for physical device access.

Heap-based buffer overflow in the vCardParser class of the Kenwood DNR1007XR automotive multimedia receiver allows physically present, unauthenticated attackers to execute arbitrary code with root privileges. The flaw stems from missing bounds validation when copying attacker-controlled string data into a heap-allocated buffer during vCard contact parsing. No public exploit code or active exploitation has been identified at time of analysis; ZDI tracked this internally as ZDI-CAN-28974 and issued advisory ZDI-26-488.

Out-of-bounds write in Kenwood DNR1007XR firmware enables physically present, unauthenticated attackers to execute arbitrary code at root privilege via the tchdr_bytestream_read function. The device - an in-vehicle infotainment/navigation unit - fails to bounds-check user-supplied data during bytestream parsing, resulting in a heap or stack write past the allocated buffer. No public exploit or active CISA KEV listing has been identified at time of analysis, and real-world impact is materially constrained by the physical access prerequisite.

Root code execution on the Kenwood DNR1007XR in-vehicle navigation receiver is reachable by anyone with physical access to the device, requiring no authentication. The firmware update service improperly resolves symbolic links during file move operations (CWE-59), allowing an attacker who can write a symlink to the device filesystem to redirect that file operation to an arbitrary path and ultimately execute code with root privileges. No public exploit code or CISA KEV listing was identified at time of analysis; the ZDI advisory (ZDI-26-484) is the primary disclosure source.

Server-side request forgery and MVG code injection in n8n's Edit Image node allows authenticated low-privilege users to issue blind outbound HTTP requests or read local files by injecting ImageMagick MVG primitives into the Draw Text operation. All n8n versions before 1.123.69 are affected, confirmed by vendor advisory GHSA-233r-fpgw-fx8x. No public exploit identified at time of analysis, but the High confidentiality impact in the CVSS 4.0 vector signals meaningful data exfiltration risk for instances co-located with sensitive internal services or cloud metadata endpoints.

Arbitrary PHP code execution in Royal Addons for Elementor WordPress plugin (all versions before 1.7.1066) is reachable by any user holding the manage_options capability, including non-super subsite administrators on WordPress Multisite who would not otherwise have code-execution rights. The plugin writes unsanitized custom widget markup directly to a server-side file that is subsequently executed as PHP, enabling full server-side code injection. A publicly available exploit exists per WPScan; no CISA KEV listing at time of analysis, though the attack scenario is realistic for any WordPress Multisite deployment with delegated administration.

Remote code injection in chenhg5 cc-connect up to version 1.4.1 allows unauthenticated network attackers to execute arbitrary code by manipulating the `exec` argument passed to the `Authenticate` function in `core/webhook.go`. Tagged by reporters as RCE-capable, the vulnerability stems from unsanitized user input reaching a code execution path within the Go webhook handler. A public exploit has been disclosed; no patch has been released, as the upstream GitHub issue was closed automatically due to maintainer inactivity - leaving affected deployments without an official remediation path.

Remote code execution in Splunk Enterprise 10.4.x allows a high-privilege user with search head cluster (SHC) management rights to write files to arbitrary locations accessible by the Splunk service account via the SHC member bundle REST API. The API fails to enforce authorization boundaries and does not validate bundle paths before accepting content, enabling path-traversal-style writes that can deliver and trigger malicious payloads. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, but the RCE primitive makes this a meaningful risk in environments running Splunk 10.4 or 10.4.1 where high-privilege insider or compromised-account scenarios are plausible.

Splunk Secure Gateway's companion app registration handler contains a hard-coded cryptographic key, enabling any low-privileged authenticated Splunk user - explicitly excluding admin or power roles - to register an arbitrary attacker-controlled callback URL and cause Secure Gateway to forward mobile user requests and authentication tokens to that URL. Affected are Splunk Enterprise branches 9.4 (below 9.4.14), 10.0 (below 10.0.9), 10.2 (below 10.2.6), and 10.4 (below 10.4.2), alongside Splunk Secure Gateway branches 3.8 (below 3.8.71), 3.9 (below 3.9.24), and 3.10 (below 3.10.10). No public exploit code or active exploitation has been confirmed at time of analysis; however, the low attack complexity and minimal privilege requirement make this a credible insider-threat or post-compromise lateral movement vector in any environment running Splunk Mobile.

Stack out-of-bounds write in Zephyr RTOS's NVS settings backend affects all tracked versions via three sites in settings_nvs.c that use nvs_read()'s unclamped return value as a NUL-terminator index into a fixed 74-byte stack buffer. An actor with write access to the raw flash partition backing the settings subsystem can plant an oversized name entry that causes a single-byte stack write at an attacker-controlled offset whenever settings_load() or settings_save() processes it, reliably crashing the device. No public exploit identified at time of analysis; upstream fix is available at commit e79a0db but the exact first patched release is not independently confirmed.

Arbitrary code execution in IBM OpenBMC FW1060.00 through FW1060.80 is achievable via a path traversal flaw (CWE-22) in the BMC firmware update process, resulting in full confidentiality, integrity, and availability compromise of the baseboard management controller. Exploitation is constrained to authenticated administrators with adjacent network access to the BMC management interface, substantially limiting the real-world attack surface despite the high CIA impact. No public exploit code and no CISA KEV listing have been identified at time of analysis.

Out-of-bounds write in IBM AIX 7.2 and 7.3 and IBM PowerVM VIOS 4.1 enables a local, high-privileged attacker to execute arbitrary code. The vulnerability is rooted in a memory corruption flaw (CWE-787) that can corrupt adjacent memory regions during a write operation. No active exploitation has been confirmed by CISA KEV, and no public exploit code has been identified at time of analysis.

GitHub Actions workflow injection in Logto's commitlint.yml exposes versions 1.40.1 through 1.41.0 to arbitrary shell command execution on the project's CI/CD runner, triggered by any GitHub user who can submit a pull request with a crafted title containing shell metacharacters. The PR title was directly interpolated into an inline echo command without sanitization, allowing a single-quote character to terminate the shell string and inject attacker-controlled commands into the ephemeral runner environment. Impact is bounded by a read-only GITHUB_TOKEN and absence of exposed repository secrets; no public exploit is identified at time of analysis, and the issue is fully patched in v1.41.0.

Stack-based buffer overflow in IBM Server Firmware's FSP firmware update process allows an authenticated administrator with adjacent network access to execute arbitrary code on the Flexible Service Processor, fully compromising the server management plane across confidentiality, integrity, and availability. Affected firmware spans four major release trains (FW950 through FW1120) deployed on IBM Power Systems servers. No public exploit code has been identified at time of analysis and this vulnerability does not appear in the CISA KEV catalog, but the complete C:H/I:H/A:H impact profile makes patching a priority for any organization where FSP admin credentials or management network access could be shared or compromised.

YAML injection in volsync-addon-controller enables a highly privileged, network-capable attacker to break out of YAML value context when annotation values are rendered into OLM Subscription resources, allowing unauthorized modification of OpenShift operator lifecycle configuration. The root cause (CWE-94) is unsanitized interpolation of Kubernetes annotation strings into generated YAML, and the impact includes high integrity and availability consequences for cluster software management. Exploitation is gated behind high-privilege cluster access and the non-default 'volsync-addon-deploy-type: olm' annotation; no public exploit or CISA KEV listing has been identified at time of analysis.

SQL injection in Wazuh's File Integrity Monitoring subsystem allows a local low-privileged user on non-Windows systems to manipulate the FIM SQLite database by creating a specially crafted filename in any monitored directory. The `wazuh-syscheckd` daemon in versions 4.6.0 through 4.14.5 concatenates unsanitized file paths directly into SQLite row filter predicates in `DB::getFile()` and `DB::searchFile()`, enabling UNION SELECT injection when the path is processed. No public exploit or KEV listing exists; however, the vendor-merged PR test suite contains a working injection payload, and the impact - falsification or suppression of FIM integrity alerts - directly undermines the product's core security monitoring function.

Root-level code execution in Cisco RoomOS via the USB driver allows an unauthenticated attacker with physical access to a device's USB port to achieve full system compromise by connecting a malicious USB device. The vulnerability spans a wide range of RoomOS versions across the 10.x, 11.x, and 26.x release families, covering the Cisco Webex Room and Board series of video collaboration endpoints. No public exploit code has been identified at time of analysis and this CVE is not listed in the CISA KEV catalog, but the root-level impact (C:H/I:H) and the unattended nature of conference room hardware make this a meaningful physical security risk.

Remote code execution in Renovate's bazel-module and bazelisk managers exposes self-hosted instances running versions 43.65.0 through 43.102.11 to arbitrary code execution triggered by malicious Bazel dependencies. When lockFileMaintenance invokes 'bazel mod deps', dependency-provided code within ctx.execute statements executes directly on the Renovate host - enabling both insider and outsider supply chain attacks against affected configurations. No public exploit code has been identified at time of analysis, and a vendor-confirmed patch is available at 43.102.11.

Stack buffer overflow and off-by-one NUL-write vulnerabilities in the Sierra Wireless HL7800 cellular modem driver within Zephyr RTOS (versions 2.4.0 through 4.4.1) allow an attacker controlling a rogue LTE base station or a compromised modem baseband to crash or potentially execute arbitrary code in kernel context. Roughly twenty AT response handlers incorrectly size the destination argument to net_buf_linearize(), placing the null terminator one byte past a 128-byte stack buffer; the +KCELLMEAS handler is the most critical, passing the raw wire length as the destination size and enabling a full, attacker-content-driven stack overflow that runs in the driver's RX kernel thread. No public exploit has been identified at time of analysis, and this CVE does not appear in CISA KEV.

Absolute path traversal in NVIDIA Triton Inference Server for Linux exposes arbitrary filesystem files to low-privileged local attackers, with the vendor flagging potential code execution as a secondary consequence. The vulnerability is classified under CWE-36 and affects all versions captured by the wildcard CPE, meaning no upper-bound patched version is confirmed from current data. No public exploit code has been identified and this CVE does not appear in the CISA KEV catalog at time of analysis, though the discrepancy between the RCE tag and the CVSS confidentiality-only impact metrics leaves the true blast radius unresolved.

Remote code execution in the submariner-operator component of Red Hat Advanced Cluster Management for Kubernetes 2.x allows a cluster administrator-or any user holding RBAC permissions to modify the Submariner Custom Resource-to reference an unvalidated, attacker-controlled container image path, causing the operator to deploy and execute arbitrary code with elevated privileges across the entire cluster, including control-plane nodes. The root cause (CWE-20: Improper Input Validation) is the absence of image path sanitization or verification before the operator acts on the Submariner CR field, enabling privilege escalation beyond the user's intended cluster boundary. No public exploit code and no CISA KEV listing have been identified at time of analysis, but the Changed Scope with full C:H/I:H/A:H impact ratings signal potential for complete cluster compromise once the high-privilege prerequisite is met.

Stored cross-site scripting in Beta Systems Software AG ANOW! Automate v.3.3.1.90 allows a remote attacker to inject persistent malicious JavaScript into the user documentation field, which then executes in the browsers of any users who view the affected content. The CVSS scope-change indicator (S:C) confirms that impact propagates beyond the injecting session to other authenticated users, enabling session hijacking, credential theft, or UI redressing. No public exploit confirmation or KEV listing is present, but a detailed researcher disclosure on GitHub (cert-rit, January 2026) documents the stored variant specifically.

Command injection in uniget CLI's hook editing feature enables arbitrary code execution via a maliciously crafted EDITOR environment variable. The `hooks edit` subcommand reads the UNIGET_EDITOR or EDITOR environment variable and splits it on whitespace using Go's `strings.Split()`, causing embedded shell metacharacters such as `&&` to be passed as discrete exec arguments that downstream shell-backed editor wrappers then interpret as command separators. Exploitation was publicly demonstrated in GHSA-qmcq-xw74-w667 with a confirmed POC achieving code execution as uid=1000; no public exploit identified at time of analysis beyond the advisory-embedded POC, and no CISA KEV listing exists.

Code injection in sqlparse prior to 0.6.0 allows attackers to escape generated Python and PHP source-code snippets by supplying crafted SQL containing backslashes immediately before quote characters, exploiting a missing pre-escaping step in the output formatting filters. The flaw resides in sqlparse/filters/output.py, which escapes quotes without first escaping pre-existing backslashes, causing the generated escape to neutralize the backslash rather than the quote and allowing attacker-controlled content to appear outside the intended string literal as executable code. Publicly available exploit code exists via a validated Docker-based proof-of-concept published in GHSA-3496-9g83-7v6x; no confirmed active exploitation in CISA KEV at time of analysis.

Arbitrary file deletion in Terragrunt before v1.0.4 allows an attacker who controls a remote module source to delete any file accessible to the Terragrunt process by embedding directory traversal paths in a forged `.terragrunt-module-manifest` file within the module. The deletion occurs automatically during the module download and initialization phase - before OpenTofu or Terraform executes - making CI/CD pipelines that consume external modules particularly exposed. No public exploit has been identified and no CISA KEV listing exists; a vendor-released patch is available in v1.0.4. Note: an 'RCE' tag in the source metadata directly contradicts the vendor advisory's explicit statement that this is a deletion-only primitive with no code execution or data exfiltration capability.

Out-of-bounds stack read and write in the WNC-M14A2A LTE-M modem driver (wncm14a2a.c) within Zephyr RTOS versions 1.13.0 through below 4.4.2 allows a rogue cellular base station or RF attacker to crash the modem RX thread and leak adjacent stack memory without any application interaction. The defect fires automatically on receipt of an unsolicited %NOTIFYEV: event whose payload exceeds 39 bytes and lacks a quote character within the linearized region, causing scanning loop indices to walk past the fixed 40-byte stack buffer. While the write primitive is weakly controlled — limiting demonstrated impact to denial of service and stack disclosure — the CVE is tagged RCE by reporters, though the description explicitly states memory-safe code execution has not been demonstrated. No public exploit or CISA KEV listing exists at time of analysis.

Cross-site scripting in JetBrains PyCharm's Quick Documentation rendering feature (before version 2026.2.1) enables code execution within the IDE process when a developer inspects documentation for a symbol from a maliciously crafted source. Attackers - including supply-chain adversaries embedding malicious HTML or JavaScript into Python package docstrings - can achieve code execution in PyCharm's local process context once the victim triggers Quick Documentation on an affected symbol. No public exploit has been identified at time of analysis, and JetBrains has released a fix in version 2026.2.1.

Remote code execution in UpTrain 0.7.1 and prior allows authenticated users to execute arbitrary commands on the host system via the `/new_run` API endpoint. The `checks` and `metadata` parameters are unsanitized, enabling injection attacks (CWE-74) that run in the context of the underlying process - typically a Docker container per the official deployment documentation. Publicly available exploit code exists (CVSS 4.0 E:P per GitHub Security Lab advisory GHSL-2024-200/201), and no vendor-released patch has been identified at time of publication.

Remote code execution in UpTrain's `/add_prompts` API endpoint allows any authenticated user to execute arbitrary commands on the host system by injecting malicious payloads into the `checks` or `metadata` parameters. Affected versions are 0.7.1 and prior, and deployments following the official documentation run inside Docker containers, meaning successful exploitation grants control of the container environment. GitHub Security Lab (GHSL-2024-200/201) has published an advisory and the CVSS 4.0 E:P modifier confirms publicly available proof-of-concept exploit code exists; no vendor-released patch has been issued as of time of publication.

Remote code execution in UpTrain v0.7.1 and prior is achievable by any authenticated user through the `/create_project` API endpoint, where the `checks` and `metadata` parameters are processed without adequate sanitization, allowing arbitrary code to run in the context of the host process. Discovered and reported by GitHub Security Lab (GHSL-2024-198/GHSL-2024-199), the flaw targets the dashboard backend (app.py:L691) and is most commonly exploited within Docker-based deployments as recommended by official documentation. No vendor patch exists as of publication, and a proof-of-concept is confirmed by the CVSS 4.0 E:P modifier, elevating real-world urgency despite the authentication prerequisite.

Code injection in GL.iNet router firmware's Language Auto-Update component allows low-privileged authenticated remote attackers to execute arbitrary OS-level commands by manipulating cron scheduling parameters in the ui.update_langs function. Seventeen router models running firmware up to version 4.8.x are affected, spanning GL.iNet's entire current lineup from travel routers (MT3000, AXT1800) to high-end mesh units (BE10000, BE9300). The vendor has confirmed the vulnerability exists and a patch is available via the GL.iNet CVE issues repository; no public exploit code or CISA KEV listing has been identified at time of analysis.

Cross-site scripting in JeecgBoot v3.9.2's AI RAG chat upload endpoint allows unauthenticated remote attackers to inject arbitrary JavaScript that executes in the browsers of users who interact with the malicious content. The CVSS 6.1 (Medium) vector confirms Changed Scope, enabling session hijacking, credential theft, or authenticated action hijacking against victims. No public exploit code has been identified and the EPSS score of 0.21% (11th percentile) indicates negligible current exploitation activity; this is not listed in the CISA KEV catalog.

Code injection in iatsiuk pptr-mcp through version 0.2.7 enables authenticated remote attackers to execute arbitrary code via the `executeCode` function in `src/vm-executor.ts`, a component of the MCP `execute` tool. The underlying sandbox fails to isolate user-supplied input from the execution context, a class of vulnerability closely associated with Node.js `vm` module escapes. A publicly available proof-of-concept exists on GitHub, and the project maintainer has not responded to responsible disclosure, leaving all known deployments unpatched.

CSS injection in WC Product Table Lite (WordPress plugin, versions ≤ 5.6.0) allows unauthenticated remote attackers to embed arbitrary CSS into any page rendering a product table with sticky sidebar enabled. The flaw originates in the unauthenticated `wp_ajax_nopriv_wcpt_ajax` AJAX handler, which JSON-decodes attacker-supplied shortcode attributes, enforces only a key-name allowlist without sanitizing values, and interpolates the raw `laptop_scroll_offset` value directly into inline CSS without numeric casting or escaping. While the assigned CVSS score of 5.3 carries C:N, the real-world impact is broader: the injection vector supports CSS-based data exfiltration via attribute-selector background-image chaining, UI redressing, and phishing that bypasses CSPs permitting inline styles - risks not captured in the base score. No public exploit code or CISA KEV listing was identified at time of analysis.

Arbitrary shortcode execution in ProfilePress (WordPress plugin) versions through 4.16.19 permits authenticated attackers holding only subscriber-level accounts to inject and run arbitrary WordPress shortcodes within the site context. The plugin's partial mitigation - applying strip_shortcodes() to [profile-first-name] and [profile-last-name] fields - is bypassed via at least three confirmed paths: the [profile-display-name format="first_last_names"] render chain, the [profile-bio] field (which re-fetches raw user_description meta, bypassing the sanitized value), and the double-bracket escape sequence [[tag]] that passes through strip_shortcodes() unmodified but is resolved by the outer do_shortcode() call. No public exploit code has been confirmed at time of analysis, but the low authentication bar (self-registration is the plugin's core use case) and three documented bypass vectors make this a meaningful risk on open-registration membership sites.

Remote code injection in DefaultFuction Notice-System-Managent 2.0 allows low-privilege authenticated attackers to execute arbitrary Groovy code by sending crafted input to the /execute endpoint, which passes unsanitized values directly to GroovyShell.evaluate in NoticeController. A public proof-of-concept exploit is available via the project's GitHub issue tracker. The vulnerability is not yet in CISA KEV, but the combination of network accessibility (AV:N), a low authentication barrier (PR:L), and a live public POC substantially elevates real-world risk beyond what the CVSS 4.0 score of 5.3 conveys.

Insecure deserialization (CWE-502) in AVEVA Enterprise SCADA and related pipeline/HMI products allows an authenticated operator holding the 'DNA Authority - Operator' role to tamper with serialized data and achieve code execution during deserialization, running under the elevated Enterprise SCADA 'DNA Apps' security group. The flaw affects AVEVA Enterprise SCADA, Enterprise SCADA HMI, Pipeline Operations for Gas/Liquids, Pipeline Integrity Monitor, Pipeline Training Simulator, and Measurement Advisor, and is fixed per AVEVA Security Bulletin AVEVA-2026-005 and CISA advisory ICSA-26-225-01. There is no public exploit identified at time of analysis, but the reported CVSS 4.0 base score is 10.0.

Out-of-bounds write in Zephyr RTOS's LoRaWAN Fragmented Data Block Transport service corrupts the Semtech/LoRaMAC-node decoder's internal MatrixM2B recovery-matrix state when a DATA_FRAGMENT command carries frag_index_n = 0, underflowing the 1-indexed counter arithmetic to array index -1. Impact is constrained to denial of an active FUOTA (Firmware Update Over The Air) session and decoder state corruption - not code execution - despite 'RCE' appearing in the intelligence metadata tags, which directly contradicts the CVE description. No public exploit has been identified and this vulnerability is not listed in CISA KEV.

Out-of-bounds read in Capstone's cs_insn_name() public API crashes host processes when the M68K or RISCV architecture backends receive caller-controlled invalid instruction IDs that bypass missing or incomplete bounds checks. Affected are all Capstone deployments prior to 6.0.0-Alpha9 where those two architecture handles are in use and instruction ID input is not sanitized by the calling application. The demonstrated impact is strictly a denial-of-service crash; no code execution or data exfiltration was shown, and no public exploit or active exploitation has been identified at time of analysis.

Out-of-bounds write in IBM i 7.3 through 7.6 enables a local, low-privileged attacker to execute arbitrary code or trigger a denial of service via improper bounds checking. The vulnerability is classified under CWE-787 and carries tags for RCE, memory corruption, and buffer overflow, indicating a classic memory safety failure in a privileged operating environment. No public exploit or CISA KEV listing has been identified at time of analysis, and IBM has released a patch.

Template-literal code injection in TypeORM's migration:generate command allows an attacker with database schema write access to achieve arbitrary JavaScript execution on any host that loads the generated migration file. Affected are TypeORM npm versions prior to 0.3.31 (0.x branch) and versions 1.0.0 through 1.0.x (fixed in 1.1.0), spanning PostgreSQL, MySQL, MariaDB, and CockroachDB drivers. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis; however, the GHSA advisory provides sufficient technical detail to reproduce the attack.

Remote code execution in Palo Alto Networks GlobalProtect app on Windows allows a network-adjacent man-in-the-middle attacker to execute arbitrary code with SYSTEM privileges by exploiting improper input validation in the Pre-Logon Access Provider (PLAP) component (CWE-94). Only Windows deployments with the PLAP feature configured are affected; GlobalProtect on Linux, macOS, iOS, Android, and Chrome OS is explicitly excluded from the vulnerability scope. No public exploit code exists at time of analysis and the vulnerability is not listed in the CISA KEV catalog, but the SYSTEM-level code execution outcome before user logon warrants prioritized remediation for any enterprise Windows fleet using the pre-logon VPN feature.

Out-of-bounds write in Palo Alto Networks GlobalProtect app exposes Windows, macOS, and Linux endpoints to arbitrary code execution at SYSTEM or root privilege levels when clients connect to an attacker-controlled rogue gateway or are subjected to a man-in-the-middle attack. The vulnerability resides in the client-side VPN agent's processing of gateway-supplied data, where a crafted response can corrupt memory and hijack execution. No public exploit has been identified at time of analysis, and CISA has not confirmed active exploitation, but full confidentiality, integrity, and availability compromise is possible on any affected endpoint that connects through a manipulated gateway.

MongoDB Atlas SQL ODBC Driver and Schema Builder CLI fail to validate URI schemes in authorization and token endpoints returned by an OIDC issuer's discovery document, allowing an attacker-controlled MongoDB deployment to dispatch arbitrary URIs to a victim's operating system protocol handler. Users employing MONGODB-OIDC authentication who are induced to connect to a rogue or compromised MongoDB deployment may have OIDC credentials exposed or, under conditions where a dangerous OS protocol handler is registered, experience code execution within their user session context. No public exploit has been identified at time of analysis, and exploitation carries meaningful social engineering prerequisites that constrain real-world reach despite the network-accessible attack vector.

Use-After-Free vulnerabilities in the GNU linker (ld) component of binutils crash the linker process when processing crafted object or archive files during LTO-enabled linking on Red Hat Enterprise Linux systems. The flaws exist at three distinct dereference points in add_archive_element() in ld/ldmain.c, where plugin_maybe_claim() frees the BFD object but the caller retains dangling pointers that are subsequently accessed. The attack surface is confined to build-time environments, with the primary realistic threat being a supply chain attack introducing a malicious object file into CI/CD pipelines or developer build systems; no public exploit code or active exploitation has been confirmed at time of analysis.

Unauthenticated shortcode injection in Kirki WordPress plugin (all versions before 6.2.1) allows any remote attacker to execute arbitrary registered WordPress shortcodes via unprotected front-end form submission REST routes. On a default WordPress install, exploitation leads to disclosure of the site administrator's email address and abuse of the victim domain as a mail relay to arbitrary recipients. A publicly available proof-of-concept exploit exists per WPScan, and a vendor patch has been released.

Remote code execution and denial-of-service in Phoenix Contact PLCnext-family industrial controllers (AXC F 1152/1252/2152/3152, RFC 4072R/S, BPC 9102S/9202S, VPLCnext Control, EPC 15xx and others) arise from a buffer overflow in the PROFINET service that is reachable in the default configuration. An unauthenticated remote attacker on the network can crash/reboot the device or execute arbitrary code, per the vendor CVSS 4.0 rating of 9.3 (critical). This is a CWE-120 classic buffer overflow reported by CERT@VDE; no public exploit identified at time of analysis and it is not on CISA KEV.

Boot partition authentication bypass in CPSD CryptoPro Secure Disk for BitLocker before v7.7.4 allows an attacker who can manipulate disk partition layout to redirect boot-time code execution to a crafted Linux partition. The product fails to cryptographically verify the integrity of the intended boot partition and instead selects the first partition whose type matches a hardcoded value - a logic flaw that allows a spoofed partition to preempt the legitimate boot target and execute arbitrary code at elevated privilege. No public exploit or CISA KEV listing is confirmed at time of analysis, though a Black Hat USA 2026 research presentation by Burch ('The Cost of Obscurity') describes the finding, suggesting detailed technical disclosure has occurred.

Integrity validation failure in CPSD CryptoPro Secure Disk for BitLocker before v7.7.4 allows an attacker with local or physical disk access to craft malicious DataStore contents that trigger code execution in a high-privilege context or disrupt service availability on the host. The DataStore - a non-partitioned filesystem holding pre-boot configuration and cryptographic material - is parsed without authenticity verification, making it a viable Evil Maid attack surface. No public exploit identified at time of analysis, and EPSS at 0.18% (8th percentile) indicates very limited real-world exploitation activity; however, research presented at Black Hat USA 2026 details the vulnerability class.

Command injection in SonicWall Global Management System (GMS) CLI version 9.5.1 and earlier enables a low-privileged user to execute arbitrary system commands with root privileges, constituting a full local privilege escalation on the GMS management host. The flaw is rooted in CWE-94 (Code Injection) within the CLI component, where unsanitized user input reaches a system command interpreter running at elevated privilege. No active exploitation has been confirmed by CISA KEV, no public exploit code has been identified, and SSVC assessment characterizes exploitation status as none with a non-automatable attack path.

MongoDB Server's JavaScript scripting engine allows an authenticated user with write privileges to inject code into the query execution scope of other database users via a specially crafted stored value processed during an internal maintenance cycle. Affected versions span the 7.0, 8.0, and 8.3 release lines, with vendor-confirmed patches available. No public exploit code has been identified at time of analysis, and CISA has not listed this in the Known Exploited Vulnerabilities catalog; however, the cross-user integrity and availability impact warrants prompt patching in multi-tenant or shared database environments.

DLL hijacking during the AMD Ryzen Master installation process allows a local low-privileged attacker to escalate privileges and execute arbitrary code on Windows systems running affected versions. The flaw, rooted in an uncontrolled DLL search path (CWE-427), affects AMD Ryzen Master up to 3.0.0.4199, Ryzen Master SDK up to 3.0.1.4732, and a legacy branch for Ryzen 3000 Series processors up to 2.14.3.5040. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.

Local privilege escalation in AMD Power Design Manager (PDM) Software Installer for Windows enables a low-privileged local user to exploit incorrectly configured directory permissions, potentially resulting in arbitrary code execution at an elevated privilege level. The vulnerability is confirmed by AMD PSIRT via security bulletin AMD-SB-8016, and a patched version (2026.1) has been released. No public exploit code and no CISA KEV listing have been identified at time of analysis.