Remote Code Execution

Loading an attacker-supplied read-only dictionary (.rws) file in GNU Aspell through 0.60.8.2 can corrupt heap memory, yielding reliable denial of service and potentially code execution. The root cause is a heap-based buffer overflow write (CWE-122) triggered by a signed-integer overflow in String::reserve(), which lets a crafted 32-bit length field in the .rws header (for example lang_name_size = 0x7FFFFFFF, paired with the valid endian marker 12345678) bypass the capacity check so attacker-controlled data is written past an undersized allocation. Exploitation is local in nature - there is no network-service trigger - and requires the victim to actively load the malicious dictionary, such as by running 'aspell dump master <file>'; no public exploit code was identified and there is no confirmed active exploitation at time of analysis, so this is assessed as a moderate-priority issue despite the RCE tag.

Code injection in IBM Maximo Application Suite's Location Service for Esri component (versions 9.0, 9.1, and 9.2) allows an authenticated attacker with high privileges (CVSS PR:H) and network access to supply an unsanitised container image configuration in the Kubernetes operator template, which the operator may then deploy. The issue is rated CVSS 6.5 Medium (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:N) and can lead to high confidentiality and integrity impact, but requires privileged access to the MAS environment and affects an optional component. No public exploit identified at time of analysis, and no KEV or EPSS data indicates active exploitation.

Arbitrary file write on the orchestrator host affects Vercel deepsec versions 0.1.0 through 1.1.16, where the extractTarballLocally routine in the sandbox download path follows symbolic and hard links planted inside result tarballs. An attacker who already controls code running inside the deepsec sandbox - the canonical case being a prompt-injected coding agent - can plant links in the host data directory so that extraction of the returned tarball writes files outside the sandbox and onto the orchestrator host. The issue is rated medium severity (CVSS 4.0 base 4.9; independent assessment CVSS 3.1 AV:N/AC:H/PR:N/UI:R/S:C/C:N/I:H/A:N), exploitation is highly conditional (attacker must already hold sandbox code execution, and the extraction must succeed on an attacker-influenced tarball), and no public exploit identified at time of analysis; there is no CISA KEV listing.

Heap buffer overflow in FreeRDP's RDP license negotiation path lets a malicious or man-in-the-middle RDP server corrupt client heap memory when a 32-bit FreeRDP client (3.0.0 through the 3.31.x line, fixed in 3.32.0) connects to it and receives a crafted SERVER_LICENSE_REQUEST carrying an oversized scopeCount that defeats the length check. A successful attack can crash or destabilize the client (denial of service) and could potentially lead to code execution in the client's context, but exploitation requires the victim to initiate an outbound RDP session to an attacker-controlled endpoint and the integer truncation only manifests on 32-bit builds, not 64-bit ones. No public exploit identified at time of analysis; the vendor fix is shipped in FreeRDP 3.32.0, and the assessed risk vector is CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:H/A:H.

