Severity:

HIGH RISK

(7.3)

SQL Injection in Yonyou KSOA work_info.jsp Parameter

CVE-2026-1122

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized database 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 handling of /worksheet/work_info.jsp, where the ID parameter is incorporated into database queries without adequate sanitization.

A remote attacker can craft malicious requests that alter the intended SQL logic, which may lead to unauthorized data access, modification, or other database-level impacts when the vulnerable endpoint is exposed.

Affected context

The vulnerability occurs in Yonyou KSOA 9.0 within the /worksheet/work_info.jsp endpoint, specifically in how the application processes the ID parameter from HTTP GET requests.

The issue is present when user-supplied values are passed into SQL statements without proper parameterization or robust validation.

Systems are particularly at risk when this JSP endpoint is internet-accessible, tied to a privileged database account, or lacks compensating controls such as web application firewalls or strict network segmentation.

Exploit preconditions

  • Attack surface: HTTP interface, reachable over the network to the /worksheet/work_info.jsp resource.
  • Required access: No prior authentication is necessarily required if the endpoint is publicly reachable; exploitability depends on the surrounding access controls.
  • Trigger point: Submission of a crafted GET request where the ID parameter contains injected SQL fragments.
  • Why exploitation is possible: The application dynamically constructs SQL queries using the raw ID parameter without using safe parameter binding or sufficient input constraints, allowing user input to influence query structure rather than being treated strictly as data.

Why this happens

This issue stems from unsafe construction of SQL queries that directly embed user-controlled input from the ID GET parameter into the query string.

Rather than using prepared statements or parameterized queries, the backend logic appears to concatenate or interpolate the parameter into SQL text, aligning with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

Additionally, insufficient neutralization of special characters within the HTTP parameter (related to CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component) allows database control characters to be interpreted by the SQL engine, enabling attackers to modify query logic or chain additional SQL statements.

Potential impact

  • May allow attackers to read sensitive data from database tables beyond their intended scope.
  • Could enable modification or deletion of records, impacting integrity of business data and worksheets.
  • Can be used to escalate privileges within the application if user or role mappings are stored in the database.
  • Might permit extraction of password hashes, session tokens, or other authentication-related data that can be leveraged for further compromise.
  • In certain configurations, could be used to execute database-specific functions that interact with the underlying operating system, increasing the blast radius.

General mitigation guidance

Effective mitigation focuses on treating all external input as untrusted and preventing it from altering SQL structure.

Recommended defensive patterns include:

  • Adopting parameterized queries / prepared statements for all database access, ensuring that variables such as ID are always bound as parameters rather than concatenated into SQL strings.
  • Applying strict server-side validation and canonicalization to numeric identifiers, enforcing type, range, and format constraints so that only expected values are accepted.
  • Centralizing data access through a well-reviewed database access layer that disallows ad-hoc string-based query construction.
  • Minimizing database privileges for the application account so that even if a query is abused, it operates under least privilege.
  • Deploying context-aware input neutralization routines only as a complement to parameterization, not as the primary defense.
  • Placing network-level and application-layer protections (such as rules in a WAF or API gateway) to detect and block common SQL injection patterns and anomalous parameter values.

How teams detect issues like this

Detection efforts can focus on both code-level patterns and runtime behavior:

  • Static analysis: Use SAST tools or custom rules to flag string concatenation or unsafe interpolation used to build SQL statements, especially when parameters come from HttpServletRequest.getParameter() or similar sources.
  • Code review: During manual review, trace the flow of request parameters like ID from the JSP/controller layer into DAO or repository classes, looking for non-parameterized query construction.
  • Logging and monitoring: Enable structured logging of SQL errors, unusual query shapes, and repeated requests with suspicious ID values that contain SQL control characters.
  • Runtime protection: Utilize web application firewalls or RASP-like solutions with policies tuned to detect and block SQL injection payloads targeting /worksheet/work_info.jsp.
  • Security testing: Incorporate automated DAST and targeted penetration testing to probe query parameters for injection behavior as part of regular SDLC security gates.

Sources

SourceLink
github.comgithub.com/LX-66-LX/cve/issues/8
vuldb.comvuldb.com/?ctiid.341714
vuldb.comvuldb.com/?id.341714
vuldb.comvuldb.com/?submit.734549

Frequently asked

questions

Yes. As described, the attack may be initiated remotely whenever an attacker can reach the /worksheet/work_info.jsp endpoint over the network and supply crafted GET parameters.

That depends on the specific deployment and access controls around the vulnerable path. If /worksheet/work_info.jsp is reachable without login, no authentication is required. If it is behind a login, the attacker would need at least the lowest level of access that can reach that endpoint.

The most robust fix is to refactor database interactions to use parameterized queries or prepared statements for all uses of the ID parameter and any other user-supplied values, combined with strict server-side validation of parameter types and ranges.

Establish secure coding standards that mandate parameterized queries, provide vetted data access utility functions or ORM layers, incorporate automated static analysis in CI pipelines to flag unsafe query construction, and ensure regular security training and code review practices focused on input handling and database interactions.

Find out what's already
exploitable in your codebase.