Ihr eigener Passwort-Manager: Der komplette Guide zum Bitwarden / BitwardenRS Self-Hosting mit einem RaspberryPi

In einer Welt, in der Online-Sicherheit wichtiger denn je ist, stellt die Verwaltung unzähliger Passwörter eine tägliche Herausforderung dar. Passwort-Manager sind hier unverzichtbar, doch viele scheuen sich davor, ihre sensibelsten Daten einem externen Dienstleister anzuvertrauen. Die gute Nachricht: Sie können die Kontrolle vollständig zurückgewinnen! Dieser umfassende Guide zeigt Ihnen, wie Sie Ihren eigenen Passwort-Manager mit Bitwarden (genauer gesagt: Vaultwarden) auf einem Raspberry Pi selbst hosten. So bleiben Ihre Zugangsdaten sicher in Ihren Händen.

Warum Bitwarden/Vaultwarden selbst hosten?

Die Entscheidung für das Self-Hosting Ihres Passwort-Managers ist oft von dem Wunsch nach maximaler Kontrolle und Datenschutz getrieben. Während beliebte Cloud-Anbieter von Passwort-Managern hervorragende Dienste leisten, bedeutet die Übergabe Ihrer Daten an Dritte immer ein gewisses Maß an Vertrauen. Beim Self-Hosting liegen Ihre verschlüsselten Passwörter physisch auf Ihrem Gerät, in Ihrem Netzwerk – und niemand sonst hat Zugriff darauf, es sei denn, Sie erlauben es explizit.

• Datenschutz und Kontrolle: Ihre Daten verlassen niemals Ihr Heimnetzwerk, wenn Sie dies nicht wünschen. Sie entscheiden, wer auf Ihren Server zugreifen darf.
• Kostenersparnis: Während viele Cloud-Dienste kostenlose Basisversionen anbieten, kosten erweiterte Funktionen oft Geld. Eine Self-Hosted-Lösung ist nach der Erstinvestition in die Hardware (z.B. Raspberry Pi) dauerhaft kostenlos.
• Flexibilität: Sie können Ihren Server an Ihre spezifischen Bedürfnisse anpassen und haben volle Kontrolle über Updates und Konfigurationen.
• Lernkurve: Es ist eine hervorragende Gelegenheit, sich mit Linux, Docker und Netzwerkadministration vertraut zu machen.

Bevor wir tief eintauchen, ein wichtiger Hinweis: Die offizielle Bitwarden-Server-Implementierung ist ressourcenintensiv und für einen Raspberry Pi in der Regel überdimensioniert. Hier kommt Vaultwarden (früher bekannt als Bitwarden_RS) ins Spiel. Vaultwarden ist eine in Rust geschriebene, hochleistungsfähige und ressourcenschonende Alternative, die vollständig kompatibel mit den offiziellen Bitwarden-Clients ist. Es ist die perfekte Wahl für unser Vorhaben auf dem Raspberry Pi.

Was Sie benötigen: Voraussetzungen für Ihr Projekt

Bevor wir mit der Installation beginnen, stellen Sie sicher, dass Sie alle notwendigen Komponenten und Kenntnisse besitzen:

Hardware:

• Raspberry Pi: Empfohlen wird ein Raspberry Pi 4 mit mindestens 2 GB RAM (besser 4 GB oder 8 GB für zukünftige Erweiterungen) oder ein Raspberry Pi 5. Ältere Modelle wie der Pi 3B+ könnten funktionieren, sind aber weniger performant.
• microSD-Karte: Eine hochwertige Class 10 (oder höher) microSD-Karte mit mindestens 16 GB Speicher (32 GB oder 64 GB sind besser für Langlebigkeit und Datenintegrität).
• Netzteil: Das offizielle Raspberry Pi USB-C Netzteil ist ideal, da es ausreichend Strom liefert (mindestens 3A für Pi 4/5).
• Gehäuse: Optional, aber empfohlen, um den Pi vor Staub und Beschädigungen zu schützen und für passive Kühlung zu sorgen.
• Ethernet-Kabel: Für eine stabile Netzwerkverbindung, unbedingt gegenüber WLAN zu bevorzugen.

Software und Kenntnisse:

• Raspberry Pi OS Lite (64-bit): Die schlanke Version ohne Desktop-Umgebung ist ideal für Server-Anwendungen.
• Grundlegende Linux-Kenntnisse: Umgang mit der Kommandozeile (SSH, Dateisystemnavigation, grundlegende Befehle).
• SSH-Client: PuTTY für Windows oder das integrierte Terminal für macOS/Linux.
• Router-Zugriff: Um eine statische IP-Adresse einzurichten und Port-Weiterleitungen zu konfigurieren.
• Domainname (optional, aber dringend empfohlen): Für den Zugriff über HTTPS und Let’s Encrypt-Zertifikate. Ein kostenloser Dynamic DNS (DDNS) Dienst kann hier ebenfalls helfen.

