/

CVE-2026-30284

Severity:

HIGH RISK

(8.6)

Arbitrary File Overwrite / External File Name or Path

CVE-2026-30284

Modified

Vulnerability type

Category:

Arbitrary File Overwrite / External File Name or Path Control

CWE:

CWE-73

Impact:

Arbitrary Code Execution and Information Exposure

Severity:

HIGH RISK

(8.6)

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

UXGROUP LLC Voice Recorder v10.0 contains an arbitrary file overwrite vulnerability in its file import process, allowing attacker-controlled files to replace internal application or system files.

When an attacker can influence which paths are written during import, this behavior can be abused to execute arbitrary code or expose sensitive information stored in overwritten or newly created files.

Affected context

The vulnerability occurs in the Voice Recorder application's file import mechanism, where external files are brought into the application workspace.

It is relevant in deployments where:

  • Users can import files from untrusted or semi-trusted locations (e.g., downloads, shared folders, removable media), and
  • The application writes imported content to internal directories without adequately constraining or normalizing the target path.

The issue manifests when the import process allows the file name or path, directly or indirectly controlled by the attacker, to influence where on disk the file is written.

Exploit preconditions

  • Attack surface: The Voice Recorder file import feature (GUI or any automated/import API it exposes).
  • Required access: Ability to supply or select files for import, often via local user interaction or a delivery channel that gets the victim to import attacker-crafted files.
  • Trigger point: The moment the application processes the import request and writes the provided file content to disk.
  • Why exploitation is possible: The application trusts file names or paths derived from external input and uses them to construct destination paths without enforcing strict directory constraints, normalization, or collision protection for internal files.

Why this happens

This issue stems from improper control of file paths that the application uses when saving imported content.

Instead of confining imported files to a dedicated, sanitized directory with fixed naming rules, the import logic appears to:

  • Accept file names or paths influenced by external sources, and
  • Use these values when building the target path for saving, without robust validation to prevent overwriting of internal or sensitive files.

This maps to CWE-73: External Control of File Name or Path, where untrusted input dictates which file is created or modified.

Potential impact

  • Overwriting application configuration or state files, which may lead to arbitrary code execution when the application later loads or executes the modified content.
  • Overwriting user data files, resulting in loss of integrity or availability of recorded audio.
  • Overwriting log files or temporary files, potentially erasing forensic evidence or altering application behavior.
  • Creating or replacing files in predictable locations that may be read or executed by other components, leading to broader system compromise.
  • Exposing sensitive information if overwritten files alter permission settings or trigger unintended disclosure through the application UI or other processes.

General mitigation guidance

Effective mitigation focuses on constraining where and how imported files are written, and decoupling external input from file system decisions:

  • Enforce strict storage directories: Always write imported files into a dedicated, application-controlled directory that is not influenced by user-supplied paths.
  • Normalize and validate paths: Canonicalize any file paths and reject those containing directory traversal sequences, absolute paths, or references outside the approved directory tree.
  • Control file naming: Generate internal file names (e.g., UUIDs or application-assigned names) rather than using user-supplied names directly; optionally maintain a separate metadata mapping.
  • Protect sensitive files: Maintain and enforce a denylist or allowlist of protected paths, ensuring that import logic cannot collide with configuration, executable, or system files.
  • Harden file permissions: Store application data with least-privilege filesystem permissions so that even if a file is created or overwritten, it cannot be trivially executed with elevated privileges.

How teams detect issues like this

Organizations can detect this class of vulnerability using a combination of review and automated checks:

  • Static analysis patterns: Flag code that writes files using paths derived from UI input, configuration, or external data without validation or canonicalization.
  • Code review signals: Look for file import routines that:
  • Concatenate user-supplied strings into filesystem paths,
  • Write to shared or top-level directories, or
  • Fail to constrain writes to a specific storage directory.
  • Runtime monitoring: Instrument file I/O to detect unexpected writes to configuration, executable, or system directories during normal import workflows.
  • Policy enforcement: Integrate secure coding guidelines into CI pipelines, requiring explicit review for any new code that creates or overwrites files based on external input; automated tools can assist in scanning for risky file operations.

Sources

SourceLink
appcraze.coappcraze.co/
github.comgithub.com/Secsys-FDU/AF_CVEs/issues/25
secsys.fudan.edu.cnsecsys.fudan.edu.cn/

Frequently asked

questions

It can be, depending on how files are imported. If an attacker can supply files over a remote channel (e.g., network shares, email attachments, or integrated cloud storage) and convince a user or process to import them, the vulnerability may be exploited without direct local access.

The attacker needs the ability to influence the imported file and its name or path. In many scenarios this requires only user-level access or social engineering to get a victim to import a crafted file.

The most robust fix is to remove any dependence on externally influenced paths for deciding where files are written. Use application-assigned file names and enforce that all imported content is stored inside a strictly controlled directory, with thorough path normalization and validation.

Adopt a strict design rule that external input must never directly control file names or paths, codify this in coding standards, and use static analysis plus code review checklists to verify that all file-writing routines apply path constraints, canonicalization, and least-privilege storage conventions.

Find out what's already
exploitable in your codebase.