Severity:

HIGH RISK

(7.3)

SQL Injection in Online Art Gallery Shop 1.0

CVE-2026-3757

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Confidentiality and Integrity Compromise of Application Data

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

Projectworlds Online Art Gallery Shop 1.0 contains an SQL injection vulnerability in the /?pass=1 endpoint, where the fnm parameter is fed into database queries without proper sanitization.

A remote attacker can manipulate this parameter to interfere with SQL commands, potentially accessing or modifying backend data and impacting application behavior.

Affected context

The vulnerability occurs within the web request handling logic for the /?pass=1 route in Projectworlds Online Art Gallery Shop 1.0.

It is relevant when user-controlled input from the fnm parameter is used to construct SQL statements without robust parameterization or validation.

Any deployment that exposes this endpoint over a network and connects it to a relational database may be affected, especially where default configurations and sample code are used unchanged.

Exploit preconditions

  • Attack surface: Public-facing web interface at the /?pass=1 route.
  • Required access: Ability to send crafted HTTP requests to the application (typically unauthenticated or low-privilege web access).
  • Trigger point: Processing of the fnm query parameter in server-side logic that builds and executes SQL queries.
  • Why exploitation is possible: The application appears to concatenate fnm directly into SQL commands without parameterized queries, escaping, or rigorous input validation, enabling attackers to alter query structure.

Why this happens

This issue stems from constructing SQL queries using string concatenation with untrusted user input, rather than using parameterized statements or an ORM with safe query-building APIs.

The fnm parameter is treated as a trusted fragment of SQL, which aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') and overlaps conceptually with CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component.

When input neutralization is missing or incomplete, attackers can inject control characters such as quotes, operators, and SQL keywords, causing the database to execute unintended commands.

Potential impact

  • Retrieval of sensitive information from database tables that should not be exposed
  • Modification or deletion of records, including product listings, user accounts, or orders
  • Creation of new, potentially privileged accounts or data entries
  • Bypassing of application-level authentication or authorization checks implemented in SQL
  • Potential staging point for further attacks, such as data exfiltration or business logic abuse

General mitigation guidance

Effective mitigation typically focuses on removing direct string concatenation from database access layers and enforcing strict separation between code and data.

Common defensive patterns include:

  • Using parameterized queries or prepared statements for all database interactions involving user input
  • Employing an ORM or query builder that automatically handles value binding, reducing direct SQL construction
  • Applying strict server-side validation and normalization of input, constraining fnm to expected formats (e.g., known identifiers, whitelisted values)
  • Restricting database privileges so that the application account has only the minimum rights needed (e.g., no schema-altering permissions)
  • Centralizing query construction in a data access layer to make it easier to audit and enforce safe patterns

How teams detect issues like this

Organizations can identify similar SQL injection risks by:

  • Running static application security testing (SAST) tools configured to flag dynamic SQL construction and unparameterized queries
  • Performing focused code reviews on database access code to look for string concatenation involving request parameters like fnm
  • Using dynamic application security testing (DAST) and fuzzing tools to probe query parameters for injection behavior
  • Implementing runtime monitoring at the database layer (e.g., query logging) to detect anomalous or structurally unusual SQL statements
  • Enforcing secure coding guidelines and pre-merge checks that prohibit unparameterized SQL in web handlers

Sources

SourceLink
github.comgithub.com/hmKunlun/projectworldcve/issues/1
vuldb.comvuldb.com/?ctiid.349735
vuldb.comvuldb.com/?id.349735
vuldb.comvuldb.com/?submit.768057

Frequently asked

questions

Yes. As described, an attacker can exploit the SQL injection remotely by sending crafted HTTP requests to the affected /?pass=1 endpoint.

Typically, no elevated system access is required beyond the ability to reach the web application over the network. If the vulnerable endpoint is unauthenticated, exploitation can often occur without logging in.

Refactor all affected queries to use parameterized statements or a safe ORM API, ensuring user input is always passed as data parameters rather than interpolated into SQL strings, while also applying least-privilege to the database account.

Establish secure coding standards that mandate parameterized queries, integrate static and dynamic security testing into the CI/CD pipeline, conduct regular security-focused code reviews of data access logic, and train developers on injection-safe patterns.

Find out what's already
exploitable in your codebase.