# A 10-Minute Security Checklist for Your Ollama Server

> Check your Ollama version, update it, bind it to localhost and add an authenticated proxy, with the 2026 GGUF loader CVE as the worked example.

- Published: 2026-09-09
- Updated: 2026-09-25
- Author: Jacobo González Jaspe
- Language: en
- Tags: Ollama, Security, Local AI, Checklist
- Canonical URL: https://vorluxai.com/en/blog/keep-your-local-ai-patched-ollama-security-checklist-en/
- Source: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

By the end of this post, your Ollama server will be on a current version, listening only where you want it to, and reachable from other machines through a password-protected proxy. The process takes ten minutes on the laptop you already use, and it costs nothing. We ran this same checklist on our own workstation while writing this to see what we found.

Running AI on your own hardware keeps your data in the building. It also means you are the person who applies updates. It is a small, regular job. It is just the routine.

> **TL;DR**
> - Your Ollama server ends up current, bound to localhost and reachable from other machines only through a password-protected proxy.
> - It takes ten minutes on the laptop you already use and costs nothing.
> - Verdict: update now, bind to 127.0.0.1 unless you chose otherwise on purpose, and repeat the checks in a monthly 15-minute slot.

## What you need
- A machine with Ollama installed (Linux, macOS or Windows). The commands below are Linux with systemd; the macOS and Windows equivalents are noted.
- A terminal and, for the proxy step, ten minutes to install [Caddy](https://caddyserver.com/docs/caddyfile/directives/basic_auth) or Nginx.
- Optional: an AI assistant. Paste any command output you do not understand and ask it to explain what the line means.

## The worked example: CVE-2026-7482
In May 2026, researchers at Cyera disclosed a heap out-of-bounds read in Ollama's GGUF model loader, tracked as [CVE-2026-7482 with a CVSS score of 9.1](https://thehackernews.com/2026/05/ollama-out-of-bounds-read-vulnerability.html). The bug sits in the `WriteTo()` function of `fs/ggml/gguf.go` and in `server/quantization.go`. An attacker who can reach the API uploads a GGUF file with an inflated tensor shape, triggers `/api/create`, and then uses `/api/push` to send the resulting model, which now contains slices of the server's memory, to a registry they control. What leaks can include environment variables, API keys, system prompts and other users' conversations ([Qualys](https://threatprotect.qualys.com/2026/05/11/ollama-heap-out-of-bounds-read-vulnerability-leads-to-remote-process-memory-leak-cve-2026-7482/)).

Three facts make it the perfect checklist example. It affected every version before 0.17.1, and [0.17.1 had been out since February 2026](https://github.com/ollama/ollama/releases/tag/v0.17.1), months before disclosure: people who updated routinely were never affected. It needs network access to the API, so a server bound to localhost was never reachable. And the article counted over 300,000 servers exposed to the internet, which means the fix for most of them was two lines of configuration. Every step below closes one of those doors.

## Step 1: Check which version you run
```bash
ollama --version
curl -s localhost:11434/api/version
```

Expected output: `ollama version is 0.33.3` and `{"version":"0.33.3"}`, or whatever the [latest release](https://github.com/ollama/ollama/releases) is on the day you read this. If the two numbers differ, you have a new binary but the old service is still running: restart it (Step 4 shows how).

Our receipt: on 2026-09-09 our workstation answered `0.30.10`. The latest release that day was v0.33.3, published 2 September 2026. Three minor versions behind, on a machine we look after daily. That is exactly why this is a checklist and not a memory exercise.

## Step 2: Update
On Linux, the installer is also the updater ([Ollama docs](https://docs.ollama.com/linux)):

```bash
curl -fsSL https://ollama.com/install.sh | sh
ollama --version        # confirm the new number
```

To pin a specific version, prefix it with `OLLAMA_VERSION=0.33.3`. On macOS and Windows the desktop app updates itself and shows a prompt; if in doubt, download the current build from ollama.com ([FAQ](https://docs.ollama.com/faq)). If the update fails, `journalctl -e -u ollama` shows the last lines of the service log.

## Step 3: See what it is listening on
```bash
ss -ltnp | grep 11434
```

`127.0.0.1:11434` means only programs on this machine can talk to Ollama. `*:11434` or `0.0.0.0:11434` means every device on your network can, and if the machine has a public address, so can the internet.

Our receipt: ours shows `*:11434`. That is deliberate, because Docker containers on the same host call it, and the machine sits behind a LAN and a Tailscale network with no public port. The point is that we know, because we checked. If you did not set it on purpose, move to Step 4.

## Step 4: Bind to localhost
Ollama reads the address from the `OLLAMA_HOST` variable ([FAQ](https://docs.ollama.com/faq)). On Linux with systemd:

```bash
sudo systemctl edit ollama
```

Add, in the editor that opens:

```ini
[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"
```

Then:

```bash
sudo systemctl daemon-reload && sudo systemctl restart ollama
ss -ltnp | grep 11434      # should now read 127.0.0.1:11434
```

On macOS: `launchctl setenv OLLAMA_HOST "127.0.0.1:11434"` and restart the app. On Windows, set the same variable in System Environment Variables and restart Ollama. If a tool on another machine stops working after this change, that tool is exactly what Step 5 is for.

## Step 5: Reach it from other machines through an authenticated proxy
Ollama's API has no login of its own, so the proxy supplies one. With Caddy, generate a password hash and write a three-line Caddyfile:

```bash
caddy hash-password        # type the password, copy the $2a$... output
```

```caddyfile
ai.internal.example:443 {
    basic_auth {
        team $2a$14$REPLACE_WITH_YOUR_HASH
    }
    reverse_proxy localhost:11434
}
```

The `basic_auth` block and `caddy hash-password` are documented in the [Caddy manual](https://caddyserver.com/docs/caddyfile/directives/basic_auth). Nginx users can take the `proxy_pass http://localhost:11434` snippet from the [Ollama FAQ](https://docs.ollama.com/faq) and add `auth_basic`. Clients then point at `https://ai.internal.example` with the username and password, and Ollama itself keeps listening on localhost only.

Two finishing touches. Add a firewall rule so the raw port is never open even by accident: `sudo ufw deny 11434/tcp`. And if a browser extension needs Ollama, allow only it with `OLLAMA_ORIGINS` in the same systemd override, rather than opening the port.

## What we found on our own server
| Check | Command | Our result, 2026-09-09 | Action |
|---|---|---|---|
| Version | `ollama --version` | 0.30.10 vs 0.33.3 current | update scheduled |
| Bind address | `ss -ltnp \| grep 11434` | `*:11434` (containers need it) | keep, documented |
| Public exposure | router / cloud firewall | no public port; LAN + Tailscale only | none |
| Auth in front | Caddy on :443 | the API is not published through the proxy; internal only | none |
| Model sources | `ollama list` | 12 models: 10 from the official library, 2 built locally from them | none |

Five checks, one action item. That is what a routine looks like when it is working.

## The monthly routine
Put a recurring 15-minute slot in the calendar, on the same day you patch the operating system:

- [ ] `ollama --version` against the latest GitHub release; update if behind.
- [ ] `ss -ltnp | grep 11434` still shows `127.0.0.1` (or the address you chose on purpose).
- [ ] The proxy still asks for a password: open it in a private browser window.
- [ ] `sudo apt update && sudo apt upgrade` (or your distribution's equivalent) for the host.
- [ ] `ollama list`: every model came from a source you trust; remove test pulls.
- [ ] `journalctl -u ollama --since "-30 days" | grep -i error | tail` for anything new.
- [ ] Note the date and version in a shared file so the next person can see it was done.

## Where this fits
This checklist covers the Ollama server itself. It does not replace host hardening, backups or access control on the applications you build on top. A local model on a patched, localhost-bound server is a strong default for private data; it is not a reason to skip the rest of your IT hygiene. If several teams share one server, treat the proxy password as a per-team credential and rotate it when people leave.

## Next steps
- Set the whole local stack up in order: [How to deploy AI locally in your business](https://vorluxai.com/en/blog/how-to-deploy-ai-locally-business-guide/).
- See the open-source stack we run behind the same proxy: [The VORLUX AI stack](https://vorluxai.com/en/blog/vorlux-ai-stack-open-source-local-private-en/).
- Connect the technical setup to your data-protection duties: [GDPR Article 25 and local AI](https://vorluxai.com/en/blog/gdpr-article-25-local-ai-privacy-by-design-2026-en/).
- If your model uses tools, protect it from the documents it reads too: [defend your agent from a poisoned document](https://vorluxai.com/en/playground/indirect-injection-rag/).

## Work with us
We run this checklist as part of every deployment we hand over, and we leave the client with the monthly routine written down. If you want us to review an existing Ollama server, [get in touch](https://vorluxai.com/en/contact/) or see [how our consulting works](https://vorluxai.com/en/consulting/).
