/

CVE-2026-28430

Severity:

CRITICAL RISK

(9.8)

SQL Injection in Chamilo LMS custom_dates Parameter

CVE-2026-28430

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Remote Database Compromise and Administrative Account Takeover

Severity:

CRITICAL RISK

(9.8)

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

Chamilo LMS prior to version 1.11.34 contains an unauthenticated SQL injection vulnerability in the custom_dates parameter, allowing arbitrary SQL commands to be executed against the application database.

When combined with a predictable legacy password reset flow, this flaw can enable full administrative account takeover and exposure of sensitive data such as PII and system configuration, even without prior authentication.

Affected context

This vulnerability affects Chamilo LMS installations that:

  • Expose the vulnerable endpoint using the custom_dates parameter to unauthenticated users
  • Construct SQL queries dynamically based on HTTP request parameters
  • Use a legacy password reset mechanism with predictable or easily influenced tokens

The issue is most critical in internet-facing deployments where anonymous users can interact with the affected functionality.

Exploit preconditions

  • Attack surface: Public web interface of Chamilo LMS
  • Required access: No prior authentication; attacker can be any remote user who can reach the LMS web front-end
  • Trigger point: Submission of crafted values in the custom_dates parameter to the affected endpoint
  • Why exploitation is possible:
  • User-controlled input is embedded directly into SQL statements without robust parameterization or escaping
  • The legacy password reset mechanism uses predictable values or insufficient verification, allowing its behavior to be manipulated using information obtained via SQL injection

Why this happens

The core issue is improper handling of user-supplied input in SQL queries, where the custom_dates parameter is concatenated or interpolated into SQL strings without using safe, parameterized query patterns.

This maps to CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), where input lacking strict validation and binding allows attackers to modify the intended query structure.

The risk is amplified by coupling this injection with an insufficiently random or weakly validated password reset mechanism, enabling an attacker to leverage database access to orchestrate administrative account takeover.

Potential impact

  • Extraction of sensitive data, including personally identifiable information (PII) of students, instructors, and administrators
  • Full administrative account takeover via manipulation of the password reset process
  • Modification or deletion of course content, grades, and learning records
  • Tampering with system configuration, including authentication and integration settings
  • Planting of malicious data or backdoors in the application database to enable long-term persistence
  • Potential pivoting to other systems if shared credentials or connection details are stored in the database

General mitigation guidance

Effective mitigation focuses on eliminating direct injection points and hardening account recovery flows:

  • Use parameterized queries or prepared statements for all database interactions, ensuring user input is never concatenated into SQL strings
  • Apply strict server-side validation and canonicalization to all request parameters, especially those influencing queries
  • Isolate authentication and account recovery logic from data obtained through user-controllable channels
  • Redesign password reset flows to rely on strong, random, single-use tokens with short lifetimes and rigorous identity checks
  • Enforce least-privilege database accounts so that the web application user cannot perform unnecessary high-impact operations
  • Introduce centralized input handling and query-building utilities to reduce ad hoc SQL construction throughout the codebase

How teams detect issues like this

Detection efforts can combine code-centric and operational approaches:

  • Static analysis and code review:
  • Flag dynamic SQL construction that interpolates HTTP parameters like custom_dates
  • Search for concatenated SQL fragments and ensure they are replaced by bound parameters
  • Review password reset implementations for predictable tokens, direct database lookups by user-controlled identifiers, or weak verification steps
  • Runtime monitoring:
  • Enable database logging for anomalous queries, such as those with unexpected operators, UNION clauses, or comment markers originating from web traffic
  • Monitor application logs for repeated errors or unusual access patterns involving password reset and related endpoints
  • Security testing:
  • Use web application security scanners or manual penetration testing to probe inputs for injection behavior
  • Incorporate focused tests for account recovery and password reset functions into regular security test plans

Sources

SourceLink
github.comgithub.com/chamilo/chamilo-lms/releases/tag/v1.11.34
github.comgithub.com/chamilo/chamilo-lms/security/advisories/GHSA-84gw-qjw9-v8jv

Frequently asked

questions

Yes. Because the vulnerable parameter is accessible without authentication, a remote attacker who can reach the Chamilo LMS web interface can attempt to exploit the SQL injection directly.

No. The flaw is unauthenticated, and when combined with the predictable legacy password reset mechanism, it can be used to obtain or reset administrative credentials without any prior login.

Replace all dynamic SQL construction involving user input with parameterized queries, enforce strong server-side validation on parameters, and redesign password reset logic to use robust, random, and time-limited tokens with clear verification steps.

Establish secure coding standards that mandate parameterized database access, centralize data access layers, subject authentication and recovery flows to dedicated security review, and integrate automated static analysis and regular security testing into the development lifecycle.

Find out what's already
exploitable in your codebase.