Back to skill

Security audit

Twitter Thread Creation

Security checks for vulnerabilities and agentic risk

Overview

The skill is aimed at Twitter/X thread creation, but its install and helper commands ask users to trust mutable remote code and broad CLI actions.

Install only if you trust inference.sh and are comfortable with its CLI posting to your X account. Prefer manual, version-pinned installation and checksum verification, avoid the curl-to-sh quick start, and treat the optional npx related-skill commands as separate installs requiring separate review.

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
SKILL.md:14
Finding
Unreviewed Remote Installation Script Executed Directly by the Shell<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, line 14 **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: High ### Vulnerable Code ```bash curl -fsSL https://cli.inference.sh | sh && infsh login ``` ### Technical Analysis The Quick Start command downloads mutable content from `https://cli.inference.sh` and pipes it directly into `sh`. Users cannot inspect or independently authenticate the script before it executes. Although the document states that the installer detects the operating system and architecture, downloads a binary, and verifies its SHA-256 checksum, that verification is performed by the remote script itself. A compromised installer can replace both the downloaded artifact and expected checksum or omit verification entirely. HTTPS protects data in transit but does not mitigate compromise of the hosting service, DNS or certificate infrastructure, deployment pipeline, or publisher account. Installing the CLI may be necessary to use the documented posting integration, but executing an unpinned remote script is not the minimum access required. The same result can be achieved through a version-pinned download, independent integrity verification, and a separate installation step. ### Attack Path 1. An attacker compromises `cli.inference.sh`, its deployment pipeline, hosting account, or another component capable of controlling the returned response. 2. The attacker modifies the installation script to include arbitrary shell commands. 3. A user follows the documented Quick Start command. 4. `curl` retrieves the attacker-controlled response and sends it directly to `sh`. 5. The payload executes immediately with the permissions and environment of the invoking user. 6. The payload can access files and credentials available to that user, alter local configuration, retrieve further payloads, or establish persistence where user permissions permit. ### Impact Assessment Successful exploitation provides arbit ...[truncated 561 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the `curl | sh` installation pattern. 2. Publish versioned CLI artifacts and pin the documentation to a specific reviewed release. 3. Provide separate download, verification, and installation commands so users can inspect each step. 4. Publish the expected SHA-256 digest through an independently trusted, immutable release channel. 5. Require users to compare the downloaded artifact's digest with the published value before execution. 6. Prefer a trusted package manager with signed metadata or cryptographically signed release artifacts. 7. Document the exact files, directories, network endpoints, and permissions used by the installer. 8. Keep installation separate from `infsh login` so successful installation does not immediately lead users into an authentication flow. 9. Avoid elevated installation privileges and place the binary in a user-controlled location when possible. A safer workflow should resemble: ```bash curl -fL -o infsh https://dist.inference.sh/releases/<pinned-version>/<platform>/infsh printf '%s %s\n' '<independently-published-sha256>' infsh | sha256sum -c - chmod 0755 infsh install -m 0755 infsh "$HOME/.local/bin/infsh" ``` The artifact URL, version, and digest must be real, release-specific values published through trusted release metadata rather than placeholders. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:255
Finding
Unpinned Third-Party Skill Installation Through npx<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 255–257 **Vulnerability Type**: Insecure third-party dependencies and mutable Skill sources **Risk Level**: Medium ### Vulnerable Code ```bash npx skills add inference-sh/skills@linkedin-content npx skills add inference-sh/skills@content-repurposing npx skills add inference-sh/skills@social-media-carousel ``` ### Technical Analysis The commands invoke tooling through `npx` and install related Skills using mutable names rather than immutable, reviewed versions or commit hashes. Depending on local cache state and `npx` behavior, package tooling may be downloaded and executed from a registry. The referenced Skill content may also change after this project has been audited. This creates multiple supply-chain trust points, including the package registry, package maintainer account, Skill repository, release process, and transitive dependencies. A compromise at any of these points could cause future users to retrieve content different from what was originally reviewed. These installations are listed as related Skills and are not required for the declared Twitter/X thread-writing functionality. Recommending execution of mutable third-party tooling and installation of unrelated components therefore expands the trust boundary beyond the minimum necessary scope. ### Attack Path 1. An attacker compromises the package or Skill publisher account, registry entry, source repository, or release pipeline. 2. The attacker publishes a malicious or altered version under one of the mutable package or Skill references. 3. A user follows one of the documented `npx skills add` commands. 4. `npx` retrieves or runs the current package tooling, and the command resolves the current Skill content. 5. The malicious dependency or Skill is executed, installed, or later loaded by the agent. 6. The altered component can perform actions allowed by its runtime permissions or manipulate future agent behavior through ma ...[truncated 686 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the optional installation commands unless they are necessary for the declared functionality. 2. Pin the `npx` package runner or package to an exact reviewed version rather than resolving the latest available release. 3. Pin each related Skill to an immutable commit hash, signed release, or content digest. 4. Verify package provenance, signatures, and integrity before installation. 5. Review the source and transitive dependencies of the resolved package and Skills. 6. Use lockfiles or equivalent integrity metadata where the installation mechanism supports them. 7. Run dependency installation in a sandbox with restricted filesystem, credential, and network access. 8. Avoid exposing authentication tokens or sensitive environment variables during package installation. 9. Document that these Skills are optional and originate from separate trust domains. 10. Establish a recurring dependency review process before updating pinned versions. ]]>
Vulnerability Patterns
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (7)

External Script Fetching

High
Category
Supply Chain
Content
## Quick Start

```bash
curl -fsSL https://cli.inference.sh | sh && infsh login

# Post a tweet
infsh app run x/post-create --input '{
Confidence
98% confidence
Finding
`curl ... | sh` executes a remote script directly from the network without prior local inspection, which is a classic supply-chain and remote code execution risk. Even with accompanying claims about checksum verification, users are still instructed to trust and execute whatever the remote endpoint serves at runtime, and those claims themselves should not reduce suspicion.

Vague Triggers

Medium
Confidence
95% confidence
Finding
The trigger list is very broad and includes generic social-media phrases, which raises the chance this skill will be invoked in situations not specifically requesting thread creation. Because the skill also documents external actions like posting and research, accidental invocation could lead to unintended network actions or content generation under the wrong context.

Description-Behavior Mismatch

Medium
Confidence
91% confidence
Finding
The declared purpose is Twitter/X thread creation, but the implementation also performs external research and webpage screenshot capture. This mismatch can cause operators or orchestration systems to grant the skill more trust or broader invocation than warranted, making unintended browsing or data collection more likely.

Context-Inappropriate Capability

Medium
Confidence
94% confidence
Finding
The skill includes browser and search capabilities that go beyond simple thread-writing guidance, expanding it into external content retrieval and webpage interaction. This increases attack surface by enabling access to untrusted remote content, which could lead to unsafe data handling, misleading outputs, or unintended interaction with sensitive URLs if invoked broadly.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Static analysis

No suspicious patterns detected.