/

CVE-2026-75336

Severity:

CRITICAL RISK

(9.8)

SQL Injection (CWE-89) in Funiture Tool Interfaces

CVE-2026-75336

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Unauthorized Database Access and Data Manipulation

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

Funiture 1.0.0 contains SQL injection vulnerabilities in the /sys/tool/select.json and /sys/tool/update.json backend interfaces. An unauthenticated or otherwise authorized attacker may manipulate database queries, depending on deployment controls and how these endpoints process user input.

Affected context

The vulnerability occurs in Funiture 1.0.0 backend tool interfaces that construct or execute database queries using request-controlled data. Risk is highest when these endpoints are reachable by untrusted users and input values are incorporated into SQL statements without reliable parameterization or equivalent query isolation.

Exploit preconditions

  • Attack surface: HTTP requests to /sys/tool/select.json or /sys/tool/update.json
  • Required access: Network reachability and any authentication or authorization required by the deployment
  • Trigger point: Processing of attacker-influenced request parameters by the backend database operation
  • Why exploitation is possible: Input may affect SQL query structure when it is not consistently bound as data through parameterized database APIs

Why this happens

The underlying bug is an SQL injection condition, mapped to CWE-89, in which externally influenced input can alter the intended structure or logic of a database statement. This generally results from dynamically assembling SQL with untrusted values, incomplete escaping, or inconsistent use of parameterized queries and query builders.

Potential impact

  • An attacker may read unauthorized database records
  • An attacker could modify or delete stored data through update-related operations
  • Sensitive application or user information may be disclosed
  • Database integrity and application availability could be affected
  • Compromised database credentials or excessive privileges could increase downstream impact

General mitigation guidance

Mitigation typically focuses on ensuring that all database operations treat request data strictly as values rather than executable query structure.

Common defensive patterns include:

  • Use parameterized queries, prepared statements, or safely configured query builders
  • Apply allowlisted validation for fields that influence identifiers, sorting, or operation selection
  • Reduce input trust by enforcing server-side schemas and rejecting unexpected parameters
  • Avoid constructing SQL through string concatenation or interpolation
  • Run the application database account with only the privileges required by each function
  • Separate read and write capabilities where practical and protect administrative tool interfaces with strong authorization

How teams detect issues like this

Organizations commonly detect SQL injection risks through:

  • Static analysis rules identifying SQL string concatenation or interpolation with request data
  • Code review checks for direct use of query parameters in database statements
  • Dynamic testing of backend endpoints with benign injection-oriented test cases in authorized environments
  • Web application firewall or API gateway policies that flag suspicious query-manipulation patterns
  • Database monitoring for unusual query structures, access patterns, or unexpected write activity
  • Automated security review tools that identify missing parameterization and weak endpoint authorization

Sources

SourceLink
github.comgithub.com/fangtang7/CVE/blob/main/funiture/SQL%20Injection.md

Frequently asked

questions

It may be remotely exploitable when either backend endpoint is network-accessible and the attacker can submit requests accepted by the application.

The available description does not establish the authentication requirements. Exploitability depends on whether the interfaces are public, protected by authentication, or restricted through network and authorization controls.

Use parameterized queries or trusted query-builder abstractions for every database operation, and validate non-value inputs such as field names or sort options against strict allowlists.

Combine secure database APIs, least-privilege database accounts, endpoint authorization, code review, static analysis, and authorized security testing in the development lifecycle.

Find out what's already
exploitable in your codebase.