Authenticated template injection in Thelia versions up to and including 2.6.1 lets a logged-in user with access to Smarty template-name handling point the engine at an arbitrary absolute filesystem path, which can result in server-side template injection and, in some deployments, remote code execution. The flaw is post-authentication (CVSS vector PR:L) and the RCE outcome is conditional: it depends on Smarty loading/compiling the referenced file without an effective security policy and on a suitable file existing at the referenced path, so impact is not guaranteed on every installation. No public exploit code and no active exploitation were identified at time of analysis (EPSS 0.40%, ~32nd percentile), and no vendor-released fixed version was confirmed from the provided references (CERT/CC advisory VU#162329; CVE-2026-103537).

Remote code execution in Thelia 2.6.0 and earlier is achievable by an authenticated back-office administrator who uses the module ZIP upload-and-install feature to deliver a crafted module whose install() method contains embedded PHP; that code is executed on installation with the privileges of the web server. The affected scope is Thelia up to and including 2.6.0, and exploitation requires the highest application privilege level (an administrator account), which is why the independent assessment rates real-world priority as LOW despite high confidentiality, integrity, and availability impact on the host. There is no public exploit identified at time of analysis, no CISA KEV listing, and EPSS is only 0.19% (8th percentile), so this is best treated as an insider/misconfiguration-adjacent hardening issue rather than an urgent internet-facing threat.

Code injection in Zen Cart through 2.2.2 lets an attacker who already has privileged admin/database write access to the `configuration` table supply a malicious `use_function` value that `zen_call_function()` in `admin/includes/functions/general.php` then invokes as PHP, achieving limited code execution (low confidentiality, integrity and availability impact). The attack is network-reachable but rated highly complex and requires high privileges (CVSS:4.0 PR:H / assessed CVSS:3.1 PR:H, AC:H, base score 2.1), because the vendor states the only ways to control `use_function`/`configuration_value` are the admin SQL Patch tool (raw SQL execution) or a separate pre-existing SQL injection - normal unprivileged input does not reach it. Publicly available exploit code exists per the disclosed proof-of-concept, but there is no evidence of confirmed active exploitation and the vendor explicitly rejects the issue as independently exploitable.

Code injection in the PythonTools component of Agno (agno-agi/agno) through version 3.0.6 lets an attacker who can influence the 'code' argument of run_python_code execute arbitrary Python in the host process. The CVSS v4.0 vector supplied with the record is low (2.1, PR:L), and our independent assessment confirms that a low-privilege foothold is required - realistic paths are an authorized-but-malicious user of an agent that has PythonTools enabled, or indirect prompt injection steering the model into calling the tool with attacker-chosen code; PythonTools is an optional agent tool rather than a default network-exposed endpoint. Publicly available exploit code exists (a third-party advisory and PoC repository are linked), and the vendor was notified via a GitHub issue but has not responded, so no vendor patch is confirmed; despite the RCE framing, the signals point to a low real-world priority.

Unauthenticated content injection in the Kutethemes 'Boutique' WordPress theme at version 2.3.3 and earlier lets remote attackers reach a shortcode-handling path and inject arbitrary content into affected sites. No authentication or user interaction is required (CVSS:3.1/AV:N/AC:L/PR:N/UI:N), so any internet-facing WordPress installation with this commercial theme active is exposed by default; the attack surface is bounded to sites running this specific theme. Impact is assessed as limited content injection and partial data exposure (C:L/I:L/A:N) rather than server compromise, and no public exploit code has been identified at time of analysis, so the practical risk is concentrated in unpatched, theme-deployed sites.

Arbitrary file deletion in the WordPress plugin Listdom: AI-powered Business Directory with Classifieds Ads Listings (all versions up to and including 6.1.2) lets an authenticated administrator delete files anywhere on the server by supplying a traversal path to the plugin's CSV import routine (LSD_Menus_IX_CSV::import). The practical impact is high for integrity and availability - deleting a sensitive file such as wp-config.php can drop the site into a re-installation state and enable full takeover/RCE - but the requirement for administrator-level access (CVSS PR:H) makes this a high-barrier, medium-severity issue rather than a widespread emergency. No public exploit code and no confirmed active exploitation were identified at time of analysis.

Arbitrary shortcode execution in the Kirki - Freeform Page Builder, Website Builder & Customizer plugin for WordPress (all versions up to and including 6.3.1) lets any authenticated user with Subscriber-level access or above inject shortcodes by writing them into their own `display_name` profile field, which the plugin splices unfiltered into composed page markup and then passes through `do_shortcode()`. The flaw is exploitable as a remote, network-reachable issue requiring only a low-privileged account (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N, 5.4), rated moderate by the independent assessment; the key precondition is that a published page must exist containing a Kirki element whose dynamic content is explicitly bound to the `display_name` user field - typically a team or member-directory / users-collection page - and on sites without such a page the vulnerable code path is never reached. Where that binding does exist, the injected shortcode executes in the request of every visitor, including unauthenticated ones, so per-victim interaction is not required; no public exploit code or confirmed active exploitation was identified at time of analysis.

Local privilege escalation and arbitrary code execution in the BusyBox tar applet (CVE-2026-108119) allow an attacker who supplies a crafted tar archive to create or replace files outside the extraction directory when the archive is extracted with elevated privileges. The flaw is a CWE-59 link-following issue in the applet's deferred symlink/hardlink creation path, with a CVSS 3.1 base score of 6.3 (AV:L/AC:H/PR:N/UI:R/S:U/C:N/I:H/A:H), affecting BusyBox as shipped in Red Hat Enterprise Linux 6 and Red Hat Hardened Images. No public exploit identified at time of analysis; exploitation requires a privileged user or process to actively extract the malicious archive, and the specific archive construction plus directory-reuse timing makes this high-complexity and local-only.

Code execution and unauthorized filesystem access in Dell Secure Connect Gateway (SCG) Policy Manager are achievable when a locally positioned, highly privileged attacker supplies directory-traversal sequences to a Policy Manager file-path handling feature (CWE-22), with exploitation additionally requiring user interaction and non-trivial conditions to line up (CVSS 6.3, CVSS:3.1/AV:L/AC:H/PR:H/UI:R/S:U/C:H/I:H/A:H). Despite the HIGH confidentiality, integrity, and availability impacts in the vector, this is a moderate-severity, low-urgency issue: there is no remote or network vector, an authenticated high-privileged application account on the host is a prerequisite, user interaction is mandatory, and attack complexity is high, so practical risk is largely confined to insider or already-compromised-host scenarios. No public exploit identified at time of analysis, and a vendor patch is available via Dell DSA-2026-385, though the exact fixed version must be confirmed because the CVE description cites 5.34.00.16 while EUVD lists 5.36.00.16.

An issue in Netcore B11 Enterprise-level full Gigabit 9-port shop wireless router v1.3.241114.024540 and before allows a remote attacker to execute arbitrary code via the www\cgi-bin\upgrade file

A heap-based buffer overflow in the PNG metadata reader of Eye of GNOME (eog) allows an attacker to potentially achieve arbitrary code execution or cause a denial of service (application crash) when a user opens a specially crafted PNG file. Exploitation requires user interaction and local access, but the vulnerability is unauthenticated (no privileges required) according to the CVSS vector PR:N. No public exploit code or confirmed active exploitation has been identified at time of analysis; the risk is constrained by the need for a user to open the malicious file on a system with eog installed.

A kernel-mode heap buffer overflow (CWE-122) in HP Sure Click and the related HP Wolf Security product family at versions below 4.4.33 allows a local attacker who already holds elevated privileges to corrupt kernel memory and potentially escalate to full system-level code execution. The flaw is reachable only from a local context on a Windows host running the affected endpoint security agent, requires a non-trivial triggering condition such as precise heap state or a memory-corruption race, and exposes no network or remote attack path. HP has released version 4.4.33 as the vendor-released fix, and no public exploit code has been identified at time of analysis.

Path traversal in the BackWPup WordPress plugin before 5.7.7 lets a high-privileged, authenticated user (PR:H, typically a WordPress administrator with backup/restore permissions) write files outside the intended restore directory by supplying a crafted backup archive during a restore that runs through the plugin's fallback archive library, which can escalate to remote code execution. The CVSS 3.1 base score is 6.6 (AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H), reflecting the high privileges and the non-default fallback-library code path required rather than a broad unauthenticated attack surface. A vendor patch is available in BackWPup 5.7.7, and no public exploit code was identified at time of analysis; exploitation is not confirmed as active (no CISA KEV listing).

Heap- or stack-based memory corruption in the internal FSPF route-validation and diagnostic routine of Brocade Fabric OS can crash the routing daemon or, worst case, allow code execution in the daemon's context, but only for a local, authenticated attacker who first chains one or more separate vulnerabilities to inject an oversized diagnostic state payload. The flawed code path is explicitly not exposed through standard user interfaces or CLI management commands, so the CVSS 4.0 score of 6.8 overstates standalone risk; our independent assessment rates it medium (CVSS 3.1 AV:L/AC:H/PR:L/UI:N, availability-only impact) and it cannot be triggered in isolation against a default configuration. No public exploit code was identified at time of analysis and there is no evidence of active exploitation; the vendor fix is Fabric OS 10.0.1.

Arbitrary file creation or truncation in Apache Jackrabbit's WebDAV/DavEx client (jackrabbit-spi2dav) occurs when a malicious or intercepted remote server supplies externally controlled input that causes the client to instantiate classes from its classpath. Affected versions are 2.23.0 through 2.23.5, 2.22.0 through 2.22.4, and 2.20.0 through 2.20.17, but only applications using jackrabbit-spi2dav directly or through jackrabbit-jcr2dav to connect to a remote repository are impacted; Jackrabbit servers are not vulnerable. The vendor CVSS 4.0 base score is 6.9 (medium) with an unauthenticated network vector, and the independent assessment rates CVSS 3.1 as AC:H with integrity-low impact only (C:N/I:L/A:N) because the attacker must control the remote server or intercept the connection; no public exploit code has been identified at time of analysis.

Code injection in ImageMagick's PostScript and PDF output coders allows attacker-controlled text such as an image label to be written into generated PostScript/PDF output without escaping, so an injected PostScript operator can execute when that output is later rendered by an interpreter such as Ghostscript. Affected are ImageMagick 7.x before 7.1.2-31 and 6.x before 6.9.13-56; exploitation is not confirmed actively exploited (CISA KEV) and no public exploit code is identified at time of analysis. The assessed severity is medium (independent CVSS 5.3 / evaluated vector CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H): the attack is remote and requires no authentication, but exploitation demands a high-complexity chain in which a conversion writes a label out through the ps, ps2, ps3, or pdf coder and the resulting file is subsequently rendered.

Heap use-after-free in m17n-lib's input-method handling allows a local user who supplies specially crafted text to an application using m17n-based input engines to crash that application, producing a denial of service; arbitrary code execution is described as a potential, unverified outcome rather than a demonstrated one. The flaw is rated CVSS 6.2 (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), so exploitation is local with no privileges required (PR:N) and no user interaction, and the only confirmed impact is availability loss with no confidentiality or integrity effect. Red Hat tracks the issue for Red Hat Enterprise Linux 6 through 10, and no public exploit code or confirmed active exploitation was identified at time of analysis.

Authenticated users holding only the low-privileged 'Backup Viewer' role on Veeam Backup & Replication can leverage a deserialization flaw to execute arbitrary code as SYSTEM on the backup server, turning a read-only backup monitoring account into full control of the backup infrastructure (CVSS 9.4; CWE-502). The attack is network-reachable (AV:N) and requires no user interaction, but it is not unauthenticated: a valid Backup Viewer account or stolen credentials for that role are mandatory (PR:L), which realistically limits exposure to insiders, credential-theft scenarios, or attackers who have already chained into the environment. The high severity is compounded by the scope change (S:C) and full loss of confidentiality, integrity, and availability across the backup server and connected systems; no public exploit code or confirmed active exploitation was identified at time of analysis.

An integer overflow in the glamor rendering upload path of the X.Org X server (and Xwayland) can produce an undersized heap allocation and subsequent out-of-bounds memory writes, and is one of the issues bundled into the October 2026 X.Org security advisory tracked as CVE-2026-93521. The affected code is in builds of X.Org X server prior to xorg-server-21.1.25 and Xwayland prior to xwayland-24.1.14; exploitation requires an authenticated local X client able to reach a depth-24 drawable uploaded into a depth-32 pixmap while glamor GL acceleration is active, with the byte_stride * height computation in glamor_upload_boxes overflowing before XNFalloc is called. No public exploit code, EPSS score, CWE assignment, or CISA KEV entry was present in the input, so there is no public exploit identified at time of analysis, and because the per-CVE description for CVE-2026-93521 is absent from the truncated advisory these conditions are inferred from the associated commit and should be verified against the vendor's per-CVE entry.

Local privilege escalation in ClearPass OnGuard allows an authenticated local user to write arbitrary files and potentially execute code with elevated privileges, but only when unspecified preconditions outside the attacker's control are met. The vulnerability requires user interaction and is high-complexity (AC:H), limiting practical exploitability to hosts where the OnGuard agent is deployed and those environmental conditions already exist. No public exploit code or confirmed active exploitation was identified at time of analysis; the issue is assessed as moderate and defense-in-depth-tier.

Authenticated (site-admin) users on MISP installations prior to commit 2ebf29f93 can repoint the application's Redis host settings for the core app, ZeroMQ plugin, and SimpleBackgroundJobs plugin to an attacker-controlled Redis server, because those settings are exposed through the web UI and API instead of being restricted to CLI configuration. Combined with a separate session-hijack primitive such as stored XSS, an attacker can then restart the background workers, which trust raw Redis job payloads without validation, and inject malicious jobs that execute with the privileges of the worker account - effectively remote code execution. Exploitation requires a hijacked site-admin session and an attacker-operated Redis instance, so it is a conditional rather than drop-everything risk; no public exploit code or confirmed active exploitation was identified at time of analysis, and the assessed CVSS:3.1 vector is AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H.

Code injection in the Extensions subsystem of Google Chrome prior to 155.0.8059.39 lets a remote attacker spoof browser UI elements once a victim has been socially engineered into installing a crafted extension. Exploitation is gated behind mandatory user interaction (UI:R) and the deliberate addition of attacker-controlled extension code, so exposure is limited to users who sideload or approve an untrusted extension rather than to any default, clean Chrome install; there is no public exploit identified at time of analysis. Google has shipped a fix in the Chrome 155.0.8059.39 stable channel release, and the issue is rated Medium at 5.4 with only low confidentiality and low availability impact.

Boot-time arbitrary code execution is possible on AMD Versal Adaptive SoCs and related Alveo accelerator cards, but only when USB boot mode has been enabled through physical board modifications - a configuration AMD explicitly describes as non-default. A crafted boot image delivered over USB can trigger an out-of-bounds write (CWE-787) that overflows a buffer and overwrites an active function pointer, yielding high confidentiality, integrity, and availability impact confined to the boot process. Because exploitation requires both physical access to the device and a deliberately modified board, plus a non-trivial (high-complexity) overflow, realistic risk is limited to supply-chain, manufacturing, or evil-maid scenarios; no public exploit identified at time of analysis, and no confirmed in-the-wild activity, though the vendor bulletin AMD-SB-8028 documents the issue.

Code injection in TallCMS up to and including 4.8.0 lets an authenticated admin-panel user who is not a super admin upload and install a plugin ZIP containing arbitrary PHP that is then autoloaded and executed by the application. Exploitation requires valid credentials at a privilege level below super_admin plus the plugin-upload capability to be enabled (the uploadsAllowed() config flag), so it is not reachable anonymously, but publicly available exploit code exists per the referenced GitHub issue and no CISA KEV entry indicates confirmed active exploitation. Note that the vendor/CVSS 4.0 score (5.3, low confidentiality/integrity/availability impact) substantially understates the issue relative to the independent assessment (CVSS 3.1 8.8, C:H/I:H/A:H), which treats the arbitrary-PHP execution as full compromise of the installation; the signals across sources are mixed and partly contradictory.

Code injection in osCommerce2 (versions through 2.3.4.1) allows an attacker who already holds high backend privileges - a store administrator able to edit the payment configuration - to manipulate the MODULE_PAYMENT_INSTALLED parameter and have attacker-controlled content pulled into a PHP include() in includes/classes/payment.php. Because the CVSS 4.0 vector carries PR:H and UI:P, the vulnerable payment flow is not reachable by an anonymous shopper and requires at least passive user interaction, which keeps this a medium-severity, post-authentication issue (base score 4.8) rather than a pre-auth remote takeover. Publicly available exploit code exists, and there is no confirmed upstream fix because the project has not responded to the reporter's early notification; no EPSS or CISA KEV signal is available for this CVE.

Physical access to a Mercusys AC12 V2 router's printed circuit board lets an attacker take full control of the device: the UART debug header on the board is exposed with no authentication gate or lockdown, so wiring a serial adapter to the correct pins yields an interactive, root-level console from which arbitrary code can be executed (CWE-1299, unprotected alternate hardware interface). The CVSS 3.1 base score of 6.8 (AV:P/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) reflects complete loss of confidentiality, integrity, and availability, tempered only by the requirement for hands-on hardware access - there is no network, Wi-Fi, or LAN attack path, so remote exploitation is not possible. No confirmed active exploitation and no public exploit code have been reported, and the EPSS score is 0.16% (4th percentile), consistent with a flaw whose realistic exposure is limited to supply-chain, device-resale, lost/stolen, or evil-maid scenarios.

Unauthenticated remote attackers can execute arbitrary registered WordPress shortcodes through the WP Ultimate Review plugin (versions up to and including 2.4.3), because the plugin passes an unvalidated value to do_shortcode and the only nonce gate is emitted to anonymous visitors via the public review form, while submitted reviews auto-publish without administrator approval by default. The CVSS 3.1 base score is 6.5 (Medium) with low confidentiality and integrity impact and no availability impact; the real-world severity depends on which shortcodes exist on the target site. No public exploit code has been identified at time of analysis, and CISA KEV does not list this issue.

Arbitrary shortcode execution in the WP Ultimate Review WordPress plugin through version 2.4.3 lets any authenticated user with subscriber-level access or higher inject shortcodes that are stored and later executed when review content is rendered. The bypass abuses WordPress core behavior: the plugin passes attacker-controlled data into do_shortcode without validation, and the [[tag]] double-bracket escape is unwrapped to a bare [tag] by strip_shortcodes(), surviving wp_insert_post storage and firing through the_content on the publicly queryable xs_review post type. There is no public exploit code identified at time of analysis and no confirmed active exploitation (CISA KEV); exploitation requires a low-privilege account, which makes it practically significant on sites with open user registration.

Authenticated path traversal in the Unlimited Elements for Elementor WordPress plugin before 2.0.21 lets a privileged user (Administrator by default, or Editor when a specific non-default plugin setting is enabled) plant arbitrary files - including executable PHP - outside the intended upload directory, which can escalate to remote code execution. Exploitation requires two conditions to hold simultaneously: the attacker must already hold an account with access to the plugin's asset-management feature, and the target server must not have the PHP zip extension installed, since only the unsanitized fallback extraction path is vulnerable. Publicly available exploit code exists (tracked via WPScan), but EPSS is only 0.22% (11th percentile) and there is no CISA KEV confirmation of active exploitation, so this is a genuine but constrained risk rather than an urgent widespread threat; a vendor patch is available in version 2.0.21.

Unauthenticated attackers can inject and execute arbitrary WordPress shortcodes through the All in One SEO (AIOSEO) plugin in versions up to and including 5.0.2, because an attacker-controllable value is passed to do_shortcode without adequate validation when the plugin renders its breadcrumb trail on the site's search results page. The flaw is only reachable when the AIOSEO breadcrumb is actively displayed on search results via the breadcrumb block, widget, shortcode, or template tag, and the practical impact is bounded by which shortcodes are registered on the target site. No public exploit code has been identified at time of analysis and there is no CISA KEV listing; the issue is rated CVSS 6.5 (Medium), with the independent assessment treating attack complexity as higher than the vendor's vector because of the rendering precondition.

Code execution concealment in MathWorks Simulink before R2026b allows an attacker-crafted .slx model to include blocks that are never visible in the Simulink Editor yet execute when the model is opened. Exploitation is local and requires a victim to open an untrusted model, with high attack complexity and low confidentiality/integrity impact (CVSS 3.6), so the practical risk is low despite the code-execution wording. The supplied data shows a public technical disclosure of the concealed-block technique but no CISA KEV confirmation, and no public exploit identified at time of analysis.

Unauthenticated shortcode injection in the All in One SEO (AIOSEO) WordPress plugin before 5.0.2.1 lets remote attackers smuggle registered shortcodes past the plugin's shortcode-stripping routine and have them executed in content derived from user input; on sites upgraded from older plugin versions the stripping protection is disabled entirely, so no crafted payload is required. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N, 6.5) reflects unauthenticated, no-interaction reachability with limited confidentiality and integrity impact rather than full compromise, and the practical severity depends on which shortcodes are registered on the target (from the plugin, theme, or other plugins). Publicly available exploit code exists and a vendor patch is available in 5.0.2.1; there is no evidence of confirmed active exploitation (no CISA KEV listing), so this is best treated as a moderate-priority, patched issue with a public PoC.

Cross-site scripting in the Repasat application allows an authenticated low-privileged user to inject script that executes in a second, logged-in victim's browser when they load the affected '/es/datatables/getemployeetypesdatatable' endpoint, enabling session token theft and actions performed as the victim. Exploitation is not a drive-by: it requires a valid low-privileged account (CVSS vector PR:L) plus victim interaction (UI:A), and the impact is confined to the client-side browser context with no server-side code execution and no availability impact. Scored 4.8 (Medium) under CVSS 4.0, the flaw carries no CISA KEV listing and no public exploit code was identified at time of analysis, so treat it as a real but precondition-heavy weakness rather than an imminent mass-exploitation risk.

Authenticated WordPress users holding a role as low as Subscriber can cause arbitrary shortcodes to be executed on sites running Unlimited Elements for Elementor before 2.0.21, because the plugin's widget-rendering path never verifies that the requester is permitted to invoke it. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N) and our independent assessment keep this at moderate severity: it is an authorization bypass gated behind a low-privileged account, not an unauthenticated code-execution emergency, even though publicly available exploit code exists (WPScan). Exposure is greatest on builds below 2.0.18, where a Subscriber account - trivially obtainable on any site with open registration - is sufficient; from 2.0.18 through 2.0.20 the minimum role rises to Contributor or above. There is no CISA KEV entry, so confirmed active exploitation in the wild has not been established.

Unauthenticated shortcode injection in The Events Calendar WordPress plugin before 6.17.5.1 allows remote attackers to trigger any shortcode registered on a target site by submitting crafted data to an AJAX action that is merged into the rendering context without validation or sanitisation. No authentication, user interaction, or special configuration is required on default installs, but practical impact is limited to the set of shortcodes actually registered by WordPress core, the active theme, or installed plugins, and the assessed CVSS vector shows no availability impact and only low confidentiality and integrity impact. Public exploit code exists, but there is no CISA KEV confirmation of active exploitation; this is a moderate-priority issue rather than a critical one.

Untrusted code execution in the NetBox devicetype-library CI pipeline lets any contributor who can open a pull request run arbitrary commands on the repository's GitHub Actions runner before a maintainer ever reviews the change. Because validation.yml triggers on the pull_request event and consumes three PR-editable files (requirements.txt for pip install, the pre-commit hook configs, and .gitmodules for submodule checkout), an unauthenticated remote attacker with no repository write access can inject code that executes automatically with no user interaction; impact is capped at low confidentiality and integrity loss because fork PRs run with a read-only token and no secrets. Only versions prior to commit f41fc1e are affected, and no public exploit code identified at time of analysis.

Path traversal and symlink-validation flaws in ansible-runner's unstream_dir() (CVE-2026-103754) let an authenticated, low-privilege actor who can inject crafted archive content into the transmit/worker protocol create files, create symlinks, or change permissions outside the intended extraction directory, which can be leveraged toward code execution. The issue affects ansible-runner as shipped in Red Hat Ansible Automation Platform 2 (and upstream/AWX deployments) prior to the PR #1550 fix and carries a vendor-assigned CVSS 3.1 base score of 5.9 (AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:H/A:L). No public exploit code or confirmed active exploitation was identified at time of analysis, and exploitation is constrained by the need to supply crafted archive members into this specific worker protocol path.

Heap-based buffer overflow in the tnef command-line TNEF (winmail.dat) extractor allows a crafted TNEF file with a large number of colliding attachment filenames to overflow the numeric-suffix counter used by find_free_number(), producing a crash and denial of service; arbitrary code execution is theoretically possible but unproven. The bug only triggers under a non-default configuration in which numbered backups are enabled while file overwriting is disabled, and it requires the victim to actually run tnef against the malicious file (CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:N/A:L, base 3.1), so no public exploit code has been identified at time of analysis and real-world risk is low despite the RCE and memory-corruption tags attached to this report. Impact is limited to availability; there is no confidentiality or integrity impact in the assessed vector.

High-privilege authenticated users can abuse the agent upgrade feature in Genian NAC and Genian ZTNA to write files outside the intended extraction directory via a ZIP Slip path traversal (CWE-862, missing authorization and integrity verification), which can result in arbitrary code execution on the appliance. Affected releases include Genian NAC 4.0.175, 5.0.65 LTS, 5.0.75 LTS, 5.0.85 Stable, and 5.0.86, plus Genian ZTNA 6.0.26 LTS, 6.0.35 LTS, 6.0.45 Stable, and 6.0.46. Exploitation is gated by high attack complexity and a high privilege requirement (PR:H) on the upgrade/management function, and there is no public exploit identified at time of analysis; the vendor (via KrCERT) scores it CVSS 4.0 5.9 Medium with integrity-only impact, while an independent assessment rates CVSS 3.1 7.0 (AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H) reflecting the possible RCE outcome.

Command injection in the optional repository-connector feature of Kiteworks Core allows an authenticated system administrator to append shell commands to a user-supplied path, resulting in code execution as the connector's service account and arbitrary file writes within that account's permissions. Only deployments running Kiteworks Core below 9.5.1 that have licensed and enabled the non-default repository connector are exposed, and successful exploitation additionally requires the appliance to be able to reach an attacker-controlled host over the network, as the injected command must pull or deliver content externally. Rated CVSS 6.6 (AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H); there is no public exploit code identified at time of analysis and the vulnerability is not confirmed actively exploited (no CISA KEV listing), so real-world risk is best characterised as LOW-to-MEDIUM despite the high-integrity/high-availability outcome, given the layered prerequisites of admin privilege, a separately licensed feature, and outbound egress.

Code execution as the gateway service account can be achieved by a trusted party in a Kiteworks Email Protection Gateway cluster that has database replication enabled, via submission of a crafted serialized object that is deserialized without sufficient validation (CWE-502). The flaw is heavily gated: replication is disabled by default, so standard standalone deployments are not exposed, and the attacker must either control a trusted cluster peer or already hold administrative access to the appliance - meaning realistic exploitation is limited to insider abuse, post-compromise lateral movement, or a malicious administrator rather than opportunistic remote attack. All releases below 9.5.1 are affected, a vendor patch (9.5.1) is available, and no public exploit code or confirmed active exploitation was identified at time of analysis; the assessed CVSS is 6.6 (AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H), reflecting the high attack complexity and high privileges required.

OS command execution on a second appliance node is possible in multi-node (clustered) Kiteworks Core deployments running versions below 9.5.1, but only for an attacker who has already achieved code execution on another node in the same cluster. An unvalidated value submitted through an internal cluster interface is written into the monitoring configuration of a peer node, where it can be interpreted as an OS command running under an unprivileged service account. There is no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV); the CVSS 3.1 score of 6.3 (AV:L/PR:L/S:C) reflects the strong prerequisites - local-adjacent access, existing low-privilege foothold, and a multi-node topology.

