Back to skill

Security audit

Browser Devtools

Security checks for vulnerabilities and agentic risk

Overview

This package claims to be Chrome Dev Editor functionality, but the bundled scripts are mostly stubs or a generic local logging utility that retains user input on disk.

Review this before installing. It does not appear to provide real Chrome Dev Editor functionality, and it can store command arguments or added text under a local browser-devtools data directory. Avoid passing secrets, tokens, private paths, or sensitive project data to it unless the publisher clarifies the behavior and retention controls.

Vulnerability Patterns
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (1)

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/script.sh:4
Finding
Undisclosed Persistent Logging of User-Supplied Arguments<![CDATA[ ## Vulnerability Details **File Location**: `scripts/script.sh`, lines 4–7 and 32–80 **Vulnerability Type**: Plaintext sensitive-data retention and unsafe file handling **Risk Level**: Medium ### Vulnerable Code ```bash DATA_DIR="${BROWSER_DEVTOOLS_DIR:-${XDG_DATA_HOME:-$HOME/.local/share}/browser-devtools}" DB="$DATA_DIR/data.log" mkdir -p "$DATA_DIR" ``` ```bash _log() { echo "$(date '+%m-%d %H:%M') $1: $2" >> "$DATA_DIR/history.log"; } cmd_run() { echo " Running: $1" _log "run" "${1:-}" } cmd_config() { echo " Config: $DATA_DIR/config.json" _log "config" "${1:-}" } cmd_status() { echo " Status: ready" _log "status" "${1:-}" } cmd_init() { echo " Initialized in $DATA_DIR" _log "init" "${1:-}" } cmd_list() { [ -f "$DB" ] && cat "$DB" || echo " (empty)" _log "list" "${1:-}" } cmd_add() { echo "$(date +%Y-%m-%d) $*" >> "$DB"; echo " Added: $*" _log "add" "${1:-}" } cmd_remove() { echo " Removed: $1" _log "remove" "${1:-}" } cmd_search() { grep -i "$1" "$DB" 2>/dev/null || echo " Not found: $1" _log "search" "${1:-}" } cmd_export() { [ -f "$DB" ] && cat "$DB" || echo "No data" _log "export" "${1:-}" } cmd_info() { echo " Version: $VERSION | Data: $DATA_DIR" _log "info" "${1:-}" } ``` ### Technical Analysis The script persistently records the first argument supplied to most commands in `history.log`. The `add` command additionally records all supplied arguments in `data.log`. These writes occur without warning the user, filtering potentially sensitive values, defining a retention policy, or explicitly applying restrictive file permissions. This behavior conflicts with the documented expectation that results are sent to standard output. Users may therefore supply file paths, search terms, identifiers, tokens, or other sensitive strings without realizing that those values will remain on disk. The destination can be changed through `BROWSER_DEVTOOLS_DIR` ...[truncated 1821 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove persistent command logging unless it is essential to the tool's documented purpose. 2. Do not record raw user arguments. If operational logging is necessary, record only the command name or explicitly redact tokens, credentials, personal data, paths, and search terms. 3. Clearly document every persistent file, the information it contains, and its retention behavior. 4. Require explicit user consent before enabling argument logging, and keep it disabled by default. 5. Set restrictive permissions before creating storage: ```bash umask 077 mkdir -p -- "$DATA_DIR" ``` 6. Validate that the data directory is owned by the current user and is not a symbolic link. 7. Before appending, reject symbolic links and non-regular files for `history.log` and `data.log`. Use a safer file-opening mechanism that prevents symbolic-link traversal where available. 8. Validate or constrain `BROWSER_DEVTOOLS_DIR` and `XDG_DATA_HOME`; reject unsafe, unexpected, or shared locations. 9. Provide commands to inspect, disable, and securely delete retained history. 10. Update `SKILL.md` to accurately disclose local persistence rather than stating only that results go to standard output. ]]>
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (8)

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The description claims this skill is a developer tool for building Chrome Apps and browser devtools, but the supplied code does not implement any such functionality. It is only a simple shell script with help, info, status, and a stubbed run command that echoes a TODO message. There are no developer-tool operations, build steps, Chrome integration, or resource access consistent with the declared purpose. This is a material description-behavior mismatch.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The declared description says this is Chrome Dev Editor for building Chrome Apps and browser devtools. The supplied shell script instead exposes generic commands like add, list, search, export, and status, persisting data to ~/.local/share/browser-devtools/data.log and history.log. It acts as a simple local note/log manager or utility CLI, not a Chrome development environment or editor. This is a material purpose mismatch, and the actual file-access behavior (local datastore/history files) is unrelated to the declared developer-tool role.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The manifest says this skill is for building apps on the Chrome platform and browser devtools, but the code provides generic commands like add, list, search, remove, and export over a local data file. Nothing in the script interfaces with Chrome, developer tooling, app building, or browser debugging, so the implemented behavior does not match the claimed purpose.

Vague Triggers

Medium
Confidence
91% confidence
Finding
The command triggers `help`, `run`, `info`, and `status` are extremely generic and likely to overlap with ordinary user language or other skills. In an agent environment, broad triggers can cause accidental invocation of this skill, leading to unintended command execution paths or user confusion about which tool is acting.

Unrestricted Tool Access

Medium
Category
Excessive Agency
Content
## Usage

Run any command: `browser-devtools <command> [args]`
---
💬 Feedback & Feature Requests: https://bytesagain.com/feedback
Powered by BytesAgain | bytesagain.com
Confidence
90% confidence
Finding
The usage text explicitly states 'Run any command,' indicating a generic command pass-through model without visible allowlisting or scope restrictions. If an agent maps natural-language requests into arbitrary subcommands and arguments, this can broaden the attack surface and enable misuse of the underlying tool beyond the intended feature set.

Intent-Code Divergence

Medium
Confidence
93% confidence
Finding
The comment and help text describe the tool as 'browser-devtools' and a 'Multi-purpose utility tool', implying a developer-tool context consistent with the manifest. However, the commands actually just read, append, search, and display lines from local log files, which contradicts the implied browser-devtools functionality.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The script persistently logs user-supplied command arguments to a history file without clear disclosure, which can capture sensitive data such as search terms, file paths, tokens, or other secrets entered on the command line. In the skill context, this is more concerning because the package presents itself as a developer tool, increasing the chance that users may pass project-specific or security-sensitive values they do not expect to be retained.

Missing User Warnings

Low
Confidence
88% confidence
Finding
The add operation writes user-provided content to a persistent local database file without prior disclosure in the help text, which creates an unexpected data-retention/privacy risk. While the behavior is not remotely exploitable on its own, users may unknowingly store sensitive notes or command content on disk, especially given the misleading developer-tool framing.

Static analysis

No suspicious patterns detected.