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.

