Remote Code Execution

Unauthenticated remote code execution in WeRSS (we-mp-rss) through 1.5.3 allows any attacker who can reach the public GET /rss/{feed_id} endpoint to run arbitrary OS commands as the service account. The flaw is a server-side template injection (CWE-95) in the template parser: by supplying a non-built-in ext value together with a {{=expression}} template, an attacker uses object-subclass traversal to bypass the eval denylist and reach command execution, with no authentication, user interaction, or non-default configuration required. Reported CVSS is 9.3 (CVSS 4.0, AV:N/AC:L/AT:N/PR:N/UI:N) and our independent assessment confirms remote, unauthenticated exploitation with high confidentiality, integrity and availability impact, rating this a genuine high-priority vulnerability rather than a high-CVSS-but-low-real-risk case; no public exploit code was identified at time of analysis, though a public technical writeup of the exploitation chain and a VulnCheck advisory are referenced.

Memory corruption in RIOT OS (versions prior to 2026.04) with the ATWINC15x0 Wi-Fi driver and MODULE_ATWINC15X0_DYNAMIC_CONNECT enabled allows an adjacent unauthenticated attacker to trigger a buffer overflow by advertising a malformed or oversized SSID, potentially leading to a hard fault, denial of service, or code execution. Exploitation requires the device to perform a Wi-Fi scan and the attacker to be within radio range. No public exploit code has been identified at time of analysis, and the vendor has released a patch in version 2026.04.

Use-after-free in MariaDB Server's SYS_REFCURSOR handling (12.3.1 through 12.3.2, and the 13.0.x branch before 13.0.2) lets an authenticated, low-privileged database user crash the server and corrupt server memory by declaring and opening more than the default 16 SYS_REFCURSORs inside a stored routine and then fetching from one of them. The flaw is a stale-reference bug in the cursor array: when the array is reallocated to grow beyond its initial 16 slots, routine-context references still point at the freed element, and the resulting use-after-free can be leveraged for remote code execution only when chained with a second, separate vulnerability. Authentication is required (CVSS PR:L, AV:N), and no public exploit code or confirmed active exploitation has been identified at the time of analysis; the vendor CVSS of 9.9 is high, but practical impact is bounded by the narrow affected version range and the need for CREATE ROUTINE/EXECUTE privileges plus a second bug to convert memory corruption into code execution.

An out-of-bounds write in MariaDB Server's spatial WKT serialization allows an authenticated, low-privileged database user who can execute SQL against a GIS function to corrupt server memory by supplying a deeply nested GeometryCollection to ST_AsText/AsText. Affected builds are MariaDB 10.6.1 through the fixed releases 10.6.28, 10.11.19, 11.4.13, 11.8.9, 12.3.3 and 13.0.2; the assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (the published score of 9.9 assumes a scope change that the independent assessment does not confirm). There is no confirmation of active exploitation (the issue is not in CISA KEV), but the upstream fix commit contains a public regression test that reproduces the crash and constitutes a working proof-of-concept; the reliable standalone outcome is memory corruption and denial of service, with code execution only achievable in combination with a second vulnerability.

TuxGuitar versions before 2.1.0 will load and instantiate an attacker-supplied Java class contained in a crafted .tg tablature file, executing that class's constructor (and static initializer) with the privileges of the TuxGuitar process when the user opens the file. The document sets the gervil.soundbank.path property to an on-disk archive - the .tg file itself qualifies - whose META-INF/services/javax.sound.midi.Soundbank entry names a class bundled in that same archive, and the bundled Gervill media.sound.JARSoundbankReader loads it through an unverified URLClassLoader. The CVSS 4.0 vector is AV:L/AC:L/AT:N/PR:N/UI:P with a score of 8.5 (unauthenticated, no non-default configuration required), but the payload must be delivered as a document the victim opens, so real-world priority is moderated by that delivery model; no public exploit code has been identified at time of analysis and the issue is fixed in 2.1.0.

Arbitrary file upload in the DoubleScale All-in-One CRM WordPress plugin through version 1.5.1 allows authenticated attackers with subscriber-level access or higher to upload executable PHP files when the Helpdesk module is enabled, which can lead to remote code execution. The flaw is an unrestricted upload issue (CWE-434) with a CVSS 3.1 score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), and no public exploit was identified at time of analysis. The assessed exploitation conditions require both a valid low-privilege WordPress account and an active Helpdesk module, making the risk highest on sites that allow open user registration.

Remote code execution in the Theme-one The Grid WordPress plugin through version 2.8.1 allows network attackers to inject code or commands via the plugin's grid-generation code path, with the supplied CVSS:3.1 vector indicating AV:N/AC:L/PR:N/UI:N (unauthenticated and no user interaction per the vector, though the exact endpoint and authentication prerequisite should be verified in the Patchstack advisory). The provided vector rates this as 10.0 Critical with full confidentiality, integrity, and availability impact, while our independent assessment adjusts scope from Changed to Unchanged but still considers impact High. No public exploit identified at time of analysis, and no KEV or EPSS data was provided.

Authenticated OS command injection in the WP Photo Album Plus WordPress plugin (all versions up to and including 9.3.02.002) lets any WordPress user granted the plugin-defined wppa_upload capability execute arbitrary operating-system commands as the web-server user, achieving full server-side code execution where ImageMagick is the active image backend. Rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), the flaw is reachable through the update-photo AJAX action's value parameter, and no public exploit code was identified at time of analysis; the bug is not in CISA KEV. Because wppa_upload is a plugin-level privilege that administrators can delegate to lower-privileged roles, the effective attacker pool can extend well beyond site administrators on misconfigured sites.

Remote code execution via arbitrary file upload affects the YaySMTP WordPress plugin in all versions up to and including 2.7.7, where an authenticated subscriber-level user can upload executable files through the putFile function. The plugin relies on sanitize_file_name() without an allow-list, MIME check, or safe-extension rename, and its only server-side guard is a .htaccess file with 'Require all denied' that nginx and Apache with AllowOverride None ignore, so full RCE is achievable on those configurations. No public exploit code was identified at time of analysis and there is no confirmed CISA KEV active exploitation; exploitation requires authentication at subscriber level or above, which is commonly available when open user registration is enabled.

Unauthenticated arbitrary file upload in the ELEX WordPress HelpDesk & Customer Ticketing System plugin (all versions up to and including 3.3.7) lets a remote attacker write attacker-controlled files, including potentially executable ones, into the WordPress installation via email attachments processed by the initMailPart function, enabling remote code execution with a CVSS 3.1 base score of 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). No WordPress authentication or victim interaction is required; the only prerequisite is that the plugin's email-piping/IMAP mailbox feature is configured and actively polling an inbox, since the attacker reaches the vulnerable code simply by sending a crafted email to that monitored support mailbox. Exploitation is therefore configuration-dependent rather than universal, and sites that do not use IMAP mail fetching are not exposed; no public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor fix is available in version 3.3.8.

Arbitrary file deletion in the Groundhogg CRM, Newsletters and Marketing Automation plugin for WordPress (all versions up to and including 4.9.3) lets an authenticated user who holds the plugin's import_contacts capability - granted by default to Groundhogg's custom Sales Representative role - name an arbitrary server-side path and have the plugin delete it, with a realistic escalation to remote code execution (for example by removing wp-config.php). The flaw is reachable through the contact-import (CSV), REST API, and webhook paths that call copy_file, and it received a CVSS of 8.1 (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:H); there is no CISA KEV listing and no public exploit code identified at time of analysis. The practical risk is bounded by the authentication requirement and by the attacker's need to know or guess the absolute path of a valuable target, but the capability is assigned by default and no user interaction or non-default configuration is needed, making this a credible, actionable priority rather than an inflated high-CVSS issue.

