Ollama senza password: come proteggere l'API
L'API di Ollama non ha autenticazione: chi raggiunge la porta 11434 puo eseguire, scaricare ed eliminare modelli. Ecco 3 correzioni, in ordine.
L’API di Ollama non ha una password
L’API di Ollama non usa alcun meccanismo di autenticazione. Per i client in ingresso non esistono controlli su utente, password o chiave API. Chiunque possa aprire una connessione TCP alla porta 11434 può elencare i modelli, eseguirli, scaricarne di nuovi ed eliminare quelli disponibili.
La documentazione ufficiale lo dichiara chiaramente: "L’API locale all’indirizzo http://localhost:11434 non richiede autenticazione." Il termine locale definisce l’intero modello di sicurezza. Per impostazione predefinita, Ollama rimane in ascolto su 127.0.0.1, quindi su un laptop l’interfaccia di loopback svolge il ruolo di controllo degli accessi. Se si sposta il listener su un indirizzo pubblico, il controllo degli accessi viene meno, perché non viene introdotta alcuna protezione alternativa.
Per questo il problema è rilevante su un VPS (virtual private server). La configurazione predefinita è sicura. La prima modifica che molti applicano, cioè aprire il listener affinché una seconda macchina possa usare il modello, elimina ogni protezione in una sola volta.
Cosa rivela una porta 11434 aperta
Ogni endpoint. Non esiste una modalità di sola lettura né una porta amministrativa separata. Queste sono le richieste reali, indirizzate all'indirizzo del server invece che a localhost:
# List every model on the box
curl http://SERVER_IP:11434/api/tags
# See what is loaded into memory right now
curl http://SERVER_IP:11434/api/ps
# Run a prompt on your hardware
curl http://SERVER_IP:11434/api/generate -d '{"model":"llama3.2","prompt":"Why is the sky blue?"}'
# Write several gigabytes to your disk
curl http://SERVER_IP:11434/api/pull -d '{"model":"llama3.2"}'
# Remove a model
curl -X DELETE http://SERVER_IP:11434/api/delete -d '{"model":"llama3.2"}'Dal punto di vista operativo, si verificano quattro problemi:
- La CPU o la GPU esegue inferenze per conto di terzi. Con un piano che prevede un'allocazione CPU basata sul fair use, un carico prolungato consuma la quota a disposizione a causa di un estraneo, e tenere sotto controllo i costi dei carichi di lavoro AI su un VPS diventa molto più difficile quando non sei l'unico chiamante.
/api/pullscrive sul disco. Le dimensioni dei modelli variano; anchellama3.2:1boccupa 1.3 GB. Una serie continua di pull riempie il volume, e un disco pieno interrompe tutti gli altri servizi sul server, non soltanto Ollama.- Le richieste arrivano all'interno del processo e vengono registrate nei log. Al livello di logging predefinito, Ollama registra solo i metadati: endpoint, stato, latenza e indirizzo client, non il testo del prompt. Rimane comunque una registrazione di chi ha usato il server e per quale scopo, archiviata nel journal senza che tu abbia scelto di raccoglierla.
/api/deleterimuove i modelli. Per recuperarli devi scaricarli di nuovo usando la tua larghezza di banda.
Nulla di tutto questo richiede un exploit. È l'API documentata che si comporta esattamente come previsto.
La chiave Ed25519 non è un controllo degli accessi
Cercando "Ollama API key" si trovano due elementi distinti. Nessuno dei due è una password per il server. Separarli elimina gran parte della confusione.
Il primo è la coppia di chiavi di identità. Ollama genera una coppia di chiavi Ed25519 al primo avvio. Su Linux, lo script di installazione crea un utente di sistema denominato ollama, con directory home in /usr/share/ollama, quindi la coppia si trova qui:
/usr/share/ollama/.ollama/id_ed25519
/usr/share/ollama/.ollama/id_ed25519.pubQuesta chiave serve per l'autenticazione verso l'esterno. ollama signin registra la parte pubblica nell'account ollama.com e la usa per autorizzare il push di un modello nel registry o il pull di un modello privato. Dimostra a ollama.com l'identità della macchina. Non richiede nulla ai client che si connettono alla macchina. Eliminarla, sostituirla o non crearla non modifica in alcun modo chi può chiamare la tua API.
Il secondo è OLLAMA_API_KEY. Questa variabile contiene una chiave che crei in https://ollama.com/settings/keys e che il client invia come Authorization: Bearer $OLLAMA_API_KEY quando chiama l'API ospitata in https://ollama.com/api. È una credenziale per il loro servizio, utilizzata da te come client. Il tuo ollama serve non la usa per autenticare le richieste in ingresso. Impostare OLLAMA_API_KEY sul tuo VPS non aggiunge una password al VPS.
Non c'è quindi alcuna impostazione da attivare. Le tre difese riportate di seguito funzionano tutte nello stesso modo: mantenere la porta non raggiungibile e anteporre un componente che verifichi le richieste.
Verifica su cosa è in ascolto il server
sudo ss -tlnp | grep 11434Il risultato sicuro indica l'indirizzo di loopback:
LISTEN 0 4096 127.0.0.1:11434 0.0.0.0:* users:(("ollama",pid=812,fd=3))Il risultato esposto indica tutte le interfacce:
LISTEN 0 4096 0.0.0.0:11434 0.0.0.0:* users:(("ollama",pid=812,fd=3))0.0.0.0 indica tutti gli indirizzi IPv4 del server, incluso quello pubblico. *:11434 e [::]:11434 sono listener wildcard su tutti gli indirizzi IPv6. La loro eventuale capacità di accettare connessioni IPv4 dipende dall'opzione IPV6_V6ONLY del socket, che Linux lascia disattivata per impostazione predefinita (net.ipv6.bindv6only=0). Considera quindi esposti tutti e tre i casi.
Ora verifica dall'esterno. Esegui questo comando sul laptop, non sul server:
curl -m 5 http://YOUR_SERVER_IP:11434/api/versioncurl: (28) Connection timed out after 5001 milliseconds è il risultato atteso, così come curl: (7) Failed to connect ... Connection refused. Un oggetto JSON con un campo version indica che l'intera API è raggiungibile da chiunque invii una richiesta. Eseguire il test con curl direttamente sul server non dimostra che un'altra macchina possa raggiungerlo. Se il server dispone di un indirizzo IPv6, ripeti il test usando curl -6 -m 5 http://[YOUR_SERVER_IPV6]:11434/api/version, perché una porta IPv4 chiusa non fornisce alcuna informazione su un listener IPv6.
L'esposizione si verifica in genere in uno di due modi. Il primo è una modifica intenzionale, necessaria perché un altro computer possa raggiungere il modello:
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"Quella singola riga è sufficiente a esporre il servizio. Il secondo modo è Docker, che non richiede alcuna modifica manuale. Questo caso viene descritto nella sezione seguente.
Difesa 1: mantenerlo su localhost e usare un tunnel
Parti da questa soluzione. Non richiede nuovo software e non crea credenziali che possano fuoriuscire. La porta non è mai presente su un'interfaccia pubblica, quindi una scansione non può rilevarla.
Imposta esplicitamente l'indirizzo di ascolto invece di affidarti al valore predefinito:
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"Questo scrive /etc/systemd/system/ollama.service.d/override.conf. Applica la modifica e verifica:
sudo systemctl daemon-reload
sudo systemctl restart ollama
sudo ss -tlnp | grep 11434ss dovrebbe ora mostrare 127.0.0.1:11434. Se mostra ancora 0.0.0.0, prevale un secondo file drop-in. Esegui systemctl cat ollama.service per elencare l'unità e ogni drop-in con il relativo percorso, quindi elimina quello obsoleto.
Per usare il modello dal laptop, inoltra la porta tramite SSH:
ssh -N -L 11434:127.0.0.1:11434 you@your-server-L 11434:127.0.0.1:11434 apre la porta 11434 sul laptop e invia tutto ciò che arriva lì a 127.0.0.1:11434, come visto dal server. -N indica a SSH di non eseguire un comando remoto, quindi il processo mantiene semplicemente aperto il tunnel. Mentre il tunnel è attivo, sul laptop funziona quanto segue:
curl -s http://localhost:11434/api/tagsIncontrerai due errori. bind [127.0.0.1]:11434: Address already in use indica che l'indirizzo e la porta locali sono già in uso, da Ollama, da un altro tunnel SSH o da un altro programma. Scegli quindi una porta locale diversa con -L 11500:127.0.0.1:11434 e configura il client per usare la porta 11500. Se una richiesta attraverso il tunnel restituisce una risposta vuota, controlla ss sul server e l'output degli errori di SSH prima di stabilire quale servizio ha avuto il problema.
Per più macchine client, una rete privata è preferibile a un tunnel per ogni utente. Collega le macchine tramite WireGuard o Tailscale, quindi configura Ollama per l'ascolto sull'indirizzo assegnato a quella rete invece che su 0.0.0.0:
[Service]
Environment="OLLAMA_HOST=10.8.0.1:11434"La porta sarà quindi presente soltanto su un'interfaccia per accedere alla quale serve una chiave. Questa configurazione resta sicura anche in caso di errore nelle regole del firewall, perché una regola che consenta accidentalmente il traffico da Internet non può esporre un listener che non è presente sull'interfaccia pubblica.
Difesa 2: un reverse proxy che verifica un bearer token
Quando un componente su Internet deve chiamare il modello, mantenete Ollama in ascolto sull'interfaccia di loopback e mettete un proxy davanti al servizio. Il proxy termina TLS (transport layer security) e rifiuta le richieste prive dell'header corretto. Ollama accetta ancora connessioni soltanto da 127.0.0.1, quindi il proxy è l'unico percorso di accesso.
Generate prima un token reale. Non inventatene uno manualmente:
openssl rand -base64 36Un sito nginx che lo verifica:
map $http_authorization $ollama_ok {
default 0;
"Bearer PASTE_YOUR_GENERATED_TOKEN_HERE" 1;
}
server {
listen 443 ssl;
server_name llm.example.com;
ssl_certificate /etc/letsencrypt/live/llm.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/llm.example.com/privkey.pem;
location = /api/pull { return 403; }
location = /api/delete { return 403; }
location = /api/push { return 403; }
location / {
if ($ollama_ok = 0) { return 401; }
proxy_pass http://127.0.0.1:11434;
proxy_set_header Host 127.0.0.1:11434;
proxy_buffering off;
proxy_read_timeout 600s;
}
}In questo blocco, cinque righe svolgono un lavoro effettivo. Ognuna impedisce un errore che altrimenti si verificherebbe.
if all'interno di un blocco location è in genere una scelta errata in nginx. Tuttavia, un body di lunghezza esatta return è una delle due forme che si comportano in modo prevedibile, quindi questo utilizzo è sicuro.
location = /api/pull è una corrispondenza esatta. nginx assegna alle corrispondenze esatte una priorità maggiore rispetto al prefisso location /. Di conseguenza, questi tre endpoint vengono rifiutati prima ancora di verificare il token. Un token valido consente comunque di accedere ad altri endpoint di gestione del modello, inclusi /api/create e /api/blobs/:digest. Questi tre blocchi, quindi, non impediscono tutte le scritture su disco.
proxy_set_header Host 127.0.0.1:11434; è importante perché Ollama esamina gli header Host e Origin in ingresso. Inoltrare direttamente l'hostname pubblico del proxy può generare un 403 Forbidden proveniente da Ollama anziché da nginx, rendendo il troubleshooting più difficile. OLLAMA_ORIGINS è l'altro parametro utile per un client browser che deve consentire un'origine specifica.
proxy_buffering off; è importante perché Ollama trasmette la risposta un token alla volta. Con il buffering attivo, nginx memorizza la risposta prima di inoltrarla. Questo ritarda la consegna dei token trasmessi.
proxy_read_timeout 600s; è importante perché il valore predefinito di nginx è 60 secondi. Il timer viene misurato tra due letture successive da Ollama, non sull'intera risposta. Una risposta in streaming che continua a produrre token reimposta il timer a ogni lettura. Una richiesta in cui Ollama non invia nulla per 60 secondi fa scattare il timeout. Questo può accadere, ad esempio, con una richiesta inviata tramite "stream": false, che restituisce l'intera risposta in un unico blocco alla fine, oppure dopo un lungo silenzio prima dell'arrivo del primo token. Il client riceve 504 Gateway Time-out e /var/log/nginx/error.log registra upstream timed out (110: Connection timed out) while reading response header from upstream. La richiesta era ancora in esecuzione. nginx l'ha interrotta.
Ricaricate la configurazione e verificate entrambi i percorsi:
sudo nginx -t && sudo systemctl reload nginx
curl -s -o /dev/null -w '%{http_code}\n' https://llm.example.com/api/tags
curl -s -H "Authorization: Bearer YOUR_TOKEN" https://llm.example.com/api/tagsIl primo comando dovrebbe stampare 401. Il secondo dovrebbe stampare l'elenco dei modelli. Se anche il primo restituisce l'elenco dei modelli, verificate quale server e quale location hanno gestito la richiesta e se il reload è riuscito. Un blocco map nel contesto errato rende non valida la configurazione. Deve trovarsi al livello http. Inseritelo in un file sotto /etc/nginx/conf.d/ o sopra il blocco server, mai all'interno di server.
Caddy svolge lo stesso compito con l'autenticazione di base in quattro righe. Per un client browser, questa soluzione è più adatta di un bearer token:
llm.example.com {
basic_auth {
apiuser PASTE_BCRYPT_HASH_HERE
}
reverse_proxy 127.0.0.1:11434
}Eseguite caddy hash-password per generare l'hash bcrypt richiesto. Nota sul nome: prima di Caddy v2.8 la direttiva era basicauth, mentre ora è basic_auth. Caddy accetta ancora la vecchia sintassi come alias obsoleto. Una configurazione copiata da una guida precedente viene quindi caricata, ma Caddy avvisa che basicauth è obsoleto e chiede di usare basic_auth. Rinominate la direttiva quando compare questo avviso.
Qualunque proxy scegliate, si tratta di un unico secret condiviso da tutti. Ogni client che lo possiede ha lo stesso livello di accesso. Per revocarlo dovete modificare la configurazione e aggiornare contemporaneamente tutti i chiamanti.
Difesa 3: un gateway che rilascia chiavi per client
Quando più persone o applicazioni chiamano il modello, un token condiviso non è più sufficiente. Non puoi sapere quale client ha generato il carico e non puoi bloccarne uno senza bloccarli tutti. Un gateway si colloca dove prima si trovava il proxy, usa la stessa API compatibile con OpenAI, rilascia una chiave separata per ogni client e registra l'utilizzo associato a ciascuna chiave. Un gateway LiteLLM self-hosted è la soluzione più comune e aggiunge budget per chiave e log delle richieste oltre al controllo degli accessi.
La regola della difesa 1 non cambia. Ollama è in ascolto su 127.0.0.1, il gateway è l'unico processo che comunica con Ollama e il gateway è l'unico servizio con un listener pubblico. Un gateway installato su un host in cui la porta 11434 è ancora esposta a Internet è solo un elemento decorativo, perché i client possono semplicemente aggirarlo.
La trappola del firewall: una porta del container pubblicata aggira UFW
Questo spiega perché sui server possono esistere istanze esposte anche quando i proprietari hanno configurato correttamente il firewall.
UFW (uncomplicated firewall) scrive le proprie regole nella catena INPUT della tabella filter del kernel, mentre INPUT gestisce i pacchetti destinati direttamente all'host. Il flag -p di Docker scrive una regola di NAT di destinazione (network address translation) nella catena PREROUTING della tabella nat, che il kernel valuta prima di decidere la destinazione del pacchetto. Quando avviene la decisione di instradamento, la destinazione è già stata riscritta con l'indirizzo del container. Il pacchetto viene quindi inoltrato invece di essere consegnato localmente e attraversa FORWARD anziché INPUT. Le regole INPUT di UFW non vengono mai consultate, quindi il pacchetto aggira il firewall invece di attraversarlo.
Per questo la seguente sequenza lascia la porta 11434 aperta a Internet:
sudo ufw default deny incoming
sudo ufw enable
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollamae sudo ufw status continua a indicare che il firewall è attivo con una policy predefinita di deny. Entrambe le informazioni sono corrette allo stesso tempo. È proprio questo che porta a fidarsi dell'informazione sbagliata. È possibile vedere la regola che ha prodotto questo risultato:
sudo iptables -t nat -L DOCKER -nLa correzione consiste nell'indicare un indirizzo nel flag di pubblicazione:
docker rm -f ollama
docker run -d -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama-p 11434:11434 non specifica alcun indirizzo dell'host, quindi Docker pubblica la porta su tutti gli indirizzi dell'host, sia IPv4 (0.0.0.0) sia IPv6 ([::]). Specificando 127.0.0.1 si associa il lato host della mappatura all'interfaccia di loopback. In questo modo il tunnel SSH e il reverse proxy possono ancora raggiungerlo, mentre Internet no. Le versioni di Docker precedenti alla 28.0.0 fanno eccezione: le macchine nello stesso segmento di rete possono raggiungere le porte pubblicate su localhost. Esegui quindi l'upgrade prima di fare affidamento su questa protezione. In questo caso ricreare il container è sicuro perché i modelli si trovano nel volume denominato ollama, non all'interno del container.
Verifica che entrambe le visualizzazioni coincidano:
docker port ollama
sudo ss -tlnp | grep 11434docker port ollama dovrebbe restituire 11434/tcp -> 127.0.0.1:11434. Se restituisce 0.0.0.0:11434 o [::]:11434, il servizio è ancora esposto. Dopo aver compreso una volta il meccanismo, puoi applicarlo a ogni container che pubblicherai: perché le porte pubblicate da Docker aggirano UFW illustra la catena DOCKER-USER e le regole che rimangono attive dopo un riavvio di Docker. Se stai ancora definendo la policy dell'host, le regole UFW necessarie su un nuovo VPS descrive la configurazione di base su cui si fonda questa soluzione. Su Rocky o AlmaLinux non c'è UFW da configurare. In questo caso, la stessa policy di base scritta in firewalld è il punto di partenza.
Con quale account viene eseguito il processo
Lo script di installazione di Linux crea un account dedicato ed esegue il servizio con quell'account:
useradd -r -s /bin/false -U -m -d /usr/share/ollama ollamaL'unità in /etc/systemd/system/ollama.service imposta quindi User=ollama e Group=ollama. Non modificare questa configurazione. Un rapido ollama serve avviato manualmente in un terminale viene eseguito con l'account dell'utente con cui hai effettuato l'accesso. Se si tratta di root, un'API non autenticata scrive file con i privilegi di root. Verifica quale sia il caso:
ps -o user= -C ollamaIl risultato dovrebbe essere ollama. Qualsiasi altro risultato indica che un processo avviato manualmente è in esecuzione insieme all'unità oppure al suo posto. Lo stesso principio si applica a ogni daemon aggiunto in seguito, e eseguire i servizi con account dotati dei privilegi minimi lo applica correttamente.
Come verificare che l'endpoint API di Ollama sia sicuro
Indipendentemente dalla soluzione scelta, un test è decisivo e deve essere eseguito da un'altra macchina:
curl -m 5 http://YOUR_SERVER_IP:11434/api/version
curl -m 5 http://YOUR_SERVER_IP:11434/api/tagsEntrambe le richieste dovrebbero andare in timeout o essere rifiutate. Se hai configurato un proxy, gli stessi due percorsi sul nome host del proxy dovrebbero restituire 401 senza credenziali e JSON valido con le credenziali.
Quindi leggi una volta l'access log per le richieste eseguite mentre la porta era aperta:
journalctl -u ollama --since "-30 days" | grep GINOllama scrive una riga per ogni richiesta e include l'indirizzo del client:
[GIN] 2026/08/12 - 14:01:10 | 200 | 103.965898ms | 127.0.0.1 | POST "/api/generate"L'indirizzo proviene da ClientIP() di Gin, che controlla anche gli header X-Forwarded-For e X-Real-IP provenienti dai proxy attendibili. Una richiesta che passa attraverso un reverse proxy in loopback può quindi mostrare l'indirizzo pubblico del client, mentre Ollama è correttamente in ascolto su 127.0.0.1. La presenza di un indirizzo pubblico in quella colonna non dimostra l'accesso diretto alla porta 11434, così come l'assenza di righe di log corrispondenti non dimostra che nessuno abbia raggiunto la porta. Confronta i timestamp con i log e la configurazione del proxy e usa il test della connessione esterna per verificare l'esposizione attuale. Se la parte relativa ai modelli è nuova per te, eseguire Ollama su un VPS illustra l'installazione, il dimensionamento del modello e i limiti di memoria che determinano quali modelli verranno effettivamente caricati.
FAQ
Ollama ha una chiave API o una password?
No. Il server eseguito non applica alcun tipo di autenticazione e la documentazione ufficiale specifica che l'API locale non richiede autenticazione. Entrambi gli elementi chiamati "chiave API di Ollama" hanno uno scopo diverso. La coppia Ed25519 in /usr/share/ollama/.ollama/ autentica la macchina presso ollama.com, così puoi pubblicare modelli e scaricare quelli privati. OLLAMA_API_KEY è una credenziale che il client invia all'API ospitata in https://ollama.com/api. Il tuo ollama serve non usa nessuno dei due elementi per autenticare i client in ingresso, quindi il controllo degli accessi deve essere applicato dalla rete o da un proxy anteposto al servizio.
OLLAMA_HOST=0.0.0.0 è sicuro se ho un firewall?
Solo se il firewall blocca correttamente l'accesso a quel listener. 0.0.0.0 indica che il listener esiste realmente sull'interfaccia pubblica e che ti affidi soltanto al firewall per impedirne l'accesso. Una porta Ollama pubblicata da Docker richiede particolare attenzione, perché la regola DNAT aggiunta da Docker nella tabella nat viene valutata prima che il pacchetto raggiunga la catena INPUT, dove opera UFW; di conseguenza il pacchetto viene inoltrato e le regole INPUT di UFW non lo intercettano. Il binding a 127.0.0.1 o all'indirizzo di un tunnel privato rimuove il listener dall'interfaccia pubblica, quindi un errore del firewall non lascia nulla da esporre.
Come posso verificare se la porta Ollama è aperta a Internet?
Esegui sudo ss -tlnp | grep 11434 sul server e curl -m 5 http://YOUR_SERVER_IP:11434/api/version da un'altra macchina. Il risultato ss che mostra 127.0.0.1:11434, insieme al timeout di curl remoto, è quello atteso. Se ss mostra 0.0.0.0:11434 o *:11434 e curl remoto restituisce JSON, l'API completa è raggiungibile. Eseguire curl direttamente sul server non dimostra che un'altra macchina possa raggiungerlo.
Posso semplicemente spostare la porta da 11434 a una porta casuale?
No, ed è importante chiarire il motivo. Una porta diversa rallenta soltanto la scansione di quella singola porta. Gli scanner analizzano l'intero intervallo e una richiesta a /api/tags identifica il servizio indipendentemente dalla porta su cui è arrivata. Spostare la porta inoltre interrompe le impostazioni predefinite di tutti i client e rende più difficile comprendere la configurazione in seguito. Usa invece il binding su loopback: rimuove il listener dall'interfaccia pubblica invece di trasferirlo.
Qualcuno ha raggiunto la mia istanza Ollama esposta. Che cosa devo controllare?
Esegui prima il binding a 127.0.0.1 e riavvia il servizio, così interrompi l'esposizione prima di iniziare l'analisi. Poi esegui journalctl -u ollama --since "-30 days" | grep GIN per esaminare indirizzi dei client, endpoint e timestamp. Gin legge anche gli header che inoltrano l'indirizzo del client, quindi confronta queste voci con i log del proxy prima di considerare un indirizzo come prova di un accesso diretto. Confronta ollama list con i modelli che dovevano essere presenti, perché /api/pull non richiede autenticazione e un modello che non hai scaricato rappresenta sia spazio occupato su disco sia un'indicazione dell'accesso. Controlla lo spazio libero con df -h. Il log degli accessi predefinito registra i metadati delle richieste, non il nome del modello, il testo del prompt o la risposta generata.