Severity:

HIGH RISK

(7.3)

SQL Injection in Song-Li cross_browser details Endpoint

CVE-2026-5577

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Data Exposure and Data Integrity Compromise via SQL Injection

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

A SQL injection vulnerability in the details endpoint of Song-Li cross_browser allows attackers to manipulate the ID argument and inject arbitrary SQL into backend queries.

When this parameter is not safely handled, remote attackers may exfiltrate or tamper with data, or in some environments escalate the attack toward full system compromise.

Affected context

The vulnerability exists in the details endpoint implemented in flask/uniquemachine_app.py of the Song-Li cross_browser project.

It is triggered when the ID argument received over HTTP is used in SQL statements without adequate neutralization.

Any deployment where user-controlled request parameters are passed into database queries in this endpoint, especially in a rolling-release installation from the affected repository state, may be exposed.

Exploit preconditions

  • Attack surface: HTTP(S) interface exposing the details endpoint in flask/uniquemachine_app.py.
  • Required access: Remote network access to the application; no special privileges are implied from the description.
  • Trigger point: Supplying a crafted ID argument value in a request to the details endpoint.
  • Why exploitation is possible: The ID parameter is incorporated into SQL statements in an unsafe manner (for example via string concatenation or unparameterized formatting), allowing attacker-controlled input to alter the intended query structure.

Why this happens

The root cause aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

The backend code handling the details endpoint appears to embed the ID argument directly into an SQL query, likely as a string, without using parameterized queries or robust escaping.

This insecure pattern allows control characters such as quotes, operators, or comment markers to break out of the intended query context and inject additional SQL logic.

The association with CWE-74 (Improper Neutralization of Special Elements in Output) reflects the broader issue of failing to neutralize control characters before embedding untrusted data into a command or query language.

Potential impact

  • Reading sensitive data from database tables that the application account can access.
  • Modifying, inserting, or deleting records, leading to data loss or corruption.
  • Bypassing authentication or authorization checks implemented at the SQL layer.
  • In some configurations, executing database-specific functions that may lead to code execution or privilege escalation within the database environment.
  • Disrupting application availability by injecting queries that lock tables or alter schema.

General mitigation guidance

Effective mitigation focuses on treating all request parameters, including ID, as untrusted and ensuring they do not control SQL syntax:

  • Use parameterized queries or prepared statements consistently, binding the ID value as a typed parameter rather than concatenating it into the SQL string.
  • Apply strict input validation for identifiers and numeric IDs, enforcing expected formats (e.g., integer ranges, UUID patterns) and rejecting anything outside them.
  • Centralize database access through a data access layer or ORM that discourages ad-hoc string-built SQL and promotes safe query construction.
  • Limit database privileges for the application account to only the operations and tables that are strictly necessary, reducing blast radius if injection occurs.
  • Prefer secure-by-default coding patterns and frameworks that abstract direct SQL string handling where feasible.

How teams detect issues like this

Detection typically combines code-level and runtime approaches:

  • Static analysis: Configure SAST rules to flag dynamic SQL construction involving request parameters or Flask route arguments (such as request.args['ID'], request.form.get('ID'), or similar) that are passed into database APIs without parameter binding.
  • Code review signals: Look for string formatting (+, %, format, f-strings) or concatenation used to build SQL queries in flask/uniquemachine_app.py and related modules, especially where variables named id, ID, or route parameters appear.
  • Security testing: Use automated SQL injection scanners and targeted penetration tests against the details endpoint to identify anomalous responses or database errors indicating injectable points.
  • Policy enforcement: Introduce coding standards that require use of parameterized queries and enforce them via pre-commit hooks or CI checks, optionally using automated code review tools to continuously monitor for regressions.

Sources

SourceLink
github.comgithub.com/wing3e/public_exp/issues/24
vuldb.comvuldb.com/submit/783502
vuldb.comvuldb.com/vuln/355347
vuldb.comvuldb.com/vuln/355347/cti

Frequently asked

questions

It is remotely exploitable wherever the details endpoint is exposed over the network. Any attacker who can send HTTP requests to this endpoint and control the ID parameter may attempt SQL injection.

The description does not indicate an authentication requirement, so exploitation may be possible as an unauthenticated user if the endpoint is publicly accessible. If deployments restrict access or require login, those controls can raise the bar but do not eliminate the underlying flaw.

Refactor the affected code to use parameterized queries or an ORM so the ID value is always bound as a parameter, combined with strict validation of the expected ID format. Avoid any direct string concatenation or interpolation when building SQL queries.

Adopt a consistent defensive pattern: treat all inputs as untrusted, standardize on prepared statements, enforce input validation, and institutionalize these rules through coding guidelines, automated static analysis, and security-focused code reviews for all database interaction code.

Find out what's already
exploitable in your codebase.