Back to skill

Security audit

Solo CLI Guide

Security checks for vulnerabilities and agentic risk

Overview

This is a coherent robot-arm tutor, but it needs Review because it guides unverified software installation and real robot movement without strong safety gates.

Before installing, review and verify remote installer and package sources, avoid running setup from an elevated/admin shell unless strictly necessary, pin versions where possible, and treat robot motion steps as hazardous: clear the workspace, keep hands and bystanders away, and have an immediate stop or power cutoff ready. Review any dataset or model before pushing to HuggingFace because it may include images, robot states, and environment details.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T03 · Remote Payload Retrieval and Execution

Error
Location
domains/environment.json:7
Finding
Unverified Remote Installer Downloaded and Executed Directly## Vulnerability Details **File Location**: `domains/environment.json:7-9` **Additional Reference**: `SKILL.md:72` **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: Critical ### Vulnerable Code ```json "macos": "curl -LsSf https://astral.sh/uv/install.sh | sh", "linux": "curl -LsSf https://astral.sh/uv/install.sh | sh", "windows": "powershell -ExecutionPolicy ByPass -c \"irm https://astral.sh/uv/install.ps1 | iex\"" ``` ### Technical Analysis The macOS and Linux commands pipe a remotely downloaded script directly into a shell. The Windows command uses the equivalent PowerShell pattern, downloading a remote script with `irm` and immediately executing it with `iex`; it also bypasses the configured PowerShell execution policy. Although `astral.sh` is consistent with the declared purpose of installing the uv package manager, the downloaded payload is mutable and is not pinned to a reviewed version, checked against a cryptographic hash, or verified with a digital signature. Consequently, the code that actually executes can differ from the content reviewed during this audit. The Skill is a human-in-the-loop guide and does not execute these commands autonomously. This reduces automatic exploitation risk but does not eliminate the vulnerability: users are explicitly instructed to execute the commands in their terminals. ### Attack Path 1. A user starts the first-run environment setup tutorial. 2. The Skill selects the installation command for the user's operating system. 3. The user executes the provided command in a local terminal. 4. The command retrieves a mutable installer from `astral.sh`. 5. The response body is passed directly to a shell or PowerShell interpreter without inspection or integrity verification. 6. If the hosting infrastructure, publisher account, DNS/TLS trust chain, or delivered installer is compromised, attacker-controlled commands execute locally. 7. The malicious ...[truncated 1062 chars]
Remediation
## Remediation Suggestions - Prefer a trusted operating-system package manager with a version constraint instead of executing an Internet-delivered script. - If an installer script is unavoidable, divide retrieval and execution into separate steps: 1. Download a version-specific installer to a local file. 2. Obtain the expected SHA-256 or stronger digest through an independently authenticated release channel. 3. Verify the digest or publisher signature. 4. Allow the user to inspect the downloaded script. 5. Execute it only after explicit confirmation. - Pin the installer to a reviewed release rather than using a mutable generic installation URL. - Remove `-ExecutionPolicy ByPass` and `iex` from the Windows instructions. - Do not recommend running the installer as an administrator unless a documented operation strictly requires elevation. - Document the exact files, directories, and environment settings changed by the installer. - Update `SKILL.md` and the tutorial to present the verified installation method as the default, rather than merely warning users about the risks of the current method.

T08 · Insecure Dependencies

