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
PHPSESSIDfrom 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
PHPSESSIDas 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
PHPSESSIDvalue. - 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.

