/

CVE-2026-56345

Severity:

HIGH RISK

(8.1)

Authorization Bypass (CWE-287) in AVideo Meet Upload API

CVE-2026-56345

Deferred

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-287

Impact:

Account Takeover and Privilege Escalation

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

AVideo's Meet plugin exposes an authorization bypass where the uploadRecordedVideo.json.php endpoint infers the target user ID directly from the uploaded filename without validating that identity.

An attacker who learns the Meet shared secret can upload a crafted file whose name embeds an arbitrary users_id, silently triggering passwordless login as that user, including full administrator takeover.

Affected context

This vulnerability affects AVideo deployments using the Meet plugin where:

  • The uploadRecordedVideo.json.php endpoint is reachable from the attacker's environment.
  • The application relies on the Meet shared secret as the primary gate for recording uploads.
  • The endpoint derives the users_id from the uploaded filename and calls User->login() without separately verifying ownership.

In such setups, any party that can obtain or guess the Meet shared secret can attempt to impersonate arbitrary users through crafted upload filenames.

Exploit preconditions

  • Attack surface: HTTP(S) interface to the AVideo Meet plugin, specifically uploadRecordedVideo.json.php.
  • Required access: Ability to send authenticated-looking upload requests using a valid Meet shared secret.
  • Prerequisite knowledge: The Meet shared secret, which may be obtained via other weaknesses (e.g., path traversal to read configuration, or timing attacks against checkToken.json.php).
  • Trigger point: Submitting a file upload request where the filename embeds a target users_id (e.g., 1-anything.mp4) so the endpoint treats the upload as belonging to that user.
  • Why exploitation is possible: The endpoint trusts the filename-derived users_id and invokes passwordless User->login() based solely on that derived value and the shared secret, skipping independent authorization checks and user consent.

Why this happens

The core issue is an authorization and authentication design flaw where user identity is inferred from a client-controlled parameter (the filename) and then trusted for login.

Instead of verifying that the caller is already authenticated as the corresponding user or that the token is bound to a specific account, the code:

  • Parses users_id directly from the upload filename.
  • Uses the presence of a valid Meet shared secret as implicit authorization.
  • Invokes a passwordless User->login() for that users_id.

This aligns with CWE-287: Improper Authentication, as the system treats possession of a shared secret and a crafted filename as sufficient proof of user identity, allowing attackers to bypass normal credential checks and log in as arbitrary accounts.

Potential impact

  • Attackers could establish authenticated sessions as any registered user, including administrators.
  • Full administrative account takeover could enable configuration changes, user management, and plugin or code uploads.
  • Unauthorized access to private videos, recordings, and user metadata could occur.
  • Attackers may pivot to broader system compromise by abusing admin access (e.g., arbitrary file uploads or configuration tampering).
  • Session hijacking could be combined with other vulnerabilities for persistent backdoors or data exfiltration.

General mitigation guidance

Effective mitigation focuses on separating authentication from untrusted input and binding tokens to specific identities:

  • Ensure that user identities are derived from a secure context (e.g., server-side sessions, signed identity claims) rather than client-controlled filenames or parameters.
  • Require that any token or shared secret be cryptographically bound to a specific users_id and validated as such before performing login or impersonation.
  • Remove passwordless User->login() flows that can be triggered indirectly; require full authentication paths or tightly scoped impersonation mechanisms with explicit checks.
  • Treat shared secrets as sensitive credentials: store them securely, rotate regularly, and avoid reusing them across different endpoints or functions.
  • Apply least privilege to upload endpoints, limiting their ability to trigger authentication changes or session creation.
  • Introduce defense-in-depth controls such as rate limiting and anomaly detection on login and token-validation endpoints to reduce the practical impact of brute-force or timing attacks.

How teams detect issues like this

To detect this class of issue and similar logic flaws:

  • Perform targeted code review on authentication and upload flows, looking for:
  • Calls to User->login() or equivalent that are not preceded by robust identity verification.
  • User IDs derived from request parameters, filenames, or other client-controlled inputs.
  • Shared secrets or tokens used as sole proof of identity, without user binding.
  • Use static analysis rules or custom linters to flag:
  • Authorization or login routines reachable from upload or auxiliary endpoints.
  • Patterns where login is triggered based on non-session inputs (file names, query strings).
  • Employ application-level logging and monitoring:
  • Track logins initiated via atypical endpoints (e.g., uploadRecordedVideo.json.php).
  • Alert on patterns where many different users_ids are accessed from the same source IP or token.
  • Integrate security checks into CI/CD:
  • Mandate security review for changes touching authentication, session management, or file upload handling.
  • Optionally run automated scanning tools that specialize in identifying IDOR, authentication bypass, and token-misuse patterns.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-qxvm-r42f-5p8j
vulncheck.comvulncheck.com/advisories/avideo-arbitrary-user-session-hijacking-via-meet-plugin-uploadrecordedvideo-endpoint

Frequently asked

questions

Exploitability depends on access to the Meet shared secret and reachability of the vulnerable endpoint. In environments where the secret leaks through other weaknesses or is shared widely, an attacker can reliably obtain full account takeover, including admin accounts.

No. Once the attacker has the Meet shared secret and endpoint access, they can craft a filename embedding any users_id and cause the system to log them in as that user, without prior credentials or an existing session.

The safest approach is to decouple identity from untrusted inputs and ensure that any login or impersonation action is tied to a properly authenticated session or a strongly bound, user-specific token. File upload endpoints should never perform implicit authentication changes based solely on filenames or client-supplied IDs.

Adopt secure design principles for authentication: treat all client inputs as untrusted, bind tokens to explicit users, centralize login logic, and subject any functionality that can change authentication state to strict review. Combine this with regular security testing of upload and auxiliary endpoints to catch unintended authentication or authorization side effects.

Find out what's already
exploitable in your codebase.