Vorbereitung des Raspberry Pi

Der erste Schritt ist die Einrichtung Ihres Raspberry Pi.

1. Raspberry Pi OS Lite installieren: Laden Sie das Raspberry Pi Imager-Tool herunter. Wählen Sie „Raspberry Pi OS (64-bit) Lite”, Ihre microSD-Karte und klicken Sie auf „Schreiben”. Konfigurieren Sie im Imager unter „Erweiterte Optionen” (Zahnrad-Symbol) direkt SSH (Passwort-Authentifizierung oder SSH-Key), einen Hostnamen, WLAN (falls benötigt, aber LAN bevorzugt) und das Standard-Passwort.
2. Erster Start und Update: Stecken Sie die microSD-Karte in den Pi, verbinden Sie ihn mit dem Netzwerk und dem Strom. Nach dem Booten können Sie sich per SSH anmelden: ssh benutzername@ip-adresse-des-pi (Standard-Benutzername ist „pi”, falls nicht geändert). Führen Sie die folgenden Befehle aus, um Ihr System zu aktualisieren:

   sudo apt update && sudo apt upgrade -y

3. Statische IP-Adresse einrichten: Es ist unerlässlich, dass Ihr Pi eine statische IP-Adresse in Ihrem lokalen Netzwerk erhält, damit Port-Weiterleitungen und DNS-Einstellungen zuverlässig funktionieren. Dies können Sie entweder direkt in Ihrem Router (bevorzugt, da einfacher und zentraler) oder auf dem Pi selbst konfigurieren (z.B. in /etc/dhcpcd.conf). Konsultieren Sie hierzu die Dokumentation Ihres Routers oder die Raspberry Pi-Dokumentation.

Installation von Docker und Docker Compose

Vaultwarden wird als Docker-Container ausgeführt. Docker ist eine Plattform zum Bereitstellen, Ausführen und Verwalten von Anwendungen in isolierten Umgebungen, sogenannten Containern. Docker Compose ermöglicht es, Multi-Container-Docker-Anwendungen einfach zu definieren und auszuführen.

Installieren Sie Docker mit dem offiziellen Skript:

curl -sSL https://get.docker.com | sh

Fügen Sie Ihren Benutzer zur Docker-Gruppe hinzu, um Docker-Befehle ohne sudo ausführen zu können (Sie müssen sich danach neu anmelden oder den Pi neu starten):

sudo usermod -aG docker $USER

Installieren Sie Docker Compose (die Installation über apt ist für Raspberry Pi OS in der Regel ausreichend und einfacher):

sudo apt install docker-compose -y

Überprüfen Sie die Installation:

docker --version
docker-compose --version

Vaultwarden mit Docker Compose einrichten

Nun richten wir den Vaultwarden-Container ein.

1. Verzeichnis für Vaultwarden erstellen: Erstellen Sie einen dedizierten Ordner, in dem alle Konfigurationsdateien und persistenten Daten von Vaultwarden gespeichert werden.

   mkdir ~/vaultwarden && cd ~/vaultwarden

2. docker-compose.yml erstellen: Erstellen Sie eine Datei namens docker-compose.yml in diesem Verzeichnis. Sie können einen Texteditor wie nano verwenden:

   nano docker-compose.yml

   Fügen Sie den folgenden Inhalt ein:

   version: '3'
   
   services:
     vaultwarden:
       image: vaultwarden/server:latest
       container_name: vaultwarden
       restart: always
       ports:
         - "80:80"   # HTTP für Let's Encrypt Challenge (wird später von Nginx übernommen)
         - "3012:3012" # WebSocket für Synchronisierung
       volumes:
         - ./data:/data
       environment:
         # Hier können Sie Vaultwarden-spezifische Umgebungsvariablen definieren
         # Z.B. für SMTP-E-Mail-Einrichtung (optional, aber empfohlen für 2FA/Registrierung)
         # SIGNUPS_ALLOWED: "false" # Setzen Sie dies auf "false", nachdem Sie sich registriert haben!
         # ADMIN_TOKEN: "Ihr_sicherer_Admin_Token" # Generieren Sie einen starken Token
         # WEBSOCKET_ENABLED: "true" # Standardmäßig aktiviert, aber explizit
         # Mehr Optionen finden Sie unter https://github.com/dani-garcia/vaultwarden/wiki/Configuration-overview
         TZ: "Europe/Berlin" # Passen Sie Ihre Zeitzone an
   

   Wichtige Hinweise zur Konfiguration:

   • ports: Wir binden Port 80 des Containers an Port 80 des Hosts und Port 3012 (WebSocket) an Port 3012 des Hosts. Letzterer ist für die Echtzeit-Synchronisation wichtig.
   • volumes: Dies ist entscheidend! ./data:/data bedeutet, dass der Ordner data in Ihrem ~/vaultwarden-Verzeichnis (auf dem Host) die persistenten Daten des Containers speichert. Wenn der Container neu erstellt wird, bleiben Ihre Passwörter erhalten.
   • environment: Hier können Sie Vaultwarden anpassen.
     • SIGNUPS_ALLOWED: "false": Ganz wichtig! Setzen Sie dies auf „false”, sobald Sie Ihr erstes Benutzerkonto registriert haben. Andernfalls könnte jeder, der Ihre Vaultwarden-Instanz findet, ein Konto erstellen.
     • ADMIN_TOKEN: "Ihr_sicherer_Admin_Token": Generieren Sie einen sehr starken, einzigartigen Token. Dieser ermöglicht den Zugriff auf die Admin-Oberfläche von Vaultwarden unter IhreDomain.de/admin (falls aktiviert und freigeschaltet).

   Speichern Sie die Datei mit Strg+X, dann Y und Enter.