Improper numeric conversion in NVIDIA vGPU Virtual GPU Manager for Linux can be triggered from the kernel-mode layer by a local attacker who already holds high privileges, potentially enabling code execution, denial of service, privilege escalation, information disclosure, or data tampering. The assessed CVSS 3.1 vector (AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) shows the dominant constraint is PR:H: an unprivileged guest or local user cannot reach the vulnerable path, and only Linux vGPU Manager deployments are in scope. No public exploit or CISA KEV confirmation is identified at time of analysis; this is a genuine but not urgent issue requiring a privileged local actor.

Privilege escalation and potential code execution in the NVIDIA GPU Display Driver for Windows and Linux arise from an incorrect permission assignment (CWE-732) within a secure microcontroller component, allowing an attacker who already holds privileged local access to write to protected memory that should be restricted. Exploitation is gated by two strong prerequisites - the CVSS vector (AV:L/AC:H/PR:H/UI:N) requires local access with administrator/root-equivalent privileges and high attack complexity - so this is a genuine but lower-tier risk that primarily matters as a post-compromise escalation or persistence primitive rather than a standalone entry vector. Affected branches include GeForce (only Maxwell, Volta, and Pascal architecture GPUs), RTX/Quadro/NVS, and Tesla data-center drivers below the branch-specific fixed versions in NVIDIA bulletin 5861; there is no public exploit identified at time of analysis and no confirmed active exploitation (not in CISA KEV).

