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.