Warning
Location
domains/environment.json:65
Finding
Solo CLI Installed from Unpinned Mutable Third-Party Sources## Vulnerability Details **File Location**: `domains/environment.json:65-66` **Duplicated Workflow Location**: `tutorials/solo_first_run.json:101-125` **Vulnerability Type**: Insecure dependency and supply-chain configuration **Risk Level**: Medium ### Vulnerable Code ```json "from_pypi": "uv pip install solo-cli", "from_source": "git clone https://github.com/GetSoloTech/solo-cli.git && cd solo-cli && uv pip install -e ." ``` ### Technical Analysis Both supported installation methods consume mutable third-party code without pinning or integrity verification. The PyPI method does not specify a package version or require package hashes. It therefore installs whichever release currently satisfies the unqualified package name. The source method clones the repository's current default branch rather than a reviewed commit or signed release tag, then installs that checkout in editable mode. Editable installation further increases the trust surface because later changes to the local checkout immediately affect the installed command without requiring a controlled reinstall. The tutorial explicitly recommends the source installation and describes future `git pull` operations as the update mechanism, allowing reviewed code to be replaced by newer upstream content without a new security review. No evidence establishes that the referenced PyPI package or GitHub repository is currently malicious. The vulnerability is the absence of version pinning and authenticity controls, which creates a supply-chain exploitation path if an upstream package, repository, maintainer account, or release process is compromised. ### Attack Path 1. A user selects the recommended source installation or the PyPI installation. 2. The installation command resolves a mutable package release or the repository's current default branch. 3. An attacker compromises the relevant publisher account, repository, release process, or upstream distrib ...[truncated 1312 chars]
Remediation
## Remediation Suggestions - Pin the PyPI installation to a specifically reviewed release, for example by requiring an exact version. - Use a lockfile or requirements file containing cryptographic hashes and install with hash verification enabled. - For source installations, clone or check out an immutable commit hash or signed release tag rather than the default branch. - Verify the release signature or commit identity before installation. - Avoid editable installations for ordinary end users; install a built, immutable, verified release artifact instead. - Do not recommend unrestricted `git pull` as a trusted update mechanism. Updates should identify a specific reviewed release and repeat signature or checksum verification. - Ensure the domain action and all duplicated tutorial instructions use the same pinned and verified command. - Remove or correct the `install_mac_script` tutorial branch, which recommends `./install_mac.sh` even though that script is not bundled in this project and the associated action resolves to a different source-install command.
Vulnerability Patterns
  • 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
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (20)

Missing User Warnings

High
Confidence
99% confidence
Finding
The tutorial tells the user to run inference where the follower arm will begin acting autonomously, but it does not provide an explicit safety warning about keeping clear, ensuring an emergency stop, verifying workspace clearance, or supervising first motion. In a physical robotics context, autonomous motion can cause pinching, collisions, or equipment damage if started unexpectedly or in an unsafe environment.

Vague Triggers

Medium
Confidence
85% confidence
Finding
This manifest describes the skill in broad natural language and gives a command, but it does not define specific activation constraints, exclusions, or negative examples. As written, "Record teleoperation episodes as a training dataset" could match a wide range of generic recording requests in the data/robotics context and may lead to unintended invocation.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The manifest allows pushing recorded data to HuggingFace Hub but does not present an explicit warning that this may upload potentially sensitive images, robot state, or environment data to a remote public or shared repository. In an interactive tutoring context, users may follow steps mechanically, increasing the chance of unintentional data disclosure.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The replay action causes physical robot motion on the follower arm, yet the description omits a clear safety warning about keeping clear of the robot workspace, verifying calibration, and ensuring an emergency stop is available. Because playback is open-loop and can move hardware without live human correction, omission of safety guidance materially increases risk of injury or equipment damage.

Session Persistence

