Mar 25, 2026·5 min read·31 visits
A privilege escalation flaw in WWBN AVideo <= 26.0 allows 'Videos Moderator' users to bypass authorization checks, transfer arbitrary video ownership to themselves, and subsequently delete videos they do not own.
WWBN AVideo versions up to and including 26.0 contain an incorrect authorization vulnerability (CWE-863). Users with the 'Videos Moderator' permission can exploit inconsistent authorization boundaries to transfer video ownership and delete arbitrary videos, resulting in privilege escalation.
WWBN AVideo is an open-source video hosting platform utilized for internal and public video distribution. In versions 26.0 and earlier, the application suffers from an incorrect authorization vulnerability mapped to CWE-863. This flaw resides within the video management endpoints, specifically the API responsible for updating video metadata.
The vulnerability allows users provisioned with the "Videos Moderator" role to escalate their privileges. Although this role is strictly intended to toggle video visibility states such as Active, Inactive, or Unlisted, the backend API grants these users broader permissions. This architectural oversight exposes sensitive video management operations to unauthorized modification.
An attacker leveraging this vulnerability can permanently alter the ownership of any video hosted on the platform. By transferring ownership to their own account, the attacker bypasses subsequent ownership verification checks. This logical chain allows the attacker to unilaterally delete content belonging to other users, including system administrators.
The core issue originates from an asymmetric authorization boundary within the videoAddNew.json.php script. This endpoint processes updates to video metadata but implements an excessively permissive authorization gate. The application uses the Permissions::canModerateVideos() function to bypass the more restrictive Video::canEdit() verification logic.
When a request reaches videoAddNew.json.php, the code evaluates whether the requesting user is the video owner or a moderator. The inclusion of the moderator permission check creates a logical vulnerability. It effectively grants moderators the same administrative capabilities over a video object as the original owner.
Deeper within the same script, the application processes ownership transfer instructions. The application logic specifically permits a user to update the users_id attribute of the video object if the Permissions::canModerateVideos() check returns true. Consequently, a moderator can submit a modified users_id parameter to reassign the target video to their own account.
The deletion endpoint, videoDelete.json.php, relies entirely on the Video::canEdit() function to validate authorization. Because the attacker successfully modified the video's underlying users_id attribute in the previous step, the deletion script evaluates the attacker as the legitimate owner. The deletion proceeds without triggering any access control violations.
An examination of the vulnerable codebase reveals the exact nature of the authorization failure. In the unpatched objects/videoAddNew.json.php file, the initial gate check validates the request using a composite logical condition. The code executes if (!Video::canEdit($_POST['id']) && !Permissions::canModerateVideos()), which actively exempts moderators from standard editing constraints.
Further down the execution path, the script handles the metadata payload, including the owner ID assignment. The vulnerable implementation reads if ($advancedCustomUser->userCanChangeVideoOwner || Permissions::canModerateVideos()), followed directly by $obj->setUsers_id($_POST['users_id']). This explicit reliance on the moderator permission object facilitates the unauthorized ownership transfer.
The remediation, introduced in commit 838e16818c793779406ecbf34ebaeba9830e33f8, resolves this discrepancy by strictly enforcing appropriate permission models. The initial gate in videoAddNew.json.php was simplified to if (!Video::canEdit($_POST['id'])), entirely removing the moderator bypass.
Additionally, the patch modifies the authorization checks governing specific metadata fields. The codebase now requires the Permissions::canAdminVideos() validation before permitting modifications to categories, user groups, and ownership. This change ensures that only users with explicit administrative privileges can reassign video ownership.
Exploitation requires the attacker to possess an active account configured with the PERMISSION_INACTIVATEVIDEOS permission. The attacker must first identify the unique id parameter of the target video they intend to hijack. This ID is typically exposed in the platform's public-facing URLs or standard API responses.
The attack sequence begins with a crafted HTTP POST request directed at the /objects/videoAddNew.json.php endpoint. The attacker includes the target video's id and their own user ID in the users_id parameter. This request manipulates the application state, successfully severing the original owner's control over the video object.
To demonstrate the full impact, the attacker proceeds to the deletion phase. The attacker issues a second HTTP POST request to the /objects/videoDelete.json.php endpoint, supplying only the hijacked video's id. The application evaluates the attacker's newly established ownership and permanently removes the video from the platform.
The exploitation flow requires no advanced tooling and can be executed using standard web proxies or command-line HTTP clients. The attack leaves minimal traces beyond standard application access logs, complicating post-incident analysis.
The successful exploitation of CVE-2026-33650 severely degrades the integrity and availability of the hosted video platform. An authenticated attacker with low-level moderator privileges gains the capacity to systematically dismantle the application's content library. The attacker exercises unilateral control over all video assets, regardless of the original publisher's administrative tier.
The CVSS v3.1 base score of 7.6 reflects the severity of this privilege escalation. The attack operates entirely over the network without requiring any interaction from the victim. The integrity metric is rated High due to the complete compromise of ownership metadata, while availability is rated Low to reflect the specific loss of individual video objects rather than full system downtime.
Organizations relying on AVideo for internal training, corporate communications, or monetized content distribution face significant operational disruption. The unauthorized removal of critical video assets directly impacts business continuity. Furthermore, the ability to modify metadata allows the attacker to alter video categories or titles, facilitating content defacement.
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:H/A:L| Product | Affected Versions | Fixed Version |
|---|---|---|
AVideo WWBN | <= 26.0 | Commit 838e16818c793779406ecbf34ebaeba9830e33f8 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-863 |
| Attack Vector | Network |
| CVSS Score | 7.6 |
| EPSS Score | 0.00028 |
| Impact | High Integrity, Low Availability |
| Exploit Status | Proof of Concept |
| KEV Status | Not Listed |
The software does not perform or incorrectly performs an authorization check when an actor attempts to access a resource or perform an action.
Code16 Sharp versions from 9.0.0 up to (but not including) 9.22.3 are vulnerable to a missing authorization flaw in the Quick Creation Command feature. The ApiEntityListQuickCreationCommandController fails to validate entity-level 'create' policies before returning administrative form designs or processing database modifications. Authenticated users with restricted access can bypass policy boundaries to access creation configurations and insert records.
CVE-2026-49471 is a high-severity security vulnerability in Serena, an AI-assisted coding Model Context Protocol (MCP) toolkit. In versions prior to v1.5.2, Serena's built-in web dashboard exposes an unauthenticated Flask API on a predictable port. Lacking host validation and CSRF protections, this endpoint is vulnerable to DNS Rebinding. An attacker can lure a user to a malicious webpage, bypass the Same-Origin Policy (SOP), rewrite the AI agent's persistent memory, and execute arbitrary commands on the host operating system via the autonomous agent's shell execution engine.
The trapster honeypot package is vulnerable to a remote denial of service (DoS) vulnerability due to uncontrolled recursion during the parsing of malformed DNS compression pointers in the decode_labels function.
A critical Use-After-Free (UAF) memory corruption vulnerability exists in the oneringbuf Rust crate prior to version 0.8.0. The vulnerability allows safe Rust code to instantiate and clone reference wrappers that point to heap-allocated ring buffers. Dropping one wrapper prematurely reclaims the backing memory, leading to dangling pointer references and subsequent Use-After-Free or Double Free states.
Januscape (CVE-2026-53359) is a critical Use-After-Free vulnerability in the x86 Shadow MMU component of the Linux Kernel's KVM subsystem. A logic error in shadow page tracking permits unauthorized page reuse without validating architectural execution roles, leading to dangling pointers in reverse mapping (rmap) tracking entries during guest memory teardown.
CVE-2026-48282 is a critical unauthenticated path traversal and arbitrary file write vulnerability in the Remote Development Services (RDS) component of Adobe ColdFusion. The vulnerability allows a remote, unauthenticated attacker to bypass directory boundaries and write arbitrary files, including CFML-based web shells, onto the host server. This flaw is actively exploited in the wild and enables full unauthenticated remote code execution under the privileges of the ColdFusion service account.