Severity:

HIGH RISK

(7.3)

SQL Injection in Yonyou KSOA work_report.jsp HTTP GET

CVE-2026-1124

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 /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.

Sources

SourceLink
github.comgithub.com/LX-66-LX/cve/issues/10
vuldb.comvuldb.com/?ctiid.341716
vuldb.comvuldb.com/?id.341716
vuldb.comvuldb.com/?submit.734551

Frequently asked

questions

Yes, if the /worksheet/work_report.jsp endpoint is accessible over the network, an attacker can exploit the vulnerability remotely by sending crafted HTTP GET requests with a malicious ID parameter.

The description suggests that exploitation can occur through direct HTTP interaction, but whether authentication is required depends on how access to /worksheet/work_report.jsp is configured in a particular deployment. If the page is publicly accessible or weakly protected, unauthenticated attacks are possible.

The most robust fix pattern is to refactor the affected data access code to use parameterized queries or prepared statements exclusively, combined with strict server-side validation of the ID parameter and other inputs, so that user-controlled data cannot alter SQL query structure.

Adopting secure coding standards that prohibit dynamic SQL string concatenation, enforcing use of ORMs or query builders with parameter binding, conducting regular security code reviews, and integrating automated static and dynamic analysis into the development lifecycle will significantly reduce the risk of future SQL injection vulnerabilities.

Find out what's already
exploitable in your codebase.