Remote Code Execution

Local code execution in Acer NitroSense v5 (versions up to and including 5.2.63) allows an attacker who already has shell access on the host to run arbitrary code in the privileged context of the application by connecting to an Electron/Chromium DevTools endpoint left enabled in the production build and bound to localhost TCP port 9993. No authentication or user interaction is required against that debug port, and the assessed CVSS:3.1 vector (AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) reflects full confidentiality, integrity and availability impact once local access exists, but the exposure is confined to loopback and is therefore not remotely reachable. No public exploit code was identified and there is no CISA KEV listing at time of analysis; this is a moderate, locally-scoped risk rather than a remote emergency, and its main value to an attacker is as a privilege-escalation or persistence primitive on an already-compromised endpoint.

SQL injection in the third-party Socialwall course-format plugin for Moodle (versions 3.0 through 3.3) lets remote attackers inject crafted SQL through a plugin HTTP endpoint, granting high confidentiality and integrity impact on the Moodle database. The vendor-supplied CVSS of 9.8 assumes no authentication, but our assessment lowers this to a PR:L vector (CVSS 3.1: AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N, 8.8) because plugin endpoints in Moodle typically require a valid authenticated session - a limiting factor that remains unconfirmed from available metadata. Exploitation is not confirmed actively exploited (no CISA KEV listing), and while a public Medium write-up describes the SQLi, no public exploit code has been confirmed at time of analysis; note that the CVE description's claim of arbitrary code execution is broader than the assessed confidentiality/integrity-only impact.

Privilege escalation in GNU C Library (glibc) 2.14 through 2.44 stems from a TOCTOU race in ld.so when expanding $ORIGIN in DT_RPATH for setuid/setgid (AT_SECURE) programs. A local low-privileged (PR:L) attacker can exploit this only where fs.protected_hardlinks is disabled and a suitable setuid/setgid binary exists, by hard-linking the binary and winning a race to swap an intermediate path component for a symlink so the loader loads an attacker-controlled shared object with the program's elevated privileges. No public exploit identified at time of analysis; major Linux distributions enable fs.protected_hardlinks by default, sharply limiting exposure.

Heap memory corruption and denial of service in radare2 versions prior to 6.2.0 occur when the CPython .pyc marshal parser processes a crafted bytecode file that declares a string length of 0xffffffff, wrapping the size-plus-one allocation to zero before attacker-controlled data and fill bytes are written past the heap buffer. Exploitation is local and requires user interaction - an analyst must open or inspect the malicious .pyc with r2 or rabin2 - and no privileges are needed per the CVSS vector (AV:L/PR:N/UI:R), with impact confined to corrupting or crashing the analysis process. Arbitrary code execution is possible in principle but has not been demonstrated, no public exploit code has been identified at time of analysis, and the 5.5 CVSS score reflects a genuinely low-priority issue for most environments. Only workflows that routinely open untrusted .pyc files (malware analysis, CTF, reverse-engineering) are realistically at risk.

Code injection in mtrano APENCMS (rolling release, all builds up to commit 6546096d354153309693efabb9a0d824628ed4f5) lets a remote attacker who already holds high-privilege template or site administration access reach a PHP eval() call in cms/weasel.php through the $_CMS['site'] argument and execute arbitrary code on the server. Publicly available exploit code exists, while the vendor was contacted and did not respond, so no fixed build and no published version boundaries are available. The CNA's CVSS 4.0 base score of 1.9 (Low, all impacts rated VC:L/VI:L/VA:L) understates the technical severity: with attacker-controlled input flowing into eval(), successful exploitation is effectively full server-side code execution, and the attacker must already control the template/site variable (PR:H), consistent with template or site administrator rights rather than an unauthenticated default-configuration attack.

Authenticated file deletion via directory traversal in the CTX Feed (Product Feed Manager for WooCommerce - 220+ Shopping & Social Channels) WordPress plugin affects all versions up to and including 6.6.43: a user holding shop-manager capability or above can abuse the 'provider' parameter to walk out of the intended feed directory and force an unlink() against files whose extensions match the plugin's own whitelist (csv, xml, tsv, xls, xlsx, json, txt). Exploitation is a deliberate two-call REST sequence - first POST to /wp-json/ctxfeed/v1/make_feed/save_feed_config to persist the traversal string in wp_options, then a call to /wp-json/ctxfeed/v1/manage_feeds/delete_feed to trigger the deletion - so there is no unauthenticated path and no victim interaction beyond the attacker's own privileged session. Our independent assessment rates this a moderate, not high-priority, issue (CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:N/I:H/A:L); the frequently repeated 'leads to RCE' framing is sharply constrained because .php files such as wp-config.php cannot be deleted, and no public exploit code or confirmed active exploitation was identified at time of analysis.

Arbitrary file deletion in the BM Content Builder plugin for WordPress (all versions below 3.17.1) allows any authenticated user holding Subscriber-level access or above to delete files of the attacker's choosing from the web server through the plugin's AJAX handlers, with no user interaction required. Because the deletion is unbounded, removing a critical file such as wp-config.php can knock a site into a reconfiguration state and open a practical path to remote code execution, per the reporting vendor. At the time of analysis the issue is not listed in CISA KEV and no public exploit code has been identified; exploitation is gated by the Subscriber-or-above authentication requirement, a low bar on sites that permit self-registration.

Stack-based buffer overflow in fetchmail when built with NTLM support allows a malicious or compromised mail server to trigger memory corruption by sending a crafted NTLM Type 2 challenge, potentially leading to remote code execution, authentication failure, or process termination. Exploitation requires fetchmail to be built with NTLM and configured to authenticate via NTLM against an attacker-controlled or man-in-the-middle'd server; no public exploit code or active exploitation has been identified. The flaw carries a CVSS score of 8.1 with high confidentiality, integrity, and availability impact, though reliable RCE is limited by stack-frame layout and modern memory hardening (stack canaries, ASLR, FORTIFY_SOURCE) on RHEL builds.

Unauthenticated shortcode injection in the GiveWP WordPress donation plugin before version 4.16.9 lets any site visitor submit nested shortcode delimiters through a public donation form, causing the site to execute arbitrary registered shortcodes when the donor-supplied value is rendered. Real-world impact is bounded by which shortcodes are registered on the target: a site with only benign shortcodes suffers little, while one exposing sensitive or administrative shortcodes could face data exposure or content manipulation. No public exploit code identified at time of analysis and the issue is not in CISA KEV; severity is moderate (CVSS 6.5, unauthenticated, no user interaction).

Code injection in RooCMS (versions up to and including 1.2.2, 1.3.4 and 1.4RC2) allows an attacker who holds a privileged content-editing or administrator account to place PHP code into a page's 'content' field, which the frontend renderer passes to eval() in roocms/site_pagePHP.php, resulting in arbitrary PHP execution on the server. The flaw is CWE-94 and is remotely reachable, but exploitation is gated behind high privileges (CVSS:4.0 PR:H / CVSS:3.1 AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), so realistic exposure is limited to insiders or attackers who have already obtained editor credentials rather than an anonymous internet-facing surface. Publicly available exploit code exists (a public proof-of-concept write-up is referenced), the vendor was contacted but did not respond, and no vendor-released patch has been identified at time of analysis.

