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
IDHTTP GET parameter so that they are processed by the vulnerable SQL construction logic. - Why exploitation is possible: The
IDparameter 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
IDparameter (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
IDor 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
IDparameter. - 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.

