/

CVE-2025-15425

Severity:

HIGH RISK

(7.3)

SQL Injection in Yonyou KSOA del_user.jsp

CVE-2025-15425

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

Yonyou KSOA 9.0 contains an SQL injection flaw in the HTTP GET parameter handler of /worksheet/del_user.jsp, where the ID parameter is unsafely incorporated into database queries.

A remote attacker can manipulate this parameter to alter backend SQL statements, potentially accessing, modifying, or deleting data in the affected database when the vulnerable endpoint is exposed.

Affected context

The vulnerability occurs in Yonyou KSOA 9.0 within a web endpoint at /worksheet/del_user.jsp that processes HTTP GET requests.

The issue arises when the ID parameter from the query string is used to construct SQL statements without adequate neutralization or parameterization.

This is relevant in deployments where the application server can reach a relational database and the endpoint is accessible to untrusted clients over a network, such as the internet or a shared intranet.

Exploit preconditions

  • Attack surface: The /worksheet/del_user.jsp HTTP endpoint receiving GET requests.
  • Required access: Network access to the web application; no special privileges are implied by the description.
  • Trigger point: Supplying crafted values in the ID query parameter (e.g., ?ID=...) that are subsequently embedded into SQL queries.
  • Why exploitation is possible: The ID parameter is likely concatenated directly into an SQL statement or passed through an unsafe query builder without proper input neutralization or use of prepared statements, allowing attacker-controlled input to change the structure of the executed SQL.

Why this happens

This vulnerability is rooted in the direct use of user-supplied input from the ID HTTP GET parameter when forming SQL statements.

Instead of treating the parameter strictly as data, the application likely concatenates it into query strings or processes it through an API that does not enforce separation between code and data.

This behavior maps to CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), and is related to CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component, as the database is a downstream consumer of the tainted output.

The abstract pattern is: untrusted input → minimal or no validation/escaping → direct inclusion in SQL → attacker can inject or modify query logic.

Potential impact

  • Database contents may be read beyond the intended authorization scope, potentially exposing sensitive business or user data.
  • Stored data can be modified, corrupted, or deleted by altering INSERT, UPDATE, or DELETE operations.
  • Application-level authorization checks may be bypassed if injected queries skip or weaken access constraints.
  • In certain environments, SQL injection could be chained with DBMS-specific features to run administrative database commands.
  • Application stability and availability could be affected through injected queries that lock tables, exhaust resources, or cause errors.

General mitigation guidance

Effective mitigation focuses on ensuring that user-controlled data cannot alter SQL command structure and on minimizing trust in incoming parameters:

  • Prefer parameterized queries / prepared statements for all database access paths so that user-supplied values are always treated as data, not executable SQL.
  • Apply centralized input validation for identifier-like parameters such as ID, restricting them to expected formats (e.g., numeric-only or strict UUID patterns) and rejecting out-of-range or malformed values.
  • Introduce a data access layer or ORM that enforces safe query construction patterns by default, reducing ad hoc string concatenation.
  • Enforce principle of least privilege for database accounts so that even if a query is abused, the account has only the minimal rights needed.
  • Implement consistent error handling and generic error responses to avoid leaking database details or query fragments that could assist in iterative exploitation.
  • Incorporate secure coding guidelines and training emphasizing the separation of query logic from user input across the development team.

How teams detect issues like this

Detection generally combines code-centric review with runtime monitoring:

  • Static analysis: Configure rules to flag dynamic SQL construction that includes HTTP parameters (such as request.getParameter("ID")) or other untrusted inputs, especially in JSPs or DAO classes.
  • Code review: During manual reviews, look for SQL strings built via concatenation or string formatting; verify that all query parameters come from prepared statements rather than embedded literals.
  • Dependency and configuration review: Identify legacy modules or pages like /worksheet/del_user.jsp that bypass newer, safer data access layers and enforce refactoring where needed.
  • Dynamic testing: Use application security testing tools (DAST) or targeted query fuzzing to detect endpoints that respond abnormally to SQL meta-characters, such as quotes or comment markers.
  • Runtime monitoring: Analyze database logs and application logs for anomalous queries, unusual use of comment symbols, tautological conditions, or patterns indicative of injection attempts.

Sources

SourceLink
github.comgithub.com/master-abc/cve/blob/main/Yonyou%20Space-Time%20Enterprise%20Information%20Integration%20KSOA%20Platform%20worksheet%20del_user.jsp%20SQL%20injection.md
github.comgithub.com/master-abc/cve/blob/main/Yonyou%20Space-Time%20Enterprise%20Information%20Integration%20KSOA%20Platform%20worksheet%20del_user.jsp%20SQL%20injection.md#vulnerability-details-and-poc
vuldb.comvuldb.com/?ctiid.339347
vuldb.comvuldb.com/?id.339347
vuldb.comvuldb.com/?submit.721352
vuldb.comvuldb.com/?submit.734567

Frequently asked

questions

Yes. The vulnerable functionality is exposed through an HTTP GET endpoint, so any actor with network access to the affected /worksheet/del_user.jsp URL can attempt to exploit it, subject to any authentication or access controls in front of the page.

The description implies that only network-level access to the web application is needed. If the endpoint is unauthenticated, an anonymous user could exploit it; if it is behind login, then valid application credentials would be required.

The most robust fix is to refactor all affected queries to use parameterized statements or equivalent ORM mechanisms, ensuring that the ID and other parameters are bound as data. This should be coupled with strict validation of expected parameter formats and removal of any dynamic query string concatenation involving user input.

Prevention relies on a combination of secure coding practices and process controls: standardize on safe data access patterns (prepared statements/ORM), enforce input validation, add static analysis checks for unsafe query construction, and require security-focused code reviews for modules that interact with the database. Incorporating these controls into development and CI processes helps catch injection flaws before deployment.

Find out what's already
exploitable in your codebase.