/

CVE-2026-13521

Severity:

HIGH RISK

(7.3)

SQL Injection (CWE-89) in Class Timetabling System

CVE-2026-13521

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized Database Access and Data Manipulation

Severity:

HIGH RISK

(7.3)

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

The Class and Exam Timetabling System contains a SQL injection flaw in preview5.php via the course_year_section parameter.

When user-supplied input is concatenated directly into SQL queries, a remote attacker can manipulate database operations and potentially access or modify sensitive data.

Affected context

This vulnerability occurs in the web-based Class and Exam Timetabling System when handling HTTP requests to preview5.php that include the course_year_section parameter.

It is relevant in deployments where user-provided values are passed directly into backend database queries without adequate validation or parameterization.

Any context in which attackers can reach this endpoint over the network and influence the parameter value may be at risk, particularly if the application runs with elevated database privileges.

Exploit preconditions

  • Attack surface: Public or internal web interface exposing preview5.php
  • Required access: Ability to send crafted HTTP requests with a controlled course_year_section parameter
  • Trigger point: Execution of SQL queries that directly incorporate the course_year_section value
  • Why exploitation is possible: The application builds SQL statements by concatenating untrusted input, allowing attackers to inject additional SQL syntax that the database will execute

Why this happens

The underlying issue is the construction of SQL queries using string concatenation with unvalidated, untrusted data from the course_year_section parameter.

This aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), because special characters and SQL control tokens are not neutralized or separated from the query logic.

Additionally, aspects of CWE-74: Improper Neutralization of Special Elements in Output are present due to the lack of structured handling of user input before embedding it into an interpreted context.

The insecure pattern is treating user input as part of executable SQL rather than as data bound through parameterized statements or an ORM.

Potential impact

  • Attackers may retrieve or enumerate sensitive timetable and user records from the database.
  • Malicious users could modify or delete scheduling data, impacting class and exam timetables.
  • The vulnerability can be used to create or escalate application accounts if authentication data is stored in the same database.
  • SQL injection may lead to disclosure of underlying database schema and configuration details.
  • In some configurations, attackers could execute database-specific commands that impact server stability or integrity.

General mitigation guidance

Effective mitigation focuses on separating data from query logic and reducing trust in external input.

Common defensive patterns include:

  • Using parameterized queries or prepared statements for all database interactions so user input is never concatenated into SQL strings.
  • Employing an ORM or query builder that enforces structured query construction and handles binding automatically.
  • Validating and normalizing the course_year_section parameter against a strict whitelist (e.g., known course identifiers or numeric ranges) before using it in database operations.
  • Ensuring database accounts used by the application follow least-privilege principles, limiting the impact of any injected commands.
  • Applying secure-by-default coding guidelines that forbid dynamic SQL string building with user-controlled data.

How teams detect issues like this

Organizations can identify this type of vulnerability through a mix of automated and manual techniques:

  • Static analysis rules that flag dynamic SQL construction, especially concatenation of HTTP parameters into query strings.
  • Code review practices that focus on database access layers, ensuring all queries use parameter binding and input validation.
  • Application-level security tests (including fuzzing and DAST tools) that send crafted SQL meta-characters in parameters like course_year_section and observe for errors or abnormal responses.
  • Enforcement of internal policies that mandate parameterized queries and provide secure database access abstractions for developers.
  • Integration of security scanners into CI/CD pipelines to continuously check for SQL injection patterns as code evolves.

Sources

SourceLink
github.comgithub.com/xiaoxuxu233/myCVE/issues/2
vuldb.comvuldb.com/cve/CVE-2026-13521
vuldb.comvuldb.com/submit/839572
vuldb.comvuldb.com/vuln/374529
vuldb.comvuldb.com/vuln/374529/cti
sourcecodester.comsourcecodester.com/

Frequently asked

questions

It is network-accessible wherever preview5.php is exposed and typically exploitable by any attacker who can send HTTP requests with crafted parameters, assuming no upstream controls block the traffic.

Only the ability to reach the vulnerable endpoint and supply values for the course_year_section parameter is required; no prior authentication may be necessary depending on how the application is configured.

Refactor database interactions to use parameterized queries or prepared statements exclusively, and enforce strict validation for all external inputs before they are passed into the data access layer.

Adopt secure coding standards that forbid dynamic SQL string concatenation, use vetted database abstraction layers, include security-focused code review, and integrate automated analysis tools that specifically check for injection patterns during development.

Find out what's already
exploitable in your codebase.