Back to skill

Security audit

browser-use AI浏览器自动化

Security checks for vulnerabilities and agentic risk

Overview

This browser-automation skill has a coherent purpose, but it asks users to run mutable remote installers and handle authenticated browser/profile state without enough scoping or confirmation safeguards.

Review this skill carefully before installing. Use pinned package versions and commit-specific URLs, inspect any downloaded script before running it, avoid curl | sh, and do not sync or reuse your personal browser profile unless you understand exactly what authentication data is shared. Use a dedicated browser profile and require manual confirmation before purchases, form submissions, uploads, email sending, or account changes.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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 (4)

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:220
Finding
Unverified Remote Script Is Executed Directly by the Shell<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 220-221 **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: Critical ### Vulnerable Code ```bash curl -fsSL https://browser-use.com/profile.sh | \ BROWSER_USE_API_KEY=XXXX sh ``` ### Technical Analysis The documented command retrieves a shell script from an external URL and passes the response directly to `sh`. The script is not pinned to an immutable release, inspected before execution, or validated using a cryptographic signature or known digest. Consequently, the payload that executes can differ from the content available when the Skill was audited. Compromise of the remote server, domain, DNS resolution, CDN, deployment pipeline, or upstream script could turn this command into an arbitrary code-execution channel. Supplying `BROWSER_USE_API_KEY` to the new shell also makes that credential available to the downloaded script. ### Attack Path 1. An attacker compromises or gains control over `browser-use.com/profile.sh` or an infrastructure component serving it. 2. The attacker replaces the expected script with a malicious shell payload. 3. A user follows the Skill documentation and executes the command. 4. `curl` retrieves the attacker-controlled response. 5. The response is passed directly to `sh` without verification. 6. The payload runs with the privileges of the invoking user and can read the supplied API key and other user-accessible resources. ### Impact Assessment Successful exploitation permits arbitrary command execution with the invoking user's privileges. Depending on those privileges, the payload could: - Read or modify user files. - Exfiltrate the supplied Browser Use API key and other accessible credentials. - Access browser profiles and authenticated session data. - Install additional software or persistence mechanisms. - Modify Agent configuration and trusted Skill files. - Use authenticated services available to the affected account. ...[truncated 151 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the direct `curl | sh` execution pattern. - Publish the script as a versioned, immutable release artifact. - Download the artifact to a staging location before execution. - Verify a documented SHA-256 digest or a trusted cryptographic signature. - Display or otherwise make the downloaded script available for review before execution. - Require explicit user approval after verification and before invoking the shell. - Avoid exposing the API key to the installer unless strictly necessary. - Run the script in a restricted environment with the minimum required filesystem and network access. - Document credential rotation and revocation procedures if the script or delivery infrastructure is compromised. ]]>

T08 · Insecure Dependencies

Error
Location
SKILL.md:43
Finding
Unpinned Package and Skill Commands Execute Mutable Third-Party Releases<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 43, 46, 57, 160, 163, 166, and 294 **Vulnerability Type**: Insecure dependency execution **Risk Level**: High ### Vulnerable Code ```bash uvx browser-use install uvx browser-use init --template default npx clawhub@latest install browser-use uvx browser-use init --template default uvx browser-use init --template advanced uvx browser-use init --template tools npx clawhub@latest install browser-use-mcp ``` ### Technical Analysis The documented `uvx` commands can retrieve and execute Python package entry points without an exact audited version or package digest. The `npx clawhub@latest` commands explicitly request the mutable latest version of the package. No lockfile, immutable version, package hash, signature, or independent integrity check is specified. The effective code can therefore change after the Skill has been reviewed. Package-account compromise, registry compromise, malicious dependency updates, or compromised transitive dependencies could cause arbitrary code to execute during package invocation or installation. This differs from the direct remote-script issue because the payload is delivered through package and Skill distribution channels rather than directly through an external shell script. ### Attack Path 1. An attacker compromises a relevant registry package, publisher account, release process, or transitive dependency. 2. The attacker publishes a malicious release that satisfies the unpinned package request. 3. A user executes one of the documented `uvx` or `npx ...@latest` commands. 4. The package manager resolves and downloads the malicious or compromised version. 5. Package entry-point, lifecycle, installation, or CLI code executes locally. 6. The malicious package acts with the invoking user's privileges or installs attacker-controlled Skill content. ### Impact Assessment A compromised package can potentially: - Execute arbitrary commands as the invoking user. ...[truncated 554 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Replace `@latest` with an exact, audited package version. - Pin exact versions for all `uvx` invocations. - Require package hashes or verified signatures where supported. - Commit and enforce dependency lockfiles for reproducible installations. - Review all transitive dependencies and monitor publisher ownership changes. - Disable package lifecycle scripts where they are not required. - Run installation commands as an unprivileged user in an isolated environment. - Review generated Skill, MCP, and template files before making them trusted or executable. - Establish an update process that performs security review before changing pinned versions. ]]>

