Summary
YunaiV yudao-cloud versions up to 2026.01 contain a SQL injection vulnerability in the /admin-api/system/tenant/get-by-website endpoint, where the Website parameter is incorporated into database queries without sufficient sanitization.
A remote attacker can craft malicious requests that manipulate the underlying SQL query, potentially leading to data exposure, data modification, or other unauthorized database actions when this endpoint is exposed.
Affected context
The issue occurs in deployments of YunaiV yudao-cloud (up to 2026.01) that expose the /admin-api/system/tenant/get-by-website endpoint.
The vulnerability is triggered when user-supplied data from the Website parameter is used to construct SQL statements without robust parameterization or encoding.
Environments where this administrative API is reachable over the network, such as publicly exposed admin interfaces or internally accessible admin gateways, are at heightened risk, especially if additional network or access controls are weak or absent.
Exploit preconditions
- Attack surface: HTTP(S) interface at /admin-api/system/tenant/get-by-website
- Required access: Ability to send requests to the affected endpoint (e.g., network reachability to the admin API; additional authentication requirements depend on deployment configuration)
- Trigger point: Submission of a crafted Website parameter containing SQL control characters or fragments
- Why exploitation is possible: The server-side implementation appears to concatenate or interpolate the Website value directly into a SQL query without using safe binding mechanisms or appropriate sanitization, enabling attacker-controlled alteration of the query structure.
Why this happens
The root cause aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') and is closely related to CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component.
In abstract terms, the application treats externally supplied input (the Website parameter) as if it were trusted, combining it directly into a database command string that is interpreted by the SQL engine.
Without strict separation between data and control instructions—via prepared statements, bound parameters, or equivalent mechanisms—the database engine cannot distinguish attacker-supplied data from query logic, allowing hostile input to reshape the executed SQL statement.
Potential impact
- Extraction of sensitive tenant or system data from the database, subject to the database user's privileges
- Modification or deletion of tenant records and related data
- Creation or alteration of accounts or configuration entries stored in the database
- Potential pivoting to other parts of the application that rely on the compromised data
- In some database configurations, execution of side-effect operations via SQL features (e.g., stored procedures or administrative functions)
General mitigation guidance
Effective mitigation generally focuses on eliminating direct string concatenation in SQL paths and tightening how untrusted input is handled:
- Prefer parameterized queries or ORM query builders that enforce a strict separation between SQL code and input values.
- Apply centralized input validation for parameters like Website, constraining them to expected formats (e.g., hostnames, domains, or URLs) and rejecting unexpected characters or patterns.
- Introduce server-side encoding or escaping only as a secondary line of defense, not as a replacement for parameterization.
- Limit database privileges of the account used by the affected component so that even if input is mishandled, the account cannot perform broad administrative operations.
- Reduce exposure of administrative or tenant management endpoints by placing them behind strong authentication, authorization, and network segmentation to narrow the reachable attack surface.
How teams detect issues like this
Organizations can detect and monitor for this kind of vulnerability through a combination of proactive and reactive techniques:
- Static analysis: Configure SAST tools or custom linters to flag dynamic SQL construction patterns where user-controlled parameters (e.g., HTTP query parameters like Website) flow directly into SQL strings.
- Code review: During manual review, look for endpoints that query by "website" or similar identifiers and check whether they use prepared statements or ORM methods instead of raw concatenated SQL.
- Dynamic testing: Use automated DAST tools or targeted penetration testing to inject typical SQL meta-characters (quotes, comment markers, boolean conditions) into the Website parameter and observe for anomalies, error messages, or altered responses.
- Runtime monitoring: Enable database and application logging that records anomalous queries, repeated error patterns, or unusual use of SQL functions, and correlate them with incoming requests to the vulnerable endpoint.

