Back to skill

Security audit

Ppio Sandbox

Security checks for vulnerabilities and agentic risk

Overview

This sandbox helper is mostly coherent, but it needs review because it can move arbitrary local files to and from a cloud sandbox and uses broad sandbox/network settings.

Install only if you are comfortable giving this skill a PPIO/E2B API key and letting an agent run commands in internet-enabled cloud sandboxes. Avoid uploading secrets or broad project folders, treat downloaded sandbox files as untrusted, kill sandboxes when finished, and prefer a version with pinned dependencies plus restricted local transfer paths.

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

T08 · Insecure Dependencies

Warning
Location
scripts/requirements.txt:1
Finding
Unbounded Third-Party Dependency Installation## Vulnerability Details **File Location**: `scripts/requirements.txt:1` and `SKILL.md:55-57` **Vulnerability Type**: T08: Insecure Dependencies **Risk Level**: Medium ### Vulnerable Code `scripts/requirements.txt:1`: ```text ppio_sandbox>=1.0.5 ``` `SKILL.md:55-57`: ```bash pip3 install "ppio_sandbox>=1.0.5" # Or: pip3 install -r skills/ppio-sandbox/scripts/requirements.txt ``` ### Technical Analysis The dependency is constrained only by a minimum version. The package installer may therefore select any later release available from the configured package index. This conflicts with the statement in `SKILL.md` that the SDK version is pinned and tested. Python packages can execute installation-time code, and their imported modules execute locally with the privileges of the user running the Skill. The dependency is also entrusted with the PPIO API key and all remote sandbox operations. A compromised future release, malicious package-index response, or insufficiently reviewed update could consequently execute local code or access authentication and transferred data. No evidence indicates that the currently referenced `ppio_sandbox` package is malicious. The vulnerability is the absence of deterministic version and integrity controls. ### Attack Path 1. An attacker compromises the package publisher account, distribution infrastructure, or a later eligible release. 2. The attacker publishes a malicious version newer than or equal to `1.0.5`. 3. A user follows the documented installation command. 4. Pip resolves the malicious version because the `>=` constraint permits it. 5. Malicious installation or import code runs with the installing user's local privileges. 6. The package can access data available to that process, including the PPIO API key when the CLI is invoked, and can alter sandbox requests or exfiltrate submitted content. ### Impact Assessment Successful exploitation could permit arbi ...[truncated 578 chars]
Remediation
## Remediation Suggestions 1. Replace the lower-bound constraint with an exactly audited version, for example: ```text ppio_sandbox==1.0.5 ``` 2. Generate and commit a lock file containing cryptographic hashes. 3. Install with pip's `--require-hashes` option so modified distributions are rejected. 4. Use a trusted package index and explicitly configure the expected index rather than relying on ambient pip configuration. 5. Test dependency updates before changing the lock file. 6. Correct the documentation so claims about pinning accurately match the enforced dependency policy. 7. Run installation and execution as an unprivileged account in an isolated virtual environment.

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/sandbox.py:84
Finding
Sandbox Created Through Private SDK API with Security Disabled and Unrestricted Internet Access## Vulnerability Details **File Location**: `scripts/sandbox.py:84-94` **Vulnerability Type**: T09: Insecure Skill Coding Practices **Risk Level**: Medium ### Vulnerable Code ```python def cmd_create(args): api_key = get_api_key() # PPIO SDK 1.0.5's public create() hardcodes auto_pause=False. # Call _create() directly to enable auto_pause. sbx = Sandbox._create( template=args.template, timeout=args.timeout, metadata=SANDBOX_METADATA, envs=None, secure=False, allow_internet_access=True, auto_pause=True, api_key=api_key, ) ``` ### Technical Analysis The Skill is explicitly intended to execute untrusted code securely, but sandbox creation bypasses the SDK's supported public interface and invokes the private `_create()` method. Private methods do not provide the same stability or compatibility guarantees as public APIs, so SDK changes could silently alter security-relevant semantics. The call explicitly sets `secure=False`. Without authoritative SDK implementation details, the precise protections disabled by this option cannot be established from the audited project alone. Nevertheless, disabling a security-labeled setting contradicts the Skill's stated secure-execution purpose and may omit hardening expected for hostile workloads. The implementation also enables Internet access unconditionally for both browser and code-interpreter templates. Internet connectivity is necessary for browsing and tasks that download dependencies, but it exceeds minimum privilege for untrusted computations that do not require networking. Hostile code can therefore communicate with arbitrary external services, retrieve secondary payloads, and exfiltrate any information deliberately uploaded or generated inside the sandbox. The reviewed code does not demonstrate a sandbox escape, and the sandbox does not automatically upload local files. The confirme ...[truncated 1774 chars]
Remediation
## Remediation Suggestions 1. Use a documented public SDK creation method rather than `Sandbox._create()`. 2. Enable the provider's secure mode after verifying its documented semantics. 3. Default code-interpreter sandboxes to `allow_internet_access=False`. 4. Add an explicit CLI option to enable networking only when a task requires downloads or external communication. 5. Keep Internet access enabled for browser sandboxes only where it is essential to declared functionality. 6. If full Internet access cannot be disabled, apply destination allowlists, DNS controls, egress filtering, and traffic limits where supported. 7. Avoid placing secrets in sandbox environment variables and continue prohibiting credential or private-key uploads. 8. Kill sandboxes promptly after use rather than retaining sensitive state through auto-pause. 9. Add integration tests that verify private network ranges and cloud metadata endpoints remain unreachable under every supported template and configuration. 10. Document the actual meaning of `secure`, the network boundary, persistence behavior, and residual exfiltration risk.
Vulnerability Patterns
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (7)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The skill claims it should not be used for reading or writing local user files, yet its documented upload/download workflows inherently read local files and write sandbox output back to the local filesystem. That mismatch is dangerous because operators may trust the description and unknowingly permit local data exfiltration to the sandbox or overwrite local files with untrusted artifacts.

