Severity:

HIGH RISK

(7.3)

SQL Injection in Yonyou KSOA 9.0 HTTP GET Parameter Handler

CVE-2026-1178

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Database Compromise and Data Exfiltration

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/select.jsp, where the folderid parameter is incorporated into database queries without adequate neutralization.

A remote attacker can manipulate this parameter to interfere with application SQL logic, potentially accessing, modifying, or deleting backend data when the vulnerable endpoint is exposed.

Affected context

The vulnerability occurs in Yonyou KSOA 9.0 within the /kmf/select.jsp endpoint, specifically in the HTTP GET parameter handling logic for folderid.

It manifests when user-supplied input from query parameters is used to construct SQL statements directly, without consistent input validation or parameterization.

Environments where this endpoint is reachable over the network and tied to a privileged database account are most at risk.

Exploit preconditions

  • Attack surface: Public or internal web interface exposing /kmf/select.jsp over HTTP/HTTPS.
  • Required access: Ability to send crafted HTTP GET requests (no prior authentication may be required, depending on deployment).
  • Trigger point: Processing of the folderid query parameter by server-side logic that builds SQL statements.
  • Why exploitation is possible: The application concatenates or interpolates folderid into SQL queries without robust parameter binding or proper input neutralization, allowing an attacker-controlled value to alter the query structure.

Why this happens

The underlying flaw is the construction of SQL queries by directly embedding user-controlled data from the folderid HTTP GET parameter into SQL strings.

This aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), where input is not sanitized or parameterized before being sent to the database.

The presence of CWE-74 indicates that the application treats injected control characters or syntax elements as part of the SQL command rather than untrusted data, allowing an attacker to reshape the query logic.

Abstractly, this pattern reflects a trust boundary violation: treating external request parameters as safe to interpolate into backend commands.

Potential impact

  • Attackers could read sensitive data from database tables they would not normally be authorized to access.
  • Malicious users may insert, update, or delete records, leading to data tampering or loss.
  • The vulnerability can enable authentication bypass if credential or session data is stored in the affected database.
  • In some deployments, attackers might chain SQL injection with database-specific features to execute additional commands or pivot deeper into the environment.
  • Application availability may be impacted through destructive queries that corrupt or lock critical tables.

General mitigation guidance

Effective mitigation focuses on treating all external parameters as untrusted and ensuring they cannot influence SQL structure.

Recommended defensive patterns include:

  • Using parameterized queries or prepared statements for all database interactions, binding folderid and similar inputs as data rather than concatenating strings.
  • Applying centralized input validation to constrain folderid to expected formats (e.g., numeric identifiers or strict whitelists) before it reaches data access code.
  • Employing an abstraction or ORM layer that discourages manual SQL concatenation and enforces parameter binding by default.
  • Limiting database account privileges so that the application can only perform necessary operations on specific schemas and tables, reducing blast radius if injection occurs.
  • Adopting secure coding guidelines and code review checklists that explicitly prohibit dynamic SQL string building from raw HTTP parameters.

How teams detect issues like this

Organizations can detect this class of vulnerability using a combination of automated and manual techniques:

  • Static application security testing (SAST) rules to flag string concatenation or unescaped inclusion of HTTP parameters (like folderid) in SQL query construction.
  • Code review practices that trace data flow from request parameters to database APIs, looking for missing parameterization and validation.
  • Web application firewalls (WAF) or API gateways configured with signatures and anomaly detection for SQL injection patterns in query parameters.
  • Dynamic application security testing (DAST) that exercises endpoints such as /kmf/select.jsp with test payloads to identify SQL error responses or behavioral anomalies.
  • Logging and monitoring for unusual or malformed SQL queries, errors, or spikes in requests targeting parameters like folderid, which may indicate probing or exploitation attempts.

Sources

SourceLink
github.comgithub.com/LX-66-LX/cve/issues/18
vuldb.comvuldb.com/?ctiid.341772
vuldb.comvuldb.com/?id.341772
vuldb.comvuldb.com/?submit.734593

Frequently asked

questions

Yes, exploitation can typically be carried out remotely by sending crafted HTTP GET requests to the vulnerable /kmf/select.jsp endpoint, as long as it is reachable over the network.

In many configurations, only network access to the web application is required; no local access is needed, and authentication requirements depend on how the affected endpoint is protected in a given deployment.

The most robust fix pattern is to replace any dynamic SQL string concatenation with parameterized queries or prepared statements, combined with strict validation of parameters such as folderid and minimal database privileges for the application account.

Prevention typically involves adopting secure coding standards that mandate parameterization, integrating SAST/DAST into the CI/CD pipeline, performing regular security-focused code reviews, and enforcing architectural patterns that isolate and sanitize all external input before it touches the data access layer.

Find out what's already
exploitable in your codebase.