Unauthenticated file upload in the WordPress plugin Mang Board (all versions up to and including 2.4.4) lets an anonymous visitor place executable content on the server and reach remote code execution, because the mbw_file_upload handler enforces its extension allowlist only on the file_name parameter while the filename actually saved is derived from the unvalidated image_path parameter. Exploitation fits the assessed CVSS 9.8 vector (AV:N/AC:L/PR:N/UI:N), requiring no WordPress account and no user interaction: guest posting is the plugin's default board mode, and the nonce the request must carry is printed on every public board page and therefore readable by any unauthenticated visitor. No public exploit code has been identified at time of analysis; the practical limiting factor is configuration, since an administrator who has disabled guest posting removes the unauthenticated attack surface.

Heap out-of-bounds write in FreeRDP before 3.32.0 allows a malicious RDP server to corrupt a connecting client's memory by sending crafted RDPGFX AVC444 or AVC444v2 frames, potentially enabling code execution through heap corruption. The flaw is in general_LumaToYUV444 and general_ChromaV2ToYUV444 and triggers when an odd-height region rectangle ends exactly at the surface height, causing writes past the U/V planes. Exploitation requires the victim's client to initiate or accept an RDP session with an attacker-controlled or compromised server and negotiate the affected H.264 YUV444 codec; no public exploit identified at time of analysis, and clients limited to trusted RDP hosts face substantially lower realistic risk.

Heap buffer overflow in FreeRDP before 3.32.0 can let a local attacker corrupt heap memory and potentially execute code when the victim loads a crafted persistent bitmap cache v2 file, because persistent_cache_read_entry_v2 miscalculates bitmap sizes via integer wraparound and then performs fixed 16 KiB reads against mismatched entry-size accounting. Exploitation requires the local attacker to place a malicious cache file in the client's load path and relies on low-level local privileges plus user interaction (PR:L/UI:P), so there is no remote unauthenticated path; no public exploit identified at time of analysis. No CISA KEV entry was provided, making this a moderate-priority local risk rather than a mass-exploitation threat.

Arbitrary code execution in DeepSeek Harness (dsh) at commit c291e796 stems from an untrusted search path weakness, letting an attacker plant a crafted executable in a location dsh consults when resolving content, so that the malicious file is run in place of the legitimate one. Exploitation is not automatic: per our independent assessment the attacker first needs write access to a searched directory (or control of a shared/current working directory) and then must induce a victim to open or run the substituted content, so the realistic vector is local with user interaction (AV:L/UI:R), not the network-facing, no-interaction 10.0 score supplied in the source feed. Publicly available exploit code exists (SSVC exploitation status 'poc', with a PoC repository referenced), the issue is rated fully automatable with total technical impact, and no CISA KEV listing was provided - so this is a proof-of-concept-stage risk rather than confirmed active exploitation.

Opening an attacker-crafted repository in Z.ai ZCode v3.11.2.6792 can lead to arbitrary code execution because the IDE automatically connects to MCP (Model Context Protocol) servers declared in the repository's workspace configuration without requiring user approval. The flaw is rated CVSS 7.8 with a local attack vector and required user interaction - a victim must actively open the malicious repository - and publicly available exploit code exists, though there is no confirmed active exploitation (not in CISA KEV), so the threat is conditional and interaction-dependent rather than a mass-exploitation emergency. Exploitation is unauthenticated from the attacker's perspective and grants high confidentiality, integrity, and availability impact on the affected host.

Improper authorization in Lenovo Baiying PC Client - software distributed exclusively in the Chinese market - lets a local, already-authenticated user execute arbitrary code with elevated privileges, resulting in high impact to confidentiality, integrity, and availability. The vendor rates it 7.0 under CVSS 4.0 (CVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N), and our independent CVSS 3.1 assessment is consistent: the vector is strictly local (AV:L), requires a valid logged-in session (PR:L) and some passive user interaction (UI:P), so it is not remotely triggerable. There is no public exploit identified at time of analysis and the CVE is not in CISA KEV, so real-world risk is concentrated in Chinese-market endpoints where a low-privileged local user has interactive access.

