Back to skill

Security audit

Mobile Appium Test

Security checks for vulnerabilities and agentic risk

Overview

The skill is for legitimate Android Appium testing, but it presents broad Appium relaxed-security mode as a normal setup step without enough warning or scoping.

Install only if you are comfortable with Appium/ADB controlling a USB-authorized Android device. Prefer starting Appium on 127.0.0.1 without `--relaxed-security`, enable only specific insecure features if truly required, avoid exposing port 4723, stop the server after testing, and avoid running the global npm install with administrator privileges.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (2)

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:43
Finding
Appium Server Runs with Broad Relaxed-Security Features Enabled<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 43 and 64 **Vulnerability Type**: Unsafe Appium security configuration **Risk Level**: High ### Vulnerable Code ```markdown | Start with relaxed security | `appium --relaxed-security` | ``` ```bash appium --address 127.0.0.1 --port 4723 --relaxed-security ``` ### Technical Analysis The documented workflow starts Appium with the global `--relaxed-security` option. This option enables Appium features that are disabled by default because they can expose security-sensitive functionality. The ordinary workflow described by the Skill—creating sessions, locating UI elements, capturing screenshots, retrieving page source, and collecting logs—does not establish a requirement for blanket relaxed security. Binding Appium to `127.0.0.1` limits direct remote network exposure, but it does not protect the server from malicious or compromised local processes, unauthorized local users, untrusted automation clients, or browser-originated requests that can reach loopback services. The configuration also becomes more dangerous if a user later changes the bind address, places Appium behind a proxy, or forwards the port. ### Attack Path 1. A user follows the Skill and starts Appium with `--relaxed-security`. 2. An attacker-controlled local process or another client capable of reaching `127.0.0.1:4723` connects to the Appium service. 3. The attacker creates or takes control of an Appium session associated with the USB-connected Android device. 4. The attacker invokes security-sensitive Appium functionality made available by relaxed-security mode. 5. The attacker performs unauthorized operations against the connected device or its applications within the permissions available to Appium and ADB. The path requires access to the Appium endpoint; the loopback binding reduces, but does not eliminate, this prerequisite. ### Impact Assessment Successful exploitation can permit unauthorized control over Appium ...[truncated 659 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove `--relaxed-security` from both the quick-reference command and the standard workflow. - Use the secure default command: ```bash appium --address 127.0.0.1 --port 4723 ``` - If a particular restricted feature is essential, identify it explicitly and enable only that feature through Appium's granular feature allow-list mechanism rather than enabling all insecure features. - Continue binding the service to the loopback interface unless remote access is strictly required. - Restrict access to the Appium host and run the service under a dedicated, minimally privileged operating-system account. - Do not expose port 4723 through network forwarding or a reverse proxy without authentication, authorization, and transport security. - Terminate Appium sessions and stop the server immediately after testing. - Document which restricted feature is required, why it is necessary, and what additional device privileges it exposes. ]]>

T08 · Insecure Dependencies

Note
Location
SKILL.md:20
Finding
Unpinned Global npm Package Installation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, line 20 **Vulnerability Type**: Unpinned third-party dependency installed globally **Risk Level**: Low ### Vulnerable Code ```bash npm install -g @appium/doctor ``` ### Technical Analysis The installation command does not specify a reviewed package version. Consequently, npm resolves whichever release is current when the command is executed, making the installation non-reproducible and allowing upstream changes to alter the code that runs without any corresponding change to the Skill. npm packages may execute lifecycle scripts during installation. Because this package is installed globally, those scripts execute with the installing user's privileges and can modify globally accessible tooling or files writable by that user. The package name is consistent with the declared Appium workflow, and the audit found no evidence that it is intentionally malicious; the risk arises from unpinned supply-chain execution and global installation scope. ### Attack Path 1. A future package release or its dependency tree is compromised, maliciously modified, or introduces unsafe installation behavior. 2. A user follows the Skill and runs the unpinned global installation command. 3. npm downloads the affected current release rather than a previously reviewed version. 4. Package lifecycle code executes with the privileges of the user running npm. 5. The malicious or compromised code accesses data or modifies files available to that user and may alter globally installed development tools. Exploitation depends on an upstream package or dependency compromise, or an unsafe future release. ### Impact Assessment The package and its lifecycle scripts can obtain the privileges of the account executing npm. Potentially affected resources include user-owned files, environment-accessible credentials, development configuration, npm configuration, and globally installed packages. If the command is run with elevated pri ...[truncated 203 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin the dependency to a specifically reviewed version, for example: ```bash npm install -g @appium/doctor@<reviewed-version> ``` - Prefer a project-local development dependency governed by a committed lockfile instead of a global installation. - Install packages from the expected npm registry and verify package provenance and integrity before use. - Review the pinned package's lifecycle scripts and dependency tree. - Avoid running npm with administrator or root privileges. - Periodically update the pinned version through a controlled review and testing process rather than resolving the latest release automatically. ]]>
Vulnerability Patterns
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (2)

Tool Parameter Abuse

High
Category
Tool Misuse
Content
| Send keys | `POST /session/{id}/element/{id}/value` |
| Take screenshot | `GET /session/{id}/screenshot` |
| Get page source | `GET /session/{id}/source` |
| Quit session | `DELETE /session/{id}` |

## Typical Workflow
Confidence
80% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Missing User Warnings

Medium
Confidence
98% confidence
Finding
The skill explicitly recommends starting Appium with `--relaxed-security`, which weakens Appium's security controls and can enable access to insecure or sensitive features if the server is reachable by other local users or the network. In a testing skill this may be operationally convenient, but presenting it as a standard step without any warning, scope limitation, or safer default increases the chance of unsafe deployment.

Static analysis

No suspicious patterns detected.