T08 · Insecure Dependencies

Error
Location
SKILL.md:303
Finding
Mutable Remote Skill Content Is Written Directly into a Trusted Agent Directory<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 303-305 **Vulnerability Type**: Insecure Skill supply chain **Risk Level**: High ### Vulnerable Code ```bash curl -o ~/.claude/skills/browser-use/SKILL.md \ https://raw.githubusercontent.com/browser-use/browser-use/main/skills/browser-use/SKILL.md ``` ### Technical Analysis The command downloads a Skill definition from the mutable `main` branch and writes it directly into `~/.claude/skills/browser-use/SKILL.md`, which is a trusted Agent Skill location. The remote content is not pinned to a commit, checked against a known digest, signature-verified, or staged for review. A compromised upstream repository, maintainer account, or delivery path could therefore place attacker-controlled instructions in the Agent's Skill directory. Although no direct instruction hijacking was found in the audited local file, this installation mechanism creates a supply-chain path through which instruction hijacking could be introduced into future Agent sessions. ### Attack Path 1. An attacker compromises the upstream repository, a maintainer account, or the content-delivery path. 2. The attacker modifies the Skill file on the `main` branch to include malicious Agent instructions. 3. A user runs the documented `curl` command. 4. The malicious file is written directly into the trusted Claude Skill directory. 5. A later Agent session loads or uses the installed Skill. 6. The attacker-controlled instructions influence tool use, data handling, or Agent behavior within the permissions available to that session. ### Impact Assessment The installed content could manipulate later Agent behavior and potentially induce the Agent to: - Disclose data available in its context. - Invoke tools or network operations under false pretenses. - Modify files accessible through enabled tools. - Weaken operational safeguards. - Install further untrusted components. - Perform unauthorized actions through authenticated brows ...[truncated 149 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin the GitHub URL to a reviewed commit SHA rather than the `main` branch. - Publish and verify a known cryptographic digest or signed release. - Download the file to a non-trusted staging directory first. - Present the exact diff or contents for review before installation. - Require explicit confirmation before copying content into the trusted Skill directory. - Preserve the previously installed version and support rollback. - Apply restrictive ownership and filesystem permissions to Agent Skill directories. - Re-audit Skill updates before they are loaded into an Agent session. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:203
Finding
Authenticated Browser Profile State May Be Exposed Through Cloud Synchronization<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 203-221 **Vulnerability Type**: Excessive access to authenticated browser state **Risk Level**: High ### Vulnerable Code ```python browser = Browser( chrome_instance_path="/path/to/chrome", ) agent = Agent( task="登录我的 Gmail 并发送邮件", llm=ChatBrowserUse(), browser=browser, ) ``` ```bash curl -fsSL https://browser-use.com/profile.sh | \ BROWSER_USE_API_KEY=XXXX sh ``` ### Technical Analysis The documented workflow describes reusing an existing Chrome profile for access to authenticated services and separately instructs users to synchronize authentication information to a cloud service. An existing browser profile can contain active session cookies, authentication tokens, autofill information, browsing data, and access to sensitive accounts. The instructions do not define which authentication artifacts are uploaded, apply per-domain restrictions, require a dedicated profile, or describe explicit consent, retention, deletion, encryption, and revocation controls. This creates a least-privilege concern: a broad personal browser profile may expose substantially more authority than is necessary for a specific browser-automation task. ### Attack Path 1. A user configures browser automation to reuse a personal Chrome profile containing authenticated sessions. 2. The user follows the cloud profile synchronization instructions. 3. Authentication information is collected or transmitted outside the local browser trust boundary. 4. The cloud account, API key, synchronization service, or its infrastructure is compromised or misused. 5. Exposed session material is used to access services for which the browser profile remains authenticated. 6. An attacker performs actions within the permissions of those sessions until they expire or are revoked. ### Impact Assessment Potentially exposed authority is limited to the authentication state present in the selected browser profile, but ...[truncated 552 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Require a dedicated browser profile created solely for each automation purpose. - Do not reuse a personal daily-use Chrome profile. - Document exactly which files, cookies, tokens, and metadata are synchronized. - Exclude session cookies and authentication tokens by default unless explicitly required. - Obtain explicit, informed consent for each domain whose authentication state will be exported. - Encrypt exported state in transit and at rest using documented key-management controls. - Apply short retention periods and provide verified deletion mechanisms. - Restrict cloud-side access by task, domain, and account. - Require multi-factor authentication for the cloud account and support immediate API-key rotation. - Provide procedures for terminating browser sessions and revoking synchronized credentials. - Isolate browser automation from unrelated local files and accounts. ]]>
Vulnerability Patterns
  • 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
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (19)

