/

CVE-2025-15436

Severity:

HIGH RISK

(7.3)

SQL Injection in Yonyou KSOA work_edit.jsp

CVE-2025-15436

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Database Compromise and Data Integrity Loss

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

Yonyou KSOA 9.0 contains a SQL injection vulnerability in the /worksheet/work_edit.jsp endpoint, where the Report parameter is incorporated into database queries without sufficient sanitization.

A remote attacker can manipulate this parameter to inject arbitrary SQL, which may lead to data exposure, modification, or other database-level compromise under typical deployment conditions.

Affected context

The vulnerability occurs in web deployments of Yonyou KSOA 9.0 that expose the /worksheet/work_edit.jsp endpoint over HTTP/S.

It is triggered when user-controlled input passed via the Report parameter is used to construct SQL queries on the server without robust input validation, parameterization, or proper escaping.

Environments with direct database connectivity from the application server, especially where the application database account has broad privileges, are more susceptible to severe impact.

Exploit preconditions

  • Attack surface: Public or internal web interface at /worksheet/work_edit.jsp.
  • Required access: Ability to send HTTP requests to the vulnerable endpoint (typically unauthenticated or low-privileged user, depending on deployment configuration).
  • Trigger point: Submission of crafted values in the Report parameter that are processed into SQL statements on the server.
  • Why exploitation is possible: The application dynamically builds SQL using the Report parameter without using parameterized queries or adequate server-side validation/encoding, allowing attacker-controlled content to alter the intended SQL command structure.

Why this happens

This issue stems from constructing SQL statements by directly concatenating or interpolating user-controlled data from the Report parameter into query strings.

This pattern corresponds to CWE-89: Improper Neutralization of Special Elements used in an SQL Command, where metacharacters and control constructs in the input are not safely handled before being passed to the database.

It is also related to CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component, since unsafe data flows from the web layer into the database engine, which interprets it as executable SQL instead of pure data.

The underlying design implicitly trusts client-supplied parameters to reflect safe query fragments, rather than enforcing a strict separation between query logic and untrusted values.

Potential impact

  • Unauthorized reading of database records, including potentially sensitive or regulated data.
  • Modification or deletion of records, leading to loss of integrity or availability of business data.
  • Creation or alteration of application accounts or roles through injected SQL, depending on database privileges.
  • Potential execution of database-specific procedures that could expand the compromise to the underlying host or other systems, where supported by the database and configuration.
  • Disruption of application functionality through tampered queries, resulting in denial of service at the application layer.

General mitigation guidance

Effective mitigation focuses on eliminating direct inclusion of user-controlled data in SQL commands and reducing trust in incoming parameters:

  • Prefer parameterized queries / prepared statements for all database operations and avoid constructing SQL by string concatenation, especially for query filters or identifiers derived from user input.
  • Introduce strict server-side validation on the Report parameter, using allowlists of permissible values, patterns, or enumerated options instead of arbitrary free-form text.
  • Where dynamic query construction is unavoidable, enforce query-building abstractions that encode or escape metacharacters in a framework-consistent way, keeping application code from directly handling SQL fragments.
  • Apply principle of least privilege to the database account used by the application so that injected queries have minimal scope (e.g., no schema modification rights, limited access to non-essential tables).
  • Consider segregating sensitive data into separate schemas or databases with tighter access controls, so that compromise of one application surface does not automatically expose all critical information.

How teams detect issues like this

Detection efforts can combine code-level review and runtime monitoring:

  • Use static analysis or secure code scanning rules that flag dynamic SQL construction (e.g., string concatenation involving request parameters such as Report) and identify non-parameterized queries in the codebase.
  • During manual code review, look for JSPs and backend handlers that pass request parameters directly into SQL APIs, especially where frameworks do not enforce parameterization by default.
  • Implement web application firewall (WAF) or reverse proxy rules that detect common SQL injection patterns in requests targeting /worksheet/work_edit.jsp, while recognizing that WAFs are a compensating control rather than a primary fix.
  • Monitor database logs for anomalous queries, such as unexpected concatenated statements, tautologies, or unusual access patterns originating from the application account.
  • Integrate these checks into CI/CD pipelines so new or modified endpoints that handle query-related parameters are automatically evaluated for SQL injection risks.

Sources

SourceLink
github.comgithub.com/xinshou-test/CVE/issues/2
vuldb.comvuldb.com/?ctiid.339363
vuldb.comvuldb.com/?id.339363
vuldb.comvuldb.com/?submit.721925

Frequently asked

questions

Yes. An attacker who can reach the /worksheet/work_edit.jsp endpoint over the network can attempt to exploit the SQL injection by sending crafted HTTP requests that manipulate the Report parameter.

That depends on how Yonyou KSOA is deployed. If the vulnerable endpoint is accessible to unauthenticated users, then no login is required. If it is restricted, an attacker would need at least the level of access required to reach the page, which is often low-privileged in typical business applications.

The most robust fix is to refactor all affected queries to use parameterized statements or safe ORM query APIs, combined with strict allowlist validation of the Report parameter. This eliminates the need to trust client-supplied SQL fragments and prevents user input from altering the query structure.

Establish secure coding standards that prohibit dynamic SQL concatenation with user input, enforce automated checks for non-parameterized queries, and integrate security review into the development lifecycle. Pair this with least-privilege database accounts and regular training for developers on injection-resistant design patterns.

Find out what's already
exploitable in your codebase.