Installare OpenClaw su un VPS in sicurezza

OpenClaw e un assistente AI open-source e self-hosted che si collega alle app di messaggistica (WhatsApp, Telegram, Discord, Slack, Signal) e ai provider di modelli AI. Esegue un processo Gateway sul tuo server, riceve messaggi, esegue azioni degli agenti tramite tool e invia risposte. Tutti i dati restano sulla tua infrastruttura.

Questa guida descrive un deployment orientato alla sicurezza su un VPS con Ubuntu 24.04. Farai hardening del sistema operativo, installerai OpenClaw, configurerai l'autenticazione del gateway, imposterai Nginx con TLS come reverse proxy, risolverai il bypass del firewall Docker/UFW, abiliterai il sandboxing Docker, limiterai le policy dei tool e lancerai il gateway come servizio systemd con hardening.

Perche la sicurezza di OpenClaw conta su un VPS?

OpenClaw esegue agenti AI che possono lanciare comandi shell, leggere file e navigare il web sul tuo server. Un'istanza mal configurata offre le stesse capacita a un attaccante. Non e teoria.

A inizio 2026, i ricercatori hanno trovato oltre 42.000 istanze OpenClaw esposte sulla rete pubblica. Il 63% era vulnerabile a exploitation remoto. CVE-2026-25253 (CVSS 8.8) permetteva l'esecuzione di codice remoto con un solo clic tramite l'esfiltrazione del token di autenticazione via link malevolo. L'attaccante poteva rubare il token del gateway, connettersi via WebSocket, disabilitare i prompt di conferma, evadere il sandboxing Docker ed eseguire comandi arbitrari.

La correzione e arrivata nella versione 2026.1.29, ma applicare la patch non basta. La sicurezza richiede piu livelli: isolamento di rete, autenticazione, TLS, sandboxing e restrizioni sui tool che lavorano insieme. Un singolo livello mancante (ad esempio autenticazione gateway senza firewall) lascia un percorso diretto alla compromissione.

Cosa serve prima di iniziare?

Requisito	Dettagli
VPS	Ubuntu 24.04, 4+ vCPU, 8 GB RAM minimo
Nome di dominio	Record A che punta all'IP del tuo VPS (es. openclaw.example.com)
Accesso SSH	Autenticazione con chiave configurata
Chiave API del provider AI	Anthropic, OpenAI o Google Gemini
Node.js	Versione 22 o successiva
Docker	Engine 20+ con plugin Compose

Se hai bisogno di aiuto per il provisioning di un VPS o la configurazione delle chiavi SSH, consulta Secure a Linux VPS.

Come si fa l'hardening del VPS prima di installare OpenClaw?

Prima di installare qualsiasi cosa, metti in sicurezza il sistema operativo. Se hai gia seguito Secure a Linux VPS e SSH Security Configuration, passa alla sezione successiva.

Creare un utente dedicato

Eseguire servizi come root e un rischio inutile. Crea un utente di sistema openclaw:

sudo useradd -r -m -s /bin/bash openclaw

Questo crea un account di sistema con una home directory. OpenClaw salva la sua configurazione in ~/.openclaw, quindi la home directory e necessaria.

Configurare UFW

Installa e abilita il firewall prima di esporre qualsiasi servizio:

sudo apt update && sudo apt install -y ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp comment 'SSH'
sudo ufw allow 80/tcp comment 'HTTP'
sudo ufw allow 443/tcp comment 'HTTPS'
sudo ufw enable

Verifica le regole:

sudo ufw status verbose

Dovresti vedere le tre porte consentite e una policy di deny di default per il traffico in ingresso. La porta 18789 (il gateway OpenClaw) manca intenzionalmente. Il gateway fa bind solo su localhost e sta dietro Nginx.

Installare fail2ban

sudo apt update && sudo apt install -y fail2ban
sudo systemctl enable --now fail2ban

Verifica che sia in esecuzione:

sudo systemctl status fail2ban

L'output dovrebbe mostrare active (running). fail2ban monitora i log SSH e banna gli IP dopo tentativi di login falliti ripetuti.

Come si installa OpenClaw su Ubuntu?