Credential Access

High
Category
Privilege Escalation
Content
### 4.1 环境变量配置

```bash
# 创建 .env 文件
cat > .env << EOF
# Browser Use 云端 API(推荐,支持 Stealth + Proxy)
BROWSER_USE_API_KEY=your-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
### 4.1 环境变量配置

```bash
# 创建 .env 文件
cat > .env << EOF
# Browser Use 云端 API(推荐,支持 Stealth + Proxy)
BROWSER_USE_API_KEY=your-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
### 4.1 环境变量配置

```bash
# 创建 .env 文件
cat > .env << EOF
# Browser Use 云端 API(推荐,支持 Stealth + Proxy)
BROWSER_USE_API_KEY=your-key
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Rp1

Medium
Category
MCP Rug Pull
Confidence
84% confidence
Finding
`uvx browser-use install` executes a package tool without pinning a specific version, so behavior can change over time and a compromised upstream release could run arbitrary code. Because this is an installation/bootstrap path, it has elevated trust and execution privileges on the user's machine.

Rp1

Medium
Category
MCP Rug Pull
Confidence
84% confidence
Finding
`uvx browser-use init --template default` invokes an unpinned tool from the package ecosystem, exposing users to supply-chain risk from future or malicious releases. The risk is amplified because initialization commands may create files or templates that influence later execution.

Rp1

Medium
Category
MCP Rug Pull
Confidence
93% confidence
Finding
The skill instructs users to run `npx clawhub@latest install browser-use`, which pulls and executes the latest remote package without pinning an immutable version. If the upstream package is compromised or a malicious update is published, users could execute attacker-controlled code during installation.

Rp1

Medium
Category
MCP Rug Pull
Confidence
83% confidence
Finding
The documentation includes another unpinned `uvx browser-use init --template default` command, which may execute remote code from an arbitrary future release. Repetition across the skill increases the chance users will follow the unsafe pattern.

Rp1

Medium
Category
MCP Rug Pull
Confidence
83% confidence
Finding
`uvx browser-use init --template advanced` is also unpinned and therefore subject to supply-chain compromise or silent behavioral drift. Template generation can introduce insecure defaults into user environments if the upstream package changes.

Rp1

Medium
Category
MCP Rug Pull
Confidence
83% confidence
Finding
The unpinned `uvx browser-use init --template tools` command executes whatever version is current at the time of use. Since this template concerns custom tools, it may shape later code execution patterns and increase downstream security exposure.

External Transmission

Medium
Category
Data Exfiltration
Content
def get_github_stars(repo: str) -> str:
    """查询 GitHub 仓库的星数"""
    import requests
    r = requests.get(f"https://api.github.com/repos/{repo}")
    return r.json().get("stargazers_count", "Unknown")

# 创建代理
Confidence
50% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The skill showcases tasks such as job applications, shopping, and other browser-driven actions that can transmit personal data or spend money, but it does not prominently require user consent or warn about external data transmission. In an agent skill, these examples normalize autonomous high-impact actions and could lead to credential use, PII leakage, or unintended transactions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
82% confidence
Finding
Troubleshooting guidance repeats `uvx browser-use install` without a pinned version, normalizing unsafe package execution. Users encountering problems are especially likely to copy commands directly, increasing exploitability if the package source is compromised.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The MCP installation command again uses `npx clawhub@latest`, causing unreviewed remote code to be fetched and executed at runtime. In a skill context, users may copy-paste this directly, making supply-chain compromise more likely to translate into host compromise.

Skill Enumeration

Medium
Category
Agent Snooping
Content
### 12.2 Claude Code Skill

```bash
mkdir -p ~/.claude/skills/browser-use
curl -o ~/.claude/skills/browser-use/SKILL.md \
  https://raw.githubusercontent.com/browser-use/browser-use/main/skills/browser-use/SKILL.md
