/

CVE-2025-15421

Severity:

HIGH RISK

(7.3)

SQL Injection in Yonyou KSOA 9.0 HTTP GET Parameter Handler

CVE-2025-15421

Analyzed

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 a SQL injection vulnerability in the HTTP GET parameter handler of /worksheet/agent_worksadd.jsp, where the ID parameter is not safely handled before being used in database queries.

A remote attacker can manipulate this parameter to influence backend SQL statements, potentially leading to data access, modification, or other database-level impacts when the crafted request is processed.

Affected context

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

It is relevant where request parameters, especially ID, are incorporated into database operations without consistent parameterization or robust input handling.

The issue manifests at the application–database boundary, particularly in code paths that assemble SQL queries dynamically based on GET parameters.

Exploit preconditions

  • Attack surface: Public or internal web interface at /worksheet/agent_worksadd.jsp.
  • Required access: Ability to send crafted HTTP GET requests to the affected endpoint; no prior authentication may be required depending on deployment configuration.
  • Trigger point: Processing of the ID query parameter by server-side logic that constructs and executes SQL statements.
  • Why exploitation is possible: User-controlled data from ID is incorporated into SQL queries without reliable use of parameterized statements or adequate neutralization, allowing manipulation of the query structure itself.

Why this happens

The underlying issue aligns with 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.

Application code likely constructs SQL statements by concatenating the ID parameter directly into query strings or by otherwise treating it as trusted input.

Because the database interprets certain characters and tokens as part of SQL syntax, an attacker can craft values for ID that alter the intended query, affecting conditions, returned rows, or additional operations executed by the database.

Potential impact

  • May allow attackers to read sensitive data from database tables beyond what the application normally exposes.
  • Could enable modification or deletion of records, impacting data integrity.
  • Might permit creation of new accounts or escalation of privileges at the application level if authorization data is stored in the database.
  • Can potentially lead to full database compromise if chained with additional weaknesses such as overly privileged database accounts.
  • May facilitate application-level denial of service by issuing resource-intensive or destructive queries.

General mitigation guidance

Effective mitigation focuses on treating all incoming request parameters as untrusted and ensuring they cannot alter SQL structure:

  • Prefer parameterized queries or prepared statements for all database access, binding user input as data rather than concatenating strings.
  • Introduce strict input validation and normalization for parameters like ID, using allowlists for expected formats (e.g., numeric identifiers or constrained patterns).
  • Centralize data access logic to enforce consistent query-building patterns and avoid ad-hoc SQL string assembly in JSPs or controllers.
  • Apply least-privilege to database accounts used by the application so that even if a query is manipulated, the account cannot perform high-risk operations (e.g., DDL, cross-schema access).
  • Consider using ORM frameworks or query builders that default to safe parameter binding where appropriate.

How teams detect issues like this

Detection generally combines code-focused and behavior-focused approaches:

  • Static analysis: Use scanners or linters configured to flag dynamic SQL construction that incorporates HTTP parameters, particularly in JSPs and data access layers; look for string concatenation patterns involving request.getParameter("ID") or equivalent.
  • Code review: During manual review, pay attention to all database interactions in request handlers, verifying that they use bound parameters and that all user-supplied inputs are validated before use.
  • Dynamic testing: Employ web application security testing tools to probe endpoints like /worksheet/agent_worksadd.jsp for SQL injection indicators (e.g., differential responses, error messages, or timing discrepancies when special payloads are used).
  • Runtime monitoring: Enable database and application logging for unusual query patterns, failed queries with syntax errors, or anomalous spikes in similar query templates, and feed these into monitoring/alerting systems.

Sources

SourceLink
github.comgithub.com/master-abc/cve/blob/main/Yonyou%20Space-Time%20Enterprise%20Information%20Integration%20KSOA%20Platformworksheetagent_worksadd.jsp%20SQL%20injection.md
vuldb.comvuldb.com/?ctiid.339343
vuldb.comvuldb.com/?id.339343
vuldb.comvuldb.com/?submit.721324
vuldb.comvuldb.com/?submit.721527

Frequently asked

questions

Yes. An attacker can exploit the issue remotely by sending crafted HTTP GET requests to the affected JSP endpoint, assuming the application is reachable over the network.

That depends on how access to /worksheet/agent_worksadd.jsp is configured. If it is publicly accessible without login, no authentication is required; if it is behind a login, an attacker would need valid credentials or another way to reach the endpoint.

The most robust fix is to refactor all affected queries to use parameterized statements or prepared queries and to avoid building SQL strings via concatenation. Combined with strict validation of the ID parameter, this removes the attacker's ability to inject SQL syntax.

Adopt coding standards that mandate parameterized queries, apply centralized validation for all external inputs, incorporate secure coding review into the development lifecycle, and enforce static analysis rules that block introduction of new dynamic SQL patterns before code is merged.

Find out what's already
exploitable in your codebase.