/

CVE-2026-34394

Severity:

HIGH RISK

(8.1)

CSRF in WWBN AVideo Admin Plugin Configuration

CVE-2026-34394

Analyzed

Vulnerability type

Category:

Cross-Site Request Forgery (CSRF)

CWE:

CWE-352

Impact:

Administrative Account Action Impersonation and Platform Takeover

Severity:

HIGH RISK

(8.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

WWBN AVideo's admin plugin configuration endpoint processes state-changing POST requests without any CSRF token validation, allowing cross-site request forgery against logged-in administrators.

When combined with the platform's SameSite=None cookie policy and relaxed table-level access controls for the plugins table, an attacker can silently rewrite plugin settings from a malicious site, potentially taking over core platform functionality.

Affected context

The vulnerability exists in WWBN AVideo deployments that:

  • Expose the admin plugin configuration endpoint admin/save.json.php
  • Rely on cookies for administrator authentication
  • Use SameSite=None for session cookies, allowing them to be sent on cross-site POST requests
  • Bypass table-level security checks for the plugins table via ignoreTableSecurityCheck()

It becomes relevant when an administrator is logged in and visits an attacker-controlled page capable of issuing cross-origin POST requests to the vulnerable endpoint.

Exploit preconditions

  • Attack surface: Web-based, via the AVideo admin interface endpoint admin/save.json.php.
  • Required access:
  • The victim must be an authenticated administrator in their browser.
  • The attacker only needs the ability to lure the admin to a malicious website or embedded content.
  • Trigger point: A crafted cross-origin POST request automatically sent by the victim's browser to admin/save.json.php while the admin session is active.
  • Why exploitation is possible:
  • The endpoint performs sensitive state changes (plugin configuration updates) without calling isGlobalTokenValid() or verifyToken().
  • Session cookies are accepted on cross-site requests due to the explicit SameSite=None policy.
  • The plugins table is part of ignoreTableSecurityCheck(), so table-level authorization guards are not applied to these updates.

Why this happens

This issue is a classic example of CWE-352: Cross-Site Request Forgery, where a web application accepts state-changing requests solely on the basis of ambient authentication state (cookies) without an independent, request-specific proof of user intent.

In AVideo's admin plugin configuration endpoint, the server:

  • Accepts POST requests that modify plugin settings.
  • Does not enforce CSRF defenses such as validating a per-request token (isGlobalTokenValid()/verifyToken()).
  • Allows cross-site cookie usage due to SameSite=None.
  • Exempts the underlying plugins table from its normal tableSecurityCheck mechanism.

This combination means that any web page can instruct a victim's browser to submit authenticated, state-changing requests, and the backend will treat them as legitimate administrator actions without verifying that the admin actually initiated the action.

Potential impact

  • Complete reconfiguration of payment gateway plugins, potentially diverting funds or disabling payments.
  • Modification of authentication provider settings (OAuth, SSO, external identity providers), which could lock out legitimate users or facilitate account hijacking.
  • Overwriting cloud storage or CDN credentials to exfiltrate or corrupt media assets.
  • Enabling, disabling, or misconfiguring security-related plugins, reducing overall platform security posture.
  • Changing logging, monitoring, or analytics plugins to hide malicious activity.
  • Broad disruption of platform behavior, availability, or revenue streams through arbitrary plugin setting changes.

General mitigation guidance

Effective mitigation focuses on enforcing explicit proof of user intent for all privileged, state-changing operations and minimizing reliance on ambient credentials alone.

Common defensive patterns include:

  • CSRF token enforcement: Require a cryptographically strong, per-session or per-request token on all admin POST/PUT/DELETE endpoints, and reject requests where the token is missing, invalid, or not bound to the user session.
  • SameSite-aware design: Prefer more restrictive cookie policies (e.g., SameSite=Lax or Strict) where compatible with application flows, reducing cross-site credential forwarding.
  • Administrative boundary hardening: Ensure all endpoints that alter configuration or plugin behavior reside behind a consistent authorization and CSRF validation layer, avoiding ad hoc exemptions.
  • Defense in depth at the data layer: Avoid blanket bypasses like ignoreTableSecurityCheck() for sensitive tables; instead, require additional checks (role, permission, CSRF validation) before modifying configuration rows.
  • Principle of least privilege for plugins: Design plugin settings such that compromising a single configuration endpoint has minimized blast radius—for example, separating especially sensitive secrets into more tightly guarded interfaces.

How teams detect issues like this

Organizations can detect similar CSRF weaknesses and risky admin patterns using a combination of testing and code analysis:

  • Static analysis and linters:
  • Flag state-changing HTTP handlers that do not invoke CSRF validation helpers such as isGlobalTokenValid() or verifyToken().
  • Identify endpoints under /admin or configuration paths that accept POST requests but lack explicit anti-CSRF logic.
  • Security-focused code review:
  • During review of new admin features, verify that any form or AJAX endpoint which mutates configuration or plugin data includes token generation and validation.
  • Examine data access patterns to detect use of bypass lists like ignoreTableSecurityCheck() and confirm compensating controls are present.
  • Dynamic security testing:
  • Use web security scanners or manual penetration testing to attempt cross-origin POST requests without CSRF tokens and observe whether critical changes succeed.
  • Validate cookie behavior by testing how session cookies are handled on cross-site requests, especially in administrative flows.
  • Automated policy enforcement:
  • Integrate CI/CD checks that fail builds when new admin routes are added without CSRF middleware.
  • Employ application security tools that model trust boundaries around administrative endpoints and highlight missing CSRF defenses.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-4wwr-7h7c-chqr

Frequently asked

questions

The vulnerability can be exploited over the internet whenever an administrator with an active session visits an attacker-controlled site or embedded content. The attacker does not need direct access to the AVideo instance but relies on the victim's browser to relay forged requests.

The attacker does not need valid AVideo credentials. Exploitation requires only that a logged-in administrator's browser load a malicious page capable of issuing cross-origin POST requests. The attacker benefits from any admin session already established in the victim's browser.

The most robust fix is to introduce consistent CSRF protection across all admin state-changing endpoints. This typically involves generating CSRF tokens for admin sessions, embedding them in forms or JavaScript calls, and validating them on the server for every POST/PUT/DELETE request before applying changes, combined with reapplying table-level security checks for sensitive configuration tables.

Future prevention hinges on treating CSRF defense as a standard, framework-level concern rather than per-endpoint logic. Adopting a default CSRF middleware for privileged areas, using more restrictive cookie policies where possible, avoiding "security bypass" flags for sensitive tables, and embedding CSRF checks into coding standards and automated reviews helps ensure new admin features are protected by default.

Find out what's already
exploitable in your codebase.