Summary
TA/UTAX Mobile Print v3.7.2.251001 contains an arbitrary file overwrite vulnerability in its PDF Reader file import functionality, enabling attackers to overwrite internal application files.
When an attacker can control imported file paths or locations, this flaw may lead to arbitrary code execution or unintended exposure of sensitive data.
Affected context
The vulnerability occurs within the PDF Reader component of the TA/UTAX Mobile Print application when handling imported files.
It is relevant in environments where:
- Users can import or share files into the app from external sources (e.g., storage, messaging, cloud providers)
- The application derives target file locations from attacker-controlled or partially controlled input
- The app has permissions to write to internal or shared storage locations where critical files reside
The issue manifests when the import mechanism does not robustly constrain write locations to a safe directory or sanitize path elements.
Exploit preconditions
- Attack surface: File import / open-with / share-to-PDF-Reader interface, or any API that allows the app to ingest external files.
- Required access: Ability to supply a crafted file name or import path (often achievable by a local user, malicious app on the device, or attacker controlling a file source).
- Trigger point: User or system initiates file import into the TA/UTAX Mobile Print PDF Reader.
- Why exploitation is possible: The application uses unvalidated path information and allows writes based on attacker-influenced locations, enabling traversal outside the intended directory and overwriting internal or configuration files.
Why this happens
The underlying bug aligns with CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal').
The PDF Reader's import logic appears to:
- Accept a file path or name from an external source
- Compose a destination path for storage or processing
- Write the file without enforcing that the destination remains within an application-controlled directory
Without canonicalization, normalization, and strict whitelisting of allowed directories, attackers can introduce traversal sequences or crafted paths that cause the application to overwrite internal assets, configuration files, or executable components.
Potential impact
- Overwriting configuration or settings files that can be reinterpreted as executable logic, which may lead to arbitrary code execution within the app's context
- Corrupting internal application resources, resulting in denial of service or undefined behavior
- Overwriting log or cache files to manipulate application state or conceal activity
- Overwriting files in shared storage that may expose or destroy other users' documents
- Replacing files that are later synchronized or backed up, extending the impact beyond the device
General mitigation guidance
Effective mitigation focuses on strictly constraining file write locations and decoupling user-controlled data from path construction:
- Enforce a hardcoded, application-controlled root directory for all imported files and never allow callers to influence parent directories.
- Canonicalize and normalize paths before use, then verify that the result stays within an approved directory using allowlist checks.
- Avoid trusting file names or paths from external sources; sanitize characters, strip traversal sequences, and map external names to internally generated identifiers.
- Use per-file or per-user subdirectories with least-privilege permissions to limit blast radius if a write is abused.
- Treat configuration and executable-related directories as read-only at runtime where possible, and segregate them from areas where imported content is stored.
How teams detect issues like this
Detection typically involves both code-centric and behavioral approaches:
- Static analysis: Rules that flag dynamic file writes where the path includes user input, URI-derived components, or unvalidated external metadata.
- Code review: Look for file import flows that concatenate user-controlled strings to filesystem paths without normalization and boundary checks.
- Policy enforcement: Development guidelines requiring centralized file handling utilities that encapsulate safe path resolution and disallow ad hoc writes.
- Runtime monitoring (where applicable): Instrumentation or logging around file writes to sensitive directories, with alerting when application processes modify unexpected locations.
Automated mobile security testing tools and SAST engines often include checks for path traversal and arbitrary file write patterns and can be integrated into CI pipelines.

