Back to skill

Security audit

Pluribus

Security checks for vulnerabilities and agentic risk

Overview

The skill is mostly a disclosed peer-sharing tool, but users should review it because installation runs unpinned remote code and initialization reads a local Moltbook credentials file.

Install only after verifying the exact repository commit or release you intend to run. Treat announce, sync, signal, offers, and needs as data-sharing actions visible to Moltbook or peers, and avoid placing sensitive operational details in local Pluribus files unless you are comfortable sharing them. Consider using an explicit agent name instead of letting the init script read Moltbook credentials.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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)

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
scripts/init.sh:14
Finding
Unnecessary Access to Moltbook Credential Storage<![CDATA[ ## Vulnerability Details **File Location**: `scripts/init.sh:14-19` **Vulnerability Type**: Violation of least-privilege boundaries through access to a credential-bearing file **Risk Level**: Medium ### Vulnerable Code ```bash # Get agent name from moltbook credentials or use hostname AGENT_NAME=$(cat ~/.config/moltbook/credentials.json 2>/dev/null | jq -r '.agent_name // empty') if [ -z "$AGENT_NAME" ]; then AGENT_NAME=$(hostname) fi ``` ### Technical Analysis The initialization script opens the complete Moltbook credentials file solely to obtain the non-secret `agent_name` property. Credential files commonly contain authentication tokens or other sensitive account data. Processing the entire file with `cat` and `jq` expands the amount of sensitive information exposed to the Skill and its subprocesses beyond what is necessary to create a local node identity. The reviewed code only selects `agent_name`; no credential exfiltration or token extraction was identified. Nevertheless, this behavior violates least privilege because local node initialization can operate using an explicit user-supplied name or the existing hostname fallback without reading credential storage. The extracted Moltbook identity is subsequently written to `node.md`, including as part of the transport identifier. This also discloses the account identity to anyone who can read the configured Pluribus data directory. ### Attack Path 1. A user runs `scripts/init.sh`. 2. The script opens `~/.config/moltbook/credentials.json` with the user's filesystem permissions. 3. The complete credential file is passed through `cat` and processed by the external `jq` executable. 4. The `agent_name` property is extracted and persisted in `$PLURIBUS_DIR/node.md`. 5. If the execution environment, `jq` binary, or destination directory is compromised, the unnecessary credential-file access increases the opportunity for sensitive data exposure. No direct exfiltration path exists in the audite ...[truncated 772 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not read `~/.config/moltbook/credentials.json` during local node initialization. 2. Accept the agent name through an explicit command-line option or environment variable, for example: ```bash AGENT_NAME="${PLURIBUS_AGENT_NAME:-$(hostname)}" ``` 3. If automatic profile discovery is required, use a dedicated Moltbook command or API that returns only public profile metadata. 4. Request explicit user consent before importing an external account identity. 5. Create the destination directory and generated identity files with restrictive permissions: ```bash umask 077 mkdir -p -- "$PLURIBUS_DIR" ``` 6. Document that the selected agent name will be stored locally and may later be shared if networking features are implemented. ]]>

T03 · Remote Payload Retrieval and Execution

Warning
Location
README.md:23
Finding
Installation Instructions Retrieve and Execute Unpinned Remote Code<![CDATA[ ## Vulnerability Details **File Location**: `README.md:23-40` **Vulnerability Type**: Mutable remote payload retrieval and execution **Risk Level**: Medium ### Vulnerable Code ```bash # Set your workspace (adjust if different) WORKSPACE="${OPENCLAW_WORKSPACE:-$HOME/.openclaw/workspace}" # Clone to your skills directory git clone https://github.com/tanchunsiong/pluribus.git "$WORKSPACE/skills/pluribus" # Make it executable chmod +x "$WORKSPACE/skills/pluribus/pluribus" # Option A: Add to PATH export PATH="$WORKSPACE/skills/pluribus:$PATH" # Option B: Create a symlink (if you have a tools folder) ln -sf "$WORKSPACE/skills/pluribus/pluribus" "$WORKSPACE/tools/pluribus" # Initialize your node pluribus init ``` ### Technical Analysis The documented installation process clones the repository's mutable default branch without pinning an immutable commit, release artifact, checksum, or cryptographic signature. It then marks a remotely obtained `pluribus` file executable, places it on `PATH` or creates a tool symlink, and invokes it. The audited artifact does not contain the referenced `pluribus` executable. Consequently, the actual code run by users following these instructions is outside the reviewed package and cannot be validated by this audit. Its contents may differ from the audited files or change after publication. This is best classified as remote payload retrieval and execution because installation retrieves executable content from an external URL and runs it, allowing the effective payload to change after review. No evidence was found that the current repository is malicious; the risk arises from mutable and unauthenticated-at-the-application-level installation behavior. ### Attack Path 1. An attacker compromises the upstream repository, its maintainer account, or the default branch before installation. 2. The attacker modifies or introduces the remotely referenced `pluribus` executable. 3. A user follows the README and clones the lates ...[truncated 1236 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Include the documented `pluribus` executable in the reviewed and distributed Skill artifact. 2. Publish versioned release artifacts rather than instructing users to execute code from a mutable default branch. 3. Pin installations to an immutable commit or signed release tag. 4. Publish a SHA-256 checksum and require verification before execution. 5. Use signed commits or release signatures and document verification steps. 6. Avoid adding newly downloaded directories to `PATH` before verifying their contents. 7. Ensure release automation verifies that documentation, packaged files, and audited source all refer to the same version. 8. If Git-based installation remains supported, use an immutable reference and verify it explicitly before execution. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (4)

Credential Access

High
Category
Privilege Escalation
Content
NODE_ID="node_$(echo "$(hostname)$(date +%s)$RANDOM" | sha256sum | cut -c1-12)"

# Get agent name from moltbook credentials or use hostname
AGENT_NAME=$(cat ~/.config/moltbook/credentials.json 2>/dev/null | jq -r '.agent_name // empty')
if [ -z "$AGENT_NAME" ]; then
    AGENT_NAME=$(hostname)
fi
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The README explicitly describes peer-to-peer coordination, Moltbook DM syncing, and local markdown storage, but it does not clearly warn users that data from the local workspace may be transmitted to external peers or third-party services. In an agent environment, users may assume a local-only skill; without prominent disclosure and consent language, agents or operators could unintentionally share sensitive offers, needs, signals, or memory content.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The skill instructs agents to publicly announce node details to an external service for discovery, but it does not clearly warn that this shares agent identity and network metadata outside the local machine. Even if the shared data seems limited, publishing identifiers, timestamps, and transport details can enable profiling, correlation of agent activity, and unwanted contact from untrusted peers.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The skill describes peer discovery and synchronization over Moltbook and DMs, including pushing outbox contents and pulling signals from peers, without a clear warning that local data will be transmitted to external parties. In the context of a decentralized agent coordination system, this is more dangerous because users may assume markdown storage is local-only, while sync operations can export observations, requests, peer relationships, and other potentially sensitive operational data to untrusted networks.

Static analysis

No suspicious patterns detected.