Use-after-free in the NVIDIA GPU Display Driver kernel module (CVE-2026-47586) allows an attacker with local access to the GPU device on Windows or Linux to corrupt kernel memory, with potential outcomes including code execution, privilege escalation, denial of service, information disclosure, and data tampering. The vendor CVSS vector (AV:P/AC:H/PR:N) is anomalous - designating physical access and no privileges - while the independent assessment uses AV:L/AC:H/PR:L, indicating that exploitation is not remotely triggerable and instead depends on winning a timing/command-sequence race after obtaining local low-privileged access to the driver. No public exploit code or confirmed active exploitation is identified at time of analysis, and exploitation signals point to a low-to-moderate real-world priority despite the memory-corruption impact.

An out-of-bounds write in the kernel-mode layer of the NVIDIA GPU Display Driver for Linux can be triggered by an already-privileged local user who wins a narrow race condition between concurrent kernel operations, potentially yielding code execution in kernel context, denial of service, privilege escalation, information disclosure, and data tampering. Affected branches include GeForce, RTX/Quadro/NVS, Tesla, and Guest Driver products on Linux (CVSS 3.1 base 6.4). Impact is bounded by the requirement for high local privileges (PR:H) and the non-deterministic nature of the race (AC:H); no public exploit code and no confirmed active exploitation were identified at time of analysis.