3. Vaultwarden starten: Starten Sie den Container mit Docker Compose:

   docker-compose up -d

   Der Parameter -d bedeutet „detached”, d.h., der Container läuft im Hintergrund.

4. Überprüfen der Installation: Überprüfen Sie, ob der Container läuft:

   docker ps

   Sie sollten einen Eintrag für vaultwarden sehen.

Reverse Proxy mit Nginx und Let’s Encrypt (Sicherheit geht vor!)

Der direkte Zugriff auf Vaultwarden über die IP-Adresse und HTTP ist unsicher und unpraktisch. Wir benötigen einen Reverse Proxy (Nginx) und HTTPS-Verschlüsselung (Let’s Encrypt). Der Reverse Proxy leitet Anfragen von Ihrer Domain an den Docker-Container weiter und kümmert sich um die SSL-Verschlüsselung.

1. Domain und Port-Weiterleitung vorbereiten

• Stellen Sie sicher, dass Ihr Domainname auf die öffentliche IP-Adresse Ihres Routers zeigt (A-Record). Wenn Sie keine feste öffentliche IP haben, verwenden Sie einen DDNS-Dienst (z.B. No-IP, DuckDNS).
• Richten Sie in Ihrem Router Port-Weiterleitungen (Port Forwarding) ein:
  • Eingehende Anfragen auf Port 80 (HTTP) an die statische IP Ihres Raspberry Pi auf Port 80 weiterleiten.
  • Eingehende Anfragen auf Port 443 (HTTPS) an die statische IP Ihres Raspberry Pi auf Port 443 weiterleiten.

  Deaktivieren Sie unbedingt die Router-interne Verwaltung über Port 80/443, falls diese aktiviert ist, da sie sonst mit Nginx kollidieren würde.

2. Nginx installieren

sudo apt install nginx -y

Standard-Konfigurationsdateien entfernen:

sudo rm /etc/nginx/sites-enabled/default

3. Nginx für Vaultwarden konfigurieren

Erstellen Sie eine neue Nginx-Konfigurationsdatei für Ihre Domain:

sudo nano /etc/nginx/sites-available/vaultwarden.conf

Fügen Sie folgenden Inhalt ein (ersetzen Sie yourdomain.de durch Ihre tatsächliche Domain):

server {
    listen 80;
    listen [::]:80;
    server_name yourdomain.de www.yourdomain.de;

    location / {
        proxy_pass http://127.0.0.1:80; # Leitet an den Vaultwarden Docker-Container weiter
        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;
    }

    location /notifications/hub {
        proxy_pass http://127.0.0.1:3012; # WebSocket für Benachrichtigungen
        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;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }

    location /notifications/hub/negotiate {
        proxy_pass http://127.0.0.1:80; # Negotiation für WebSocket
        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;
    }
}

Speichern und schließen Sie die Datei. Aktivieren Sie die Konfiguration und testen Sie Nginx:

sudo ln -s /etc/nginx/sites-available/vaultwarden.conf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

4. Let’s Encrypt SSL-Zertifikate mit Certbot

Installieren Sie Certbot, das Tool zur Automatisierung von Let’s Encrypt:

sudo snap install core
sudo snap refresh core
sudo snap install --classic certbot
sudo ln -s /snap/bin/certbot /usr/bin/certbot

Fordern Sie das SSL-Zertifikat an (ersetzen Sie yourdomain.de):

sudo certbot --nginx -d yourdomain.de -d www.yourdomain.de

Folgen Sie den Anweisungen von Certbot (E-Mail, Zustimmungen). Certbot modifiziert Ihre Nginx-Konfiguration automatisch, um HTTPS zu aktivieren und HTTP-Anfragen auf HTTPS umzuleiten. Es richtet auch die automatische Verlängerung der Zertifikate ein.

Testen Sie die automatische Verlängerung:

sudo certbot renew --dry-run

Wenn dies fehlerfrei durchläuft, sind Ihre Zertifikate sicher und werden automatisch verlängert.

Zugriff auf Ihre Vaultwarden-Instanz

Sobald alles eingerichtet ist, können Sie Ihren persönlichen Passwort-Manager nutzen:

• Web-Tresor: Öffnen Sie Ihren Browser und navigieren Sie zu https://yourdomain.de. Sie sollten die Bitwarden-Login-Seite sehen.
• Benutzerkonto erstellen: Erstellen Sie ein neues Konto mit einer sehr starken Master-Passphrase. Denken Sie daran, SIGNUPS_ALLOWED in Ihrer docker-compose.yml auf „false” zu setzen, sobald Sie sich registriert haben, um weitere Registrierungen zu verhindern. Führen Sie danach docker-compose down && docker-compose up -d aus, damit die Änderung wirksam wird.
• Client-Anwendungen: Laden Sie die offiziellen Bitwarden-Clients für Desktop, Mobile oder Browser-Erweiterungen herunter. Wählen Sie beim Anmeldebildschirm „Self-Hosted” oder „Eigene Server-URL” und geben Sie https://yourdomain.de als Ihre Server-URL ein.

Wichtige Sicherheitsaspekte

Ein selbst gehosteter Server erfordert eigenverantwortliche Sicherheit. Beachten Sie folgende Punkte:

• Starke Master-Passphrase: Das ist der Schlüssel zu allem. Verwenden Sie eine lange, komplexe Passphrase, die Sie sich merken können, aber die nicht erraten werden kann.
• Regelmäßige Backups: Sichern Sie regelmäßig den Inhalt Ihres ~/vaultwarden/data-Ordners. Dies kann manuell oder über ein Skript erfolgen. Ein einfaches sudo cp -r ~/vaultwarden/data /mnt/backup_laufwerk/vaultwarden_backup_$(date +%F) auf ein externes Laufwerk oder einen Netzwerkspeicher ist ein guter Anfang.
• Software-Updates: Halten Sie Ihr Raspberry Pi OS, Docker und den Vaultwarden-Container stets aktuell.
  • Pi OS: sudo apt update && sudo apt upgrade -y
  • Vaultwarden: cd ~/vaultwarden && docker-compose pull && docker-compose up -d
• Firewall (UFW): Konfigurieren Sie eine Firewall auf Ihrem Raspberry Pi, um nur notwendige Ports (SSH 22, HTTP 80, HTTPS 443) zu öffnen.

  sudo apt install ufw -y
  sudo ufw default deny incoming
  sudo ufw default allow outgoing
  sudo ufw allow ssh
  sudo ufw allow http
  sudo ufw allow https
  sudo ufw enable

  Überprüfen Sie mit sudo ufw status verbose.

• SSH-Sicherheit: Deaktivieren Sie die passwortbasierte SSH-Authentifizierung und verwenden Sie stattdessen SSH-Schlüssel. Erwägen Sie die Installation von Fail2Ban, um Brute-Force-Angriffe auf SSH (und Nginx) zu erkennen und zu blockieren.
• Admin-Interface absichern: Wenn Sie das Admin-Interface nutzen, stellen Sie sicher, dass Ihr ADMIN_TOKEN sehr stark ist und überlegen Sie, den Zugriff darauf nur von bestimmten IP-Adressen zu erlauben.

Wartung und Updates

Ihr Vaultwarden-Server erfordert regelmäßige Wartung, um sicher und stabil zu bleiben:

• System-Updates: Führen Sie monatlich oder alle paar Wochen sudo apt update && sudo apt upgrade -y aus, um das Betriebssystem auf dem neuesten Stand zu halten.
• Vaultwarden-Container aktualisieren: Wechseln Sie in Ihr ~/vaultwarden-Verzeichnis und führen Sie aus:

  docker-compose pull
  docker-compose up -d

  Dies lädt die neueste Version des Vaultwarden-Images herunter und startet den Container neu.

Fazit: Ihr Schlüssel zur digitalen Souveränität

Das Self-Hosting von Vaultwarden auf einem Raspberry Pi mag anfangs komplex erscheinen, doch die Belohnung ist groß: Sie erhalten einen voll funktionsfähigen, sicheren und datenschutzfreundlichen Passwort-Manager, der vollständig unter Ihrer Kontrolle steht. Keine Drittanbieter, keine Abo-Gebühren und die Gewissheit, dass Ihre sensibelsten Daten dort bleiben, wo sie hingehören – bei Ihnen. Dieser Guide hat Ihnen die nötigen Schritte und das Wissen vermittelt, um diese digitale Festung erfolgreich zu errichten. Nutzen Sie diese Macht verantwortungsvoll und genießen Sie Ihre neu gewonnene digitale Souveränität!