Arbitrary code execution in the Lenovo Legion Zone application allows an attacker positioned on the same logical network (shared LAN or Wi-Fi segment) to run code of their choosing on the affected host. Exploitation requires the attacker to already hold low-level privileges on the network (CVSS PR:L), needs no user interaction, and can affect confidentiality, integrity, and availability - reflected in the reported CVSS 4.0 base score of 8.6 (assessed as CVSS 3.1 8.2-equivalent, AV:A/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The issue is a moderate-to-high severity but realistically constrained problem, because Legion Zone is distributed exclusively in the Chinese market and the attack surface is limited to adjacent-network reachability; no public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV.

Memory corruption in Google Chrome's Workers component affects versions prior to 155.0.8059.84 and can allow a remote attacker to execute arbitrary code inside the browser's renderer sandbox when a victim visits a crafted HTML page. The CVSS vector indicates network reachability, no authentication, and required user interaction, with high confidentiality, integrity, and availability impact inside the sandbox; however, Scope is Unchanged, so full host compromise requires a separate sandbox escape. Assessment signals conflict and should be weighed carefully: CVSS is 8.8 while Chromium rated it Medium, SSVC says exploitation is none and automatable is no, and no public exploit identified at time of analysis; a vendor patch is available.

Use-after-free in Google Chrome's compositing pipeline lets an unauthenticated remote attacker execute arbitrary code within the browser sandbox when a victim loads a crafted HTML page in any Chrome build prior to 155.0.8059.84. The flaw carries a CVSS 3.1 score of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) even though Google rates it Chromium severity Medium, and no public exploit has been identified at time of analysis, with CISA's SSVC assessment recording no observed exploitation. Because the resulting code execution stays inside the sandbox, full host compromise would require chaining a separate sandbox escape, which tempers the real-world severity despite the high vector score.

Improper input validation in Google Chrome Desktop versions prior to 155.0.8059.84 could let a remote attacker execute arbitrary code outside the browser sandbox when a victim loads a crafted HTML page. The CVSS 3.1 vector scores 9.6 (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H), meaning no authentication is required but the victim must interact with attacker-supplied content, and the Changed Scope rating implies a security-boundary crossing such as an escape from the renderer sandbox - a non-trivial step that CISA's SSVC rates as not automatable. Despite the critical base score, the practical risk signal is mixed at time of analysis: exploitation status is none per SSVC, no public exploit code has been identified, and EPSS is only 0.21% (11th percentile), while Chromium's own severity classification for this issue is Medium and a vendor patch is available.

Memory corruption in the V8 JavaScript engine of Google Chrome before 155.0.8059.84 lets a remote, unauthenticated attacker achieve arbitrary code execution inside the browser's renderer sandbox when a victim loads a crafted HTML page. Exploitation requires user interaction (CVSS UI:R) - the target must navigate to attacker-controlled or compromised web content - and no public exploit code has been identified at time of analysis, with CISA SSVC rating current exploitation as 'none'. Because the code execution is explicitly confined to the sandbox (S:U), full host compromise would require chaining a separate sandbox-escape vulnerability, making this a high-priority patch item rather than an emergency.

Use-after-free in the V8 JavaScript engine in Google Chrome before 155.0.8059.84 allows unauthenticated remote attackers to achieve arbitrary code execution inside the renderer sandbox by persuading a victim to load a crafted HTML page; only default JavaScript settings are required, with no privileges needed (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H). Vendor patches are available in Chrome 155.0.8059.84, and no public exploit code has been identified at time of analysis per CISA SSVC (Exploitation: none). The resulting code execution is confined to the renderer sandbox, so a separate sandbox-escape vulnerability would be required to compromise the underlying host; the exposure window closes once the browser auto-updates to the patched build.

Use-after-free in the V8 JavaScript engine of Google Chrome before 155.0.8059.84 allows a remote attacker to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page. Successful exploitation is gated by mandatory user interaction (CVSS UI:R) and needs no authentication (PR:N), so a single visit to an attacker-controlled or compromised page is enough, though the resulting code execution stays confined to the renderer sandbox under the assessed S:U scope and would require a separate sandbox-escape to compromise the host. No public exploit code or active exploitation has been identified at time of analysis, and a vendor patch is available in release 155.0.8059.84 (Chromium severity: High).

Memory corruption in Google Chrome's DOM implementation allows remote attackers to execute arbitrary code within the browser's renderer sandbox by convincing a victim to load a crafted HTML page. All Chrome builds prior to 155.0.8059.84 are affected; exploitation is unauthenticated (CVSS PR:N) but requires the user to navigate to attacker-controlled content (UI:R), and the resulting code execution is contained by the sandbox (S:U), so host compromise would require a separate sandbox-escape vulnerability. No public exploit has been identified at time of analysis and CISA's SSVC assessment rates exploitation as none, though the vendor's Chrome severity rating is High and technical impact is total for the compromised renderer; a vendor patch is available in Chrome 155.0.8059.84 and the corresponding extended stable update.

Use-after-free in Google Chrome's Prerender component allows remote attackers to execute arbitrary code inside the renderer sandbox when a victim navigates to a crafted HTML page, and Google rates the flaw Critical with a CVSS base score of 8.8. All Chrome builds prior to 155.0.8059.84 are affected, and exploitation requires user interaction (UI:R) since the attacker cannot trigger the flaw without the victim loading the malicious content, though no authentication or special privileges are needed. Vendor-released patch: 155.0.8059.84; no public exploit code or confirmed active exploitation has been identified at time of analysis, and the SSVC assessment records exploitation as none, making this a high-priority patching target rather than an emergency.

Remote code execution in Jooan JA-A12 IP cameras running firmware 009_20171107 or 05.02.31.105 allows unauthenticated attackers to execute root-level commands by abusing hard-coded credentials. An attacker sends singleCMD=SetDiagMode to /goform/SingleHandlebyCommand with attacker-controlled authserverip and authcode values, causing the jooandiag daemon to run commands through /bin/sh and granting full device control. Publicly available exploit code exists, and the provided CVSS 4.0 score is 9.3; no CISA KEV listing is present in the supplied data.

Heap-based buffer overflow in Microsoft Office (Windows and macOS builds: Microsoft 365 Apps for Enterprise, Office LTSC 2021/2024, and Office 365/LTSC for Mac) allows unauthenticated remote attackers to execute arbitrary code when a victim opens a crafted document. Exploitation requires user interaction (UI:R in the CVSS vector) and is not zero-click, executing with the victim user's privileges rather than SYSTEM. No public exploit has been identified at time of analysis, and a vendor patch is available per the Microsoft advisory (CVE-2026-108444).

Authenticated Dolibarr users with privileges to write extrafields, export configurations, or blocked log entries can trigger PHP object injection in versions before 23.0.4, potentially leading to code execution or file manipulation if a suitable gadget chain exists. The flaw resides in jsonOrUnserialize() and requires the stored payload to be non-JSON so that unserialize() runs without class restrictions; exploitation is high-complexity and no public exploit has been identified. Upgrading to 23.0.4 or later is the only complete fix.

Authorization bypass in Netgate pfSense CE through 2.9.0 allows an authenticated WebGUI account that holds page privileges for services_acb.php, uploadconfig.php, diag_confbak.php, or diag_backup.php to replace config.xml despite lacking the 'User - Config: Deny Config Write' privilege; the account can otherwise be read-only. Successful exploitation can yield root-level code execution after a configuration reload or reboot, and publicly available exploit code exists. The independent assessment scores this CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (8.6), reflecting a remote authenticated low-privilege attacker with high confidentiality, integrity, and availability impact.

Native code execution inside the shim zygote process is possible in runwasi's containerd-shim-wasmtime-v1 prior to 0.6.1 when a victim pulls and runs an attacker-crafted OCI image whose single Wasm layer is actually Wasmtime precompiled (serialized native-code) bytes. Because the shim trusts precompiled-format bytes from image layers as if they came from the trusted precompile-cache path, it deserializes them without normal WebAssembly validation, yielding the filesystem, environment, credentials, networking, and Linux syscall access of the workload container; the escape reaches the workload container boundary but does not by itself break container isolation or give direct host code execution. Per the CVSS vector the attack is network-reachable with no privileges (PR:N), though the independent assessment notes required user interaction (UI:R) to induce the victim to run the image; no public exploit code or confirmed in-the-wild exploitation was identified at time of analysis, and the issue is fixed in 0.6.1.

Remote code execution in Telegram's bundled rlottie library allows an attacker to execute arbitrary code in the context of the current process when a victim opens a malicious Lottie/TGS animation. The flaw is a numeric truncation error (CWE-197) that results in an out-of-bounds write before the start of an allocated buffer, requiring user interaction (UI:R) and high attack complexity (AC:H) to exploit; the CVSS vector is AV:L, indicating a client-side file/content-handling issue. No public exploit has been identified at time of analysis, and no CISA KEV status is present.

Heap-based out-of-bounds reads and writes in bincookie prior to 0.1.9 occur when an application calls bincookie_init_file() on an attacker-supplied .binarycookies file, allowing the crafted input to drive byte-swap and iteration loops past a heap buffer sized only to the real file length. The vulnerable parser trusts file-controlled num_pages, page_sizes, and cookie_offsets as loop bounds, so malformed files can crash the host application or corrupt heap metadata in ways that could potentially lead to code execution. Exploitation requires local delivery of the crafted file and user interaction to make the target application parse it (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, score 7.8); no authentication to the parsing application is needed, and there is no public exploit identified at time of analysis. Version 0.1.9 fixes the issue by rejecting malformed files.

Amazon Neptune engine versions prior to 1.5.0.0 contain a deserialization flaw in the Gremlin graph data import component that lets an authenticated remote actor holding standard database permissions execute arbitrary code and reach internal service credentials. Exploitation requires working database credentials and network access to the Gremlin import interface, so exposure is greatest in multi-user, multi-tenant, or lower-trust deployments where untrusted parties hold standard DB accounts; no public exploit code or confirmed active exploitation was identified at time of analysis, but the high CVSS 4.0 score (9.4) and our independent CVSS 3.1 assessment (8.8, scope-changed, high confidentiality/integrity/availability impact) confirm this is a genuine high-priority issue rather than a CVSS-inflated one. Vendor-released patches are available as engine version 1.5.0.0 with backports to 1.4.8.1 and 1.4.7.1, and clusters enrolled in auto-update may be remediated without operator action.

Jinja2 template injection in Ansible Operator Plugins (CWE-1336) lets an authenticated Kubernetes user who can create or modify a custom resource reconciled by an affected Ansible-based operator execute embedded Jinja2 expressions inside the operator pod, achieving remote code execution and escalating to the operator's service account. Because these operators typically hold cluster-wide RBAC, successful exploitation crosses a privilege boundary (CVSS 3.1 base 8.5, AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H), affecting components of Red Hat Ansible Automation Platform 2, Red Hat Advanced Cluster Management for Kubernetes 2, the Migration Toolkit for Applications/Containers/Virtualization, OpenShift Service Mesh 3 and related Red Hat OpenShift and OpenStack streams. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis; the high attack complexity reflects the prerequisite that the targeted operator must pass attacker-controllable CR spec values into Jinja2 templating without sanitization. This is a genuinely high-priority flaw rather than a CVSS-inflated one, but with an important authentication caveat: purely anonymous or read-only users cannot trigger it.

Remote code execution affects JetBrains TeamCity releases older than 2026.2, 2026.1.4, and 2025.11.8, where a type-whitelist bypass in the build messages protocol lets a serialized payload cross the deserialization trust boundary and execute code in the server process; the flaw carries a CVSS of 9.8 (AV:N/AC:L/PR:N/UI:N, unauthicated per the PR:N vector). There is no public exploit identified at time of analysis, CISA's SSVC records Exploitation as 'none' with Automatable set to 'no', and EPSS is low at 0.38% (31st percentile), though Technical Impact is rated 'total'. JetBrains has released fixes, so the primary risk is unpatched, network-reachable TeamCity servers whose agent-facing build messages channel is exposed beyond trusted build-agent hosts.

Code execution in JetBrains Junie CLI before 26.8.3 allows an attacker to run arbitrary code via a malicious MCP server configuration embedded in an untrusted project. The victim must open and interact with the project (user interaction required), and local access is necessary, but no privileges are required. No public exploit code has been identified at time of analysis.

Server-side template injection in SolusVM 2 up to and including build 2.0.0-44576 lets a remote authenticated user run arbitrary code as root on the management node, so a single low-privileged panel account - a client, reseller, or sub-account on the hosting provider's instance - is enough to potentially take over the underlying virtualization infrastructure. Exploitation requires valid credentials (CVSS PR:L) and no user interaction (UI:N), which is the primary limiting factor and excludes fully anonymous attackers, but because the injected template reaches a code-execution sink running with root privileges the confidentiality, integrity, and availability impact is high across both the vulnerable component and dependent systems (CVSS 9.4). No public exploit identified at time of analysis and the flaw is not reported as confirmed actively exploited.

PHP object deserialization in EspoCRM versions prior to 9.3.7 lets an authenticated administrator achieve remote code execution by storing crafted serialized object data in background MassAction or Export parameters that the application later unserializes without any allowed-class restriction. The deserialization sinks are reachable over the network (AV:N) with no user interaction (UI:N), and an attacker with admin credentials can instantiate arbitrary PHP objects and execute code, provided a usable gadget chain is reachable in the deployed codebase or its dependencies. Publicly available exploit code exists, and the vendor released a fix in version 9.3.7; the practical limiting factor is the administrator-privilege prerequisite (PR:H), which tempers real-world urgency even though the flaw is rated 9.1.

Local privilege escalation in TotalAV versions up to 7.1.17 allows an authenticated but unprivileged local user to impersonate the SYSTEM service by forging a gRPC IPC authentication token, leading to arbitrary code execution as NT AUTHORITY\SYSTEM. Publicly available exploit code exists (a proof-of-concept C file is linked in the disclosure), though CISA KEV does not list the vulnerability as actively exploited, and the SSVC assessment rates exploitation as 'poc' with total technical impact. Exploitation requires a local foothold and the vulnerable TotalAV service to be running; it cannot be triggered remotely or against hosts without TotalAV.

Authenticated administrators on a connected P4 Server can exploit a relative path traversal (CWE-23) in P4 Search 2026.4.2 and earlier by supplying a crafted logging configuration, causing files to be written or deleted outside the intended logging directory and potentially achieving code execution as the P4 Search service account. Perforce resolved the issue in P4 Search 2026.4.3; no public exploit code has been identified at time of analysis (no CISA KEV listing), and because a P4 Server administrative account is a hard prerequisite, this is a genuine but conditional integrity/availability risk rather than a mass-exploitation priority.

Siemens Software Center (all versions) loads dynamic-link libraries from an uncontrolled search path, allowing an authenticated local attacker with high privileges to stage a crafted DLL where the application will load it and achieve arbitrary code execution in the application's context, with full confidentiality, integrity, and availability impact on the affected host. The vendor scores this CWE-427 DLL-hijacking issue CVSS 4.0 8.4 (AV:L/AC:L/AT:N/PR:H/UI:N), and our independent assessment agrees on the local vector, no user interaction, unchanged scope, and high C/I/A impact. There is no public exploit code identified at time of analysis and the flaw is not listed in CISA KEV; exploitation is constrained to a local, already highly privileged actor able to write to a directory on the loader's search path.

Path traversal in PeaZip's archive object preview handler allows a crafted archive entry to escape the extraction directory and be handed directly to ShellExecuteW, so a victim who opens a malicious archive on Windows and invokes 'Preview with... -> Associated application' (Shift+Ctrl+O) on the rogue entry can be made to launch an arbitrary program already present on their system without the usual dangerous-extension warning. Affected are PeaZip 11.2.0 and earlier on Windows; no authentication or elevated privileges are needed, but exploitation is interaction-gated (local file delivery plus a deliberate multi-step preview action, CVSS 4.0 base 8.4 with AV:L/UI:A/PR:N and high C/I/A impact). A proof of concept was demonstrated against official vendor builds on two archive formats (.zip and .tar), confirming the defect is in PeaZip's own path handling rather than a single format parser; no CISA KEV entry or independent confirmation of active exploitation was reported at time of analysis. The practical limitation is that the flaw launches programs that already exist at the resolved path (for example a system binary) rather than dropping new attacker-supplied binaries.

Eclipse Vert.x DB2 Client versions 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0 can deserialize attacker-controlled DRDA UDT column data, enabling remote code execution if a Java deserialization gadget chain is present on the classpath or denial of service otherwise. The affected component is io.vertx:vertx-db2-client, and exploitation requires an application to connect to a malicious or man-in-the-middle DRDA server that returns a result-set column tagged with FDOCA LID 0x50; legitimate DB2 servers never emit that type, and client-side TLS is disabled by default. The CVSS 4.0 score is 9.2 with PR:N, but practical exploitation requires attacker server-side/MITM position (AC:H) and, for RCE, a classpath gadget chain; no public exploit identified at time of analysis, and the real-world blast radius is narrower than the score alone suggests.

FreeBSD's bhyve hypervisor contains a guest-to-host race condition and input-validation flaw in its framebuffer/VNC device model, allowing a guest with existing code execution to crash the bhyve process or potentially execute code in the host userspace context, subject to bhyve's Capsicum sandbox. Only VMs configured with the fbuf framebuffer/VNC device are exposed, affecting FreeBSD 14.4 before p11, 14.5 before p2, and 15.1 before p5, while headless or serial-only guests are not affected by this path. The CVSS 3.1 vector is AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, requiring guest-level privilege and a difficult timing race, and no public exploit identified at time of analysis.

Out-of-bounds memory access in FreeBSD's bhyve hypervisor Intel HDA audio device emulation can be triggered by a privileged guest that supplies a zero-length Buffer Descriptor List entry and then modifies BDL fields after the hypervisor's validation step, causing an out-of-bounds read or write during DMA transfer processing. The concrete impact is a crash of the bhyve process or, potentially, arbitrary code execution in the host userspace context running the virtual machine, although any such execution remains confined by bhyve's Capsicum sandbox. Only hosts that expose the emulated HDA audio device to untrusted guests are affected, and exploitation requires local access from within a guest with device-programming privileges plus a high-complexity post-validation race (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, 7.0); no public exploit identified at time of analysis and the EPSS score is low at 0.18% (7th percentile).

FreeBSD's bhyve hypervisor xHCI (USB 3) device model can be driven into a guest-to-host memory race by a malicious privileged guest: the emulated controller neither validates nor caches the guest-supplied event ring size, re-reading it from guest memory on each use, and loads Transfer Request Block (TRB) fields without guarding against concurrent modification by the guest. Winning that race (CVSS 3.1 AV:L/AC:H/PR:L) crashes the host-side bhyve process or potentially yields arbitrary code execution in the host userspace running the VM, bounded by bhyve's Capsicum sandbox. Exploitation requires an attacker who already controls privileged code inside a guest configured with the bhyve xHCI controller; no public exploit code was identified at time of analysis, and EPSS is low at 0.18% (7th percentile), making this a moderate, defense-in-depth priority rather than an urgent emergency.

Remote code execution in ThemeHigh's Email Customizer for WooCommerce (Pro) through version 3.9.5 allows any authenticated user with subscriber-level access or higher to write attacker-controlled PHP into executable files inside the WordPress uploads directory through the plugin's send_test_mail() function, leading to full site compromise. The assessed vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (8.8) makes clear that the low-privilege account requirement is the main gate; exposure is greatest on WooCommerce stores that permit open customer/subscriber self-registration rather than manual account approval. Code execution also depends on the server permitting PHP to run from the uploads path, so sites that already harden that directory are materially less exposed, and no public exploit code has been identified at time of analysis.

Unauthenticated arbitrary file upload in the 10Web Booster WordPress plugin (tenweb-speed-optimizer) in all versions up to and including 2.34.10 allows remote attackers to place executable files on a target site, leading to remote code execution. The compressCustom REST endpoint fails to validate file type or extension on the page_id parameter, and the authentication check is bypassed because the plugin's tenwebio_rest nonce is written to a world-readable file under wp-content/uploads/ whenever a bulk optimisation batch pauses - a nonce minted in a cron/loopback context with user ID 0, so it is accepted for unauthenticated visitors. Our independent assessment rates this CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H (below the 9.8 base published elsewhere) because exploitation is conditional on the site having previously paused a bulk optimisation batch and on the uploaded file landing in a PHP-executable, web-accessible path; no public exploit code was identified at time of analysis and the CVE is not in CISA KEV.

Arbitrary OS command execution on hosts running MoviePilot through 3.1.5 is achievable when the product's LLM agent ingests attacker-controlled content via browse_webpage, search_web, or torrent metadata parsing and is induced to call the unrestricted ExecuteCommandTool, which runs shell commands through asyncio.create_subprocess_shell under the admin session's is_admin context. The flaw is a prompt-injection-to-RCE chain (CWE-1427) that bypasses the validate_command_safety denylist by setting confirm_dangerous=true; the attacker needs no MoviePilot credentials (CVSS PR:N), but an administrator must interact with the poisoned content (UI:P in CVSS:4.0, UI:R in the assessed CVSS:3.1) and the model must be successfully coerced, so the issue is conditionally gated rather than a mass-exploitation emergency. Severity is 8.7 in CVSS:4.0 and 8.7 in the independently assessed CVSS:3.1; no public exploit code and no CISA KEV entry are associated as of this analysis.

Remote code execution in GitPython 3.1.30 through 3.1.x allows unauthenticated attackers controlling the positional refspec argument to Remote.pull() to execute arbitrary OS commands via a crafted --upload-pack option, bypassing the library's keyword-only unsafe-option guard. The flaw affects local-path and SSH transports and is fixed in 3.2.0; no public exploit code has been identified at time of analysis, but the vulnerability carries a CVSS 4.0 base score of 9.2 and requires the calling application to pass attacker-controlled data as the positional refspec.

Remote code execution in GitPython releases before 3.2.0 (CVE-2026-110857) allows unauthenticated attackers to execute arbitrary commands through Git.ls_remote, which forwards a caller-supplied remote URL without the check_unsafe_protocols validation that normally blocks dangerous transports, notably ext:: remote-helper URLs when Git's protocol.ext.allow setting permits them. Exploitation is conditional rather than trivial: a consuming application must pass an attacker-controlled URL into the affected API (user interaction is required per the assessed CVSS:3.1 vector AV:N/AC:H/PR:N/UI:R), and a default Git configuration that rejects the ext transport blocks the primary ls_remote path, while the related merge_base and IndexFile.move option-injection paths remain similarly unguarded. No public exploit identified at time of analysis; the flaw is fixed in GitPython 3.2.0.

Authenticated code execution in n8n (before 1.123.83, 2.x before 2.41.4, and 2.42.x before 2.42.1) is possible through the Git node's Log operation, which invokes the external git program without stripping the target repository's local git configuration first. A member-level authenticated user who can point that node - including the scenario where the Git node is exposed as an agent tool the attacker can steer - at a repository whose local config they control can smuggle configuration directives that cause git to launch arbitrary programs as the n8n process user. There is no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV); the CVSS 4.0 base score is 7.7, and the independent assessment rates it CVSS 3.1 8.8 (AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H), with exploitation gated on valid n8n member credentials and attacker control of the repository's local configuration.