Improper input validation in NVIDIA GPU Display Driver firmware for Windows and Linux (GeForce, RTX/Quadro/NVS, and Tesla product lines) allows a locally positioned attacker who already holds high privileges to trigger code execution, denial of service, privilege escalation, information disclosure, and data tampering within the GPU firmware handling path. Scoring 6.7 (CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), the flaw is not remotely reachable and cannot be exercised by an unprivileged local user, so it is best characterized as a post-compromise privilege/kernel-boundary escalation rather than an initial-access vector. No public exploit code was identified at time of analysis and there is no indication of confirmed active exploitation; EPSS scoring was not provided in the available intelligence.

Local high-privileged attackers can exploit improper input validation in NVIDIA GPU Display Driver firmware on Windows and Linux to potentially achieve code execution, denial of service, privilege escalation, information disclosure, or data tampering. The assessed CVSS vector (CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) confirms local access and high privileges (PR:H), so this is realistically a post-compromise escalation/persistence primitive rather than an initial-access vulnerability. No public exploit identified at time of analysis.

Improper input validation in the NVIDIA GPU Display Driver kernel-mode layer allows a local high-privileged attacker to achieve code execution, denial of service, privilege escalation, information disclosure, or data tampering. Affected products include GeForce, RTX/Quadro/NVS, and Tesla drivers on Windows and Linux. Exploitation requires administrator or root-equivalent access (PR:H), so risk is limited to scenarios where a high-privilege account is already compromised; no public exploit code is identified at time of analysis.

Improper input validation in the kernel-mode layer of the NVIDIA GPU Display Driver on Windows and Linux allows a local attacker who already holds high privileges to execute code, escalate privileges, disclose information, or crash the system. The flaw is not remotely reachable (AV:L) and requires existing HIGH privileges (PR:H) to reach the vulnerable kernel code path, with no user interaction needed; the resulting CVSS 3.1 base score is 6.7. There is no public exploit identified at time of analysis and no EPSS score or KEV listing was provided in the available intelligence, making this a moderate-priority local privilege-escalation/kernel-compromise primitive rather than an internet-facing emergency.

An out-of-bounds write in the firmware component of the NVIDIA GPU Display Driver for Windows and Linux lets a local attacker who already holds administrator or root privileges corrupt memory, with potential outcomes spanning code execution, escalation of privileges, denial of service, information disclosure and data tampering. Rated CVSS 6.7 (AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, CWE-787), the flaw affects GeForce, RTX/Quadro/NVS and Tesla products; exploitation requires local access to the host plus high existing privileges, and no public exploit code was identified at time of analysis, so real-world risk is moderate rather than urgent. No user interaction is required and there is no network attack path, which rules out remote exploitation entirely.

Out-of-bounds write in the NVIDIA GPU Display Driver for Linux kernel mode layer allows a local attacker who already holds high privileges (PR:H) to corrupt kernel memory, potentially achieving code execution, privilege escalation, denial of service, information disclosure, or data tampering. Affected driver branches cover GeForce, RTX/Quadro/NVS, and Tesla products below the fixed versions listed in NVIDIA's advisory, and the attack surface is local-only, so real-world risk is assessed as MODERATE-LOW. No public exploit identified at time of analysis.

Improper validation of an array index in the kernel-mode layer of the NVIDIA GPU Display Driver for Windows and Linux gives a local, already highly privileged attacker a path to full loss of confidentiality, integrity, and availability on the host. The flaw affects driver branches for GeForce, RTX/Quadro/NVS, and Tesla products below the fixed versions published in NVIDIA bulletin 5861, including 580.178.04, 582.78, 595.91.07, 596.86, 610.60, 610.88, 615.71.09 and 616.92 depending on the product line. Exploitation requires local access (AV:L) and pre-existing high privileges (PR:H) to reach the kernel-mode driver interface, with no user interaction and no network vector, so this is a local privilege/kernel-escalation primitive rather than an initial-access vector; no public exploit has been identified at time of analysis. Real-world risk is MODERATE-LOW despite the full-CIA impact assessment, because the attacker must already be highly privileged before the flaw can be touched.

