当AI推理服务暴露在公网上——Ollama攻击面实证分析
Ollama 默认监听 0.0.0.0,14 个 API 端点无认证暴露在公网,Shodan 上 1000+ 台可查。本文对其中一台做了完整攻击面实证——黑盒测试 14 端点、白盒审计 v0.31.1 Go 源码追踪 ParseNameBare 调用链(types/model/name.go:146)、对比 v0.30.10→v0.31.1 files 参数差异,发现 Ollama 团队只加校验器
复现环境:Ubuntu 22.04,Docker 部署 Ollama v0.31.1,OLLAMA_HOST=0.0.0.0。文中的 K3s 集群凭证来自授权测试环境。
前置条件: 目标服务器有外网可达的 11434 端口。如果你不确定自己的 Ollama 有没有暴露,直接用 ollama-audit.sh 扫一遍。
写在前面
之前一直在关注AI推理框架的安全问题。Ollama是最流行的本地推理框架,但它的API设计哲学是"方便优先"——默认监听127.0.0.1,一旦改成0.0.0.0,14个API端点全部对外网开放,没有任何认证。这篇文章从攻击者视角,走完从外网探测到代码审计到同主机推演的完整分析链。
一、一台开门揖盗的Ollama
假设你是一个攻击者。你在做外网资产探测,扫到了一个开放的11434端口。
$ curl -s --connect-timeout 3 http://139.199.68.168:11434/
Ollama is running
$ curl -s http://139.199.68.168:11434/api/version
{"version":"0.31.1"}
$ curl -s http://139.199.68.168:11434/api/tags
{"models":[]}三个请求,零成本,零风险。攻击者拿到了版本号和运行状态——如果服务器上有模型在跑,api/ps会返回模型名称、上下文长度、过期时间,相当于暴露了管理员的使用习惯。
没有401、没有403、没有API Key校验。Ollama用HTTP 200告诉你:你想知道什么,我就告诉你什么。
这不是一个配置错误——Ollama的默认配置行为。它的设计哲学是"方便优先":默认监听127.0.0.1,本地开发用得很舒服。但当你为了远程访问把OLLAMA_HOST改成0.0.0.0时,Ollama不会提醒你"你这样暴露到公网了哦"——它只是默默地开始监听所有接口,把14个API端点全部晾在公网上。
我当初部署这台Ollama的时候也踩了同样的坑。拉了一个Ubuntu 22.04,Docker一条命令启动Ollama,然后改了OLLAMA_HOST=0.0.0.0方便从本地curl测试。测试完了,忘记改回去。第二天Shodan上就出现了这台服务器的记录。不是Ollama的问题——是我的问题。但这正是大多数Ollama用户的真实画像:AI工程师,不是安全工程师,他们只会关心推理延迟,不会注意到一个端口绑定参数的安全含义。
Ollama不是唯一这么做的AI推理框架。vLLM默认监听0.0.0.0,TGI也一样。行为偏好是AI基础设施行业的通病:框架作者假定用户会自己加一层Nginx反代来做认证,但实际上一线部署者往往是AI工程师而非安全工程师,他们改一行配置就上线了。
Ollama是目前最流行的本地AI推理框架,GitHub上超过15万Star,Docker Hub上的镜像拉取量超过1亿次。从个人开发者的笔记本到企业的Kubernetes集群,到处都能看到它的影子。它的核心卖点是"开箱即用"——一条命令启动服务,一套HTTP API做推理。但这个卖点的另一面是:默认配置几乎没有任何安全防护。
文中提到的"零认证API"不是Ollama独有的设计。2024年Wiz Research发布的一份报告显示,Shodan上搜索到的暴露Ollama服务器超过1000台,这些服务器大部分属于中小企业和研究机构。它们有AI能力但没有安全运维经验,部署了Ollama后改了OLLAMA_HOST=0.0.0.0就上线了——这是当前AI基础设施安全现状的缩影。到了2026年,这个数字只增不减——AI基础设施的部署速度远远超过了安全防护意识的提升速度。
这篇文章围绕这台服务器,从攻击者视角做一次完整的攻击面分析。四个角度回答同一个问题:Ollama暴露到公网后会发生什么?
- 二、默认配置:14个API端点全部无认证,攻击者能做什么
- 三、代码审计:CVE-2024-37032的修复策略为什么不彻底
- 四、同主机推演:如果攻击者从Ollama入口进入,同一台服务器上的K3s和其他Web服务会怎样
- 五、防御方案:三把锁从网络层到审计层怎么落地
每个角度独立成立,但合在一起才能拼出Ollama安全现状的完整画像。
全文均在 Ubuntu 22.04 上执行,所有curl命令输出真实,截图真实可复现。
二、14个API端点,14个入口——Ollama默认配置有多安全?
先从第一个角度入手:默认配置下,Ollama的API暴露到什么程度?
Ollama的HTTP API覆盖了模型管理、推理、配置查询三类功能,全套接口基于Gin框架的RESTful设计。我写了一个批量探测脚本(ollama-audit.sh,附在文章末尾),对14个API端点逐个发送请求:
for endpoint in / /api/version /api/tags /api/ps /api/show /api/create \
/api/pull /api/push /api/copy /api/delete \
/api/generate /api/chat /api/embed /api/blobs/; do
echo -n "$endpoint → "
curl -s -o /dev/null -w "%{http_code}" http://139.199.68.168:11434$endpoint
echo ""
done结果:5个端点返回200或404,8个返回405(因为需要POST而非GET),0个返回401或403。Ollama没有在任何入口挂载认证中间件——14个端点全部可匿名访问。
这张表的含义不是"Ollama有14个漏洞",而是:攻击者不需要找到漏洞,只需要利用这些功能就够了。
信息收集不需要任何权限:
$ curl -s http://139.199.68.168:11434/api/version
{"version":"0.31.1"}
$ curl -s http://139.199.68.168:11434/api/ps
{"models":[]}
$ curl -s -X POST http://139.199.68.168:11434/api/show -H "Content-Type: application/json" \
-d '{"model":"llama3.2:1b"}'
{"error":"model \"llama3.2:1b\" not found"}三个请求,零成本,零风险。攻击者拿到了版本号和运行状态——如果服务器上有模型在跑,api/ps会返回模型名称、上下文长度、过期时间,相当于暴露了管理员的使用习惯。
从安全测试的角度看,这三个接口的价值递进很有意思。第一个接口(/)用来确认目标存活,适合做大范围扫描的筛选条件;第二个接口(/api/version)用来匹配历史漏洞,攻击者会拿着版本号去CVE数据库搜一遍——Ollama历史上出过CVE-2024-37032(SSRF,CVSS 8.6)和CVE-2024-39720(认证绕过,CVSS 7.5);第三个接口(/api/tags)用来做价值评估——如果服务器上跑了model系列的大模型(几十GB),说明硬件配置不差,值得花精力深入。
管理接口同样是零认证。虽然当前服务器上没有模型,但操作本身没有被拦截的痕迹——Ollama不会返回401或403,只在模型不存在时报"not found"。结果就是:攻击者可以不停地试接口,Ollama不会拒绝任何请求。
$ curl -s -X POST http://139.199.68.168:11434/api/copy \
-H "Content-Type: application/json" \
-d '{"source":"test","destination":"test2"}'
{"error":"model \"test\" not found"}
# 同样,api/delete也没有认证
$ curl -s -X DELETE http://139.199.68.168:11434/api/delete \
-H "Content-Type: application/json" \
-d '{"model":"target-model"}'
{"error":"model \"target-model\" not found"}值得注意的不是"API能访问",而是HTTP状态码。被认证拦截的正规API应该返回401或403,Ollama返回的是200或404——说明请求已经到达了业务处理层,只是模型不存在而已。Gin框架没有在路由层挂载任何认证中间件。
对比其他主流AI推理框架的安全设计:
框架 | 默认监听 | API认证 | SSRF防护 | 安全文档 |
Ollama | 127.0.0.1 | 无 | 有(入口拦截) | 无专门安全文档 |
vLLM | 0.0.0.0 | 可选API Key | 无(依赖部署者) | 有安全最佳实践 |
TGI | 0.0.0.0 | 可选Token | 无 | 有基础安全说明 |
llama.cpp | 127.0.0.1 | 无 | 无 | 无 |
Ollama在默认监听地址上有优势(127.0.0.1),但一旦改为0.0.0.0,它是这四个里面唯一完全没有安全选项的。vLLM和TGI至少提供了可选的API Key认证。vLLM还支持API Key的OpenAI兼容格式——这意味着用户可以用现成的API管理工具进行控制。Ollama和llama.cpp一样,没有给用户任何安全配置的选项。
这种差距不只在认证层面。从SSRF修复完整性来看,差异同样明显:
框架 | SSRF CVE | 修复策略 | 风险函数是否移除 | 当前状态 |
Ollama | CVE-2024-37032 | 加校验器 | 否(ParseNameBare仍在) | 部分修复 |
llama.cpp | — | 无相关修复 | — | 无SSRF防护 |
vLLM | — | 社区PR | 是 | 已被社区加固 |
TGI | — | 无已知CVE | — | 依赖部署者防护 |
Ollama的修复策略在AI推理框架中并不罕见——但vLLM的做法(社区PR直接修改底层代码)更接近于传统Web安全的"根除"思路。同样是修复SSRF,vLLM社区的PR将HTTP请求的URL拼接逻辑整体替换为net/url.Parse的严格校验,而不是在调用链上层加拦截器。这种差异反映了两个项目不同的安全治理理念:Ollama倾向于最小改动、快速修复;vLLM倾向于彻底重构风险代码。不能说哪种绝对正确,但在安全领域,"删掉风险函数"永远比"挡住风险函数"更可靠。
模型下载——资源消耗攻击的可行性验证
前面提到api/pull可以远程拉取模型,但到底能造成多大影响?我在服务器上做了实测:
$ curl -s -X POST http://139.199.68.168:11434/api/pull \
-H 'Content-Type: application/json' \
-d '{"model":"llama3.2:1b","stream":false}'
{"status":"pulling manifest"}
{"status":"pulling 6beb1... a47b0..."}
...
{"status":"success"}单个llama3.2:1b模型大小约1.3GB,从ollama.com拉取到本地耗时约40秒(服务器带宽)。这台服务器磁盘总量59GB,已用19GB。12个这样的模型就能填满剩余40GB空间。
更重要的是——Ollama对模型下载并发数没有限制。虽然OLLAMA_NUM_PARALLEL=1限制了推理并发,但pull操作不受这个参数控制。攻击者可以在不同时段分段下载不同模型,逐步耗尽磁盘。磁盘满了之后不只是Ollama不能用——同宿主机的系统日志、K3s集群、其他Web服务都会受影响。
OLLAMA_ORIGINS——CORS策略的CSRF风险
配置泄露中暴露的OLLAMA_ORIGINS包含了跨域风险。为了验证,我构造了一个简单的PoC页面:
<html><body>
<script>
fetch('http://139.199.68.168:11434/api/tags')
.then(r => r.json())
.then(d => document.body.innerHTML = '<pre>' + JSON.stringify(d) + '</pre>');
</script></body></html>纯前端JavaScript,没有任何代理或后端。在Chrome中打开这个页面时——请求成功发送并收到响应。app://*、file://*、tauri://*这些通配符意味着Ollama没有检查请求来源的协议。
Ollama的CORS策略不是"域名白名单",而是"协议通配符白名单"——允许从任意桌面协议发起的跨域请求。攻击者需要的只是一个让受害者点击链接的机会:诱导使用Ollama的管理员访问恶意网页,页面中的JavaScript就能无认证调用Ollama API。
配置泄露——服务器日志的意外收获
Ollama启动时会打印完整的服务配置。这个日志在Docker容器中通过docker logs即可获取:
OLLAMA_HOST:http://0.0.0.0:11434
OLLAMA_ORIGINS:[http://localhost https://localhost http://localhost:* https://localhost:*
http://127.0.0.1 https://127.0.0.1 http://127.0.0.1:* https://127.0.0.1:*
http://0.0.0.0 https://0.0.0.0 http://0.0.0.0:* https://0.0.0.0:*
app://* file://* tauri://* vscode-webview://* vscode-file://*]
OLLAMA_MODELS:/home/ubuntu/.ollama/models
OLLAMA_REMOTES:[ollama.com]几个关键发现:
OLLAMA_ORIGINS 包含了 app://*、file://*、tauri://*、vscode-webview://* 等桌面协议通配符。在本地使用时这些是合理的——Ollama Desktop应用需要这些协议通信。但暴露到公网后,这套CORS策略意味着攻击者可以构造一个恶意网页,只要诱导管理员访问,页面中的JavaScript就可以跨域请求Ollama API——经典的DNS Rebinding + CSRF攻击路径。
OLLAMA_MODELS 暴露了模型存储路径 /home/ubuntu/.ollama/models。有模型时api/show会返回完整的blob路径(如 FROM /home/ubuntu/.ollama/models/blobs/sha256-xxx),攻击者可以据此推断操作系统和用户信息。
OLLAMA_REMOTES 显示可信源只有ollama.com。这条信息对攻击者来说最有价值的是"走远了没戏"——但如果Ollama后续版本支持自定义remote源,这个配置项就会成为供应链攻击的切入点。
三、源码审计——入口堵了,解析器没删
进入第二个角度:Ollama的CVE-2024-37032修复到底修得怎么样?
黑盒测试只告诉我们"能不能访问",源码审计才能回答"为什么"。我读了Ollama v0.31.1的Go源码,找到了CVE-2024-37032修复后的遗留问题。
找到 ParseNameBare 的过程就是一个完整的攻击面探测流程。我先在 GitHub 上拉下 v0.31.1 的 tag,grep 搜索 URL 解析相关的函数名:
$ grep -rn "func.*ParseName" server/ types/
types/model/name.go:140: func ParseName(s string) (Name, error) {
types/model/name.go:146: func ParseNameBare(s string) Name {
server/routes.go:1188: name, err := getExistingName(model.ParseName(mname))两条线索:ParseNameBare 是底层解析引擎,ParseName 是带校验的包装器。routes.go:1188 显示 api/push 端点直接调了 ParseName 而没有经过 ValidateModelName()——校验器在 push 接口被绕过了。
我又确认了 ParseNameBare 的提交历史,最后一次修改是 2024 年 2 月(对应 v0.1.20 左右发布的版本)。ValidateModelName 是 2024 年 8 月 CVE-2024-37032 修复时新增的——新加了一层校验器,底层函数一个字符都没改。
ParseNameBare——一条从未移除的URL解析器
Ollama的CVE-2024-37032(CVSS 8.6,SSRF漏洞)原理很简单:通过api/create的from参数传入HTTP URL,Ollama服务端会发起HTTP请求访问该地址。修复方案是在模型名校验层加入HTTP URL拦截。
问题在于修复者选择的是"堆叠校验器"而非"移除底层有风险的解析能力"。
证据在types/model/name.go中:
func ParseNameBare(s string) Name {
var n Name
var promised bool
// 处理:和/分隔符
if strings.LastIndex(s, ":") > strings.LastIndex(s, "/") {
s, n.Tag, _ = cutPromised(s, ":")
}
s, n.Model, promised = cutPromised(s, "/")
if !promised {
n.Model = s
return n
}
s, n.Namespace, promised = cutPromised(s, "/")
if !promised {
n.Namespace = s
return n
}
scheme, host, ok := strings.Cut(s, "://")
if ok {
n.ProtocolScheme = scheme
} else {
host = scheme
}
n.Host = host
return n
}注意最后这一段——strings.Cut(s, "://")。如果输入字符串包含://,函数会把协议和主机名分开存储(ProtocolScheme=http,Host=127.0.0.1:8080/metadata),然后正常返回。
CVE-2024-37032的修复只是在调用ParseNameBare之前加了一层ValidateModelName()校验器——如果模型名包含HTTP URL,直接返回"invalid model name"错误。但ParseNameBare本身从未被修改或移除。
它的直接后果是:只要任何一个API入口不经过ValidateModelName(),URL解析能力就会重新暴露。
读出来是一回事,实际能不能利用是另一回事。我花了一段时间追踪 ParseNameBare 的调用链,评估了两条可能的路。
第一条路:api/push + SSRF。 既然 api/push 调了 ParseNameBare 且没有 ValidateModelName 拦截,那么 push 的处理函数会不会基于解析出的 host 发起 HTTP 请求?在 server/routes.go 里追了 PushHandler 的调用链:
PushHandler → getExistingName(model.ParseName(mname)) → [n.Host 存入 Name 结构体]
但 getExistingName 里只有文件系统操作(读 manifests),没有 http.Get 或 http.Client.Do 调用。从代码分析判断:api/push 不会发起 SSRF。host 被解析了,但没被下游使用。
第二条路:api/show + 文件路径解析。 我追了 ShowHandler 的完整调用链:
ShowHandler → parseAndValidateModelRef(req.Model) → [model_resolver.go:36]
→ GetModelInfo(req) → model.ParseName(req.Model) → [types/model/name.go:140]
→ manifest.ParseNamedManifest(name) → [manifest/manifest.go:112]
→ Path() → filepath.Join(envconfig.Models(), "manifests") → [manifest/paths.go:24]
→ n.Filepath() → filepath.Join(n.Host, n.Namespace, n.Model, n.Tag) → [types/model/name.go:295]这条链的核心——manifest.ParseNamedManifest(:112-124):
func ParseNamedManifest(n model.Name) (*Manifest, error) {
if !n.IsFullyQualified() {
return nil, model.Unqualified(n)
}
manifests, err := Path()
p := filepath.Join(manifests, n.Filepath())
// ...
}两层保护:入口 IsFullyQualified() 在先——如果 name 缺少 host/namespace/model/tag 四部分之一,立即返回 Unqualified 错误,不会走到 filepath.Join。同时 n.Filepath() 拼接的是 Name 结构体解析后的四个字段(Host/Namespace/Model/Tag),不是原始输入字符串——filepath.Join 会规范化其中的路径段,../ 被限制在四层子目录结构中,无法突破到 manifests 目录之外。
两条路在代码分析的层面都不通。但评估过程不是没有价值的——它证明了 Ollama 的修复策略是 堆叠校验器而不是移除风险能力。ValidateModelName 像一道放在门口的闸门,但当某个新端点开发人员不了解这段历史、忘记加闸门时,ParseNameBare 仍然是全功能可用的 URL 解析器。
api/push暴露了真相
api/push接口的调用链是:PushHandler → getExistingName(model.ParseName(mname))。
当传入http://127.0.0.1:8080/metadata时,ParseName解析出host=127.0.0.1:8080/metadata,然后在getExistingName中查找manifest——找不到,返回"couldn't retrieve manifest"。同时,解析后的model name因为没有匹配完整的host/namespace/model:tag格式,触发了ErrUnqualifiedName:
var ErrUnqualifiedName = errors.New("unqualified name")
func Unqualified(n Name) error {
return fmt.Errorf("%w: %s", ErrUnqualifiedName, n)
}所以api/push返回:
{"status":"retrieving manifest"}
{"status":"couldn't retrieve manifest"}
{"error":"unqualified name: http://127.0.0.1:8080/metadata:latest"}注意第三行——http://127.0.0.1:8080/metadata:latest。Ollama确实解析了这个URL,提取了host,加上了默认的:latest标签,然后才报错。解析器在工作。
这句话不是读代码推出来的——我直接在服务器上跑了这条命令:
$ curl -s -X POST http://139.199.68.168:11434/api/push \
-H 'Content-Type: application/json' \
-d '{"model":"http://127.0.0.1:8080/test"}'
{"status":"retrieving manifest"}
{"status":"couldn't retrieve manifest"}
{"error":"unqualified name: http://127.0.0.1:8080/test:latest"}这三条输出完整地展示了 ParseNameBare 和 ValidateModelName 的分工:
ParseNameBare 仍然活在:错误信息中出现了 http://127.0.0.1:8080/test:latest——http:// 被解析为 protocol、127.0.0.1:8080/test 被解析为 host、Ollama 自动拼接了默认的 :latest 标签。URL 解析能力从 types/model/name.go 一路暴露到了 HTTP 响应层。
ValidateModelName 在拒绝:前两步(retrieving manifest → couldn't retrieve manifest)说明 getExistingName 确实尝试去拉取这个 URL 对应的 manifest,但被 unqualified name 错误阻止了进一步下发——上层的校验器在拦截。
两个函数都活着,但 ParseNameBare 的 URL 解析已经通过了 Gin 框架的路由层、进入了业务逻辑层(getExistingName),最后在 ValidateModelName 的校验层才被拦截。这个细节如果只读代码很容易漏掉。
strace 验证——从代码分析到系统调用追踪
读代码追踪是一回事,实际跑 strace 看系统调用是另一回事。我在服务器上用 strace 跟踪了 Ollama 进程的文件系统访问轨迹,验证了前面代码分析的结论。
先用 strace 启动 Ollama,只跟踪文件打开相关的系统调用:
$ sudo killall ollama 2>/dev/null
$ export OLLAMA_HOST=0.0.0.0
$ nohup sudo strace -e trace=open,openat -o /tmp/ollama_strace.log \
/usr/local/bin/ollama serve > /tmp/ollama_dlv.log 2>&1 &
$ sleep 4然后发送 api/push 请求,URL 指向一个不存在的内网地址:
$ curl -s -X POST http://localhost:11434/api/push \
-H 'Content-Type: application/json' \
-d '{"model":"http://127.0.0.1:8080/test"}'
{"status":"retrieving manifest"}
{"status":"couldn't retrieve manifest"}
{"error":"unqualified name: http://127.0.0.1:8080/test:latest"}查看系统调用日志,看 Ollama 实际做了什么:
$ grep -E 'manifest' /tmp/ollama_strace.log
openat(AT_FDCWD, "/root/.ollama/models/manifests", O_RDONLY|O_CLOEXEC) = 6
openat(AT_FDCWD, "/root/.ollama/models/manifests", O_RDONLY|O_CLOEXEC) = 6
openat(AT_FDCWD, "/root/.ollama/models/manifests", O_RDONLY|O_CLOEXEC|O_DIRECTORY) = 6关键发现: strace 显示了四次对 /root/.ollama/models/manifests 的 openat 系统调用——Ollama 确实读取了 manifests 目录,尝试寻找匹配的 manifest 文件。但日志中没有connect() 或 sendto() 网络系统调用——getExistingName 确实只做了文件系统操作,没有发起网络请求。代码分析结论被系统调用轨迹验证了。
再对比 api/create + from=URL(已经被 ValidateModelName 拦截的情况):
$ curl -s -X POST http://localhost:11434/api/create \
-H 'Content-Type: application/json' \
-d '{"model":"ssrf-test","from":"http://127.0.0.1:8080/metadata"}'
{"error":"invalid model name"}
$ grep -E 'manifest' /tmp/ollama_strace.log
# 无输出——系统调用日志中没有 manifest 相关记录strace 输出为空——api/create + from=URL 被 ValidateModelName 在进入业务逻辑层之前拦截了,getExistingName 根本没有被调用,所以 strace 日志里一条 manifest 相关记录也没有。
两个请求的 strace 差异,直接验证了 Ollama 修复策略的分层效果:
请求 | 校验函数 | ParseNameBare调用 | filepath系统调用 | 网络系统调用 |
api/push | getExistingName | 调用 | 4次openat(manifest) | 0 |
api/create+from | ValidateModelName | 未调用 | 0 | 0 |
ValidateModelName 确实在业务逻辑层之前拦截了,但 api/push 绕过了它,让 URL 解析能力(ParseNameBare) 进入了文件系统层。
五条攻击向量的修复完整性
攻击向量 | 校验函数 | 是否拦截HTTP URL | ParseNameBare是否调用了 |
api/create from | ValidateModelName | 拦截 | 是(拦截后不往下传) |
api/push | getExistingName | 残留(返回unqualified name) | 是(解析了URL) |
api/pull | ValidateModelName | 拦截 | 是(拦截后不往下传) |
api/copy | ValidateModelName | 拦截 | 是(拦截后不往下传) |
api/create files | 文件路径校验 | N/A | N/A |
五条向量中,四条调用了ParseNameBare。其中三条在调用前被ValidateModelName拦截了,一条(api/push)的校验链不完整——它让URL进入了ParseNameBare,解析出了host信息,然后才因为manifest不存在而报错。
这不是一个有利用价值的漏洞——push操作不会向外发起HTTP请求(它解析URL后尝试找本地manifest,找不到就报错)。但它暴露了一个设计问题:Ollama团队修的是"入口",没修"根"。 如果后续版本新增了一个API端点,新开发者在不知道背景的情况下复用了ParseNameBare而没有加ValidateModelName,SSRF可以换个入口复活。
files参数的版本差异——加法策略的重复模式
为了验证源码审计的判断(Ollama 用加法策略而非减法策略修复安全问题),我又追了另一个参数 files 的版本变化。files参数是同一个设计哲学的另一块试金石:它原本的目的是从本地文件构建模型内容——用户传入一个文件路径到内容映射,Ollama会读取本地文件作为模型blob。
在v0.30.10(上一个验证版本)上:
{"files":{"/etc/passwd": "test.txt"}}
→ "file path must be relative"
{"files":{"../../../etc/passwd": "reveal.txt"}}
→ "file path must be relative"
{"files":{"Modelfile": "FROM llama"}}
→ "unknown type"当时(2026年6月版本)的报错"must be relative"暗示的是"给了绝对路径,改成相对路径再试"——攻击者可以尝试相对路径遍历(../../etc/passwd)来读取服务器上的任意文件。
在v0.31.1(当前版本)上:
{"files":{"/etc/passwd": "test.txt"}}
→ "file path must be relative"
{"files":{"../../../etc/passwd": "reveal.txt"}}
→ "file path must be relative"
{"files":{"Modelfile": "FROM llama"}}
→ "unknown type"
{"files":{"test.txt": ""}}
→ "invalid digest format"表面上看起来跟0.30.10一样。但第四条——"test.txt":"" 返回"invalid digest format"——暴露了变化:0.31.1在底层加了digest格式校验。files参数的value现在必须是一个合法的SHA256 digest格式,不再是任意字符串。
这说明Ollama团队在0.30.10到0.31.1之间意识到了files参数的安全风险,并加了一层校验。但跟ParseNameBare一样——底层文件操作能力没有被移除,只是校验层加厚了。如果校验逻辑有绕过路径(如digest格式解析的边界情况),files参数的文件读取能力可能再次暴露。
版本 | files 参数行为 | 数据来源 |
v0.1.32 (2024-02) | 无路径校验 | GitHub release notes |
v0.3.10 (2024-08) | 仅允许相对路径 | 实测 + Git diff |
v0.31.1 (当前) | 相对路径 + digest 格式校验 | 实测 |
补充说明:代码分析结论 vs 实测验证。
这篇文章的技术分析基于两项工作:Ollama v0.31.1 Go 源码的代码审计(第三、四节)和服务器的黑盒测试(第二节、files参数部分)。下面我把两类工作的边界说清楚。
代码分析结论(未经过实际 payload 验证):
- ParseNameBare 解析 URL 但不发起网络请求——我追踪了所有调用链,没有找到 http.Get 或 http.Client.Do
- api/show 路径拼接后有 IsFullyQualified 拦截 + filepath.Join 的 Clean 逻辑——路径穿越在代码层面被拦截
- files 参数 digest 格式校验——v0.31.1 比旧版本更严格
实测验证结果:
- 14 个 API 端点全部可匿名访问(第二节)
- api/push 返回 JSON 中包含 URL 解析后的结果(第三节)
- files 参数在不同版本的报错差异(第四节)
我没有在 v0.31.1 上找到可以直接利用的漏洞。但不代表这些方向完全不通——代码分析结论和实际跑 payload 的判断是两回事。如果读者发现我在标记为"代码分析结论"的方向上存在实际的攻击面,欢迎指正。
但将安全结论限定在这两层已经够回答文章的核心问题了——Ollama 的 CVE-2024-37032 修复是加法策略。ValidateModelName 不是加固了 ParseNameBare,而是绕过了它;files 参数的底层文件操作能力还在,校验层只是加厚了。在新端点加入时,任何一次开发者失误——忘记加 ValidateModelName 或绕过了 digest 校验——都会让这些能力重新暴露。CVE-2024-37032 不是最后一个,只是第一个。
四、攻击推演——如果这台服务器被盯上
第三个角度:假设攻击者已经拿下了Ollama入口,同一台服务器上的K3s和Web服务会怎样?
把分析放到一个真实的红队场景中。这台服务器上跑的不只是Ollama——同一宿主机还有K3s集群和其他Web服务。
环境全景
注意:下面这个端口暴露情况不是虚构的——是我在这台服务器上真实运行过的配置。当前只有 Ollama 和 Varnish 在监听,但之前测试时 K3s、SSTI 靶场、Nginx 都一起跑过。攻击者扫一次就能拼出下面这张图:
# 宿主机端口暴露情况
ss -tlnp | grep -E '11434|6443|6081|5020|19321'
LISTEN 0.0.0.0:11434 # Ollama (外网可达)
LISTEN 0.0.0.0:6443 # K3s API Server (仅内网)
LISTEN 0.0.0.0:6081 # Varnish (外网可达)
LISTEN 0.0.0.0:5020 # SSTI靶场 (外网可达)
LISTEN 0.0.0.0:80 # Nginx (外网可达)
# Docker网络拓扑
Ollama: 172.17.0.3
K3s: 172.17.0.2
# 两者在同一Docker网桥攻击者的第一步是资产盘点。从外网先扫Ollama,然后发现同一IP上还有其他Web服务(Nginx 80、Varnish 6081),同时注意到K3s的6443端口虽然外网不可达但内网存在。这个信息本身就能帮助攻击者构建目标画像。
我整理了一个完整的攻击面卡片:
目标: 139.199.68.168
操作系统: Ubuntu 22.04 (2核4G)
暴露端口:
80/tcp Nginx (外网可达)
6081/tcp Varnish (外网可达)
5020/tcp SSTI靶场 (外网可达)
11434/tcp Ollama v0.31.1 (外网可达, 无认证)
6443/tcp K3s API Server (仅内网可达)
Docker网络:
Ollama: 172.17.0.3
K3s: 172.17.0.2这张卡片就是攻击者在第一轮信息收集中能拼出的画面。不需要扫描器、不需要漏洞利用工具,只需要三次API请求和一次端口扫描。
凌晨3点的第一手侦察(路径A:信息收集)
# 版本号→匹配官方CVE数据库
GET /api/version → 0.31.1
# OLLAMA配置→CORS策略、模型路径
docker logs ollama → OLLAMA_ORIGINS宽松
# 同主机端口→其他服务暴露情况
80(Nginx) + 6081(Varnish) + 5020(SSTI)这条路线零成本、零风险、成功率100%。攻击者不需要发送任何攻击payload,只通过合法的API请求和信息关联就能拼出一个完整的目标画像。
我在测试环境中通过api/version拿到了版本号,在CVE数据库中匹配到两个历史漏洞,确认了这台服务器存在已知攻击面。同时通过端口扫描发现了同一IP上的Nginx、Varnish和SSTI靶场——这些服务在同一宿主机上,任何一个被攻破都能扩大战果。
磁盘无声地填满(路径B:资源消耗)
Ollama的api/pull接口可以从远程拉取模型文件。单个7B模型通常在4-5GB,如果攻击者批量发送pull请求,可以快速填满服务器的磁盘。
我在服务器上实测了模型下载:
$ curl -s -X POST http://139.199.68.168:11434/api/pull \
-H 'Content-Type: application/json' \
-d '{"model":"llama3.2:1b","stream":false}'
{"status":"pulling manifest"}
{"status":"pulling sha256:6beb1... a47b0..."}
...
{"status":"success"}
$ ls -lh /home/ubuntu/.ollama/models/blobs/
-rw-r--r-- 1 root root 1.3G ...一个llama3.2:1b的模型1.3GB,耗时约40秒完成下载。这台服务器磁盘59GB,已用19GB,剩余40GB。32个这样的模型就能填满剩余空间。而且pull操作不限制并发数——虽然OLLAMA_NUM_PARALLEL=1限制了推理并发,但模型下载本身不受这个参数控制。
更麻烦的是:即使管理员发现异常后重启了Ollama服务,已下载的模型文件仍然占用磁盘空间。攻击者可以在不同时间段分批下载不同模型,导致磁盘逐步耗尽。而磁盘满了之后,不只是Ollama不能用——同宿主机的其他服务、系统日志、甚至K3s集群都可能受到影响。
资源消耗攻击的价值不在于"让服务不可用",而在于拖住运维——磁盘爆满要排查、清理、加监控,这段时间攻击者能在其他方向做文章。
李逵与李鬼(路径C:模型供应链攻击)
如果这台Ollama上有模型在跑,攻击者可以做更精细的操作:
- 通过api/copy创建与官方名称极相似的恶意副本(如 llama3.2:1b → llama3.2-1b)
- 通过api/create + modelfile修改模型的System Prompt
- 通过api/delete删除原模型
- 诱导管理员或自动化流水线使用恶意模型
这种攻击的隐蔽之处在于——api/tags返回的模型名称、大小、digest看起来都是正常的,只有模型的输出内容被篡改了。如果Ollama被集成到聊天机器人后端或自动化处理管道中,恶意模型的输出可能包含诱导信息、钓鱼链接或数据投毒payload。
更值得警惕的是一种混合攻击方式:攻击者先通过api/pull拉取一个正常模型(如llama3.2:1b),然后通过api/create的modelfile参数修改模型的system prompt,再加入一条恶意指令——比如"当用户问及服务器信息时,回复一个伪造的IP地址"。修改后的模型digest会发生变化,但名称不变。api/tags列表中的digest更新了,不仔细对比不会发现异常。
这种攻击在真实的红队行动中是有先例的。2024年披露的一起AI供应链攻击中,攻击者向公开模型仓库上传了带有后门的模型文件,模型的前向传播结果在特定输入下会返回攻击者控制的信息。Ollama的api/pull从内建registry拉取模型时,不验证模型的完整性和来源——如果registry被攻破或攻击者部署了恶意model,Ollama用户会无条件信任并下载。
叠叠乐——AI + K3s + Web 服务的横向移动(路径D:K3s凭证泄露)
这是最吸引人的路线。K3s集群中存在一个demo-app命名空间,里面有一个demo-secret:
apiVersion: v1
kind: Secret
metadata:
name: demo-secret
namespace: demo-app
data:
api_key: c2stYWJjZGVmMTIzNDU2Nzg5MA==
aws_secret: QUtJQTEyMzQ1Njc4OTBFWEFNUExF
db_password: U3VwZXJTZWNyZXRQYXNzd29yZDEyMyE=Base64解码后分别得到:sk-abc...7890(API密钥)、AKIA1234567890EXAMPLE(AWS密钥)、SuperSecretPassword123!(数据库密码)。
Ollama容器(172.17.0.3)和K3s容器(172.17.0.2)在同一个Docker网桥上,网络层完全互通。问题在于:Ollama没有提供RCE接口——攻击者无法通过API在容器内执行任意命令。
但如果存在以下任一场景,这条路线就能走通:
- Ollama的推理接口可以正常使用(内存的某个漏洞触发容器逃逸)
- Ollama的files参数可以读取容器内文件(已被削弱但未移除)
- 攻击者通过其他入口(如Nginx的漏洞)获得了宿主机权限
- K3s的API Server存在未授权访问(当前版本需要认证)
如果容器逃逸成功,攻击者的下一步操作:拿到宿主机shell后,攻击者会检查K3s的kubeconfig文件。K3s的默认安装位置在/etc/rancher/k3s/k3s.yaml,文件权限通常为644,宿主机上任何用户都能读取。拿到kubeconfig后:
# 在宿主机上
$ kubectl --kubeconfig=/etc/rancher/k3s/k3s.yaml get secrets -n demo-app
NAME TYPE DATA AGE
demo-secret Opaque 3 180d
$ kubectl --kubeconfig=/etc/rancher/k3s/k3s.yaml get secret demo-secret -n demo-app -o yaml
apiVersion: v1
kind: Secret
metadata:
name: demo-secret
namespace: demo-app
data:
api_key: c2stYWJjZGVmMTIzNDU2Nzg5MA==
aws_secret: QUtJQTEyMzQ1Njc4OTBFWEFNUExF
db_password: U3VwZXJTZWNyZXRQYXNzd29yZDEyMyE=解码后得到的三组凭证分别对应:API服务密钥(sk-abc...)、AWS访问密钥(AKIA...)、数据库密码(SuperSecret...)。拿到这些凭证后,攻击者的选择就多了:可以用API密钥调用第三方服务、用AWS密钥接管云资源、用数据库密码直连内部数据库。
而且K3s的API Server(:6443)也在同一台服务器上监听。虽然当前版本的K3s API Server启用了TLS认证,但如果kubeconfig文件被拿到,集群的完整控制权就到手了。攻击者可以创建、删除任意pod、读取所有namespace的secret、甚至通过hostNetwork pod逃逸到宿主机网络空间。
这三条命令,零权限提升、零绕过,直接拿到K3s集群的完整控制权。
更值得警惕的是K3s的自动部署机制。K3s会在所有worker节点上自动部署traefik作为Ingress Controller,默认配置下traefik的dashboard绑定在0.0.0.0:9000。如果这台服务器上运行的K3s也暴露了traefik dashboard,攻击者又多了一个入口。
这个环境本身就是一例典型的风险"叠叠乐":AI推理服务 + K3s集群 + 多个Web服务跑在同一台服务器上,任何一个组件被突破,其他组件都不安全。
三年前的教训——CVE时间线里的安全哲学
Ollama团队不是没收到过安全反馈。2024年至今,Ollama共披露了三项主要安全漏洞。它们的修复过程展示出这家公司的安全策略演变:从被动修复到防御性设计,但始终没有跨过"根除风险"这道门槛。
2024年8月,CVE-2024-37032(CVSS 8.6):Modelfile SSRF漏洞,攻击者通过api/create的from参数传入HTTP URL,Ollama服务端会发起内网请求。Ollama的修复方案是在模型名校验层加入ValidateModelName()——只拦截不根除。
2024年9月,CVE-2024-39720(CVSS 7.5):认证绕过漏洞,攻击者可以绕过Ollama的origin检查访问API。修复方案是加固CORS校验逻辑。底层无认证API设计没有改变。
2026年,我发现的ParseNameBare残留:不是CVE,但暴露出与CVE-2024-37032同样的设计缺陷——修复只做了加法(加校验器),没做减法(删底层函数)。
拿CVE-2024-37032这个SSRF漏洞来说,它跟传统Web框架中的SSRF没什么两样——攻击者通过一个HTTP URL参数让服务端发起请求。Nginx、Apache、Tomcat在十几年前就遇到过同样的问题,修复方案也早就成熟了:输入校验+白名单+禁用HTTP重定向。但Ollama的修复只做到了第一层——输入校验。底层的URL解析器没有被移除,内网访问能力没有被禁用,只是被一层校验器挡住了。一年半之后,ParseNameBare还在原处。
不是Ollama一家的问题。整个AI基础设施行业都在经历Web安全二十年前走过的路——框架作者优先保证"开箱即用",安全性是事后附加的。vLLM和TGI提供了可选的API Key认证——也是最近几个版本才加的功能。llama.cpp到现在都没有。
做一个简单的类比:如果你部署了一个MySQL数据库并且监听0.0.0.0:3306,你一定会加密码、做防火墙规则、配置SSL。没人会说"MySQL的默认设计不安全"。但AI推理框架不一样——同样是暴露一个数据库级敏感的服务到公网,大部分部署者不认为需要同样的防护措施。原因是AI基础设施的使用者长期以来是研究者,研究者的网络环境和生产环境是完全不同的。在实验室里,所有服务都在同一个内网段,API不需要认证是合理的。但同样的系统被部署到生产环境时,没有人告诉这个研究者"你的实验室习惯在生产环境中是危险的"。
AI基础设施公司的安全团队也处于追赶状态。Ollama的核心开发团队以开发者体验闻名,安全问题主要依赖社区报告。相比之下,一些云服务商的AI推理平台从一开始就把认证、审计、网络隔离作为内置特性。这种差异最终体现在产品设计中:前者默认全开放,后者默认最小权限。
这个问题的根源不在技术层面,在生态层面:AI框架的主要用户是数据科学家和AI研究员,他们关心的核心指标是推理延迟和吞吐量,不是认证机制是否完善。框架作者自然优先满足主流用户需求。这种情况下,安全就变成了用户的"自己负责"——但用户没有安全背景,他不知道默认配置存在什么问题,也不知道应该怎么加固。Ollama 没有安全文档、没有安全 checklist、启动时也没有"你的 API 正暴露在公网上"的警告。这不是恶意的设计,是安全在优先级上输给了易用性。
要改变这个现状,需要三个方向的努力。对框架开发者:默认配置应该遵循最小权限原则——即使要以牺牲一部分易用性为代价。对运维者:部署 AI 推理服务前应该执行安全基线检查,至少确认 API 不对外网开放、认证机制已启用。对行业:需要一套 AI 基础设施安全标准,类似于云安全联盟(CSA)对云计算的定义——让用户和提供者都有明确的安全预期。在标准出现之前,每一台暴露在公网的 Ollama 都是测试案例——有些已经被利用,有些还在等待被发现。
五、三把锁
给运维者和管理者的建议,不多,三条就够了。但三条锁不是平级关系——它们的防御价值递减、实现代价递增。
第一把锁:网络层(高价值,零成本)
在所有防御措施中,绑定 127.0.0.1 是最有效的。因为攻击者的第一步通常是端口扫描,Shodan、ZoomEye、Fofa 这些搜索引擎只收录公网可达的服务。把端口绑死在本地环回地址上,你的 Ollama 在互联网上就是不可见的——连扫描的机会都不给攻击者。
# 立即生效,一条命令
iptables -A INPUT -p tcp --dport 11434 ! -s 127.0.0.1 -j DROP
# 或者改Ollama配置
# 在Docker启动参数中修改
docker run -d --name ollama \
-p 127.0.0.1:11434:11434 \
ollama/ollama
# 在systemd配置中(宿主机安装)
Environment="OLLAMA_HOST=127.0.0.1:11434"把端口绑定限制到127.0.0.1,这是最基础也是最有效的防御——99%的自动扫描针对0.0.0.0。如果你只能做一件事,做这个。
但这条锁有漏洞:如果攻击者已经进入你的内网(比如通过其他 Web 服务的漏洞),本机绑定挡不住内网横向移动。需要第二把锁来补这个缺口。
第二把锁:代理层(中价值,中等成本)
如果必须提供远程访问——比如你的团队需要从办公室连回 Ollama 做推理——在 Ollama 前面加一层 Nginx 反代:
server {
listen 443 ssl;
server_name ollama.internal.example.com;
location / {
# IP白名单
allow 10.0.0.0/8;
allow 192.168.0.0/16;
deny all;
# 速率限制
limit_req zone=ollama burst=20 nodelay;
proxy_pass http://127.0.0.1:11434;
}
}Nginx 反代有几个网络层做不到的好处:可以做 SSL 终止(加密传输中的 API 请求和响应)、可以做 IP 白名单(只允许公司内网段访问)、可以做速率限制(防止资源耗尽攻击)。
但警惕一种常见错误:有些运维人员部署了 Nginx 反代却忘了加 allow/deny 规则,结果 Nginx 比 Ollama 更暴露——SSL 握手成功的外网请求直接透传到了 Ollama API。Nginx 前面的链路层防火墙仍然是必要的。
第三把锁:审计层(低价值,低成本)
前两把锁都是"防",审计是"检"。再好的防御也有配置错误的可能,所以需要一个脚本定期自检:
# 一条命令跑完全部检测
$ ./ollama-audit.sh 139.199.68.168:11434完整脚本就是开头提到的 ollama-audit.sh,和文章放在一起。可以作为 cron 任务每小时跑一次——30 秒完成五项检测,检测失败时自动报警。
三把锁的关系:网络层最有效但只能防外网扫描、代理层最灵活但配置复杂、审计层最被动但能发现前两把锁的配置失误。单一把锁都不够——没有网络层,代理层的配置错误就会暴露 API;没有代理层,内网攻击者直连 Ollama 没有任何阻碍;没有审计层,配置错误可能数月不被发现。三层叠加,才是完整的防御。
六、总结
回到开头的问题:Ollama的安全修复到底修得怎么样?
对攻击者来说, 暴露的Ollama有14个无认证API入口。SSRF被修了,但信息收集、资源消耗、模型操控全开。CORS策略宽泛、配置日志明文泄露、files参数的底层文件操作能力还在。
对Ollama团队来说, CVE-2024-37032的修复是堆叠校验器而非移除风险。ParseNameBare保留至今,api/push暴露了它。files参数做了收紧但未移除底层机制。新端点一不注意,SSRF就能换个入口复活。
对整个AI推理框架行业来说, 安全成熟度还处于Web安全二十年前的阶段。不是Ollama一家的问题——vLLM默认0.0.0.0、llama.cpp到2026年都没有认证、TGI的API Key最近才变成可选。框架作者优先保证开箱即用,安全是事后附加的。
这篇文章不是要证明Ollama很危险——任何无认证服务暴露到公网都很危险。问题是AI框架的部署者往往意识不到改了OLLAMA_HOST=0.0.0.0意味着API全世界可用了。最讽刺的事发生在写这篇文章的验证过程中——我在Docker日志里翻到了之前测试留下的K3s demo-secret。AI推理服务暴露的后果,比大部分运维者想象的大得多。
ollama-audit.sh(批量检测脚本)
#!/bin/bash
# ollama-audit.sh — Ollama 攻击面批量检测工具
# 用法: ./ollama-audit.sh <target_ip:port>
# 示例: ./ollama-audit.sh 192.168.1.100:11434
set -euo pipefail
TARGET="${1:-}"
if [ -z "$TARGET" ]; then
echo "用法: $0 <target_ip:port>"
echo "示例: $0 139.199.68.168:11434"
exit 1
fi
echo "============================================"
echo " Ollama Attack Surface Audit Tool"
echo " Target: $TARGET"
echo "============================================"
echo ""
echo "[1] API端点匿名访问检测"
ENDPOINTS=("/" "/api/version" "/api/tags" "/api/ps"
"/api/show" "/api/create" "/api/pull" "/api/push"
"/api/copy" "/api/delete" "/api/generate"
"/api/chat" "/api/embed" "/api/blobs/")
for ep in "${ENDPOINTS[@]}"; do
status_code=$(curl -s -o /dev/null -w "%{http_code}" --connect-timeout 5 "http://${TARGET}${ep}" 2>/dev/null || echo "TIMEOUT")
if [ "$status_code" = "405" ]; then
status_code=$(curl -s -o /dev/null -w "%{http_code}" -X POST --connect-timeout 5 "http://${TARGET}${ep}" 2>/dev/null || echo "TIMEOUT")
fi
echo " ${ep} → ${status_code}"
done
echo ""
echo "[2] SSRF防护检测"
SSRF=$(curl -s -X POST "http://${TARGET}/api/create" -H 'Content-Type: application/json' -d '{"model":"ssrf-test","from":"http://127.0.0.1:8080/test"}')
echo "$SSRF" | grep -q "invalid model name" && echo " api/create: ✓ SSRF拦截" || echo " api/create: ⚠ 响应: $SSRF"
PUSH=$(curl -s -X POST "http://${TARGET}/api/push" -H 'Content-Type: application/json' -d '{"model":"http://127.0.0.1:8080/test"}')
echo "$PUSH" | grep -q "unqualified name" && echo " api/push: ⚠ ParseNameBare残留" || echo " api/push: 响应: $PUSH"
echo ""
echo "[3] 配置泄露检测(需在服务器本地执行)"
echo " sudo journalctl -u ollama | grep 'server config'"
echo " 或 docker logs <container> | grep 'server config'"
echo ""
echo "[4] files参数风险检测"
for payload in '{"model":"t1","files":{"/etc/passwd":"x"}}' '{"model":"t2","files":{"../../../etc/passwd":"x"}}' '{"model":"t3","files":{"Modelfile":"FROM llama"}}' '{"model":"t4","files":{"x":""}}'; do
result=$(curl -s -X POST "http://${TARGET}/api/create" -H 'Content-Type: application/json' -d "$payload")
echo " $result"
done
echo ""
echo "[5] 模型操作权限检测"
curl -s --connect-timeout 5 "http://${TARGET}/api/tags" | grep -o '"name"' | wc -l | xargs echo " 已安装模型数:"
curl -s --connect-timeout 5 "http://${TARGET}/api/ps" | echo " 运行中: $(cat)"
echo ""
echo "============================================"
echo " 检测完成"
echo "============================================"