Local privilege escalation in WatchDog Anti-Virus 1.8.640 on Windows lets an unprivileged local user redirect the quarantine restoration workflow so a quarantined file is written to an attacker-chosen filesystem location, by planting an NTFS directory junction at the file's original path before an administrator triggers a restore. The defect is root-caused as improper link resolution before file access (CWE-59); the vector requires local access (PR:L in the CVSS 4.0 vector) and an administrator actively performing the restore (UI:A), so the privileged write cannot be triggered by the attacker alone. Successful exploitation can overwrite protected files and, with a well-chosen target path, support DLL hijacking for SYSTEM-level code execution, but there is no indication of active exploitation, no CISA KEV listing, and no public exploit code identified at time of analysis; this is treated as a genuine but conditional local privilege-escalation issue rather than an urgent remote threat.

Improper default filesystem permissions in WatchDog Anti-Virus for Windows let any local, low-privileged user take over the installation directory, because the default installer grants the Users group Full Control over C:\Program Files (x86)\Watchdog Anti-Virus. That access alone is enough to disable protection by deleting or rewriting antivirus binaries and configuration files, and it can escalate to privileged code execution if a tampered binary is subsequently loaded by an elevated WatchDog process, for example after a service restart, scheduled scan, or update cycle. The flaw requires an existing local user account (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H; vendor CVSS 4.0 base 5.9, PR:L) and is confined to hosts still running the affected installer build; no public exploit code was identified at time of analysis, and WatchDog's release notes reference the corrected build.

Code injection in DedeCMS through version 5.7.118 lets remote, unauthenticated attackers manipulate the 'aid' argument handled by plus/mytag_js.php to inject attacker-controlled code into the application's processing path, with the vendor-scored impact limited to low confidentiality, integrity and availability effects. A public exploit for this issue exists, so any internet-reachable installation that still exposes the plus/ auxiliary scripts should be considered at risk of opportunistic scanning and exploitation; CISA KEV does not list this CVE, indicating no confirmed active exploitation at time of analysis. Because the technical impact is constrained rather than a full compromise chain, this is a moderate-priority hardening item rather than an emergency patch-and-isolate scenario.

Unauthenticated arbitrary file upload in the Ultra Addons for Contact Form 7 WordPress plugin (versions 3.2.4 through before 3.5.51) lets a remote attacker place a file with an attacker-chosen name and extension at a predictable public path inside the WordPress site. On hosts running the default Debian/Ubuntu Apache PHP package configuration, where .phar is mapped to the PHP handler alongside .php and .phtml, that uploaded file is interpreted and the issue escalates to remote code execution and full site takeover; on hosts that route only .php to PHP, the file is served inert from the site's own origin, degrading the outcome to stored cross-site scripting. No authentication, user interaction, or special access is required (our assessed vector CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H), publicly available exploit code exists, and the RCE path is immediate on affected Apache/mod_php stacks - which is why our independent assessment rates real-world severity above the vendor-assigned CVSS 6.5.

Local file inclusion that can escalate to PHP code execution affects the All Bootstrap Blocks WordPress plugin in versions up to and including 1.3.31, allowing an authenticated user with contributor-level access or higher to direct the plugin to include arbitrary local files at render time and read their contents. Code execution occurs only where an includable local file already contains PHP, and exploitation additionally requires the plugin's non-default Lightspeed subsystem to be explicitly enabled, so a stock installation is not exposed. No CISA KEV entry has been recorded for this issue, but publicly available exploit code exists and a proof-of-concept is referenced by WPScan, making the risk material for sites that have enabled Lightspeed and grant contributor accounts.

In the Linux kernel, the following vulnerability has been resolved: PCI/sysfs: Add lockdown checks to legacy I/O and memory handlers Currently, the legacy I/O and memory sysfs handlers do not check security_locked_down(LOCKDOWN_PCI_ACCESS), leaving the legacy_io and legacy_mem files unprotected when the kernel is locked down. Commit eb627e17727e ("PCI: Lock down BAR access when the kernel is locked down") added the check to pci_write_config(), pci_mmap_resource(), and pci_write_resource_io() to prevent userspace from programming DMA-capable hardware that could be used to modify kernel code, but did not cover the legacy handlers. As a result, root can still write arbitrary I/O ports and map the legacy I/O and memory spaces while the kernel is locked down, which is the same capability the lockdown is meant to remove. Add the same check to pci_write_legacy_io(), pci_mmap_legacy_mem(), and pci_mmap_legacy_io(). These generic handlers cover both architectures that define HAVE_PCI_LEGACY (such as Alpha and PowerPC). [bhelgaas: add Link]

In the Linux kernel, the following vulnerability has been resolved: net/sched: act_ife: Only operate on Ethernet frames act_ife encapsulates/decapsulates the original Ethernet header and uses skb->dev->hard_header_len as the length of that header. That is only correct for Ethernet devices: on a device where hard_header_len does not match the L2 header that was actually pulled (PPP reports PPP_HDRLEN while nothing is stripped on ingress), the ingress skb_push()/skb_pull() use the wrong length and can hit skb_under_panic when headroom is tight. IFE is Ethernet-only by design - it builds an outer ethhdr, rewrites h_source/h_dest/h_proto, and calls eth_type_trans() on decode - so instead of trying to make the offsets work for arbitrary link types, simply drop packets that do not carry an Ethernet header. Checking skb->dev->type alone is not enough. We have to cater for a corner case where mirred can redirect an skb from a non-Ethernet device to an Ethernet one, and skb->dev then says nothing about the framing the skb actually has: an skb redirected from ppp0 reaches the target's ingress hook with mac_len 0 and no Ethernet header at all. So at ingress also require mac_len to be ETH_HLEN. On egress mac_len is not maintained, so the device type is all we have; a bogus redirect there yields a malformed frame rather than an out-of-bounds push, and it would be malformed with or without IFE. That corner case is not theoretical - redirecting from ppp0 into a veth that has an ife encode action on its ingress hook panics without this patch: skbuff: skb_under_panic: len:98 put:14 head:ffff88800e410000 data:ffff88800e40fff5 tail:0x57 end:0x640 dev:veth3 kernel BUG at net/core/skbuff.c:214! Call Trace: skb_push (net/core/skbuff.c:224 net/core/skbuff.c:2657) tcf_ife_act (net/sched/act_ife.c:829 net/sched/act_ife.c:874) tc_run (net/core/dev.c:4463) netif_receive_skb (net/core/dev.c:6463 net/core/dev.c:6522) tcf_mirred_to_dev (net/sched/act_mirred.c:248 net/sched/act_mirred.c:328) tcf_mirred_act (net/sched/act_mirred.c:489) tc_run (net/core/dev.c:4463) process_backlog (net/core/dev.c:6728) With Ethernet framing guaranteed, use ETH_HLEN instead of hard_header_len.

