/

CVE-2026-30277

Severity:

HIGH RISK

(8.4)

Path Traversal / Arbitrary File Overwrite in TA/UTAX Mobile

CVE-2026-30277

Modified

Vulnerability type

Category:

Path Traversal / Arbitrary File Overwrite

CWE:

CWE-22

Impact:

Arbitrary Code Execution and 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

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.

Sources

SourceLink
github.comgithub.com/Secsys-FDU/AF_CVEs/issues/24
secsys.fudan.edu.cnsecsys.fudan.edu.cn/
triumph-adler.comtriumph-adler.com/ta-de-de/software/mobile-und-cloud/mobile-print

Frequently asked

questions

It can be, depending on how files reach the app. If attackers can deliver specially crafted files via remote channels (email, messaging, downloads, or network shares) that are then imported into the app, they may trigger the issue without physical access to the device.

The attacker generally needs the ability to influence the file being imported—its name, path, or metadata—or run a malicious app on the same device that shares a crafted file with the PDF Reader. Direct system-level access is not required if the app honors attacker-controlled file paths.

The strongest fix is to centralize file import handling so that all imported content is written into a dedicated, application-controlled directory using system-generated file names, after canonicalizing and validating paths. The application should never use external input to navigate directories or select write targets outside this sandbox.

Adopt a strict file handling model: treat all external paths and filenames as untrusted, validate and normalize them, confine writes to known safe directories, and regularly review file I/O code paths. Enforcing these patterns through shared utilities, code review checklists, and static analysis rules helps prevent new path traversal and arbitrary file write vulnerabilities.

Find out what's already
exploitable in your codebase.