An out-of-bounds write in the kernel-mode layer of the NVIDIA GPU Display Driver for Windows and Linux allows a local attacker who already holds high privileges (PR:H) to corrupt kernel memory, with the potential for code execution, privilege escalation, information disclosure, denial of service, and data tampering. Affected installations are those running GeForce, RTX/Quadro/NVS, or Tesla display drivers at versions below the fixed release for their branch (for example prior to 610.88, 582.78, 616.92, or 580.178.04), on either Windows or Linux. The CVSS 3.1 base score of 6.7 reflects the non-network, high-privilege access prerequisite rather than broad exposure; no public exploit code has been identified at time of analysis.

A kernel-mode out-of-bounds write in the NVIDIA GPU Display Driver for Linux lets a local attacker who already holds high privileges corrupt kernel memory in the driver's kernel mode layer, which the vendor states may lead to code execution, denial of service, privilege escalation, information disclosure and data tampering. The flaw carries a CVSS 3.1 base score of 6.7 (AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), meaning exploitation is strictly local and requires pre-existing elevated/administrative access on the host; there is no network attack vector and no user interaction is needed. Affected systems are Linux hosts running GeForce, RTX/Quadro/NVS or Tesla driver branches below the fixed releases published in NVIDIA security bulletin 5861, and there is no public exploit identified at time of analysis.

Out-of-bounds read in the firmware component of NVIDIA GPU Display Drivers for Windows and Linux allows a local attacker who already holds high privileges (PR:H, per CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) to read memory beyond intended firmware buffer bounds, most plausibly resulting in memory disclosure or a driver/GPU crash, with the vendor also flagging the potential for code execution, escalation of privileges and data tampering. The CVSS 3.1 base score is 6.7; the attack path is local-only, requires no user interaction, and is gated behind pre-existing high privilege, which materially limits real-world exposure. No public exploit code has been identified for this issue and it is not in CISA KEV, so no public exploit identified at time of analysis.

Code execution, privilege escalation, denial of service, information disclosure, and data tampering are all possible on Windows and Linux hosts running unpatched NVIDIA GPU Display Driver branches, because the kernel-mode layer fails to validate an array index (CWE-129) when processing a crafted GPU command. The flaw is strictly local: per the CVSS vector (AV:L, PR:H, UI:N) and our independent assessment, an attacker must already hold high privileges on the machine and be able to submit work to the GPU kernel driver, and there is no network or unauthenticated path. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, so this is a genuine but moderate-priority hardening target for GeForce, RTX/Quadro/NVS, and Tesla deployments; fixed driver builds exist for each affected branch.

An out-of-bounds read in the kernel-mode layer of NVIDIA's GPU Display Driver for Windows and Linux can be triggered by a locally present attacker who already holds high privileges, potentially leading to kernel-context code execution, privilege escalation, denial of service, information disclosure, or data tampering. Exploitation requires local code execution at an elevated privilege level (CVSS vector PR:H) against a vulnerable driver build that is installed and loaded, so there is no remote or unauthenticated path and the practical risk is a defense-in-depth and privilege-boundary concern rather than an initial-access vector; no public exploit has been identified at time of analysis. NVIDIA has published fixed driver builds per product line and branch, and the affected install base spans GeForce, RTX/Quadro/NVS, and Tesla GPUs.

Improper input validation in the NVIDIA GPU Display Driver kernel-mode layer can be triggered by a locally present attacker who already holds high privileges, potentially yielding kernel code execution, denial of service, privilege escalation, information disclosure, or data tampering on Windows and Linux hosts. The affected code base spans all three major product lines - GeForce, RTX/Quadro/NVS, and Tesla - and NVIDIA has published branch-specific fixed driver versions for each. There is no confirmed active exploitation (the issue is not in CISA KEV) and no public exploit code identified at time of analysis; the dominant real-world constraint is that PR:H means this cannot be used for initial access, only by an actor who has already obtained elevated privileges on the host.

An out-of-bounds read in the NVIDIA GPU Display Driver kernel-mode layer on Windows and Linux lets a locally authenticated attacker who already holds high privileges trigger an unbounded string operation that reads beyond the end of an allocated buffer, with vendor-acknowledged consequences including code execution, denial of service, privilege escalation, information disclosure, and data tampering. The flaw (CWE-125, CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, base 6.7) affects GeForce, RTX/Quadro/NVS, Tesla, and vGPU guest driver builds below the fixed versions published in NVIDIA's 2026 advisory, and exploitation is strictly local - there is no network vector, no user interaction, and no non-default configuration requirement, only a privileged process on an affected host. Real-world risk is moderate and localized: no public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, so value to an attacker is mainly as a local privilege-escalation or kernel-tampering primitive after an initial foothold.

Kernel-mode out-of-bounds write in NVIDIA GPU Display Driver for Windows and Linux (GeForce, RTX/Quadro/NVS, Tesla, and vGPU guest drivers) allows a local attacker with high privileges to corrupt kernel memory, potentially leading to code execution, denial of service, privilege escalation, information disclosure, and data tampering. No public exploit has been identified at time of analysis. Affected driver branches include GeForce prior to 595.91.07, RTX/Quadro/NVS prior to 596.86, Tesla prior to 616.92, and vGPU guest drivers prior to vGPU 19.5/20.1, among others.

PHP Object Injection in the EWWW Image Optimizer WordPress plugin before 8.8.0 allows an authenticated user holding author-level or higher privileges to persist a serialized payload into a post meta field that the plugin unserializes when the post is rendered, which can escalate to remote code execution when a suitable POP gadget chain is reachable in EWWW itself or in another installed plugin or theme. Exploitation is conditional: it requires a valid author (or higher) account, the ability to write the offending meta value, and the affected post being rendered, and without a usable gadget chain the outcome stops at object injection rather than code execution. No public exploit code and no confirmed active exploitation have been identified at time of analysis (CISA SSVC records Exploitation: none and Automatable: no), and our independent assessment characterises this as a genuine but conditional risk.

Local privilege escalation in HPE Networking Instant On firmware 3.4.1.0 and earlier allows an attacker who already holds high-privilege local access to the affected daemon to achieve arbitrary code execution as root. The CVSS 3.1 vector (AV:L/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H, score 6.4 Medium) shows the barriers are steep: the attacker must be local and already privileged, and exploitation is further gated by 'certain preconditions outside of the attacker's control,' consistent with a high-complexity trigger such as timing or transient system state. No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV.

Memory corruption reachable through an unvalidated format string in the management API of HPE Networking Instant On access points allows an attacker who already holds high administrative privileges to provoke a denial-of-service condition or potentially achieve remote code execution on devices running firmware 3.4.1.0 and earlier. The flaw is scored CVSS 3.1 6.6 (AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H), reflecting that the attacker must be authenticated with high privileges and that reliable exploitation hinges on crafting format-string input that reliably corrupts memory, which often requires memory-layout knowledge or repeated attempts. No public exploit code or confirmed active exploitation was identified at time of analysis, so the dominant risk driver is the high-privilege prerequisite - an attacker must first obtain or compromise an admin account, or chain another vulnerability to reach the vulnerable function.

Cache poisoning in UnoPim before 2.0.1 and 2.1.x before 2.1.1 allows unauthenticated remote attackers to inject an arbitrary origin into admin layout pages by sending a crafted X-Forwarded-Host header, because the application trusts every connecting client as a proxy and never validates the header. When a shared caching proxy or CDN stores the poisoned admin response, a subsequent administrator loading that page has the admin UI's JavaScript assets resolved from the attacker's server, executing attacker-supplied code inside an authenticated session. Exploitation is conditional - it requires an intermediary cache in front of admin responses and an administrator visiting the poisoned page (assessed CVSS 3.1 AV:N/AC:H/PR:N/UI:R/S:C, with limited confidentiality and integrity impact), no public exploit code or confirmed active exploitation was identified at time of analysis, and the CVSS 4.0 base score is 2.3.