```
Confidence
85% confidence
Finding
Skill enumerates or reads other installed skills. Access to other skills' SKILL.md files or the skills directory reveals prompt instructions, capabilities, and secrets that should be invisible to peer skills.

Session Persistence

Medium
Category
Rogue Agent
Content
### 12.2 Claude Code Skill

```bash
mkdir -p ~/.claude/skills/browser-use
curl -o ~/.claude/skills/browser-use/SKILL.md \
  https://raw.githubusercontent.com/browser-use/browser-use/main/skills/browser-use/SKILL.md
```
Confidence
80% confidence
Finding
The skill instructs users to persistently install remote skill content into `~/.claude/skills/browser-use`, which creates a durable trust relationship and can affect future agent behavior across sessions. Because the content is fetched remotely and not pinned or verified, persistence magnifies the blast radius of a compromised or malicious update.

Skill Enumeration

Medium
Category
Agent Snooping
Content
```bash
mkdir -p ~/.claude/skills/browser-use
curl -o ~/.claude/skills/browser-use/SKILL.md \
  https://raw.githubusercontent.com/browser-use/browser-use/main/skills/browser-use/SKILL.md
```
Confidence
80% confidence
Finding
Skill enumerates or reads other installed skills. Access to other skills' SKILL.md files or the skills directory reveals prompt instructions, capabilities, and secrets that should be invisible to peer skills.

Skill Enumeration

Medium
Category
Agent Snooping
Content
```bash
mkdir -p ~/.claude/skills/browser-use
curl -o ~/.claude/skills/browser-use/SKILL.md \
  https://raw.githubusercontent.com/browser-use/browser-use/main/skills/browser-use/SKILL.md
```
Confidence
80% confidence
Finding
Skill enumerates or reads other installed skills. Access to other skills' SKILL.md files or the skills directory reveals prompt instructions, capabilities, and secrets that should be invisible to peer skills.

Vague Triggers

Medium
Confidence
94% confidence
Finding
The trigger phrases are broad enough to match common requests like filling forms, shopping, or controlling a browser, which can cause the skill to activate in contexts the user did not explicitly intend. Because this skill enables real browser actions and data-affecting operations, ambiguous invocation can lead to unintended external actions or data disclosure.

Natural-Language Policy Violations

Low
Confidence
88% confidence
Finding
Most of the natural-language instructions and usage guidance are presented in Chinese, which can impose a language-specific experience on users without opt-in. The document does not state that the skill is intended only for Chinese-speaking users or provide an alternative language option.

Static analysis

No suspicious patterns detected.