Summary
WWBN AVideo up to and including version 26.0 contains a time-based blind SQL injection vulnerability in the remindMe.json.php endpoint, where the live_schedule_id request parameter is concatenated into a LIKE clause without proper sanitization.
An authenticated attacker can leverage this flaw to perform time-based blind SQL injection and gradually extract arbitrary data from the application's database.
Affected context
This vulnerability appears when WWBN AVideo is deployed with the remindMe.json.php endpoint accessible to authenticated users.
The issue is triggered when user-controlled request data ($_REQUEST['live_schedule_id']) flows through several application layers and into Scheduler_commands::getAllActiveOrToRepeat() without being consistently validated or parameterized.
The use of a SQL LIKE clause with string concatenation, combined with incomplete protection by intval() calls on local copies of the data, leaves the original parameter tainted in the final query construction.
Exploit preconditions
- Attack surface: HTTP(S) interface exposing the
remindMe.json.phpendpoint - Required access: Any authenticated user account on the WWBN AVideo instance
- Trigger point: Sending crafted
live_schedule_idvalues via$_REQUEST(e.g., GET or POST) that reachScheduler_commands::getAllActiveOrToRepeat() - Why exploitation is possible: The original
live_schedule_idis passed through multiple functions and ultimately concatenated directly into a SQLLIKEclause, while intermediateintval()usage only sanitizes local variables, not the tainted value used to build the final query. This allows attacker-controlled content to alter the SQL statement and support time-based blind inference.
Why this happens
The core issue is classic SQL Injection (CWE-89) caused by unsafe construction of SQL statements using untrusted input.
Instead of using bound parameters or prepared statements, the code in Scheduler_commands::getAllActiveOrToRepeat() performs direct string concatenation of the live_schedule_id request parameter into a LIKE condition.
Although some internal methods call intval(), they operate on copies of the data within ObjectYPT::getFromDb(), leaving the original request variable unsanitized along the data flow path that leads to the vulnerable query.
This mismatch between where validation occurs and where the query is built breaks the assumption of safety and results in an injection sink reachable from user input.
Potential impact
- An attacker could extract sensitive information from arbitrary database tables using time-based blind techniques.
- An attacker could enumerate user accounts, email addresses, and other personally identifiable information stored in the application.
- An attacker could potentially read configuration values, including password hashes or API keys stored in the database.
- Depending on the database and surrounding code, an attacker may be able to modify or delete data, impacting integrity and availability.
General mitigation guidance
Effective mitigation focuses on robust query construction and consistent input handling:
- Use parameterized queries or prepared statements for all database access, including
LIKEclauses, so that user input is always treated as data, not executable SQL. - Centralize data access patterns in a thin abstraction layer that enforces parameter binding and disallows direct string interpolation in queries.
- Avoid relying on ad-hoc sanitization (such as scattered
intval()calls) that does not clearly align with the actual values used to build queries. - Introduce clear data flow boundaries: treat all request parameters as untrusted and require explicit validation and type enforcement at the point of entry.
- Apply least-privilege to the database user account to reduce the blast radius if an injection does occur.
How teams detect issues like this
Detection can combine code-centric and runtime techniques:
- Use static application security testing (SAST) rules to flag SQL queries built via string concatenation, especially where
$_REQUEST,$_GET, or$_POSTvariables are involved. - During code review, look for query-building functions that take raw user input, particularly in helper methods like
getAllActiveOrToRepeat()where developers may assume upstream sanitization. - Enforce coding standards or linters that prohibit dynamic SQL construction without parameter binding.
- Employ runtime application monitoring or database activity monitoring to detect anomalous query patterns such as repetitive, time-based queries indicative of blind injection attempts.
- Integrate automated security scanning tools into CI pipelines to highlight unparameterized queries and missing validation.

