/

CVE-2026-73331

Severity:

HIGH RISK

(7.1)

SQL Injection (CWE-89) in CamaleonCMS Slug Handler

CVE-2026-73331

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Sensitive Data Exposure and Database Integrity Compromise

Severity:

HIGH RISK

(7.1)

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

CamaleonCMS contains an authenticated SQL injection vulnerability in slug processing, where crafted input may be incorporated into an inadequately parameterized database query. An attacker with permission to create or edit posts could use this flaw to retrieve sensitive application data from the underlying SQLite database.

Affected context

The vulnerability occurs in CamaleonCMS deployments where users with post creation or editing privileges can submit slug values that reach database queries without effective parameterization. Risk depends on the affected application path being enabled, the attacker possessing the required authenticated role, and sensitive information being stored in accessible application tables.

Exploit preconditions

  • Attack surface: Authenticated post creation or editing functionality
  • Required access: A valid account with permission to create or modify posts
  • Trigger point: Processing and persistence of a crafted post slug
  • Why exploitation is possible: Slug input is incorporated into a database query without sufficiently separating data from SQL syntax
  • Backend context: The affected deployment uses SQLite and stores potentially sensitive records in application tables

Why this happens

The underlying bug is inadequate parameterization of a user-controlled slug value in a database query. When input is concatenated into SQL or otherwise interpreted as query syntax, an attacker may alter query logic through boolean-based or union-style injection techniques. This behavior maps to CWE-89, SQL Injection, because externally supplied data is not reliably treated as data-only by the database interface.

Potential impact

  • An attacker may extract administrative credentials or configuration values.
  • Sensitive application records may be disclosed.
  • Query results could be manipulated or combined with attacker-controlled data.
  • Database integrity could be affected if additional query capabilities are exposed.
  • The application may experience unauthorized access or follow-on compromise using recovered secrets.

General mitigation guidance

Mitigation generally centers on ensuring that all slug-derived database

operations use parameterized queries or safe query-builder abstractions.

Common defensive patterns include:

  • Separating SQL code from user-controlled values through bound parameters.
  • Applying allowlisted slug formats and length limits as a secondary control.
  • Avoiding dynamic SQL construction from request or model fields.
  • Restricting database and application account privileges to the minimum required.
  • Protecting stored credentials and configuration secrets with appropriate access controls and secret-management practices.
  • Returning generic database errors so query structure and sensitive details are not exposed.

How teams detect issues like this

Organizations can look for:

  • Static analysis findings involving string concatenation, interpolation, or formatting in SQL construction.
  • Code review signals where model fields or request parameters reach raw-query APIs.
  • Tests that verify parameters are bound rather than embedded in generated SQL.
  • Web and database logs containing anomalous slug values, SQL operators, comments, or unexpected query patterns.
  • Database monitoring and policy enforcement for excessive reads from credential or configuration tables.

Neutral automated code-review and application-security tools may help identify unsafe query construction, but findings should be validated against the actual data-access path.

Sources

SourceLink
enrik-m.github.ioenrik-m.github.io/posts/Camaleon-CMS-Vulnerabilties/#44-stored-xss-via-draft-post-title
github.comgithub.com/owen2345/camaleon-cms
vulncheck.comvulncheck.com/advisories/camaleoncms-authenticated-sql-injection-via-post-slug-field

Frequently asked

questions

It may be exploitable through the application's authenticated web interface when the affected post slug functionality is reachable and the attacker has the required role.

The attacker needs a valid account with privileges to create or edit posts. Anonymous access alone is not expected to satisfy this precondition.

Use parameterized queries or trusted query-builder APIs for every database operation, with input validation applied as an additional defense.

Combine secure data-access abstractions, least-privilege database permissions, focused code review, automated static analysis, and testing of authorization and input-handling paths.

Find out what's already
exploitable in your codebase.