Denial of service in HP's HPLIP (HP Linux Imaging and Printing Software) printing stack is reachable when a physically-present attacker supplies specially crafted input that triggers a CWE-191 integer underflow, crashing or hanging affected components; the scored CVSS:3.1 vector (AV:P/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) limits impact to availability only, with no confidentiality or integrity loss. The physical attack vector (direct hardware/USB or local physical access) is the dominant gating factor and rules out remote or network-based exploitation, and no public exploit has been identified at time of analysis. HP has stated that it identified and remediated the underlying issues, so a vendor fix is available per advisory hpsbpi04151, though the specific affected and fixed version ranges are not enumerated here and must be confirmed against that bulletin. Overall this is a genuine but low-priority issue: real availability impact, but exploitation requires an attacker to already have hands on the machine.

Denial of service in HP Linux Imaging and Printing Software (HPLIP) can be triggered by a physically present attacker who supplies crafted input via a local device or print/scan job, exploiting improper array index validation (CWE-129). Although HP's advisory bundles several vulnerabilities that could potentially enable a broader range of impacts, the specific vector for this CVE limits the effect to availability (system crash or service disruption) with no confidentiality or integrity impact. No public exploit code or active exploitation has been identified at time of analysis, and the primary prerequisite is physical access to the target system.

Command injection (CWE-78) in HP's HPLIP (HP Linux Imaging and Printing) software enables an unauthenticated local user to execute commands or modify files with high integrity impact (VI:H) after active user interaction, matching HP's CVSS 4.0 score of 6.8 (AV:L/AC:L/PR:N/UI:A/VC:L/VI:H/VA:L) and the independent CVSS 3.1 assessment (AV:L/AC:L/PR:N/UI:R/C:L/I:H/A:L). The HP security bulletin HPSBPI04151 bundles this issue with other externally reported HPLIP flaws that could lead to remote code execution, privilege escalation, denial of service, or information disclosure, but the exact vulnerable component is not disclosed. No public exploit code or CISA KEV entry is identified at time of analysis, and the local vector plus mandatory user interaction prevents triggering without a user processing attacker-supplied input.

Local attackers with valid credentials on Linux systems running HPLIP can exploit symbolic-link handling flaws (CWE-61) in HPLIP components to read or modify arbitrary files, as described in HP security bulletin HPSBPI04151. This CVE is one of multiple issues remediated by HP in HPLIP and is assessed as a moderate, locally-scoped issue (CVSS 3.1: AV:L/AC:L/PR:L/UI:N, limited confidentiality/integrity impact) rather than an urgent priority, despite the broader impact list in the description; no public exploit code or CISA KEV active exploitation has been identified at time of analysis. Exploitation requires local access and a vulnerable HPLIP component that follows attacker-controllable symlinks at a predictable path, limiting impact to unauthorized file read/modification.

Heap use-after-free in the HDF5 library (The HDF Group, all versions before 2.3.0) is triggered when an application such as h5dump reads a dataset whose compound datatype contains floating-point members, allowing a crafted .h5 file to crash the parsing process and, depending on heap layout and allocator behaviour, potentially corrupt memory further. Exploitation requires the victim to open a malicious file locally (local vector, mandatory user interaction, no authentication needed), so it is not remotely reachable on its own. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV; the vendor's own CVSS 4.0 base of 4.6 aligns with the independent assessment that the reliably demonstrated impact is a crash rather than proven code execution.

Unauthenticated visitors can inject arbitrary WordPress shortcodes, including attacker-chosen attributes, into Formidable Forms versions before 6.35 because a request-derived value is substituted into a form's custom HTML and then passed through the shortcode parser server-side. Any page rendering an affected form will execute the injected shortcode, which can expose data or alter site behaviour depending on which shortcodes are installed on the target. Publicly available exploit code exists per WPScan, but CISA KEV does not list this issue and the CVSS score is moderate (4.8, AV:N/AC:H/PR:N/UI:N/C:L/I:L/A:N), reflecting configuration-dependent preconditions and limited impact.

Privilege escalation in the command line interface of HPE Networking EdgeConnect SD-WAN Gateways lets an authenticated, already high-privileged remote user exceed their assigned authorization level and execute arbitrary code on the appliance. Four release branches are affected: 9.4.0.0-9.4.8.2, 9.5.0.0-9.5.8.1, 9.6.0.0-9.6.3.1 and 9.7.0.0. The CVSS score of 6.6 understates the operational weight of the flaw because a compromised SD-WAN gateway sits on the control plane of the whole WAN fabric; there is no public exploit identified at time of analysis and the issue is not listed in CISA KEV.

Unauthenticated attackers can push files of the component's choosing onto a Joomla site running the JoomGallery extension (all versions below 4.4.1) by abusing the extension's TUS resumable-upload endpoint, which fails to enforce access control. The practical impact is bounded — neither the file name nor the extension is attacker-controlled — and turning the upload into code execution requires an unusual web-server configuration that maps the stored artefacts to an executable handler, which is why the CVSS 4.0 base score lands at 6.3 rather than critical. No CISA KEV entry or EPSS score accompanies this CVE in the supplied data, but the CVSS 4.0 vector carries an E:A (Attacked) supplemental metric indicating the scoring source has observed exploitation activity.

Ingestion denial of service in Bugsink affects self-hosted instances running versions 2.2.1 and earlier, where any caller holding a valid project DSN can submit an event carrying an unusually large custom tag set and force the server to write excessive tag rows. Because Bugsink digests events through a single-writer database transaction, that oversized write blocks concurrent ingestion and temporarily starves the event pipeline of other projects and clients. Version 2.2.2 fixes this by enforcing a configurable MAX_EVENT_TAGS cap (default 100) before storage; the impact is strictly availability-limited, with no data exposure, event modification, or code execution, and no public exploit code or CISA KEV listing was identified at time of analysis.

Use-after-free in FreeRDP's smartcard RDPDR device handler (before 3.31.0) allows a malicious or compromised RDP server to free a registered device pointer while the device manager still holds a reference, producing a dangling pointer that can crash the client or potentially be leveraged for code execution in the victim's session. The flaw is only reachable when a client with smartcard redirection enabled connects to an attacker-controlled RDP endpoint and the attacker can force a worker-thread creation failure during channel setup — a narrow, non-deterministic window reflected in the low CVSS 4.0 score of 2.3 (AV:N/AC:H/AT:P/PR:N/UI:P, availability-only impact). A vendor patch is available in FreeRDP 3.31.0; no public exploit code and no CISA KEV listing were identified at time of analysis.

The Bitnami Sealed Secrets controller (versions up to and including 0.38.4) turns its unauthenticated POST /v1/verify and /v1/rotate endpoints into a decryption oracle, letting an attacker with internal cluster network access — or a simple kubectl port-forward to port 8080 — recover the full plaintext of any sealed secret one character at a time. The flaw chains two weaknesses: spec.template.data is excluded from the AEAD authenticated-data label binding, so an attacker can replay a victim's metadata and encryptedData verbatim and substitute arbitrary Go template logic, and template execution errors are reflected directly in HTTP status codes (200 = success, 409 = failure), producing a reliable equality oracle. No public exploit code and no CISA KEV entry were associated with this CVE at the time of analysis, though the vendor has published a GitHub security advisory.

