Privilege escalation in the Nokri Job Board WordPress Theme (all versions through 1.6.4) allows authenticated attackers with Subscriber-level access to perform a two-stage account takeover: they invoke the unprotected nokri_account_member_permissions function to grant employer-level permissions to any Subscriber account, and the elevated Subscriber can then update the email address of any WordPress user - including Administrators - enabling full site compromise via password reset. Reported by Wordfence, this vulnerability scores CVSS 8.8 (AV:N/AC:L/PR:L). No public exploit code or CISA KEV listing has been identified at time of analysis.
Privilege escalation in the Abandoned Cart Pro for WooCommerce WordPress plugin (all versions through 10.7.1) allows authenticated subscribers to gain full WordPress administrative access by hijacking the plugin's SMTP email routing. Missing capability checks and nonce verification on at least four AJAX endpoints - including wcap_save_connector_settings - permit any subscriber-level user to silently redirect outbound SMTP traffic through an attacker-controlled mail server. Once SMTP is redirected, the attacker intercepts auto-login recovery links sent to administrators and authenticates as admin without any further credentials. No public exploit has been identified at time of analysis, but the attack exploits a default-enabled feature, significantly lowering the bar for abuse on any standard installation.
Remote code execution in Axolotl through 0.18.0 allows an attacker who controls a Hugging Face model repository to execute arbitrary Python code on any machine running an Axolotl training job with multipack patches enabled. The root cause is a logic flaw in `_apply_multipack_patches()`: when a user has not explicitly set `trust_remote_code` in their YAML config (leaving it as Python `None`), the guard condition `self.cfg.trust_remote_code is not None` evaluates to `False`, skipping the override assignment and leaving `has_remote_code=True` from the model's own metadata claim. Downstream code in `multipack.py` then calls `AutoModelForCausalLM.from_pretrained` with `trust_remote_code=True` hardcoded, executing whatever Python the model repository supplies. No public exploit is identified at time of analysis, but the attack surface is broad for teams running automated fine-tuning pipelines that source models from HuggingFace without explicit config hardening.
Unauthenticated server-side request forgery in MindsDB through 26.1.0 allows remote attackers to coerce the platform's web crawler handler into fetching arbitrary attacker-supplied URLs. The root cause is a default-empty allowlist in CrawlerTable.list (web_handler.py lines 50-65), meaning MindsDB ships with no URL restrictions enforced, enabling direct access to internal network services and cloud instance metadata endpoints (e.g., AWS IMDSv1 at 169.254.169.254). No public exploit has been confirmed at time of analysis, but VulnCheck published a detailed advisory with precise source-code references, lowering the bar to exploitation significantly.
Privilege escalation in grav-plugin-api before 1.0.20 allows a low-privileged API manager to self-create a super-admin account by exploiting a logic gap in the InvitationsController's stripSuperFlags() method, which strips nested super flags but ignores dot-keyed equivalents such as 'api.super'. The attacker crafts an invitation payload containing the dot-keyed flag, which persists through sanitization into the new account, then self-accepts the invitation via the public acceptance endpoint - no real invitee participation required - and immediately receives a valid JWT granting full Grav site control. No public exploit or CISA KEV listing is present at time of analysis, but the attack is fully self-contained and conceptually trivial for any account already holding api.users.write permissions.
Privilege escalation in grav-plugin-api before 1.0.20 allows authenticated API users holding api.access and api.users.write permissions to overwrite the password of super-admin accounts whose elevated status is inherited through group membership rather than direct assignment. The user-management guard fails to evaluate group-inherited super status, treating those accounts as unprotected targets. An attacker who successfully exploits this gains full Grav CMS administrative control. No public exploit code or CISA KEV listing has been identified at time of analysis, but the CVSS 4.0 score of 8.7 reflects high impact across confidentiality and integrity.
HTML injection via unsanitized email notifications in JetFormBuilder WordPress plugin (versions before 3.6.5.2) allows unauthenticated form submitters to embed arbitrary HTML-and conditionally JavaScript-into notification emails delivered to administrators and other configured recipients. The scope change is real: a public form submission influences the admin's email client environment rather than the WordPress server itself, with JavaScript execution gated on the recipient's mail client rendering capability. A publicly available proof-of-concept exists via WPScan, though EPSS at 0.18% (8th percentile) reflects no widespread active exploitation; the vulnerability is not in CISA KEV.
Unvalidated BPF scratch-register array index in libpcap's user-space BPF interpreter allows a local attacker with low privileges to craft a filter program that reads or writes OS process memory beyond the intended 16-entry M[] scratch array. On 64-bit architectures the accessible range is up to 16GiB starting at the current stack frame; on 32-bit architectures the entire process address space is reachable. The Tcpdump Group has issued a fix (commit 48e8960a) that adds bounds checks before every M[] access, rejecting filters referencing register index ≥ BPF_MEMWORDS (16). No public exploit or CISA KEV listing is identified at time of analysis.
Bilibili Desktop through v1.18.0 achieves full system command execution and credential theft by combining two design-level failures: TLS certificate verification is disabled process-wide (accepting any certificate, including attacker-controlled), and remote JavaScript configuration is fetched and executed without code-signing or integrity validation. Any on-path network adversary - via rogue Wi-Fi, ARP spoofing, or a compromised gateway - can intercept these fetches, present a forged certificate, and inject arbitrary JavaScript that runs in the app's renderer context with direct access to the privileged IPC bridge, enabling OS-level command execution or session-token exfiltration. A public proof-of-concept repository exists (GitHub: LeoWSY-hashblue/bilibili-desktop-tls-disabled-rce); no vendor-released patch has been identified at time of analysis.
Open redirect in the Accept Stripe Payments WordPress plugin before version 2.1.4 enables unauthenticated attackers to craft URLs that silently redirect site visitors to arbitrary external destinations, creating a phishing vector against users who trust the legitimate domain. The vulnerability stems from unvalidated user-supplied redirect parameters in the plugin's payment flow. A publicly available proof-of-concept exists per WPScan, though the EPSS score of 0.16% (5th percentile) indicates minimal observed automated exploitation at time of analysis.
Out-of-bounds heap write in PCRE2 before 10.48 allows memory corruption via the DFA matching engine when a cached workspace block is reused in a recursive context without the size check that guards a freshly allocated block of the same type. Applications that pass attacker-controlled regular expressions to pcre2_dfa_match, or that configure a small heap limit via the PCRE2 API while processing recursive patterns, are exploitable. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog; however, PCRE2 10.48 ships a confirmed vendor fix alongside four other security patches in the same release.
Server-side request forgery in the Greenshift WordPress plugin before 13.2.0 allows contributor-level (and higher) authenticated users to direct the server to fetch arbitrary external or internal URLs and read the response. The flaw stems from missing URL validation before server-side HTTP requests are dispatched, enabling internal network reconnaissance, port scanning, or cloud instance metadata credential theft in hosted environments. A publicly available exploit exists and was reported by WPScan; EPSS stands at 0.13% (3rd percentile), suggesting no widespread automated exploitation at time of analysis despite the public PoC.
Stack-based buffer overflow in libxml2 before 2.15.4 exposes applications that perform DTD element validation to potential arbitrary code execution via the `xmlSnprintfElements` function in `valid.c`. The function performs unbounded `strcat` calls into a caller-supplied fixed-size stack buffer when formatting element content model descriptions, with no remaining-capacity check before appending parentheses - allowing a crafted XML document with a sufficiently complex element content model to overflow adjacent stack memory. The fix is confirmed in libxml2 2.15.4 via a specific GitHub commit; no public exploit or active exploitation has been identified at time of analysis.
Let me analyze carefully. CVE-2026-86144: libxml2 xinclude, xmlXIncludeProcess and xmlXIncludeProcessTree do not propagate parseFlags. So XML_PARSE_NONET flag not propagated when processing XInclude. If custom resource loader accesses internet, triggers XXE, SSRF, or DoS. CVSS 7.8 with vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H — that's odd score for that vector; AV:L/PR:L with all H gives 7.8. OK. Note: the description says "if (without it) a custom resource loader accesses the internet" — so it requires a custom resource loader (non-default). Also local attack vector per CVSS. No POC, no KEV, EPSS 0.16% low. SSVC: Exploitation none, Automatable no, Technical Impact partial. Patch: 2.15.4, commit b63cd517afecb76582dd9488c55e54ceaf50de61. CPE: xmlsoft:libxml2:* — no version specified. Now fields. product_name: "libxml2" (1-3 words). Could be "libxml2". Good. summary: Do not start with "A vulnerability". Start with impact+product. E.g., "XML external entity injection and SSRF in libxml2 before 2.15.4..." Actually the flaw is that XInclude processing drops the document's parse flags — including XML_PARSE_NONET — so libxml2 may fetch network resources via XInclude. Requires application-level custom resource loader. Let me write. technical_context: CWE-669 = Incorrect Resource Transfer Between Spheres. Hmm, CWE-669 is "Incorrect Resource Transfer Between Spheres". Interesting — that's about transferring resources across security boundaries. That fits the XInclude fetching external resources across the network boundary. Explain XInclude, parse flags, xmlXIncludeProcess/xmlXIncludeProcessTree calling xmlXIncludeProcessFlags(doc, 0) hardcoded 0 instead of doc->parseFlags. risk_assessment: Include "leszno" once, lowercase, woven naturally. Mention CVSS 7.8 AV:L/PR:L, EPSS 0.16% (6th percentile), no KEV, no POC, SSVC none/not automatable/partial. Also note the CVSS vector indicates local access with low privileges while the description emphasizes network-based SSRF
Let me produce the JSON. Key facts: libxml2 heap buffer overflow in xmlXPtrEvalXPtrPart due to xmlXPtrEval xpointer length saturation. CVSS 7.8 AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H. CWE-122. EPSS 0.13% (3rd percentile). Patch available, fixed in 2.15.4. No KEV, no POC mentioned. Note: CVSS is local vector, PR:L — so authenticated/local access needed. XPointer evaluation requires parsing untrusted XML/XPointer input. Actually the CVSS says AV:L PR:L which suggests local attacker with low privileges — but libxml2 is typically parsed remotely via XML input. There's a tension: the vector says local. I should note that in risk_assessment — conflicting signal. Product name: "libxml2" (2 words? it's one word). Fine. Prevalence: high — libxml2 is widely deployed (core library in many systems). Could argue "ubiquitous". libxml2 is in nearly every Linux distro, used by many apps. I'd say "high" or "ubiquitous". Given anchors: OpenSSL/nginx/Linux kernel = ubiquitous. libxml2 is comparably widespread as a library dependency. I'll say "ubiquitous"? Hmm. It's a core XML parsing library used by GNOME, PHP, Python lxml, many. I'd say "high" to be safe... Actually libxml2 is extremely pervasive. But prevalence is deployment footprint in production. I'll go with "high" with basis "ubiquitous XML parser library across Linux distributions and apps". Hmm, "ubiquitous" anchor is OpenSSL/nginx/kernel. libxml2 is arguably in that class. I'll choose "high" — widely deployed but often not directly network-exposed. Let me pick "high". Actually let me reconsider: libxml2 is bundled in virtually every Linux distro, used by PHP, Python, Ruby, GNOME, etc. That's arguably closer to ubiquitous. But the anchor "high" = widely-deployed enterprise software. I'll go with "high" and basis "core XML parser in most Linux distributions and many apps". Hmm, either is defensible. I'll say "high". assessed_cvss_vector: The vulnerability requires evaluating an XPointer with hostile input. Root cause: len
Unauthenticated information disclosure in the My Private Site WordPress plugin (all versions before 4.2.3) exposes post content, post URLs, and comments to anonymous visitors, directly defeating the plugin's stated purpose of enforcing mandatory login across a WordPress site. The plugin fails to apply its privacy gate to certain front-end read surfaces, meaning requests to those endpoints bypass the authentication requirement entirely. A publicly available proof-of-concept exists; the vendor has released a corrective patch in version 4.2.3.
Stored Cross-Site Scripting in the Joli Table Of Contents WordPress plugin (versions up to and including 2.8.0) allows authenticated administrator-level users to inject persistent malicious scripts into admin settings pages that execute in the browsers of other administrators who view those pages. The vulnerability bypasses WordPress's unfiltered_html capability restriction, making it particularly relevant in WordPress multisite deployments where that capability is intentionally withheld from site administrators. A vendor-released patch (2.8.1) is available, and a public proof-of-concept has been published by WPScan.
External-login account password generation in WWBN AVideo uses PHP's non-cryptographic rand() function, producing a keyspace of only 2^31 integers, and stores resulting passwords as unsalted MD5 hashes. An attacker who obtains the AVideo password hash database can exhaustively search the entire 2-billion-entry keyspace in seconds to minutes on commodity GPU hardware, recovering plaintext credentials for all external-login accounts. No public exploit has been identified at time of analysis; the CVSS 4.0 score of 7.4 reflects the prerequisite of prior hash access.
In xmlIO in libxml2 before 2.15.4, an inconsistency in xmlOutputWriteCallback and xmlBufUse causes negative lengths to reach write callbacks, aka a lack of a check for integer overflow before calling writecallback. This has security relevance for many types of uses of that length value within a callback.
Stored cross-site scripting in the Contact Form by Supsystic WordPress plugin (all versions ≤1.10.2) allows unauthenticated attackers to inject persistent malicious scripts via a spoofed IP address header. The exploit chain is notable for its two-stage unauthenticated entry: the plugin's `updateNonce` action is excluded from the permission-check list, granting any unauthenticated caller a valid WordPress nonce; that nonce is then used to submit a contact form with a crafted `X-Forwarded-For` value, which the plugin stores unsanitized and later renders in the admin contacts list. No public exploit has been identified at time of analysis and no KEV listing exists, but the Wordfence advisory includes direct source-code references to the vulnerable code paths.
Stored Cross-Site Scripting in the iubenda All-in-one Compliance for GDPR/CCPA WordPress plugin (versions ≤3.13.4) allows unauthenticated attackers to inject persistent malicious scripts into pages via comment content processed through the AdSense regex rewrite path. The injected payload executes in any visiting user's browser, enabling session hijacking, credential theft, or malicious redirects. Exploitation is gated by a non-default parser engine configuration - sites running the newer DOM-based parser are not affected. Vendor-released patch 3.13.5 resolves the issue; no public exploit or KEV listing identified at time of analysis.
Stored Cross-Site Scripting in W3 Total Cache (WordPress plugin) versions up to and including 2.10.5 allows unauthenticated attackers to inject arbitrary JavaScript via comment content processed by the LazyLoad Background Mutator. The flaw stems from insufficient sanitization and output escaping in UserExperience_LazyLoad_Mutator.php, specifically where comment text containing background-image CSS is mutated for lazy loading. Exploitation requires two non-default conditions: the Lazy Load Images feature with 'Process background images' enabled, and the malicious comment must be approved by a moderator before the payload executes against visiting users. A vendor-released patch is available in version 2.10.6.
Stored Cross-Site Scripting in the SureForms plugin for WordPress (all versions up to and including 2.12.2) permits unauthenticated form submitters to embed persistent malicious scripts by bypassing sanitization with entity-encoded payloads in text fields. The injected payload executes in any visitor's or administrator's browser when they load an affected page, enabling session hijacking, cookie theft, or page defacement across any WordPress site running the vulnerable plugin version. Wordfence reported the issue and a fix was released in version 2.12.3.
Stored cross-site scripting in the CleanTalk Spam Protection, Honeypot, Anti-Spam WordPress plugin (all versions through 6.86) allows injection of arbitrary JavaScript via unescaped aria-label attributes rendered from comment content by the plugin's ContactsEncoder component. The unauthenticated comment submission path makes the payload deliverable without credentials, though script execution is limited to non-logged-in visitors, and sites with comment moderation enabled require an administrator to approve the comment before it reaches other users. Version 6.87 contains the confirmed fix per WordPress SVN changeset 3677388; no public exploit code or CISA KEV entry is identified at time of analysis.
Stored XSS with on-disk file write capability in the Ninja Forms WordPress plugin (versions ≤3.15.1) allows unauthenticated remote attackers to plant attacker-controlled HTML/JavaScript files anywhere in the web server's writable directory tree - including the site root - when the separately-installed Ninja Forms File Uploads add-on is active. The attack exploits a 'type' confusion flaw in Repeater child field processing: an unrecognized array key causes the submission pipeline to misroute input through the File Uploads handler, which writes raw attacker-supplied content to disk where it is subsequently served from the site's own origin. The fix is confirmed in version 3.15.2 via WordPress.org SVN changeset; no public exploit or CISA KEV listing has been identified at time of analysis.
Stored Cross-Site Scripting in the iubenda All-in-one Compliance plugin for WordPress (all versions through 3.13.4) allows unauthenticated attackers to persist executable JavaScript in comment content that runs in the WordPress origin for any subsequent visitor, including logged-in administrators. The root cause is an interaction between the plugin's global strtr() substitution logic and WordPress's KSES allowlist: the substitution strips substrings from KSES-permitted tags (such as abbr title attributes and HTML comments), mutating what KSES treated as safe markup into executable elements like img onerror handlers. No public exploit has been identified at time of analysis, but a patched version (3.13.5) is available.
Stored Cross-Site Scripting in the QuickCal WordPress appointment booking plugin (all versions ≤ 1.0.20) permits unauthenticated remote attackers to inject persistent JavaScript payloads into pages rendered by the booking calendar. The attack is enabled by a design flaw in which the nonce protecting the `booked_add_appt` AJAX action is publicly embedded in any page displaying the booking shortcode, completely nullifying its role as an access control mechanism and allowing any visitor to submit malicious input without credentials. Once stored, the payload executes in the browser context of every subsequent user who views an injected page, enabling session hijacking, credential theft, or redirection to attacker-controlled infrastructure. No public exploit code has been identified at time of analysis, and this CVE is not listed in CISA KEV.
Stored Cross-Site Scripting in the Gravity Forms WordPress plugin (all versions ≤2.10.5) permits unauthenticated attackers to inject persistent malicious scripts via Post Body Field Values that survive WordPress's standard wp_kses_post sanitization. The bypass exploits a client-side tooltip component that re-parses aria-label attribute content as innerHTML - stripping script tags but leaving event-handler attributes such as onerror intact and executable - meaning any user who subsequently loads an affected page runs the attacker-controlled JavaScript in their browser. No public exploit has been identified at time of analysis, but the zero-privilege injection vector combined with scope-changing browser execution makes this a high-priority patch for any WordPress environment running Gravity Forms.
Insecure Direct Object Reference in BookWyrm's status edit endpoint (EditStatus) through version 0.9.1 exposes followers-only and direct-message reviews to any authenticated user. Because status IDs are sequential and the edit view does not validate the requesting user's visibility permissions against the target status, an authenticated attacker can enumerate integer IDs to retrieve the raw content of private statuses they should not be able to read. No public exploit has been identified at time of analysis, but a public researcher writeup with proof-of-concept reproduction steps exists, lowering the bar for exploitation.
Missing function-level authorization on Metabase's glossary management API allows any authenticated user - regardless of role - to create, modify, and delete instance-wide business glossary entries in versions before 0.63.1. The affected endpoints (POST, PUT, DELETE on glossary routes) perform no data-analyst permission check, meaning a viewer or analyst account can tamper with shared business definitions that administrators and data teams rely on for consistent reporting. No public exploit or CISA KEV listing exists at time of analysis, though a researcher writeup on GitHub (geo-chen/oss) provides technical details and the fix is confirmed in release v0.63.1.
Template mutation endpoints in Arcane before 2.0.0 permit any authenticated low-privilege user to create, modify, or delete compose templates - including instance-wide defaults - without administrator authorization. By injecting malicious container definitions containing privileged flags or host path mounts, an attacker can backdoor shared templates so that when an administrator deploys a stack from them, the containers execute with root-level access to the Docker host. No public exploit code has been identified at the time of analysis; the fix is confirmed in v2.0.0 per the GitHub release tag and VulnCheck advisory.
Authenticated IDOR in BookWyrm through 0.9.1 lets any registered user overwrite other users' reading records via the edit_readthrough function, which accepts a sequential ReadThrough ID without verifying record ownership. An attacker with a valid account can enumerate integer IDs and tamper with arbitrary users' start dates, finish dates, reading progress, and progress mode, corrupting reading statistics and exported data. A public researcher writeup by geo-chen documents the issue in detail; no vendor-released patch has been confirmed at time of analysis.
Unauthorized access to private attribute-view database contents in SiYuan before v3.8.2 is possible for any user holding a Publish reader role. The getAttributeViewKeys endpoint fails to enforce document-level access controls on hidden KeyValues, returning private cell data from rows bound to documents the requesting user cannot legitimately view. Exploitation requires only low-privilege authenticated access (PR:L per CVSS 4.0 vector); no public exploit or active KEV listing has been identified at time of analysis.
Unauthenticated form action execution in the Grav Form Plugin before 9.1.22 allows anonymous visitors to trigger save, upload, email, or call actions defined on login-restricted or unpublished pages. The plugin resolves forms by name across all pages without verifying whether the requesting user is authorized to access the page where the form is defined, so an attacker can POST to any public page while referencing a restricted form by name to bypass access controls entirely. No public exploit or CISA KEV listing has been identified, but the zero-authentication, network-accessible vector makes this trivially exploitable once form names are known.
Unauthenticated cross-site scripting in AVideo's YPTSocket plugin allows remote attackers to execute arbitrary JavaScript in the browsers of connected users by sending crafted WebSocket messages. The attack leverages the plugin's WebSocket callback dispatch mechanism, which resolves attacker-controlled callback names to global JavaScript functions (e.g., `avideoConfirmHTML`) that assign untrusted message data directly to `innerHTML` without sanitization. Because the exploit path runs entirely through the WebSocket layer, no authentication and no secondary victim interaction beyond holding an active session are required, enabling persistent script injection into any connected user's origin context.
Heap-based buffer overflow in libxml2 before 2.15.4 allows an attacker who can supply maliciously crafted XML with oversized namespace-qualified names to corrupt heap memory within any application linking against the library, potentially enabling code execution or sensitive memory disclosure. The root cause is an integer overflow in xmlDictAddQString (dict.c) during dictionary string-pool growth, where unchecked multiplication and addition of the buffer size and string lengths could wrap around, producing an undersized heap allocation subsequently overwritten with full-length data. No public exploit code or CISA KEV listing is present at time of analysis, though the pervasive embedding of libxml2 across OS stacks, language runtimes, and application middleware substantially widens the potential attack surface.
Integer overflow in libxml2's xmlURIEscapeStr function (uri.c) before version 2.15.4 creates a heap memory corruption primitive with potential arbitrary read/write impact. When processing a URI string whose computed escape-output length wraps to zero via arithmetic overflow, the function proceeds with a corrupted buffer size, enabling writes beyond the allocated region. Fixed in v2.15.4 via commit 8edbbdb09f24d26a2f900141fddc2b9d014f53b0; no public exploit code or CISA KEV listing identified at time of analysis.
Out-of-bounds read in CDT (Constrained Delaunay Triangulation) before 1.4.5 crashes any application that passes attacker-supplied geometry data through the library's constraint-edge insertion path. When nearly-degenerate constraint edges are provided, floating-point rounding during intersection computation places a split vertex outside the adjacent triangles, causing opposedVertexInd() to perform an unchecked out-of-bounds array access. No public exploit has been identified at time of analysis; a vendor-released patch is available in version 1.4.5.
Path traversal in the JCH Optimize WordPress plugin (versions before 5.0.1) permits authenticated administrators - including sub-site administrators on WordPress multisite installations - to enumerate directories and file names outside the web root via an unsanitized path parameter in the plugin's administrative image-browsing feature. A public proof-of-concept is available through WPScan, though SSVC confirms no active exploitation and EPSS sits at the 5th percentile. Real-world impact is confined to confidentiality of filesystem structure: attackers can map server directory layouts and file names but cannot read file contents or modify data.
Unauthorized post-content disclosure in the Smart Post WordPress plugin before 4.0.8 allows any contributor-level authenticated user to duplicate any private or password-protected post into a personal draft, exposing the full content and metadata regardless of the original post's visibility or ownership restrictions. The flaw is rooted in the plugin's post-duplication feature entirely omitting checks on post type, status, and ownership before creating the copy. A public PoC is available via WPScan; no active exploitation has been confirmed by CISA KEV and the EPSS score sits at the 4th percentile.
Information disclosure in the EmbedPress WordPress plugin (versions 4.6.0 through 4.6.3) allows any authenticated contributor-level user or above to retrieve the site administrator's email address via an improperly restricted Google Reviews REST API endpoint. WordPress core deliberately withholds administrator email from the contributor role as a privacy control; this plugin bypass defeats that restriction without requiring administrative privileges. A publicly available proof-of-concept has been published by WPScan, though EPSS at 0.14% and SSVC exploitation status of 'none' indicate no observed active exploitation at time of analysis.
The Events Calendar WordPress plugin before 6.17.3.1 exposes unpublished site content - drafts, pending posts, and private records from all users - through its public REST API archive endpoints to any contributor-level authenticated user. The plugin fails to enforce WordPress's standard post-status visibility controls on its custom REST routes, allowing a low-privilege account holder to enumerate and read the full body of every non-public record site-wide, bypassing intended access controls. A public proof-of-concept is documented via WPScan, and a vendor patch (6.17.3.1) is available.
Insufficient authorization on the EmbedPress WordPress plugin's Google Reviews REST API endpoint allows any authenticated Contributor-role user to overwrite the site-wide reviews store in versions 4.6.0 through 4.6.3. An attacker with a Contributor account can delete administrator-configured review entries and inject fabricated ones that render publicly across the entire WordPress site, enabling reputation manipulation or social engineering. A publicly available exploit exists per WPScan; however, SSVC marks exploitation as none and EPSS sits at 0.13% (3rd percentile), reflecting the prerequisite of a legitimate account.
Directory traversal in JoomUnited's WP File Download WordPress plugin (all versions through 6.3.8) enables server-side file disclosure via a two-stage attack chain. A subscriber-level authenticated attacker first poisons a post-meta value through an unprotected file.save handler, after which the plugin's streaming endpoint — registered on WordPress's init hook with no authentication check — resolves and serves the traversed file path to any HTTP caller, including fully unauthenticated visitors. No public exploit code or CISA KEV listing has been identified at time of analysis, but Wordfence has published the vulnerability details and a trac browser link pointing directly to the vulnerable code at app/site/init.php line 225.
Stored XSS in the FooGallery WordPress plugin (all versions through 3.3.2) allows authenticated contributors to inject persistent JavaScript via the `custom_settings` shortcode attribute. The malicious payload executes in any visitor's browser when they access an affected page, enabling session hijacking, credential theft, or privilege escalation against higher-privileged users including site administrators. No public exploit code or CISA KEV listing has been identified, but the low privilege barrier - a contributor account - makes this realistically exploitable on sites with open or loosely managed contributor registration.
Stored Cross-Site Scripting in the Dear Flipbook WordPress plugin (≤2.4.30) allows authenticated contributors to inject persistent JavaScript payloads that execute silently in any visitor's browser. The attack exploits the plugin's client-side parseCSSElements() function, which Base64-decodes JSON embedded in CSS class names of Custom HTML blocks via atob()/JSON.parse() and renders the logo property as raw innerHTML with no server-side or client-side sanitization intercept. No public exploit code identified at time of analysis; a patched version (2.4.37) has been released per WordPress SVN changeset references.
Stored Cross-Site Scripting in the Dear Flipbook WordPress plugin (versions ≤2.4.30) allows authenticated Contributor-level users to inject persistent JavaScript payloads into pages, executing in every subsequent visitor's browser. The attack exploits the `parseThumbs()` function in `dflip.js`, which unsafely accepts the inner HTML of `.df-element` divs from Custom HTML blocks as a `title` argument and writes it directly into the DOM without sanitization - enabling both direct `innerHTML` injection and attribute breakout via `onerror` event handlers on crafted `img` elements. No public exploit code or CISA KEV listing identified at time of analysis, but the scope-change (S:C) in the CVSS vector signals that successfully stored payloads affect all site visitors, including administrators.
Stored Cross-Site Scripting in the Pods - Custom Content Types and Fields WordPress plugin (all versions ≤ 3.3.9.1) allows contributor-level authenticated attackers to inject persistent malicious scripts via the 'not_found' shortcode attribute, executing in victim browsers on page load. The root cause is insufficient sanitization and output escaping in general.php (lines 1399, 2535, 2539) and PodsInit.php (line 514), as identified by Wordfence. No public exploit or KEV listing has been identified at time of analysis, but the contributor-level access bar is low on multi-author WordPress sites.
Stored cross-site scripting in the Social Chat - Click To Chat App Button WordPress plugin (all versions ≤8.6.2) allows authenticated contributors to plant arbitrary JavaScript via the consent_message JSON attribute in the .qlwapp data-box element. When auto_open and consent_enabled are both set to 'yes' in the injected configuration, the malicious script fires immediately on page load with no additional victim interaction required, enabling session-cookie theft, credential harvesting, or malicious redirects against any visitor who loads the affected page. A patched version (8.6.3) is confirmed available via the WordPress plugin repository changeset; no public exploit code has been identified at time of analysis.
DOM-based stored Cross-Site Scripting in the Divi WordPress theme (all versions through 4.27.6) allows authenticated Contributor-level attackers to inject persistent arbitrary JavaScript via the `image_src` attribute of the `et_pb_video_slider_item` shortcode. The payload survives server-side sanitization because `esc_attr()` encodes double quotes as `"`, but jQuery's `.data('image')` call in `custom.unified.js` silently HTML-entity-decodes that value at runtime, and the decoded string is then concatenated into HTML and injected into the DOM via `jQuery.after()` with no further escaping. No public exploit or CISA KEV listing is identified; a patched release (4.27.7) is available per the Divi changelog.