Summary
A SQL injection vulnerability in the Seeyon Zhiyuan OA Web Application System allows crafted input in the unitCode parameter of /assetsGroupReport/fixedAssetsList.jsp to be embedded directly into database queries.
When exposed over the network, a remote attacker can abuse this flaw to manipulate or exfiltrate data from the backend database, depending on the surrounding application logic and database privileges.
Affected context
The vulnerability occurs in Seeyon Zhiyuan OA deployments that expose the /assetsGroupReport/fixedAssetsList.jsp endpoint and pass the unitCode parameter into SQL statements without adequate validation or parameterization.
It is relevant where the application uses relational databases and constructs queries dynamically in server-side code.
The risk typically increases when the application account has broad database privileges or when error messages expose query behavior.
Exploit preconditions
- Attack surface: HTTP interface to the Seeyon Zhiyuan OA Web Application System, specifically the
/assetsGroupReport/fixedAssetsList.jspendpoint. - Required access: Ability to send crafted HTTP requests to the vulnerable endpoint (usually unauthenticated or with baseline user-level access, depending on deployment configuration).
- Trigger point: Server-side processing of the
unitCodeparameter that is concatenated into SQL query strings. - Why exploitation is possible: User-controlled data is incorporated into SQL statements without proper parameterization or escaping, allowing attacker-controlled fragments to alter the query structure (CWE-89) and inject crafted commands into backend SQL execution (CWE-74: improper injection into downstream interpreters).
Why this happens
The core issue is dynamic construction of SQL queries using untrusted input from the unitCode parameter, likely through string concatenation or formatting APIs.
Rather than binding user input as typed parameters, the application appears to embed it directly into query text, allowing an attacker to break out of the intended value context and modify the logic of the SQL statement.
This aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command, and involves passing unvalidated, unsanitized user data to the SQL interpreter (a downstream component) as per CWE-74.
Potential impact
- Extraction of sensitive data from database tables, subject to the database account's read permissions.
- Modification or deletion of records, including business and audit data.
- Bypassing of application-level access controls enforced through SQL queries.
- Introduction of inconsistent or fraudulent data affecting reporting or asset management features.
- Potential pivoting to other application components if SQL functions or stored procedures expose additional capabilities.
General mitigation guidance
Mitigation generally centers on removing the ability for user input to control SQL structure and tightening data access boundaries.
Key defensive patterns include:
- Using parameterized queries or prepared statements for all database access, ensuring
unitCodeand similar parameters are always bound as values, not concatenated into SQL strings. - Defining strict server-side validation for parameters (e.g., enforcing type, length, and allowed character sets for identifiers like
unitCode). - Applying the principle of least privilege to the database account, limiting it to only the operations and tables required for the asset reporting feature.
- Centralizing query construction in a data access layer, discouraging ad hoc string-based SQL assembly in presentation code such as JSPs.
- Implementing secure-by-default frameworks or ORM layers that abstract raw SQL and encourage safe patterns.
How teams detect issues like this
Effective detection combines code-level analysis with runtime monitoring.
Common approaches include:
- Static analysis rules that flag SQL query construction using string concatenation, especially where request parameters (e.g.,
unitCode) flow into query text. - Targeted code review of JSPs and report-generation modules for patterns like
"... where ... " + param,Statement.executewith interpolated values, or dynamic query building without bind variables. - Enforcing secure coding standards that mandate prepared statements and disallow raw SQL in view-layer files, supported by automated policy checks in CI/CD pipelines.
- Database and application logging tuned to detect anomalous query patterns, such as unexpected use of logical operators, comment markers, or UNION clauses, which may indicate ongoing SQL injection attempts.

