In questo articolo andrò a descrivere come auto-ospitare Bitwarden sul nostro Raspberry Pi utilizzando Docker.
Bitwarden è un gestore di password gratuito e open-source, che ci permette di mantenere il pieno controllo su dove e come vengono archiviate le nostre password. È ampiamente considerato la migliore soluzione gratuita per chi vuole un password manager sicuro.
Il Raspberry Pi è una piattaforma perfetta per ospitare Bitwarden: consuma pochissimo, quindi tenerlo acceso 24 ore su 24 costa poco, e tutti i client Bitwarden (desktop, smartphone ed estensioni per browser) si collegheranno a questo server per sincronizzare le password.
Poiché il Raspberry Pi non ha una grande potenza di calcolo, utilizzeremo Vaultwarden (ex Bitwarden_RS), una re-implementazione non ufficiale delle API del server Bitwarden scritta in Rust, molto più leggera dell’originale e perfetta per girare su un Raspberry Pi. Vaultwarden è compatibile con tutti i client ufficiali di Bitwarden.
Prerequisiti
- un Raspberry Pi (consiglio un Raspberry Pi 3 o superiore) con Raspberry Pi OS;
- Docker e Docker Compose installati (qui la guida su come installarli);
- facoltativo: Portainer, per gestire i container tramite interfaccia web;
- facoltativo, ma consigliato se volete usare Bitwarden anche fuori casa: un nome a dominio (o un DDNS, qui una guida su come configurare DuckDNS).
Importante: l’interfaccia web e i client di Bitwarden funzionano solo tramite una connessione HTTPS. Per questo motivo, oltre al container, in questa guida configureremo anche un reverse proxy con un certificato SSL.
Prima di cominciare aggiorniamo il sistema operativo con i due comandi seguenti:
$ sudo apt update $ sudo apt upgrade -y
Installazione di Bitwarden su Raspberry Pi
Essendo disponibile come immagine Docker, l’installazione di Bitwarden è molto semplice: qui di seguito vedremo come farlo sia con Portainer che da riga di comando con Docker Compose. Scegliete il metodo che preferite.
Metodo 1: installazione tramite Portainer
Apriamo l’interfaccia web di Portainer, raggiungibile all’indirizzo IP del Raspberry Pi sulla porta 9000:
http://IP_RASPBERRY:9000
sostituendo IP_RASPBERRY con l’IP del nostro Raspberry Pi, e selezioniamo l’ambiente Docker locale.
Prima di creare il container creiamo un volume dedicato, dove verranno salvati tutti i dati di Bitwarden: nella barra laterale clicchiamo su “Volumes” e poi sul pulsante “Add volume“. Diamo al volume un nome, ad esempio “bitwarden“, e clicchiamo su “Create the volume“.
Creato il volume, passiamo al menù “Containers” nella barra laterale e clicchiamo sul pulsante “Add container” in alto.
Diamo un nome al container, ad esempio “bitwarden“, e come immagine da scaricare da Docker Hub inseriamo:
vaultwarden/server:latest
Scendiamo fino a “Network ports configuration” e clicchiamo su “Map additional port” per aggiungere la porta da esporre:
- nel campo “Host” inseriamo
127.0.0.1:8080e nel campo “Container”80: è la porta su cui sarà raggiungibile l’interfaccia web di Bitwarden (dalle versioni recenti di Vaultwarden viene usata anche per le notifiche in tempo reale tramite websocket, quindi non serve più esporre la vecchia porta 3012).
La porta resta legata al solo localhost (127.0.0.1): non ci serve esporla direttamente, perché sarà il reverse proxy che configureremo più avanti a renderla accessibile in HTTPS.
Scorriamo fino a “Advanced container settings“, apriamo la scheda “Volumes” e clicchiamo su “map additional volume“. Impostiamo /data come percorso nel container e come volume selezioniamo quello creato in precedenza (“bitwarden“).
Nella scheda “Env” clicchiamo su “add environment variable” e aggiungiamo la variabile DOMAIN con l’indirizzo completo con cui raggiungeremo Bitwarden, ad esempio https://bitwarden.tuodominio.com (oppure https://IP_RASPBERRY se lo userete solo in rete locale). Questo valore viene utilizzato da Bitwarden per generare correttamente i link, ad esempio nelle email di invito.
Infine, per far sì che Bitwarden resti sempre online, apriamo la scheda “Restart policy” e selezioniamo “Unless stopped“: in questo modo Docker riavvierà il container in caso di problemi e ad ogni riavvio del Raspberry Pi.
A questo punto possiamo distribuire il container cliccando sul pulsante “Deploy the container” in fondo alla pagina. Terminato lo scaricamento dell’immagine, il container Bitwarden comparirà nell’elenco dei container.
Metodo 2: installazione tramite Docker Compose
Se preferiamo non usare Portainer, possiamo installare Bitwarden da riga di comando con Docker Compose. Colleghiamoci in SSH al Raspberry Pi e creiamo una cartella che conterrà il file di configurazione e i dati del container:
$ mkdir ~/vaultwarden $ cd ~/vaultwarden $ nano docker-compose.yml
e incolliamo quanto segue:
services:
vaultwarden:
image: vaultwarden/server:latest
container_name: bitwarden
restart: unless-stopped
environment:
- DOMAIN=https://bitwarden.tuodominio.com
volumes:
- ./vw-data:/data
ports:
- 127.0.0.1:8080:80
sostituendo bitwarden.tuodominio.com con il vostro nome a dominio (oppure con l’IP del Raspberry Pi). Salviamo il file premendo CTRL+X, poi Y o S (a seconda della lingua impostata) ed infine INVIO.
Ora non ci resta che avviare il container con il comando:
$ docker compose up -d
Come nella versione con Portainer, la porta 8080 resta legata a 127.0.0.1: sarà il reverse proxy, configurato nella prossima sezione, a rendere Bitwarden raggiungibile in HTTPS. Tutti i dati di Bitwarden verranno salvati nella cartella ~/vaultwarden/vw-data.
Impostazione di un reverse proxy per Bitwarden
Come anticipato, Bitwarden richiede una connessione HTTPS. Se utilizzate già NGINX Proxy Manager, vi basterà creare un nuovo Proxy Host che punti al Raspberry Pi sulla porta 8080, attivando l’opzione “Websockets Support” e richiedendo un certificato Let’s Encrypt dalla scheda SSL (in questo caso, nel container, pubblicate la porta come 8080:80 invece di 127.0.0.1:8080:80, così che NGINX Proxy Manager possa raggiungerla). Potete quindi saltare direttamente alla sezione “Accesso all’interfaccia web di Bitwarden“.
In alternativa, qui di seguito vediamo come configurare manualmente NGINX come reverse proxy direttamente sul Raspberry Pi. Se non è già installato, installiamolo con:
$ sudo apt install nginx -y
Non serve installare anche PHP, dato che useremo NGINX solo come reverse proxy verso il container Bitwarden.
Il certificato SSL
Per la connessione HTTPS ci serve un certificato SSL. Ci sono due strade:
- se avete un nome a dominio, potete usare Let’s Encrypt per generare un certificato firmato gratuito (non è possibile generarne uno firmato usando solo un indirizzo IP): in questo caso prendete nota della cartella dove viene salvato il certificato e passate direttamente alla configurazione di NGINX;
- in alternativa possiamo generare un certificato autofirmato: la connessione resta cifrata, ma il browser mostrerà un avviso perché il certificato non è firmato da un’autorità di certificazione riconosciuta.
Nota: le app di Bitwarden per smartphone di solito non accettano certificati autofirmati. Se volete utilizzare Bitwarden anche da smartphone, consiglio vivamente di utilizzare un nome a dominio con un certificato Let’s Encrypt.
Per generare un certificato autofirmato eseguiamo:
$ sudo openssl req -x509 -nodes -days 365 -newkey rsa:4096 -keyout /etc/ssl/private/nginx-bitwarden.key -out /etc/ssl/certs/nginx-bitwarden.crt
Il certificato avrà una validità di 365 giorni e verrà salvato nelle cartelle /etc/ssl/private/ e /etc/ssl/certs/. Durante la generazione, OpenSSL chiederà alcuni dettagli da inserire nel certificato:
Country Name (2 letter code) [AU]: IT State or Province Name (full name) [Some-State]: Italy Locality Name (eg, city) []: Rome Organization Name (eg, company) [Internet Widgits Pty Ltd]: TuaAzienda Organizational Unit Name (eg, section) []: Common Name (e.g. server FQDN or YOUR name) []: IP_RASPBERRY Email Address []: tuaemail@tuodominio.com
Come ultimo passaggio, creiamo un gruppo Diffie-Hellman robusto per rendere più sicure le connessioni SSL (l’operazione può richiedere qualche minuto):
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
Configurazione di NGINX come proxy
Per prima cosa rimuoviamo il sito di default di NGINX (questo passaggio non serve se sul Raspberry Pi state già utilizzando NGINX per altri siti):
$ sudo rm /etc/nginx/sites-enabled/default
Creiamo un nuovo file di configurazione con l’editor nano:
$ sudo nano /etc/nginx/sites-available/bitwarden.conf
e incolliamo quanto segue:
map $http_upgrade $connection_upgrade {
default upgrade;
'' "";
}
server {
listen 80;
listen [::]:80;
server_name _; #Sostituire con il proprio nome a dominio
return 301 https://$host$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name _; #Sostituire con il proprio nome a dominio
ssl_certificate /etc/ssl/certs/nginx-bitwarden.crt; #Sostituire con il percorso Let's Encrypt se si usa un certificato firmato
ssl_certificate_key /etc/ssl/private/nginx-bitwarden.key; #Sostituire con il percorso Let's Encrypt se si usa un certificato firmato
ssl_dhparam /etc/ssl/certs/dhparam.pem;
# Consente allegati di grandi dimensioni
client_max_body_size 128M;
location / {
proxy_pass http://127.0.0.1:8080;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection $connection_upgrade;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
Il primo blocco (map) serve a gestire correttamente le connessioni websocket, il secondo reindirizza il traffico da HTTP (porta 80) a HTTPS (porta 443) e il terzo gestisce il proxy vero e proprio. Se usiamo un nome a dominio, sostituiamo server_name _; con il nostro dominio, ad esempio server_name bitwarden.tuodominio.com;, in entrambi i blocchi server.
Salviamo il file con CTRL+X, poi Y e INVIO, attiviamo la configurazione creando un collegamento nella cartella sites-enabled e verifichiamo che non ci siano errori:
$ sudo ln -s /etc/nginx/sites-available/bitwarden.conf /etc/nginx/sites-enabled/ $ sudo nginx -t
Se il comando nginx -t restituisce “syntax is ok” e “test is successful“, riavviamo NGINX perché le modifiche abbiano effetto:
$ sudo systemctl restart nginx
Accesso all’interfaccia web di Bitwarden
Configurato il proxy, possiamo accedere all’interfaccia web di Bitwarden dal nostro browser all’indirizzo:
https://IP_RASPBERRY
sostituendo IP_RASPBERRY con l’IP del Raspberry Pi, oppure con il nome a dominio se ne avete configurato uno. Se abbiamo usato un certificato autofirmato il browser mostrerà un avviso di sicurezza: possiamo procedere tranquillamente, sapendo di aver generato noi stessi il certificato.
Clicchiamo su “Crea account” e compiliamo il modulo: l’indirizzo email che useremo per accedere e il nome da mostrare nell’interfaccia, poi clicchiamo su “Continua“. Nella schermata successiva scegliamo una master password robusta e confermiamo la creazione dell’account. Attenzione: la master password non può essere recuperata in alcun modo, se la dimenticate perderete l’accesso a tutte le password salvate.
Creato l’account, possiamo effettuare il login inserendo email e master password: da qui in poi possiamo iniziare a salvare le nostre password nel nuovo caveau Bitwarden.
Collegare i client Bitwarden al nostro server
Per utilizzare il nostro server con le app ufficiali di Bitwarden (desktop, smartphone ed estensioni per browser), nella schermata di accesso dell’app dobbiamo selezionare, nel menù “Accesso a“, la voce “Self-hosted” (o “self-hosted“) e inserire l’indirizzo del nostro server, ad esempio:
https://bitwarden.tuodominio.com
Dopo aver salvato, potremo accedere con l’email e la master password dell’account creato in precedenza.
Abilitazione del pannello amministrativo di Bitwarden
Vaultwarden mette a disposizione un pannello di amministrazione, da cui è possibile vedere ed eliminare gli utenti registrati, generare inviti e configurare le varie opzioni del servizio, come la possibilità o meno per nuovi utenti di registrarsi. Per motivi di sicurezza il pannello è disattivato finché non impostiamo un token di amministrazione.
Generare il token amministratore
Il metodo consigliato è salvare nella configurazione solo una versione cifrata (hash Argon2) del token, invece del token in chiaro. Vaultwarden include un generatore apposito: eseguiamo il seguente comando (dove bitwarden è il nome del nostro container):
$ docker exec -it bitwarden /vaultwarden hash
Ci verrà chiesto di inserire due volte una password: sarà la password con cui accederemo al pannello di amministrazione, per cui sceglietene una robusta e annotatela in un posto sicuro. Il comando restituirà una stringa simile alla seguente:
ADMIN_TOKEN='$argon2id$v=19$m=65540,t=3,p=4$MmeKRnGK5RW5...'
Copiamo il valore tra gli apici (quello che inizia con $argon2id$): è il valore da assegnare alla variabile ADMIN_TOKEN.
Impostazione del token amministratore con Portainer
Apriamo Portainer, andiamo nell’elenco dei container, clicchiamo sul container Bitwarden per aprirne la pagina di dettaglio e poi su “Duplicate/Edit“.
Scorriamo fino a “Advanced container settings“, apriamo la scheda “Env” e clicchiamo su “add environment variable“. Nel campo “name” digitiamo ADMIN_TOKEN e nel campo “value” incolliamo il valore generato al passaggio precedente (senza apici).
Clicchiamo su “Deploy the container“: Portainer avviserà che sostituirà il container esistente, dato che il nome coincide. Confermiamo cliccando su “Replace“. I dati non andranno persi, perché sono salvati nel volume “bitwarden“.
Impostazione del token amministratore con Docker Compose
Se abbiamo utilizzato Docker Compose, apriamo nuovamente il file di configurazione:
$ cd ~/vaultwarden $ nano docker-compose.yml
e aggiungiamo la variabile ADMIN_TOKEN nella sezione environment. Attenzione: nel file docker-compose.yml ogni simbolo $ del token va raddoppiato ($$), altrimenti Docker Compose lo interpreterà come una variabile:
environment:
- DOMAIN=https://bitwarden.tuodominio.com
- ADMIN_TOKEN=$$argon2id$$v=19$$m=65540,t=3,p=4$$MmeKRnGK5RW5...
Salviamo il file e ricreiamo il container con il comando:
$ docker compose up -d
Docker Compose si accorgerà della modifica e ricreerà automaticamente il container, mantenendo i dati salvati nella cartella vw-data.
Accesso al pannello di amministrazione di Bitwarden
Impostato il token, possiamo raggiungere la pagina di amministrazione dal browser all’indirizzo:
https://IP_RASPBERRY/admin
Inseriamo la password scelta durante la generazione del token e clicchiamo su “Enter“: da qui possiamo gestire gli utenti e configurare le impostazioni di Bitwarden.
Disabilitare la creazione di nuovi utenti
Creato il nostro account e impostato l’accesso al pannello di amministrazione, consiglio di disabilitare le nuove registrazioni, così che solo chi viene invitato personalmente potrà creare un account sul nostro server. Questo è particolarmente importante se il server è raggiungibile da internet.
Dal pannello di amministrazione apriamo “General settings“, cerchiamo l’opzione “Allow new signups” e disattiviamo la casella di controllo accanto ad essa. Scorriamo fino in fondo alla pagina e clicchiamo sul pulsante “Save” per confermare.
In alternativa, possiamo ottenere lo stesso risultato aggiungendo la variabile SIGNUPS_ALLOWED=false alla configurazione del container (con Portainer o nel file docker-compose.yml).
Backup dei dati
Trattandosi delle nostre password, il backup è fondamentale. Tutti i dati di Bitwarden (database, allegati e chiavi) si trovano nel volume del container: la cartella ~/vaultwarden/vw-data se avete usato Docker Compose, oppure il volume “bitwarden” se avete usato Portainer.
Il modo più semplice per eseguire un backup consistente è fermare per un istante il container, archiviare la cartella dei dati e riavviarlo. Ad esempio, con Docker Compose:
$ cd ~/vaultwarden $ docker compose stop $ tar -czf ~/bitwarden-backup-$(date +%Y_%m_%d).tar.gz vw-data $ docker compose start
Consiglio di automatizzare questi comandi con uno script pianificato in crontab e di salvare l’archivio su un altro dispositivo, ad esempio su un NAS (qui una guida su come collegare una condivisione NFS al Raspberry Pi).
Aggiornare Bitwarden
Per aggiornare Vaultwarden all’ultima versione, con Docker Compose basta eseguire:
$ cd ~/vaultwarden $ docker compose pull $ docker compose up -d
mentre con Portainer è sufficiente aprire il container, cliccare su “Recreate” e attivare l’opzione “Re-pull image“. In entrambi i casi i dati restano al sicuro nel volume.
Conclusione
A questo punto Bitwarden dovrebbe essere attivo e funzionante sul nostro Raspberry Pi, pronto per essere collegato ai client ufficiali su desktop, smartphone e browser.
Se avete problemi con l’esecuzione del server, lasciate pure un commento qui sotto.
Buon divertimento!