OpenClaw supporta due metodi di installazione: npm (diretto) e Docker. Entrambi sono descritti qui sotto. Scegline uno. Docker e consigliato per i deployment su VPS perche l'isolamento del container limita il raggio d'azione se il processo dell'agente viene compromesso.

Opzione A: installazione Docker (consigliata)

Installa Docker se non e gia presente:

sudo apt install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

Aggiungi l'utente openclaw al gruppo docker:

sudo usermod -aG docker openclaw

Nota: l'appartenenza al gruppo docker concede l'equivalente dell'accesso root sull'host. Questo e necessario per la funzionalita Docker di OpenClaw, ma significa che l'utente openclaw puo controllare tutti i container sul sistema. L'hardening systemd e l'isolamento sandbox descritti sotto limitano cio che il processo OpenClaw puo effettivamente fare.

Passa all'utente openclaw e configura OpenClaw:

sudo -u openclaw -i

Clona il repository e lancia il setup con l'immagine pre-compilata ufficiale:

git clone https://github.com/openclaw/openclaw.git ~/openclaw-src
cd ~/openclaw-src
OPENCLAW_IMAGE=ghcr.io/openclaw/openclaw:latest ./docker-setup.sh

Impostare OPENCLAW_IMAGE indica allo script di scaricare l'immagine pre-compilata dal GitHub Container Registry invece di compilare dai sorgenti. Lo script esegue l'onboarding e avvia il gateway tramite Docker Compose.

Il gateway all'interno del container fa bind su tutte le interfacce di default (modalita lan). Questo e corretto per i deployment Docker perche il port mapping di Docker deve raggiungere il gateway dentro il container. L'accesso esterno e bloccato a livello host usando le regole iptables DOCKER-USER (trattate sotto).

Verifica che il gateway sia in esecuzione:

curl -fsS http://127.0.0.1:18789/healthz

Una risposta 200 OK conferma che il gateway e attivo. L'endpoint /readyz conferma che e pronto ad accettare connessioni:

curl -fsS http://127.0.0.1:18789/readyz

Opzione B: installazione npm

Installa Node.js 22 usando NodeSource:

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs

Verifica la versione:

node --version

L'output dovrebbe mostrare v22.x.x o superiore.

Passa all'utente openclaw e installa:

sudo -u openclaw -i
npm install -g openclaw@latest

Esegui l'onboarding:

openclaw onboard

Seleziona loopback per la modalita di bind. Il wizard di onboarding genera un token di autenticazione del gateway e lo salva in ~/.openclaw/openclaw.json.

Avvia il gateway:

openclaw gateway start

Verifica:

curl -fsS http://127.0.0.1:18789/healthz

Verificare il binding del gateway

Controlla su cosa e in ascolto il gateway:

ss -tulpn | grep 18789

Per le installazioni npm: l'output dovrebbe mostrare 127.0.0.1:18789, non 0.0.0.0:18789. Se vedi 0.0.0.0, ferma il gateway e imposta gateway.bind su "loopback" in openclaw.json.

Per le installazioni Docker: vedrai 0.0.0.0:18789 dal processo docker-proxy. Questo e previsto. Il port mapping di Docker pubblica la porta su tutte le interfacce dell'host cosi il traffico da localhost puo raggiungere il container. Le regole iptables DOCKER-USER (trattate nella sezione firewall sotto) bloccano l'accesso esterno a livello di rete.

Bloccare i permessi dei file

Il file di configurazione contiene il tuo token di autenticazione e le chiavi API:

chmod 700 /home/openclaw/.openclaw
chmod 600 /home/openclaw/.openclaw/openclaw.json

Verifica:

ls -la /home/openclaw/.openclaw/openclaw.json