Markdown Preview Enhanced, the VS Code Markdown preview extension, fails to validate webview-to-extension-host messages prior to version 0.8.30: the handler in src/preview-provider.ts accepts any attacker-supplied _crossnote.{command} plus arbitrary args and forwards it to vscode.commands.executeCommand with no allowlist or type checking. JavaScript already running inside the preview webview - obtainable via the separately tracked .crossnote/head.html script-injection flaw (GHSA-mcwg-4j78-qwv3) - can therefore invoke privileged extension commands such as updateMarkdown, chromeExport, pandocExport, and runCodeChunk with attacker-selected arguments, enabling file writes, code-chunk execution, export-tool execution, and arbitrary URL opening within the victim's workspace context. Exploitation is conditional rather than standalone: it requires a pre-existing webview JavaScript execution primitive and a victim who opens and previews attacker-controlled repository content, and no public exploit code has been identified at time of analysis; both the bridge-abuse bug and its most practical trigger are resolved in 0.8.30.

Remote code execution in Markdown Preview Enhanced (a Visual Studio Code Markdown preview extension) before 0.8.29 lets a malicious repository run operating-system commands as the victim's account the moment the victim opens a Markdown file from that repository. The extension automatically evaluates repository-controlled .crossnote/config.js and .crossnote/parser.js files through vm.runInNewContext, and prototype-chain traversal escapes the Node.js host realm to reach the Function constructor and the process object - no further interaction and no module-scoped require are needed, and both the configuration-evaluation and parser-hook paths are affected. The vector requires local placement of the repository plus user interaction (opening the file), so it is not mass-exploitable over the network against a default install; there is no CISA KEV listing and no public exploit identified at time of analysis. The issue is fixed in Markdown Preview Enhanced 0.8.29, which bundles crossnote 0.9.30.

