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.

