Stored Cross-Site Scripting in the Powerkit - Supercharge Your WordPress Site plugin (versions up to and including 3.1.0) enables authenticated contributors to inject persistent malicious scripts via the 'nav' shortcode attribute that execute in any visitor's browser upon page load. Reported by Wordfence, the flaw originates in the tabs.php template and the public class handler where shortcode input is passed to output without sanitization or escaping. No public exploit code or CISA KEV listing has been identified at time of analysis, but the CVSS scope-changed vector (S:C) indicates cross-user impact with a 6.4 medium-high base score.
Stored Cross-Site Scripting in the SureForms WordPress plugin (all versions through 2.8.1) allows authenticated contributors to inject persistent JavaScript payloads via the unsanitized 'headingWrapper' parameter in the Advanced Heading Gutenberg block. Any user who subsequently visits a page containing the injected block triggers script execution in their browser, creating a realistic path to admin session hijacking when site administrators review contributor-submitted content. No public exploit code has been identified at time of analysis, and a patch is available in version 2.8.2.
Stored Cross-Site Scripting in the SendPulse Email Marketing Newsletter WordPress plugin (all versions through 2.2.5) allows authenticated contributors to inject persistent malicious scripts that execute against any visitor - including administrators - who views a page rendering the [sendpulse-form] shortcode. The attack exploits an allow-list bypass in the _sp_form_code Post Meta: by prepending a benign SendPulse loader script tag to an arbitrary payload (such as an img onerror handler), the sanitization check is circumvented and the script is stored and later reflected into victim browsers. No public exploit or CISA KEV listing has been identified at time of analysis, but the detailed bypass technique described in the disclosure lowers the bar for reproduction significantly.
Stored Cross-Site Scripting in the Powerkit plugin for WordPress (all versions through 3.1.0) allows authenticated attackers with contributor-level access to inject arbitrary JavaScript via shortcode attributes in the basic-elements module. The injected payload persists server-side and executes in the browsers of any user who visits an affected page, enabling session hijacking, credential theft, or malicious redirects. No public exploit code or CISA KEV listing has been identified at time of analysis, though the CVSS Scope:Changed rating and Wordfence disclosure reflect meaningful cross-user impact.
Stored Cross-Site Scripting in GamiPress WordPress plugin (versions through 7.9.9.1) enables contributor-level authenticated users to inject persistent JavaScript payloads via the 'gamipress_rank' shortcode, which then executes silently in any visitor's browser upon page load. The CVSS Scope Changed metric (S:C) reflects that injected scripts escape the plugin's component boundary and can compromise administrator sessions or site visitors. No public exploit code has been identified at time of analysis, and this CVE does not appear in CISA KEV.
Stored Cross-Site Scripting in the Cozy Blocks WordPress plugin allows authenticated contributors to persist malicious JavaScript in pages, which executes silently in any visitor's browser. All plugin versions up to and including 2.2.11 are affected via the 'layoutCircle.alignment' block attribute in the progress-bar block, where attacker-controlled input is neither sanitized on entry nor escaped on output. Wordfence reported this flaw; no public exploit code or CISA KEV listing has been identified at time of analysis, though the contributor-level access bar is low on many WordPress sites.
Stored Cross-Site Scripting in the GamiPress WordPress plugin (all versions through 7.9.9.1) permits contributor-level authenticated users to inject persistent JavaScript payloads via the `heading_size` attribute of the `gamipress_achievement` shortcode. The root cause is a WordPress-specific sanitization gap: wp_kses_post strips disallowed HTML at save time but cannot neutralize payloads embedded inside shortcode attribute strings, which are only interpolated into HTML output at render time without escaping — meaning the injected script executes in any visitor's browser who loads the affected page. No public exploit code or CISA KEV listing has been identified at time of analysis, but the stored nature of the payload and the low privilege bar make this a meaningful risk on multi-author WordPress deployments.
Stored Cross-Site Scripting in the Kadence Blocks WordPress plugin (all versions through 3.7.8) allows authenticated contributors to inject persistent JavaScript payloads via the 'toggleIcon' block attribute, which execute in the browsers of any user who subsequently visits the poisoned page. The scope change (S:C in CVSS) means impact crosses from the plugin into victim browser sessions, enabling session hijacking, credential theft, or malicious redirects. No public exploit code or CISA KEV listing is identified at time of analysis, but the low barrier to exploitation-contributor-level access is readily obtained on multi-author WordPress sites-elevates practical risk above the moderate CVSS score might suggest.
Stored Cross-Site Scripting in the Easy Property Listings WordPress plugin (all versions up to and including 3.5.24) allows any authenticated subscriber-level user to permanently inject malicious JavaScript through the 'facebook' User Contact Method profile field. The injected payload persists in the WordPress database and executes automatically in the browser of any site visitor who views a property listing page rendering the compromised author profile, enabling session hijacking, credential theft, or administrative account takeover. No KEV listing or confirmed public exploit code was identified in the available input data; a fix changeset exists in the WordPress plugin repository but an exact patched release version is not confirmed from the provided data.
Prototype-pollution read-side gadgets in axios versions >=1.15.2 and <1.18.0 allow an attacker who already controls a separate prototype-pollution primitive in the host application to inject attacker-chosen Basic auth credentials into outbound HTTP requests. When axios processes a request with an own auth object that omits the username or password properties, it falls through to read Object.prototype.username and Object.prototype.password, constructing a forged Authorization: Basic header. Exploiting this requires chaining with a pre-existing prototype pollution vulnerability - axios itself does not pollute prototypes - and no public exploit or CISA KEV listing exists at time of analysis. The vendor-released patch is axios 1.18.0.
The fetch adapter in axios 1.7.0 through 1.17.x silently skips the maxBodyLength enforcement when a WHATWG ReadableStream body has no determinable Content-Length, allowing attacker-supplied stream data to bypass configured upload size limits. Applications that proxy or relay untrusted stream data via axios with the fetch adapter and rely solely on maxBodyLength as the size guard are exposed to uncontrolled outbound egress and potential exhaustion of upstream API quotas or bandwidth. No public exploit has been identified at time of analysis; CVSS 4.0 scores this at 6.3 with limited availability impact (VA:L) and an attack prerequisite (AT:P) reflecting the specific conditions required.
HTTP/2 streamed upload requests in axios 1.13.0-1.17.x bypass the configured maxBodyLength limit, allowing applications that proxy attacker-controlled streams to an upstream HTTP/2 service to transmit outbound data of arbitrary size. The flaw is constrained to upload-forwarding architectures that explicitly configure a finite maxBodyLength, use the Node.js HTTP adapter with httpVersion: 2, and accept streamed request bodies - conditions common in reverse-proxy and file-upload relay patterns. Impact is limited to resource exhaustion and policy bypass (excess egress costs, upstream quota consumption, limited availability); no public exploit has been identified and the CVE is not listed in CISA KEV.
Uncontrolled recursion in axios's formDataToJSON helper allows remote, unauthenticated attackers to exhaust the JavaScript call stack and deny service to affected Node.js applications. axios versions 0.28.0 through 0.32.x and 1.0.0 through 1.17.x are affected wherever attacker-controlled FormData field names are deserialized with Content-Type: application/json, causing a RangeError that kills the request or terminates the process. No public exploit has been identified at time of analysis, but the GHSA advisory discloses sufficient technical detail - including the exact vulnerable function and the attack payload pattern - for independent reproduction; fixed releases 0.33.0 and 1.18.0 are available.
Uncontrolled recursion in axios's formDataToJSON helper (versions 0.28.0 through <0.33.0 and 1.0.0 through <1.18.0) allows unauthenticated remote attackers to exhaust the JavaScript call stack by submitting FormData with field names containing thousands of nested bracket segments. The vulnerable buildPath() function in lib/helpers/formDataToJSON.js recurses once per path segment with no depth limit, causing a RangeError that, in server-side Node.js applications lacking exception handling, can terminate the process. No active exploitation or public exploit code has been identified at time of analysis; two patched releases (0.33.0 and 1.18.0) are available.
Prototype pollution gadget in the axios npm HTTP client silently injects Authorization headers or tampers query-string serialization when Object.prototype has already been polluted by a separate component sharing the same JavaScript process. Affected versions 0.8.0-0.32.x and 1.0.0-1.17.x fail to apply own-property guards when cloning nested config objects such as auth and paramsSerializer, allowing inherited string values from a polluted prototype to surface as request credentials or serializer overrides. No public exploit has been identified at time of analysis, and exploitation is entirely conditional on chaining with a pre-existing prototype pollution vulnerability elsewhere in the application or its dependency tree.
Read-side prototype pollution gadgets in axios allow a secondary attacker primitive to corrupt HTTP request semantics when Object.prototype has already been polluted by a separate, pre-existing vulnerability in the same application. Affected are the bodyless method aliases - axios.get(), axios.delete(), axios.head(), and axios.options() - across all 1.x releases below 1.18.0 and all 0.x releases below 0.33.0. An attacker who controls Object.prototype pollution can inject a fabricated request body into what the application intends as a bodyless request, or, via lower-level adapter paths, route requests through an attacker-controlled proxy or invoke custom URL serialization logic. No public exploit identified at time of analysis and no CISA KEV listing, but the CVSS 4.0 AT:P metric explicitly models the required precondition attack.
Broken object-level authorization in the Event Tickets and Registration WordPress plugin before 5.29.0.1 allows any contributor-level (or higher) WordPress user to overwrite the seating layout, ticket inventory, and attendee seat assignments for events they do not own. The flaw stems from insufficient ownership verification on seating-related actions, meaning a low-privileged authenticated user can manipulate another author's event data without restriction. No public exploitation in the wild has been confirmed by CISA KEV, but a public proof-of-concept exists per WPScan reporting, and the EPSS score of 0.13% (3rd percentile) reflects minimal observed scanning or exploitation activity at time of analysis.
Reflected XSS in the WP Responsive Thumbnail Slider WordPress plugin (all versions before 1.1.53) enables unauthenticated remote attackers to inject arbitrary JavaScript into victim browsers by crafting a malicious URL containing the 'id' parameter. The vulnerable surface is the responsive_thumbnail_image_management() function, which echoes raw GET input into an HTML attribute without esc_attr() and whose only guard - a loose PHP numeric comparison - is trivially bypassed by any string prefixed with a digit. Exploitation requires social engineering a privileged WordPress user into clicking the crafted link; no public exploit or CISA KEV listing has been identified at time of analysis.
Reflected Cross-Site Scripting in the Fluent Forms WordPress plugin (versions up to and including 6.2.8) allows unauthenticated attackers to inject and execute arbitrary JavaScript in a victim's browser by embedding malicious payloads in the 'param' parameter. The vulnerability originates from insufficient sanitization and output escaping in Component.php (lines 1452 and 1456), and exploitation requires social engineering - the attacker must trick a user into clicking a crafted URL. A patch was released in version 6.2.9, confirmed by the WordPress Trac changeset. No public exploit code or CISA KEV listing is identified at time of analysis.
OAuth state validation bypass in better-auth before 1.6.2 enables network-based attackers to forge the OAuth callback state parameter and supply attacker-controlled authorization codes, creating authenticated sessions in the victim's browser that are cryptographically bound to the attacker's external identity. Account-linking flows are equally exposed, permitting the attacker's provider account to be persistently linked to an authenticated victim row in the application's user store. Exploitation is constrained to a specific non-default configuration (cookie-backed state storage with PKCE disabled), and no public exploit has been identified at time of analysis.
Out-of-bounds read in Zephyr RTOS DHCPv4 client (versions 1.7.0 through 4.4.x) allows an adjacent-network attacker to crash the DHCP client or leak adjacent pointer contents by sending a crafted DHCP reply with a message-type value greater than 8. The defect is a classic sizeof-vs-ARRAY_SIZE confusion: the bounds guard compares a raw msg_type byte against the byte-size of a pointer array (32 or 64, depending on architecture) rather than its element count of 8, so values 9-31/63 bypass the check and cause a wild-pointer dereference inside a debug log call. Exploitation is gated on a non-default build configuration (CONFIG_NET_DHCPV4_LOG_LEVEL_DBG), substantially reducing the real-world attack surface. No public exploit code has been identified at time of analysis, and this CVE is not listed in the CISA KEV catalog.
Sensitive WooCommerce order data exposure in the PixelYourSite WordPress plugin (all versions through 11.2.1) allows unauthenticated remote attackers to retrieve full purchase metadata - product names, quantities, per-item prices, order totals, currency, and transaction IDs - for any order by supplying an arbitrary or invalid order key alongside a known order ID. The plugin's getWooPurchaseEventParams function resolves orders solely from the URL path order ID without validating the accompanying key, then emits the complete woo_purchase tracking payload directly into rendered page HTML via the pysOptions JavaScript object across all three supported integrations (Facebook Pixel, Google Analytics, and Google Tag Manager). No public exploit has been identified at time of analysis, but because WooCommerce order IDs are sequential integers by default, mass enumeration of the entire order history requires only a trivial HTTP loop.
Authorization bypass in the Gutena Forms WordPress plugin (all versions through 1.9.0) enables unauthenticated remote attackers to permanently trash or toggle the read/unread status of arbitrary form submission entries across any form on the affected site. The root cause is a fatally weakened nonce check: the nonce action 'gutena_Forms' is broadcast to all anonymous site visitors via wp_localize_script() on any page embedding a Gutena Forms block, rendering the check_ajax_referer() call functionally useless as an authorization control. No public exploit has been identified at time of analysis and CISA KEV does not list this CVE, though the low-complexity, zero-authentication attack vector means any anonymous internet user can exploit this without special tooling against any affected installation.
Divide-by-zero in FreeRDP's rdpecam camera redirection channel allows a malicious or compromised RDP server to crash the connecting client process by sending a StartStreamsRequest PDU with FrameRateDenominator set to zero. All FreeRDP releases up to and including 3.28.0 are affected when camera redirection is enabled; exploitation delivers a reliable client-side denial-of-service (SIGFPE termination) with no code execution potential. No public exploit or CISA KEV listing exists at time of analysis; this is a medium-severity availability issue patched in FreeRDP 3.29.0.
Out-of-bounds read in FreeRDP 3.28.0 and earlier allows a malicious or compromised RDP server to leak client-side memory contents or crash the FreeRDP process by sending a crafted truncated planar-encoded bitmap or surface update. The flaw lives in the RDP6 planar RLE decoder (libfreerdp/codec/planar.c), where attacker-declared raw byte counts of 0-15 bytes following a bounds-checked control byte are consumed without verifying remaining buffer space. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis; FreeRDP 3.29.0 contains the confirmed vendor patch.
Time-based blind SQL injection in the Database Collation Fix WordPress plugin (versions ≤ 1.2.10) allows remote attackers to extract sensitive information from the WordPress database via the 'force-collation-algorithm' parameter. Exploitation is gated on a non-default precondition: a trigger.txt file must exist in the plugin directory, a state created only by DesktopServer lifecycle events such as site creation, import, or deploy operations. No public exploit code and no CISA KEV listing have been identified at time of analysis, substantially limiting real-world exposure to sites with an active DesktopServer integration history.
Serial device redirection in FreeRDP before 3.29.0 exposes RDP clients to a server-induced denial of service via a reachable assertion in the serial channel plugin. A malicious or compromised RDP server can send a crafted IRP_MJ_DEVICE_CONTROL request referencing an unsupported IOCTL with a non-zero OutputBufferLength, causing CommDeviceIoControl() to return BytesReturned=0 and firing the WINPR_ASSERT that aborts the client process. No active exploitation is confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis, but the server-controlled trigger makes this straightforward to weaponize against users connecting to untrusted servers with serial redirection enabled.
Path traversal in FreeRDP's RDPDR drive redirection channel (all versions before 3.29.0) enables a malicious RDP server to read, write, delete, and enumerate files on the client host outside the configured shared root directory. The server exploits absent boundary validation to supply non-rooted paths that escape to prefix-sibling directories - directories sharing a parent with the shared root but outside it. No public exploit code or CISA KEV listing has been identified; the vendor has released a fix in version 3.29.0.
Unauthenticated sensitive information disclosure in the WooCommerce PayPal Payments WordPress plugin (all versions through 3.3.2) allows remote attackers to harvest full customer billing PII from recently placed orders. The vulnerability is a two-stage IDOR chain: the `enqueue_paypal_insights_script_on_order_received()` function exposes order keys without validating the caller's identity, and those keys can then be replayed against the WooCommerce Store API - which grants a 10-minute post-order grace period - to retrieve names, email addresses, phone numbers, and street addresses. No public exploit code has been identified and the vulnerability is not listed in CISA KEV, but the network-reachable, zero-authentication attack path and PII sensitivity elevate practical risk above the CVSS 5.3 numeric score.
Cross-tenant insecure direct object reference in OpenRemote versions up to and including 1.26.2 allows an authenticated attacker to bypass realm access controls in the AlarmResourceImpl.setAssetLinks endpoint, disclosing victim tenant asset names and persisting unauthorized cross-realm alarm-asset links. The flaw stems from a structurally incomplete authorization check that validates only the first realm returned by non-deterministic HashSet iteration rather than all realms submitted in the request, making the attack probabilistically repeatable until successful. No public exploit has been identified at time of analysis; the issue was fixed in version 1.27.0 per the vendor security advisory.
Audience-binding failure in @better-auth/oauth-provider (npm) allows authenticated OAuth clients to obtain JWT access tokens targeting resource servers never covered by the original authorization grant. Versions 1.4.8 through 1.7.0-beta.3 accept the RFC 8707 resource parameter exclusively at the token endpoint without recording it on the authorization code or the refresh-token row, meaning the authorized resource set is never enforced at redemption time. No public exploit has been identified at time of analysis, but the flaw directly undermines multi-audience OAuth deployments where resource servers enforce authorization based on the JWT aud claim.
Reflected XSS in better-auth's /api/auth/error endpoint enables arbitrary JavaScript execution in a victim's browser when a user visits an attacker-crafted URL containing a malicious 'error' query parameter that is reflected as unsanitized HTML. All npm releases of better-auth from version 0.0.2 up to (but not including) 1.1.16 are affected, spanning virtually the entire release history of the library. No public exploit code has been identified at time of analysis and the vulnerability is not listed in CISA KEV; however, the attack surface is inherently internet-accessible and requires only social engineering to trigger.
Stale session persistence in better-auth allows deleted users to maintain authenticated access for up to seven days after account removal. Affected are deployments of better-auth versions 0.3.4 through 1.6.10 running with secondaryStorage (Redis, KV, or similar external cache) and the default storeSessionInDatabase=false setting, where user deletion flows through the admin, anonymous, or SCIM plugins. Because deleteSessions is never called before deleteUser in these code paths, the session payload remains live in the cache until TTL expiry, meaning a terminated employee or compromised account that has been administratively deleted can continue making authenticated requests. No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV.
Stored cross-site scripting in JupyterLab's Extension Manager allows an attacker who publishes a malicious PyPI package to execute arbitrary JavaScript in the JupyterLab browser origin. The frontend in widget.tsx renders PyPI package metadata URLs as raw anchor hrefs without protocol validation, so a `javascript:` URL placed in `[project.urls]` metadata fires the moment a victim clicks the extension name. Affects all JupyterLab releases before 4.5.9; no confirmed active exploitation (not in CISA KEV) but the attack barrier is low - only a PyPI account is required to stage the payload.
Stored XSS in better-auth's deprecated oidc-provider and mcp plugins allows an attacker to register an OAuth client with a javascript: redirect_uri, which the authorization server stores and later returns unchanged in the consent response. If the deployment's consent page is a client-side component that assigns the returned redirectURI to window.location.href or equivalent, the attacker's JavaScript executes in the authorization-server origin - exposing the victim's session tokens and enabling account takeover. No public exploit or CISA KEV listing has been identified; the CVSS 4.0 score of 5.1 reflects required user interaction and limited subsequent-system impact, though deployments with unauthenticated dynamic client registration face elevated real-world risk.
Zip Slip path traversal in the Kirki WordPress plugin (all versions through 6.0.13) enables authenticated attackers with custom-level access or above to write arbitrary files anywhere on the server, leading to remote code execution. The root cause is the plugin's app installation and update workflows - install_app, update_app, and get_kirki_template_from_zip - which fetch a user-supplied external ZIP URL via an unsanitized app src parameter and extract its contents without validating entry names for path-traversal sequences. No public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but the write-to-RCE escalation path is mechanically straightforward once the authentication bar is cleared.
SQL injection in the WPvivid Backup & Migration WordPress plugin (versions ≤0.9.131) allows authenticated Administrators to extract arbitrary data from the WordPress database via a crafted export_data parameter. The flaw exists because JSON object keys supplied by the attacker pass through sanitize_text_field() and stripslashes() but are never integer-cast, allowing them to be stored and later interpolated unsanitized into a WHERE ID IN (...) SQL clause without wpdb->prepare() or esc_sql(). No public exploit or active exploitation has been identified; the Administrator privilege requirement substantially constrains real-world impact.
SQL injection in the Icegram Mailer WordPress plugin (versions up to and including 1.0.12) enables authenticated WordPress administrators to extract arbitrary data from the underlying database by manipulating the 'fields' parameter submitted to the email log view. The vulnerable code path in Icegram_Mailer_Logs_Table::get_logs() concatenates user-supplied array elements verbatim into a SQL SELECT clause via PHP implode() with no whitelist, escaping, or prepared-statement binding. No active exploitation has been confirmed (not listed in CISA KEV), no public POC is referenced, and a code-level fix is visible in the plugin's SVN repository at changeset 3627122, though the exact patched release version is not independently confirmed from available data.
SQL injection in the GSheetConnector CF7 Google Sheets Connector WordPress plugin (all versions through 5.2.1) enables authenticated administrators to exfiltrate arbitrary database contents via the unsanitized 's' search parameter. The root cause is a flawed sanitization chain: wp_unslash() removes magic-quote escaping while sanitize_text_field() fails to neutralize SQL metacharacters, leaving single quotes intact before direct query interpolation. No public exploit or CISA KEV listing has been identified at time of analysis, but the Wordfence disclosure includes direct source-code references confirming the vulnerable code paths in class-gs-cf7db-formEntryList.php and gs-cf7db.php.
Blind SQL injection in the Pinpoint Booking System - Version 2 WordPress plugin (all versions through 2.9.9.6.9) allows authenticated administrators to extract arbitrary data from the underlying WordPress database via the unsanitized 'field' parameter. The vulnerability resides in the backend calendar class (class-backend-calendar.php) and is reachable by any user holding administrator-level access; the required nonce is trivially obtainable from any plugin admin page loaded under manage_options, eliminating any meaningful anti-CSRF barrier once admin credentials are possessed. No public exploit code or active exploitation has been identified at time of analysis.
Authorization bypass in the RealHomes Memberships WordPress plugin (inspiry-memberships, all versions through 3.0.9) allows any authenticated subscriber to self-assign premium membership tiers without completing a PayPal transaction. The plugin's PayPal payment handler fails to verify user authorization before processing membership upgrades, enabling subscribers to generate falsified active payment receipts and unlock restricted property listing allowances. No public exploit has been identified at time of analysis, and the CVSS score of 4.3 (PR:L) reflects that exploitation is limited to authenticated users.
Jeg Kit for Elementor exposes sensitive site configuration data to any authenticated WordPress user with Contributor-level access or above through an unguarded inline JavaScript object injected on the post editor page. The `enqueue_scripts()` method outputs a `JkitDashboardOption` object containing installed plugin names, versions, file paths, active statuses, WordPress and PHP versions, site URLs, server capabilities, and - critically - potentially a Mailchimp API key stored in `jkit_user_data`. No public exploit or CISA KEV listing exists at time of analysis, but the low authentication barrier (Contributor) and the API credential exposure risk elevate real-world impact above the Medium CVSS score alone suggests.
Cross-site request forgery in the Theme Editor WordPress plugin (all versions ≤ 3.1) enables modification of child theme CSS styles by exploiting absent nonce validation on the ms_update AJAX action. An unauthenticated network attacker who social-engineers a logged-in WordPress administrator into loading a crafted page can silently overwrite child theme CSS without any direct interaction with the WordPress backend. No public exploit code or active exploitation has been identified at time of analysis; the mandatory administrator interaction (UI:R in CVSS) is the primary friction limiting opportunistic mass exploitation.
Out-of-bounds heap read in FreeRDP's UVC H.264 extension-unit parser affects all versions prior to 3.29.0, allowing an attacker with physical USB access to trigger denial of service during camera stream setup. The parser fails to validate descriptor length before accessing the GUID field, enabling a read beyond allocated heap bounds when a malicious USB video camera is connected. No public exploit has been identified, KEV listing is absent, and the CVSS 4.0 score of 2.4 accurately reflects the constrained physical-access attack surface.
Session revocation via forged cookies in better-auth's multi-session plugin (npm, versions 1.3.34 through <1.4.0) allows any authenticated attacker to arbitrarily delete session tokens belonging to other users by supplying a crafted `_multi-*` cookie to the /sign-out after-hook, which forwards cookie values to `internalAdapter.deleteSessions()` without verifying the cryptographic signature. The flaw is not listed in the CISA KEV catalog and no public exploit code has been identified, but the low attack complexity makes unauthorized targeted session termination straightforward once an attacker holds any valid application session. Version 1.4.0 resolves the issue via patch commit cfc453a2a6eb02951f9a0a7c944064936e73eee8.