Summary
Yonyou KSOA 9.0 contains a SQL injection vulnerability in the /worksheet/work_report.jsp endpoint, where the ID HTTP GET parameter is used unsafely in database queries.
An attacker can manipulate this parameter to interfere with SQL statements, potentially accessing, modifying, or deleting backend data when the vulnerable endpoint is exposed over the network.
Affected context
The vulnerability exists in Yonyou KSOA 9.0 within the /worksheet/work_report.jsp page, specifically in the logic that processes the ID HTTP GET parameter before constructing SQL queries.
It typically manifests where user-supplied request parameters are concatenated into SQL statements without robust validation or parameterization.
The issue is relevant in deployments where this JSP endpoint is reachable over HTTP/S and tied directly to a relational database backend without sufficient query hardening.
Exploit preconditions
- Attack surface: Network-accessible web interface exposing /worksheet/work_report.jsp.
- Required access: Unauthenticated or minimally authenticated ability to send crafted HTTP GET requests to the vulnerable endpoint (depending on how the application is deployed and protected).
- Trigger point: Supplying a specially crafted ID parameter value in a request to /worksheet/work_report.jsp so that it is incorporated into downstream SQL queries.
- Why exploitation is possible: The ID parameter is incorporated into SQL statements without consistent use of parameterized queries, proper escaping, or strict server-side validation, allowing attacker-controlled input to alter query structure.
Why this happens
This vulnerability stems from constructing SQL queries using string concatenation that incorporates raw HTTP GET parameters, mapping directly to CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').
The code likely treats the ID value as trusted and inserts it into a WHERE clause or similar context without using prepared statements or rigorous input validation.
As a result, special characters and control tokens within the user input are not neutralized and can change the logic of the executed SQL, rather than being handled as data.
The presence of CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component reflects the broader pattern of passing untrusted data into downstream interpreters (the database engine) without appropriate context-aware sanitization.
Potential impact
- Retrieval of database records that the current user or application role should not access.
- Modification, insertion, or deletion of data, potentially impacting business workflows and reporting integrity.
- Extraction of sensitive information such as user details, configuration data, or internal identifiers.
- Bypassing of application-level authorization checks through direct database-level access.
- In certain configurations, execution of database-specific commands that could affect availability or facilitate further compromise.
General mitigation guidance
Effective mitigation typically focuses on eliminating direct concatenation of user input into SQL and enforcing strict boundaries between data and code:
- Use parameterized queries or prepared statements for all database access paths, ensuring user input is always treated as data.
- Apply context-aware validation on incoming parameters such as ID, restricting them to expected formats (e.g., numeric or specific whitelists) before use.
- Centralize data access logic in a data access layer that enforces safe query construction patterns by default.
- Reduce privileges of the database account used by the application to the minimum required for its functions, limiting the impact of injected queries.
- Implement defense-in-depth with web application firewalls or API gateways that can detect and block common SQL injection patterns, while not relying on them as the sole control.
How teams detect issues like this
Detection typically combines code-level inspection with runtime monitoring:
- Perform static code analysis to search for SQL query construction that uses string concatenation with request parameters (especially ID-like fields) in JSPs and related classes.
- During code review, flag any manual assembly of SQL strings and require use of prepared statements or ORM query builders that separate parameters from query text.
- Use security testing tools (SAST/DAST) configured with rules for SQL injection signatures targeting Java/JSP stacks and HTTP parameter usage.
- Monitor database logs for anomalous queries containing suspicious patterns such as tautologies, stacked statements (where supported), or unusual comment syntax originating from web application accounts.
- Integrate automated security checks into CI/CD pipelines so new or changed endpoints that handle parameters like ID are scanned consistently.

