/

CVE-2026-68928

Severity:

HIGH RISK

(8.6)

Exposed Android Service (CWE-926) in Acode Terminal

CVE-2026-68928

Deferred

Vulnerability type

Category:

Improperly Exposed Android Component

CWE:

CWE-749, CWE-862, CWE-926

Impact:

Local Privilege Abuse and Command Execution

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

Acode exposes its Android terminal service without a binding permission or caller verification, allowing any installed application to invoke command execution through the service.

A zero-permission local application could run commands under Acode's identity and potentially access data, credentials, granted storage locations, and runtime-authorized resources.

Affected context

The vulnerability occurs in Acode's Android terminal plugin when the terminal service is declared as exported without a binding permission and does not authenticate callers. Deployments are at risk when an untrusted application can interact with the service and the service forwards caller-controlled command data to a shell-running process.

Exploit preconditions

  • Attack surface: An exported Android bound service provided by Acode
  • Required access: Installation and execution of another Android application; no special permission is required from the attacking application
  • Trigger point: A request to the terminal service that causes command execution
  • Why exploitation is possible: The service accepts requests from external applications without enforcing a binding permission or verifying the calling identity, then passes attacker-controlled command content to a shell through ProcessBuilder

Why this happens

The underlying issue is an Android component exposure combined with missing caller authorization. An exported service that lacks a signature-level binding permission or equivalent identity check can be invoked by unrelated applications, which maps to CWE-926: Improper Export of Android Application Components and CWE-862: Missing Authorization.

The service also exposes a dangerous operation: executing shell commands using input supplied by an untrusted caller. This behavior is consistent with CWE-749: Exposed Dangerous Method, because a remotely reachable application interface provides access to a high-impact capability without adequate access control.

Potential impact

  • An installed application could execute commands with Acode's UID
  • Attackers may read or alter Acode-private data
  • Remote service credentials stored or accessible by Acode could be exposed
  • Existing Storage Access Framework grants may be abused
  • Resources covered by Acode's runtime permissions could be accessed
  • The Acode application context could be used for further local privilege abuse

General mitigation guidance

Mitigation generally focuses on removing unnecessary external exposure and enforcing authorization before any sensitive operation is performed.

Common defensive patterns include:

  • Keeping sensitive services non-exported unless cross-application access is explicitly required
  • Protecting intentionally exported services with narrowly scoped, signature-level binding permissions
  • Verifying the caller identity and authorization state at every sensitive entry point
  • Avoiding shell invocation for application operations and using fixed, non-shell APIs instead
  • Replacing caller-controlled command strings with allowlisted operations and structured arguments
  • Applying least-privilege Android permissions and limiting access to private data and granted storage resources
  • Treating all interprocess requests as untrusted, including requests from installed applications

How teams detect issues like this

Detection can include static analysis and manifest reviews for exported services, receivers, providers, and activities that lack appropriate permissions. Code review should look for exported components that perform file access, shell execution, credential handling, or other privileged actions without caller validation.

Additional signals include use of ProcessBuilder or shell interpreters with interprocess input, missing checkCallingPermission-style checks, and exported services whose manifest declarations do not require a restrictive binding permission. Android security policy checks and automated mobile application review tools can help enforce these patterns in CI.

Sources

SourceLink
github.comgithub.com/Acode-Foundation/Acode/commit/0a5237a3b140562dac877868137a784d6531894d
github.comgithub.com/Acode-Foundation/Acode/pull/2442
github.comgithub.com/Acode-Foundation/Acode/releases/tag/v1.12.7
github.comgithub.com/Acode-Foundation/Acode/security/advisories/GHSA-wm94-wp33-43gx

Frequently asked

questions

No. It is primarily a local Android attack requiring a separate application to be installed on the same device. That application can interact with the exposed service without requiring additional special permissions.

The described attack does not require additional interaction at execution time after the malicious application has been installed and can communicate with the service.

Keep the terminal service private when external access is unnecessary. If external access is required, enforce a restrictive binding permission, verify the caller, and avoid executing arbitrary shell commands.

Review every exported Android component, require explicit authorization for sensitive operations, minimize application permissions, and use structured allowlisted APIs instead of shell interpreters for command execution.

Find out what's already
exploitable in your codebase.