Severity:

HIGH RISK

(7.3)

SQL Injection in YunaiV yudao-cloud get-by-website

CVE-2026-5147

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized Database Access and Manipulation

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

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.

Sources

SourceLink
gitee.comgitee.com/zhijiantianya/yudao-cloud/commit/bccf7c79e5f93f027a021172a18e8876cc6c1062
github.comgithub.com/NarcherAlter/Security_Note/blob/main/Vulnerability_Discovery/yudaoCloudv2026.01.md
github.comgithub.com/NarcherAlter/Security_Note/blob/main/Vulnerability_Discovery/yudaoCloudv2026.01.md#admin-apisystemtenantget-by-website
vuldb.comvuldb.com/cve/CVE-2026-5147
vuldb.comvuldb.com/submit/780191
vuldb.comvuldb.com/vuln/354181
vuldb.comvuldb.com/vuln/354181/cti

Frequently asked

questions

Yes. As described, an attacker can exploit the flaw remotely by sending crafted HTTP requests to the /admin-api/system/tenant/get-by-website endpoint, provided it is accessible from their network location.

The attacker needs network access to the admin API and any authentication or authorization that the deployment enforces on this endpoint. In some misconfigured environments, the endpoint may be reachable without strong authentication, which significantly increases the risk.

The most robust fix is to replace any dynamic SQL construction involving the Website parameter with parameterized queries or safe ORM methods, combined with strict validation of the parameter to ensure it conforms to the expected domain or URL format.

Establish coding standards that mandate use of parameterized queries for all database access, introduce automated static analysis to detect unsafe query construction, review new endpoints that interact with the database for input-handling weaknesses, and enforce least-privilege database accounts so that any single query path cannot cause disproportionate damage.

Find out what's already
exploitable in your codebase.