External Script Fetching

High
Category
Supply Chain
Content
```bash
python3 skills/ppio-sandbox/scripts/sandbox.py create --template browser-chromium --timeout 120
python3 skills/ppio-sandbox/scripts/sandbox.py exec <sandbox_id> \
  "curl -sL https://example.com" --timeout 30
```

### JS-rendered pages (puppeteer)
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The skill metadata explicitly says it is not for reading or writing local user files, yet the upload and download commands directly access arbitrary local filesystem paths via open(). In an agent setting, this creates a capability to exfiltrate host files into the remote sandbox or write sandbox-controlled content back onto the local machine, violating the stated trust boundary and enabling data theft or overwrite of sensitive files.

Context-Inappropriate Capability

High
Confidence
97% confidence
Finding
Local file read/write capability is unnecessary for a tool whose stated purpose is secure remote sandbox execution, and it meaningfully expands the attack surface of the host environment. An LLM agent using this skill could be induced to read secrets from the local machine or persist untrusted sandbox output into sensitive local paths, defeating the isolation benefits the sandbox is supposed to provide.

Lp3

Medium
Category
MCP Least Privilege
Confidence
92% confidence
Finding
The skill exposes capabilities involving environment variables and local file writes, but it declares no explicit tool scope or permission boundaries. In a skill designed to handle untrusted code and external content, missing scope declarations increase the chance that an agent may invoke it with broader-than-intended local access, undermining isolation guarantees.

Intent-Code Divergence

Medium
Confidence
90% confidence
Finding
The module is presented as a secure sandbox boundary for untrusted browsing and code execution, but the implementation quietly includes host filesystem operations. That mismatch is dangerous in agent workflows because operators may trust the skill as containment-only, while it actually provides a bridge between untrusted remote execution and local host data.

Unpinned Dependencies

Low
Category
Supply Chain
Content
ppio_sandbox>=1.0.5
Confidence
92% confidence
Finding
The dependency is specified with a lower-bound range (>=1.0.5) rather than an exact version, so installs can resolve to different upstream releases over time. This weakens build reproducibility and increases supply-chain risk if a later version introduces a malicious package, compromised release, or breaking security behavior in a sandboxing library that is security-sensitive by design.

Static analysis

No suspicious patterns detected.