Stored cross-site scripting in the file upload feature of 1024-lab SmartAdmin v3.30.0 lets an authenticated remote attacker persist malicious script that executes in the browser of any user who later views the uploaded file or its entry in the file listing. The vendor-assigned vector requires a low-privileged account (PR:L) plus victim interaction (UI:R) and rates the issue 6.5 (Medium), with no CISA KEV listing, no EPSS score, and no confirmed public exploit code in the supplied intelligence. Impact is limited to low confidentiality, integrity, and availability effects within the victim's browser session, but the scope change (S:C) means the injected script can act on resources beyond the vulnerable component.

Out-of-bounds write in the Zephyr RTOS ITE it51xxx I2C target driver allows a malicious or compromised I2C master to corrupt embedded controller firmware memory by sending a write transaction exceeding 256 bytes while the controller operates in buffer mode. The FIFO interrupt handler target_i2c_isr_fifo() accumulated bytes into a fixed-size buffer without a pre-write bounds check, enabling overflow into the adjacent target_out_buffer and following static device data in the interrupt handler context. No software privilege on the victim controller is required; the attacker needs physical or electrical access to the I2C bus with both CONFIG_I2C_TARGET and CONFIG_I2C_TARGET_BUFFER_MODE enabled. No public exploit exists and this vulnerability is not listed in CISA KEV at time of analysis.

Comment-injection in the OpenZeppelin Contracts Wizard code generators lets a newline character embedded in the `info.securityContact` or `info.license` option break out of the single-line `//` comment and be emitted as live source declarations in generated Solidity, Cairo, Stellar/Soroban, and Stylus contracts. Only integrations that populate those two fields from untrusted input and then hand the generated source to a downstream consumer are affected — the self-service web app, AI assistant, CLI, and self-hosted API all use user-supplied values and never cross that trust boundary, and shared links cannot set the fields. The flaw is integrity-only (CVSS 3.3, CWE-94): no code executes on any Wizard service, no public exploit is identified in the supplied data, and patched packages are available as @openzeppelin/wizard 0.10.11, wizard-cairo 3.0.1, wizard-stellar 0.6.2, and wizard-stylus 0.3.1.

PHP object injection in October CMS (composer package october/system) allows an attacker-controlled serialized payload stored in a widget session key to be passed to unserialize() without an allowed_classes restriction, enabling instantiation of arbitrary classes and reachable gadget chains — potentially yielding PHP code execution as the web server user. The flaw is reachable only when the niche opt-in cms.safe_mode setting is enabled and a backend user with CMS markup editing access is not fully trusted, so standard production installations with Safe Mode off are not exposed. Public proof-of-concept code exists and vendor patches ship in 3.7.17 and 4.2.x; exploitation is not confirmed in CISA KEV, and the vendor's own CVSS score (3.3) is far below what the stated code-execution impact would normally imply.

Apache Syncope contains a Groovy sandbox bypass (CWE-94 code injection) that lets an administrator holding entitlements over the Implementations console register a malicious Groovy Command class whose untrusted code executes in a static CommandArgs initializer, escaping the intended script sandbox. Affected releases span 3.0.0-M0 through 3.0.16, 4.0.0-M0 through 4.0.7, and 4.1.0-M0 through 4.1.2; exploitation requires a privileged, already-authenticated administrator account (CVSS 3.1 vector PR:H, score 6.5) rather than an anonymous attacker. There is no public exploit identified and the vulnerability is not in CISA KEV, but because Syncope is an identity governance and provisioning platform, successful abuse yields high confidentiality and integrity impact over managed identity data - CISA's SSVC assessment rates technical impact as 'total' while noting exploitation has not been observed and the attack is not automatable.

Remote code execution in Yot CMS 3.3.0 and 3.3.1 is achievable by an authenticated administrator through the Admin Console's unsanitized use of PHP's eval() function in modsys/console/admin.php, where the text POST parameter is passed directly to eval() without validation. A publicly available proof-of-concept on GitHub demonstrates the attack. Despite the technically accurate RCE classification, exploitation is gated behind high-privilege (administrator) authentication, substantially reducing practical risk compared to the tag alone suggests.

Remote code execution in cym1102 nginxWebUI up to 4.4.2 is achievable by any authenticated user via the `autoUpdate` endpoint, which accepts an arbitrary `url` parameter and downloads and executes the resulting JAR file on the host OS without domain validation. A public proof-of-concept is disclosed in GitHub issue #213, and a fix exists only as an unmerged PR (#215) - no released patched version has been confirmed. The CVSS 4.0 low-impact metrics (VC:L/VI:L/VA:L) conflict materially with the actual RCE capability.

Code injection in sanjevirau gsubs (Electron application) up to version 1.0.3 allows remote attackers to execute arbitrary code by manipulating the filename argument passed to the showQuerySuccessPage function in renderer/index.js. The vulnerability exists in the Electron renderer process and requires passive user interaction to trigger. A public proof-of-concept exploit has been published on GitHub; no patch has been released and the vendor was unresponsive during coordinated disclosure.

Remote code execution in Xuxueli xxl-job up to version 3.4.2 allows authenticated low-privileged users to execute arbitrary code on the executor host via the GLUE mode Groovy script handler in GlueFactory.java. The root cause is that GroovyClassLoader.parseClass processes attacker-supplied Groovy source directly, compiling and running it without a restrictive sandbox. A public proof-of-concept exploit targeting v3.4.2 has been released on GitHub, and the vendor did not respond to the coordinated disclosure.

Stack-based buffer overflow in ArduinoCore-avr versions prior to 1.8.8 allows an attacker who can influence float or double values passed to Arduino String concatenation methods to corrupt stack memory on AVR-based Arduino boards, causing denial of service and - under specific conditions - arbitrary code execution on the microcontroller. The flaw resides in `String::concat(float)` and `String::concat(double)` in `WString.cpp`, where a fixed 20-byte stack buffer is insufficient for values near the extremes of the float or double range when processed by `dtostrf()`. A vendor-released patch is available in version 1.8.8; no public exploit has been identified at time of analysis.

Unauthenticated shortcode injection in the Simple CAPTCHA with Cloudflare Turnstile WordPress plugin (versions 1.2.2 through 1.42.2) allows any visitor to execute arbitrary WordPress shortcodes registered on the site. The plugin incorrectly passes the entire rendered Contact Form 7 output - including raw visitor-supplied field values - through the WordPress shortcode parser before returning the response. The practical impact scales with which shortcodes are registered: benign sites face limited exposure, but sites with shortcodes that disclose data, modify content, or trigger code execution face proportionally higher risk. No public exploit has been identified at time of analysis.

Arbitrary code execution in Dell ThinOS 10 (all builds prior to 2605_10.2616) is enabled by a missing integrity check (CWE-353) that allows a local high-privileged attacker to substitute unverified code or data in a load path the OS processes without cryptographic validation. Dell advisory DSA-2026-389 confirms both the vulnerability and a corrective update. No public exploit code or CISA KEV listing exists at time of analysis, limiting real-world risk to targeted insider-threat or physical-access scenarios.

