/

CVE-2026-51106

Severity:

CRITICAL RISK

(9.3)

Denial of Service (CWE-400) in qTox Persistence Layer

CVE-2026-51106

Deferred

Vulnerability type

Category:

Denial of Service

CWE:

CWE-400, CWE-502

Impact:

Application Denial of Service

Severity:

CRITICAL RISK

(9.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 vulnerability in TokTok qTox v1.18.4's persistence serialization component can allow a local attacker to trigger a denial-of-service condition. The issue becomes risky when locally accessible persistence data or serialization paths can be influenced in a way that causes excessive resource consumption, unsafe object handling, or application failure.

Affected context

The issue occurs in qTox v1.18.4 within src/persistence/serialize.cpp, where application state or persistence-related data is serialized or deserialized. Exploitation depends on a local attacker being able to access the qTox environment and influence the relevant persistence input or execution path; the available description does not establish that the issue is remotely reachable.

Exploit preconditions

  • Attack surface: The local qTox persistence and serialization component
  • Required access: Local access sufficient to influence relevant application data, files, or execution conditions
  • Trigger point: Processing of affected persistence data in src/persistence/serialize.cpp
  • Why exploitation is possible: Crafted or otherwise problematic input may cause excessive resource consumption, application failure, or unsafe deserialization behavior

Why this happens

The underlying issue is an insufficiently constrained persistence-processing path that can allow attacker-influenced data to produce abnormal resource use or application termination. This maps primarily to CWE-400: Uncontrolled Resource Consumption, with CWE-502: Deserialization of Untrusted Data also relevant if serialized input is reconstructed without strict type, size, or structure controls. The insecure pattern is trusting persistence data beyond the boundary required for safe parsing and bounded processing.

Potential impact

  • The qTox application may become unresponsive or terminate unexpectedly
  • Local users may lose access to messaging or other application functions
  • Repeated triggering could consume excessive CPU, memory, storage, or processing time
  • Persistence data may be mishandled if unsafe deserialization behavior is involved

General mitigation guidance

Mitigation generally focuses on bounding resource use and reducing trust in persistence data.

Common defensive patterns include:

  • Applying strict size, depth, type, and complexity limits before processing serialized data
  • Using narrowly scoped serialization formats and safe deserialization APIs
  • Validating data against an explicit schema before constructing application objects
  • Handling malformed input through bounded error paths rather than unrestricted retries or recursion
  • Running the application with least privilege and limiting access to persistence files
  • Treating locally stored state as untrusted when it can be modified by other users or processes

How teams detect issues like this

Organizations can look for this class of issue through:

  • Static analysis rules for unsafe deserialization, unbounded recursion, unchecked allocation, and missing input-size limits
  • Code review of persistence parsers for attacker-controlled fields, recursive structures, and exception handling
  • Tests using malformed, oversized, deeply nested, and resource-intensive serialized inputs
  • Runtime monitoring for abnormal memory, CPU, file, or process behavior during state loading
  • Policy enforcement requiring schema validation and bounded parsing for persisted application data

Automated security review tools may help identify unsafe parser usage and missing resource constraints.

Sources

SourceLink
github.comgithub.com/TokTok/qTox/issues/706

Frequently asked

questions

The description identifies a local attacker, so exploitation generally requires local access to the qTox environment. Remote exploitation is not established by the available information.

An attacker would need enough local access to influence the persistence data or execution conditions processed by the affected serialization component.

Use bounded, schema-validated parsing and safe deserialization, while ensuring malformed input cannot cause excessive resource consumption or application termination.

Treat persisted state as untrusted, enforce limits on size and structural complexity, test malformed inputs, and apply least-privilege controls to application files and processes.

Find out what's already
exploitable in your codebase.