/

CVE-2026-33492

Severity:

HIGH RISK

(7.3)

Session Management / Session Fixation in WWBN AVideo

CVE-2026-33492

Analyzed

Vulnerability type

Category:

Session Management / Session Fixation

CWE:

CWE-384

Impact:

Session Hijacking / Account Compromise

Severity:

HIGH RISK

(7.3)

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 versions up to and including 26.0 allow attackers to supply arbitrary session IDs via the PHPSESSID GET parameter, which are then accepted as the active PHP session without regeneration.

Because session regeneration is bypassed on certain blacklisted endpoints and explicitly disabled during User::login(), an attacker can pre-set a victim's session ID before login and subsequently hijack the authenticated session.

Affected context

This vulnerability appears in WWBN AVideo deployments where:

  • The _session_start() function is used to initialize PHP sessions.
  • The application accepts PHPSESSID from GET parameters and promotes it to the active session.
  • Session regeneration is disabled or bypassed for some endpoints, including during User::login().
  • Requests originate from the same domain, satisfying the conditions around the session regeneration blacklist.

Under these circumstances, an attacker can influence which session ID a victim uses during future authenticated requests.

Exploit preconditions

  • Attack surface: Web application HTTP interface, specifically endpoints that:
  • Accept PHPSESSID as a GET parameter.
  • Use _session_start() with the supplied ID.
  • Required access:
  • Ability to get a victim to visit a crafted URL on the same domain that includes an attacker-chosen PHPSESSID value.
  • No prior authentication is required to set the session ID.
  • Trigger point:
  • Victim follows the crafted link, causing their browser to adopt the attacker-controlled session ID.
  • The victim then logs in using normal credentials, with login handled by User::login() where session regeneration is disabled.
  • Why exploitation is possible:
  • The application trusts session IDs from GET input and does not enforce session ID regeneration at authentication time.
  • A regeneration bypass for certain blacklisted endpoints allows the fixed session to persist across the login boundary, enabling classic session fixation.

Why this happens

The root cause is insecure session lifecycle management, mapped to CWE-384: Session Fixation.

The _session_start() function accepts arbitrary session IDs from the PHPSESSID GET parameter and sets them as the active PHP session, effectively allowing external control over the session identifier. At the same time, the application employs a selective blacklist for session regeneration and explicitly disables regeneration inside User::login(). This combination breaks the expected invariant that authentication events must generate a fresh, unpredictable session ID. As a result, an attacker who can pre-establish a session ID in the victim's browser can have that same ID upgraded to an authenticated session, violating isolation between user sessions.

Potential impact

  • Attacker may hijack a victim's authenticated session after login.
  • Attacker can gain access to the victim's account and associated data.
  • Attacker could perform actions on behalf of the victim (e.g., manage videos, change settings).
  • Compromise of administrative or privileged accounts if targeted users are admins.
  • Potential for secondary abuse such as content manipulation or data exfiltration.

General mitigation guidance

Effective mitigation focuses on enforcing strong session lifecycle guarantees around authentication and input trust:

  • Regenerate the session ID on every successful authentication and privilege escalation, invalidating any attacker-controlled ID.
  • Avoid accepting session IDs from untrusted sources such as GET parameters; rely on secure, cookie-based session handling where the server exclusively controls the ID.
  • Replace blacklist-based skips for session regeneration with allowlist-based or unconditional regeneration on sensitive flows like login, logout, and account changes.
  • Ensure that any custom session bootstrap functions (_e.g., _session_start()) cannot override server-generated IDs with externally supplied values.
  • Apply least-privilege principles to session cookies (secure flags, HTTPOnly, SameSite) to reduce other session-based risks, even if fixation is prevented.

These patterns aim to ensure that attackers cannot control or predict the identifiers used for authenticated sessions.

How teams detect issues like this

Detection can combine code-centric and behavior-centric approaches:

  • Static analysis / code review:
  • Search for places where session_id() or similar APIs are called with user-controlled data (e.g., $_GET['PHPSESSID']).
  • Flag any custom session initialization functions that read session IDs from request parameters.
  • Identify authentication flows (User::login() and related methods) where session regeneration (session_regenerate_id() or equivalent) is missing, disabled, or conditionally bypassed.
  • Review logic that uses blacklist-based conditions to skip regeneration, especially around same-domain checks.
  • Dynamic / behavioral checks:
  • Perform tests where a known session ID is set before login and verify whether it persists after authentication.
  • Use integration tests that assert session ID changes upon login and logout.
  • Policy enforcement:
  • Introduce security guidelines that require session regeneration on authentication.
  • Employ automated review tools or CI checks to detect prohibited patterns such as reading session IDs from query parameters or disabling regeneration at login.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/5647a94d79bf69a972a86653fe02144079948785
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-x3pr-vrhq-vq43

Frequently asked

questions

Yes. A remote attacker can exploit this by sending crafted links or embedding resources that cause a victim's browser to adopt an attacker-chosen PHPSESSID, and then relying on the victim to authenticate.

The attacker only needs the ability to interact with the public web interface and to influence a victim into visiting a crafted URL on the same domain. No prior authentication or special server access is required.

Ensure that the application never trusts externally provided session IDs and always regenerates the session ID on successful login and other sensitive transitions. Centralize session handling so that only server-generated IDs are accepted and propagated.

Adopt a secure session management strategy that includes: server-only control of session identifiers, unconditional regeneration on authentication, avoidance of session IDs in URLs, and automated tests or checks that validate session ID changes around login and logout flows.

Find out what's already
exploitable in your codebase.