/

CVE-2026-79570

Severity:

CRITICAL RISK

(9.8)

SQL Injection (CWE-89) in mfish-nocode-pro DB API Endpoint

CVE-2026-79570

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Unauthorized Database Access and Sensitive Data Disclosure

Severity:

CRITICAL RISK

(9.8)

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

A critical SQL injection vulnerability in mfish-nocode-pro v1.0.0 affects the tableName parameter at /sys/dbConnect/data. An attacker who can reach the endpoint may submit crafted input to alter database queries and access sensitive database information.

Affected context

The vulnerability occurs in deployments running mfish-nocode-pro v1.0.0 where the /sys/dbConnect/data endpoint accepts a user-controlled tableName parameter. Risk exists when that parameter is incorporated into database operations without sufficient structural validation or safe query construction.

Exploit preconditions

  • Attack surface: The /sys/dbConnect/data HTTP endpoint
  • Required access: Network access to the endpoint; authentication requirements depend on the deployment configuration
  • Trigger point: Processing the tableName parameter during database query construction
  • Why exploitation is possible: User-controlled input may influence SQL syntax rather than being restricted to an approved table identifier

Why this happens

The underlying bug is an unsafe boundary between user input and SQL query construction. When a parameter such as tableName is concatenated into a query or otherwise permitted to influence SQL structure without strict allowlisting, an attacker may alter the intended statement.

This behavior maps to CWE-89: Improper Neutralization of Special Elements used in an SQL Command, commonly known as SQL injection.

Potential impact

  • Attackers may read sensitive database records
  • Confidential application, user, or configuration data could be disclosed
  • Database queries may be altered or expanded beyond their intended scope
  • Data integrity could be affected if write-capable operations are reachable
  • Compromised database credentials or records may enable further attacks

General mitigation guidance

Mitigation generally focuses on ensuring that user input cannot define SQL syntax or unrestricted database objects.

Common defensive patterns include:

  • Using parameterized queries for values and strict allowlists for identifiers such as table names
  • Mapping external table identifiers to fixed internal names rather than accepting arbitrary names
  • Applying server-side schema and format validation before database access
  • Enforcing least-privilege database accounts with only the required permissions
  • Separating read and write capabilities where feasible
  • Limiting endpoint exposure and requiring appropriate authentication and authorization

How teams detect issues like this

Detection approaches may include:

  • Static analysis for string concatenation or interpolation in SQL construction
  • Code review checks for request parameters used as table, column, or query fragments
  • Dynamic testing with safe SQL injection test cases in controlled environments
  • Web application firewall or API policy rules for suspicious query-manipulation patterns
  • Database monitoring for unusual query structures, metadata enumeration, or unexpected access patterns
  • Automated security review tools that identify unsafe database APIs and missing input constraints

Sources

SourceLink
github.comgithub.com/fangtang7/CVE/blob/main/mfish-nocode/sql.md

Frequently asked

questions

It may be remotely exploitable when the affected endpoint is network-accessible and an attacker can submit requests that reach the vulnerable parameter.

Not necessarily. The required access depends on how the endpoint is exposed and whether authentication and authorization controls are enforced.

Use parameterized queries for data values and strict server-side allowlists or fixed mappings for identifiers such as table names.

Combine secure query APIs, centralized input validation, least-privilege database accounts, endpoint authorization, code review, and automated security testing.

Find out what's already
exploitable in your codebase.