/

CVE-2026-11483

Severity:

HIGH RISK

(7.3)

SQL Injection (CWE-89) in Class Exam Timetabling System

CVE-2026-11483

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Database Compromise and Data Exfiltration

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

SourceCodester Class and Exam Timetabling System 1.0 contains a SQL injection flaw in archive4.php via the sy parameter, allowing crafted input to be interpreted as part of a database query.

A remote attacker can abuse this to manipulate or exfiltrate data, and potentially escalate to full database compromise when the vulnerable page is accessible over the network.

Affected context

The vulnerability arises in the web-facing component of the Class and Exam Timetabling System that processes requests to /archive4.php.

It appears when user-controlled request parameters, particularly sy, are concatenated or interpolated directly into SQL statements without robust server-side validation, parameterization, or output encoding tailored to database queries.

Any deployment that exposes this endpoint to untrusted users, such as on the public internet or a shared campus network, is at heightened risk.

Exploit preconditions

  • Attack surface: HTTP requests targeting /archive4.php on the Timetabling System.
  • Required access: Network access to the web application; no special privileges are implied by the description.
  • Trigger point: Supplying crafted values in the sy parameter (e.g., via GET or POST) that are used in a backend SQL query.
  • Why exploitation is possible: The application dynamically builds SQL queries using untrusted input from sy without using prepared statements or equivalent parameter binding, corresponding to injection into a command string (CWE-74) and classic SQL Injection (CWE-89).

Why this happens

At its core, this is an injection bug where untrusted input is treated as part of executable SQL.

The backend code likely constructs SQL strings through string concatenation or direct interpolation of the sy parameter rather than using parameterized queries.

Because no strict input validation or query parameter binding is applied, an attacker can introduce additional SQL tokens (such as operators, literals, or clauses) that the database engine executes.

This aligns with CWE-89 (Improper Neutralization of Special Elements used in an SQL Command) and more generally CWE-74 (Improper Neutralization of Special Elements in Output Used by a Downstream Component).

Potential impact

  • An attacker may read sensitive data from database tables, including student, class, or exam information.
  • The database contents could be modified, leading to tampering with schedules, records, or administrative data.
  • In some configurations, the attacker can delete data or entire tables, causing loss of availability.
  • If the database account has elevated privileges or supports command execution, the attacker may escalate toward server-level compromise.
  • Application logic relying on database integrity can be subverted, impacting grading, timetable accuracy, or audit trails.

General mitigation guidance

Effective mitigation centers on strict separation of data from code in database interactions and reduction of trust in user input:

  • Use prepared statements or parameterized queries for all database access, ensuring user input is bound as data values, not SQL syntax.
  • Apply centralized server-side validation for parameters like sy, enforcing expected formats (e.g., numeric ranges, fixed enumerations) to reduce input variability.
  • Introduce an abstraction or data access layer that forbids ad hoc query string concatenation and encourages safe APIs by design.
  • Run the database with least-privilege accounts so that, even if an injection occurs, the accessible operations are minimized.
  • Limit exposure of administrative or sensitive query capabilities through the web layer and avoid embedding dynamic clauses directly influenced by user parameters.

How teams detect issues like this

Organizations can detect and monitor for this class of vulnerability using multiple approaches:

  • Static application security testing (SAST) to flag string concatenation or interpolation into SQL APIs, especially around parameters like sy.
  • Manual code review with a focus on database access patterns, looking for direct inclusion of $_GET/$_POST or other raw request data in query strings.
  • Runtime application security testing (DAST) or interactive testing that probes parameters for SQL error messages, response anomalies, or behavioral changes.
  • Web application firewall (WAF) or reverse proxy rules that log and optionally block suspicious SQL-like patterns in query parameters while still treating them as potential indicators rather than definitive proof.
  • Secure coding checklists and CI/CD policies that prevent merging code where unsafe query construction patterns are detected.

Sources

SourceLink
github.comgithub.com/ssaaaa1234/cve/issues/4
vuldb.comvuldb.com/cve/CVE-2026-11483
vuldb.comvuldb.com/submit/834108
vuldb.comvuldb.com/vuln/369103
vuldb.comvuldb.com/vuln/369103/cti
sourcecodester.comsourcecodester.com/

Frequently asked

questions

Yes. The issue is triggered via HTTP requests to /archive4.php, so any attacker with network access to the application and knowledge of the endpoint can attempt exploitation.

The description does not indicate an authentication requirement. If the vulnerable endpoint is externally reachable without login or with easily obtained access, exploitation can occur without privileged credentials.

Refactor all affected queries to use parameterized statements or a database abstraction layer that enforces parameter binding, combined with strict server-side validation of the sy parameter and other user inputs before they reach the database.

Adopt secure coding standards that prohibit query string concatenation with user input, enforce automated static checks in the development pipeline, use ORM or query builders configured for safe defaults, and conduct regular security reviews focused on data access layers.

Find out what's already
exploitable in your codebase.