Back to skill

Security audit

tiktok-android-720p

Security checks for vulnerabilities and agentic risk

Overview

This TikTok automation skill mostly matches its stated purpose, but its publish and input-handling behavior can delete phone videos or execute unintended commands on a connected Android device.

Install only after reviewing the code and preferably after removing the publish-mode camera cleanup, adding strict input validation for ADB shell commands, and replacing executable config.py/plaintext .env secret handling. Do not run publish mode on a personal phone or logged-in account containing media you care about unless the deletion behavior has been fixed and you have backups.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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
Findings (6)

T09 · Insecure Skill Coding Practices

Error
Location
tiktok_bot.py:445
Finding
Android Shell Command Injection Through the Video URL<![CDATA[ ## Vulnerability Details **File Location**: `tiktok_bot.py:445-455` **Vulnerability Type**: OS command injection through an ADB shell command **Risk Level**: High ### Vulnerable Code ```python if video_url.startswith("http://") or video_url.startswith("https://"): # Download video from URL print(f"\n📥 Downloading video from URL...") # Use unique timestamp filename for identification timestamp = int(time.time()) device_video_path = f"/sdcard/DCIM/Camera/video_{timestamp}.mp4" # Use curl to download directly to device curl_result = subprocess.run( ["adb", "-s", device_id, "shell", f"curl -L -o {device_video_path} '{video_url}'"], capture_output=True, timeout=300 # 5 minutes for download ) ``` ### Technical Analysis The `--video` argument is accepted as an arbitrary string. When it begins with `http://` or `https://`, it is interpolated into a command string that is passed to Android's shell through `adb shell`. Using a list for the host-side `subprocess.run()` invocation does not prevent this vulnerability because the final list element is explicitly interpreted by the remote Android shell. The URL is enclosed in single quotes, but embedded single quotes are neither rejected nor escaped. An attacker can terminate the quoted URL and append additional shell commands. The scheme-prefix check is not a security boundary. A malicious value can begin with `https://` and still contain shell syntax later in the string. ### Attack Path 1. The attacker gains the ability to invoke the CLI or influence the `--video` argument. 2. The attacker supplies an HTTPS-prefixed value containing a single quote followed by shell operators and an Android command. 3. `publish_mode()` embeds the value into the device-side `curl` command. 4. `adb shell` passes the resulting string to Android's command interpreter. 5. The injected command executes with the privileges granted to the ADB shell user. For example, the ...[truncated 819 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not construct device-side shell commands from user-controlled URLs. 2. Download the media on the host with a maintained HTTP client using: - An explicit `https` scheme allowlist. - Connection and read timeouts. - Redirect limits. - Maximum response-size limits. - Content-type and media-format validation. 3. Save the response to a securely created host-side temporary file and transfer it with argument-based `adb push`. 4. If device-side downloading is unavoidable, reject all shell metacharacters and apply robust shell quoting rather than manually surrounding the value with quotes. 5. Consider restricting remote hosts to an administrator-defined allowlist. 6. Add tests using quotes, semicolons, command substitutions, newlines, and other shell metacharacters. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
src/bot/android/tiktok_navigation.py:64
Finding
Android Shell Command Injection Through Search Topics<![CDATA[ ## Vulnerability Details **File Location**: `src/bot/android/tiktok_navigation.py:64-76`; command execution helper at `src/bot/android/tiktok_android_bot.py:46-59` **Vulnerability Type**: OS command injection through an ADB shell command **Risk Level**: High ### Vulnerable Code ```python # Use direct ADB input for search query escaped_query = query.replace(' ', '%s') log.debug(f"[Navigation] Using direct ADB input: {escaped_query}") # Try direct input self.bot._adb_shell(f'input text {escaped_query}') time.sleep(2) # Wait for input to appear ``` The helper executes the entire value through Android's shell: ```python def _adb_shell(self, command: str, timeout: int = 10) -> str: """Execute ADB shell command.""" try: result = subprocess.run( ["adb", "-s", self.device_id, "shell", command], capture_output=True, text=True, timeout=timeout ) return result.stdout.strip() ``` ### Technical Analysis Search topics originate from the command-line `--topics` argument and reach `search_query()` without a restrictive validation step. Replacing spaces with `%s` is an input-method formatting transformation, not shell escaping. It leaves shell metacharacters such as semicolons, quotes, command substitutions, redirection operators, and newlines available for interpretation. Because `_adb_shell()` sends the complete string to `adb shell`, Android's command interpreter can treat attacker-controlled portions of the topic as additional commands. ### Attack Path 1. The attacker invokes search mode or controls a topic supplied to it. 2. A crafted topic containing Android shell syntax is passed through `args.topics`. 3. `search_query()` only replaces spaces with `%s`. 4. The crafted topic is concatenated with `input text`. 5. `_adb_shell()` submits the complete command to `adb shell`. 6. Android's shell interprets the injected operators and executes the appended command. ### Impact As ...[truncated 472 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Apply strict allowlist validation to search terms before they reach ADB. Permit only the characters genuinely needed for TikTok searches, such as letters, digits, spaces, hyphens, and selected Unicode ranges. 2. Reject shell metacharacters, control characters, and newlines. 3. Avoid sending dynamically assembled command strings to `adb shell`. 4. Centralize all ADB input handling in a helper that validates and safely encodes text. 5. Add unit tests for semicolons, quotes, backticks, `$()`, redirection operators, backslashes, and newline characters. 6. Treat values loaded from configuration files and campaign scripts as untrusted in addition to direct CLI values. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
setup.py:224
Finding
Arbitrary Host-Side Python Execution Through Generated Configuration<![CDATA[ ## Vulnerability Details **File Location**: `setup.py:224-227`; generated configuration is imported at `tiktok_bot.py:62-68` **Vulnerability Type**: Python source-code injection **Risk Level**: Critical ### Vulnerable Code ```python else: # AI config_content += f''' # AI Configuration AI_PROVIDER = "{ai_config['provider']}" AI_MODEL = "{ai_config['model']}" # Comment generation prompt AI_COMMENT_PROMPT = """ Analyze this video screenshot and generate a natural, engaging comment. ``` The generated file is later imported as executable Python: ```python try: from config import TOPICS, COMMENT_STYLE # Import based on comment style if COMMENT_STYLE == "static": from config import COMMENTS_BY_TOPIC, GENERIC_COMMENTS else: # AI mode from config import AI_PROVIDER, AI_MODEL, AI_COMMENT_PROMPT, GENERIC_COMMENTS ``` ### Technical Analysis The setup wizard accepts an arbitrary model name through `ask_text()` and directly interpolates it into executable Python source between double quotes. No Python-string serialization or allowlist validation is applied. A model value containing a quote and newline can terminate the intended assignment and inject additional Python statements. The generated `config.py` is subsequently imported by `tiktok_bot.py`; importing a Python module executes its top-level statements. This is host-side execution, making it more severe than the Android-only command-injection findings. ### Attack Path 1. The attacker interacts with the setup wizard or influences the entered AI model value. 2. The attacker supplies a model string that closes the quoted assignment and inserts Python statements. 3. `save_config()` writes the resulting content to `config.py`. 4. The main program imports `config.py`. 5. Python executes the injected top-level statements with the privileges of the user running the bot. A payload can conceptually use this structure: ```text model-name" <attacker-controlled Python st ...[truncated 630 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not store user configuration as executable Python. 2. Replace `config.py` with a non-executable format such as JSON or TOML and parse it as data. 3. Validate provider and model values against explicit allowlists maintained for each supported service. 4. If Python generation must temporarily remain, serialize every inserted string with `repr()` or `json.dumps()` rather than placing raw values inside quotes. 5. Write the configuration atomically to avoid partial or attacker-raced files. 6. Review all other values included in generated source, including topics and comment templates. 7. Add tests containing quotes, triple quotes, backslashes, newlines, comments, and Python statements. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
tiktok_bot.py:427
Finding
Publish Mode Deletes Unrelated Camera Videos<![CDATA[ ## Vulnerability Details **File Location**: `tiktok_bot.py:427-441` **Vulnerability Type**: Destructive operation beyond least-privilege requirements **Risk Level**: High ### Vulnerable Code ```python # Step 0: Clean up all videos in DCIM/Camera folder print(f"\n🧹 Cleaning up all videos in DCIM/Camera...") # Delete all video files except .thumbnails folder subprocess.run( ["adb", "-s", device_id, "shell", "rm -f /sdcard/DCIM/Camera/*.mp4"], capture_output=True, timeout=10 ) subprocess.run( ["adb", "-s", device_id, "shell", "rm -f /sdcard/DCIM/Camera/*.3gp"], capture_output=True, timeout=10 ) print(f"✅ All videos cleaned") ``` ### Technical Analysis Before validating, downloading, or uploading the requested media, publish mode unconditionally deletes every MP4 and 3GP file in the device's standard camera directory. The deletion is not limited to files created by this project or the current session. Publishing one video does not require deleting unrelated personal media. The implementation therefore exceeds the minimum access and destructive scope needed for the declared operation. The deletion is also performed before the requested source is validated. Consequently, an invalid path, failed download, or later publishing error can still leave the user's existing media deleted. ### Attack Path 1. A user connects an Android device with USB debugging enabled. 2. The device contains personal MP4 or 3GP files under `/sdcard/DCIM/Camera`. 3. The user or another process invokes publish mode. 4. The cleanup commands execute immediately. 5. All matching camera videos are removed, even if the new video fails to download or publish. No command-injection exploit is required; invoking the documented publish operation is sufficient. ### Impact Assessment The operation can cause irreversible loss of all matching videos in the connected device's camera directory. The scope includes content unrelated to this project, such as personal ...[truncated 257 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the wildcard cleanup entirely. 2. Create a dedicated, application-owned directory on shared storage for media staged by this project. 3. Generate and track the exact path of each file created during the current operation. 4. Delete only that exact tracked file after publishing. 5. Validate the source and complete the transfer before performing any cleanup. 6. Require explicit, prominent confirmation before any operation that could remove user-created media. 7. Implement failure-safe cleanup in a `finally` block that only targets project-created files. 8. Verify paths canonically before deletion and reject paths outside the dedicated staging directory. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
setup.py:255
Finding
AI API Keys Are Written to a Plaintext File Without Enforced Restrictive Permissions<![CDATA[ ## Vulnerability Details **File Location**: `setup.py:255-275` **Vulnerability Type**: Insecure local secret storage **Risk Level**: Medium ### Vulnerable Code ```python # Save AI API key to .env if AI mode if comment_style == "ai" and ai_config: env_content = "" if os.path.exists(".env"): with open(".env", 'r') as f: env_content = f.read() key_name = { "anthropic": "ANTHROPIC_API_KEY", "openai": "OPENAI_API_KEY", "openrouter": "OPENROUTER_API_KEY" }[ai_config['provider']] # Remove existing key if present lines = [l for l in env_content.split('\n') if not l.startswith(f"{key_name}=")] lines.append(f"{key_name}={ai_config['api_key']}") with open(".env", 'w') as f: f.write('\n'.join(lines)) print(f"✓ Saved API key to .env") ``` ### Technical Analysis The setup process writes the provider API key directly to a plaintext `.env` file. It does not explicitly set owner-only permissions, perform a symlink check, or create the file atomically. For a newly created file, effective permissions depend on the host's umask. If the file already exists, opening it with mode `w` truncates it but generally preserves its prior permissions. An existing broadly readable file can therefore remain broadly readable after the API key is written. The code also states that the file will not be committed, but the reviewed write path does not itself enforce source-control exclusion. ### Attack Path 1. The user selects AI comment mode and enters an API key. 2. The setup wizard writes the secret to `.env`. 3. The file is created or retained with permissions that may allow unintended local access. 4. Another local account, process, backup mechanism, or accidental repository operation obtains the file. 5. The exposed key is used against the configured AI provider until revoked. A local attacker could also attempt to prepare a malicious filesystem object at `.env` before setup if direc ...[truncated 522 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Prefer an operating-system credential store or a dedicated secrets manager. 2. If file storage is required, create the file atomically with mode `0600`. 3. Refuse to follow symbolic links and verify that the destination is a regular file owned by the current user. 4. Correct permissions on an existing file before writing secrets. 5. Add `.env` to a committed `.gitignore` file and provide a pre-commit secret scan. 6. Avoid printing or logging key values. 7. Document key rotation and revocation procedures. 8. Consider loading secrets exclusively from process environment variables in production deployments. ]]>

T08 · Insecure Dependencies

Warning
Location
requirements.txt:1
Finding
Dependencies Are Installed Without Upper Bounds, Locking, or Integrity Hashes<![CDATA[ ## Vulnerability Details **File Location**: `requirements.txt:1-3` **Vulnerability Type**: Uncontrolled dependency resolution and supply-chain exposure **Risk Level**: Medium ### Vulnerable Code ```text loguru>=0.7.0 anthropic>=0.18.0 openai>=1.12.0 ``` ### Technical Analysis Each dependency uses only a minimum-version constraint. A future installation can therefore resolve to versions that were not reviewed with this project, including releases with breaking behavior or newly introduced vulnerabilities. The requirements file also contains no integrity hashes or lock data. Package authenticity is delegated entirely to the configured Python package index and transport environment. No evidence was found that the listed package names are typosquatted or intentionally malicious. The confirmed issue is the lack of reproducible and integrity-checked dependency resolution, not a confirmed compromise of the named packages. ### Attack Path 1. A user runs `pip install -r requirements.txt`. 2. The resolver selects the newest versions satisfying the lower bounds. 3. A future vulnerable, compromised, or incompatible release is selected without a project review. 4. Package installation or import exposes the host process to the affected dependency behavior. A separate package-index compromise, malicious mirror, or dependency-account takeover would increase the likelihood of this path. ### Impact Assessment Potential impact depends on the behavior of a selected dependency release. Python dependencies execute in the bot's host process and can therefore access: - Files available to the invoking user. - Environment variables, including AI API keys. - Network resources available to the host. - The project runtime and connected ADB devices. This finding alone does not demonstrate current arbitrary code execution or a known malicious installed version. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin dependencies to versions reviewed and tested by the project. 2. Generate a lock file containing transitive dependencies. 3. Require package hashes during installation, such as through a hash-locked requirements file. 4. Install only from trusted package indexes over authenticated TLS. 5. Run dependency vulnerability and license scanning in continuous integration. 6. Review release notes and security advisories before updating pins. 7. Use an automated update process that opens reviewable pull requests rather than accepting arbitrary future releases. 8. Test dependency updates in an isolated environment before deployment. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (65)

Tool Parameter Abuse

High
Category
Tool Misuse
Content
### 发布流程

1. **清理相册** → `rm -f /sdcard/DCIM/Camera/*.mp4`
2. **下载/上传** → curl 或 adb push
3. **媒体扫描** → `MEDIA_SCANNER_SCAN_FILE` 广播
4. **选择视频** → 点击第一个帧
Confidence
98% confidence
Finding
The documented command `rm -f /sdcard/DCIM/Camera/*.mp4` performs broad deletion of all MP4 files in a common camera directory on the device. In the context of an ADB automation skill operating on a real user's phone, this is dangerous because it can irreversibly remove unrelated personal videos, and the README presents it as part of the normal workflow without strong safeguards or scoping.

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding
This finding includes a materially dangerous, undeclared destructive behavior: publish mode reportedly deletes existing .mp4/.3gp files under /sdcard/DCIM/Camera. In the context of an Android automation skill, undocumented destructive file cleanup can cause irreversible loss of user media and is especially risky because the skill already normalizes shell/ADB access and automated actions.

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding
This finding includes a materially dangerous, undeclared destructive behavior: publish mode reportedly deletes existing .mp4/.3gp files under /sdcard/DCIM/Camera. In the context of an Android automation skill, undocumented destructive file cleanup can cause irreversible loss of user media and is especially risky because the skill already normalizes shell/ADB access and automated actions.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
This finding includes a materially dangerous, undeclared destructive behavior: publish mode reportedly deletes existing .mp4/.3gp files under /sdcard/DCIM/Camera. In the context of an Android automation skill, undocumented destructive file cleanup can cause irreversible loss of user media and is especially risky because the skill already normalizes shell/ADB access and automated actions.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
This finding includes a materially dangerous, undeclared destructive behavior: publish mode reportedly deletes existing .mp4/.3gp files under /sdcard/DCIM/Camera. In the context of an Android automation skill, undocumented destructive file cleanup can cause irreversible loss of user media and is especially risky because the skill already normalizes shell/ADB access and automated actions.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
This finding includes a materially dangerous, undeclared destructive behavior: publish mode reportedly deletes existing .mp4/.3gp files under /sdcard/DCIM/Camera. In the context of an Android automation skill, undocumented destructive file cleanup can cause irreversible loss of user media and is especially risky because the skill already normalizes shell/ADB access and automated actions.

Credential Access

High
Category
Privilege Escalation
Content
# Ask for API key
    print(f"\n📝 Enter your {provider_name.upper()} API key")
    print("(This will be stored in .env file, not committed to git)")
    
    api_key = ask_text(f"API key")
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
# Ask for API key
    print(f"\n📝 Enter your {provider_name.upper()} API key")
    print("(This will be stored in .env file, not committed to git)")
    
    api_key = ask_text(f"API key")
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
# Save AI API key to .env if AI mode
    if comment_style == "ai" and ai_config:
        env_content = ""
        if os.path.exists(".env"):
            with open(".env", 'r') as f:
                env_content = f.read()
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
# Save AI API key to .env if AI mode
    if comment_style == "ai" and ai_config:
        env_content = ""
        if os.path.exists(".env"):
            with open(".env", 'r') as f:
                env_content = f.read()
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
# Save AI API key to .env if AI mode
    if comment_style == "ai" and ai_config:
        env_content = ""
        if os.path.exists(".env"):
            with open(".env", 'r') as f:
                env_content = f.read()
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
lines = [l for l in env_content.split('\n') if not l.startswith(f"{key_name}=")]
        lines.append(f"{key_name}={ai_config['api_key']}")
        
        with open(".env", 'w') as f:
            f.write('\n'.join(lines))
        
        print(f"✓ Saved API key to .env")
Confidence
91% confidence
Finding
This line writes the user-supplied API key into a plaintext .env file, which can expose credentials to other local users, backups, shell tooling, or accidental inclusion in project artifacts if file hygiene is poor. In the context of a bot that integrates paid AI providers, compromise of the API key can lead to unauthorized API usage, billing abuse, and indirect access to prompts or generated content.

Description-Behavior Mismatch

High
Confidence
97% confidence
Finding
`publish_video` claims to publish a caller-specified local file but ignores `video_path` and instead selects the first album item on the device. That mismatch can cause unintended or sensitive media to be posted, which is especially dangerous in a social-media automation skill where publication is externally visible and difficult to undo.

Intent-Code Divergence

High
Confidence
98% confidence
Finding
The docstring states that `video_path` determines the video to publish, but the implementation never uses it. This deceptive interface can mislead upstream automation into believing a safe asset is being posted when the bot may actually publish unrelated gallery content, creating a serious integrity and privacy risk.

os.system() or os exec-family call

High
Category
Dangerous Code Execution
Content
response = input("Run interactive setup now? [Y/n]: ").strip().lower()
    if response in ['', 'y', 'yes']:
        print("\nStarting setup wizard...\n")
        os.system("python3 setup.py")
        if not os.path.exists("config.py"):
            print("\n❌ Setup was not completed. Exiting.")
            sys.exit(1)
Confidence
85% confidence
Finding
The script executes `python3 setup.py` via `os.system`, which invokes an external file from the current working directory without validating its path or integrity. If a user runs this tool from an untrusted directory or the setup script is replaced, arbitrary local code will execute under the user's privileges.

Description-Behavior Mismatch

High
Confidence
99% confidence
Finding
The skill claims TikTok interaction and publishing, but publish mode silently performs bulk deletion of device camera videos beforehand. That undisclosed destructive capability materially increases risk because operators may not realize the tool can erase unrelated user media on the connected phone.

Missing User Warnings

High
Confidence
99% confidence
Finding
Publish mode deletes all videos in the device camera folder without any confirmation prompt. Because this is a destructive operation on user-owned media, lack of explicit confirmation materially increases the chance of accidental irreversible loss.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
print(f"\n🧹 Cleaning up all videos in DCIM/Camera...")
        # Delete all video files except .thumbnails folder
        subprocess.run(
            ["adb", "-s", device_id, "shell", "rm -f /sdcard/DCIM/Camera/*.mp4"],
            capture_output=True,
            timeout=10
        )
Confidence
99% confidence
Finding
Using `rm -f /sdcard/DCIM/Camera/*.mp4` through ADB is tool abuse because it applies a broad wildcard deletion to a sensitive user media directory. In context, a TikTok publishing workflow does not need blanket deletion of all camera videos, so this creates disproportionate destructive capability.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
timeout=10
        )
        subprocess.run(
            ["adb", "-s", device_id, "shell", "rm -f /sdcard/DCIM/Camera/*.3gp"],
            capture_output=True,
            timeout=10
        )
Confidence
99% confidence
Finding
This repeats the same destructive pattern for `.3gp` files, enabling mass deletion of user recordings. The skill context makes it more dangerous because users may connect a personal phone expecting TikTok automation, not media wiping.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The README documents destructive behavior in publish mode, including clearing album content and deleting media after posting, without prominent warnings about data loss scope. In a skill that automates ADB commands on a real device, insufficient disclosure can cause users to unintentionally erase local media or publish/delete the wrong files.

Intent-Code Divergence

Medium
Confidence
95% confidence
Finding
L483-L488 的完整示例展示了 `interact --videos 3 --like --favorite --comment --topics travel`,并声称会先搜索 travel 再互动。可是在 L210-L213 与 L215-L221,README 明确说明互动模式从推荐页开始,且 `--topics` 仅适用于 search_mode,这构成了文档内部对代码/行为意图的直接矛盾。

Lp3

Medium
Category
MCP Least Privilege
Confidence
89% confidence
Finding
The skill documents capabilities that imply shell, environment-variable, and file access but does not declare any tool scope or permission boundaries. In an agent setting, this creates an authorization gap: consumers cannot tell what tools the skill expects, and a host may expose broader capabilities than intended.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The AI comment feature says Claude/GPT-4/OpenRouter may perform visual analysis of video content, but the document does not warn that screenshots, frames, or metadata could be transmitted to third-party AI providers. In this context, the skill handles potentially sensitive personal or copyrighted content, so lack of a privacy disclosure meaningfully increases user exposure.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The publish workflow states that it will 'clean the album' and later 'clean up' without a prominent warning about deletion impact. In a mobile-device context, destructive media deletion can remove personal content unrelated to the automation task, making this a genuine safety/security issue even if the intent is operational convenience.

subprocess module call

Medium
Category
Dangerous Code Execution
Content
device_id = os.environ.get("ANDROID_DEVICE_ID")
    if not device_id:
        # Auto-detect first connected device
        result = subprocess.run(["adb", "devices"], capture_output=True, text=True)
        devices = [line.split()[0] for line in result.stdout.split("\n")[1:] if line.strip() and "device" in line]
        if not devices:
            print("❌ No Android device found. Connect device and enable USB debugging.")
Confidence
70% confidence
Finding
subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Static analysis

No suspicious patterns detected.