Arbitrary code execution on Dell ThinOS 10 (all versions prior to 2605_10.2616) is possible when an unauthenticated attacker gains physical access to a thin client endpoint and exploits the absence of cryptographic integrity verification during code download (CWE-494). The vulnerability allows substitution of a malicious payload during the device's update or provisioning process, resulting in full system compromise with high confidentiality, integrity, and availability impact. No public exploit code and no CISA KEV listing have been identified at time of analysis; the physical access prerequisite (AV:P) substantially constrains the attacker population.

Buffer overflow in Bosch Sensortec COINES SDK versions 2.0 through 2.11 allows a malicious or compromised sensor evaluation board, connected to a host machine via USB or BLE, to overflow the host application's heap or stack by streaming an excessive volume of sensor samples. The root cause is that `coines_read_stream_sensor_data()` unconditionally performs a `memcpy` of the full ring buffer content without verifying whether the caller-provided destination buffer can accommodate it, because the internal `comm_intf_process_stream_response()` silently discards the requested `number_of_samples` bound. No public exploit has been identified at time of analysis, but successful exploitation could yield arbitrary code execution on the host developer machine.

Arbitrary code execution in Palo Alto Networks Checkov - the Prisma Cloud IaC static-analysis scanner - triggers when the tool scans a directory containing an attacker-crafted configuration file. The vulnerability is rooted in CWE-829 (Inclusion of Functionality from Untrusted Control Sphere): Checkov loads and evaluates IaC configuration files without sufficient isolation, allowing embedded attacker-controlled logic to execute in the scanner's runtime context. The most consequential attack surface is CI/CD pipelines, where Checkov runs automated scans with access to cloud credentials and secrets, making successful exploitation a pathway to subsequent-system compromise even though the primary vulnerable-system impact is limited. No public exploit code has been identified and Palo Alto rates exploit maturity as unreported (E:U).

Code injection in AppFlowy 0.11.8 allows arbitrary code execution through insufficient URI and local path validation in the application's file-launch and URL-handling subsystems. The vulnerability exists in the Flutter-based desktop/mobile productivity app's afLaunchUri, _afLaunchLocalUri (url_launcher.dart), OpenFilex.open, and localPathRegex (common_patterns.dart) components, where inadequate sanitization of URI schemes or local file paths enables an attacker to trigger execution of arbitrary code. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, though the CWE-94 classification confirms the root cause as a code injection pattern rather than a memory-safety issue.

