Back to skill

Security audit

Slack Gif Creator Anthropic

Security checks for vulnerabilities and agentic risk

Overview

This skill is a coherent Slack GIF creation helper; its main risk is ordinary dependency hygiene, not hidden or harmful behavior.

Install this in an isolated Python environment as a normal user. For higher-assurance use, pin the listed dependencies with hashes or a lockfile before installing, and be cautious when processing untrusted image files because image parsers can have vulnerabilities.

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

T08 · Insecure Dependencies

Warning
Location
requirements.txt:1
Finding
Unpinned and Unverified Third-Party Dependencies<![CDATA[ ## Vulnerability Details **File Location**: `requirements.txt:1-4`; related installation guidance at `SKILL.md:250-254` **Vulnerability Type**: Supply-chain exposure through mutable dependency resolution **Risk Level**: Medium ### Vulnerable Code ```text pillow>=10.0.0 imageio>=2.31.0 imageio-ffmpeg>=0.4.9 numpy>=1.24.0 ``` Related installation guidance: ```bash pip install pillow imageio numpy ``` ### Technical Analysis Every dependency in `requirements.txt` uses a lower-bound constraint rather than an exact, reviewed version. Consequently, each installation can resolve to a different future package release. The project also provides no lockfile or cryptographic hashes with which to verify downloaded distributions. The installation command in `SKILL.md` independently asks package installers to retrieve the latest compatible versions and omits the declared `imageio-ffmpeg` dependency. This discrepancy reduces reproducibility and may cause users to install an incomplete or differently resolved environment. No evidence was found that any currently named package is malicious. The vulnerability is the absence of dependency integrity and reproducibility controls, which increases exposure to compromised upstream releases, registry-account compromise, and unexpected incompatible changes. ### Attack Path 1. An attacker compromises the publishing account, build infrastructure, or distribution process of one of the declared packages. 2. The attacker publishes a malicious version satisfying the broad lower-bound constraint. 3. A user installs the project dependencies using `pip install -r requirements.txt` or follows the command in `SKILL.md`. 4. The package installer resolves and downloads the malicious release because no exact version or artifact hash is enforced. 5. Attacker-controlled package code can execute during installation, import, or normal library use with the privileges of the user running the project. This path requires compromise of an ...[truncated 792 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace lower-bound constraints with exact versions that have been reviewed and tested, for example: ```text pillow==<reviewed-version> imageio==<reviewed-version> imageio-ffmpeg==<reviewed-version> numpy==<reviewed-version> ``` 2. Generate and commit a dependency lockfile appropriate for the supported Python environments. 3. Record SHA-256 hashes for every permitted distribution and install with hash verification, such as: ```bash python -m pip install --require-hashes -r requirements.lock ``` 4. Ensure the installation command in `SKILL.md` uses the same locked manifest and includes `imageio-ffmpeg`. 5. Use an automated dependency update process that runs tests and requires review before changing locked versions or hashes. 6. Install dependencies in an isolated virtual environment as a non-privileged user. 7. Consider using a controlled package mirror and dependency vulnerability scanning in CI. ]]>
Vulnerability Patterns
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (6)

Unpinned Dependencies

Low
Category
Supply Chain
Content
pillow>=10.0.0
imageio>=2.31.0
imageio-ffmpeg>=0.4.9
numpy>=1.24.0
Confidence
97% confidence
Finding
The dependency is specified with a lower bound only, which allows builds to resolve to different future versions over time. This weakens reproducibility and can inadvertently introduce vulnerable or breaking releases through the supply chain.

Unverifiable Dependency: pillow has 16 known advisory(ies) (CVE-2016-2533 (Pillow buffer overflow in ImagingPcdDecode); CVE-2023-50447 (Arbitrary Code Execution in Pillow); CVE-2021-27922 (Pillow Uncontrolled Resource Consumption) +13 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
90% confidence
Finding
Pillow has multiple historical advisories, including issues relevant to image parsing such as resource exhaustion and potential code-execution scenarios. Because the manifest does not pin a specific version, it is impossible to verify from this file alone whether deployments avoid affected releases, which is more concerning in a GIF/image-processing skill that may handle untrusted media.

Unpinned Dependencies

Low
Category
Supply Chain
Content
pillow>=10.0.0
imageio>=2.31.0
imageio-ffmpeg>=0.4.9
numpy>=1.24.0
Confidence
97% confidence
Finding
Using an unpinned minimum version for imageio means installations are not deterministic and may pull in unexpected upstream changes. That increases supply-chain risk and makes it harder to verify whether deployed environments are using reviewed versions.

Unpinned Dependencies

Low
Category
Supply Chain
Content
pillow>=10.0.0
imageio>=2.31.0
imageio-ffmpeg>=0.4.9
numpy>=1.24.0
Confidence
97% confidence
Finding
The imageio-ffmpeg package is not pinned to a fixed release, so future installs may resolve to different versions than were tested. For media-processing tools, this can expose the skill to newly introduced vulnerable code or behavior changes in transitive/native components.

Unpinned Dependencies

Low
Category
Supply Chain
Content
pillow>=10.0.0
imageio>=2.31.0
imageio-ffmpeg>=0.4.9
numpy>=1.24.0
Confidence
97% confidence
Finding
An unpinned numpy dependency permits non-reproducible installations and complicates assurance that a safe version is deployed. Because numpy is widely used and occasionally affected by security advisories, lack of pinning increases uncertainty and supply-chain exposure.

Unverifiable Dependency: numpy has 16 known advisory(ies) (CVE-2014-1859 (Numpy arbitrary file write via symlink attack); CVE-2021-41495 (NumPy NULL Pointer Dereference); CVE-2021-33430 (NumPy Buffer Overflow (Disputed)) +13 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
88% confidence
Finding
Numpy has known historical advisories, and without a pinned version there is no reliable way to determine whether an installed release is affected. While the direct exploitability depends on how numpy is used, the lack of version certainty creates avoidable supply-chain and vulnerability-management risk.

Static analysis

No suspicious patterns detected.