Back to skill

Security audit

Trio Stream Vision

Security checks for vulnerabilities and agentic risk

Overview

This is a real video-analysis skill, but it needs Review because it can send camera feeds to an external service, run ongoing monitoring, and uses unsafe shell examples for user-supplied text.

Before installing, confirm you are comfortable sending stream URLs and captured frames or clips to Trio for processing, use only streams you own or are authorized to analyze, avoid camera URLs with embedded credentials, prefer a verified ClawHub or pinned release over direct mutable git clones, store the API key in a secret store where possible, and require explicit confirmation before starting monitoring, digest, or webhook delivery.

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)

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:33
Finding
Shell Command Injection Through User-Controlled Stream URLs and Conditions<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:33-40`, `SKILL.md:62-72`, and `SKILL.md:94-102` **Vulnerability Type**: Shell command injection caused by unsafe interpolation into single-quoted JSON **Risk Level**: High ### Vulnerable Code ```bash curl -s -X POST "https://trio.machinefi.com/api/check-once" \ -H "Authorization: Bearer $TRIO_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "stream_url": "STREAM_URL_HERE", "condition": "NATURAL_LANGUAGE_CONDITION_HERE" }' | python3 -m json.tool ``` The same construction pattern appears in the continuous-monitoring action: ```bash curl -s -X POST "https://trio.machinefi.com/api/live-monitor" \ -H "Authorization: Bearer $TRIO_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "stream_url": "STREAM_URL_HERE", "condition": "NATURAL_LANGUAGE_CONDITION_HERE", "interval_seconds": 10, "monitor_duration_seconds": 600, "max_triggers": 1 }' | python3 -m json.tool ``` It also appears in the digest action: ```bash curl -s -X POST "https://trio.machinefi.com/api/live-digest" \ -H "Authorization: Bearer $TRIO_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "stream_url": "STREAM_URL_HERE", "window_minutes": 10, "capture_interval_seconds": 60 }' | python3 -m json.tool ``` ### Technical Analysis The Skill directs the agent to replace `STREAM_URL_HERE` and `NATURAL_LANGUAGE_CONDITION_HERE` with values supplied through user conversation and then execute the resulting command in a shell. These values are placed inside a single-quoted shell argument. A single quote in an attacker-controlled value can terminate the quoted JSON argument. Additional shell metacharacters can then introduce a new command. Escaping a value for JSON is not sufficient because JSON and POSIX shell quoting are separate parsing layers. The issue affects both nominal URL input and free-form natural-language conditions. The latter is particularly exposed becaus ...[truncated 2077 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not insert user-controlled text directly into shell command templates. 2. Prefer the structured JavaScript handler described in `IMPLEMENTATION_GUIDE.md`, where request bodies are constructed with `JSON.stringify` and sent through `fetch`. 3. If shell-based operation must be retained, construct JSON with a tool that accepts data as arguments rather than source code. For example, pass values through environment variables and serialize them with Python: ```bash STREAM_URL="$USER_STREAM_URL" CONDITION="$USER_CONDITION" python3 - <<'PY' | import json import os print(json.dumps({ "stream_url": os.environ["STREAM_URL"], "condition": os.environ["CONDITION"] })) PY curl --fail-with-body --silent --show-error \ -X POST "https://trio.machinefi.com/api/check-once" \ -H "Authorization: Bearer $TRIO_API_KEY" \ -H "Content-Type: application/json" \ --data-binary @- ``` 4. Prefer direct subprocess invocation with an argument array and with shell evaluation disabled. 5. Validate stream URLs against an explicit scheme allowlist such as `https`, `rtsp`, and `rtsps`. Reject control characters and malformed URLs, but do not treat validation as a substitute for safe command construction. 6. Apply length limits to stream URLs, conditions, webhook URLs, and option fields. 7. Run the Skill in a restricted environment with minimal filesystem access, a limited environment-variable set, and constrained outbound networking. 8. Add automated tests containing apostrophes, newlines, command separators, command substitutions, and other shell metacharacters to verify that input remains data rather than executable syntax. ]]>

