/

CVE-2026-14745

Severity:

HIGH RISK

(7.3)

SQL Injection (CWE-89) in Real State Services 1.0

CVE-2026-14745

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized data access and database compromise

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

A SQL injection flaw in code-projects Real State Services 1.0 allows an attacker to manipulate the ID parameter in /single-list_rent.php and inject arbitrary SQL into backend queries.

When user-controlled input is concatenated directly into SQL without proper validation or parameterization, remote attackers can leverage this to access, modify, or delete data in the underlying database.

Affected context

The vulnerability occurs in the Real State Services 1.0 web application, specifically within the /single-list_rent.php script that appears to load rental listing details based on an ID argument.

It is present when the application builds SQL queries using this request parameter directly, without using prepared statements, strict type enforcement, or consistent input validation.

The risk is most pronounced in deployments where the database account used by the application has broad privileges such as read/write access to sensitive tables.

Exploit preconditions

  • Attack surface: Public-facing HTTP endpoint handling requests to /single-list_rent.php.
  • Required access: Ability to send crafted requests (e.g., via browser or automated tools) that control the ID parameter.
  • Trigger point: Server-side processing of the ID value inside dynamically constructed SQL statements.
  • Why exploitation is possible: The application interpolates the ID parameter directly into SQL without parameterization or proper escaping, matching CWE-89 and CWE-74 patterns of code injection through improperly handled special characters.

Why this happens

The core issue is dynamic SQL construction using untrusted user input.

Instead of using prepared statements or stored procedures that separate code from data, the application appears to concatenate the ID parameter directly into the query string.

This insecure pattern aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command and is often accompanied by CWE-74, where input containing special characters is not neutralized before being incorporated into commands or queries.

At an abstract level, the bug class is: application logic treating external input as part of executable SQL syntax, without enforcing strict typing, whitelisting, or neutralization.

Potential impact

  • Attackers may read sensitive information from database tables beyond the intended listing data.
  • Malicious users could modify or delete records, including rental listings or user accounts.
  • The application can be used as a pivot to enumerate database structure and metadata.
  • In some configurations, attackers might escalate to file write operations or server-side command execution via SQL functions.
  • Data integrity may be compromised, leading to fraudulent listings or tampered real estate information.

General mitigation guidance

Effective mitigation focuses on eliminating direct concatenation of user input into SQL and tightening data trust boundaries.

Pattern-based defensive measures include:

  • Using parameterized queries or prepared statements for all database interactions, ensuring user input is treated strictly as data.
  • Applying strict type checks and whitelisting on identifiers like ID (e.g., enforcing numeric IDs server-side).
  • Centralizing database access in a data access layer that disallows dynamic query construction based on raw request parameters.
  • Limiting database accounts used by the application to least-privilege roles that cannot modify schema or access unrelated tables.
  • Implementing secure defaults in frameworks or ORM layers, such as disabling raw query execution paths where possible.

How teams detect issues like this

Organizations can detect similar SQL injection risks through a combination of code and runtime analysis:

  • Static analysis rules that flag string concatenation involving SQL keywords and request parameters in PHP code, especially in files like /single-list_rent.php.
  • Manual code review focusing on data access layers, looking for raw mysqli_query, PDO::query, or equivalent calls built from untrusted input.
  • Enforcing secure coding policies that mandate prepared statements and prohibit ad-hoc dynamic SQL in web controllers.
  • Deploying application security testing such as DAST tools or fuzzers to probe endpoints for injection behavior and unexpected SQL error messages.
  • Integrating automated code review tools or CI checks that recognize common SQL injection anti-patterns in PHP applications.

Sources

SourceLink
code-projects.orgcode-projects.org/
github.comgithub.com/6Justdododo6/CVE/issues/24
vuldb.comvuldb.com/cve/CVE-2026-14745
vuldb.comvuldb.com/submit/849265
vuldb.comvuldb.com/vuln/376331
vuldb.comvuldb.com/vuln/376331/cti

Frequently asked

questions

Yes. Because /single-list_rent.php is part of the web application, attackers can exploit the issue remotely by sending crafted HTTP requests that control the ID parameter.

Typically only network access to the web application is required. No authentication may be needed if the vulnerable endpoint is publicly accessible, though actual impact depends on the database permissions and application logic.

Refactor the database interaction to use parameterized queries or prepared statements exclusively, enforce strict typing on the ID parameter, and centralize query construction in a data access layer that does not allow raw concatenation of user input into SQL.

Adopt a secure development standard that mandates prepared statements, perform security-focused code reviews on all data access code, use frameworks or ORMs that default to safe query interfaces, and include automated security testing in the CI/CD pipeline to catch injection patterns early.

Find out what's already
exploitable in your codebase.