Severity:

HIGH RISK

(7.3)

SQL Injection in Yonyou KSOA del_work.jsp HTTP GET Handler

CVE-2026-1120

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Data Exfiltration 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 issue in the HTTP GET parameter handler of /worksheet/del_work.jsp, where the ID parameter is incorporated into database queries without adequate sanitization.

An attacker who can send crafted HTTP requests to the affected endpoint may manipulate backend SQL queries, potentially leading to data access, modification, or other database-level impacts.

Affected context

The vulnerability appears in the web layer of Yonyou KSOA 9.0, specifically in the /worksheet/del_work.jsp component that processes HTTP GET requests.

The issue manifests when the ID query parameter is passed into SQL statements without sufficient validation or parameterization.

It is most relevant in deployments where this endpoint is network-accessible to untrusted or semi-trusted clients and where the associated database account has broad privileges.

Exploit preconditions

  • Attack surface: Exposed web endpoint at /worksheet/del_work.jsp over HTTP/HTTPS.
  • Required access: Ability to send HTTP GET requests to the application (no indication of prior authentication being required, though actual requirements may depend on deployment configuration).
  • Trigger point: Supplying a crafted value in the ID query parameter that is processed by the vulnerable SQL construction logic.
  • Why exploitation is possible: The ID parameter is concatenated or otherwise incorporated into SQL expressions without robust input validation, escaping, or use of parameterized queries, allowing attacker-controlled input to alter the intended query structure.

Why this happens

The underlying bug aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), and is also related to CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component.

At an abstract level, the application trusts user-supplied HTTP GET parameters and directly embeds them into SQL commands executed by the database layer.

Instead of enforcing strict typing and using parameterized statements, the code likely builds queries through string concatenation or equivalent mechanisms, creating a channel where SQL syntax from user input can change the logic of the query.

Potential impact

  • Attackers may extract sensitive data from the database, including business records or user-related information.
  • Attackers could modify or delete records, potentially impacting data integrity and application behavior.
  • Attackers might leverage SQL functions to escalate to additional privileges within the application or database.
  • Under certain configurations, SQL injection may be chained into OS-level impacts via database-specific features (e.g., file operations, extended procedures).
  • Application availability could be affected by crafted queries that cause resource exhaustion or lock contention.

General mitigation guidance

Effective mitigation centers on eliminating direct use of untrusted input in SQL commands and reducing the trust boundary between user input and database operations.

Common defensive patterns include:

  • Using parameterized queries or prepared statements for all database access involving user-controlled values.
  • Applying strict server-side validation and normalization of input parameters, enforcing expected types (e.g., numeric ID) and ranges.
  • Centralizing data access through well-reviewed data access layers or ORM frameworks that discourage raw string-based query construction.
  • Implementing least-privilege database accounts so that the application user has only the minimal required permissions.
  • Applying defense-in-depth measures such as query whitelisting, stored procedures with controlled parameters, and database-level security policies.

How teams detect issues like this

Organizations can pursue multiple, complementary strategies to detect issues of this type:

  • Static analysis: Use rules that flag dynamic SQL construction involving HTTP parameters (e.g., string concatenation with request.getParameter("ID") or similar) in JSPs and backend code.
  • Code review: Focus review on endpoints handling query parameters and building SQL statements, checking for parameterization and validation around ID fields and similar identifiers.
  • Dynamic testing: Employ automated DAST tools or manual penetration testing to send crafted payloads via the ID parameter to detect anomalous responses or error messages indicative of SQL injection.
  • Runtime monitoring: Configure application and database logging to flag unusual query patterns, syntax errors, or spikes in failed queries that may suggest attempted injection.
  • Policy enforcement: Adopt secure coding standards requiring prepared statements and integrate them into CI/CD checks and code quality gates.

Sources

SourceLink
github.comgithub.com/LX-66-LX/cve/issues/6
vuldb.comvuldb.com/?ctiid.341712
vuldb.comvuldb.com/?id.341712
vuldb.comvuldb.com/?submit.734535

Frequently asked

questions

Yes, assuming the affected /worksheet/del_work.jsp endpoint is reachable over the network, an attacker can exploit the vulnerability remotely by sending crafted HTTP GET requests.

The description does not clearly specify authentication requirements. Exploitability may depend on access control configurations; if the endpoint is publicly accessible without login, anonymous exploitation is plausible.

Replace any string-concatenated SQL involving the ID parameter (and other user inputs) with parameterized queries or prepared statements, accompanied by strict server-side validation that enforces the expected type and format of the parameter.

Establish and enforce secure coding standards that mandate parameterized database access, integrate static and dynamic security testing into the development lifecycle, and require security-focused code reviews for all endpoints handling user input and database operations.

Find out what's already
exploitable in your codebase.