Severity:

HIGH RISK

(7.3)

SQL Injection in dameng100 muucmf Search Module

CVE-2026-6562

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Data Exposure 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

dameng100 muucmf 1.9.5.20260309 contains a SQL injection vulnerability in the getListByPage function of /index/Search/index.html, where the keyword parameter is incorporated into database queries without sufficient sanitization.

A remote attacker can craft malicious search requests that manipulate the underlying SQL query, potentially exposing or altering data and impacting application behavior.

Affected context

The vulnerability occurs in the search functionality exposed at /index/Search/index.html, specifically within the getListByPage logic that paginates search results.

It manifests when user-controlled input from the keyword parameter is passed into SQL statements without proper validation or query parameterization.

Any deployment that exposes this search endpoint to untrusted users over a network is potentially affected, especially where the application connects to a production database with sensitive data.

Exploit preconditions

  • Attack surface: HTTP(S) interface to the /index/Search/index.html endpoint
  • Required access: Ability to send crafted requests (no prior authentication may be required, depending on configuration)
  • Trigger point: Supplying specially constructed values in the keyword parameter used by getListByPage
  • Why exploitation is possible: The application appears to interpolate keyword directly into an SQL query or fragment without robust escaping or bound parameters, allowing the attacker to alter the query structure

Why this happens

This issue is a classic example of CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

The underlying logic builds SQL queries dynamically using user-provided keyword values, likely via string concatenation or unsafe formatting.

Because special characters and control tokens (such as quotes, comment markers, or operators) are not consistently neutralized or avoided through parameter binding, user input can escape its intended data context and inject additional SQL logic.

The presence of CWE-74 (Injection) further reflects the broader pattern of failing to neutralize control characters before embedding untrusted data into a backend interpreter (the SQL engine).

Potential impact

  • May allow attackers to read sensitive information from database tables beyond what the search feature should expose
  • Could permit modification or deletion of records, impacting data integrity and availability
  • Can enable extraction of authentication credentials or session data stored in the database, facilitating further compromise
  • Might allow enumeration of database schema, aiding more targeted attacks
  • In some deployment configurations, could lead to execution of database-specific functions that impact the underlying host or other applications

General mitigation guidance

Mitigation focuses on eliminating direct concatenation of user input into SQL and reducing the trust placed in search parameters:

  • Adopt parameterized queries or prepared statements for all database access paths, including search and pagination.
  • Refactor query-building logic to treat keyword strictly as data, never as a query fragment, avoiding string concatenation with SQL keywords or operators.
  • Apply strict input validation and normalization for search terms, constraining length and allowed character sets to expected values.
  • Introduce a data access abstraction layer that centralizes query construction, making it easier to enforce safe patterns by default.
  • Run the database with least-privilege accounts so that compromised queries are limited in what they can read or modify.
  • Implement defense-in-depth at the platform level, such as database query firewalls or anomaly detection that can flag suspicious patterns.

How teams detect issues like this

Detection can leverage both code-level and runtime approaches:

  • Static analysis: Use rules that flag dynamic SQL construction (e.g., string concatenation or template-based queries) involving HTTP parameters like keyword, especially in search-related code paths.
  • Code review: During manual review, watch for controller or template files (like /index/Search/index.html handlers) that pass raw request parameters directly to data access APIs without a clear parameter binding step.
  • Testing and fuzzing: Employ automated security testing that sends common SQL injection payload patterns into the keyword parameter and evaluates for errors, anomalies, or unexpected data leakage.
  • Logging and monitoring: Configure application and database logs to record query errors and unusual query shapes; monitor for sudden patterns such as tautologies, UNION-based queries, or comment markers originating from user inputs.
  • Policy enforcement: Integrate secure coding standards into CI pipelines, enforcing that all new database queries use parameterization helpers or ORM layers rather than raw concatenated SQL strings.

Sources

SourceLink
thinhneee.github.iothinhneee.github.io/posts/muucmf-sqli/
vuldb.comvuldb.com/submit/789501
vuldb.comvuldb.com/vuln/358199
vuldb.comvuldb.com/vuln/358199/cti

Frequently asked

questions

It is remotely exploitable wherever the search endpoint is reachable over the network.

If the endpoint does not require authentication, any external user who can send requests may attempt to exploit the flaw.

Not necessarily. The vulnerability arises at the point where the keyword parameter is processed.

If the search functionality is publicly accessible, no prior authentication is required; if it is behind a login, an attacker at least needs a basic account.

The most robust fix is to replace any dynamic, concatenated SQL that includes keyword with parameterized queries or prepared statements.

At the same time, constrain the keyword input via allowlists and length limits so that only expected characters and sizes are accepted.

Establish a project-wide rule that all database access must go through safe abstractions that enforce parameter binding by default.

Combine this with regular security-focused code reviews, automated static analysis for injection patterns, and input validation standards for all externally influenced parameters.

Find out what's already
exploitable in your codebase.