Severity:

HIGH RISK

(7.3)

SQL Injection in Yonyou KSOA 9.0 HTTP GET Parameter Handler

CVE-2026-1130

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized Data Access 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 for /worksheet/worksadd_plan.jsp, where the ID parameter is incorporated into database queries without proper safeguards.

A remote attacker can manipulate this parameter to influence backend SQL execution, potentially accessing, altering, or deleting data depending on database privileges and configuration.

Affected context

The vulnerability occurs in Yonyou KSOA 9.0 within the web interface that processes HTTP GET requests to /worksheet/worksadd_plan.jsp.

The issue is present when the ID parameter from the query string is used to build SQL statements without robust validation, sanitization, or parameterization.

Systems that expose this endpoint to untrusted networks or users, and that connect to a relational database with meaningful privileges, are particularly at risk.

Exploit preconditions

  • Attack surface: Public or internally exposed web endpoint at /worksheet/worksadd_plan.jsp.
  • Required access: Network-level access to the application; no specific prior authentication is necessarily implied by the description.
  • Trigger point: Supplying crafted values in the ID HTTP GET parameter so that they are processed by the vulnerable SQL construction logic.
  • Why exploitation is possible: The ID parameter is concatenated or embedded directly into SQL queries without strict input validation, escaping, or prepared statements, allowing the attacker's input to be interpreted as SQL syntax rather than data.
  • Exploit status: Public exploit code or techniques have been published, reducing the effort required for attackers.

Why this happens

This is a classic CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

The underlying bug class is the direct use of user-controlled input (the ID GET parameter) in SQL statements without using safe construction patterns such as parameterized queries.

Additionally, aspects of CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component are present, as data flows from HTTP handling to the database layer with insufficient neutralization.

Conceptually, the application treats untrusted input as trusted query logic, allowing attackers to extend or modify the intended SQL command.

Potential impact

  • Database contents may be read, including sensitive or business-critical records.
  • Data stored in affected tables could be modified, corrupted, or deleted.
  • Authentication or authorization checks that rely on database data may be bypassed.
  • Additional SQL operations (such as creation of new accounts or escalation of privileges) might be performed if the database account has broad permissions.
  • In some environments, SQL injection could be chained with database-specific features to execute server-side code or pivot to other systems.

General mitigation guidance

Mitigation generally centers on treating all incoming parameters as untrusted and ensuring database access is resilient to malicious input.

Non-version-specific defensive patterns include:

  • Using parameterized queries or prepared statements for all database interactions, ensuring user input is always bound as data, not query text.
  • Applying strict server-side validation for the ID parameter (e.g., enforcing numeric or UUID formats) and rejecting values that do not match expected patterns.
  • Centralizing database access patterns behind a safe data access layer that disallows ad-hoc string concatenation.
  • Applying the principle of least privilege to the database account so it only has the minimal rights needed (e.g., no arbitrary DDL privileges).
  • Implementing consistent input handling and encoding rules between the HTTP layer and the database layer to reduce mixed trust assumptions.

These controls reduce the likelihood that user-controlled input can alter SQL semantics, even if some validation gaps exist.

How teams detect issues like this

Detection typically involves both code-level review and runtime monitoring:

  • Static analysis: Configure SAST tools or custom rules to flag dynamic SQL string construction involving HTTP parameters, especially where ID or similar request variables are concatenated into queries.
  • Code review signals: Look for inline SQL built with string concatenation, absence of prepared statements, and request parameters flowing directly into query-building functions.
  • Runtime monitoring: Use database activity monitoring or web application firewalls (WAFs) to detect anomalous SQL patterns, such as injected operators, tautologies, or stacked queries originating from the ID parameter.
  • Policy enforcement: Introduce coding standards that mandate parameterized queries and enforce them with pre-merge checks in CI pipelines.

Automated review tools can assist in identifying these patterns early, but should be complemented with manual analysis of critical data access paths.

Sources

SourceLink
github.comgithub.com/LX-66-LX/cve/issues/12
vuldb.comvuldb.com/?ctiid.341720
vuldb.comvuldb.com/?id.341720
vuldb.comvuldb.com/?submit.734565

Frequently asked

questions

The vulnerability is network-exploitable wherever the /worksheet/worksadd_plan.jsp endpoint is reachable and the vulnerable code path is active. With a publicly available exploit, even non-specialist attackers can attempt to leverage it, though actual impact depends on database privileges and configuration.

The description does not state that authentication is required, so exploitation may be possible as an unauthenticated user if the endpoint is accessible without login. Deployments with strong access controls or network segmentation will reduce exposure.

The most robust fix is to refactor database interactions to use parameterized queries or prepared statements everywhere, combined with strict server-side validation of the ID parameter (e.g., enforcing its expected type and format). Removing all instances of string concatenation when forming SQL is key.

Prevention typically involves adopting a secure data access layer, mandating parameterized queries by policy, and integrating security checks into the development lifecycle. Regular code reviews focused on input handling, automated static analysis for injection patterns, and least-privilege database configuration help ensure new features do not reintroduce the same risk class.

Find out what's already
exploitable in your codebase.