Severity:

HIGH RISK

(7.3)

SQL Injection in itsourcecode Construction Management

CVE-2026-7073

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Database Compromise and Data Exposure

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

itsourcecode Construction Management System 1.0 contains a SQL injection vulnerability in the /execute.php endpoint, where the code parameter is incorporated into database queries without proper sanitization.

A remote attacker can manipulate this parameter to alter SQL logic, potentially exposing or modifying data, and the existence of public exploit code increases the practical risk of compromise.

Affected context

The vulnerability occurs within the web-facing /execute.php script of itsourcecode Construction Management System 1.0 when handling the code parameter.

It is relevant in deployments where this endpoint is reachable over the network and where the parameter value is used to build SQL statements dynamically without strong validation or parameterization.

Typical affected contexts include internet-exposed or intranet instances where application and database accounts have broad privileges and query responses are observable by the attacker.

Exploit preconditions

  • Attack surface: HTTP(S) interface to /execute.php
  • Required access: Remote web access; no local system access is necessary
  • User interaction: Usually none beyond sending crafted HTTP requests containing a malicious code parameter
  • Trigger point: Application logic that constructs and executes SQL queries in response to requests to /execute.php
  • Why exploitation is possible: The code argument is inserted into SQL statements without proper input neutralization or use of parameterized queries, allowing attacker-controlled tokens to modify query structure.

Why this happens

The root cause is unsafe construction of SQL queries using untrusted input from the code parameter in /execute.php.

Instead of using parameterized statements or a safe query builder, the application appears to concatenate raw user input directly into the SQL string, which maps to CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

This pattern treats external input as if it were data-only, but in SQL contexts, certain characters and sequences alter control flow, enabling attackers to inject conditions, unions, or additional statements.

The presence of CWE-74 (Improper Neutralization of Special Elements in Output Used by a Downstream Component) reflects that data passed to the database (a downstream component) is not properly constrained or encoded before use.

Potential impact

  • Extraction of sensitive data from the database, including project, client, or user records
  • Modification or deletion of application data, potentially disrupting construction project tracking and records
  • Authentication bypass if credential or session-related tables are affected
  • Creation of new administrative or application accounts in the underlying database
  • Potential execution of database-level procedures, leading to broader server compromise depending on DBMS configuration

General mitigation guidance

Effective mitigation focuses on eliminating direct string concatenation of SQL queries and reducing the trust placed in external parameters such as code.

Common patterns include:

  • Adopting parameterized queries or prepared statements for all database access paths, ensuring user input is always bound as data
  • Enforcing strict whitelisting or allowlists for parameters that control query behavior (e.g., only accepting known, enumerated codes)
  • Centralizing database access through a well-reviewed data access layer or ORM that discourages raw SQL construction
  • Applying least-privilege to database accounts so that application users cannot perform arbitrary schema changes or access unrelated tables
  • Implementing generic input validation policies that constrain length, type, and format of parameters before they reach SQL construction logic

How teams detect issues like this

Organizations can detect this type of vulnerability using several complementary approaches:

  • Static analysis rules that flag dynamic SQL construction involving superglobals or request parameters (e.g., $_GET['code'], $_POST['code']) without parameter binding
  • Code review checklists that require reviewers to verify parameterization of all queries in scripts like /execute.php
  • Web application firewall (WAF) or reverse proxy rules tuned to detect common SQL injection patterns in the code parameter
  • Runtime monitoring of database logs for anomalous queries, such as unexpected UNIONs, tautological conditions, or abnormal error rates associated with /execute.php
  • Integration of automated security testing (SAST/DAST) in CI/CD pipelines to regularly scan endpoints for injection weaknesses

Sources

SourceLink
github.comgithub.com/Beatriz-ai-boop/cve/issues/2
itsourcecode.comitsourcecode.com/
vuldb.comvuldb.com/submit/799543
vuldb.comvuldb.com/vuln/359648
vuldb.comvuldb.com/vuln/359648/cti

Frequently asked

questions

Yes. The vulnerability is in a web-accessible endpoint (/execute.php), and attackers can exploit it remotely by sending crafted HTTP requests that manipulate the code parameter.

Not necessarily. If /execute.php is reachable without authentication or is exposed in pre-authentication flows, exploitation can occur without valid user credentials. If the route is access-controlled, attackers would first need a way to reach it, such as via a low-privileged account.

The most robust fix is to replace any string-concatenated SQL involving the code parameter with parameterized queries or prepared statements and to restrict code to an explicit set of allowed values, avoiding user-controlled fragments that influence SQL structure.

Prevention depends on enforcing secure coding practices: mandate parameterized queries across the codebase, use a data access abstraction that makes unsafe patterns hard to express, apply least-privilege database roles, and adopt automated security checks (static analysis, code review rules, and regular dynamic testing) as part of the development lifecycle.

Find out what's already
exploitable in your codebase.