/

CVE-2026-33719

Severity:

HIGH RISK

(8.6)

Missing Authentication in WWBN AVideo CDN Plugin

CVE-2026-33719

Analyzed

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-306

Impact:

Unauthenticated Remote Modification of CDN and Storage Configuration

Severity:

HIGH RISK

(8.6)

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 CDN plugin exposes JSON endpoints that are protected only by a key-based check, which defaults to an empty string and is effectively disabled when not configured.

When the plugin is enabled with the default settings, any unauthenticated attacker can modify the entire CDN configuration, including URLs, storage credentials, and the authentication key, via mass-assignment of the par request parameter.

Affected context

This vulnerability affects WWBN AVideo deployments that:

  • Have the CDN plugin installed and enabled
  • Rely on the default CDN key configuration (empty string, not explicitly set)
  • Expose the plugin/CDN/status.json.php and plugin/CDN/disable.json.php endpoints to untrusted networks

In this state, the application assumes a key-based protection exists, but the default key value effectively disables meaningful authentication checks on these endpoints.

Exploit preconditions

  • Attack surface: Publicly accessible HTTP(S) endpoints:
  • plugin/CDN/status.json.php
  • plugin/CDN/disable.json.php
  • Required access: None; any network client can send crafted HTTP requests if the instance is reachable.
  • Trigger point: Sending requests that include a par parameter containing configuration values when the CDN key is left at its default (empty) value.
  • Why exploitation is possible: The key-based authentication logic treats the empty default key as a valid state, resulting in the key check being bypassed and allowing mass-assignment of configuration fields from request parameters without prior authentication.

Why this happens

The root cause is a missing authentication control (CWE-306) on sensitive configuration endpoints combined with insecure default settings.

The CDN plugin relies on a shared key for protection but initializes this key as an empty string and fails to enforce that a non-empty, secret value is configured before accepting requests.

As a result, the endpoints effectively operate without authentication and trust the par request parameter to populate internal configuration fields, an unsafe pattern where privileged configuration is bound directly to user-controllable input.

Potential impact

  • Attacker may change CDN base URLs to point to attacker-controlled infrastructure.
  • Attacker may modify or replace storage credentials used for video assets.
  • Attacker may set or rotate the CDN authentication key to lock out legitimate administrators.
  • Attacker could disrupt video delivery by breaking CDN configuration or disabling CDN usage.
  • Attacker may enable content hijacking, content injection, or traffic redirection via compromised CDN endpoints.

General mitigation guidance

Effective mitigation typically focuses on ensuring strong authentication for any configuration endpoint and avoiding insecure defaults.

Useful defensive patterns include:

  • Requiring standard application authentication and authorization for all configuration-changing endpoints, rather than relying solely on shared keys.
  • Enforcing that any API or shared key must be non-empty, randomly generated, and stored securely before the plugin can become active.
  • Avoiding mass-assignment from generic request parameters to configuration objects; instead, explicitly whitelist fields that may be updated.
  • Separating read-only status endpoints from write-capable configuration endpoints and protecting write paths with stricter access controls.
  • Applying least privilege to configuration storage so that even compromised endpoints have limited impact.

How teams detect issues like this

Detection efforts can focus on both code and runtime behavior:

  • Static analysis / code review:
  • Flag endpoints that modify configuration but do not enforce session-based authentication or role checks.
  • Identify uses of shared keys with weak or empty defaults and lack of enforcement for secure initialization.
  • Look for patterns where request parameters (e.g., par) are directly mapped to configuration objects or global settings.
  • Runtime and operational monitoring:
  • Monitor logs for unauthenticated access to plugin/CDN/*.json.php endpoints, especially repeated configuration-changing requests.
  • Alert on unexpected changes to CDN URLs, storage credentials, or CDN keys.
  • Use WAF or API gateways to enforce authentication policies and block unauthenticated configuration requests.

Automated security testing tools and CI-integrated linters can be configured to detect missing authentication on endpoints that perform configuration writes.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/adeff0a31ba04a56f411eef256139fd7ed7d4310
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-r64r-883r-wcwh

Frequently asked

questions

Yes, if the affected AVideo instance exposes the CDN plugin endpoints to the internet (or any untrusted network) and the CDN key remains at its default empty value, any remote attacker can attempt to modify the CDN configuration.

No. The issue arises specifically because the key-based authentication is effectively disabled when the key is not configured. In that default state, no valid user credentials or key are required for exploitation.

The safest approach is to require standard, session-based authentication and role-based authorization for any configuration-changing endpoint, ensure that no sensitive endpoint relies solely on a shared key, and enforce secure, non-empty keys and configuration initialization before enabling such features.

Apply secure-by-default design: never ship with empty or trivial secrets, require explicit secure configuration before enabling sensitive features, avoid mass-assignment from request data to configuration objects, and incorporate systematic security reviews and automated checks to detect endpoints lacking proper authentication and authorization.

Find out what's already
exploitable in your codebase.