Severity:

HIGH RISK

(7.3)

SQL Injection in code-projects Simple Content Management

CVE-2026-6183

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized Data Access and Modification via SQL Injection

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 Simple Content Management System 1.0 contains a SQL injection flaw in /web/index.php where the ID parameter is used unsafely in database queries.

An attacker who can send crafted HTTP requests to this endpoint may manipulate SQL commands, potentially accessing or modifying backend data remotely.

Affected context

This vulnerability occurs in the web-facing component of the Simple Content Management System (SCMS) 1.0, specifically within /web/index.php.

It manifests when user-controlled input from the ID parameter is incorporated into SQL statements without adequate validation, sanitization, or parameterization.

Any deployment that exposes this script to the internet and connects it to a database with meaningful content is at risk, especially where default or weak hardening measures are in place.

Exploit preconditions

  • Attack surface: Public-facing web application endpoint at /web/index.php.
  • Required access: Network access to submit HTTP requests (no prior authentication is necessarily required if the endpoint is publicly reachable).
  • Trigger point: Supplying crafted values in the ID parameter of a request so that they are concatenated into SQL queries.
  • Why exploitation is possible: The application appears to build SQL statements dynamically using the raw ID value without prepared statements or robust input handling, enabling attacker-controlled SQL syntax injection.

Why this happens

The root cause aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

The application likely constructs SQL queries by concatenating the ID parameter directly into the query string rather than using parameterized statements or safely binding user input.

This behavior allows SQL metacharacters in the ID value to alter the intended structure of the query.

Additionally, aspects of CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component are implicated, because untrusted data is passed to the database (a downstream interpreter) without neutralization, letting it be interpreted as SQL code instead of pure data.

Potential impact

  • Unauthorized reading of database records, including potentially sensitive user or configuration data.
  • Modification or deletion of content managed by the CMS, leading to data loss or defacement.
  • Creation of new administrative or privileged accounts within the application data store.
  • Enumeration of database schema and structure to support further attacks.
  • In some environments, possible execution of secondary attacks such as writing malicious data that influences application behavior.

General mitigation guidance

Mitigation revolves around treating all external input as untrusted and ensuring it cannot change the structure of SQL statements.

Common defensive patterns include:

  • Using parameterized queries or prepared statements for all database interactions involving user input.
  • Applying strict input validation and type enforcement on parameters like ID (e.g., ensuring it is numeric and rejecting unexpected characters).
  • Centralizing database access through a safe data-access layer that abstracts query construction and enforces parameter binding by default.
  • Limiting database privileges so that the application account can only perform the minimum operations necessary, reducing the blast radius of any injection.
  • Implementing secure coding guidelines and training to avoid dynamic query concatenation patterns.

How teams detect issues like this

Effective detection typically combines code-level inspection with runtime testing:

  • Static analysis: Configure SAST tools or linters to flag dynamic SQL construction, string concatenation in query builders, and direct insertion of $_GET/$_POST variables into queries.
  • Manual code review: Look for database calls inside /web/index.php and related files that embed request parameters directly into SQL strings without parameter binding.
  • Dynamic testing: Use automated scanners or targeted penetration tests to send crafted ID parameter values and observe anomalous database errors or responses.
  • Policy enforcement: Enforce coding standards that require parameterized queries and prohibit ad-hoc dynamic SQL in code review checklists and CI gate rules.

Sources

SourceLink
code-projects.orgcode-projects.org/
github.comgithub.com/Xmyronn/simple-cms-sqli-id-parameter
vuldb.comvuldb.com/submit/797264
vuldb.comvuldb.com/vuln/357106
vuldb.comvuldb.com/vuln/357106/cti

Frequently asked

questions

Yes. An attacker with network access to the affected /web/index.php endpoint can exploit the SQL injection remotely by sending crafted HTTP requests, assuming the endpoint is exposed and no compensating controls block the malicious input.

Not necessarily. If the vulnerable functionality is accessible without logging in, then no authentication is required. If the ID parameter is only processed within authenticated workflows, an attacker would first need valid credentials or another way to access that code path.

The most robust fix is to replace any dynamically constructed SQL that includes user-controlled data with parameterized queries or prepared statements, combined with strict type and range validation on the ID parameter and other inputs that influence database calls.

Adopt a development standard that mandates parameterized database access, perform regular security-focused code reviews, integrate static analysis into the CI/CD pipeline to flag unsafe query construction, and train developers on secure input handling and interpreter-boundary risks.

Find out what's already
exploitable in your codebase.