Local privilege escalation in Rapid7 InsightVM, Nexpose, and the Insight Agent allows a low-privileged user to gain elevated code execution by planting an executable in a location the scanner discovers and runs during an authenticated assessment. Because the products execute discovered executables without validating file ownership (CWE-250), the planted code runs as the scan credential on Scan Engine or as root/SYSTEM under the Insight Agent, yielding full local compromise. There is no public exploit identified at time of analysis and the CVE is not on CISA KEV, but the vendor-confirmed root/SYSTEM outcome makes this a meaningful escalation path.
Privilege escalation in Exim versions 4.82 through 4.99.4 permits local users with shell access to execute arbitrary commands with elevated mail delivery privileges by crafting a malicious ~/.forward file that exploits mishandled force_command logic in the pipe transport. The affected deployment window is substantial - covering a wide span of Exim releases present across Debian, Ubuntu, and other Linux distributions. No confirmed active exploitation or public exploit code has been identified at the time of analysis; SSVC rates this as non-automatable with no observed exploitation, though technical impact is assessed as total given full CIA compromise upon success.
...
Exposure of Sensitive Information (CWE-200) in LWEB802 browser `localStorage` in Loytec LWEB-802 before 5.0.8 on all platforms allows an unauthenticated remote attacker to leak stored management credentials via a crafted link.
Pre-authentication remote code execution in libssh2 1.11.1 and earlier allows a malicious SSH server to compromise any connecting client. A heap buffer overflow in the Encrypt-then-MAC (ETM) cipher negotiation path overwrites heap metadata, enabling tcache bin confusion and function pointer control before user authentication. No active exploitation is known, and EPSS is low (0.32%), but the client-side impact is severe if a victim can be lured to an attacker-controlled server.
Heap-based buffer overflow in the vf_hqdn3d denoising filter of FFmpeg versions up to 8.1.2 allows remote attackers to execute arbitrary code by tricking a user into processing a crafted video with filter graph reinitialization explicitly disabled (-reinit_filter 0). Exploitation requires the vulnerable filter to be applied to input where frame width increases after the initial frame, causing an undersized buffer allocation and subsequent out-of-bounds write. No active exploitation or public proof-of-concept is known at time of analysis; EPSS score is low (0.29%).
Memory corruption in libssh2's publickey response parser allows a malicious SSH server to leak heap pointers and corrupt the heap, potentially leading to remote code execution. The issue affects libssh2 versions up to 1.11.1 and is triggered when a client connects to an attacker-controlled SSH server and fetches public keys, with no authentication required on the server side. A patch is available in commit a13bb6c, though no tagged release includes the fix yet; no active exploitation or public exploit code is currently reported.
Denial of service in Apache Thrift Ruby bindings before 0.24.0 allows unauthenticated remote attackers to exhaust server resources by sending highly compressed data. No active exploitation or public exploit code has been observed at time of analysis. Upgrading to version 0.24.0 resolves the vulnerability.
Denial of service in Apache Thrift 0.x before 0.24.0 allows remote attackers to exhaust server memory via crafted zlib-compressed payloads in the Python THeaderTransport layer. The flaw permits a small compressed request to decompress into an excessively large memory allocation, causing service disruption. No public exploit code or active exploitation is known, and the vulnerability is rated important by the Apache project.
Information disclosure in Microsoft Azure Portal allows a remote, unauthenticated attacker to access sensitive data they are not authorized to view by exploiting an improper authorization check (CWE-285) reachable over the network. The flaw affects the cloud-hosted Azure management console and, per its CVSS vector, requires no privileges or user interaction while yielding high confidentiality impact with no integrity or availability effect. No public exploit has been identified at time of analysis, and CISA SSVC records exploitation status as none, though the issue is assessed as automatable; the EPSS probability is modest at 1.03%.
Denial of service in Apache NimBLE 1.9.0 and earlier allows a remote attacker to crash the BLE host stack via a crafted ATT Read Multiple Variable Response. The vulnerability is triggered when a vulnerable device, acting as a BLE Central, sends a Read Multiple Variable Request and receives a malicious response that causes an assertion failure in the ATT parser. Exploitation is not known to be active in the wild, and a patch is available in version 1.10.0.
Denial of service in Apache Neethi versions before 3.2.3 allows unauthenticated remote attackers to bypass a limit on normalized policy alternatives using crafted WS-Policy documents, causing resource exhaustion. The flaw was introduced with the limit in version 3.2.2 and has a CVSS of 7.5 but very low EPSS probability (0.33%), with no active exploitation or public exploit code reported. Upgrading to version 3.2.3 fully resolves the issue.
Denial of service via memory exhaustion in Apache Neethi versions prior to 3.2.3 allows remote unauthenticated attackers to crash services by supplying crafted policies with deep nesting or missing Policy Ids. No public exploit or active exploitation is known; EPSS score (0.33%) indicates low current exploitation probability. Users should upgrade to version 3.2.3.
A remote denial-of-service vulnerability in the Linux kernel's AF_RXRPC subsystem allows unauthenticated attackers to crash the system by sending malicious RxGK-secured DATA packets. The flaw stems from missing length checks in the Kerberos 5 crypto library before message decryption or verification. While the CVSS score is 7.5 (High), no active exploitation or public proof-of-concept exists, and EPSS predicts a low exploitation probability (0.17%), suggesting limited immediate real-world risk.
In the Linux kernel, the following vulnerability has been resolved: net/mlx5e: xsk: Fix unlocked writing to ICOSQ During napi poll, when the affinity changes and there's still XSK work to be done, we trigger an ICOSQ interrupt on the new CPU. However, this triggering on the ICOSQ is done unprotected. There are 2 such races: A) mlx5e_trigger_irq() is called while mlx5e_xsk_alloc_rx_mpwqe() is running from a different CPU due to affinity change. This can happen because IRQ triggering is done after napi_complete_done(). At this point the NAPI can be scheduled on a different CPU. Like this: CPU A (old affinity, NAPI tail) CPU B (new affinity, fresh NAPI) ------------------------------- -------------------------------- napi_complete_done() clears SCHED mlx5e_cq_arm(...) napi_schedule_prep() sets SCHED mlx5e_napi_poll() mlx5e_xsk_alloc_rx_mpwqe() mlx5e_icosq_sync_lock() // noop memcpy 640 B UMR body advance sq->pc by 10 mlx5e_trigger_irq(&c->icosq) wqe_info[pi] = {NOP, 1} mlx5e_post_nop() advances sq->pc B) mlx5e_trigger_irq() is called on the ICOSQ when mlx5e_trigger_napi_icosq() is running. The obvious fix would be to lock the ICOSQ. But ICOSQ has an optimized locking scheme that doesn't work for this scenario. Kick the async ICOSQ instead which is always locked. This issue was noticed in the wild with the following splat: netdevice: ge-0-0-1: Bad OP in ICOSQ CQE: 0xd WARNING: drivers/net/ethernet/mellanox/mlx5/core/en_rx.c:826 [...] [...] Call Trace: <IRQ> mlx5e_napi_poll+0x11d/0x7f0 [mlx5_core] __napi_poll+0x30/0x200 ? skb_defer_free_flush+0x9c/0xc0 net_rx_action+0x2fe/0x3f0 handle_softirqs+0xd8/0x340 __irq_exit_rcu+0xbc/0xe0 common_interrupt+0x85/0xa0 </IRQ> <TASK> asm_common_interrupt+0x26/0x40 [...] ---[ end trace 0000000000000000 ]--- mlx5_core 0000:08:00.0 ge-0-0-1: Error cqe on cqn 0x548, ci 0x2022, qn 0x8f4, opcode 0xd, syndrome 0x2, vendor syndrome 0x68 00000000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00000020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00000030: 00 00 00 00 01 00 68 02 01 00 08 f4 de 14 59 d2 WQE DUMP: WQ size 16384 WQ cur size 0, WQE index 0x1e14, len: 64 00000000: 00 00 00 01 d9 ed 80 02 00 00 00 01 d9 ed 90 02 00000010: 00 00 00 01 d9 ed a0 02 00 00 00 01 d9 ed b0 02 00000020: 00 00 00 01 d9 ed c0 02 00 00 00 01 d9 ed d0 02 00000030: 00 00 00 01 d9 ed e0 02 00 00 00 01 d9 ed f0 02 mlx5_core 0000:08:00.0 ge-0-0-1: Error cqe on cqn 0x548, ci 0x2023, qn 0x8f4, opcode 0xd, syndrome 0x5, vendor syndrome 0xf9 00000000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00000020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00000030: 00 00 00 00 01 00 f9 05 01 00 08 f4 de 15 cf d2
Improper certificate validation in Apereo CAS Client 4.1.0 and Jasig CAS Client 3.6.4 allows a man-in-the-middle attacker to intercept Ticket-Granting Tickets (TGTs) by presenting any CA-signed certificate for a hostname matching the client's allowlist. An attacker with a network interception position can then obtain service tickets on behalf of the victim. No active exploitation or public exploit code is confirmed, and EPSS indicates low exploitation probability (0.17%).
Privilege escalation via authorization bypass in EventON Action User for WordPress allows unauthenticated attackers to grant management and file-upload capabilities to any non-administrator role or user. The same endpoint also leaks user IDs, display names, capability states, and nonces, and lets attackers tamper with event-to-user assignments. No public exploit or active exploitation has been identified, but the vulnerability is trivially automatable.
Cleartext credential storage in Tycon Systems TPDIN-Monitor-WEB2 web management interface allows authenticated attackers to view system credentials, potentially leading to compromise of other network systems. Affected version is 2.3.9. No active exploitation or public exploit is known, and EPSS indicates a very low probability of exploitation.
Local privilege/code execution in GeoVision's GV-IP Device Utility is possible via DLL hijacking (CWE-427): the Windows desktop application loads one or more DLLs from an unsafe search path, letting a local attacker who can plant a malicious DLL run code in the context of the user who launches the utility. Exploitation requires the victim to execute the application (UI:R) and the attacker to already have a foothold with low privileges on the host (PR:L). There is no public exploit identified at time of analysis and it is not listed in CISA KEV; CVSS is 7.3 (High).
Stored cross-site scripting in VikBooking Hotel Booking Engine & PMS plugin for WordPress allows unauthenticated attackers to inject arbitrary web scripts through the 'vbfX' custom field via the publicly accessible saveorder task. Affected versions up to 1.8.13 enable code execution in the context of any user viewing the injected page, with potential for cookie theft or session hijacking. No known exploitation in the wild; EPSS indicates low probability of exploitation.
### Summary Heap-buffer-overflow READ (16 bytes) in `Gemm_7_6::adapt_gemm_7_6()` (`onnx/version_converter/adapters/gemm_7_6.h:41`) when `ConvertVersion()` processes a model with a Gemm node whose input tensors have fewer than 2 dimensions. The adapter accesses `B_shape[1]` without checking rank. On Release builds the OOB read is silent; ASan confirms 16-byte read past a 48-byte allocation. ### Details The Gemm 7→6 downgrade adapter reads input shapes without bounds checking: ```cpp // gemm_7_6.h:26-42 const auto& A_shape = inputs[0]->sizes(); // May have < 2 elements const auto& B_shape = inputs[1]->sizes(); // May have < 2 elements if (node->hasAttribute(ktransB) && node->i(ktransB) == 1) { MN.emplace_back(B_shape[0]); // OOB if B has 0 dims } else { MN.emplace_back(B_shape[1]); // OOB if B has < 2 dims ← CRASH } ``` The PoC has input B with shape `[28]` (1 dimension). `B_shape` has 1 element. Accessing `B_shape[1]` reads 16 bytes past the `std::vector<Dimension>` internal storage into adjacent heap memory. The same unchecked pattern applies to `A_shape[0]` and `A_shape[1]` at lines 34 and 36. **Entry point:** `onnx.version_converter.convert_version(model, 6)` - different from the `InferShapes` bugs reported in separate advisories. This triggers during opset downgrade (7→6). ### PoC ```python import base64 import onnx from onnx import version_converter poc_b64 = "CAM6rwEKUQoBQQoBQgoBQRIBWSIER2VtbSoPCgVhbHBoYRUBAQA+oAEBKg4KBGJldGEVAAAAOqABASoNCgZ0dGZsc0EYAaABAioNCgZ0cmFuc0IYAKABAhIKb2Vpdl94bWZ2aFoTCgFBEg4KDAgBEggKAggCCgIIA1oTCgFCEg4KDAgBEggKAggcCgIIBFoPCgFCEgoKCAgBEgQKAggbYhMKAVkSDgoMCAESCAoCCAIKAggEQgQKABAH" model = onnx.load_from_string(base64.b64decode(poc_b64)) # Triggers heap-buffer-overflow in Gemm_7_6 adapter version_converter.convert_version(model, 6) ``` 186-byte PoC. ASan confirms: `heap-buffer-overflow READ of size 16` at `gemm_7_6.h:41`, `0 bytes after 48-byte region` allocated in `tensorShapeProtoToDimensions` at `ir_pb_converter.cc:216`. ### Impact Any application that uses `onnx.version_converter.convert_version()` on untrusted models is vulnerable. This includes model conversion pipelines and tools that auto-downgrade opset versions for compatibility. On Release builds the OOB read is silent - the read value propagates into the converted model's output shape, potentially leaking heap data. On ASan builds it's detected as a heap-buffer-overflow. Could also cause crashes with different heap layouts.
Remote code execution in Microsoft Azure API Management (APIM) allows an authorized network attacker to achieve full system compromise via improper access control. The vulnerability (CWE-284) is tagged 'Authentication Bypass,' suggesting that despite requiring high privileges for initial entry, the flaw may allow an attacker to circumvent authorization boundaries within APIM and escalate to code execution. No public exploit has been identified at time of analysis, and SSVC confirms no current exploitation; however, the total technical impact (C:H/I:H/A:H) makes patching a priority for any organization running Azure API Management workloads.
Arbitrary OS command execution in OpenStack Ironic Python Agent (IPA) through version 11.6.0 lets a project-scoped user holding the manager role run attacker-chosen commands on a running IPA ramdisk by supplying a crafted ntp_server value that is passed unsanitized to a shell. Because IPA drives bare-metal provisioning, code execution occurs in the privileged provisioning agent context, enabling full compromise of the node being managed. There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV.
HTTP request smuggling in libsoup (GNOME's HTTP client/server library) enables network-accessible attackers to inject hidden requests into backend streams by exploiting a parsing differential between libsoup's permissive chunked transfer encoding parser and strict RFC 9112-compliant frontend proxies. All libsoup versions are affected as tracked under CPE cpe:2.3:a:gnome:libsoup, with confirmed vendor impact across Red Hat Enterprise Linux 6.0 through 10.0. No public exploit code or active exploitation has been identified at time of analysis; SSVC classifies exploitation as none with non-automatable, partial technical impact.
Privilege escalation and unauthorized data modification in the Grafana IRM cloud service allowed authenticated low-privilege users to perform operations on behalf of other users due to broken access controls, potentially leading to account takeover. The vulnerability affected cloud-only deployments of versions 1.0.0 through 1.164.0 and has been automatically resolved; self-hosted environments are not impacted. The EPSS exploitation probability is low (0.29%) and no active exploitation is known.
Uncontrolled memory allocation in FFmpeg through 8.1.2 allows a remote attacker to exhaust process memory by supplying a crafted IAMF media file as small as 17 bytes. The IAMF demuxer's mix_presentation_obu() function calls av_calloc() with an attacker‑controlled count_label value before validating input data, causing an amplification of approximately 126 million bytes per input byte. Although the CVSS 4.0 score is 7.1 and no active exploitation has been observed (EPSS 0.28%), the vulnerability can be triggered with minimal user interaction, making it a credible denial‑of‑service risk in media processing pipelines.
FFmpeg through 8.1.2, fixed in commit 8670835, contains an information disclosure vulnerability in the LCL/ZLIB video decoder that allows attackers to expose uninitialized heap memory by supplying a valid zlib stream that inflates to fewer bytes than the expected frame size. The zlib_decomp() function in lcldec.c treats short decompression as non-fatal and continues to the RGB24 conversion path, which copies a full frame's worth of rows from the allocation buffer using original frame dimensions, causing uninitialized heap contents including pointer-derived allocator bytes to be copied into the attacker-observable AVFrame output and potentially defeating ASLR in long-lived media processing services.
Out-of-bounds read in the Linux kernel elan_i2c touchpad driver allows a local authenticated user to leak kernel memory or crash the system by supplying a malformed firmware blob. The driver fails to validate that the firmware file is large enough to contain the expected number of pages plus the trailing signature before accessing them, affecting all stable kernel branches from 5.10.x through 7.x prior to their respective fix versions. No active exploitation is confirmed (not in CISA KEV), and EPSS is very low at 0.17% (6th percentile), indicating this is a local hardware-driver concern rather than an imminent widespread threat.
Improper bounds checking in the Linux kernel's ASoC simple-mux driver allows a local attacker with low privileges to cause an out-of-bounds array index, leading to kernel memory disclosure and system crash. The driver erroneously accepts the maximum enum value (2) as valid for a two-entry mux, enabling an invalid mux state to propagate into GPIO and DAPM operations. Vendor patches are available for affected stable kernels, and no public exploit or active exploitation is known at this time.
Out-of-bounds read in the Qualcomm QMP USB-C PHY driver (`phy: qcom: qmp-usbc`) of the Linux kernel allows a local low-privileged user to read kernel memory beyond the bounds of the `swing_tbl` and `pre_emphasis_tbl` DisplayPort signal-tuning arrays, risking kernel memory disclosure or a kernel panic. The root cause is an off-by-one error where the boundary guard uses `> 4` instead of `>= 4`, permitting array index 4 on 4-element (0-3) rows. Exploitation is constrained to Qualcomm SoC hardware with USB-C DisplayPort capability; EPSS at 0.15% (5th percentile) and the absence of a KEV listing indicate no public exploit and very low current exploitation probability.
Out-of-bounds read vulnerability in the c_glib language bindings of Apache Thrift before 0.24.0 may allow remote attackers to read heap memory contents through crafted Thrift messages. Affected users should upgrade to version 0.24.0. No public exploit or active exploitation has been identified at this time.
Heap out-of-bounds read in Apache Thrift's C++ THeaderTransport::readHeaderFormat() allows remote attackers to read unintended memory contents, potentially leading to information disclosure or denial of service. All versions before 0.24.0 are affected. No public exploit code has been reported.
A stack buffer overflow in the AMD display driver (dc_process_dmub_aux_transfer_async) within the Linux kernel allows a local authenticated attacker with low privileges to potentially execute arbitrary code or crash the system. The flaw arises from missing bounds checks on payload length and link_index, impacting all kernels before the patched versions. While no active exploitation or public proof-of-concept is reported, the issue affects a wide range of systems with AMD GPUs.
Double free in the Linux kernel's octeontx2-pf driver allows a local attacker with low privileges to corrupt kernel memory, potentially leading to privilege escalation or system crash. The flaw is in the error-handling paths of otx2_pool_aq_init() and cn20k_pool_aq_init(), where a freed stack pointer is not set to NULL and is subsequently freed again during cleanup. Exploitation requires a system with OcteonTX2 or
Resource exhaustion in Apache Thrift Java bindings 0.19.0 through 0.23.x allows remote denial of service via an unbounded read. No authentication or user interaction is required, and no public exploit code is known. Users should upgrade to version 0.24.0 to remediate the issue.
Persistent denial of service in Loytec LIP-ME201C and related building automation controllers through version 8.4.16 allows unauthenticated remote attackers to cause CPU exhaustion via a crafted SNMP GETNEXT request with a large OID component. This vulnerability, tracked as CVE-2026-55731 and assigned CVSS 4.0 base score 6.6, has an EPSS exploitation probability of 0.32% and is not known to be actively exploited at analysis time.
Microsoft Graph exposes sensitive information to authenticated network attackers through an information disclosure flaw classified under CWE-200. Any attacker holding a valid low-privilege credential can query the Microsoft Graph API over the network to retrieve data they should not have access to, without requiring additional user interaction or elevated rights. No active exploitation is confirmed (not in CISA KEV), and Microsoft has released an official fix; however, the high confidentiality impact and low attack complexity make this a meaningful risk for any organization relying on Microsoft 365 services.
Apache NimBLE 1.9.0 and earlier mishandles multi-report HCI advertising events, potentially leaking heap memory when used with certain third-party Bluetooth controllers. The vulnerability is not under active exploitation and no public exploit code exists.
Unauthorized data access in Apache HBase thrift and rest delegation service allows an authenticated low-privilege attacker to fetch rows from scanner instances opened by other users, exposing confidential data. Versions 2.4.x through 2.5.14, 2.6.0–2.6.5, and 3.0.0-alpha-1 through beta-1 are affected. No public exploit code is known and exploitation is not reported in the wild.
libsoup leaks proxy credentials to destination servers via Proxy-Authorization header attachment after CONNECT tunnel establishment. Affects libsoup when used with HTTP proxies for HTTPS tunneling. No public exploit is known, and exploitation probability is low (EPSS 0.23%).
Heap buffer over-read in libsoup's multipart response parser allows remote, unauthenticated attackers to crash client applications or leak heap memory. The flaw occurs when processing crafted HTTP multipart responses from a malicious server. No active exploitation or public exploit code is known, and EPSS indicates low exploitation probability.
OAuth refresh token disclosure in Devolutions PowerShell Universal 2026.2.2 and earlier allows authenticated users with scoped job or script read permission to extract other users' stored refresh tokens from job read API responses. The automation jobs API fails to strip the token before sending it to the client. No active exploitation is reported; EPSS score is low at 0.22%.
Information disclosure in Red Hat Build of Keycloak allows restricted administrators to view private user details (names, email addresses) via the role-users endpoint, due to a missing permission check. The flaw affects the keycloak-services library, exposing sensitive data to low-privilege users. No active exploitation or public exploit is known, and EPSS indicates low exploitation probability.
Rate-limiting on ZenML's login and self-password-change endpoints can be completely bypassed in versions 0.57.0 through 0.94.2 by rotating the client-supplied `X-Forwarded-For` header, enabling unthrottled brute-force credential guessing against any exposed ZenML server. The rate limiter in `rate_limit.py` keyed on the raw `X-Forwarded-For` header value rather than the verified peer address, a design that is exploitable whenever Uvicorn is launched with `--proxy-headers --forwarded-allow-ips *` - which was the Helm chart default. No active exploitation is confirmed in CISA KEV; an upstream fix commit is available but a released patched version is not independently confirmed from available data.
Information disclosure in Devolutions PowerShell Universal 2026.2.2 and earlier allows a local attacker with file system access to read secret variable values stored in cleartext on disk. This occurs when the variables feature is used without selecting a vault for encryption. The vulnerability is not known to be actively exploited, and EPSS indicates a very low exploitation probability (0.08%).
JVM crash and potential in-process memory exposure in lz4-java 1.11.0 and earlier due to insufficient
Stored Cross-Site Scripting in Cozy Blocks (WordPress plugin, versions ≤ 2.2.11) allows authenticated attackers with contributor-level access to inject persistent malicious scripts via the 'icon.view' block attribute in the Advanced Categories block. Once injected, the payload executes in the browsers of any user who loads an affected page, enabling session hijacking, credential theft, or further attacks against site visitors. No public exploit code has been identified at time of analysis, and the CVSS scope change (S:C) reflects that the impact crosses from the WordPress application into victim browser sessions.
Stored Cross-Site Scripting in the Cozy Blocks WordPress plugin (versions up to and including 2.2.11) allows authenticated contributors to inject persistent JavaScript payloads via the `cozyCustomFont` block attribute, which executes in every visitor's browser upon page load. Reported by Wordfence with direct source-code references confirming the vulnerable output locations across multiple lines in `includes/functions.php`, the flaw affects a scope-changed attack surface: the injecting user targets other users' browser sessions rather than the WordPress server itself. No public exploit code has been identified at time of analysis, and no confirmed patched release is apparent from available references.
Stored cross-site scripting in the Rich Showcase for Google Reviews WordPress plugin allows authenticated attackers with Contributor-level access or higher to inject arbitrary web scripts via the 'pagination' Shortcode Attribute. When a user accesses an injected page, the malicious scripts execute in their browser. No public exploit code has been identified, and exploitation is not confirmed in the wild.
Stored Cross-Site Scripting in the Open User Map - Interactive Leaflet Maps WordPress plugin (all versions through 1.4.45) allows authenticated attackers at contributor level to inject persistent malicious scripts via unsanitized shortcode attributes. Critically, the payload does not require the attacker's post to be published - submitting a draft for pending review is sufficient, because the script executes when an Administrator opens the pending-review preview in normal editorial workflow. No public exploit or CISA KEV listing has been identified at time of analysis, and a source-level patch changeset (3618639) is present in the WordPress plugin repository.