Medium
Category
Rogue Agent
Content
{
    "id": "create_venv",
    "domain": "environment",
    "description": "Create a Python 3.12 virtual environment using uv",
    "command": "uv venv --python 3.12",
    "inputs": [],
    "parameters": {},
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.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
"command": "solo setup-usb",
    "inputs": [],
    "parameters": {
      "--yes / -y": "Skip confirmation prompt"
    },
    "explanation": "Adds the current user to the dialout group for serial access to Koch/SO100/SO101 arms. Only needed on Linux. Informational-only on macOS.",
    "expected_output": "USB permissions configured successfully",
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
This skill guides operation of a physical robot arm but omits an explicit safety warning that teleoperation causes immediate real-world movement and that '-y' may auto-apply saved settings without interactive confirmation. In a robotics context, missing warnings can lead to unintended motion, incorrect port/robot configuration reuse, and increased risk of collision, pinching, or equipment damage.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The teleoperation step initiates real-world robot arm motion but only asks whether the follower moves, without an explicit safety warning to keep hands/body clear, verify an emergency stop/stop procedure, and maintain safe distance before motion begins. In a hardware-control tutorial for first-time users, this omission increases the risk of pinch, collision, or property damage during initial activation.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The tutorial instructs the user to delete a partial dataset and re-record, but it does not clearly warn that the deletion may permanently remove previously captured data. In a data collection and training workflow, this can cause irreversible loss of work or accidental deletion of a dataset the user intended to salvage or back up.

External Script Fetching

Low
Category
Supply Chain
Content
| Command | Endpoint | Purpose |
|---|---|---|
| `curl -LsSf https://astral.sh/uv/install.sh \| sh` | astral.sh | Install uv package manager |
| `git clone https://github.com/GetSoloTech/solo-cli` | github.com | Install solo-cli from source |
| `uv pip install solo-cli` | pypi.org | Install solo-cli from PyPI |
| `solo data push` | huggingface.co | Push recorded dataset (optional) |
Confidence
15% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

Vague Triggers

Low
Confidence
80% confidence
Finding
This is a manifest file, so vague trigger review applies. The description "Install the uv Python package manager" is generic and does not indicate any invocation scope, negative examples, or narrower context, which can increase the chance of unintended activation in systems that rely on natural-language matching.

External Script Fetching

Low
Category
Supply Chain
Content
"domain": "environment",
    "description": "Install the uv Python package manager",
    "command": {
      "macos": "curl -LsSf https://astral.sh/uv/install.sh | sh",
      "linux": "curl -LsSf https://astral.sh/uv/install.sh | sh",
      "windows": "powershell -ExecutionPolicy ByPass -c \"irm https://astral.sh/uv/install.ps1 | iex\""
    },
Confidence
95% confidence
Finding
Piping a remotely fetched script directly into 'sh' executes unverified code from the network with no integrity check, review step, or pinned version. If the remote host, transport, or distribution path is compromised, users could run arbitrary code during setup.

External Script Fetching

Low
Category
Supply Chain
Content
"description": "Install the uv Python package manager",
    "command": {
      "macos": "curl -LsSf https://astral.sh/uv/install.sh | sh",
      "linux": "curl -LsSf https://astral.sh/uv/install.sh | sh",
      "windows": "powershell -ExecutionPolicy ByPass -c \"irm https://astral.sh/uv/install.ps1 | iex\""
    },
    "inputs": ["os_platform"],
Confidence
95% confidence
Finding
This Linux/macOS installer pattern again executes code fetched from the internet immediately, which removes opportunities for inspection and integrity validation. In an environment-setup skill, users are primed to trust and run commands, making this pattern more dangerous because it normalizes remote code execution during onboarding.

Vague Triggers

Low
Confidence
77% confidence
Finding
The description "Create a Python 3.12 virtual environment using uv" is understandable but does not define precise trigger scope, exclusions, or invocation boundaries. In manifest files, missing specificity can lead to accidental activation from loosely related user requests about environments or Python setup.

Vague Triggers

Low
Confidence
76% confidence
Finding
The description "Activate the virtual environment" is short and generic, and in a manifest context it does not define when the skill should or should not activate. Because activation descriptions can drive routing, this broad phrasing may overlap with many ordinary requests about virtual environments.

Vague Triggers

Low
Confidence
78% confidence
Finding
The description "Install solo-cli package" identifies the task but does not define invocation context, approved trigger phrases, or exclusions. For manifest files, this absence of specificity makes routing more error-prone when users ask general questions about installation or packages.

Vague Triggers

Low
Confidence
79% confidence
Finding
Although the task is more specialized, the description still lacks explicit trigger conditions, negative examples, or routing constraints in the manifest. For skills matched by natural-language descriptions, this can cause unintended invocation from broad requests about USB access or Linux permissions.

Vague Triggers

Low
Confidence
82% confidence
Finding
This manifest describes what the skill does and the command it runs, but it does not define explicit activation phrases, constraints, or exclusion conditions for when the skill should be invoked. In a manifest file, that lack of trigger specificity can cause overly broad matching if an agent relies on the description text alone to select the skill.

Vague Triggers

Low
Confidence
85% confidence
Finding
The skill entry is broadly described as 'Train a robot policy on a recorded dataset' with a simple command binding, but it does not define clear trigger boundaries or user-confirmation requirements. In an agent setting, this can cause overbroad activation from natural-language requests and launch expensive or safety-relevant robot training workflows unintentionally, especially since training can write files, consume compute, and potentially publish artifacts via push_to_hub.

Vague Triggers

Low
Confidence
91% confidence
Finding
The inference skill can be matched by broad requests about 'running' or 'testing' a policy, yet its action is physically consequential: it runs a policy in closed loop on a follower arm. Because this affects real hardware and may move a robot autonomously, ambiguous activation boundaries materially increase the risk of unintended execution, which is more dangerous in this robotics context than in a purely informational skill.

Static analysis

No suspicious patterns detected.