Ollama sem palavra-passe: como proteger a API 11434
A API do Ollama não tem autenticação: quem alcança a porta 11434 pode executar, baixar e apagar modelos. Veja as três correções, na ordem certa.
A API do Ollama não tem palavra-passe
A API do Ollama não tem autenticação. Não existe utilizador, palavra-passe nem validação de chave de API para os clientes recebidos. Qualquer cliente que consiga abrir uma ligação TCP à porta 11434 pode listar os seus modelos, executá-los, descarregar novos modelos e eliminar os que já tem.
A documentação oficial afirma isso claramente: "A API local em http://localhost:11434 não requer autenticação." A palavra local define todo o modelo de segurança. Por predefinição, o Ollama associa-se a 127.0.0.1, pelo que, num portátil, a interface de loopback funciona como controlo de acesso. Se mover esse listener para um endereço público, o controlo de acesso desaparece, porque nada o substitui.
É por isso que isto é importante num VPS (servidor privado virtual). A configuração predefinida é segura. A primeira alteração que a maioria das pessoas faz, abrir o listener para que uma segunda máquina possa usar o modelo, é precisamente a alteração que remove todas as proteções de uma só vez.
O que uma porta 11434 aberta expõe
Todos os endpoints. Não existe modo só de leitura nem uma porta de administração separada. Estes são os pedidos reais, dirigidos ao endereço do servidor em vez de 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"}'Do ponto de vista operacional, há quatro problemas:
- O seu CPU ou GPU executa inferência para outra pessoa. Num plano com uma quota de CPU de utilização razoável, uma carga contínua consome a sua quota sem que saiba quem a está a utilizar, e manter os custos das cargas de trabalho de IA sob controlo num VPS torna-se muito mais difícil quando não é o único a fazer pedidos.
/api/pullescreve no seu disco. Os tamanhos dos modelos variam; atéllama3.2:1btem 1.3 GB. Um ciclo de downloads preenche o volume, e um disco cheio interrompe todos os outros serviços no servidor, não apenas o Ollama.- Os pedidos entram no seu processo e ficam registados. No nível de log predefinido, o Ollama regista apenas metadados. Assim, obtém o endpoint, o estado, a latência e o endereço do cliente, mas não o texto do prompt. Ainda assim, fica no seu journal um registo de quem utilizou o servidor e para quê, sem que tenha escolhido recolhê-lo.
/api/deleteremove modelos. Para os recuperar, é necessário descarregá-los novamente através da sua própria largura de banda.
Nada disto requer uma exploração de vulnerabilidade. É a API documentada a funcionar exatamente como foi concebida.
A chave Ed25519 não controla o acesso
Pesquise por "Ollama API key" e encontrará duas coisas diferentes. Nenhuma delas é uma palavra-passe do seu servidor. Distingui-las elimina grande parte da confusão.
A primeira é o par de chaves de identidade. O Ollama gera um par de chaves Ed25519 na primeira execução. No Linux, o script de instalação cria um utilizador de sistema chamado ollama, com o diretório pessoal em /usr/share/ollama. Por isso, o par fica aqui:
/usr/share/ollama/.ollama/id_ed25519
/usr/share/ollama/.ollama/id_ed25519.pubEssa chave é usada para ligações de saída. ollama signin regista a parte pública na sua conta ollama.com. É ela que autoriza o envio de um modelo para o registry ou a obtenção de um modelo privado. A chave identifica a sua máquina perante o ollama.com. Não exige nada dos clientes que se ligam à sua máquina. Apagá-la, substituí-la ou nunca a criar não altera quem pode chamar a sua API.
A segunda é OLLAMA_API_KEY. Essa variável contém uma chave que cria em https://ollama.com/settings/keys. O seu cliente envia-a como Authorization: Bearer $OLLAMA_API_KEY ao chamar a API alojada em https://ollama.com/api. É uma credencial do serviço deles, usada por si enquanto cliente. O seu próprio ollama serve não a usa para autenticar pedidos recebidos. Definir OLLAMA_API_KEY no seu VPS não coloca uma palavra-passe no seu VPS.
Por isso, não há nenhuma definição para ativar. As três defesas abaixo funcionam da mesma forma: mantenha a porta inacessível e coloque à frente dela algo que faça a verificação.
Verifique em que portas o seu servidor está a escutar neste momento
sudo ss -tlnp | grep 11434O resultado seguro identifica o endereço de loopback:
LISTEN 0 4096 127.0.0.1:11434 0.0.0.0:* users:(("ollama",pid=812,fd=3))O resultado exposto identifica todas as interfaces:
LISTEN 0 4096 0.0.0.0:11434 0.0.0.0:* users:(("ollama",pid=812,fd=3))0.0.0.0 representa todos os endereços IPv4 do sistema, incluindo o endereço público. *:11434 e [::]:11434 são listeners wildcard em todos os endereços IPv6. O facto de também aceitarem IPv4 depende da opção IPV6_V6ONLY do socket, que o Linux deixa desativada por predefinição (net.ipv6.bindv6only=0). Por isso, trate qualquer um dos três como exposto.
Agora confirme a partir do exterior. Execute isto no seu portátil, não no servidor:
curl -m 5 http://YOUR_SERVER_IP:11434/api/versioncurl: (28) Connection timed out after 5001 milliseconds é o resultado esperado, tal como curl: (7) Failed to connect ... Connection refused. Um objeto JSON com um campo version significa que toda a API está acessível a qualquer pessoa que faça o pedido. Testar com curl no próprio servidor não confirma se outra máquina consegue aceder-lhe. Se o servidor tiver um endereço IPv6, repita o teste com curl -6 -m 5 http://[YOUR_SERVER_IPV6]:11434/api/version, porque uma porta IPv4 fechada não fornece informação sobre um listener IPv6.
A exposição costuma ocorrer de uma de duas formas. A primeira é uma alteração deliberada, porque era necessário permitir que uma segunda máquina acedesse ao modelo:
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"Essa única linha é suficiente para expor o serviço. A segunda forma é o Docker, que não exige qualquer alteração manual. Esse caso tem uma secção própria abaixo.
Defesa 1: mantenha-o em localhost e crie um túnel
Comece por esta opção. Ela não exige software adicional e não cria nenhuma credencial que possa vazar. A porta nunca existe numa interface pública, portanto as varreduras não a encontram.
Defina explicitamente o endereço de escuta em vez de depender do valor padrão:
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"Isso grava /etc/systemd/system/ollama.service.d/override.conf. Aplique a alteração e verifique:
sudo systemctl daemon-reload
sudo systemctl restart ollama
sudo ss -tlnp | grep 11434ss agora deve mostrar 127.0.0.1:11434. Se ainda mostrar 0.0.0.0, outro ficheiro drop-in está a prevalecer. Execute systemctl cat ollama.service para listar a unidade e todos os drop-ins com os respetivos caminhos e elimine o ficheiro obsoleto.
Para utilizar o modelo a partir do seu portátil, encaminhe a porta através de SSH:
ssh -N -L 11434:127.0.0.1:11434 you@your-server-L 11434:127.0.0.1:11434 abre a porta 11434 no seu portátil e envia tudo o que chegar a essa porta para 127.0.0.1:11434, conforme visto a partir do servidor. -N indica ao SSH para não executar um comando remoto, por isso o processo mantém apenas o túnel aberto. Enquanto estiver em execução, isto funciona no seu portátil:
curl -s http://localhost:11434/api/tagsIrá encontrar duas falhas. bind [127.0.0.1]:11434: Address already in use significa que o endereço e a porta locais já estão a ser utilizados, pelo Ollama, por outro túnel SSH ou por outro programa. Nesse caso, escolha outra porta local com -L 11500:127.0.0.1:11434 e aponte o cliente para 11500. Se um pedido através do túnel receber uma resposta vazia, verifique ss no servidor e a saída de erro do SSH antes de decidir qual serviço falhou.
Para várias máquinas cliente, uma rede privada é melhor do que um túnel por pessoa. Coloque as máquinas numa rede WireGuard ou Tailscale e configure o Ollama para escutar no endereço dessa rede, em vez de 0.0.0.0:
[Service]
Environment="OLLAMA_HOST=10.8.0.1:11434"A porta passa a existir apenas numa interface à qual é necessária uma chave para aderir. Isto também resiste a um erro de firewall, porque uma regra que permita acidentalmente o acesso de toda a Internet não consegue expor um serviço que não está presente na interface pública.
Defesa 2: um reverse proxy que valida um bearer token
Quando algo na Internet pública precisa de chamar o modelo, mantenha o Ollama em loopback e coloque um proxy à frente dele. O proxy termina o TLS (transport layer security) e rejeita pedidos sem o cabeçalho correto. O Ollama continua a aceitar ligações apenas de 127.0.0.1, por isso o proxy é a única rota de entrada.
Gere primeiro um token real. Não invente um manualmente:
openssl rand -base64 36Um site nginx que o valida:
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;
}
}Há cinco linhas que fazem trabalho efetivo, e cada uma evita uma falha que, de outra forma, encontraria.
if dentro de um bloco location é normalmente uma má ideia no nginx, mas um corpo com exatamente return é uma das duas formas que funcionam de maneira previsível, por isso esta utilização é segura.
location = /api/pull é uma correspondência exata, e o nginx atribui prioridade às correspondências exatas sobre o prefixo location /. Por isso, esses três endpoints são recusados antes de o token ser sequer considerado. Um token válido continua a dar acesso a outros endpoints de gestão do modelo, incluindo /api/create e /api/blobs/:digest, por isso estes três blocos não impedem todas as escritas em disco.
proxy_set_header Host 127.0.0.1:11434; é importante porque o Ollama analisa os cabeçalhos de entrada Host e Origin. Passar diretamente o hostname público do proxy pode produzir um 403 Forbidden originado pelo Ollama e não pelo nginx, o que dificulta a resolução de problemas. OLLAMA_ORIGINS é o outro mecanismo, para um cliente de browser que precise de uma origem específica autorizada.
proxy_buffering off; é importante porque o Ollama transmite a resposta token a token. Com o buffering ativado, o nginx armazena a resposta antes de a enviar, o que atrasa a entrega dos tokens transmitidos.
proxy_read_timeout 600s; é importante porque o valor predefinido do nginx é de 60 segundos, e esse temporizador corre entre duas leituras sucessivas do Ollama, não durante toda a resposta. Uma resposta transmitida que continue a produzir tokens reinicia o temporizador a cada token. Um pedido em que o Ollama não envie nada durante 60 segundos faz o temporizador expirar, como um pedido enviado com "stream": false, que devolve a resposta completa de uma só vez no fim, ou um pedido com um longo silêncio antes de chegar o primeiro token. O cliente recebe 504 Gateway Time-out, e /var/log/nginx/error.log regista upstream timed out (110: Connection timed out) while reading response header from upstream. O pedido continuava em execução. O nginx desistiu dele.
Recarregue a configuração e teste os dois caminhos:
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/tagsO primeiro deve imprimir 401. O segundo deve imprimir a lista dos seus modelos. Se o primeiro também devolver a lista de modelos, confirme qual servidor e qual localização trataram o pedido e se o reload foi concluído com sucesso. Um bloco map no âmbito errado torna a configuração inválida. Deve ficar ao nível de http, num ficheiro sob /etc/nginx/conf.d/ ou acima do bloco server, nunca dentro de server.
O Caddy faz o mesmo trabalho com autenticação básica em quatro linhas, o que é mais adequado para um cliente de browser do que um bearer token:
llm.example.com {
basic_auth {
apiuser PASTE_BCRYPT_HASH_HERE
}
reverse_proxy 127.0.0.1:11434
}Execute caddy hash-password para gerar o hash bcrypt que ele espera. Uma nota sobre a nomenclatura: a diretiva chamava-se basicauth antes do Caddy v2.8 e chama-se basic_auth atualmente. O Caddy ainda aceita a grafia antiga como alias obsoleto, por isso uma configuração copiada de um guia mais antigo é carregada, mas o Caddy avisa que basicauth está obsoleta e pede que use basic_auth. Renomeie-a quando vir esse aviso.
Independentemente do proxy escolhido, este é um segredo partilhado por todos. Todos os clientes que o possuam têm exatamente o mesmo acesso, e revogá-lo implica editar a configuração e atualizar todos os clientes ao mesmo tempo.
Defesa 3: um gateway que emite chaves por cliente
Quando mais do que uma pessoa ou aplicação chama o modelo, um token partilhado deixa de ser suficiente. Não é possível saber qual cliente causou a carga, nem bloquear apenas um deles sem bloquear todos. Um gateway fica no lugar onde estava o proxy, utiliza a mesma API compatível com OpenAI, emite uma chave separada por cliente e regista o que cada chave utilizou. Um gateway LiteLLM autoalojado é a resposta habitual. Além do controlo de acesso, acrescenta limites por chave e logs de pedidos.
A regra da defesa 1 não muda. O Ollama faz bind a 127.0.0.1, o gateway é o único processo que comunica com ele e o gateway é o único serviço com um listener público. Um gateway num servidor onde a porta 11434 continua aberta para a Internet é apenas decoração, porque os clientes podem contorná-lo.
A armadilha do firewall: uma porta de contentor publicada ignora o UFW
É por isso que existem instâncias expostas em servidores cujos proprietários configuraram corretamente um firewall.
O UFW (uncomplicated firewall) escreve as suas regras na cadeia INPUT da tabela filter do kernel, e INPUT processa os pacotes destinados ao próprio host. A opção -p do Docker escreve uma regra de NAT de destino (network address translation) na cadeia PREROUTING da tabela nat, que o kernel avalia antes de decidir para onde o pacote deve ser encaminhado. Quando ocorre a decisão de encaminhamento, o destino já foi alterado para o endereço do contentor. Por isso, o pacote é encaminhado em vez de ser entregue localmente e atravessa FORWARD em vez de INPUT. As regras INPUT do UFW nunca são consultadas. O pacote contorna o firewall em vez de passar por ele.
É por isso que esta sequência deixa a porta 11434 aberta à 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 indicar que o firewall está ativo com uma política padrão de negar. As duas leituras estão corretas ao mesmo tempo. É exatamente por isso que as pessoas confiam na leitura errada. Pode ver a regra que causou o problema:
sudo iptables -t nat -L DOCKER -nA correção consiste em indicar um endereço na opção de publicação:
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 não indica nenhum endereço do host. Por isso, o Docker publica a porta em todos os endereços do host, tanto IPv4 (0.0.0.0) como IPv6 ([::]). Indicar 127.0.0.1 associa o lado do host do mapeamento à interface de loopback. Assim, o seu túnel SSH e o reverse proxy continuam a conseguir aceder à porta, mas a Internet não. As versões do Docker anteriores a 28.0.0 têm uma exceção: máquinas no mesmo segmento de rede conseguem aceder a portas publicadas em localhost. Atualize antes de depender desta proteção. Recriar o contentor é seguro neste caso porque os modelos estão no volume nomeado ollama, e não dentro do contentor.
Confirme que as duas perspetivas coincidem:
docker port ollama
sudo ss -tlnp | grep 11434docker port ollama deve imprimir 11434/tcp -> 127.0.0.1:11434. Se imprimir 0.0.0.0:11434 ou [::]:11434, o serviço continua exposto. Depois de compreender este mecanismo, ele aplica-se a todos os contentores que publicar: por que motivo as portas publicadas pelo Docker ignoram o UFW explica a cadeia DOCKER-USER e as regras que permanecem depois de um reinício do Docker. Se ainda estiver a configurar a política do próprio host, as regras UFW necessárias num VPS novo explica a base desta configuração. No Rocky ou AlmaLinux, não existe UFW para configurar. Nesse caso, a mesma política base escrita em firewalld é o ponto de partida.
Com que conta o processo está a ser executado
O script de instalação do Linux cria uma conta dedicada e executa o serviço com essa conta:
useradd -r -s /bin/false -U -m -d /usr/share/ollama ollamaA unidade em /etc/systemd/system/ollama.service define então User=ollama e Group=ollama. Não altere essa configuração. Um ollama serve iniciado manualmente num terminal é executado com a conta do utilizador com que iniciou sessão. Se essa conta for root, uma API sem autenticação estará a escrever ficheiros como root. Verifique qual é o caso:
ps -o user= -C ollamaA resposta deve ser ollama. Qualquer outro resultado significa que existe um processo iniciado manualmente a correr em paralelo com a unidade ou em vez dela. O mesmo princípio aplica-se a cada daemon que adicionar posteriormente, e executar serviços com contas de privilégios mínimos trata corretamente deste caso.
Como verificar se o endpoint da API do Ollama está seguro
Independentemente da opção escolhida, um teste confirma a configuração. Ele tem de ser executado a partir de outra máquina:
curl -m 5 http://YOUR_SERVER_IP:11434/api/version
curl -m 5 http://YOUR_SERVER_IP:11434/api/tagsAmbos devem atingir o tempo limite ou ser recusados. Se tiver configurado um proxy, os mesmos dois caminhos no nome do host do proxy devem devolver 401 sem credenciais e JSON válido com credenciais.
Em seguida, leia uma vez o log de acesso para consultar os pedidos feitos enquanto a porta esteve aberta:
journalctl -u ollama --since "-30 days" | grep GINOllama escreve uma linha por pedido e inclui o endereço do cliente:
[GIN] 2026/08/12 - 14:01:10 | 200 | 103.965898ms | 127.0.0.1 | POST "/api/generate"Esse endereço vem de ClientIP() do Gin, que também verifica os cabeçalhos X-Forwarded-For e X-Real-IP enviados por proxies confiáveis. Por isso, um pedido através de um reverse proxy em loopback pode apresentar o endereço público do cliente, enquanto o Ollama está corretamente associado a 127.0.0.1. Um endereço público nessa coluna não prova que houve acesso direto à porta 11434, e a ausência de linhas correspondentes no log não prova que ninguém a alcançou. Compare os timestamps com os logs e a configuração do proxy e use o teste de ligação externo para verificar a exposição atual. Se esta parte relacionada com os modelos for nova para si, executar o Ollama num VPS aborda a instalação, o dimensionamento do modelo e os limites de memória que determinam o que será efetivamente carregado.
FAQ
O Ollama tem uma chave de API ou uma palavra-passe?
Não. O servidor que executa não tem qualquer tipo de autenticação, e a documentação oficial afirma que a API local não requer autenticação. As duas coisas chamadas "chave de API do Ollama" referem-se a outra finalidade. O par Ed25519 em /usr/share/ollama/.ollama/ identifica a sua máquina perante ollama.com, para que possa enviar modelos e obter modelos privados. OLLAMA_API_KEY é uma credencial que o seu cliente envia para a API alojada em https://ollama.com/api. O seu próprio ollama serve não utiliza nenhuma delas para autenticar clientes recebidos, por isso o controlo de acesso tem de ser aplicado pela rede ou por um proxy à frente do serviço.
OLLAMA_HOST=0.0.0.0 é seguro se eu tiver uma firewall?
Apenas se a firewall bloquear corretamente o acesso a esse listener. 0.0.0.0 significa que o listener existe efetivamente na interface pública e que está a confiar apenas na firewall para impedir o acesso. Uma porta do Ollama publicada pelo Docker requer atenção separada, porque a regra DNAT que o Docker adiciona à tabela nat é avaliada antes de o pacote chegar à cadeia INPUT, onde o UFW funciona. Assim, o pacote é encaminhado e as regras INPUT do UFW nunca o veem. A associação a 127.0.0.1 ou a um endereço de túnel privado remove o listener da interface pública, por isso um erro na firewall deixa de ter algo para expor.
Como verifico se a minha porta do Ollama está aberta para a Internet?
Execute sudo ss -tlnp | grep 11434 no servidor e curl -m 5 http://YOUR_SERVER_IP:11434/api/version a partir de outra máquina. O resultado ss a mostrar 127.0.0.1:11434, juntamente com o curl remoto a exceder o tempo limite, é a combinação de respostas que pretende obter. Se ss mostrar 0.0.0.0:11434 ou *:11434 enquanto o curl remoto devolve JSON, a API completa está acessível. Testar com curl no próprio servidor não prova que outra máquina lhe consiga aceder.
Posso simplesmente mudar a porta de 11434 para uma porta aleatória?
Não, e vale a pena explicar o motivo. Uma porta diferente não abranda nada, exceto uma verificação dessa única porta. Os scanners percorrem todo o intervalo, e um pedido para /api/tags identifica o serviço, independentemente da porta em que o pedido chegou. Mudar a porta também quebra os valores predefinidos de todos os clientes e torna a sua configuração mais difícil de compreender posteriormente. Associe o serviço ao loopback, que remove o listener em vez de o mudar de lugar.
Alguém acedeu ao meu Ollama exposto. O que devo verificar?
Associe-o a 127.0.0.1 e reinicie primeiro o serviço, para interromper a exposição antes de iniciar a investigação. Em seguida, execute journalctl -u ollama --since "-30 days" | grep GIN para consultar os endereços dos clientes, os endpoints e os timestamps. O Gin também lê cabeçalhos encaminhados com o endereço do cliente, por isso compare essas entradas com os logs do proxy antes de considerar um endereço como prova de acesso direto. Compare ollama list com os modelos que pretendia ter, porque /api/pull não requer autenticação e um modelo que não tenha obtido representa tanto utilização de espaço em disco como evidência. Verifique o espaço livre com df -h. O log de acesso predefinido regista metadados dos pedidos, não o nome do modelo, o texto do prompt nem a resposta gerada.