Severity:

HIGH RISK

(7.3)

SQL Injection in Yonyou KSOA user_popedom.jsp

CVE-2026-1179

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 HTTP GET parameter handler of /kmf/user_popedom.jsp, where the folderid parameter is incorporated into database queries without sufficient sanitization.

A remote attacker can manipulate this parameter to inject arbitrary SQL, which may allow unauthorized data access, modification, or other database-level impacts when the affected endpoint is reachable.

Affected context

The vulnerability arises in web deployments of Yonyou KSOA 9.0 that expose the /kmf/user_popedom.jsp endpoint over HTTP/S.

The issue occurs when the folderid query parameter from incoming GET requests is used directly or with insufficient validation in SQL statements.

Environments where the application server can communicate with a backend database and where this JSP is accessible to users (authenticated or unauthenticated, depending on configuration) are within the affected context.

Exploit preconditions

  • Attack surface: Public or internal web interface exposing /kmf/user_popedom.jsp over HTTP/S.
  • Required access: Ability to send crafted HTTP GET requests to the vulnerable endpoint (network-level access to the application).
  • Trigger point: Processing of the folderid query parameter by server-side logic that builds and executes SQL queries.
  • Why exploitation is possible: The application appears to concatenate the folderid value directly into SQL statements without robust input validation or parameterization, allowing attacker-controlled SQL fragments to alter the intended query structure.

Why this happens

This issue is a classic instance of CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), and also relates to CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component.

The server-side logic that handles /kmf/user_popedom.jsp treats the folderid HTTP GET parameter as trusted and interpolates it into database queries, rather than using parameterized statements or strict input constraints.

As a result, special characters and SQL control tokens within the user input are not properly neutralized before being interpreted by the database engine, allowing the input to change the semantics of the executed SQL command.

Potential impact

  • Unauthorized reading of data from database tables that the application account can access.
  • Modification or deletion of records, potentially impacting integrity of business data and permissions.
  • Escalation of application-level privileges by manipulating access-control related tables.
  • Potential extraction of credential hashes or sensitive configuration data stored in the database.
  • In some environments, possible execution of database-native functions that could lead to further system compromise, depending on DBMS capabilities and privileges.

General mitigation guidance

Effective mitigation focuses on eliminating direct concatenation of user input into SQL and tightening input handling boundaries:

  • Prefer parameterized queries or prepared statements for all interactions involving the folderid parameter and any other user-controllable input.
  • Introduce strict server-side validation for folderid, aligning accepted values with business rules (e.g., numeric IDs, whitelisted patterns).
  • Apply centralized input normalization and encoding layers before data is passed to the database layer to reduce the risk of dangerous characters being interpreted as SQL syntax.
  • Enforce least-privilege on the database account used by the application so that, even if input validation fails, the impact of injected SQL is constrained.
  • Consider generic query-building abstractions or ORM layers that are secure-by-default and make raw SQL interpolation uncommon.

How teams detect issues like this

Organizations can approach detection of this vulnerability class using multiple complementary strategies:

  • Static analysis: Configure SAST tools to flag string concatenation or unparameterized SQL construction involving HTTP parameters, especially within JSPs and related data access layers.
  • Code review: During manual reviews, look for patterns where request parameters such as folderid flow directly into query strings or where input validation is absent or inconsistent.
  • Dynamic testing: Use automated or guided SQL injection testing (DAST) against /kmf/user_popedom.jsp and similar endpoints, monitoring for database errors, unexpected responses, or time-based anomalies.
  • Runtime monitoring: Enable query logging and anomaly detection at the database layer to spot unusual query patterns, concatenated literals from HTTP parameters, or errors indicative of injection attempts.

Sources

SourceLink
github.comgithub.com/LX-66-LX/cve/issues/19
vuldb.comvuldb.com/?ctiid.341773
vuldb.comvuldb.com/?id.341773
vuldb.comvuldb.com/?submit.734594

Frequently asked

questions

Exploitability depends on whether /kmf/user_popedom.jsp is reachable from the attacker's network location and whether additional authentication is required; however, once reachable, the public availability of exploit details reduces the skill barrier needed to leverage the flaw.

The description does not clarify authentication requirements, so it may vary by deployment. Some instances might expose the vulnerable endpoint to unauthenticated users, while others may require at least basic login; in either case, access to send crafted GET requests to the endpoint is necessary.

The most robust fix is to refactor all affected queries to use parameterized statements or prepared queries, combined with strict server-side validation of folderid (for example, enforcing integer-only semantics and rejecting unexpected input).

Establish development standards that mandate parameterized database access, centralize input validation, and integrate automated security checks (SAST/DAST) into the CI/CD pipeline so that new instances of unsafe query construction are detected before deployment.

Find out what's already
exploitable in your codebase.