T08 · Insecure Dependencies

Warning
Location
README.md:25
Finding
Unpinned and Inconsistent Direct Git Installation Sources<![CDATA[ ## Vulnerability Details **File Location**: `README.md:25-30`, `DISTRIBUTION.md:49-56`, and `IMPLEMENTATION_GUIDE.md:218-220` **Vulnerability Type**: Mutable, unverified supply-chain installation **Risk Level**: Medium ### Vulnerable Code `README.md` recommends cloning from the `machinefi` organization without pinning a commit or release: ```bash # From ClawHub openclaw skills install machinefi/trio-stream-vision # Or clone directly git clone https://github.com/machinefi/trio-openclaw-skill.git ~/.openclaw/skills/trio-stream-vision ``` `DISTRIBUTION.md` instead identifies a different publisher account: ```bash clawhub install trio-vision ``` ```bash git clone https://github.com/drandrewlaw/trio-openclaw-skill.git ~/.openclaw/skills/trio-vision ``` `IMPLEMENTATION_GUIDE.md` again uses the `machinefi` source: ```bash git clone https://github.com/machinefi/trio-openclaw-skill.git ~/.openclaw/skills/trio-vision ``` ### Technical Analysis The direct installation commands clone the repository's mutable default branch into an OpenClaw Skill directory. They do not pin an audited commit, verify a release signature, or validate a checksum. A repository owner—or an attacker who compromises the repository or maintainer account—can change the branch contents after this audit. A later user following the same command may therefore install instructions that differ from the reviewed version. The documentation also alternates between the `machinefi` and `drandrewlaw` GitHub publishers and uses inconsistent Skill identifiers such as `trio-stream-vision` and `trio-vision`. This makes it harder for users to establish the canonical publisher and increases the chance of installing from an unintended or impersonated source. Because Markdown-only Skills can instruct agents to execute shell commands, compromise of the installed `SKILL.md` can become a local execution or data-access issue even without conventional executable files. ### Attack Path 1. A maintainer ...[truncated 1674 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Select and document one canonical publisher, repository, Skill name, and ClawHub identifier. 2. Remove or correct all references to noncanonical publisher accounts. 3. Prefer installation through a verified package registry that supports immutable versions and publisher identity. 4. If Git installation remains supported, pin it to an audited commit or signed release rather than cloning the mutable default branch. For example: ```bash git clone --no-checkout https://github.com/machinefi/trio-openclaw-skill.git \ ~/.openclaw/skills/trio-stream-vision git -C ~/.openclaw/skills/trio-stream-vision checkout --detach AUDITED_COMMIT_SHA ``` 5. Publish a cryptographic checksum for each release and require users or the installer to verify it before loading the Skill. 6. Sign release tags and document how to verify the signature against an expected maintainer key. 7. Avoid installing downloaded content directly into the active Skill directory before verification. Download to a staging directory, verify provenance and integrity, and then move it into place. 8. Ensure ClawHub package names, local directory names, metadata names, and GitHub repository URLs are consistent across `README.md`, `DISTRIBUTION.md`, and `IMPLEMENTATION_GUIDE.md`. 9. Add a documented security contact and repository ownership statement so users can verify the authoritative distribution channel. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
Findings (30)

Anti-Refusal Statement

High
Category
Anti-Refusal
Content
|-------|-----|
| Agent doesn't validate stream first | Add stronger "ALWAYS validate first" language in Rules section |
| Agent forgets to show explanation | Emphasize in Rules: "ALWAYS show the explanation field" |
| Agent starts monitor without warning about cost | Add cost disclosure to the monitor workflow |
| Condition writing is poor | The "Condition Writing Tips" section helps the agent write better conditions |
| Error messages are confusing | The `remediation` field from the API gives actionable guidance |
Confidence
80% confidence
Finding
Skill instructs the agent to omit warnings, disclaimers, or ethical commentary. Stripping safety caveats hides risk from the user and is a common jailbreak preamble.

External Script Fetching

High
Category
Supply Chain
Content
Ask a yes/no question about what's currently visible on a stream. Costs 1 credit ($0.01).

```bash
curl -s -X POST "https://trio.machinefi.com/api/check-once" \
  -H "Authorization: Bearer $TRIO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

External Script Fetching

High
Category
Supply Chain
Content
Monitor a stream continuously and get alerted when a condition becomes true. Costs 2 credits/min ($0.02/min).

```bash
curl -s -X POST "https://trio.machinefi.com/api/live-monitor" \
  -H "Authorization: Bearer $TRIO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

External Script Fetching

High
Category
Supply Chain
Content
Get narrative summaries of what's happening on a stream at regular intervals. Costs 2 credits/min ($0.02/min).

```bash
curl -s -X POST "https://trio.machinefi.com/api/live-digest" \
  -H "Authorization: Bearer $TRIO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

External Script Fetching

High
Category
Supply Chain
Content
### 4. Check Job Status

```bash
curl -s "https://trio.machinefi.com/api/jobs/JOB_ID_HERE" \
  -H "Authorization: Bearer $TRIO_API_KEY" | python3 -m json.tool
```
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

External Script Fetching

High
Category
Supply Chain
Content
### 5. List All Jobs

```bash
curl -s "https://trio.machinefi.com/api/jobs?limit=20&offset=0" \
  -H "Authorization: Bearer $TRIO_API_KEY" | python3 -m json.tool
```
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

External Script Fetching

High
Category
Supply Chain
Content
### 6. Cancel a Job

```bash
curl -s -X DELETE "https://trio.machinefi.com/api/jobs/JOB_ID_HERE" \
  -H "Authorization: Bearer $TRIO_API_KEY" | python3 -m json.tool
```
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
- `NOT_LIVESTREAM` — URL is not a live stream. Confirm it's actively broadcasting.
- `STREAM_FETCH_FAILED` — Cannot reach the stream. Check URL and network.
- `STREAM_OFFLINE` — Stream exists but is offline. Wait for it to go live.
- `MAX_JOBS_REACHED` — Too many concurrent jobs. Cancel old ones with DELETE /jobs/{id}.

If you get an error, always show the `remediation` field to the user — it contains actionable guidance.
Confidence
80% confidence
Finding
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).

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The marketing copy promotes live camera monitoring, person/package detection, and smart alerts without any notice about privacy, consent, or the fact that video may be continuously transmitted to an external AI service. That omission can lead users to deploy the skill in surveillance-sensitive contexts without understanding legal, ethical, or data-handling risks, increasing the chance of non-consensual monitoring of people or private property.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The setup and usage documentation instructs users to enable continuous monitoring and alerting for live streams but does not warn about privacy obligations, consent requirements, or ongoing transmission of video to a third-party service. In this skill's context, the omission is more dangerous because the capability is explicitly designed for surveillance-style monitoring of homes, doors, and other real-world spaces, which raises legal and privacy risks for bystanders and occupants.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The document explicitly reframes the skill as an 'AI security guard' and promotes 24-hour monitoring of live cameras, which broadens the use case from generic stream understanding into persistent surveillance and security monitoring. That increases the likelihood of deployment for monitoring people in public or semi-private spaces without guardrails, policy limits, or abuse-prevention language.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The markdown encourages broad live-camera monitoring and presents surveillance as cheap, scalable, and labor-replacing, but omits any privacy, consent, or misuse warnings. In context, this makes the skill more dangerous because it normalizes using AI to watch public camera feeds for security purposes without discussing legal or ethical constraints.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The recommended skill description emphasizes convenience and broad camera/stream support but omits a prominent upfront disclosure that live camera frames are sent to Trio's cloud services for analysis. Users may connect indoor, private, or workplace cameras without realizing third-party transmission is involved, creating privacy, consent, and compliance risks that are especially relevant for surveillance-oriented use cases.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The public demo plan encourages connecting live streams and exposing a shareable interface without any requirement to verify that streams are public, authorized, or consented. In a vision-monitoring skill, this can lead to unauthorized surveillance, disclosure of sensitive scenes, and downstream privacy harm if users analyze or share feeds containing people, homes, or other private spaces.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The meta-skill is designed to let other agents invoke a free camera check and surface results, but it omits any privacy notice, consent requirement, or restriction on what streams may be analyzed. Because this broadens access and automates invocation across agents, it increases the chance of unauthorized analysis or disclosure of sensitive visual information.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
An always-on agent that posts observations from camera feeds to social media creates a direct pipeline from surveillance to public disclosure. Without privacy screening, consent checks, and content restrictions, it could publish identifying details, behavioral patterns, locations, or other sensitive observations about individuals captured on streams, amplifying harm beyond the original feed.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The guide promotes analysis of livestreams and local images through an external vision API but does not consistently warn that potentially sensitive visual data and stream metadata may leave the local environment. In a surveillance/video-analysis skill, this omission materially increases privacy, compliance, and user-consent risk because users may submit camera feeds containing people, homes, workplaces, or other regulated content.

Session Persistence

Medium
Category
Rogue Agent
Content
1. Go to https://console.machinefi.com
2. Sign up (free, gives you 100 credits / $1.00)
3. Navigate to the API Keys section
4. Create and copy your API key

### 2b. Set the Environment Variable
Confidence
90% confidence
Finding
The guide advises persisting the API key in shell configuration files, which can increase long-term secret exposure through backups, dotfile sync, shared accounts, terminal history mistakes, or accidental publication. In a skill that relies on paid third-party API access, compromised credentials can lead to unauthorized usage, billing loss, and access to associated account resources.

Skill Enumeration

Medium
Category
Agent Snooping
Content
```bash
# Option 1: User-level skills directory
mkdir -p ~/.openclaw/skills/trio-vision
cp trio-vision-skill/SKILL.md ~/.openclaw/skills/trio-vision/SKILL.md

# Option 2: Project-level skills directory (higher precedence)
mkdir -p ./skills/trio-vision
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
# Option 1: User-level skills directory
mkdir -p ~/.openclaw/skills/trio-vision
cp trio-vision-skill/SKILL.md ~/.openclaw/skills/trio-vision/SKILL.md

# Option 2: Project-level skills directory (higher precedence)
mkdir -p ./skills/trio-vision
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
# Option 1: User-level skills directory
mkdir -p ~/.openclaw/skills/trio-vision
cp trio-vision-skill/SKILL.md ~/.openclaw/skills/trio-vision/SKILL.md

# Option 2: Project-level skills directory (higher precedence)
mkdir -p ./skills/trio-vision
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
# Option 1: User-level skills directory
mkdir -p ~/.openclaw/skills/trio-vision
cp trio-vision-skill/SKILL.md ~/.openclaw/skills/trio-vision/SKILL.md

# Option 2: Project-level skills directory (higher precedence)
mkdir -p ./skills/trio-vision
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
95% confidence
Finding
The invocation example encourages broad natural-language triggering using ordinary chat phrasing, which can cause the skill to activate when a user did not explicitly intend to invoke an external video-analysis workflow. In this skill's context, accidental activation can lead to unintended transmission of stream URLs and possibly sensitive video content to a third-party API, as well as unexpected cost-incurring operations.

Session Persistence

Medium
Category
Rogue Agent
Content
### 6a. GitHub Repository

Create a public GitHub repo for the skill:

```bash
cd trio-vision-skill
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.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The README encourages users to analyze livestreams, RTSP camera feeds, and security cameras through a third-party vision API, but it does not clearly warn that stream content may be transmitted off-device for processing. This creates a real privacy and compliance risk because users may submit personal, bystander, or security-sensitive footage without informed consent or understanding of retention, sharing, or jurisdictional implications.

Static analysis

Detected: suspicious.exposed_secret_literal

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
IMPLEMENTATION_GUIDE.md:324