Dovresti vedere -rw-------. Per le installazioni npm, il proprietario e openclaw. Per le installazioni Docker, il proprietario potrebbe apparire come uid 1000 (l'utente node dentro il container). Questo e normale e necessario perche il container possa leggere la configurazione.

Come si configura l'autenticazione del gateway?

Il gateway di OpenClaw richiede autenticazione di default. Se non e configurato nessun token o password, il gateway rifiuta le connessioni WebSocket (fail-closed). Il wizard di onboarding genera un token automaticamente.

OpenClaw supporta tre modalita di autenticazione:

Modalita	Come funziona	Ideale per
token	Token bearer condiviso in ogni richiesta	VPS singolo utente (consigliato)
password	Autenticazione basata su password	Setup multi-dispositivo
trusted-proxy	Delega l'autenticazione a un reverse proxy	Setup enterprise/SSO

Impostare un token forte

Se vuoi sostituire il token generato automaticamente, generane uno nuovo:

openssl rand -base64 32

Salvalo come variabile d'ambiente invece di inserirlo direttamente nel file di configurazione. Crea un file di ambiente:

sudo mkdir -p /etc/openclaw
sudo tee /etc/openclaw/env > /dev/null << 'EOF'
OPENCLAW_GATEWAY_TOKEN=your-generated-token-here
EOF
sudo chmod 600 /etc/openclaw/env
sudo chown openclaw:openclaw /etc/openclaw/env

Modifica ~/.openclaw/openclaw.json per referenziare la variabile d'ambiente:

{
  gateway: {
    bind: "loopback",  // use "loopback" for npm, keep default for Docker
    port: 18789,
    auth: {
      mode: "token",
      token: "${OPENCLAW_GATEWAY_TOKEN}"
    }
  }
}

OpenClaw supporta la sostituzione ${VARIABLE} nella configurazione JSON5, quindi il token viene letto dall'ambiente all'avvio. Per le installazioni Docker, imposta la variabile OPENCLAW_GATEWAY_TOKEN nel file .env dentro la directory openclaw-src. Lo script docker-setup.sh genera questo file automaticamente.

Riavvia il gateway e verifica che le richieste non autenticate vengano rifiutate:

curl -s -o /dev/null -w "%{http_code}" http://127.0.0.1:18789/healthz

L'endpoint di health restituisce 200 senza autenticazione (e un health check). Per verificare l'applicazione dell'autenticazione sull'endpoint WebSocket, controlla i log del gateway:

Per le installazioni systemd/npm:

journalctl -u openclaw-gateway --no-pager -n 20

Per le installazioni Docker:

cd ~/openclaw-src && docker compose logs openclaw-gateway --tail 20

Cerca le voci auth required o connection rejected che confermano il comportamento fail-closed.

Come si configura Nginx come reverse proxy TLS per OpenClaw?

Il gateway fa bind su localhost. Nginx sta davanti, termina il TLS e fa proxy delle connessioni WebSocket verso il gateway. Questo ti da connessioni cifrate senza esporre la porta del gateway.

Per approfondimenti sui reverse proxy Nginx, consulta Nginx Reverse Proxy. Per la configurazione TLS con Let's Encrypt, consulta Nginx SSL/TLS with Let's Encrypt.

Installare Nginx e Certbot

sudo apt install -y nginx certbot python3-certbot-nginx

Ottenere un certificato TLS

sudo certbot --nginx -d openclaw.example.com

Sostituisci openclaw.example.com con il tuo dominio reale. Certbot configura il rinnovo automatico.

Configurare il reverse proxy

Crea il server block Nginx:

sudo tee /etc/nginx/sites-available/openclaw.conf > /dev/null << 'NGINX'
server {
    listen 443 ssl;
    listen [::]:443 ssl;
    server_name openclaw.example.com;

    ssl_certificate /etc/letsencrypt/live/openclaw.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/openclaw.example.com/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

    # Hide Nginx version
    server_tokens off;

    # WebSocket proxy to OpenClaw gateway
    location / {
        proxy_pass http://127.0.0.1:18789;

        # WebSocket support
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

        # Overwrite X-Forwarded-For, do not append
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header Host $host;

        # Timeouts for long-running agent sessions
        proxy_read_timeout 86400s;
        proxy_send_timeout 86400s;
    }
}

server {
    listen 80;
    listen [::]:80;
    server_name openclaw.example.com;
    return 301 https://$host$request_uri;
}
NGINX

Occhio al dettaglio: nota che proxy_set_header X-Forwarded-For $remote_addr usa $remote_addr (sovrascrittura), non $proxy_add_x_forwarded_for (append). Questo e intenzionale. L'append permette ai client di iniettare IP falsi nell'header. La documentazione di OpenClaw consiglia specificamente la sovrascrittura.

Abilita il sito e testa la configurazione:

sudo ln -s /etc/nginx/sites-available/openclaw.conf /etc/nginx/sites-enabled/
sudo nginx -t

L'output dovrebbe mostrare syntax is ok e test is successful. Ricarica Nginx:

sudo systemctl reload nginx

Configurare OpenClaw per fidarsi del proxy

Indica al gateway di fidarsi degli header inoltrati da Nginx aggiungendo trustedProxies a ~/.openclaw/openclaw.json:

{
  gateway: {
    bind: "loopback",  // use "loopback" for npm, keep default for Docker
    port: 18789,
    trustedProxies: ["127.0.0.1"],
    auth: {
      mode: "token",
      token: "${OPENCLAW_GATEWAY_TOKEN}"
    }
  }
}

Riavvia il gateway per applicare. Verifica che il TLS funzioni dalla tua macchina locale (non dal server):

curl -I https://openclaw.example.com/healthz

Dovresti ricevere una risposta 200 via HTTPS. Per ulteriore hardening di Nginx, consulta la guida all'hardening della sicurezza Nginx (in arrivo).

Come si risolve il bypass del firewall Docker e UFW?

Docker manipola iptables direttamente, aggirando UFW completamente. Se esegui OpenClaw con Docker e pubblichi una porta, quella porta e accessibile da internet anche se UFW la blocca. Questa e una delle misconfigurazioni piu comuni nei deployment Docker.

Per una spiegazione completa di questo problema, consulta Docker UFW Firewall Fix.

La soluzione usa la chain DOCKER-USER, che Docker elabora prima di inoltrare il traffico ai container.

Bloccare tutto l'accesso esterno alle porte Docker

sudo iptables -I DOCKER-USER -i eth0 -j DROP

Questo scarta tutto il traffico dall'interfaccia esterna (eth0) che Docker inoltrerebbe altrimenti ai container. Adatta il nome dell'interfaccia se il tuo e diverso (controlla con ip link show).

Consentire il traffico loopback

Nginx sullo stesso host deve raggiungere il container del gateway su localhost:

sudo iptables -I DOCKER-USER -i lo -j ACCEPT

Consentire le connessioni stabilite

sudo iptables -I DOCKER-USER -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

Rendere le regole persistenti

sudo apt install -y iptables-persistent
sudo netfilter-persistent save

Verificare le regole

sudo iptables -L DOCKER-USER -n -v

Dovresti vedere le regole ACCEPT per loopback e connessioni stabilite sopra la regola DROP per eth0. L'ordine conta: iptables elabora le regole dall'alto verso il basso.

Testa da una macchina esterna che la porta del gateway non sia raggiungibile:

nmap -p 18789 your-server-ip

La porta 18789 dovrebbe risultare filtered o closed, non open.

Come si abilita il sandboxing Docker per OpenClaw?

Il sandboxing Docker esegue le azioni dei tool degli agenti dentro container isolati. Quando un agente lancia un comando shell o scrive un file, succede in un container usa e getta, non sul tuo host.

Aggiungi la configurazione sandbox a ~/.openclaw/openclaw.json:

{
  agents: {
    defaults: {
      sandbox: {
        mode: "all",
        scope: "session",
        workspaceAccess: "none",
        docker: {
          image: "openclaw-sandbox:bookworm-slim",
          network: "none",
          user: "1000:1000",
          memory: "1g",
          cpus: 1
        }
      }
    }
  }
}

Cosa fa ogni impostazione:

Impostazione	Valore	Effetto
mode	"all"	Ogni sessione e in sandbox, senza eccezioni
scope	"session"	Ogni sessione di chat ottiene il proprio container
workspaceAccess	"none"	La sandbox non puo vedere il workspace dell'agente
network	"none"	Nessun accesso di rete dalla sandbox (previene l'esfiltrazione)
memory	"1g"	Limita la RAM del container a 1 GB
cpus	1	Limita il container a 1 core CPU

Compila l'immagine sandbox:

cd ~/openclaw-src
scripts/sandbox-setup.sh

Verifica la configurazione sandbox:

openclaw sandbox explain

Per le installazioni Docker, esegui tramite compose:

cd ~/openclaw-src && docker compose exec openclaw-gateway node dist/index.js sandbox explain

Questo comando stampa la modalita sandbox effettiva, lo scope, l'accesso al workspace, la policy dei tool e qualsiasi override. Conferma che mode: all e network: none compaiano nell'output.

Se hai bisogno di accesso alla rete per tool specifici (es. web_search), concedilo selettivamente per agente invece di cambiare il default globale. Consulta la sezione tool policy qui sotto.

OpenClaw blocca le sorgenti di bind mount pericolose di default: /var/run/docker.sock, /etc, /proc, /sys e /dev sono tutte negate. Non sovrascrivere questo con bind mount personalizzati che le ri-espongono. Se un container sandbox ha bisogno di accedere a dati dell'host, usa mount in sola lettura con percorsi espliciti:

{
  agents: {
    defaults: {
      sandbox: {
        docker: {
          binds: ["/home/openclaw/shared-data:/data:ro"]
        }
      }
    }
  }
}

Il suffisso :ro assicura che il container possa leggere i dati ma non modificarli.

Come si blocca la policy dei tool di OpenClaw?

La tool policy controlla quali tool possono usare gli agenti. La sandbox ha il proprio filtro dei tool separato dai permessi a livello di agente. Il deny prevale sempre sull'allow.

Policy deny di default

Imposta un default restrittivo in ~/.openclaw/openclaw.json:

{
  tools: {
    deny: ["exec", "write", "edit", "browser"],
    allow: ["read", "web_search"]
  }
}

Questo blocca l'esecuzione di comandi, la scrittura di file, la modifica di file e l'accesso browser di default. Gli agenti possono comunque leggere file e cercare sul web.

Profili per agente

Sovrascrivi i default per agenti specifici che necessitano di piu accesso. Aggiungi profili sotto agents.list:

{
  agents: {
    list: [
      {
        name: "coding-agent",
        tools: {
          allow: ["exec", "read", "write", "edit"],
          deny: ["browser"]
        },
        sandbox: {
          mode: "all",
          docker: {
            network: "none"
          }
        }
      },
      {
        name: "messaging-agent",
        tools: {
          allow: ["read", "web_search"],
          deny: ["exec", "write", "edit", "browser"]
        }
      }
    ]
  }
}

Il coding-agent puo eseguire comandi ma solo dentro un container in sandbox senza rete. Il messaging-agent puo leggere e cercare ma non puo eseguire nulla.

Disabilitare la modalita elevata

La modalita elevata (elevated mode) permette agli agenti di eseguire comandi direttamente sull'host del gateway, aggirando la sandbox. Disabilitala:

{
  tools: {
    elevated: {
      enabled: false
    }
  }
}

Se lasci la modalita elevata attiva, qualsiasi utente che puo chattare con l'agente puo potenzialmente eseguire comandi sull'host. Su un VPS, questo e esecuzione di codice remoto.

Isolamento DM multi-utente

Se piu persone invieranno messaggi alla tua istanza OpenClaw, abilita lo scoping DM per-peer. Di default, tutti i DM condividono una singola sessione principale. Questo significa che l'Utente A puo vedere il contesto della conversazione dell'Utente B.

{
  session: {
    dmScope: "per-peer"
  }
}

Questo assegna a ogni mittente la propria sessione con contesto e container sandbox isolati.

Come si esegue OpenClaw come servizio systemd con hardening?

Eseguire OpenClaw sotto systemd significa che si avvia al boot, si riavvia in caso di crash e ottiene isolamento del processo tramite le direttive di hardening.

Creare la unit del servizio

Per le installazioni Docker, crea il seguente file unit:

sudo tee /etc/systemd/system/openclaw-gateway.service > /dev/null << 'EOF'
[Unit]
Description=OpenClaw Gateway
After=network-online.target docker.service
Wants=network-online.target
Requires=docker.service

[Service]
Type=simple
User=openclaw
Group=openclaw
WorkingDirectory=/home/openclaw/openclaw-src
EnvironmentFile=/etc/openclaw/env
ExecStart=/usr/bin/docker compose up --no-log-prefix openclaw-gateway
ExecStop=/usr/bin/docker compose down
Restart=always
RestartSec=10

# Security hardening
NoNewPrivileges=yes
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=read-only
ReadWritePaths=/home/openclaw/.openclaw
CapabilityBoundingSet=
ProtectKernelTunables=yes
ProtectKernelModules=yes
ProtectControlGroups=yes
RestrictSUIDSGID=yes
MemoryMax=4G

[Install]
WantedBy=multi-user.target
EOF

Per le installazioni npm, sostituisci le righe ExecStart e ExecStop:

ExecStart=/usr/bin/openclaw gateway start --foreground
ExecStop=/usr/bin/openclaw gateway stop

E rimuovi la riga Requires=docker.service.

Cosa fa ogni direttiva di hardening:

Direttiva	Protezione
NoNewPrivileges	Impedisce al processo di ottenere privilegi aggiuntivi tramite setuid/setgid
PrivateTmp	Assegna al servizio il proprio /tmp, invisibile agli altri processi
ProtectSystem=strict	Monta l'intero filesystem in sola lettura tranne i ReadWritePaths espliciti
ProtectHome=read-only	Impedisce la scrittura in qualsiasi home directory tranne il percorso consentito
CapabilityBoundingSet=	Rimuove tutte le Linux capabilities (set vuoto)
ProtectKernelTunables	Blocca le scritture su /proc/sys, /sys
ProtectKernelModules	Impedisce il caricamento di moduli kernel
MemoryMax=4G	Termina il servizio se supera 4 GB di RAM, prevenendo OOM sull'host

Abilitare e avviare

sudo systemctl daemon-reload
sudo systemctl enable --now openclaw-gateway

enable lo fa partire al boot. --now lo avvia immediatamente.

Verifica che sia in esecuzione:

sudo systemctl status openclaw-gateway

L'output dovrebbe mostrare active (running). Controlla i log per eventuali errori:

journalctl -u openclaw-gateway -f --no-pager -n 50

Come si verifica che il deployment completo sia sicuro?

Segui questa checklist dopo il deployment per confermare che ogni livello funzioni.

1. Eseguire l'audit di sicurezza integrato di OpenClaw

Per le installazioni npm:

sudo -u openclaw openclaw security audit --deep

Per le installazioni Docker:

cd ~/openclaw-src && docker compose exec openclaw-gateway node dist/index.js security audit --deep

Questo segnala le misconfigurazioni comuni: esposizione di rete senza autenticazione, permessi elevati sui tool, problemi di permessi dei file. Correggi tutti i warning prima di procedere.

2. Confermare il binding del gateway

ss -tulpn | grep 18789

Installazioni npm: atteso 127.0.0.1:18789. Non 0.0.0.0:18789.

Installazioni Docker: atteso 0.0.0.0:18789 da docker-proxy. Questo e normale. L'accesso esterno e bloccato dalle regole iptables DOCKER-USER.

3. Scansione porte esterne

Dalla tua macchina locale (non dal server):

nmap -p 18789 your-server-ip

Atteso: filtered o closed.

4. Verificare il TLS

curl -I https://openclaw.example.com/healthz

Atteso: 200 via HTTPS con un certificato valido.

5. Testare l'applicazione dell'autenticazione

curl -s -o /dev/null -w "%{http_code}" https://openclaw.example.com/

Il gateway dovrebbe richiedere autenticazione per gli endpoint non-health.

6. Controllare l'isolamento sandbox

Per le installazioni npm:

sudo -u openclaw openclaw sandbox explain

Per le installazioni Docker:

cd ~/openclaw-src && docker compose exec openclaw-gateway node dist/index.js sandbox explain

Conferma mode: all, network: none e nessun override elevato.

7. Verificare i permessi dei file

ls -la /home/openclaw/.openclaw/openclaw.json
ls -la /etc/openclaw/env

Entrambi dovrebbero mostrare permessi 600. Il file env e di proprieta di openclaw. Per le installazioni Docker, openclaw.json potrebbe essere di proprieta dell'uid 1000 (l'utente node del container).

8. Controllare l'hardening systemd

systemd-analyze security openclaw-gateway

Questo assegna un punteggio alle proprieta di sicurezza del servizio. Punta a un punteggio intorno a 5.0 o inferiore (piu basso e piu sicuro). I servizi basati su Docker tipicamente ottengono circa 5.0-5.5 perche Docker richiede accesso a namespace e interfacce dei dispositivi. Le direttive di hardening sopra portano il punteggio dal default di circa 9.6 a circa 5.2.

9. Verificare le regole UFW e DOCKER-USER

sudo ufw status
sudo iptables -L DOCKER-USER -n -v

UFW dovrebbe mostrare solo le porte 22, 80 e 443. La chain DOCKER-USER dovrebbe scartare il traffico esterno.

10. Controllare i servizi esposti

ss -tulpn

Solo SSH (22), Nginx (80, 443) e OpenClaw (127.0.0.1:18789 per npm, o 0.0.0.0:18789 via docker-proxy per Docker) dovrebbero comparire.

Come si tiene aggiornato e si fa il backup di OpenClaw?

Nascondere la versione

Nascondi la versione di OpenClaw nelle risposte del gateway. La divulgazione della versione aiuta gli attaccanti a prendere di mira vulnerabilita note. In ~/.openclaw/openclaw.json:

{
  gateway: {
    exposeVersion: false
  }
}

Combinato con la direttiva server_tokens off; gia presente nella configurazione Nginx, questo impedisce il fingerprinting sia del reverse proxy che dell'applicazione.

Aggiornamenti

OpenClaw rilascia aggiornamenti frequentemente. Controlla la versione corrente:

openclaw --version

Per le installazioni Docker:

cd ~/openclaw-src && docker compose exec openclaw-gateway node dist/index.js --version

Per aggiornare un'installazione Docker:

cd ~/openclaw-src
git pull
docker compose pull
docker compose up -d openclaw-gateway

Per aggiornare un'installazione npm:

npm update -g openclaw

Dopo l'aggiornamento, riavvia il gateway e riesegui l'audit di sicurezza:

sudo systemctl restart openclaw-gateway

Per npm:

sudo -u openclaw openclaw security audit

Per Docker:

cd ~/openclaw-src && docker compose exec openclaw-gateway node dist/index.js security audit

Leggi le note di rilascio prima di aggiornare. I breaking change nel formato della configurazione accadono. La versione 2026.3.7 ha introdotto un campo gateway.auth.mode obbligatorio quando sono presenti sia token che password. Ometterlo dopo l'aggiornamento ti blocca fuori dal gateway.

Backup

Fai il backup della directory di configurazione:

sudo tar czf /root/openclaw-backup-$(date +%Y%m%d).tar.gz /home/openclaw/.openclaw

Conserva i backup fuori dal server. La directory di configurazione contiene i tuoi token di autenticazione, le configurazioni degli agenti e lo stato delle conversazioni. Proteggi i backup con la stessa cura della configurazione attiva: cifrali con gpg o conservali in un volume cifrato.

Gestione dei log

Visualizza i log in tempo reale:

journalctl -u openclaw-gateway -f

I log di OpenClaw potrebbero contenere frammenti di conversazione. Imposta la retention dei log per limitare l'esposizione:

sudo tee /etc/systemd/journald.conf.d/openclaw.conf > /dev/null << 'EOF'
[Journal]
MaxRetentionSec=7d
MaxFileSec=1d
EOF
sudo systemctl restart systemd-journald

Qualcosa non funziona?

Sintomo	Causa probabile	Soluzione
Il gateway non si avvia	Porta 18789 gia in uso	ss -tulpn | grep 18789 per trovare il processo in conflitto
Le connessioni WebSocket falliscono tramite Nginx	Header Upgrade e Connection mancanti	Controlla le direttive proxy_set_header nella configurazione Nginx
I container sandbox non si avviano	Permessi del socket Docker	Assicurati che l'utente openclaw sia nel gruppo docker e riesegui il login
openclaw security audit mostra warning	Drift della configurazione dopo l'aggiornamento	Esamina l'output dell'audit e applica le correzioni consigliate
Gateway accessibile dall'IP esterno	Bypass Docker/UFW	Aggiungi le regole iptables DOCKER-USER come descritto sopra
Errori del certificato TLS	Rinnovo Certbot fallito	Esegui sudo certbot renew --dry-run per diagnosticare
OOM kill sul VPS	MemoryMax mancante nella unit systemd	Aggiungi MemoryMax=4G alla sezione [Service]

---

Copyright 2026 Virtua.Cloud. Tutti i diritti riservati. Questo contenuto e un'opera originale del team Virtua.Cloud. La riproduzione, ripubblicazione o redistribuzione senza autorizzazione scritta e vietata.