Authenticated users of Langflow instances prior to 1.12.0 can convert crafted component input options into arbitrary Python code execution because schema.py interpolates those options into a Literal type string that is handed directly to eval() without safe-evaluation controls (CWE-95). The sink fires when an affected component is turned into a LangChain tool via ComponentToolkit.get_tools(), which also occurs during custom-component saves through the API, so an attacker must already hold a valid account able to create or save components (PR:L in the assessed CVSS 3.1 vector; PR:H in the vendor's CVSS 4.0 vector) and must satisfy the high-complexity object-crafting and interpolation path (AC:H/AT:P). No public exploit code has been identified at time of analysis and the issue is not in CISA KEV; practical marginal risk is limited because the privileges required to reach the sink typically already allow legitimate Python execution through Langflow's custom-component feature.

The F&F Filipowski mH-DEVELOPER smart home module ships production firmware built on end-of-life Debian 8 and Node.js 17.0.1, both of which are past their support lifecycles and carry publicly documented, permanently unpatched vulnerabilities. Rather than containing one discrete exploitable flaw, the product is exposed because it bundles obsolete, unsupported third-party components (CWE-1104); an attacker who can reach and correctly trigger one of the known component CVEs in this firmware could achieve arbitrary code execution, data disclosure, or denial of service, and the network-reachable services require no authentication (CVSS vector signals PR:N). No public exploit identified at time of analysis, and no KEV listing, so this is best treated as a software-composition hygiene finding whose real-world risk is contingent on how exposed the device's services are; F&F addressed the issue in firmware 3.0.30.

Arbitrary file write via path traversal in the kubectl client on Windows allows a malicious tar binary inside an untrusted container to place files at attacker-chosen locations on the operator's workstation, limited only by the permissions of the local user running kubectl. Exploitation requires victim interaction: the user must run `kubectl cp` to copy files FROM an attacker-controlled container, and only affects kubectl clients on Windows (v1.34.0-1.34.11, v1.35.0-1.35.8, v1.36.0-1.36.4) - Linux and macOS clients are explicitly unaffected. The Kubernetes Security Response Committee rated this Medium at CVSS 6.5, our independent assessment concurs at CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:N (unauthenticated, user-interaction required, high integrity impact only), and no public exploit code was identified at time of analysis.

Unauthenticated shortcode injection in WPForms Lite (versions 1.5.0.1 through 2.0.2) lets remote attackers execute arbitrary registered WordPress shortcodes by submitting form field values that the plugin echoes back into the rendered form without stripping shortcode delimiters. Publicly available exploit code exists via the WPScan advisory, and the CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N (6.5 Medium) confirms low-complexity, no-user-interaction exploitation. Impact is bounded by the shortcodes present on the target; successful exploitation can disclose attachment details of non-public posts and modify rendered form output, but does not by itself grant full remote code execution.

Local code execution in Google fuse-archive versions prior to 1.24 lets an attacker hijack the external decompression helpers that libarchive launches when an archive is mounted, by prepending a directory to the process PATH or by planting a malicious binary in an attacker-writable directory that already appears on PATH. The flaw is an untrusted search path issue (CWE-426) rated 5.4 under CVSS 4.0 (AV:L/AC:L/AT:P/PR:L/UI:A/VC:H/VI:H/VA:H); exploitation requires local access as an authenticated user (PR:L), that fuse-archive run without the '-o noexternal' option, and that a victim mount an archive whose format triggers an external filter such as base64 or gpg. No public exploit code or CISA KEV entry was identified at time of analysis; version 1.22 delivered only a partial mitigation and version 1.24 fully resolves the issue by restricting external helper lookups to a sanitized, fixed PATH.

Cross-site scripting in Adminer before 6.0.2 allows a malicious database server to execute arbitrary JavaScript in an authenticated Adminer session by returning a crafted CONNECTION_ID() result that is interpolated into JavaScript without escaping. The base XSS requires a victim to initiate a connection to the malicious server (UI:P); in co-located deployments where the database account holds FILE privileges and the webroot is writable, this can escalate to remote code execution via SQL writes using INTO DUMPFILE. No public exploit code has been identified at time of analysis, and exploitation requires specific non-default conditions for the RCE escalation.

Exec allowlist bypass in OpenClaw (npm-distributed agent runtime) causes Windows hosts running in exec allowlist mode to launch the wrong binary: a PowerShell command approved by bare executable name is analyzed and allowed against the PATH-resolved path, but at execution time a same-named executable planted in an agent-writable workspace is run instead, yielding arbitrary code execution with the privileges of the Gateway or node-host user. Affected versions are 2026.2.26 through 2026.7.1; the vendor rates it CVSS 4.0 5.4, while our assessment maps to CVSS 3.1 AV:L/AC:H/PR:L/UI:R/S:U/C:H/I:H/A:H, i.e. a real but heavily gated privilege/execution issue requiring a local, low-privileged actor with an existing operator allowlist approval and the ability to steer the agent. No public exploit identified at time of analysis and no CISA KEV entry; version 2026.7.1 contains the vendor-released fix.

Out-of-policy local file disclosure in OpenClaw's Discord integration (@openclaw/discord) before 2026.9.3 allows an authenticated sender who is already permitted to invoke the guild emoji and sticker upload actions to have the integration read and upload bytes from a local host file that the sender's configured media roots would otherwise reject. The bypass is narrow: it stems from the sender-scoped media policy being dropped in the emoji/sticker upload code path before the local file is loaded, and it does not grant filesystem browsing, directory listing, or code execution - the attacker must already know or derive a useful absolute path on the OpenClaw host. CVSS 4.0 scores this 6.0 (AV:N/AC:H/AT:P/PR:L/UI:N/VC:H), and while no public exploit or confirmed active exploitation has been identified at time of analysis, the vendor has released a fix in @openclaw/discord 2026.9.3, so the real-world priority is low-to-moderate and driven by deployments that expose the guild asset action to semi-trusted senders.

Code injection in the Zhonglun CloudPos desktop client (versions up to and including 3.0.1.76) allows remote attackers to inject and execute code through the 'url' argument of the OpenLocalBrowser function in the CefSharp-based JSBridge component (ZlPos/ZlPos/Bizlogic/JSBridge.cs), with the vendor's own CVE record pointing to RCE as the practical outcome. Publicly available exploit code exists - a proof-of-concept document titled 'CloudPos.CefSharp.RCE' is linked from the disclosure - so the attack is both demonstrable and reproducible. The vendor was contacted but did not respond, so no vendor-released patch has been identified; exploitation requires the affected desktop client to process an attacker-influenced url (the independent assessment rates UI:R, implying some operator interaction or attacker-controlled content delivery is likely despite the CVSS 4.0 vector's UI:N claim). The CPE entry uses a wildcard version range, so all released builds up to 3.0.1.76 should be treated as affected.

Directory traversal in Input Leap through 3.0.3 allows a connected peer to send a crafted DDRG drag-and-drop protocol message that escapes the intended drop directory on Windows and macOS, writing attacker-controlled files anywhere the Input Leap process has write access - including startup directories, which yields code execution the next time the victim logs in or reboots. The flaw only manifests when the non-default --enable-drag-drop option is explicitly enabled and only against Windows or macOS targets; delivery requires the attacker to act as an authorized/connected peer (PR:L per the assessed vector, which the vendor vector agrees on). No public exploit code or confirmed active exploitation was identified at time of analysis, and while the vendor score is 5.3 (C:N/I:H/A:N), our independent assessment raises the impact ceiling to C:H/I:H/A:H - this is a high-ceiling but low-risk-in-practice issue because of the non-default prerequisite, the platform restriction, and the delayed, login-dependent execution path.