Authenticated attackers with high privileges on SonicWall Network Security Manager (NSM) on-prem can execute arbitrary OS commands via an OS command injection flaw (CWE-78), achieving remote code execution. The vulnerability affects NSM on-prem versions 4.3.1 and earlier, requires a privileged session (PR:H), and is assessed with high attack complexity (AC:H) due to unenumerated specific conditions. No public exploit code or active exploitation has been identified (CISA KEV status: none; SSVC exploitation: none), and the EPSS score is 0.54% (44th percentile), indicating a moderate-priority risk rather than an urgent emergency.

Arbitrary file access and operating-system command execution in Stirling-PDF prior to 2.13.2 are reachable by an authenticated administrator who uploads a crafted SQL file to POST /api/v1/database/import-database on instances running the default H2 database backend with security mode enabled. DatabaseService.validateSqlContent() splits the normalized input on semicolons and accepts a statement if it merely contains an allowed keyword, so dangerous H2 constructs such as FILE_READ, CSVWRITE and CREATE ALIAS slip past the whitelist and execute when RUNSCRIPT processes the import; the demonstrated chain writes attacker-controlled startup files to a user-site location and triggers the application's Python interpreter to load them, yielding command execution as the JVM service account. The CVSS 3.1 base score of 9.1 (CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:H) reflects network reachability with full confidentiality, integrity and availability impact and a scope change, but PR:H means the attacker must already hold administrative privileges and non-H2 deployments are unaffected; no public exploit code identified at time of analysis, and the issue is fixed in version 2.13.2.

