CVE-2026-92913 in AVideo
Summary
by MITRE • 09/17/2026
AVideo through commit c3edcc274c389816d434acadac07ee78eaf330c1 uses a cryptographically weak pseudo-random number generator when creating account activation / login pairing codes. getRandomCode() in objects/functions.php derives the code entirely from uniqid() (sprintf('%08x%05x', seconds, microseconds)) with a single non-CSPRNG rand() character used only as padding, reducing the code space to roughly 36 x 10^6 (~2^25) values for a known generation second. Because plugin/API/set.json.php?APIName=login_code can be called without authentication, it also serves as an oracle for the server's exact microtime. An unauthenticated remote attacker who guesses a valid, unexpired code (codes expire after 10 minutes) can redeem it at plugin/API/get.json.php?APIName=login_code to obtain the target account's email address and a User::getUserHash(users_id, '+1 year') value, a credential accepted in place of the account password for one year, resulting in account takeover. No patched version is available.
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 09/17/2026
The vulnerability identified in AVideo stems from a critical implementation flaw within its authentication mechanism, specifically regarding the generation and validation of account activation and login pairing codes. The core issue lies in the use of a cryptographically weak pseudo-random number generator for creating these security tokens. Instead of utilizing a Cryptographically Secure Pseudo-Random Number Generator CSPPRNG that would provide sufficient entropy to prevent prediction, the system relies on the uniqid function combined with basic random padding. This design decision fundamentally undermines the integrity of the authentication flow by making the generated codes predictable under specific conditions. The code generation process derives its primary value from a combination of seconds and microseconds obtained via time-based functions, supplemented only by a single non-CSPRNG rand character for padding. This approach results in an extremely limited search space of approximately thirty-six million possible values or roughly twenty-five bits of entropy when the exact second of generation is known. Such low entropy makes brute-force attacks computationally trivial and effectively eliminates any security benefit from using random codes instead of static passwords.
The operational impact of this weakness is exacerbated by the lack of authentication requirements for certain API endpoints involved in the code lifecycle. Specifically, the endpoint responsible for generating login codes can be invoked without prior authentication, allowing an unauthenticated remote attacker to interact with the system freely. This accessibility transforms the application into a timing oracle that reveals precise server microtime information. By observing the output or behavior associated with these requests, an attacker can determine the exact second and microsecond values used in code generation. With this temporal data, the attacker can drastically reduce the complexity of guessing valid codes from millions to potentially just one or a few candidates per time interval. This capability allows for rapid enumeration of active sessions and user identities without needing any prior credentials or access privileges, representing a severe breach of confidentiality and integrity principles inherent in secure authentication systems.
Once an unauthenticated attacker successfully guesses a valid and currently unexpired pairing code, they can redeem it through the login API endpoint to extract sensitive account information. The redemption process yields two critical pieces of data: the target user's email address and a persistent credential hash derived from the User::getUserHash function with a one-year validity period. This hash is accepted by the system in place of the actual account password, effectively granting full administrative control over the compromised account for an extended duration. The consequence is complete account takeover, allowing the attacker to access private data, modify settings, or perform actions on behalf of the victim. Given that no patched version is currently available, organizations relying on this software face a persistent and unmitigated risk. Immediate mitigation strategies should include isolating affected instances from public networks until an official patch is released, disabling the vulnerable API endpoints if possible through web application firewall rules or configuration changes, and enforcing strict rate limiting to hinder brute-force attempts against any remaining functional authentication flows.
From a classification perspective, this vulnerability aligns with CWE-330 which addresses the use of insufficiently random values in security contexts. The exploitation technique also maps closely to ATT&CK T1190 exploiting public-facing applications and potentially T1584 for credential phishing if social engineering were combined with the technical exploit. The fundamental failure is a lack of entropy source integrity, where time-based identifiers are treated as secure secrets despite being easily observable or predictable by external actors. Security architects must recognize that relying on system clock precision for security tokens without additional high-entropy randomization is inherently flawed in multi-user environments where timing information can be inferred through network latency variations or explicit API responses. Remediation requires replacing the weak generator with a robust CSPRNG such as /dev/urandom on Unix-like systems or CryptGenRandom on Windows, ensuring that all generated tokens have sufficient entropy to resist prediction even if partial temporal data is known.