T08 · Insecure Dependencies
- Location
SKILL.md:4- Finding
Unpinned third-party browser package execution
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This skill is a powerful browser automation wrapper presented as restricted and safe, but its documented defaults and templates allow broad navigation, authentication, session persistence, file access, and page scripting without enforced guardrails.
Review this as a high-trust browser automation skill, not a read-only browser helper. Install only if you are comfortable with an unpinned npm tool controlling browser sessions, interacting with authenticated sites, saving cookies/session data, writing capture files, and running page JavaScript; use strict domain allowlists, content boundaries, output limits, a pinned package version, encrypted state, and avoid reusing saved auth state unless explicitly needed.
SKILL.md:4Unpinned third-party browser package execution
SKILL.md:10Mandatory browser safety controls are documented but not enforced
templates/authenticated-session.sh:28Caller-controlled state path can cause arbitrary file deletion
templates/authenticated-session.sh:29Authentication state is persisted without enforced confidentiality or safe temporary-file handling
references/proxy-support.md:40Proxy examples expose credentials and permit TLS verification bypass
The skill is presented as restricted navigation, screenshots, and public-data extraction, but it also supports interactive state-changing actions such as form filling, clicking, and submission. That discrepancy increases the chance of unintended writes, account changes, or other destructive browser-side actions under a falsely narrow safety label.
The skill is presented as restricted navigation, screenshots, and public-data extraction, but it also supports interactive state-changing actions such as form filling, clicking, and submission. That discrepancy increases the chance of unintended writes, account changes, or other destructive browser-side actions under a falsely narrow safety label.
The file says execution is forbidden without safety boundaries, but later admits that all security features are opt-in and unrestricted behavior is the default. This contradiction is dangerous because users may rely on the earlier assurance while the actual runtime defaults permit unsafe navigation, output, and action behavior.
The skill claims to be restricted, yet it exposes capabilities such as credential vaulting, authenticated login, persistent state storage, downloads, local file interaction, proxy support, and arbitrary JavaScript evaluation. This is a broad privilege surface that can access sensitive data, alter sessions, and create local artifacts beyond the stated purpose.
The documentation encourages saving authentication state to disk but does not clearly warn that the saved state can include sensitive cookies, bearer tokens, and session identifiers. If those files are exposed, copied, or reused improperly, an attacker could hijack authenticated sessions.
Auto-saved session persistence retains cookies and localStorage across runs without a prominent warning about the sensitivity of that data. Persistent browser state can silently carry authentication across tasks, increasing the risk of cross-task data leakage, unauthorized reuse, or session theft.
Session recording can capture credentials, tokens, personal data, and other sensitive page contents visible during browsing. In this skill, recording is normalized as a debugging feature without guardrails, so artifacts like .webm files may become durable context leaks if stored or shared.
agent-browser --headed open https://example.com
agent-browser highlight @e1 # Highlight element
agent-browser record start demo.webm # Record session
agent-browser profiler start # Start Chrome DevTools profiling
agent-browser profiler stop trace.json # Stop and save profile (path optional)
Allowing file:// access exposes local filesystem contents to the browser automation flow, yet the section lacks a strong warning about that risk. In an agent setting, this can bridge web automation into local file disclosure, especially if combined with extraction, screenshots, or script execution.
The file documents login flows, session persistence, OAuth, 2FA, cookies, and credential handling even though the skill is described as a restricted browser for navigation, screenshots, public-data extraction, and testing. This expands the effective capability boundary into authenticated-session handling, which can enable account access, token capture, and reuse of privileged browser state beyond the declared safe scope.
The examples directly handle usernames, passwords, auth cookies, HTTP Basic credentials, and persistent state files. In a supposedly restricted 'safe' browser skill, this materially increases risk by normalizing storage and replay of live authentication artifacts that could be abused for unauthorized access or lateral movement if exposed.
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).
Clean up after automation
agent-browser cookies clear
rm -f ./auth-state.json
Use short-lived sessions for CI/CD
The documentation presents the tool as restricted and safe, yet the reference exposes broad code execution, persistence, authentication, and state-changing features. This mismatch is dangerous because operators and downstream agents may rely on the safety framing while unknowingly invoking much more powerful capabilities.
The command reference includes request interception and response mocking features that materially exceed a 'restricted browser automation' tool intended only for navigation, screenshots, and public-data extraction. These capabilities can alter application behavior, bypass intended workflows, and facilitate unauthorized testing or manipulation if exposed to an agent without strong policy enforcement.
The documented support for credentials, cookies, localStorage manipulation, and request routing expands the tool from passive browsing into persistent authenticated session control and browser state modification. In the context of a supposedly limited safe browser skill, this creates a path to retain secrets, impersonate users, and alter execution context beyond public-data extraction.
Arbitrary JavaScript execution via eval, base64 input, or stdin directly contradicts the skill's stated safety-bounded purpose. It enables inspection and modification of page state, extraction of sensitive DOM data, and execution of complex logic that bypasses higher-level safety constraints normally imposed by limited browser commands.
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).
echo "*.auth-state.json" >> .gitignore
rm /tmp/auth-state.json
### 4. Timeout Long Sessions
The template explicitly supports authenticated login and session reuse, which expands the skill beyond its declared restricted browsing scope of navigation, screenshots, public data extraction, and testing. Even though much of the actual login flow is commented out, the file is a ready-made workflow for handling authenticated access and persistent session state, creating a capability/policy mismatch that can enable access to non-public data.
The template introduces credential ingestion via environment variables and persistent authenticated state storage, neither of which is necessary for a tool described as limited to public-data browsing and testing. This increases the risk of credential misuse, accidental secret exposure, and unauthorized replay of authenticated sessions through the saved state file.
The template enables active form filling, submission, and post-submit verification, which exceeds the stated skill scope of navigation, screenshots, extraction of public data, and testing under constrained boundaries. In practice, this can be used to perform unauthorized actions on third-party sites, submit sensitive data, or drive workflows that materially change remote state, making the mismatch between declared purpose and actual capability security-relevant.
Including a file upload example introduces a path for local file exfiltration or accidental disclosure of sensitive host data, especially if operators reuse the template without understanding the trust boundary. Because the skill's stated purpose does not justify local file access, this capability is unusually dangerous in context and can be abused to transmit arbitrary files to remote forms.
The skill allows execution via npx agent-browser:* without pinning a specific package version. That creates supply-chain risk because future package updates or a compromised upstream release could change behavior or introduce malicious code while retaining the same invocation path.
Early text frames snapshots as a way to avoid reading sensitive full-page content, but later sections document unrestricted full-page text extraction and arbitrary JS execution in the browser context. This inconsistency can cause operators to underestimate the amount of untrusted or sensitive content the skill can ingest and expose.
The download and file output examples write artifacts to the local filesystem without clearly warning about that side effect. This can lead to unreviewed persistence of untrusted files, storage of sensitive content, or accidental overwriting/exfiltration paths in agent workflows.
The example get text body > page.txt writes full-page contents to disk without warning that the page may contain secrets, personal data, or copyrighted material. In a browser automation context, this can create unexpected local data residues and broaden exposure beyond the live browsing session.
Persistent configuration and profile storage can retain browsing data, cookies, history, and other state across runs. In a supposedly restricted browser skill, this increases cross-task contamination risk and can preserve sensitive state longer than users expect.
Create agent-browser.json in the project root for persistent settings:
{