Code injection in the VillaTheme Salevo WooCommerce plugin for WordPress (woo-boost-sales) affects all releases through 1.3.0 and lets a remote attacker reach a code-generation sink within the plugin, with the assessor's scoring indicating high impact to confidentiality, integrity and availability. The underlying vulnerability class is CWE-94 (Improper Control of Generation of Code), and the Patchstack advisory tags the issue as potential remote code execution; there is no confirmed actively exploited status (not in CISA KEV) and no public exploit code identified at time of analysis. Exploitation requires the plugin to be installed and active on a WooCommerce site, which meaningfully narrows the realistic attack surface; the exact vulnerable function, endpoint or parameter is not disclosed, and the published CVSS vector (PR:N) conflicts with the assessor's vector (PR:L), so the precise authentication precondition is not fully resolved from available data.

Authenticated file upload bypass in the FV Flowplayer Video Player plugin for WordPress (all versions up to and including 7.5.54.7212) allows a subscriber-level user to write attacker-supplied content to the server by slipping a crafted filename past the plugin's incomplete check_mimetype extension filter, which performs no MIME inspection and skips the standard WordPress upload helpers, potentially resulting in remote code execution. Exploitation is not unconditional: the plugin's non-default 'profile videos on bio' setting must be enabled so that the required nonce is emitted on the subscriber-accessible profile page, and the attacker must craft a filename that evades the partial extension enforcement; sites that keep registration closed or leave that option disabled are substantially less exposed. The published CVSS 3.1 vector is 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), while the assessed vector applies AC:H to reflect the non-default configuration prerequisite; no public exploit code identified at time of analysis, and the issue was reported by Wordfence.

Authenticated attackers holding high-privilege administrative access to the PAN-OS management interface can execute arbitrary code with root privileges on PA-Series and VM-Series firewalls and on Panorama (virtual and M-Series). The underlying weakness is a code-injection flaw (CWE-94) in the management plane that is network-reachable with low attack complexity, but the realistic attacker population is narrow because CVSS PR:H requires the adversary to already possess an authenticated high-privilege session, and Palo Alto's recommended practice of limiting management access to trusted internal IP addresses largely neutralizes the exposure. Cloud NGFW and Prisma Access are explicitly not impacted, and no CISA KEV entry or public exploit code is identified in the available data at time of analysis.

Remote code execution and denial of service in Juniper Networks Junos OS and Junos OS Evolved arise from a stack-based buffer overflow (CWE-121) in the httpd process that serves the J-Web management interface, reachable by an unauthenticated network attacker who can reach the J-Web HTTP(S) listener. The vendor-assigned CVSS 4.0 score is 9.3 (and our independent assessment maps this to CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, i.e. 9.8), reflecting full confidentiality, integrity and availability impact with no authentication or user interaction required; attack complexity is low in the base vector, though the real-world exploitable population is constrained by two configuration prerequisites. Successful exploitation is contingent on J-Web being enabled and a J-Web virtual-domain being configured - a non-default state - so devices with J-Web disabled or no virtual-domain configured are not affected. No confirmed active exploitation (CISA KEV) or public exploit code has been identified at time of analysis.

Authenticated low-privileged users of Hestia Control Panel 1.9.7 through 1.10.4 who own at least one web domain can escalate to root by injecting a single quote into a custom document-root value, which update_object_value() fails to escape before writing it to the user's web.conf file. The forged PATH field is later loaded by the root-privileged v-search-user-object script via parse_object_kv_list_non_eval() - which allows reserved shell-variable names and replaces PATH globally - and the subsequent invocation of 'column' without an absolute path executes an attacker-supplied binary placed in the injected search path, yielding arbitrary code execution as root with a scope change (S:C) and full confidentiality, integrity and availability impact. The flaw is fixed in Hestia Control Panel 1.10.5; no public exploit code was identified at time of analysis, and the realistic threat model is multi-tenant/shared hosting or a malicious insider rather than an anonymous attacker, since a provisioned panel account with web-domain capability is mandatory.

Remote root code execution in the routing protocol daemon (rpd) of Juniper Junos OS is reachable through protocol-valid EVPN route advertisements sent by an established BGP/EVPN peer for a configured EVPN-VPWS service, while the identical input causes only an rpd crash (denial of service) on Junos OS Evolved. The underlying defect is a stack-based buffer overflow (CWE-121) in a daemon that runs with root privileges on FreeBSD-based Junos OS, so a successful overflow yields full device compromise, and Juniper has published patched builds under advisory JSA112187. The vendor's CVSS 4.0 base is 9.3 with AV:N/AC:L/PR:N/UI:N/VC:H/VI:H/VA:H, but real exposure is gated by the requirement that the attacker already hold a configured BGP/EVPN adjacency to the target device; no public exploit code has been identified at time of analysis and there is no KEV confirmation of active exploitation.

Juniper Junos OS and Junos OS Evolved rpd contain a stack-based buffer overflow that an unauthenticated adjacent LDP peer can trigger with a malformed LDP Label Mapping message, causing an rpd crash or potentially arbitrary code execution. Exploitation requires LDP/MPLS to be configured and the attacker to have an LDP adjacency, so exposure is limited to MPLS-enabled routers rather than arbitrary internet-facing systems. Vendor patches are available; no public exploit code has been identified at time of analysis.

Memory corruption in NASA's F´ (F Prime) FpySequencer component, affecting framework versions prior to 4.2.0, lets an authenticated high-privilege actor who can load and execute flight sequences bypass the sequencer's stack write bounds check via a U32 integer wraparound in a STORE directive, so memcpy writes outside the sequencer stack and can cause denial of service, memory corruption, and potentially code execution. It is rated CVSS 3.1 7.2 (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) because the malicious sequence must be supplied and run - typically requiring trusted commanding, uplink, or ground-system authority - making it an access-gated risk rather than an unauthenticated mass-exploitation threat. No public exploit has been identified at time of analysis, there is no CISA KEV entry, and the vendor released a fixed version (4.2.0).

Out-of-bounds array access in the Svc::GenericHub component of NASA's F´ (F Prime) framework (4.1.0 through 4.1.x, fixed in 4.2.0) lets remote, unauthenticated attackers who can deliver a crafted hub packet via fromBufferDriver supply an output-port index outside the configured port array; assert-enabled builds abort (denial of service) while builds compiled without assertions can corrupt heap memory and potentially achieve remote code execution. No public exploit code exists and no exploitation has been confirmed in the wild - exploitation presupposes attacker reachability to the hub's input channel, which in F´ deployments is typically a mission radio link or inter-process transport rather than an internet-facing service. The vendor rates this CWE-129 improper array index validation flaw CVSS 4.0 9.3 (Critical), with high confidentiality, integrity and availability impact.

Stack-based buffer overflow in the srxpfe packet-forwarding daemon of Juniper Networks Junos OS and Junos OS Evolved on the SRX Series lets a Layer-2-adjacent attacker execute arbitrary code as root by injecting crafted high-availability fabric traffic. This is a genuinely serious but access-constrained vulnerability: exploitation requires the SRX to be operating in a high-availability chassis cluster, and the attacker must already sit on the same Layer-2 segment as the HA fabric link - the flaw is not reachable over routed networks and does not affect standalone or non-clustered deployments. No authentication or user interaction is required once fabric adjacency is achieved (PR:N/UI:N per the assessed CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H vector and the vendor CVSS 4.0 score of 8.7), and no public exploit code has been identified at time of analysis; the vendor reports a patch is available via advisory JSA112186.

