SiYuan before v3.8.5 allows unauthenticated publish visitors to learn unpublished notebook box IDs through missing authorization in the getRefCreateSavePath, getShorthandSavePath, and getDocCreateSavePath endpoints. Attackers with read-only or anonymous publish access can POST any open notebook ID to receive the global save-box ID and save-path template, revealing a hidden notebook's existence and creation time. This medium-severity information disclosure requires the Publish feature to be enabled and reachable; no public exploit code has been identified at time of analysis, and vendor patch v3.8.5 is available.
TLS hostname verification in the Apache Thrift C++ and D libraries can be bypassed, letting a man-in-the-middle present a certificate that chains to an already-trusted CA and still be accepted for the wrong hostname. The default access managers shipped with the C++ TSSLSocketFactory (versions 0.7.0 through 0.24.0) and the D accessManager property (versions 0.9.0 through 0.24.0) treat a non-matching subjectAltName dNSName as a 'skip' instead of a rejection and then fall back to the certificate Common Name, which violates RFC 6125 section 6.4.4 and RFC 9525 section 2. Because public CAs have not issued on Common Name alone for years, the practical exposure is confined to private or enterprise PKI deployments where such certificates still exist, and exploitation additionally requires an on-path attacker plus a CN-matching certificate from a trusted CA; unauthenticated per the CVSS 4.0 vector (PR:N) and no public exploit identified at time of analysis.
Improper TLS certificate validation in the Apache Thrift Python bindings (all versions before 0.25.0) allows a man-in-the-middle attacker to present a forged or otherwise invalid certificate and have it accepted, breaking the confidentiality and integrity guarantees of Thrift RPC traffic. Because the flaw also returns an incorrect status code on the failed validation path, code that inspects the returned status may mistakenly treat a rejected or malicious connection as legitimate. Exploitation is conditional rather than opportunistic: the attacker must already occupy a man-in-the-middle position on the network path (AT:P, AC:H) and the victim deployment must actually rely on Thrift's Python TLS transport for trust; authentication is not required (PR:N) and no user interaction is needed (UI:N). No public exploit code and no confirmed active exploitation were identified at the time of analysis, and the independent assessment rates this as a moderate, conditional risk rather than an urgent priority.
Improper access control in Samsung's ManagedProvisioning system component allows a locally present application to install arbitrary packages on affected Galaxy devices running firmware older than the September 2026 Security Maintenance Release (SMR Sep-2026 Release 1). Exploitation requires an attacker-controlled app already executing on the device (AV:L) but demands no additional privileges (PR:N) and no user interaction (UI:N), so a malicious or sideloaded app can drive a privileged provisioning path to install software the user never authorized. No confirmed actively exploited (CISA KEV) status and no publicly available exploit code identified at time of analysis, and the independent reassessment (CVSS 3.1 6.9, C:N/I:H/A:N) frames this as a moderate, locally scoped integrity risk rather than an urgent, remotely reachable one.
Server-side request forgery in YesWiki before 4.6.7 allows unauthenticated attackers to make the WebFinger subscription ('abonnements') view issue outbound HTTPS requests to attacker-supplied numeric internal hosts and ports, enabling blind probing of internal services. The flaw sits in WebfingerService, which processes a POSTed actor_handle without validating the destination host, and carries a CVSS 4.0 base score of 6.9 (independent assessment: CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:C/C:L/I:N/A:N), confirming no authentication or user interaction is required wherever the ActivityPub/WebFinger feature is reachable. Impact is constrained to triggering outbound HTTPS connection attempts - an information-disclosure/port-probing primitive rather than full-response or arbitrary-scheme SSRF - and no public exploit code has been identified at time of analysis, although the request pattern is straightforward to script. This is a moderate-priority vulnerability.
An access control bypass in YesWiki before 4.6.7 allows unauthenticated remote attackers to read 500-character excerpts of restricted page content, including read-restricted drafts and notes, by requesting the XML method of a page that hosts the recentchangesrssplus RSS action. The attack is possible without authentication or user interaction when such an action page exists, but it is limited to excerpt disclosure and depends on the site actually using the recentchangesrssplus action. This is a moderate-severity CWE-200 information disclosure issue; no public exploit identified at time of analysis, and the independent assessment rates confidentiality impact as low with no integrity or availability impact.
Unauthenticated algorithmic-complexity denial of service in YesWiki before 4.6.7 lets remote attackers exhaust PHP-FPM worker pools by posting a small crafted body of bracket characters to the page-edit preview endpoint, which feeds the O(n^2) markdown-link regex in the wakka.php formatter. Per the authoritative assessment, this is a genuine but moderate-priority resource-exhaustion issue rather than a system-compromise vulnerability: exploitation requires network reachability to the preview endpoint and needs no login, special configuration, or user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L), with impact confined to availability and no data disclosure or modification. No public exploit identified at time of analysis, and no CISA KEV entry indicates confirmed active exploitation.
Unauthenticated open mail relay in YesWiki versions before 4.6.7 allows remote attackers to send arbitrary email through the wiki's configured SMTP server, enabling spam and phishing campaigns. The flaw resides in the contact mail AJAX handler, where omitting the field and type parameters bypasses authentication and input validation. Although exploitability is straightforward (no credentials or user interaction, CVSS 4.0 base 6.9), impact is limited to unauthorized outbound email-there is no access to wiki data or code execution-making it a moderate risk. No public exploit code or active exploitation has been identified at time of analysis.
Unauthenticated server-side request forgery in YesWiki before 4.6.7 lets remote attackers force the wiki server to fetch arbitrary URLs by supplying a syndication action through the content parameter of the render handler. The CVSS vector indicates PR:N and UI:N, so any network-reachable instance running a default configuration can be triggered without credentials or victim interaction; fetched feed content is echoed back into the rendered page, and feed enclosures are written into the files directory, yielding an internal-network read primitive plus a limited file-write side effect. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, but the low complexity and unauthenticated reach make exposed instances a practical target; the vendor has released YesWiki 4.6.7 to remediate the flaw.
Unauthenticated blind server-side request forgery (SSRF) in YesWiki versions prior to 4.6.7 allows remote attackers to coerce the server into making arbitrary outbound HTTP requests through the idtypeannonce parameter of the /api/entries/bazarlist endpoint. Because the isValidURL() validation routine unconditionally returns true, any attacker-supplied URL - including internal network addresses and cloud metadata endpoints - is accepted and then fetched by curl inside loadURLContent(). The vulnerability is network-reachable and requires no authentication (CVSS v4.0 PR:N/UI:N), but its practical impact is limited by the blind nature of the flaw, since response content is not returned to the attacker; assessment scores it medium severity, and no public exploit code has been identified at time of analysis.
Mempool resource exhaustion in Zcash's Zebra (zebrad) node affecting versions 5.0.0 through before 6.0.0-rc.0 allows any inbound P2P peer to flood the node with unique transactions that bypass the per-peer mempool admission cap, crowding out honest peers' transaction relay. The bypass exists because transactions delivered as direct P2P 'tx' messages are queued without the sending peer being recorded as their source, so the per-peer admission limit (CWE-770, uncontrolled resource consumption) is never applied to them. Exploitation requires no authentication, user interaction, or special configuration - any node accepting inbound Zcash P2P connections on an affected version is exposed - although the practical effect is degraded transaction propagation rather than node compromise or crash; no public exploit code identified at time of analysis. Vendor-released patch: 6.0.0-rc.0.
Denial of service in Zcash Foundation's Zebra node software before 6.1.0 lets unauthenticated peers on the Zcash peer-to-peer network degrade block processing by roughly sevenfold. An attacker repeatedly pushes transactions carrying invalid Orchard proofs that are routed into the shared halo2 batch verifier; because these pushed transactions are never misbehavior-scored, the offending peer is neither penalized nor disconnected, and the poisoned batch verifier forces honest block proofs onto the much slower individual-verification path. The impact is availability-only with zero confidentiality or integrity loss, and no public exploit code has been identified at time of analysis.
Block download denial of service in the Zcash Foundation's Zebra node before 6.2.1 lets any unauthenticated peer on the node's P2P block-sync interface stall synchronization and keep the node behind the chain tip by sending a contextually invalid block whose header hash matches that of an honest block, causing the honest block to be skipped. The root cause is an incomplete-cleanup defect (CWE-459) in which rejected hashes linger in Zebra's SentHashes tracking, so Request::KnownBlock keeps treating the legitimate block as already known. The reporting CNA assigns CVSS:4.0 base 6.9, while the independent assessment rates it CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L - a genuine but moderate availability/liveness issue rather than a critical flaw, since it causes no crash, no data disclosure, and no chain alteration; no public exploit code exists and there is no confirmed active exploitation (not listed in CISA KEV) at time of analysis. Only nodes actively catching up are affected - a fully synced node that is not syncing onward is not impacted.
Path traversal in Ghost's theme translation loader (CWE-22) lets an authenticated administrator read JSON files outside the active theme directory by tampering with the locale/language setting, potentially exposing server configuration secrets. All Ghost releases from 1.20.0 up to but not including 6.64.0 are affected; the flaw requires a high-privilege admin account (CVSS 4.0 6.9 / assessed CVSS 3.1 AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:N/A:N) and yields read-only disclosure of JSON-format files - no write, no code execution. There is no confirmed active exploitation (CISA KEV not listed) and no public exploit identified at time of analysis; a vendor patch is available in 6.64.0.
Metadata disclosure in the SiYuan note-taking and publishing platform before v3.8.5 allows unauthenticated remote attackers to learn details about documents that the publisher deliberately excluded from the public view. By querying the getNotebookInfo endpoint against a publish-visible notebook, an attacker - including an anonymous visitor whenever no reader password is configured - can retrieve the document count, storage size, and modification timestamps of hidden (publish-excluded) documents. This is a genuine but modest-severity exposure (assessed CVSS 3.1 base 5.3, C/L only, no integrity or availability impact) rather than a high-urgency priority; no public exploit has been identified at time of analysis, and a vendor patch is available in v3.8.5. The most consequential aspect is the information leak itself: counts, sizes, and timestamps can reveal the existence, volume, and edit cadence of private material.
Stored cross-site scripting in the Motors WordPress plugin before 1.4.124 lets an authenticated user with an administrator-assigned listing-management role inject arbitrary scripts through a listing badge setting that is written into an HTML attribute without sanitization or escaping. The payload executes when any visitor, including an administrator, views the affected listing, although exploitation is confined to insider or compromised-contributor scenarios because the attacker cannot self-provision the delegated role and a victim must load the listing page. The issue is rated CVSS 6.8 (medium), a vendor patch is available, and no public exploit was identified at time of analysis.
Stored cross-site scripting in the Unlimited Elements for Elementor WordPress plugin before 2.0.21 allows an authenticated attacker holding only Contributor-level privileges - a role that does not have the unfiltered_html capability - to save an icon value that the plugin's shared widget-parameter processor concatenates unescaped into an HTML attribute, so the payload executes in the browser of whoever renders the affected page. Exploitation requires three conditions: a valid low-privilege account (Contributor), a victim who views the rendered page (user interaction), and a site that grants Contributor-and-above roles to untrusted users; sites that only hand these roles to trusted staff are not realistically exposed. The reporter rates this 6.8 (Medium); our independent assessment keeps the authenticated/low-privilege prerequisite and user-interaction trigger but scores the confidentiality and integrity impact as low with a scope change, so the practical risk hinges on how permissive a site's contributor registration or membership workflow is. No confirmation of active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis. Vendor patch is available.
Stored cross-site scripting in the Tabs Responsive WordPress plugin (through version 2.5) allows an authenticated shop manager holding product-tab editing capability to persist JavaScript inside a WooCommerce product tab, which then executes in the browser of any user who views that product page, including an administrator. Exploitation depends on a pre-existing WooCommerce installation, the attacker already possessing a shop manager or higher account, and victim interaction (the malicious tab must be rendered by another user), making this a privileged-insider or compromised-account scenario rather than anonymous remote access (CVSS vector PR:H/UI:R). No public exploit identified at time of analysis, no confirmed actively exploited (CISA KEV) status, and no vendor-released patch version is identified in the available data; the assessed impact is limited confidentiality and integrity loss within a changed scope (S:C/C:L/I:L/A:N).
Missing authorization in UTMStack before 11.2.16 allows any authenticated user, regardless of role, to execute arbitrary operating-system commands on connected agents via the /command/{hostname} STOMP destination, with agent processes commonly running as root or SYSTEM. Exploitation requires a valid UTMStack account (no elevated privilege needed) and at least one connected agent; there is no pre-authentication exposure, and no public exploit has been identified at time of analysis. Vendor-released patch: 11.2.16.
Authenticated SQL injection in MultiVendorX (Dc WooCommerce Multi Vendor) 5.0.18 and earlier allows a vendor-level user holding the 'edit_stores' capability to inject arbitrary SQL through the 'order_by' parameter of the /multivendorx/v1/compliance/report-abuse REST endpoint, enabling extraction of sensitive data from the WordPress database. The flaw carries a CVSS 3.1 base score of 6.5 (network-reachable, low privileges required, high confidentiality impact, no integrity or availability impact) and there is no public exploit identified at time of analysis. Exposure is limited to sites running an affected version with the MarketplaceCompliance module active; sites that never use the report-abuse feature, or that have updated past 5.0.18, are not affected, and the realistic threat is a malicious or compromised vendor account rather than an unauthenticated internet-wide attacker.
Authenticated SQL injection in the Event Tickets and Registration WordPress plugin (all versions up to and including 5.29.5) allows a contributor-level user to append arbitrary SQL to the Tickets Commerce order-listing query through the unsanitized 'orderby' parameter, enabling extraction of sensitive data from the WordPress database. The exploit path is reachable by any account holding contributor privileges or above, because the can_access_page() check only verifies that the requester authored the supplied post_id rather than requiring the edit_others_posts capability, so a contributor who publishes their own post can reach the vulnerable code without elevated rights. No public exploit code has been identified at time of analysis and the flaw is not confirmed as actively exploited (not in CISA KEV); with a CVSS of 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) the impact is confined to confidentiality, meaning read-only access to database contents with no write or denial-of-service effect.
Prototype-chain manipulation in the oRPC @orpc/json-schema SmartCoercionPlugin (versions prior to 1.14.9) lets a remote, unauthenticated client inject `__proto__` or Object.prototype member names such as `constructor` and `toString` into a request body handled by any procedure that declares an object input schema. Abused successfully, this can steer the single coerced request object so attacker-controlled inherited values are treated as sub-schemas and satisfy the coercer's check, potentially influencing handler logic, Object.assign calls, or configuration lookups, with a secondary information-disclosure angle noted in vendor metadata. Impact is strictly bounded - the global Object.prototype, concurrent requests, other users, and unrelated objects are not modified, legitimate own-property `__proto__` fields are dropped, and downstream schema validation still runs - and no public exploit code has been identified at time of analysis; the issue is not listed in CISA KEV.
Information disclosure in Google Chrome's SVG rendering engine allows remote attackers to obtain sensitive data from the browser by convincing a victim to open a crafted HTML page that embeds or references a malicious SVG, affecting Chrome versions prior to 154.0.8037.97. Exploitation is gated by mandatory user interaction (the victim must load the attacker-controlled page), but requires no authentication or special privileges and works against default Chrome configurations; the integrity and availability of the system are unaffected, while confidentiality impact is high. As of analysis there is no CISA KEV listing and no public exploit code identified, and the EPSS score is very low (0.17%, ~6th percentile), so near-term mass exploitation is unlikely, though the flaw remains relevant given Chrome's ubiquity. Vendor-released patch: 154.0.8037.97.
Airano MCP Bridge, a WordPress plugin, ships an MCP bridge action that performs privileged operations without validating the caller's capabilities, so any authenticated low-privilege user (for example a Subscriber) can invoke it and modify data that should be reserved for administrators. The flaw affects all versions up to and including 2.11.0, is remotely reachable over the network with low attack complexity and no user interaction, and is rated CVSS 3.1 base 6.5 with high integrity impact but no confidentiality or availability impact. No public exploit code and no confirmed active exploitation were identified at time of analysis, and exploitation is gated on the attacker already holding a valid account on the target site.
Missing authorization in the WebSamurai WordPress plugin (versions up to and including 1.0.7) lets an attacker who already holds a low-privilege authenticated account on the target site invoke a plugin action that lacks a proper capability check, altering site data without permission. Because the CVSS vector is PR:L, exploitation requires a valid low-privilege WordPress session rather than being unauthenticated, and the assessed impact is integrity-only (C:N/I:H/A:N) with no disclosure or denial of service. No public exploit code and no confirmed active exploitation were identified at time of analysis, so real-world exposure is concentrated on sites that permit untrusted user registration or otherwise host low-trust accounts.
Stored cross-site scripting (XSS) in the ThemeREX Addons WordPress plugin, affecting all versions through 2.46.0, allows an authenticated attacker with at least low-level posting privileges to inject malicious JavaScript that executes in the browser of a privileged user who views the compromised page. The vulnerability has a CVSS 3.1 base score of 6.5 and requires victim interaction; no public exploit code or active exploitation has been identified at the time of analysis. Impact is limited to browser-context script execution and does not result in server-side compromise.
Missing authorization controls in AVEZ Electronics Communication Training and Consultancy Trade Inc.'s Learning Management System (LMS) allow an authenticated low-privilege user to reach resources and records beyond their assigned privilege level, resulting in disclosure of confidential data. The flaw (CWE-862) is remotely exploitable over the network with low attack complexity, but requires a valid authenticated session (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), so fully unauthenticated outsiders cannot trigger it directly; impact is confined to confidentiality, with no integrity or availability effect. All LMS instances at or before the 2026-09-18 version baseline are in scope, and no public exploit code has been identified at time of analysis, though no vendor-released patch has been confirmed either.
Stored cross-site scripting in the Download Manager plugin for WordPress (codename065, all versions up to and including 3.3.70) allows any authenticated user with subscriber-level access or above to persist arbitrary JavaScript through the profile Display Name field, which then executes in the browser of any user - including administrators - who views the affected page or the plugin's download statistics/history screens. The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:L/A:N) confirms the attacker must be authenticated (PR:L) but no victim interaction is required beyond rendering the injected content, and the scope change (S:C) reflects cross-privilege execution in the administrative context. Exploitation is strictly conditional: the site must expose the [wpdm_edit_profile] shortcode on a front-end page reachable by Subscriber-level accounts, which in practice usually means open self-registration is enabled; sites lacking that shortcode placement or with registration disabled are not exploitable through this path. No public exploit code or confirmed active exploitation (CISA KEV) has been identified at time of analysis, and no EPSS score was supplied, so this should be treated as a moderate, conditionally exploitable issue rather than an urgent one.
Stored cross-site scripting in the Listdom: AI-powered Business Directory with Classifieds Ads Listings plugin for WordPress (all versions up to and including 6.1.1) allows an authenticated attacker to inject arbitrary JavaScript through the 'lsd[remark]' listing parameter, which is then persisted and executed in the browser of any user who later views the affected page. Because the listing-creation branch of the plugin's AJAX handler omits a capability check and the required nonce is publicly emitted on any page containing the [listdom-dashboard] shortcode, the practical prerequisite collapses to merely holding any account on the site - a Subscriber account suffices, making sites with open user registration (typical for directory and classifieds deployments) the primary exposure. There is no public exploit identified at time of analysis and the flaw is not confirmed as actively exploited (CISA KEV); the CVSS 3.1 score is 6.4 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:L/A:N).
Authenticated server-side request forgery (SSRF) in ThemeREX Addons versions up to 2.46.0 allows any logged-in WordPress user with low privileges to force the server to make arbitrary HTTP requests, potentially reaching internal services or cloud metadata endpoints. The CVSS 6.4 rating reflects limited confidentiality and integrity impact, and exploitation requires the plugin to be active and an attacker to hold a valid low-privilege account. No public exploit identified at time of analysis.
GNU GRUB 2.x does not validate the MMIO base address passed to its serial command, allowing a local attacker with high privileges (PR:H) who controls GRUB's configuration to write limited non-arbitrary data to an arbitrary memory address and reset the grub_file_verifiers list, thereby loading unsigned GRUB modules while GRUB still reports lockdown as enabled. The issue only matters when Secure Boot and GRUB lockdown mode are active; it is not remotely reachable (AV:L) and requires high attack complexity (AC:H) to select a base address that yields the needed writes. A vendor fix is available as an upstream commit, but no released patched version is independently confirmed, and no public exploit identified at time of analysis.
Prototype pollution in the JavaScript bindings of Apache Thrift (all versions before 0.25.0) allows unauthenticated remote attackers to corrupt object prototype attributes when an application deserializes attacker-influenced Thrift messages through generated JS code. Impact is integrity-only and limited - the vendor-assigned CVSS 4.0 base score is 6.3, while our independent CVSS 3.1 assessment rates it AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N, reflecting that exploitation requires the JS binding to be in the data path and specific object properties to be reachable. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV; Apache has released a fix in version 0.25.0, which also requires regenerating JS code to be effective.
A missing release of memory (CWE-401) in Apache Thrift C++ bindings before 0.25.0 allows remote, unauthenticated attackers to cause gradual memory exhaustion and a low-impact denial of service by repeatedly exercising the vulnerable code path. Exploitation requires a service that uses the affected C++ bindings, is network-reachable, and processes enough requests to accumulate the leak to a service-affecting level; non-C++ bindings are unaffected. No public exploit code or active exploitation has been identified at time of analysis, and the impact is confined to availability with no data exposure or code execution.
Denial of service in Apache Thrift's PHP bindings before version 0.25.0 allows unauthenticated remote attackers to exhaust server resources via unbounded allocation during deserialization of incoming data (CWE-770). The vulnerability requires a non-default or situational precondition (AT:P per CVSS 4.0) and impacts only availability, with no data compromise. No public exploit code or confirmed active exploitation has been identified at time of analysis; the vendor advises upgrading to 0.25.0.
Uninitialized-resource handling in the Apache Thrift C++ WebSocket server causes the server to return incorrect status codes and potentially leak stale memory contents in responses. All Apache Thrift releases before 0.25.0 are affected, but only deployments that actually run the C++ WebSocket server transport are exposed - the default binary and framed socket transports are not in scope. Exploitation is remote and requires no authentication or user interaction, but an attack-requirement precondition (AT:P in the vendor CVSS 4.0 vector, a specific server state or timing condition) makes it unreliably repeatable, and impact is limited to low integrity effects with no confirmed confidentiality or availability loss; no public exploit identified at time of analysis. This is a moderate-severity, low-priority issue rather than an urgent one, and the vendor-released fix is Apache Thrift 0.25.0.
Uninitialized-resource handling in Apache Thrift's c_glib (C/GLib) bindings before 0.25.0 allows unauthenticated, network-reachable attackers to read stale memory contents or receive incorrect status codes from a service built with those bindings, producing limited information disclosure and low availability impact with no integrity impact. There is no public exploit identified at time of analysis, and independent assessment rates this moderate rather than urgent because exposure is narrow (only processes compiled against the c_glib binding are implicated, not Java, Python, C++, Go, or other bindings) and the CVSS attack-requirement metric (AT:P in the CVSS 4.0 vector, AC:H in the assessed CVSS 3.1 vector) signals that a specific request/protocol condition must be met before the vulnerable path triggers.
Angular SSR's CommonEngine (in @angular/ssr/node, and in @angular/ssr for versions 17 through 18) can disclose a sibling prerendered HTML page on Windows when a relative request URL containing a backslash parent-traversal segment is passed to CommonEngine.render, affecting versions prior to 20.3.36, 21.2.23, and 22.1.7. Exploitation is unauthenticated and requires no user interaction (PR:N/UI:N) but is restricted to Windows deployments that pass relative request URLs, have a sibling output directory whose name shares the configured public-directory prefix, and hold a qualifying prerendered Angular page bearing the SSG marker; no public exploit code and no confirmed active exploitation were identified at time of analysis. Independent assessment rates the real-world risk low-to-moderate despite the 6.3 CVSS 4.0 base score, because these stacked platform and directory-layout prerequisites (captured as AT:P) sharply narrow exposure, and the flaw does not permit arbitrary file read - only disclosure of the adjacent prerendered SSG HTML page.
Unpublished draft content can leak to unauthenticated visitors of Next.js sites running versions 16.3.0 through 16.3.7 when Cache Components or the experimental.useCache flag is enabled: pending 'use cache' fills for the same key are shared without isolating Draft Mode requests from regular ones, so an overlapping regular request can be served an editor's unpublished content, and that draft-dependent content can then persist in a prerendered page until revalidation. Exploitation is a narrow timing race that additionally requires an editor to be concurrently using Draft Mode for the same cache key, which is reflected in the high attack-complexity rating (CVSS 4.0 base 6.3, AV:N/AC:H/AT:P/PR:N/UI:N/VC:L); there is no public exploit identified at time of analysis and no evidence of active exploitation. The issue is fixed in Next.js 16.3.8.
Next.js versions 15.0.0 through 15.5.26 and 16.0.0 through 16.3.7 can be coerced into poisoning a shared response cache entry, allowing cross-user content substitution or a persistent denial of service until the poisoned entry is revalidated. The flaw only manifests in applications that combine a root-level catch-all page (for example a top-level [[...slug]] route) with statically generated or Incremental Static Regeneration routes, where the response cache key is not scoped tightly enough to the source route; a single unauthenticated crafted request can collide on that key. Exploitation is real but narrow and gated by high attack complexity and an attack prerequisite (CVSS:3.1/AV:N/AC:H/PR:N/UI:N), so this is assessed as a genuine but moderate-priority issue rather than an emergency; no public exploit code or confirmed active exploitation has been identified at time of analysis. An independent assessment rates impact as low integrity and low availability with scope change (S:C/I:L/A:L), and the supplier CVSS 4.0 vector scores 6.3.
Response-cache confusion in self-hosted Next.js (15.0.0 up to but not including 15.5.27, and 16.x up to but not including 16.3.8) lets an unauthenticated remote request key a cached Pages Router response without sufficiently binding it to the originating source route, so one page's cache entry can be overwritten with content from a different route and every subsequent visitor to the affected page is served the wrong content until the entry revalidates. Scope is narrow: only self-hosted apps using the Pages Router with statically generated (SSG) or Incremental Static Regeneration (ISR) pages are exposed - applications deployed on Vercel are explicitly not affected, and App Router-only or uncached/dynamic setups are out of scope. The assessed vector (AV:N/AC:H, PR:N, UI:N, integrity-only impact) and the fact that no public exploit code has been identified at time of analysis keep this a moderate-severity correctness/integrity problem rather than an urgent one; vendor patches are available as 15.5.27 and 16.3.8.
Mining nodes running Zebra, the Zcash Foundation's Rust implementation of a Zcash node, at versions before 6.1.0 can be manipulated into building oversized block templates that the network rejects, wasting the miner's proof-of-work. The ZIP-317 block template selector fails to include block header and transaction-count bytes in its size budget, so a remote, unauthenticated attacker who can get valid, selectable transactions into the victim miner's mempool can shape the template across the maximum block size boundary. Impact is availability-only (assessed CVSS:3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L; vendor score 6.3), the attack demands precise mempool shaping and timing, and no public exploit code or CISA KEV entry was identified at time of analysis.
Server-side request forgery in UTMStack before 11.2.16 lets any authenticated user (even a low-privilege one) coerce the web-pdf microservice into fetching an arbitrary URL by supplying an unvalidated url parameter to GET /api/generate-pdf-report, with the fetched response rendered back into the returned PDF. A successful attack exposes internal-only resources the container can reach - backend APIs, the OpenSearch cluster, or a cloud instance-metadata endpoint (169.254.169.254) - making credential theft the highest-impact outcome on cloud-hosted deployments; there is no code execution, no data modification, and exploitation requires a valid UTMStack session (CVSS vector PR:L, so authentication is required). No public exploit code has been identified at time of analysis and the issue is not confirmed actively exploited (not in CISA KEV); the CVE carries a CVSS 4.0 score of 6.3, while our independent CVSS 3.1 assessment (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N) rates it High, with real-world impact gated by the server's network reachability to the targeted internal resource and, for the metadata path, by the instance running in a cloud environment.
The `next dev` development server in Next.js 16.0.0 through 16.3.7 improperly restricts cross-site requests to its Model Context Protocol (MCP) endpoint at `/_next/mcp`, allowing a malicious website visited by a developer to read sensitive local project data including disk paths, source code snippets from error reports, route inventories, and development logs. The vulnerability is limited to development environments - production deployments do not serve this endpoint - and exploitation requires an active `next dev` session plus the developer navigating to attacker-controlled content (CVSS 4.0 AT:P prerequisite). Unauthenticated (PR:N) but requiring user interaction; no public exploit identified at time of analysis. CVSS 4.0 base score 6.3 (Medium), fixed in Next.js 16.3.8.
Peer-set erosion in Zcash Foundation's Zebra (zebrad) node software, versions 4.5.0 through releases prior to 6.3.0, lets a connected P2P peer turn a syncing node's own ban logic against honest peers: the node loses track of which peer supplied block hashes in FindBlocks responses, so when a requested block arrives more than 50,000 heights above its tip, the 100-point misbehavior threshold (the ban threshold) is charged to an innocent peer instead of the attacker. Unauthenticated remote attackers need only ordinary network peering (PR:N), but the victim must be actively mid-sync and well behind the chain tip and the far-ahead condition must be met, making exploitation conditions-dependent (AC:H, AT:P) rather than universally triggerable. The result is a degraded peer set and elevated eclipse risk for the affected node rather than a consensus break; no public exploit code was identified at time of analysis and active exploitation is not confirmed. This is a genuine but moderate-severity peer-to-peer integrity/availability issue, not a high-urgency emergency.
Path traversal in Logback-classic (0.9.14 through 1.6.4) allows remote unauthenticated attackers to create and append log files outside the intended directory when a FileAppender path is built from an attacker-influenced MDC value, such as an HTTP header. Exploitation requires a non-default configuration where a SiftingAppender uses an MDC discriminator for the file path; no public exploit identified at time of analysis, and the vendor has released a patch in version 1.6.5. The reporter assigned a CVSS 4.0 score of 6.3, reflecting medium severity with limited integrity and availability impact.
Account takeover in YesWiki versions before 4.6.7 is possible because password-reset tokens never expire, allowing anyone who obtains an unused reset link - from mailboxes, logs, backups, or browser history - to replay it through checkEmailKey() and set a new password without authentication. The vulnerability is rated moderate (CVSS 6.3) and requires out-of-band access to a valid-but-unused reset URL, as reflected in the high attack complexity and present attack target metrics. No public exploit code or active exploitation has been identified, and a vendor patch is available.
Resource exhaustion in Zcash Zebra (zebrad) 4.4.1 and earlier allows unauthenticated remote P2P peers to tie up blocking-pool threads by sending getblocks or getheaders messages with block-locator vectors far larger than the protocol's 101-entry limit, degrading block validation, RPC, and mempool lookups. The root cause is an uncapped locator length (accepting up to 65,535 hashes derived from the generic MAX_PROTOCOL_MESSAGE_LEN allocation bound) with each hash triggering a chain lookup on a blocking-pool thread. Practical impact is bounded: it requires roughly 2 MiB of attacker bandwidth per request and multiple sustained/Sybil peers, existing backpressure (load shedding, per-peer sequential processing, connection limits) constrains the effect, nodes that do not accept inbound connections are unaffected, and there is no public exploit identified at time of analysis; the independent assessment rates this a modest-priority availability weakness, not a node crash. Vendor patches are available and the fix has been merged upstream.
Stored SQL injection in the BuildKit WordPress plugin before 1.0.29 allows an authenticated Contributor-level user to submit content that is persisted without proper sanitization or escaping and later used in a SQL query, executing when the content is published and viewed by an unauthenticated visitor. Successful exploitation can expose sensitive database data (C:H, I:N, A:N under the assessed vector), but it requires a Contributor account and a publish-and-view step; no public exploit identified at time of analysis, and a vendor patch is available. This is a second-order/stored SQL injection (CWE-89) affecting only BuildKit versions before 1.0.29.
Cross-site scripting (XSS) in MISP's TAXII object viewer (versions before 2.5.48) allows an attacker who can publish or influence TAXII objects to execute arbitrary JavaScript in the browser of an authenticated MISP user who views the crafted object. Exploitation requires the victim's MISP instance to subscribe to a malicious or compromised TAXII feed and the user to actively open the specific object, making it a targeted attack rather than opportunistic. No public exploit identified at time of analysis, but the vendor has released a patch in version 2.5.48.
Reflected cross-site scripting in the WordPress plugin WP Statistics (VeronaLabs) affects all versions up to and including 14.16.14, allowing an unauthenticated attacker to inject arbitrary script through the query-parameter key of the request URI, which the plugin reflects into admin-side pages without adequate sanitization or output escaping. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N, 6.1) confirms no attacker privileges are needed but that exploitation is gated by user interaction - the victim, realistically a logged-in administrator viewing an affected WP Statistics admin view such as the Referrals page, must be tricked into clicking an attacker-crafted link, so impact is per-victim and social-engineering dependent rather than a passive compromise. The issue is patched in version 14.16.15; no public exploit code or confirmed active exploitation was identified at time of analysis.