Back to skill

Security audit

Web Researcher Mini

Security checks for vulnerabilities and agentic risk

Overview

This skill performs web scraping through external tools, but it includes unsafe command examples, under-disclosed third-party data handling, and installation/authentication steps that need careful review.

Install only if you are comfortable sending target URLs and extracted content to Firecrawl and, for the bundled summarize workflow, potentially to AI providers or Apify. Avoid using it on confidential, internal, regulated, or proprietary material unless approved. Do not run the documented batch xargs/sh command on untrusted URL lists, avoid sudo npm install, prefer pinned/local installs, and store API keys in a proper secret manager rather than shell profiles.

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 (6)

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:267
Finding
Shell Command Injection Through Untrusted URL Interpolation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:267-270` **Vulnerability Type**: Shell command injection **Risk Level**: High ### Vulnerable Code ```bash For many URLs, use xargs with `-P` for parallel execution: ```bash cat urls.txt | xargs -P 10 -I {} sh -c 'firecrawl scrape "{}" -o ".firecrawl/$(echo {} | md5).md"' ``` ``` ### Technical Analysis The command substitutes every line from `urls.txt` directly into a command string interpreted by `sh -c`. Although the template uses double quotes around the URL, `xargs` performs textual substitution before the resulting string is interpreted by the shell. A malicious URL containing a double quote followed by shell metacharacters can terminate the intended argument and append an arbitrary command. URL lists may be derived from mapped or scraped websites, so their contents cannot be assumed to be trusted. For example, a crafted line conceptually shaped like the following could break out of the quoted URL: ```text https://example.invalid/"; attacker_command; # ``` ### Attack Path 1. An attacker publishes or injects a crafted URL into content processed by the user. 2. The crafted URL is written to `urls.txt`, such as through website mapping or extraction. 3. The user or Agent follows the documented batch-processing command. 4. `xargs` inserts the malicious line into the `sh -c` program. 5. The shell parses the injected metacharacters and executes the attacker-supplied command. 6. The injected command runs with the same filesystem, network, and credential access as the Agent or user. ### Impact Assessment Successful exploitation permits arbitrary local command execution with the invoking user's privileges. An attacker could read accessible project files, environment variables, API keys, and user data; modify or delete files; install additional programs; or make unauthorized network requests. If the command is run from a privileged account, the impact extends to all resources available to that ...[truncated 13 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Do not interpolate untrusted URLs into a `sh -c` program. - Pass each URL as a positional argument and reference it through a safely quoted parameter. - Validate that each input is an expected HTTP or HTTPS URL before processing it. - Generate output filenames using a language or utility that does not reinterpret the URL as shell syntax. - Reject control characters, newlines, and malformed URL input. A safer pattern is: ```bash xargs -P 10 -I {} sh -c ' url=$1 case "$url" in http://*|https://*) ;; *) echo "Rejected invalid URL" >&2; exit 1 ;; esac name=$(printf "%s" "$url" | md5) firecrawl scrape "$url" -o ".firecrawl/$name.md" ' sh "{}" < urls.txt ``` Where available, prefer a small script using an argument-safe process execution API rather than invoking a shell. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
firecrawl-skills/SKILL.md:267
Finding
Shell Command Injection Through Untrusted URL Interpolation in Mirrored Skill<![CDATA[ ## Vulnerability Details **File Location**: `firecrawl-skills/SKILL.md:267-270` **Vulnerability Type**: Shell command injection **Risk Level**: High ### Vulnerable Code ```bash For many URLs, use xargs with `-P` for parallel execution: ```bash cat urls.txt | xargs -P 10 -I {} sh -c 'firecrawl scrape "{}" -o ".firecrawl/$(echo {} | md5).md"' ``` ``` ### Technical Analysis This mirrored Skill contains the same unsafe `sh -c` construction as the root Skill. Values read from `urls.txt` are inserted into shell source code rather than passed solely as opaque command arguments. An attacker-controlled URL containing quote characters and shell operators can escape the intended argument and inject additional shell commands. This is especially significant because URL lists can originate from remotely controlled web pages. ### Attack Path 1. An attacker causes a crafted URL to appear in a mapped or extracted URL list. 2. The malicious value is stored in `urls.txt`. 3. The documented parallel scrape command is executed. 4. `xargs` substitutes the malicious string into the `sh -c` command. 5. The shell interprets the injected syntax and executes arbitrary commands under the invoking account. ### Impact Assessment Exploitation can provide arbitrary command execution with the Agent or user's privileges. Accessible credentials, API keys, source files, and personal data may be disclosed or modified. The attacker may also install additional payloads or use the victim's network access and Firecrawl account. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions Remove direct substitution into `sh -c`. Pass the URL as a positional argument, quote every expansion, and permit only valid `http://` or `https://` URLs. Prefer an implementation that invokes Firecrawl without a shell. For example: ```bash xargs -P 10 -I {} sh -c ' url=$1 case "$url" in http://*|https://*) ;; *) echo "Rejected invalid URL" >&2; exit 1 ;; esac name=$(printf "%s" "$url" | md5) firecrawl scrape "$url" -o ".firecrawl/$name.md" ' sh "{}" < urls.txt ``` The repaired command should be applied consistently to both copies of the Skill. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:32
Finding
Unpinned Global Installation of Firecrawl CLI<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:32` **Vulnerability Type**: Unpinned third-party dependency installation **Risk Level**: Medium ### Vulnerable Code ```bash If not installed: `npm install -g firecrawl-cli` ``` ### Technical Analysis The installation command does not specify a reviewed version or integrity value. It therefore installs whichever release the npm registry currently resolves for `firecrawl-cli`. npm installation can execute package lifecycle scripts, and the global installation scope makes the resulting executable available across projects. A compromised publisher account, malicious future release, or registry supply-chain incident could cause code different from the audited version to execute during installation or later invocation. ### Attack Path 1. The package publisher, publishing credentials, or distribution channel is compromised. 2. A malicious release becomes the package version selected by npm. 3. An Agent follows the Skill's unpinned installation instruction. 4. npm downloads the mutable package and may execute its lifecycle scripts. 5. The malicious package executes with the privileges of the user running npm. ### Impact Assessment A compromised dependency could execute arbitrary code, access files and environment variables available to the user, steal API credentials, modify globally installed tools, or establish further persistence. The command does not itself request root access, but its global scope increases the affected environment. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Pin the dependency to a specifically reviewed version, such as `firecrawl-cli@<reviewed-version>`. - Verify package provenance, publisher identity, signatures, and integrity hashes. - Prefer a project-local installation governed by a lockfile instead of a global installation. - Disable lifecycle scripts during installation when they are not required. - Document the expected package source and approved version. - Require user confirmation before installing or upgrading executable dependencies. ]]>

T08 · Insecure Dependencies

Warning
Location
firecrawl-skills/rules/install.md:12
Finding
Unpinned Firecrawl Dependency and Dynamic npx Execution<![CDATA[ ## Vulnerability Details **File Location**: `firecrawl-skills/rules/install.md:12,78-79,93` **Vulnerability Type**: Unsafe third-party dependency retrieval and execution **Risk Level**: Medium ### Vulnerable Code ```bash npm install -g firecrawl-cli ``` ```bash 2. Try: `npx firecrawl-cli --version` 3. Or reinstall: `npm install -g firecrawl-cli` ``` ```bash # Option 2: Use sudo (not recommended) sudo npm install -g firecrawl-cli ``` ### Technical Analysis The instructions retrieve and execute an unpinned npm package. The `npx` fallback may dynamically download and run a package when it is not already installed. The optional `sudo npm install -g` command significantly increases the consequences of a compromised package because installation scripts can run with administrative privileges. Although the document labels the `sudo` option as not recommended, it still presents it as an executable troubleshooting path. No version pin, integrity verification, package signature requirement, or lockfile is supplied. ### Attack Path 1. An attacker compromises the npm package, publisher account, or package distribution path. 2. The Agent encounters an installation or command-not-found condition. 3. The Agent executes the documented `npx`, global npm installation, or `sudo` installation command. 4. npm retrieves the current unreviewed package contents. 5. Malicious package code or lifecycle scripts execute. 6. If the `sudo` path is selected, execution occurs with administrative privileges. ### Impact Assessment Without `sudo`, malicious package code receives the invoking user's access to files, credentials, network resources, and shell configuration. With `sudo`, it may modify system-wide files, install privileged executables, alter other users' environment, or establish system-level persistence. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the `sudo npm install -g` option. - Remove dynamic `npx` execution or pin it to an explicitly reviewed version. - Pin `firecrawl-cli` to a known-good release and verify its integrity and provenance. - Prefer a local dependency installed under a lockfile. - Run installation without package lifecycle scripts unless they are required and audited. - Execute the tool in a restricted environment with only the filesystem and network access necessary for scraping. - Require explicit user approval before any package installation or update. ]]>

T08 · Insecure Dependencies

Warning
Location
summarize/SKILL.md:5
Finding
Unpinned Third-Party Homebrew Tap for Summarize CLI<![CDATA[ ## Vulnerability Details **File Location**: `summarize/SKILL.md:5` **Vulnerability Type**: Mutable third-party dependency source **Risk Level**: Medium ### Vulnerable Code ```yaml metadata: {"clawdbot":{"emoji":"🧾","requires":{"bins":["summarize"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/summarize","bins":["summarize"],"label":"Install summarize (brew)"}]}} ``` ### Technical Analysis The Skill authorizes installation from a third-party Homebrew tap without pinning a reviewed release, commit, checksum, or signed artifact. The effective code installed by the formula may change after this Skill package has been audited. If the tap repository, maintainer account, formula, or referenced release artifact is compromised, the installation can retrieve and execute attacker-controlled content. ### Attack Path 1. An attacker compromises the third-party tap, its maintainer account, or an artifact referenced by the formula. 2. The formula is changed to install a malicious package or run malicious installation steps. 3. The Agent's dependency installer follows the metadata and installs `steipete/tap/summarize`. 4. The altered formula or binary executes with the installing user's privileges. 5. Subsequent summarization commands continue to invoke the compromised executable. ### Impact Assessment A compromised formula or executable could read local files submitted for summarization, access configured AI-provider credentials, modify user files, or send confidential content to unauthorized destinations. Its reach is generally limited to the installing user's privileges unless Homebrew or the Agent is run with elevated permissions. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Pin installation to a reviewed release or immutable source commit. - Verify the downloaded artifact with a cryptographic checksum or signature. - Document the trusted publisher and official repository. - Require user approval before installation or upgrades. - Prefer a sandboxed execution environment because this CLI receives local file content and provider credentials. - Periodically review the formula and its transitive dependencies for unexpected changes. ]]>

T09 · Insecure Skill Coding Practices

Note
Location
firecrawl-skills/rules/install.md:54
Finding
API Key Exposure Through Command Arguments and Plaintext Shell Profiles<![CDATA[ ## Vulnerability Details **File Location**: `firecrawl-skills/rules/install.md:54-69` **Vulnerability Type**: Insecure secret handling **Risk Level**: Low ### Vulnerable Code ```bash ### If user selects manual API key: Ask for their API key, then run: ```bash firecrawl login --api-key "<their-key>" ``` Or set the environment variable: ```bash export FIRECRAWL_API_KEY="<their-key>" ``` Tell them to add this export to `~/.zshrc` or `~/.bashrc` for persistence, then retry the original command. ``` ### Technical Analysis The instructions encourage inserting an API key directly into a command and persisting it as plaintext in a general-purpose shell profile. Command-line secrets may be recorded in shell history and can be exposed through process inspection while the command is executing. Shell profiles are commonly included in backups, diagnostic archives, or dotfile repositories and may have permissions broader than a dedicated credential store. Exporting the key also makes it available to all child processes launched from that shell. ### Attack Path 1. A user supplies a valid Firecrawl API key. 2. The Agent places the key directly in a command or shell profile as instructed. 3. The key remains in shell history, a plaintext profile, process metadata, backups, or a dotfile repository. 4. Another local process, user, backup recipient, or repository reader obtains the key. 5. The attacker reuses the credential against the Firecrawl service. ### Impact Assessment Exposure may permit unauthorized use of the victim's Firecrawl account, consumption of paid credits, access to account metadata available to the key, and activity attributed to the victim. This issue does not directly disclose unrelated credentials, but compromise may extend to all Firecrawl resources authorized by the key. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Do not place API keys in command-line arguments. - Use hidden interactive input or a CLI-supported secure login flow. - Store persistent credentials in an operating-system keychain or dedicated secrets manager. - If a file-based credential is unavoidable, use a dedicated file with restrictive permissions such as mode `0600`. - Do not recommend storing reusable secrets in `.bashrc`, `.zshrc`, or shared dotfile repositories. - Redact credentials from logs and diagnostic output. - Document key rotation and revocation procedures for users who may already have followed these instructions. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (14)

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The README materially overstates the skill’s capabilities by presenting it as an AI summarization and report-generation agent rather than a narrower scraping/crawling CLI. This can cause users or upstream agents to invoke the skill for broader autonomous research tasks than intended, increasing the chance of unsafe data handling, unexpected external transmission, or misuse of outputs in automated workflows.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The description omits a user-facing warning that webpage URLs and retrieved content may be transmitted to an external Firecrawl service and possibly processed by related infrastructure. Users may unknowingly send sensitive internal URLs, private documents, or proprietary research targets to a third party, creating confidentiality and compliance risks.

Vague Triggers

Medium
Confidence
90% confidence
Finding
The usage description is broad and action-oriented but does not define clear activation constraints, approval boundaries, or limits on what content may be fetched and processed. In agent environments, this ambiguity can enable over-collection of third-party content or autonomous use beyond user intent, especially when combined with claims of one-click research and report generation.

Context-Inappropriate Capability

Medium
Confidence
92% confidence
Finding
The skill directs the agent to run `firecrawl login --browser`, which opens an interactive browser authentication flow and transmits credentials or tokens to an external service. This exceeds passive scraping behavior and can trigger external side effects and account linkage without an explicit user-approved authentication step.

Context-Inappropriate Capability

Medium
Confidence
89% confidence
Finding
The skill instructs the agent to modify local workspace state by creating a `.firecrawl/` directory and editing `.gitignore` as a default behavior, even though the core purpose is web scraping/search. Unnecessary persistent filesystem changes can affect repositories, alter version-control behavior, and create side effects outside the user’s explicit request.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The skill directs the agent to create a `.firecrawl/` directory and modify `.gitignore` automatically, but it does not require notifying the user or obtaining consent before changing the workspace. Silent filesystem changes can violate user expectations, alter repository state, and potentially hide generated artifacts from version control without explicit approval.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Session Persistence

Medium
Category
Rogue Agent
Content
```bash
# Option 1: Fix npm permissions (recommended)
mkdir ~/.npm-global
npm config set prefix '~/.npm-global'
export PATH=~/.npm-global/bin:$PATH
# Add the export to your shell profile
Confidence
60% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
export PATH=~/.npm-global/bin:$PATH
# Add the export to your shell profile

# Option 2: Use sudo (not recommended)
sudo npm install -g firecrawl-cli
```
Confidence
95% confidence
Finding
The skill explicitly suggests `sudo npm install -g firecrawl-cli`, which executes package installation scripts with root privileges. If the package or one of its dependencies is compromised, this can lead to full system compromise, and agent users may copy-paste the command without appreciating the risk despite the 'not recommended' note.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
# Add the export to your shell profile

# Option 2: Use sudo (not recommended)
sudo npm install -g firecrawl-cli
```
Confidence
94% confidence
Finding
This is the same privileged install guidance repeated in the rendered block, again instructing users to run npm as root. Repetition increases the chance an agent or user treats it as an endorsed remediation path, magnifying the risk of arbitrary code execution as root through npm lifecycle scripts.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The skill encourages users to summarize URLs, local files, PDFs, images, audio, and YouTube links while documenting multiple external model providers and fallback extractors, but it never warns that submitted content may be transmitted to those third parties. This creates a real confidentiality and privacy risk because users may send sensitive local documents or restricted web content to external services without informed consent.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill explicitly advertises optional Firecrawl and Apify integrations for blocked sites and YouTube fallback, but it does not disclose that enabling these services can share fetched content or request metadata with additional third parties. In a scraping/summarization context, this omission is more dangerous because users may assume all processing is local or limited to their selected model provider when in fact extra providers may receive the data.

Missing User Warnings

Low
Confidence
90% confidence
Finding
The documentation recommends automatic browser-based authentication without a clear warning that a browser will open and that authentication data will be exchanged with a third-party service. This weakens informed consent and can surprise users in restricted or sensitive environments.

Missing User Warnings

Low
Confidence
89% confidence
Finding
The authentication guidance instructs running `firecrawl login --browser`, which automatically opens a browser, without warning the user about this side effect. Unexpected browser launches can disrupt user workflows and may trigger authentication actions or expose session-related behavior without informed consent.

Static analysis

No suspicious patterns detected.