Adjacent, unauthenticated code execution as root affects Juniper Junos OS and Junos OS Evolved devices that support Secure-ZTP when their phone-home daemon (phcd) processes a crafted DHCP SZTP bootstrap message. The flaw is a stack-based buffer overflow (CWE-121) that can be triggered by a network-adjacent attacker (CVSS 4.0 AV:A/AC:L/PR:N/UI:N, vendor score 8.7 High); no credentials or user interaction are required, but the target must be a Secure-ZTP-capable platform actively in the DHCP SZTP bootstrap/provisioning state and the attacker must be on the same Layer-2/logical segment. Vendor patches are available; no public exploit code or KEV-listed active exploitation was identified in the provided data.

Stack-based buffer overflow in the cfmd process of Juniper Junos OS and Junos OS Evolved on MX Series and PTX Series platforms enables unauthenticated adjacent-network attackers to execute arbitrary code as root or cause denial of service when enhanced CFM mode and a configured down-MEP are present. The CVSS 8.7 score reflects high confidentiality, integrity, and availability impact, but real-world exposure is constrained by the non-default CFM/802.1ag configuration and the need for Layer 2 adjacency; no public exploit identified at time of analysis.

A stack-based buffer overflow in Juniper's jdhcpd process lets an adjacent, unauthenticated attacker crash or potentially achieve root-level code execution on Junos OS and Junos OS Evolved devices that are configured to use the DHCPv4 local-client feature. Exploitation requires the device to act as a DHCPv4 client and an attacker to sit on the same Layer 2 segment able to deliver a malformed DHCPv4 server response (for example via a rogue or spoofed DHCP server); there is no public exploit identified at time of analysis, but a vendor patch is available. Because jdhcpd runs with root privileges, a successful overflow could yield high confidentiality, integrity and availability impact, making this a mid-to-high priority issue for exposed deployments rather than a universal emergency.

Adjacent unauthenticated attackers can trigger a stack-based buffer overflow in the l2cpd process on Juniper Junos OS and Junos OS Evolved by sending crafted LLDP traffic to an interface configured with Unified Access Policy, potentially causing a denial of service or root-level code execution. Exploitation requires Layer-2 adjacency and the non-default UAP configuration, so this is a high-priority networking vulnerability rather than a universal emergency. No public exploit identified at time of analysis, and a vendor patch is available.

A stack-based buffer overflow (CWE-121) in the UTM Anti-Spam SBL inspection component of Juniper Networks Junos OS on SRX series firewalls lets an unauthenticated, remote attacker achieve arbitrary code execution or a denial of service by injecting a malformed DNS packet into the device's SBL lookup flow. Exploitation is gated by two real-world preconditions: the non-default UTM Anti-Spam SBL feature must be explicitly enabled, and the attacker must be positioned to inject or spoof the DNS response the device consumes (reflected by the CVSS 4.0 AT:P attack-requirements metric) - which is why the vendor's 9.2 score is tempered by our assessed CVSS 3.1 vector of AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H. No public exploit code and no confirmed active exploitation were identified at time of analysis.

Remote code execution in Juniper Networks Junos OS on SRX Series devices configured for AutoDiscovery VPN (ADVPN) can let an attacker who already is a trusted ADVPN peer take complete control of the device via malformed ADVPN attributes that trigger a buffer overflow. Exploitation requires the attacker either to possess the ADVPN pre-shared secret to impersonate a peer or to have compromised a legitimate peer, and the independent assessment rates this as high severity but not an emergency despite the 9.2 CVSS 4.0 score. No public exploit code or confirmed active exploitation was identified at time of analysis.

A heap-based buffer overflow in the VXLAN Gateway Daemon (vgd) of Juniper Networks Junos OS allows an attacker who controls (or has compromised) the SDN controller to crash the OVSDB control plane - a complete denial of service of the EVPN/VXLAN control path - and possibly achieve remote code execution on the gateway device. The flaw is remotely reachable from the adjacent control/management network (CVSS 4.0 8.7, AV:A/PR:N), meaning no authentication is required per the published vector, though exploitation is conditional: the device must be deployed as a VXLAN/EVPN gateway with the OVSDB control plane enabled and managed by an external SDN controller, which is not a default configuration. Vendor patches are available and no public exploit code or confirmed active exploitation has been identified at time of analysis.

An authenticated format-string vulnerability in the gRPC daemon that backs the gNMI service on Juniper Networks Junos OS Evolved lets a network attacker who holds valid low-privileged credentials feed crafted format specifiers into a telemetry code path, with potential outcomes ranging from telemetry-service disruption and information disclosure up to root-level code execution. The flaw is rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), so exploitation is remote but requires an authenticated session against an enabled, network-reachable gNMI interface - it is not reachable by a fully anonymous attacker. At the time of analysis there is no CISA KEV entry and no public exploit code identified, and the vendor has published advisory JSA112250; this is a credible priority for organizations running Evolved with gNMI exposure, but not a drop-everything emergency on the available signals.

Unauthenticated remote attackers can trigger a use-after-free in NGINX's ngx_http_core_module when asynchronous file I/O (AIO) is enabled and a Server Side Includes (SSI) page containing 'include virtual' commands is processed, causing memory corruption or a worker process crash. This affects both NGINX Plus and NGINX Open Source, with code execution possible only on systems where Address Space Layout Randomization (ASLR) is disabled or can be bypassed. Exploitation requires a non-default configuration (AIO and SSI enabled), and no public exploit code was identified at time of analysis.

Heap buffer overflow in NGINX Plus and NGINX Open Source can be triggered by crafted HTTP requests when a non-default map directive with regex matching is configured so that the root directive or access log format references the map's regex capture variables before the map output variable, or when a non-cacheable variable is used in a string expression under specific conditions. The flaw is remotely reachable without authentication (CVSS PR:N) but has high attack complexity (AC:H) because exploitation depends on conditions beyond the attacker's control and on a non-default configuration; the realistic outcome on systems with ASLR enabled is worker-process restart/DoS, while code execution is limited to systems with ASLR disabled or bypassed. F5 rates this CVSS 4.0 9.2 (Critical), and no public exploit identified at time of analysis.

Heap buffer overflow in NGINX Plus and NGINX Open Source can be triggered by unauthenticated remote attackers through crafted HTTP requests, but only when a non-default configuration uses the alias directive together with rewrite and a set or return directive referencing the $request_filename variable, or when $request_filename is used in an access log format directive. Successful exploitation causes a heap buffer overflow in the NGINX worker process, leading to a restart (denial of service) and potentially allowing code execution on systems with ASLR disabled or bypassable. No public exploit code or active exploitation has been identified at time of analysis.

Missing authorization in the handleLocalTerminal WebSocket handler of Skyhook Radar before 1.12.2 lets an attacker who can reach the /api/local-terminal endpoint spawn an interactive /bin/bash -l shell on the Radar host with Radar's own kubeconfig and process credentials injected into the environment, achieving remote code execution with Radar's privileges. The handler is governed only by a runtime-mode check instead of role-based access control, and per the advisory the exploit still works when the operator has set --disable-local-terminal, so that flag cannot be relied on as a mitigation in vulnerable builds. The vendor's CVSS 4.0 rating is 8.7 (VC:H/VI:H/VA:H, PR:L) while our independent reassessment scores it CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, meaning authentication is not reliably enforced despite the PR:L marking; there is no CISA KEV entry and no public exploit code identified at time of analysis, and real-world exposure is chiefly limited by the fact that Radar is a local-first developer tool that is normally bound to localhost on an individual workstation.

