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.jspover 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
folderidquery parameter by server-side logic that builds and executes SQL queries. - Why exploitation is possible: The application appears to concatenate the
folderidvalue 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
folderidparameter 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
folderidflow 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.jspand 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.

