/

CVE-2026-33651

Severity:

HIGH RISK

(8.1)

SQL Injection in WWBN AVideo remindMe.json.php

CVE-2026-33651

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Database Compromise / Data Exfiltration

Severity:

HIGH RISK

(8.1)

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 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.php endpoint
  • Required access: Any authenticated user account on the WWBN AVideo instance
  • Trigger point: Sending crafted live_schedule_id values via $_REQUEST (e.g., GET or POST) that reach Scheduler_commands::getAllActiveOrToRepeat()
  • Why exploitation is possible: The original live_schedule_id is passed through multiple functions and ultimately concatenated directly into a SQL LIKE clause, while intermediate intval() 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 LIKE clauses, 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 $_POST variables 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.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/75d45780728294ededa1e3f842f95295d3e7d144
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-pvw4-p2jm-chjm

Frequently asked

questions

Yes. Any user who can reach the remindMe.json.php endpoint over HTTP(S) and is able to authenticate can attempt to exploit the vulnerability, even without direct access to the database server.

No elevated privileges are required beyond having an authenticated account on the WWBN AVideo instance. The injection occurs at the application layer, so basic authenticated access is sufficient.

The most robust fix is to replace all string-concatenated SQL with parameterized queries or prepared statements, ensuring that the live_schedule_id and similar inputs are bound as parameters and validated for expected type and range before query execution.

Adopt a strict policy that forbids building SQL via string concatenation, enforce parameterized access through a shared data access layer, add automated checks in CI for unsafe query patterns, and train developers to treat all request-sourced values as untrusted until validated and bound as parameters.

Find out what's already
exploitable in your codebase.