Remote, unauthenticated code execution is possible in the HPE NonStop SNMP Trap Multiplexer, which processes inbound SNMP trap messages on the HPE NonStop platform. An attacker who can reach the trap-receiving interface can deliver a crafted trap that overflows a stack buffer (CWE-121); our independent assessment rates the full impact as high for confidentiality, integrity and availability (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), whereas the vendor-published 7.5 vector reflects only an availability impact (C:N/I:N/A:H) - a conflict that must be reconciled with HPE before prioritization. Exploitation requires network reachability to the trap listener and no credentials, privileges, or user interaction (PR:N/UI:N); no public exploit code has been identified at time of analysis and the CVE is not in CISA KEV. Exposure is confined to the specialized population running HPE NonStop with this multiplexer deployed - typically banking, telecom and transaction-processing environments - which limits the scale but not the severity of a successful attack.

Code injection in the VillaTheme 'Email Template Customizer for WooCommerce' WordPress plugin, affecting versions up to and including 1.3.4, lets an attacker influence the content/code generated by the plugin's email template handling, carrying a high confidentiality impact (C:H) with low integrity impact in our assessment. The supplied advisory vector claims unauthenticated, no-interaction exploitation (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N, 7.5), but our independent assessment revises this to PR:L (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N), meaning a privilege prerequisite cannot be ruled out and the unauthenticated claim is unverified. No public exploit code and no CISA KEV entry were identified at time of analysis, and no EPSS score was supplied; exposure is limited to WordPress sites running WooCommerce with this specific plugin active.

Heap-based buffer overflow in GStreamer's gst-plugins-base plugin library lets a local attacker who controls the sending side of a GStreamer inter-process IPC pipeline corrupt memory in the receiving process, yielding a CVSS 3.1 base score of 8.4 (AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) with high confidentiality, integrity, and availability impact. The victim process maps a crafted video buffer whose GstVideoMeta declares plane strides and offsets larger than the actual backing allocation, causing out-of-bounds reads and writes that can crash the process or potentially permit code execution in its context. Exploitation is strictly local and requires a deployment where GStreamer buffers cross a trust boundary between a less-trusted producer and a more-trusted consumer; no user interaction or authentication to the victim is needed, and no public exploit has been identified at time of analysis.

Unauthenticated local file inclusion in the Mang Board WordPress plugin (all versions through 2.4.3) allows remote attackers to include and execute arbitrary PHP files by supplying a crafted '<mode>_type' parameter (e.g. foo_type) to any publicly reachable page that renders the [mb_board] shortcode. Because no nonce or capability check is enforced on the shortcode render path, the LFI itself is trivially triggered by an unauthenticated POST and can be used to bypass access controls or disclose sensitive data; full code execution is a further step that requires either a standard PHP installation exposing pearcmd.php (which can be abused to write and then include an attacker-controlled payload in a single request) or the ability to upload .php files that are then included, which is why the vendor scored the issue AC:H despite the unauthenticated PR:N vector. The vulnerability is tracked as CWE-98 with a CVSS 3.1 base score of 8.1, reported by Wordfence; no public exploit code identified at time of analysis and the CVE is not listed in CISA KEV, though the low exploitation complexity warrants prompt patching.

Local file inclusion in the LifterLMS WordPress plugin (up to and including 10.3.1) lets an authenticated attacker with Instructor-level access or above include and execute arbitrary files on the server by manipulating the 'template_name' and 'default_path' attributes of the [lifterlms_checkout] shortcode. The flaw causes llms_get_template() to overwrite its own local parameters via extract(), redirecting a PHP include to an attacker-chosen path, which can bypass access controls, expose sensitive data, and potentially achieve code execution where attacker-controlled content has been uploaded under an allowed file extension. There is no confirmed active exploitation (CISA KEV) and no public exploit code identified at time of analysis; the assessed vector (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, 7.5) reflects that Instructor+ authentication and, for full RCE, a successful upload are required prerequisites.

Unauthenticated local file inclusion in ShopMagic for WooCommerce (all versions up to and including 4.9.0) allows remote attackers to include and execute arbitrary .php files on a WordPress server by submitting a path payload as the billing first name during WooCommerce guest checkout. The value reaches the plugin's PHP template renderer through the {{ customer.first_name }} placeholder, and the built-in "New Order email with social media profile links" recipe processes that placeholder out of the box, so default configurations are exploitable with no account, cookie, or nonce. CVSS is 8.1 (C:H/I:H/A:H, AC:H); full code execution additionally requires that an attacker-controllable .php file already exist on the server, and no public exploit code was identified at time of analysis. The vendor-released fix is 4.9.1.

Remote code execution in the affiliate-toolkit WordPress plugin (versions before 3.9.1) lets an authenticated user holding the Contributor role or higher submit a template body that the plugin's bundled templating engine compiles and runs as PHP, giving full server-side code execution with high confidentiality, integrity, and availability impact. Any WordPress site running an affected version is exposed, and because Contributors are unprivileged content authors, sites with open author self-registration or large multi-author teams carry the greatest practical risk; no end-user interaction is required. Publicly available exploit code exists (documented via WPScan) and the EPSS score is low at roughly 0.18% (8th percentile), with no indication of confirmed active exploitation (CISA KEV) and no SSVC exploitation signal, so this rates as a moderate-but-real priority for sites that actually run the plugin.

Unauthenticated arbitrary file upload in the JTL-Connector for WooCommerce WordPress plugin (all versions up to and including 2.4.3) lets remote attackers upload executable files and achieve remote code execution with a CVSS 3.1 score of 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). Exploitation is trivial against default configurations: startSession() accepts an empty jtlauth parameter as a valid credential, so no authentication, no user interaction, and no non-default setting is required - only that the plugin is installed and active and the connector endpoint is network-reachable. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, but the low attack complexity, unauthenticated vector, and default-configuration exploitability make this a genuine high-priority vulnerability rather than a high-score/low-risk case.

Unauthenticated remote code execution affects the AGE-GATE (wp-site-age-gate) plugin for WordPress in all versions up to and including 1.0. Because the plugin ships a standalone admin.php endpoint that never bootstraps WordPress and carries no ABSPATH guard, the capability and nonce arguments registered through the plugin's simulated menu API are purely decorative, and POST parameters such as width and height are written unsanitized into generated PHP source that is subsequently included - letting any remote attacker who can reach admin.php execute arbitrary code on the server. The vendor CVSS is 9.8 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), and no public exploit code has been identified at time of analysis; exploitation requires only that the vulnerable plugin be installed and active and that admin.php be directly reachable over HTTP.

Code injection in TeamPlus Messenger allows unauthenticated remote attackers to trick a user into interacting with crafted content, injecting and executing arbitrary JavaScript; after the user confirms a Windows security warning, arbitrary code executes with the victim's privileges. The CVSS 4.0 vector scores 8.6 (High) with UI:A, gated by two distinct user actions: interacting with the malicious content and then accepting an OS-level security prompt. No public exploit code or confirmed active exploitation has been identified at time of analysis.

Remote code execution in TeamPlus Messenger for Windows lets an unauthenticated attacker deliver a crafted link that injects and executes arbitrary JavaScript inside the client, escalating to native code execution with the privileges of the logged-in user once the victim opens the link and confirms a Windows security warning dialog. Rated CVSS 4.0 base 8.6 (High) and mapped to CWE-94, the flaw's practical severity is gated by two mandatory victim actions - following the malicious link and accepting the Windows prompt - so only users who both act are compromised, and execution is confined to user-level privileges rather than SYSTEM or administrative rights. At the time of analysis no public exploit code was identified and the issue was not listed in CISA KEV; only TWCERT/CC advisory references are available, and no vendor patched version is specified in the provided data.