/

CVE-2026-30279

Severity:

HIGH RISK

(8.4)

Path Traversal / Arbitrary File Overwrite in My Location

CVE-2026-30279

Modified

Vulnerability type

Category:

Path Traversal / Arbitrary File Overwrite

CWE:

CWE-22

Impact:

Arbitrary File Overwrite leading to Code Execution or Information Exposure

Severity:

HIGH RISK

(8.4)

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

My Location Travel Timeline v11.80 contains an arbitrary file overwrite vulnerability in its file import functionality, where user-supplied paths are not safely constrained to expected locations.

Under certain conditions, an attacker can overwrite internal application files, which may lead to arbitrary code execution or exposure of sensitive information stored by the app.

Affected context

The vulnerability manifests in the file import feature of My Location Travel Timeline v11.80, where imported files are written to the device storage without robust validation of the target file path.

It is relevant in environments where the application processes user-controlled or externally supplied files, and where the underlying platform permits application-managed files to be overwritten.

The issue typically arises when path components from the imported file metadata or user input are used directly to construct filesystem paths inside the app's internal or shared storage.

Exploit preconditions

  • Attack surface: The file import mechanism of My Location Travel Timeline (e.g., import dialogs, share-to-app flows, or backup/restore features).
  • Required access: Ability to supply or influence the file being imported, including any embedded filename or path metadata the app uses during import.
  • Trigger point: Initiating the import operation so that the app writes data to a filesystem path derived (wholly or partially) from attacker-controlled input.
  • Why exploitation is possible: The import logic does not sufficiently constrain paths to a safe directory, allowing traversal or crafted paths that point to sensitive or executable files within the app's accessible filesystem area.

Why this happens

This vulnerability is rooted in improper restriction of filesystem paths when handling user-influenced input, aligning with CWE-22: Improper Limitation of a Pathname to a Restricted Directory.

The import code likely uses attacker-controlled values (such as filenames, relative paths, or URIs) directly or with incomplete sanitization to form output paths, without enforcing canonical checks or strict directory whitelisting.

As a result, crafted paths may escape the intended import directory and target arbitrary locations within the app's accessible storage, including critical configuration, data, or executable-related files that influence runtime behavior.

Potential impact

  • Overwriting configuration or state files that can alter application behavior.
  • Overwriting files that the app later interprets or executes, potentially leading to arbitrary code execution in the app's context.
  • Corrupting or deleting user location history or travel data by overwriting associated files.
  • Overwriting files that contain sensitive information, leading to indirect data leakage (e.g., via error logs, backups, or debug output).
  • Facilitating further privilege or data access escalation if overwritten files are trusted by other components.

General mitigation guidance

Effective mitigation focuses on strict path handling and controlled write locations in the import flow:

  • Constrain all imported file writes to a fixed, application-controlled directory and never incorporate raw user input into directory components.
  • Use canonicalization (e.g., resolving .. segments and symbolic links) and verify that the resulting path remains within an expected base directory before writing.
  • Normalize and sanitize filenames by stripping path separators, reserved characters, and unexpected prefixes; use server- or app-generated filenames where possible instead of trusting client-supplied ones.
  • Treat imported content as untrusted data, not as code or configuration; avoid loading or executing content directly based on file type or extension alone.
  • Apply least-privilege principles to file access, ensuring the app writes only where strictly necessary and avoids shared or globally sensitive directories.

How teams detect issues like this

High-level detection and review approaches include:

  • Static analysis: Configure rules to flag uses of user-controlled input in file path construction, especially where concatenation or interpolation feeds into file write APIs.
  • Code review: Examine import and backup/restore code paths for directory traversal risks, paying attention to any use of ../, absolute paths, or unvalidated URI/filename fields.
  • Security testing: Perform focused file import tests with crafted filenames and paths to observe whether writes can escape the intended directory.
  • Policy enforcement: Introduce development guidelines requiring explicit path canonicalization and directory whitelisting for all file operations that originate from user or external input.

Sources

SourceLink
github.comgithub.com/Secsys-FDU/AF_CVEs/issues/28
lightapp3.firebaseapp.comlightapp3.firebaseapp.com/
secsys.fudan.edu.cnsecsys.fudan.edu.cn/

Frequently asked

questions

It can be, depending on how the app receives imported files. If an attacker can cause the app to import a crafted file remotely (for example via shared links, inter-app communication, or cloud-synced content), exploitation does not require physical access to the device.

The attacker must be able to control or significantly influence the file being imported, including its name or path-like metadata that the app uses when writing to storage. No direct system-level privileges are required beyond whatever the app itself already has.

Constrain all write operations to a fixed, canonical base directory, generate filenames on the server or within the app rather than trusting user input, and validate that any computed path stays within the allowed directory before performing file writes.

Establish a standard file-handling pattern that always normalizes paths, enforces directory whitelisting, and treats all external input as untrusted. Integrate static analysis and security review steps specifically focused on file I/O paths into the development and CI processes.

Find out what's already
exploitable in your codebase.