Symlink traversal in the drag-and-drop remote staging path of kitty 0.47.0 up to (but not including) 0.49.0 lets a program that can write to the terminal create new files (mode 0644) and directories (mode 0755) at arbitrary absolute paths writable by the user running kitty, by declaring two identically named entries - the first a symlink to a chosen absolute path, the second a directory. Exploitation is local and requires the victim to actively initiate a drag-and-drop operation from the terminal (UI:A); the assessed vector is CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:N (CVSS 4.0 base 4.6), so impact is limited to integrity of newly created paths, and O_CREAT|O_WRONLY|O_EXCL semantics prevent overwriting any pre-existing file. No public exploit code identified at time of analysis, and the vendor released a fix in 0.49.0 that refuses symlinked directory entries during remote drag staging.

Stored cross-site scripting in the pfBlockerNG package for Netgate pfSense 26.03.1-RELEASE allows an unauthenticated remote attacker to inject script into a crafted DNS hostname, which is captured by DNSBL logging and later rendered unsafely in the pfBlockerNG report UI, executing in the browser of an administrator who opens the affected page and enabling escalation to command execution through the admin's authenticated session. The published CVSS 3.1 base score of 6.1 (Medium), derived from the standard reflected/stored XSS vector (AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N), understates the real-world impact, which the independent assessment re-scores to integrity and availability High (C:H/I:H/A:H) because the stored script can pivot to arbitrary code execution on the firewall. This is not part of the base pfSense install: pfBlockerNG must be installed and actively logging DNS via DNSBL, and an administrator must subsequently view the affected report/log page, so exploitation is not fully automatic despite the unauthenticated delivery vector (PR:N with UI:R confirmed from the CVSS vector); no confirmed public exploit code or CISA KEV listing was identified at time of analysis.

Code injection in DbGate (a web-based database GUI) versions up to 7.2.5-beta.5 lets an authenticated user who can create or edit a JSON Runner or scheduled script inject text into the comment.text or script.schedule fields that escapes the generator's `//` comment wrapper and reconstitutes a `// @require <module>` or `// @schedule` directive, causing the server to load and execute attacker-supplied code. The flaw is remote, requires low privileges (PR:L) and no user interaction, and is limited to unpatched releases; it is fixed by upgrading to 7.2.5-beta.6 (upstream commit 70e7b6b58e464d7a015ba16e8d7574b420ee4877, PR #1527). There is no confirmed active exploitation (not in CISA KEV) and no public exploit identified at time of analysis, though the EPSS-style exposure is mitigated mainly by the requirement for an authenticated account with runner-editing rights. This issue is explicitly distinct from CVE-2026-47668.

A specially crafted NFC card or NFC emulator can feed unsanitized data into the web view used by the PaperCut Hive embedded application on Ricoh devices, allowing an attacker with physical access to the device panel to execute code within the application's UI context and potentially trigger unauthorized actions or disclose information. Exploitation requires hands-on physical access to an NFC-enabled device that is configured to use NFC card authentication, and the resulting execution is confined to the embedded app's web view rather than the underlying Ricoh firmware or OS. No public exploit code has been identified at time of analysis and the flaw is not in CISA KEV; with a CVSS 4.0 base score of 3.8 (assessed CVSS 3.1 AV:P/AC:L/PR:N/UI:N/S:C/C:H/I:L/A:N), real-world risk is LOW despite the 'arbitrary code execution' phrasing in the vendor description.

Argument injection in Red Hat Ansible Automation Platform 2's automation-controller system-job subsystem allows an authenticated user with superuser privileges to inject arbitrary command-line arguments into the control-plane awx-manage process, gaining control of its argument vector and the first entry of its Python module search path. The root cause is that the system-job template launch endpoint stores a caller-supplied 'days' value without applying the integer validation used elsewhere for that field, and the dispatcher flattens the management-command argument list into a single space-delimited string that the job runner re-splits, so embedded spaces become additional arguments; system jobs run in-process on the control node without the container isolation applied to other job types. Confirmed remote code execution does not follow from the injected arguments alone - it would require an additional import gadget that is not present in the current management commands - so the demonstrated impact is argument injection and search-path control rather than code execution, and no public exploit was identified at time of analysis.

Cross-site request forgery in REDAXO CMS 5.21.1 and earlier lets a remote, unauthenticated attacker (CVSS PR:N with UI:R) lure a logged-in backend administrator into silently triggering an addon update or downgrade from the REDAXO package server via a single forged request to index.php?page=install/packages&rex-api-call=install_package_update. The attacker must know or guess a valid addonkey and target file id, and the admin must have an active session and visit an attacker-controlled page, so this is a genuine but conditional-risk flaw rather than a drop-everything emergency; absent a supply-chain compromise of a redaxo.org package or a vulnerable prior version to downgrade to, the practical impact is limited to forced or unwanted addon installs and site disruption. No active exploitation in CISA KEV has been reported, and no public exploit identified at time of analysis beyond the minimal image-tag proof-of-concept published in the vendor advisory.

Arbitrary shortcode execution in the WordPress plugin Ninja Tables before 5.2.17 lets an unauthenticated visitor execute arbitrary shortcodes and permanently break a public page by submitting an ordinary form entry, provided the site is running a non-default configuration in which user-submitted rows are rendered with shortcode expansion. Affected sites require no authentication and no victim interaction (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:L, score 5.6); default installations do not expand shortcodes in non-administrator-authored rows and are therefore not exposed, which is why the vendor rated attack complexity as High. Publicly available exploit code exists via the WPScan advisory, but there is no indication of confirmed actively exploited (CISA KEV) status, so priority is bounded by the configuration prerequisite.

Server-side shortcode execution can be triggered through the GTranslate WordPress plugin before 5.0.1, which fails to strip shortcodes from outgoing email content before expanding them. Unauthenticated remote attackers can exploit this only when the plugin is configured in a non-default way that places user-influenced content into email bodies passed through WordPress shortcode expansion, and only if a useful shortcode is already registered on the site; both prerequisites keep the practical impact bounded and are reflected in the assessed CVSS score of 4.8 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N). Publicly available exploit code exists via the WPScan advisory, and there is no indication of confirmed active exploitation (CISA KEV); this is a real but low-priority issue.

Unauthenticated attackers can execute registered shortcodes server-side and read unpublished recipe content on WordPress sites with comments enabled that use the WP Recipe Maker plugin before 10.8.2. The vulnerability occurs because comment content is shortcode-expanded during structured metadata generation without stripping shortcodes, allowing any available shortcode to run. Publicly available exploit code exists, and the CVSS 3.1 score is 6.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N), indicating network-reachable, low-complexity exploitation with no authentication or user interaction and low confidentiality/integrity impact limited to shortcode capabilities and disclosure of unpublished recipes.

Remote code execution on the Apache Doris Frontend (FE) is achievable when a privileged, already-authenticated user supplies a crafted JDBC driver URL that the FE loads without sufficient validation, a case of inclusion of functionality from an untrusted control sphere (CWE-829). The assessed vector (CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) shows the flaw is network-reachable but gated behind high privileges, meaning only accounts that can define or modify JDBC catalogs or external resources can reach the vulnerable code path; anonymous or low-privilege actors are out of scope, and no user interaction or default-configuration vector exists for an external unauthenticated attacker. No CVSS score, EPSS value, KEV entry, or proof-of-concept was supplied in the source data, so there is no confirmation of active exploitation and no public exploit identified at time of analysis, leaving quantitative prioritization signals absent.

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.