Back to skill

Security audit

Social Media Carousel

Security checks for vulnerabilities and agentic risk

Overview

This skill is mostly aligned with carousel generation, but its quick-start install path asks users to run a mutable remote shell installer and optional unpinned installs.

Review this skill before installing. Its carousel advice is coherent, but do not run the quick-start installer unless you trust inference.sh and are comfortable executing a remote shell script under your user account. Prefer a manually downloaded, version-pinned, signature- or checksum-verified CLI, and treat the optional related-skill npx commands as separate unreviewed installs.

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
Mutable Remote Installer Executed Directly by the Shell<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md: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 instructions download a mutable script from an external URL and immediately pipe it into `sh`. The user has no opportunity to inspect the downloaded content, and the command does not pin a version, expected cryptographic digest, or publisher signature before execution. The later statement that the installer verifies the downloaded CLI binary does not secure the installer script itself. A compromised or subsequently modified installer can execute arbitrary commands before performing—or instead of performing—the claimed binary verification. Installing a CLI is relevant to the Skill's declared functionality, but executing an unverified remote response directly in a shell exceeds the minimum privilege and trust required. A manual installation procedure using an immutable artifact and independently verified signature or checksum would reduce this exposure. ### Attack Path 1. A user or agent follows the documented Quick Start command. 2. `curl` retrieves the current response from `https://cli.inference.sh`. 3. The response is passed directly to `sh` without inspection or pre-execution verification. 4. An attacker who compromises the hosting service, release infrastructure, DNS/TLS path, or installer publication process substitutes malicious shell commands. 5. Those commands execute with the privileges of the user running the Skill instructions. 6. The command subsequently invokes `infsh login`; if the attacker installed or replaced that executable, it can intercept authentication information or display a spoofed login flow. ### Impact Assessment Successful exploitation provides arbitrary command execution under the invoking user's account. This can permit access to files and credenti ...[truncated 449 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the `curl | sh` installation pattern from the Quick Start instructions. 2. Pin the CLI to a specific immutable version and trusted artifact URL. 3. Download the artifact to a local file without executing it. 4. Verify it using a publisher-authenticated signature. If signatures are unavailable, publish and pin the expected SHA-256 digest in the reviewed Skill rather than retrieving both the artifact and checksum from the same mutable source. 5. Inspect or verify the installer separately if an installer remains necessary. 6. Install the verified artifact using the least-privileged destination available; do not require administrator privileges unless strictly necessary. 7. Place `infsh login` in a separate command so authentication occurs only after the user has verified the installed executable. 8. Document the files, network endpoints, and credentials the CLI accesses during installation and login. A safer workflow would be: ```bash curl -fLo infsh "<version-pinned-artifact-url>" echo "<reviewed-sha256> infsh" | sha256sum -c - chmod 0755 infsh # Move to a user-controlled executable directory, then authenticate separately. ``` ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:209
Finding
Unpinned Third-Party Skill and Command Runner Installation Instructions<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:209-211` **Vulnerability Type**: Insecure third-party dependency resolution **Risk Level**: Medium ### Vulnerable Code ```bash npx skills add inference-sh/skills@ai-image-generation npx skills add inference-sh/skills@content-repurposing npx skills add inference-sh/skills@linkedin-content ``` ### Technical Analysis The optional Related Skills commands use `npx` without pinning the invoked `skills` package to a reviewed version. The referenced Skill identifiers are also not pinned to immutable versions, release digests, or commit hashes. Consequently, the code and instructions resolved when a user runs these commands may differ from what existed when this project was audited. The project contains no lockfile, vendored dependency, digest, or signature that would allow users to confirm that the resolved components match reviewed content. This is a supply-chain risk rather than proof that the currently referenced packages are malicious. Exploitation requires compromise or malicious modification of one of the mutable upstream components or its distribution channel. ### Attack Path 1. A user follows one of the Related Skills installation commands. 2. `npx` resolves and runs a current version of the external `skills` package rather than a version fixed by this project. 3. The command retrieves the referenced external Skill from mutable upstream content. 4. An attacker compromises an upstream account, package, repository, release process, or dependency and publishes malicious content. 5. The user receives and installs content that was not part of this audit. 6. Any execution capability granted to that package or installed Skill can then be used with the privileges of the invoking user or agent. ### Impact Assessment The exact impact depends on the behavior and permissions of the resolved `npx` package and installed Skills. A malicious dependency could potentially execute commands, alter files acce ...[truncated 342 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the `skills` command-line package to an exact reviewed version instead of invoking an unspecified current version through `npx`. 2. Pin each external Skill to an immutable release, commit hash, or content digest. 3. Document the authoritative registry or repository from which every component is resolved. 4. Verify downloaded content using publisher signatures or reviewed cryptographic hashes. 5. Use lockfiles or vendored, reviewed artifacts where supported. 6. Disable or avoid dependency lifecycle scripts unless they are required and have been audited. 7. Treat these commands as optional and warn users that they install separately maintained third-party content. 8. Re-audit pinned dependencies before updating their 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

# Generate a carousel slide
infsh app run infsh/html-to-image --input '{
Confidence
98% confidence
Finding
The skill instructs users to pipe a remote script directly into sh, which allows arbitrary code execution from a network-fetched resource at install time. Even with claims about checksum verification, this pattern is dangerous because it bypasses independent review of the fetched script and inherits compromise risk from the hosting endpoint or delivery chain.

Description-Behavior Mismatch

Medium
Confidence
91% confidence
Finding
The manifest presents the skill as content/design guidance, but the body operationalizes remote generation through inference.sh services. This mismatch can mislead operators about the trust boundary and cause unexpected networked execution or data transfer when a user expects only static advice.

Vague Triggers

Medium
Confidence
95% confidence
Finding
The description's trigger list includes terms like "carousel," "slide post," and "educational content," which are broad and not tightly scoped to this specific skill invocation context. Without clearer constraints or negative examples, the skill could be invoked for common social-media or presentation-related requests beyond the intended carousel-design use case.

Context-Inappropriate Capability

Medium
Confidence
93% confidence
Finding
The skill declares broad Bash execution capability even though its stated purpose is carousel design guidance. Granting shell access expands the attack surface substantially and could enable unintended command execution if the skill is invoked in automation or combined with prompt-manipulated content.

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.