Broken Windows directory-ownership verification in gix-sec (gitoxide's trust enforcement crate) causes all filesystem paths to be unconditionally trusted when the process runs with an unfiltered administrative token, nullifying safe.directory protections. Versions 0.13.2 and earlier of gix-sec contain a logic inversion in is_path_owned_by_current_user: the administrator-specific branch checks the SID of the running process against the Administrators group rather than checking the SID of the target directory, so both IsWellKnownSid and CheckTokenMembership always return true for elevated processes regardless of who actually owns the directory. A local limited-privilege attacker can plant a malicious Git repository (configuring core.sshCommand or hooks) in a shared or system-root location and trigger arbitrary code execution with full administrative rights when any admin-level gitoxide-backed operation encounters that path. No CISA KEV listing is present, but a working proof-of-concept is included in the GHSA advisory.

Remote code execution via subscriber-level authorization bypass in the Checkout Custom Fields Builder for WooCommerce WordPress plugin (all versions ≤1.1.5) allows any authenticated subscriber to install an arbitrary attacker-hosted PHP plugin and achieve full server compromise. The plugin registers AJAX endpoints for plugin installation and activation without enforcing WordPress capability checks, and the required nonce is emitted directly into all admin pages visible to subscribers when WooCommerce is inactive - making the exploit trivially accessible to any registered user. No public exploit code has been identified, but the low authentication barrier and clear exploit path represent a critical risk on multi-user WordPress sites.

Unauthenticated shortcode injection in the Contact Form 7 Captcha WordPress plugin before 0.1.9 allows any site visitor to execute arbitrary WordPress shortcodes registered on the target site. The plugin incorrectly passes visitor-submitted form field values through the WordPress shortcode parser without sanitization, meaning an attacker submitting a shortcode tag as a form value triggers its execution in the rendered response. With a publicly available proof-of-concept and the breadth of shortcodes available across typical WordPress installations - some of which can include files, run PHP, or interact with other plugins - the practical impact can escalate beyond the conservative C:L/I:L baseline to full remote code execution, depending on the shortcodes registered on the site.

Unauthenticated shortcode injection in the CleanTalk WordPress anti-spam plugin before 6.87 allows any site visitor to trigger arbitrary shortcodes registered on the target WordPress site to execute server-side, with output persisted and rendered to every subsequent visitor of the affected page. Because shortcode execution scope depends entirely on which shortcodes third-party plugins have registered, actual impact can range from minor data leakage to server-side code execution if code-execution shortcodes are present. A publicly available exploit exists, and the vendor has released a patch in version 6.87.

Out-of-bounds write in libsavscmn.so, a shared library component of Samsung One UI, enables local attackers holding low-level user privileges to execute arbitrary code on affected devices. All Samsung devices running One UI prior to version 8.5 are in scope, with the fix delivered in the September 2026 One UI 8.5 security update as documented in Samsung Mobile's bulletin. No public exploit code or active exploitation has been identified at the time of analysis, and the vulnerability is not listed in CISA's KEV catalog.

Let me synthesize. Product: Halo (halo-dev/halo) — a Java-based blog/CMS platform. Product name: "Halo". Vulnerability: CWE-94 code injection — plugin management allows installing/updating malicious plugins leading to arbitrary command execution with Halo process privileges. CVSS 3.1: AV:N/AC:L/PR:L/UI:R/S:U/C:L/I:L/A:N = 4.6. Interesting — low privilege, requires user interaction, confidentiality/integrity low, no availability impact. Scope unchanged. EPSS 0.16% percentile 5% — very low. No KEV. No POC explicitly stated (references include a GitHub issue report from a researcher - MyCVE-Report). Tags: RCE, Code Injection. Affected: Halo <= 2.25.4. Prevalence: Halo is a popular open-source blog/CMS in China — medium (common but not everywhere). I'd say "medium" — it's a widely used open-source CMS/ blogging platform, but niche-ish. Let's say medium with basis "popular open-source Java CMS/blog platform, limited enterprise footprint". Assessed CVSS: The description says plugin management allows users to install/update malicious plugins — requires authenticated user with plugin management permission (admin typically), plus user interaction (UI:R from vector). Actually the input vector already says PR:L, UI:R. Hmm, but plugin management typically requires admin. The provided CVSS says PR:L. I might assess PR:L as given but arguably PR:H. I should be honest. Let me use CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:U/C:L/I:L/A:N — but the impact of arbitrary command execution should be high. However CVSS given is low impacts. The description says "execute any command with Halo process permissions" — that would be C:H/I:H/A:H arguably. But scope unchanged and Halo process permissions limited. Hmm. I'll assess as AV:N/AC:L/PR:H/UI:R/S:U/C:H/I:H/A:H? Let me think: to install a plugin you need plugin management privilege — typically administrator. The given vector says PR:L though. Actually maybe Halo allows certain users to manage plugins. I'll go with PR:L per the vendor/NVD-ish

PHP code injection in Okta Access Gateway (all versions prior to 2026.9.1) allows an authenticated administrator to execute arbitrary code as the web server process by embedding malicious PHP payloads in dashboard application label values. The gateway writes these labels unsanitized into generated PHP configuration files, which are automatically included on every subsequent authentication request, triggering execution without further interaction. No public exploit has been identified at time of analysis; vendor-released patch is available at version 2026.9.1.

Remote code execution in InstantCMS prior to 2.18.2 allows authenticated administrators to execute arbitrary PHP code by abusing the component installer's file upload functionality. The attacker uploads a crafted ZIP archive containing a PHP webshell alongside a custom .htaccess file that overrides the upload directory's default PHP execution prohibition, causing the uploaded PHP files to become executable via direct HTTP request. The vulnerability requires admin-level authentication (PR:H per CVSS), significantly limiting exposure, but full server-side code execution is achievable post-exploitation. No public exploit code has been identified at time of analysis.

Arbitrary shortcode execution in Beaver Builder Page Builder for WordPress (all versions ≤2.10.3.1) allows unauthenticated remote attackers to invoke any registered WordPress shortcode via an insufficiently validated action handler that passes attacker-controlled input directly to do_shortcode(). Because shortcode impact depends on what handlers are registered in the environment, real-world consequences range from limited content disclosure or modification to chained exploitation through dangerous third-party shortcodes. No public exploit has been identified at time of analysis, and a patch was released as version 2.10.3.2.

Arbitrary shortcode execution in the Icegram Email Subscribers & Newsletters WordPress plugin (all versions through 5.9.27) allows unauthenticated network attackers to invoke registered WordPress shortcodes without authentication. The flaw originates in the plugin's email workflow and subscription handling code, which passes user-controlled input to `do_shortcode()` without adequate validation - enabling attackers to trigger any shortcode registered on the target site. Depending on the shortcodes available, impact ranges from information disclosure and content manipulation to potential code execution; no public exploit or CISA KEV listing has been identified at time of analysis.

Privilege escalation in PostgreSQL Anonymizer (Dalibo) prior to 3.2.0 allows a table owner to execute arbitrary code with full superuser privileges via the `anon.anonymize_database_parallel()` function. The vulnerability (CWE-250, Execution with Unnecessary Privileges) enables a low-to-high privilege escalation within the database server, granting complete C:H/I:H/A:H impact. No public exploit has been identified and the issue is not listed in CISA KEV; a vendor-released patch is available in version 3.2.0.

Shortcode injection in JetFormBuilder WordPress plugin before 3.6.5.2 allows unauthenticated remote attackers to execute any shortcode registered on the target WordPress site. The flaw stems from a misordered sanitization pipeline: user-supplied input in a request parameter is HTML-escaped before it is passed to WordPress's shortcode expansion function rather than after, meaning shortcode syntax survives the escape pass intact and is then evaluated server-side. A publicly available proof-of-concept exploit exists via WPScan, making this immediately actionable for attackers against unpatched installs.

Let me synthesize. Product: pfSense (Netgate pfSense Plus / pfSense CE). Product name: "pfSense". Key facts: XSS in captive_portal_status.widget.php, affects pfSense Plus <= 26.03 and pfSense CE <= 2.8.1. CVSS 5.4 AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:N. CWE-79. EPSS 0.26% (17th percentile). No KEV. Tags mention RCE — likely mislabeled/stretch (XSS → limited code exec in browser context). "N A" tag is noise. CPE is n/a — data quality flag possible: CPE missing. Hmm, the flag types are mislabeled_tag/wrong_vendor/wrong_product/missing_tag. Not "missing_cpe". I could flag "RCE" as mislabeled tag? The description says "execute arbitrary code" but it's XSS — the CWE is CWE-79, so "RCE" tag is arguably mislabeled. Hmm — but description itself says allows arbitrary code execution. I'd be careful. Maybe flag "RCE" mislabeled with medium/low confidence... Actually the rules say only emit flags when clearly wrong and verifiable. XSS in a captive portal widget page = script execution in victim's browser, not server RCE. CVSS vector C:L/I:L/A:N with S:U strongly implies no RCE. I think flagging "RCE" as mislabeled is defensible with medium confidence. Also "N A" tag — that's clearly a bad tag (from "n/a" vendor parsing). Could flag as mislabeled_tag target "N A" — but suggested? It's not a real tag. Hmm, "wrong_vendor"? The tag "N A" is a garbage placeholder. I'd flag it as mislabeled_tag with suggested null. Actually maybe better: type "mislabeled_tag", target "N A", suggested null, confidence high, reason "Placeholder 'N A' is an artifact of missing CPE vendor/product data, not a real tag." Also missing tags: "pfsense" would be a clearly applicable vendor/product tag. Suggested "pfsense". That seems high confidence and unambiguous. Also "netgate"? I'd emit missing_tag target "pfSense", suggested "pfsense". Hmm, but the instruction says emit missing_tag only when unambiguously implied — pfSense is the product; the tag list lacks it. Yes. Should I flag "PHP"? captive_portal_

SQL injection in OASYS sysoa 1.0 lets remote attackers inject arbitrary SQL through the unsanitized 'outtype' parameter of the /outaddresspaging endpoint. The CVSS 3.1 vector (PR:N) indicates no authentication is required, and the advisory claims the flaw can be escalated to arbitrary code execution. A public write-up with proof-of-concept details exists on GitHub, though EPSS estimates only a 0.20% exploitation probability and the CVE is not on CISA KEV - no public exploit is confirmed weaponized in the wild.

Stack corruption with potential code execution in MOOS core-moos through version 10.4.0 arises from an off-by-one error in CMOOSSerialPort::GetTelegram(), where a NUL terminator is written one byte past the end of a fixed-size stack buffer. An attacker who controls the serial communication line connected to a MOOS-enabled platform can send a full-length telegram to trigger the overwrite, corrupting adjacent stack memory and potentially redirecting execution. A vendor patch is available via GitHub PR #73 and commit befb04df; no public exploit has been identified at time of analysis.

Code injection in SeaCMS's Locoy Collector module (versions up to 13.6) allows remote unauthenticated attackers to execute arbitrary PHP code by manipulating the `pwd` argument to the `parseIf` function in `seacms_locoy_news.php`. A publicly available proof-of-concept exploit exists, documented in a GitHub security advisory, elevating practical risk above the conservative 6.9 base score. The provided CVSS 4.0 impact metrics (VC:L/VI:L/VA:L) conflict with the 'RCE' tag - PHP code injection in a CMS context typically yields full server-side code execution, suggesting the vendor scoring may significantly understate actual impact.

OS command injection (CWE-78) in WSO2's shared Carbon Console administrative interface allows an authenticated administrator with adjacent network access to execute arbitrary operating system commands, leading to complete compromise of the affected system. The vulnerability spans at least eight WSO2 middleware products - including API Manager, Identity Server, Open Banking components, Traffic Manager, Universal Gateway, and API Control Plane - all of which share the Carbon Console administrative layer. The CVSS scope-change flag (S:C) indicates that successful exploitation extends impact beyond the WSO2 application boundary to the underlying host and potentially adjacent systems.

CSV injection (CWE-1236) in Hitachi Energy MicroSCADA SYS600 allows attackers who can write arbitrary entries to the Notify service log to embed malicious spreadsheet formulas that execute when a Windows operator exports and opens the log as a CSV file. Impact ranges from cell data manipulation and link insertion to conditional code execution on the operator's workstation, contingent on the target's spreadsheet application security configuration. No active exploitation or public proof-of-concept has been identified; Hitachi Energy has published a security advisory documenting the issue.

Shortcode injection in the Brave WordPress plugin before 0.8.8 allows unauthenticated remote attackers to execute arbitrary WordPress shortcodes server-side by passing crafted values through URL parameters designed for pre-filling form fields. The exploitable shortcodes and their consequences depend entirely on which shortcodes are registered on the target installation - ranging from information disclosure to, in worst-case scenarios involving code-execution shortcodes, elevated impact. A publicly available proof-of-concept exists per WPScan; no active exploitation (KEV) has been confirmed. The CVSS score of 4.8 with AC:H reflects that real-world impact is highly site-dependent.

Control-character (newline) injection in Yoast SEO Premium before 27.6.1 allows an authenticated WordPress Author to write arbitrary Apache directives into the site's root .htaccess file via unsanitized redirect origins in file-based redirect mode. On Apache servers that process PHP directives, the injected auto_prepend_file directive can be chained with a polyglot image upload (available to Author-role users) to achieve full Remote Code Execution as the web server process. A public exploit is available via WPScan, making real-world exploitation feasible wherever the three required conditions align.

Remote code execution in Rockwell Automation FactoryTalk® Historian Machine Edition allows an adjacent-network attacker holding low-privilege credentials to fully compromise the historian host via a memory corruption flaw. The root cause is CWE-787 (Out-of-bounds Write), consistent with a buffer overflow in the historian's network-facing service, yielding full confidentiality, integrity, and availability impact on the affected device. No active exploitation has been confirmed in CISA KEV and no public proof-of-concept has been identified at the time of analysis.

Cross-site scripting in @pdfme/schemas before 5.5.9 allows any party who can supply a malicious template to execute arbitrary JavaScript in the browsers of users who render Select schema components. The Select plugin's UI renderer interpolates template-controlled option values directly into an innerHTML assignment without HTML encoding, meaning a value containing `">` breaks out of the attribute context and injects arbitrary HTML and event handlers. A detailed proof-of-concept is publicly documented in GHSA-qq9g-96v4-m3cj; no active exploitation is recorded in CISA KEV at time of analysis.

Code injection in yaojingang GEOFlow versions up to 2.1.0 allows a remote superadmin to execute arbitrary PHP on the server by submitting a malicious Blade template payload to the preview function of the Superadmin Theme Editor (SiteThemeEditorController.php). A publicly available proof-of-concept exploit has been disclosed via GitHub issue #60, and the attack requires no user interaction beyond the attacker's own authenticated session. Vendor-released patch version 2.1.1 resolves the issue; no confirmed active exploitation (CISA KEV) has been recorded at time of analysis.

AshAdmin's Table, DataTable, and Show LiveView components constructed row-action URLs via raw Elixir string interpolation, splicing unencoded record primary keys directly into query strings. Attackers who control a record's string primary key - common in Ash applications using slugs or email addresses as identifiers - can craft a key containing query-string metacharacters (e.g., `legitimate-slug&action_type=destroy`) that override URL parameters when an administrator clicks a row-action link, silently redirecting them to an unintended action such as resource destruction. No public exploit code has been identified at time of analysis; exploitation requires write access to a string-keyed Ash resource and active administrator interaction, affecting ash_admin 0.3.0-rc.0 through 1.3.0.

Remote code injection in SeaCMS 13.6 and earlier allows unauthenticated network attackers to execute arbitrary code by passing malicious input through the `searchtype` parameter, which flows into the `parseIf` function of the template engine in `search.php` without adequate sanitization. A public proof-of-concept exploit has been disclosed on GitHub under the title 'cascade-template-rce,' materially lowering the attack threshold for any internet-exposed instance. No vendor-released patch has been identified at time of analysis; publicly available exploit code exists.

Improper privilege management in the Really Simple Security WordPress plugin before 9.8.0 permits a subsite administrator on a WordPress multisite network to install an arbitrary plugin from a user-supplied URL, placing attacker-controlled PHP code into the network-shared plugin directory normally reserved for network (super) administrators. Successful exploitation achieves remote code execution with full confidentiality, integrity, and availability impact across the entire multisite network. A public proof-of-concept is available via WPScan, though EPSS remains low (0.15%) consistent with the high-privilege, non-default-configuration prerequisites; no confirmed active exploitation (CISA KEV) is recorded at time of analysis.

Arbitrary file write via path traversal in the WPvivid - Backup, Migration & Staging WordPress plugin (versions before 0.9.133) allows high-privilege WordPress administrators to extract backup archives with traversal sequences that write files outside the designated restore directory. A publicly available proof-of-concept exists per WPScan, though EPSS sits at 0.17% (7th percentile) and CISA KEV lists no active exploitation at time of analysis. Successful exploitation can lead to remote code execution by placing malicious PHP files in web-accessible directories.

Heap buffer overflow in U-Boot's do_mv shell command (fs/fs.c) affects all versions through v2026.01-rc4 and allows an attacker with U-Boot shell access to corrupt pre-boot heap memory and potentially execute arbitrary code before any OS-level security controls activate. The flaw is rooted in missing bounds checks during string length addition when constructing move-command path arguments: integer overflow causes a heap under-allocation, which is then overflowed by an unchecked strcpy() call. No public exploit code or active exploitation has been identified, and the upstream fix is confirmed in v2026.04-rc1.

Integer overflow in U-Boot's SquashFS filesystem parser (fs/squashfs/sqfs.c, function sqfs_concat_tokens) enables heap under-allocation followed by a heap-based buffer overflow via strcpy() when a crafted SquashFS image with manipulated token lists is processed during boot. All U-Boot releases through v2026.01-rc4 are affected. No public exploit code and no CISA KEV listing have been identified at time of analysis; a confirmed fix is available in v2026.04-rc1 (commit adccdb2).

Zephyr RTOS's WireGuard VPN receive handler in wg_process_data_message() commits permanent peer-state mutations - endpoint roaming update, liveness timer refresh, and keypair promotion - before validating the anti-replay counter, allowing an on-path attacker who captures a single valid encrypted datagram to replay it from a spoofed source address and hijack the tunnel endpoint. Because AEAD decryption succeeds for any authentic ciphertext regardless of freshness, the spoofed replay is processed as legitimate and irreversibly alters peer state before the replay check fires and returns -EINVAL. No public exploit has been identified at time of analysis; patch is available via upstream commit 260c32ef.

Reflected JSON injection in PrivateBin v2.0.4 and earlier allows remote unauthenticated attackers to inject arbitrary key/value pairs into JSON-LD API responses served at the /?jsonld= endpoint. PHP's FILTER_SANITIZE_URL passes double-quote characters through unmodified into JSON template construction via str_replace(), breaking out of the JSON string context and reflecting attacker-controlled fields. The vulnerable response path additionally omits X-Content-Type-Options: nosniff while setting Access-Control-Allow-Origin: *, enabling any cross-origin structured-data consumer to read the manipulated output. No public exploit or KEV listing exists, though the advisory includes a dynamically verified proof-of-concept on v2.0.4.

Memory corruption in the TP-Link TL-WR841N v14 embedded HTTP service allows an unauthenticated attacker with adjacent network access to trigger a buffer overflow by submitting a crafted multipart/form-data request containing an oversized boundary parameter. The confirmed impact is limited to undefined application behavior resulting from process memory corruption; TP-Link's own advisory and the CVE description both explicitly state that arbitrary code execution, information disclosure, and denial-of-service have not been demonstrated, despite those labels appearing in the CVE tags. No public exploit code has been identified at time of analysis, and this CVE is not listed in CISA's Known Exploited Vulnerabilities catalog.

Archive symlink traversal in aquaproj/aqua prior to v2.60.1 enables an attacker who controls a tool archive to write arbitrary files outside the extraction directory with the privileges of the user running aqua. The vulnerable combination in `pkg/unarchive/archives.go` - creating a symlink without destination validation, then following it with a regular file write - allows a malicious tar.gz to overwrite files such as shell startup scripts or PATH entries, resulting in user-level code execution. A working PoC is confirmed in GHSA-mf5c-hw34-4hpp; no CISA KEV listing is present and EPSS data is unavailable for this CVE.

Out-of-bounds memory write in libsolv crashes RPM-based package manager tools (dnf, yum, zypper) when processing a corrupted or specially crafted .solv repository cache file. The root cause is an absent array-index bounds check on directory-id values read from compressed filelist data during .solv file rewriting - but because the out-of-bounds write stores only a fixed, non-attacker-controlled value, the vendor explicitly rules out arbitrary code execution, confining impact to denial of service. No public exploit has been identified and no active exploitation is confirmed; note that the 'RCE' metadata tag conflicts directly with the description and appears to be erroneous.

Memory corruption via out-of-bounds write in OX Dovecot Pro and OX Dovecot CE's ManageSieve service allows authenticated network attackers to crash the ManageSieve process, denying all users the ability to remotely manage Sieve email filter scripts. The root cause is improper handling of extreme numeric literals during Sieve script compilation. The vendor notes that remote code execution may theoretically be achievable via the same memory corruption primitive, though no public exploit demonstrates this; no public exploits are known and the vulnerability is not listed in CISA KEV.

Heap buffer overflow in FFmpeg's TDSC screen-capture codec decoder exposes Red Hat Enterprise Linux AI 3 and OpenShift AI deployments to denial of service or potential arbitrary code execution. The tdsc_load_cursor() function performs erroneous stride-based pointer arithmetic in two locations when rendering cursor data from crafted TDSC video, writing past a heap-allocated buffer boundary. No public exploit or active exploitation has been confirmed at time of analysis, and the upstream fix is available as FFmpeg commit 242ff799c.

Unauthenticated remote PHP function invocation in the Tutor LMS WordPress plugin (all versions up to and including 4.0.5) allows any internet-accessible attacker to call arbitrary zero-argument PHP functions server-side via a missing-authorization AJAX handler combined with extract()-based variable injection into a template scope. The most critical demonstrated impact is persistent subscriber-level account creation through WordPress core's edit_user() function, which reads POST parameters directly, enabling unauthenticated user registration on any affected site. No CISA KEV listing has been identified at time of analysis, but Wordfence's detailed technical disclosure with specific file paths and line numbers substantially lowers the barrier for independent exploit development against the 6.5 CVSS-rated but trivially accessible unauthenticated attack surface.

Cross-site scripting via `javascript:` URI injection in Omeka S 4.2.0 allows an attacker who controls site navigation configuration to plant a malicious custom URL that executes arbitrary JavaScript in any visitor's browser when the navigation link is clicked. The flaw resides in the `Url.php` navigation link handler, which failed to reject URLs using the `javascript:` scheme. A researcher-published writeup exists, but no confirmed active exploitation or CISA KEV listing is present at time of analysis.

Cleartext cluster key disclosure in Wazuh 4.14.0-4.14.6 allows any low-privilege API user with the default readonly or cluster_readonly role to retrieve the shared secret that authenticates and encrypts all inter-node cluster traffic. The GET /cluster/local/config endpoint was missing the mask_sensitive_config decorator applied to every sibling config endpoint, causing the cluster.key field to be returned unredacted to accounts that are explicitly denied update-config permission. The severity of this information disclosure is amplified by prior Wazuh advisories that establish cluster-peer remote code execution chains contingent on possessing the cluster key, making this a practical stepping stone to full cluster compromise. No public exploit has been identified at time of analysis and the vulnerability is not in the CISA KEV catalog.

Code injection in RooCodeInc Roo-Code up to version 3.51.1 allows a remote low-privileged attacker to execute injected code via the `fetch_instructions` function within the MCP (Model Context Protocol) Integration Trust Model component (`malicious_mcp_server.py`). A publicly available proof-of-concept exploit exists on GitHub. Critically, the vendor has explicitly confirmed the product is no longer maintained - the repository is archived - meaning no patch will ever be released, permanently leaving all deployed instances vulnerable.

Code injection in RooCodeInc Roo-Code through version 3.51.1 allows remote attackers to execute arbitrary code via the ExecaTerminalProcess function in the README File Handler, triggered by passive user interaction with a crafted README file. The vendor has explicitly archived the repository and confirmed no patch will be issued, leaving all installed instances permanently unpatched. A public proof-of-concept exploit is available on GitHub; however, no active exploitation has been confirmed by CISA KEV, and the CVSS 4.0 score of 2.1 reflects limited impact ratings across all three CIA pillars.

Code injection in RooCodeInc Roo-Code up to version 3.51.1 allows a remote, low-privileged attacker with passive user interaction to inject and execute arbitrary code via the `optimizeQuery` function in the CodeIndexManager component (`src/utils/helpers.ts`). A public proof-of-concept exploit exists on GitHub. Critically, the vendor has explicitly archived the repository and will not issue a patch, leaving all users of this product permanently unpatched.

Reflected XSS in Netron desktop application versions 9.1.2 and earlier enables arbitrary JavaScript execution within the Electron/Chromium renderer by injecting payloads into unsanitized model node names, types, and attribute descriptions. Reported by HiddenLayer, the vulnerability allows an attacker who can deliver a crafted ML model file to hide graph nodes, conduct local network port scanning, and - when chained with a Chrome n-day exploit - escalate to full Remote Code Execution on the victim's machine. No public exploit has been identified at time of analysis, and the CVE is not currently listed in the CISA KEV catalog.

Reflected XSS in Netron ≤9.1.2 desktop application executes attacker-controlled JavaScript when a user opens a specially crafted ML model file containing malicious node names, descriptions, or type labels. Because Netron is Electron-based, XSS runs in a privileged Chromium renderer context - enabling SSRF-style local port scanning and, when chained with an unspecified Chrome n-day vulnerability, potential remote code execution on the host. No public exploit confirmed at time of analysis, but HiddenLayer published a security advisory documenting the impact chain.

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.