Severity:

HIGH RISK

(7.3)

SQL Injection in Fujian Smart Integrated Management

CVE-2026-2820

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized Database Access and Data Manipulation

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

Fujian Smart Integrated Management Platform System up to version 7.5 contains a SQL injection vulnerability in the XAccessPermissionPlus.ashx handler via the DeviceIDS parameter.

A remote attacker can manipulate this parameter to inject crafted SQL fragments, which may lead to unauthorized data access, data modification, or other database-level impacts when the vulnerable endpoint is reachable.

Affected context

The vulnerability arises in deployments of the Fujian Smart Integrated Management Platform System (up to 7.5) that expose the /Module/CRXT/Controller/XAccessPermissionPlus.ashx endpoint.

It affects code paths where the DeviceIDS argument is processed and incorporated into SQL queries without robust parameterization or sanitization.

The issue is more impactful when the application account connecting to the database holds broad privileges, or when the endpoint is accessible from untrusted networks such as the public internet.

Exploit preconditions

  • Attack surface: HTTP(S) interface to /Module/CRXT/Controller/XAccessPermissionPlus.ashx
  • Required access: Network reachability to the affected web application; no specific prior authentication is implied by the description
  • User-controlled input: The DeviceIDS parameter in requests to the .ashx handler
  • Trigger point: Server-side processing that interpolates DeviceIDS into SQL statements at runtime
  • Why exploitation is possible: The application dynamically constructs SQL queries using the DeviceIDS value without proper input validation, encoding, or prepared statements, allowing attacker-controlled tokens to alter query structure and logic.

Why this happens

This flaw stems from constructing SQL queries by concatenating or interpolating raw user input from the DeviceIDS parameter into SQL command strings.

Rather than treating input solely as data, the application allows user-controlled values to influence the SQL syntax, creating conditions described by CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

The association with CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component reflects the broader pattern where data passed to the database (a downstream component) is not correctly neutralized, enabling the attacker to inject control characters such as quotes, delimiters, and operators.

Potential impact

  • Unauthorized reading of database records that the application account can access
  • Modification, insertion, or deletion of data in application tables
  • Bypassing of application-level authorization checks enforced at the data layer
  • Potential extraction of sensitive information such as user details or configuration data
  • In some configurations, execution of database-specific functions that could facilitate further compromise of the application environment

General mitigation guidance

Effective mitigation focuses on ensuring that user-controlled input can never change SQL syntax:

  • Use parameterized queries or prepared statements for all database interactions involving DeviceIDS and similar parameters.
  • Apply strict server-side validation on DeviceIDS, enforcing expected formats (for example, numeric IDs or constrained lists) and rejecting malformed values.
  • Centralize database access logic so that query construction is handled by vetted utility layers rather than ad hoc string concatenation.
  • Configure database accounts following least-privilege principles, limiting the impact even if an injection path is discovered.
  • Implement defensive output encoding or escaping only as a secondary measure, not as a replacement for parameterized queries.

How teams detect issues like this

Organizations can identify this class of issue using a combination of static and dynamic techniques:

  • Static analysis: Scan server-side code for SQL queries built via string concatenation or interpolation using request parameters such as DeviceIDS, and flag uses of low-level APIs that accept raw query strings.
  • Code review: Pay special attention to .ashx handlers and controller endpoints that consume query or form parameters; ensure all database calls use prepared statements and clearly separated data bindings.
  • Dynamic testing: Use web application security testing tools or custom test cases to send crafted DeviceIDS values containing SQL metacharacters and monitor responses or database behavior for signs of injection.
  • Policy enforcement: Integrate secure coding guidelines into CI/CD, requiring that new database interaction patterns pass automated checks for parameterization and input handling.

Sources

SourceLink
github.comgithub.com/luoye197-prog/cve-yinda-sql/blob/main/introduce
github.comgithub.com/luoye197-prog/cve-yinda-sql/blob/main/poc.py
vuldb.comvuldb.com/?ctiid.346945
vuldb.comvuldb.com/?id.346945
vuldb.comvuldb.com/?submit.753397

Frequently asked

questions

Yes. The vulnerable endpoint is reachable over the network, and exploitation can be carried out remotely by sending crafted requests to /Module/CRXT/Controller/XAccessPermissionPlus.ashx when it is exposed.

The description does not state that authentication is required. If the handler is accessible without login, an unauthenticated attacker with network access may be able to exploit it; if placed behind authentication, valid credentials would be necessary.

Refactor all affected code paths to use parameterized queries or prepared statements, and enforce strict validation on DeviceIDS so that only expected, well-formed identifiers are accepted, independent of any specific product version.

Adopt a development standard that forbids dynamic SQL string concatenation with user input, enforce this via code review and automated checks, and ensure database accounts use least privilege so that any residual injection bugs have constrained impact.

Find out what's already
exploitable in your codebase.