/

CVE-2026-45060

Severity:

CRITICAL RISK

(9.8)

Blind SQL Injection (CWE-89) in ClipBucket v5 API

CVE-2026-45060

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Database Compromise and Sensitive Data Exfiltration

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

ClipBucket v5 contains a blind SQL injection flaw in the actions/progress_video.php endpoint that allows arbitrary database queries through the ids parameter.

Because the endpoint is accessible without authentication, any remote user can exploit the issue to infer and exfiltrate sensitive data from the application's database under typical deployments.

Affected context

The vulnerability occurs in ClipBucket v5 deployments where the actions/progress_video.php endpoint is exposed to users, including anonymous visitors.

It manifests when user-controlled input from the ids parameter is concatenated into SQL statements without proper parameterization or validation.

Environments that directly expose this endpoint over the internet, rely on the underlying database for user credentials or video metadata, and lack compensating controls (such as strict WAF rules) are at higher risk.

Exploit preconditions

  • Attack surface: HTTP(S) requests to the actions/progress_video.php endpoint.
  • Required access: None; the endpoint can be reached by unauthenticated remote users.
  • Trigger point: Supplying crafted values in the ids parameter when calling the vulnerable endpoint.
  • Why exploitation is possible: The application embeds untrusted ids input directly into SQL queries (or fails to bind it safely), enabling attackers to modify query logic and perform blind inference by observing response behavior or timing.

Why this happens

This issue is rooted in classic SQL injection, where application logic builds SQL statements using string concatenation or unsafe interpolation with user-supplied values.

Instead of using parameterized queries with bound variables, the code path handling ids in actions/progress_video.php appears to trust input to be well-formed, causing the database engine to interpret attacker-controlled fragments as part of the query structure.

This aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command, in which meta-characters (quotes, operators, or comment markers) in input are not neutralized, allowing query manipulation and data extraction through blind techniques.

Potential impact

  • Attackers may infer and exfiltrate sensitive user data, including email addresses, profile details, and authentication-related information stored in the database.
  • Database contents such as video metadata, access control information, and configuration records could be enumerated and disclosed.
  • Integrity of stored data can be affected, as queries may be altered to insert, update, or delete records.
  • Broader application compromise may occur if configuration secrets, password hashes, or session data in the database are leveraged to escalate access.
  • In some deployments, chained attacks could enable full takeover of the ClipBucket instance or underlying infrastructure.

General mitigation guidance

Effective mitigation centers on treating all external inputs as untrusted and ensuring that data never controls SQL query structure.

Common defensive patterns include:

  • Using parameterized queries (prepared statements) and bound parameters for all database interactions, especially those influenced by request parameters like ids.
  • Applying strict input validation and normalization on numeric or identifier fields so they conform to expected formats and ranges before reaching the data access layer.
  • Centralizing database access through a well-reviewed abstraction layer that disallows dynamic query construction with raw user input.
  • Enforcing least privilege on database accounts so that even if queries are abused, access is limited to only the data and operations required by the application.
  • Complementing code-level fixes with generic protections such as query-allowlisting or rules in database proxies or application firewalls to reduce exposure to similar flaws.

How teams detect issues like this

Detection typically involves a combination of automated and manual techniques:

  • Static analysis can flag dynamic SQL construction patterns, string concatenation involving request parameters, and query builders that bypass parameter binding.
  • Code reviews should focus on controllers and endpoints that handle request parameters, checking for direct interpolation of values like ids into query strings.
  • Runtime security testing and fuzzing, including automated SQL injection scanners, can probe endpoints for behavioral differences and timing variations indicative of blind SQL injection.
  • Logging and monitoring can be tuned to highlight anomalous query patterns, unexpected errors, or high volumes of requests to database-backed endpoints.
  • Policy enforcement in CI/CD, such as blocking merges when insecure SQL patterns are detected by linters or SAST tools, helps prevent reintroduction of similar issues.

Sources

SourceLink
github.comgithub.com/MacWarrior/clipbucket-v5/security/advisories/GHSA-wpq3-gxx7-c76h

Frequently asked

questions

Yes. Because the affected endpoint can be accessed without authentication, a remote attacker can exploit the blind SQL injection purely via crafted HTTP requests, assuming the endpoint is reachable over the network.

No prior credentials are required. The attacker only needs network access to the ClipBucket instance exposing the actions/progress_video.php endpoint to send malicious requests using the ids parameter.

The most robust fix is to refactor all queries influenced by ids to use parameterized statements with strict typing, ensuring user input is treated solely as data. This should be combined with disciplined input validation and a prohibition on building SQL with string concatenation.

Adopting secure coding standards that mandate prepared statements, adding automated checks for dynamic SQL, and conducting regular security-focused code reviews and testing help prevent recurrences. Training developers on injection risks and enforcing least-privilege database access also reduces the impact of any future mistakes.

Find out what's already
exploitable in your codebase.