复现环境: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上有模型在跑,攻击者可以做更精细的操作:

  1. 通过api/copy创建与官方名称极相似的恶意副本(如 llama3.2:1b → llama3.2-1b)
  2. 通过api/create + modelfile修改模型的System Prompt
  3. 通过api/delete删除原模型
  4. 诱导管理员或自动化流水线使用恶意模型

这种攻击的隐蔽之处在于——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 "============================================"