/

CVE-2025-15446

Severity:

HIGH RISK

(7.3)

SQL Injection in Seeyon Zhiyuan OA fixedAssetsList.jsp

CVE-2025-15446

Modified

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Data Exposure and Manipulation via SQL Injection

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

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.jsp endpoint.
  • 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 unitCode parameter 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 unitCode and 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.execute with 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.

Sources

SourceLink
github.comgithub.com/xiaozipang/CVE/issues/2
vuldb.comvuldb.com/?ctiid.339479
vuldb.comvuldb.com/?id.339479
vuldb.comvuldb.com/?submit.721917

Frequently asked

questions

The issue is remotely exploitable whenever the vulnerable endpoint is reachable over the network and the unitCode parameter is processed by the backend. Exploitability may be increased if authentication is not required or if common user roles can access the endpoint.

That depends on the deployment. In some configurations, the endpoint may be publicly or anonymously accessible; in others, basic user-level access might be required. The vulnerability stems from request parameter handling, not from elevated application privileges.

Refactor the affected code to use parameterized queries or prepared statements for all database interactions, ensuring that unitCode and other inputs are always bound as parameters. Complement this with strict input validation and reduced database privileges for the application account.

Establish coding standards that prohibit dynamic SQL string concatenation with user input, adopt frameworks or ORMs that encourage parameterization by default, and integrate static analysis plus security-focused code review into the development lifecycle to catch unsafe patterns before deployment.

Find out what's already
exploitable in your codebase.