Vaultwarden: Die Open-Source Alternative zu Passwortmanager Bitwarden

Vaultwarden ist eine leichtgewichtige, in Rust entwickelte Server-Implementation der Bitwarden Client API.

Einführung: Was ist Vaultwarden?

Diese Open-Source-Alternative wurde speziell für Self-Hosting-Szenarien entwickelt, in denen die offiziellen Bitwarden-Server zu ressourcenintensiv wären. Früher unter dem Namen „bitwarden_rs“ bekannt, bietet Vaultwarden eine nahezu vollständige Kompatibilität mit allen offiziellen Bitwarden-Clients.

Das Besondere an Vaultwarden ist, dass es komplett kostenlos ist, erheblich weniger Systemressourcen benötigt als der offizielle Bitwarden-Server und trotzdem alle wichtigen Features unterstützt. Es ist die perfekte Lösung für tech-affine Privatpersonen, Familien und kleine Unternehmen, die ihre Passwörter vollständig unter eigener Kontrolle behalten möchten.

Alternative Installationsmethoden

Neben der in diesem Artikel detailliert beschriebenen Docker-Installation existieren verschiedene andere Installationsmöglichkeiten für Vaultwarden:

Pre-built Binaries: Vorgefertigte Binärdateien für verschiedene Betriebssysteme
Systemd Service: Direkter Systemservice ohne Container
Third-party Packages: Community-Pakete für verschiedene Distributionen (AUR, Homebrew, etc.)
Source Code Build: Manuelle Kompilierung aus dem Rust-Quellcode
Container-Alternativen: Podman als Docker-Alternative
Cloud-Deployments: Kubernetes, Docker Swarm oder Cloud-spezifische Lösungen

In diesem Artikel konzentrieren wir uns auf die Docker-basierte Installation, da diese am einfachsten zu implementieren und plattformübergreifend verfügbar ist. Für andere Installationsmethoden findet Ihr detaillierte Anleitungen in der offiziellen Vaultwarden-Wiki.

Vorzüge von Vaultwarden

Technische Vorteile

Geringer Ressourcenverbrauch: Deutlich weniger RAM und CPU-Verbrauch als der offizielle Bitwarden-Server
Vollständige Kompatibilität: Funktioniert mit allen offiziellen Bitwarden-Clients (Browser-Extensions, Mobile Apps, Desktop-Anwendungen)
Aktive Entwicklung: Regelmäßige Updates und starke Community-Unterstützung
Rust-basiert: Hohe Performance und Speichersicherheit
Docker-ready: Einfache Containerisierung und Deployment

Funktionsumfang

Personal Vault (Persönlicher Tresor)
Send (Sicherer Dateiaustausch)
Dateianhänge
Website-Icons
Personal API Key
Organisationen
Zwei-Faktor-Authentifizierung
Emergency Access (Notfallzugriff)
Admin-Backend

Datenschutz und Sicherheit

Vollständige Datenkontrolle: Alle Daten bleiben auf Ihren eigenen Servern
Keine Abhängigkeit von Drittanbietern: Kein Risiko von Service-Ausfällen oder Datenlecks bei externen Anbietern
Open Source: Transparenter Code, der von der Community überprüft werden kann
Compliance-freundlich: Ideal für Unternehmen mit strengen Datenschutzanforderungen

Nachteile von Vaultwarden

Technische Herausforderungen

Self-Hosting erforderlich: Benötigt etwas technisches Know-how für Installation und Wartung
Eigene Verantwortung: Backups, Updates und Sicherheit müssen selbst verwaltet werden
Kein offizieller Support: Support nur durch Community, nicht durch Bitwarden Inc.
HTTPS-Erfordernis: Web-Interface funktioniert nur über HTTPS oder localhost

Wartungsaufwand

Regelmäßige Updates: Müssen manuell durchgeführt werden
Backup-Management: Eigene Backup-Strategie erforderlich
Monitoring: Server-Überwachung liegt in eigener Verantwortung

Detaillierte Installationsanleitungen

1. Installation auf Linux (Ubuntu/Debian)

Voraussetzungen

Diese Schritte installieren alle benötigten Docker-Komponenten für Vaultwarden auf einem Ubuntu/Debian-System, auf Bestandssystemen mit bereits laufendem Docker kann dieser Schritt übersprungen werden:

# System aktualisieren - Stellt sicher, dass alle Pakete auf dem neuesten Stand sind
sudo apt update && sudo apt upgrade -y

# Docker installieren - Die Container-Plattform, die Vaultwarden ausführt
sudo apt install -y docker.io docker-compose

# Docker-Service starten und aktivieren - Sorgt dafür, dass Docker beim Systemstart automatisch startet
sudo systemctl start docker
sudo systemctl enable docker

# Benutzer zur Docker-Gruppe hinzufügen - Ermöglicht die Ausführung von Docker-Befehlen ohne sudo
# WICHTIG: Nach diesem Befehl müssen Sie sich ab- und wieder anmelden!
sudo usermod -aG docker $USER

Schritt-für-Schritt Installation

Schritt 1: Verzeichnisstruktur erstellen Hier erstellen wir die Ordnerstruktur für Vaultwarden und seine Daten:

# Arbeitsverzeichnis erstellen - Hier werden alle Konfigurationsdateien gespeichert
mkdir -p /opt/vaultwarden


# Datenverzeichnis erstellen - Hier speichert Vaultwarden die Datenbank und Dateien
# WICHTIG: Dieses Verzeichnis muss regelmäßig gesichert werden!
mkdir -p ./vw-data

Schritt 2: Docker Compose Datei erstellen Die Docker Compose Datei definiert, wie Vaultwarden ausgeführt wird:

nano docker-compose.yml

Füge folgenden Inhalt ein und passe die mit #ZWINGEND ÄNDERN markierten Werte an deine Umgebung an:

version: '3.8'
services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    environment:
      # ZWINGEND ÄNDERN: Ersetzen Sie durch Ihre eigene Domain oder IP-Adresse
      DOMAIN: "https://ihr-domain.de"
      # ZWINGEND ÄNDERN: Erstellen Sie ein sicheres Admin-Token (min. 32 Zeichen)
      # Generieren Sie es z.B. mit: openssl rand -hex 32ls
      ADMIN_TOKEN: "IhrSicheresAdminToken123"
      # WebSocket für Live-Synchronisation aktivieren
      WEBSOCKET_ENABLED: "true"
      # SICHERHEIT: Nach der Ersteinrichtung auf "false" setzen!
      SIGNUPS_ALLOWED: "true"
    volumes:
      # Persistente Datenspeicherung - NIEMALS löschen!
      - ./vw-data/:/data/
    ports:
      # Port-Mapping: Host-Port:Container-Port
      # 127.0.0.1 bindet nur an localhost (sicherer)
      - "127.0.0.1:8080:80"
      - "127.0.0.1:3012:3012"

Schritt 3: Vaultwarden starten Dieser Befehl lädt das Vaultwarden-Image herunter und startet den Container im Hintergrund:

# Container im Detached-Modus starten (läuft im Hintergrund)
docker-compose up -d

# Status überprüfen - sollte "Up" anzeigen
docker-compose ps

# Logs anschauen (falls Probleme auftreten)
docker-compose logs vaultwarden

Schritt 4: Nginx Reverse Proxy konfigurieren (optional) Ein Reverse Proxy ist notwendig für HTTPS und erweiterte Funktionen. Hier installieren wir Nginx mit automatischen SSL-Zertifikaten:

# Nginx und Certbot für SSL-Zertifikate installieren
sudo apt install nginx certbot python3-certbot-nginx

# Nginx-Konfiguration für Vaultwarden erstellen
sudo nano /etc/nginx/sites-available/vaultwarden

Nginx-Konfiguration (passe „deine-domain.de“ an deine Domain an):

# HTTP-zu-HTTPS Weiterleitung
server {
    listen 80;
    server_name ihr-domain.de;  # ZWINGEND ÄNDERN: Ihre Domain
    return 301 https://$server_name$request_uri;
}

# HTTPS-Konfiguration
server {
    listen 443 ssl http2;
    server_name deine-domain.de;  # ZWINGEND ÄNDERN: Ihre Domain

    # SSL-Zertifikatspfade (werden von Certbot automatisch gesetzt)
    ssl_certificate /etc/letsencrypt/live/deine-domain.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/deine-domain.de/privkey.pem;

    # Hauptanwendung
    location / {
        proxy_pass http://127.0.0.1:8080;
        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;
    }

    # WebSocket-Verbindungen für Live-Sync
    location /notifications/hub {
        proxy_pass http://127.0.0.1:3012;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Schritt 5: SSL-Zertifikat erstellen und Nginx aktivieren

# Nginx-Seite aktivieren
sudo ln -s /etc/nginx/sites-available/vaultwarden /etc/nginx/sites-enabled/

# Nginx-Konfiguration testen
sudo nginx -t

# SSL-Zertifikat erstellen (ersetzen Sie "ihr-domain.de")
sudo certbot --nginx -d ihr-domain.de

# Nginx starten und automatischen Start aktivieren
sudo systemctl enable nginx
sudo systemctl restart nginx

Damit ist die Installation unter Linux schon abgeschlossen, weiter geht es im Abschnitt Konfiguration.

2. Installation auf Windows

Voraussetzungen

Docker Desktop for Windows herunterladen und installieren von: https://docs.docker.com/desktop/windows/install/
Git for Windows installieren (optional, für einfacheres Management)

Schritt-für-Schritt Installation

Schritt 1: Arbeitsverzeichnis erstellen**

Das Windows-Dateisystem erfordert etwas andere Pfade als Linux, bitte nicht vergessen, diese entsprechend anzupassen:

:: Arbeitsverzeichnis auf Laufwerk D erstellen  
mkdir D:\vaultwarden
cd D:\vaultwarden

:: Datenverzeichnis für persistente Speicherung erstellen
:: WICHTIG: Dieses Verzeichnis regelmäßig sichern!
mkdir vw-data

Schritt 2: Docker Compose Datei erstellen Erstellt eine Datei namens docker-compose.yml (mit einem Editor wie Notepad++ oder VS Code):

Wichtige Anpassungen für Windows:

version: '3.8'
services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    environment:
      # Für lokale Windows-Installation - ändern Sie bei externer Nutzung
      DOMAIN: "http://localhost:8080"
      # ZWINGEND ÄNDERN: Sicheres Admin-Token generieren
      # PowerShell: -join ((1..32) | ForEach {'{0:X}' -f (Get-Random -Max 16)})
      ADMIN_TOKEN: "IhrSicheresAdminToken123"
      WEBSOCKET_ENABLED: "true"
      # Nach Ersteinrichtung auf "false" setzen!
      SIGNUPS_ALLOWED: "true"
    volumes:
      # Windows-Pfad-Syntax mit Vorwärtsslash
      - ./vw-data/:/data/
    ports:
      # Localhost-Binding für lokale Nutzung
      - "127.0.0.1:8080:80"
      - "127.0.0.1:3012:3012"

Schritt 3: Vaultwarden starten Öffnet jetzt die PowerShell oder Command Prompt als Administrator im Vaultwarden-Verzeichnis:

:: Container starten (lädt automatisch das Image herunter)
docker-compose up -d

:: Status überprüfen - sollte "Up" anzeigen
docker-compose ps

:: Bei Problemen: Logs anschauen
docker-compose logs vaultwarden

Schritt 4: Windows-Firewall konfigurieren (optional) Falls ihr euren neuen Vaultwarden im Netzwerk verfügbar machen möchtet:

:: Firewall-Regel für Port 8080 erstellen
netsh advfirewall firewall add rule name="Vaultwarden" dir=in action=allow protocol=TCP localport=8080

Schritt 5: Windows Service erstellen (optional) Für automatischen Start mit Windows verwendet zB. den NSSM (Non-Sucking Service Manager):

NSSM herunterladen: https://nssm.cc/download und entpacken
Service erstellen (PowerShell als Administrator):

# NSSM-Pfad anpassen
cd C:\nssm-2.24\win64

# Service installieren
.\nssm.exe install VaultwardenService

# Executable setzen (Docker Desktop muss installiert sein)
.\nssm.exe set VaultwardenService Application "C:\Program Files\Docker\Docker\Docker Desktop.exe"

# Arbeitsverzeichnis setzen  
.\nssm.exe set VaultwardenService AppDirectory "C:\vaultwarden"

# Startverzögerung (damit Docker Desktop zuerst startet)
.\nssm.exe set VaultwardenService AppExit Default Restart
.\nssm.exe set VaultwardenService DependOnService Docker Desktop Service

# Service starten
.\nssm.exe start VaultwardenService

Damit ist die Installation unter Windows ebenfalls schon abgeschlossen, weiter geht es im Abschnitt Konfiguration.

3. Installation auf macOS

Voraussetzungen

# Homebrew installieren (falls noch nicht vorhanden)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Docker installieren
brew install --cask docker

# Docker Desktop starten
open /Applications/Docker.app

Schritt-für-Schritt Installation

Schritt 1: Arbeitsverzeichnis erstellen macOS verwendet Unix-ähnliche Pfadstrukturen, daher ähnlich zu Linux:

# Arbeitsverzeichnis im Home-Verzeichnis erstellen
mkdir -p ~/vaultwarden
cd ~/vaultwarden

# Datenverzeichnis für Vaultwarden-Daten erstellen
# WICHTIG: Regelmäßig sichern - hier werden alle Passwörter gespeichert!
mkdir vw-data

Schritt 2: Docker Compose Datei erstellen Verwendet einen Text-Editor wie nano, vim oder TextEdit:

# Datei mit nano erstellen (empfohlen für Terminal-Nutzung)
nano docker-compose.yml

macOS-spezifische Konfiguration:

version: '3.8'
services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    environment:
      # Für lokale Nutzung - bei externer Nutzung Domain ändern
      DOMAIN: "http://localhost:8080"
      # ZWINGEND ÄNDERN: Sicheres Token generieren
      # Terminal: openssl rand -hex 32
      ADMIN_TOKEN: "IhrSicheresAdminToken123"
      WEBSOCKET_ENABLED: "true"
      # Nach Setup deaktivieren aus Sicherheitsgründen!
      SIGNUPS_ALLOWED: "true"
      # macOS-spezifisch: Timezone setzen
      TZ: "Europe/Berlin"
    volumes:
      # macOS-Pfad (Tilde wird von Docker nicht unterstützt, daher relativer Pfad)
      - ./vw-data/:/data/
    ports:
      # Localhost-Binding für Sicherheit
      - "127.0.0.1:8080:80"
      - "127.0.0.1:3012:3012"

Schritt 3: Vaultwarden starten

# Container im Hintergrund starten
docker-compose up -d

# Status überprüfen (sollte "Up" und "healthy" zeigen)
docker-compose ps

# Logs bei Problemen überprüfen
docker-compose logs -f vaultwarden

Schritt 4: macOS-Firewall konfigurieren (optional) Falls die macOS-Firewall aktiviert ist:

# Aktuellen Firewall-Status prüfen
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate

# Docker für eingehende Verbindungen erlauben
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --add /Applications/Docker.app/Contents/MacOS/Docker
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --unblockapp /Applications/Docker.app/Contents/MacOS/Docker

Schritt 5: Automatischer Start mit macOS (LaunchAgent) Für den automatischen Start von Vaultwarden beim Systemstart erstellt eine LaunchAgent-Datei:

# LaunchAgent-Verzeichnis erstellen (falls nicht vorhanden)
mkdir -p ~/Library/LaunchAgents

# LaunchAgent-Datei erstellen  
nano ~/Library/LaunchAgents/com.vaultwarden.plist

LaunchAgent-Konfiguration (passe dort den Benutzernamen an):

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.vaultwarden</string>
    <key>ProgramArguments</key>
    <array>
        <!-- ZWINGEND ÄNDERN: Pfad zu docker-compose (which docker-compose) -->
        <string>/usr/local/bin/docker-compose</string>
        <string>up</string>
        <string>-d</string>
    </array>
    <key>WorkingDirectory</key>
    <!-- ZWINGEND ÄNDERN: Ihren Benutzernamen eintragen -->
    <string>/Users/IhrBenutzername/vaultwarden</string>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <false/>
    <key>StandardOutPath</key>
    <string>/tmp/vaultwarden.stdout</string>
    <key>StandardErrorPath</key>
    <string>/tmp/vaultwarden.stderr</string>
</dict>
</plist>

LaunchAgent aktivieren:

# LaunchAgent laden und aktivieren
launchctl load ~/Library/LaunchAgents/com.vaultwarden.plist

# Status prüfen
launchctl list | grep vaultwarden

# Bei Änderungen: LaunchAgent neu laden
launchctl unload ~/Library/LaunchAgents/com.vaultwarden.plist
launchctl load ~/Library/LaunchAgents/com.vaultwarden.plist

Schritt 6: Homebrew-Integration (optional) Für eine noch sauberere macOS-Integration könnt ihr Homebrew-Services nutzen:

# Homebrew-Services installieren (falls nicht vorhanden)
brew tap homebrew/services

# Einfachen Wrapper-Service erstellen
brew services start docker

# Alternativ: Vaultwarden über Docker-Befehl direkt starten
alias vaultwarden-start="cd ~/vaultwarden && docker-compose up -d"
alias vaultwarden-stop="cd ~/vaultwarden && docker-compose down"
alias vaultwarden-logs="cd ~/vaultwarden && docker-compose logs -f"

# Aliases dauerhaft in .zshrc oder .bash_profile speichern
echo 'alias vaultwarden-start="cd ~/vaultwarden && docker-compose up -d"' >> ~/.zshrc
echo 'alias vaultwarden-stop="cd ~/vaultwarden && docker-compose down"' >> ~/.zshrc
echo 'alias vaultwarden-logs="cd ~/vaultwarden && docker-compose logs -f"' >> ~/.zshrc

Und zack, so schnell kann es gehen. Installation abgeschlossen. Jetzt sehen wir uns im nächsten Abschnitt die Einrichtung im Detail an.

Erweiterte Konfiguration und Verwaltung

Erste Schritte: Das Admin-Panel

Das Admin-Panel ist die zentrale Verwaltungsoberfläche für euren neuen Vaultwarden-Server:

Zugriff: Navigiert zu https://domain.de/admin (oder http://localhost:8080/admin bei nur lokalem Setup)
Authentifizierung: Gebt das Admin-Token ein, das ihr in der Docker Compose Datei definiert habt
Wichtige Ersteinstellungen:
- SMTP-Konfiguration: Für E-Mail-Benachrichtigungen und 2FA per E-Mail erforderlich
- Domain-Einstellungen: Muss mit eurer tatsächlichen URL übereinstimmen
- Benutzerregistrierung: Nach der Ersteinrichtung aus Sicherheitsgründen bitte deaktivieren! (Einladen könnt ihr trotzdem)
- Backup-Pfade: Verzeichnisse für automatische Backups definieren

Noch ein paar Sätze zu der oben in gelb eingeblendeten Fehlermeldung bezüglich des Admin_Tokens:

Sicherheit ist ja das A und O, besonders wenn es um so sensible Dinge wie euren neuen Passwort-Manager geht. Lange Zeit war der ADMIN_TOKEN in Vaultwarden nur im Klartext verfügbar, nicht die sicherste Lösung, wie wir alle wissen. Aber keine Sorge, das hat ein Ende! Seit Version 1.28.0+ könnt ihr den Token ordentlich hashen und so eure Instanz noch sicherer machen.

Warum solltet ihr das tun?

Stellt euch vor, jemand bekommt Zugriff auf eure config.json oder eure Umgebungsvariablen. Wenn der ADMIN_TOKEN dort im Klartext steht, hat diese Person sofort Admin-Zugriff auf euren Vaultwarden-Server. Mit einem gehashten Token ist das quasi unmöglich, da aus dem Hash nicht wieder das ursprüngliche Passwort rekonstruiert werden kann. Super, oder?

Dafür verwendet Vaultwarden jetzt Argon2, einen Hash-Algorithmus, der speziell für die Passwort-Verschlüsselung entwickelt wurde und als sehr sicher gilt. Ein gehashter Token wird als PHC String (Password Hashing Competition) bezeichnet.

Okay, und wie erstelle ich den Hash?

Am einfachsten geht das direkt über die integrierte Funktion von Vaultwarden selbst. Ihr habt zwei Optionen:

1. Der einfache Weg: `vaultwarden hash`

Vaultwarden bringt ein eigenes kleines Tool mit, das euch den PHC String generiert. Das Beste daran? Es gibt zwei Voreinstellungen: die Bitwarden-Defaults und die OWASP-Empfehlungen. Die OWASP-Empfehlungen sind die sicheren von den beiden, aber beide sind eine deutliche Verbesserung zum Klartext.

Um den Hash zu erstellen, gebt ihr einfach den entsprechenden Befehl ein. Ich gehe mal davon aus, dass ihr Vaultwarden wie oben beschrieben im Docker betreibt und nenne den Container vwcontainer, ersetzt das einfach durch den Namen eures Containers.

Mit Bitwarden-Defaults (Standard):

docker exec -it vwcontainer /vaultwarden hash
# oder alternativ direkt über die Binary:

./vaultwarden hash

Mit OWASP-Empfehlungen (empfohlen):

docker exec -it vwcontainer /vaultwarden hash --preset owasp
# oder alternativ direkt über die Binary:

./vaultwarden hash --preset owasp

Der Befehl fragt euch zweimal nach einem Passwort und spuckt dann den fertigen PHC String aus. Diesen kopiert ihr dann einfach in eure Konfiguration.

Wichtig: Wenn ihr eure Einstellungen schon mal über die Admin-Oberfläche gespeichert habt, werden die Umgebungsvariablen ignoriert. Dann müsst ihr das Passwort ebenfalls über die Admin-Oberfläche aktualisieren!

2. Der DIY-Weg: `argon2` CLI

Falls ihr es lieber selbst in die Hand nehmen wollt, könnt ihr auch das argon2-CLI Tool verwenden, das auf den meisten Linux-Distributionen verfügbar ist. Hier müsst ihr die Parameter für die Bitwarden- oder OWASP-Einstellungen manuell angeben.

Mit Bitwarden-Defaults:

echo -n "DeinMegaGeheimesPasswort" | argon2 "$(openssl rand -base64 32)" -e -id -k 65540 -t 3 -p 4

Mit OWASP-Empfehlungen:

echo -n "DeinMegaGeheimesPasswort" | argon2 "$(openssl rand -base64 32)" -e -id -k 19456 -t 2 -p 1

Einfach DeinMegaGeheimesPasswort durch euer Wunschpasswort ersetzen. Das Terminal gibt euch dann den PHC String zurück.

Was mache ich mit dem PHC String?

Habt ihr den String, könnt ihr ihn in eurer Docker-Konfiguration verwenden. Am einfachsten geht das über Umgebungsvariablen in eurer docker-compose.yml Datei. Und ganz wichtig: Danach loggt ihr euch nicht mehr mit dem Token selbst ein, sondern mit eurem Passwort, das ihr bei der Hash-Erstellung eingegeben habt.

Achtung: Bearbeitet auf keinen Fall manuell die config.json. Das kann schnell zu Problemen führen. Benutzt stattdessen ansonsten am besten die Admin-Oberfläche, um die Einstellungen zu aktualisieren.

Und wenn ihr immer noch die nervige Warnung seht, dass euer Token unsicher ist, dann habt ihr entweder die Einstellungen schon einmalig über die Admin-Oberfläche gespeichert, oder die Konfiguration ist nicht ganz korrekt. Überprüft in diesem Fall unbedingt die Doku zur Variablensubstitution in Docker-Compose oder die Tipps direkt im Github Vaultwarden Repo.

Fertig? Das war es dann schon. So einfach macht ihr euren Vaultwarden-Server ein gutes Stück sicherer.

Den ersten Benutzer erstellen

Die Ersteinrichtung eines Administrator-Kontos:

Registrierung: Navigiert zu https://domain.de (Hauptseite)
Konto erstellen: Klickt auf „Konto erstellen“ – Dies funktioniert nur, wenn SIGNUPS_ALLOWED: "true" gesetzt ist
Sichere Anmeldedaten:
- Verwendet eine gültige E-Mail-Adresse (für 2FA und Recovery wichtig)
- Wählt ein starkes, einzigartiges Master-Passwort (mindestens 12 Zeichen, Sonderzeichen, Zahlen)
E-Mail-Bestätigung: Bei aktivierter E-Mail-Verifikation den Bestätigungslink anklicken
Wichtig: Nach der Erstellung des ersten Admin-Kontos solltet ihr unbedingt SIGNUPS_ALLOWED auf "false" setzen!

Vaultwarden Admin Oberfläche nach Installation

Organisationen und Gruppen erstellen

Vaultwarden unterstützt Organisationen für die gemeinsame Nutzung von Passwörtern in Teams oder Familien.

Organisation erstellen:

Im Vaultwarden Web-Interface anmelden
„Neue Organisation“ → „Organisation erstellen“ klicken
Namen vergeben (z.B. „Familie Mustermann“ oder „Firma XY“)
Organisationstyp wählen (Familie oder Business)

Gruppen aktivieren:

Gruppen müssen in Vaultwarden explizit aktiviert werden durch eine Umgebungsvariable in der Docker Compose Datei:

environment:
  # Gruppen-Funktionalität aktivieren
  ORG_GROUPS_ENABLED: "true"

Nach der Aktivierung könnt ihr auch Gruppen erstellen:

Organisation auswählen → „Verwalten“ → „Gruppen“
„Neue Gruppe“ → Namen vergeben (z.B. „Admins“, „Benutzer“)
Zugriffsrechte definieren und Mitglieder zuweisen

Collections und Zugriffskontrollen:

Collections organisieren Vault-Einträge innerhalb einer Organisation:

„Verwalten“ → „Collections“ → „Neue Collection“
Zugriffsrechte pro Gruppe/Benutzer definieren:
- Nur lesen: Kann Passwörter einsehen und verwenden
- Lesen/Schreiben: Kann Einträge bearbeiten
- Verwalten: Vollzugriff inklusive Löschen

Zwei-Faktor-Authentifizierung (2FA/MFA) einrichten

Vaultwarden unterstützt verschiedene 2FA-Methoden, die für maximale Sicherheit unbedingt aktiviert werden sollten.

Unterstützte 2FA-Methoden:

E-Mail-Codes: Einfachste Methode, Code wird per E-Mail gesendet
TOTP (Time-based OTP): Google Authenticator, Authy, Microsoft Authenticator
Duo: Professioneller 2FA-Service mit Push-Benachrichtigungen
YubiKey: Hardware-basierte Authentifizierung
FIDO2 WebAuthn: Moderne Hardware-Keys (YubiKey 5, SoloKey, etc.)

TOTP (Google Authenticator) einrichten:

Kontoeinstellungen → „Sicherheit“ → „Zwei-Schritt-Anmeldung“
„Authenticator-App“ wählen
QR-Code mit Authenticator-App scannen
6-stelligen Code eingeben zur Bestätigung
Recovery-Code sicher speichern!

Hardware-Key (FIDO2) konfigurieren:

Für Hardware-Keys müssen zusätzliche Umgebungsvariablen gesetzt werden:

environment:
  # FIDO2 WebAuthn aktivieren
  FIDO2_ENABLED: "true"
  # Domain für FIDO2 (muss exakt mit Ihrer Domain übereinstimmen)  
  DOMAIN: "https://domain.de"

2FA global erzwingen (Enterprise-Feature):

Vaultwarden bietet Optionen, um 2FA für alle Benutzer zu erzwingen:

environment:
  # 2FA-Remember-Funktion deaktivieren (erzwingt 2FA bei jeder Anmeldung)
  DISABLE_2FA_REMEMBER: "true"
  # Organisationsrichtlinien aktivieren
  ORG_EVENTS_ENABLED: "true"

Best Practices für Sicherheit

Admin-Panel ausschließlich für lokalen Zugriff absichern:

environment:
  # Admin-Panel nur von bestimmten IPs erreichbar
  ADMIN_ALLOWED_IPS: "192.168.1.0/24,10.0.0.0/8"
  # Admin-Session-Timeout (in Sekunden)  
  ADMIN_SESSION_LIFETIME: "3600"

Benutzerregistrierung kontrollieren:

environment:
  # Nach Setup deaktivieren!
  SIGNUPS_ALLOWED: "false"
  # Nur Einladungen über bestehende Accounts erlauben
  INVITATIONS_ALLOWED: "true"
  # Domain-Whitelist für Registrierungen
  SIGNUPS_DOMAINS_WHITELIST: "meinefirma.de,vertrauenswuerdig.com"

E-Mail-Konfiguration für 2FA und Einladungen:

SMTP-Settings sind essentiell für E-Mail-2FA und Benutzereinladungen:

environment:
  # SMTP-Server (Beispiel: Gmail)
  SMTP_HOST: "smtp.gmail.com"
  SMTP_FROM: "vaultwarden@ihr-domain.de"  
  SMTP_PORT: "587"
  SMTP_SECURITY: "starttls"
  SMTP_USERNAME: "ihr-email@gmail.com"
  # App-Passwort bei Gmail erforderlich!
  SMTP_PASSWORD: "ihr-app-passwort"

Fehlgeschlagene Anmeldeversuche protokollieren:

environment:
  # Extended Logging aktivieren  
  EXTENDED_LOGGING: "true"
  # Fehlgeschlagene Anmeldungen loggen
  LOG_LEVEL: "warn"
  # Log-Datei (optional)
  LOG_FILE: "/data/vaultwarden.log"

Erweiterte Sicherheitsfunktionen

Emergency Access konfigurieren:

Emergency Access ermöglicht vertrauenswürdigen Personen Zugriff auf Ihren Vault im Notfall:

Kontoeinstellungen → „Emergency Access“
Vertrauensperson über E-Mail-Adresse hinzufügen
Wartezeit definieren (z.B. 7 Tage)
Zugriffstyp wählen: „Nur anzeigen“ oder „Vollzugriff“

Vault Health Reports:

Vaultwarden bietet eingebaute Sicherheitsanalysen:

Schwache Passwörter: Identifiziert unsichere Passwörter
Wiederverwendete Passwörter: Findet doppelt verwendete Credentials
Kompromittierte Passwörter: Prüft gegen HaveIBeenPwned-Datenbank
Unsichere Websites: Warnt vor HTTP-Sites mit Login-Daten

Fail2Ban für Brute-Force-Schutz:

Linux-Systeme sollten Fail2Ban konfigurieren:

# Fail2Ban installieren
sudo apt install fail2ban

# Vaultwarden-Filter erstellen
sudo nano /etc/fail2ban/filter.d/vaultwarden.conf

Fail2Ban-Konfiguration:

[Definition]
failregex = ^.*Username or password is incorrect\. Try again\. IP: <HOST>\. Username:.*$
ignoreregex =

# Jail konfigurieren  
sudo nano /etc/fail2ban/jail.d/vaultwarden.conf

[vaultwarden]
enabled = true
port = 80,443
filter = vaultwarden  
action = iptables-allports[name=vaultwarden]
logpath = /opt/vaultwarden/vw-data/vaultwarden.log
maxretry = 3
bantime = 14400
findtime = 14400

Monitoring und Wartung

Health Check implementieren:

services:
  vaultwarden:
    # ... andere Konfigurationen
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:80/alive"]
      interval: 30s
      timeout: 10s  
      retries: 3
      start_period: 40s

Log-Rotation einrichten:

environment:
  # Logs begrenzen
  LOG_LEVEL: "warn"
  # Maximale Log-Dateigröße
  LOG_FILE: "/data/vaultwarden.log"

Logrotate-Konfiguration:

sudo nano /etc/logrotate.d/vaultwarden

/opt/vaultwarden/vw-data/vaultwarden.log {
    weekly
    missingok
    rotate 52  
    compress
    notifempty
    create 644 root root
    postrotate
        docker-compose -f /opt/vaultwarden/docker-compose.yml restart vaultwarden
    endscript
}

Bitwarden-Clients und kompatible Tools

Browser-Erweiterungen

Alle offiziellen Bitwarden Browser-Erweiterungen funktionieren nahtlos mit Vaultwarden:

Chrome/Chromium-basierte Browser

Name: Bitwarden – Kostenloser Passwort-Manager
Verfügbar für: Chrome, Edge, Brave, Vivaldi, Arc, Opera
Installation: Chrome Web Store → „Bitwarden“ suchen und installieren
Download-Link: https://chrome.google.com/webstore/detail/bitwarden-free-password-m/nngceckbapebfimnlniiiahkandclblb

Firefox

Name: Bitwarden – Kostenloser Passwort-Manager
Installation: Firefox Add-ons → „Bitwarden“ suchen und installieren
Download-Link: https://addons.mozilla.org/firefox/addon/bitwarden-password-manager/

Safari

Name: Bitwarden für Safari
Installation: Mac App Store → „Bitwarden“ herunterladen
Besonderheit: Benötigt die Desktop-App als Basis

Konfiguration der Browser-Extension:

Nach der Installation müsst ihr mit der Extension auf euren Vaultwarden-Server verweisen:

Extension installieren und öffnen
Auf das Einstellungen-Symbol (Zahnrad) klicken
Server-URL ändern zu: https://domain.de (oder http://localhost:8080 bei lokalem Setup)
Mit Ihren Vaultwarden-Anmeldedaten einloggen

Mobile Apps

Android

Mehrere Optionen stehen hier zur Verfügung:

Offizielle Bitwarden App:

Name: Bitwarden Password Manager
Download: Google Play Store
Link: https://play.google.com/store/apps/details?id=com.x8bit.bitwarden
Features: Vollständige Integration, Autofill-Service, Biometrische Entsperrung

F-Droid Alternative:

Name: Bitwarden (Open Source)
Download: F-Droid Repository
Vorteil: Vollständig Open Source, keine Google-Dienste erforderlich

iOS/iPadOS

Name: Bitwarden Password Manager
Download: Apple App Store
Link: https://apps.apple.com/app/bitwarden-password-manager/id1137397744
Features: iOS-Integration, Face ID/Touch ID, AutoFill-Provider, Apple Watch-Unterstützung

Konfiguration der Mobile Apps:

App installieren und öffnen
Bei der Anmeldung auf „Self-hosted“ oder „Enterprise“ tippen
Server-URL eingeben: https://domain.de
Mit Vaultwarden-Konto anmelden
Biometrische Entsperrung in den App-Einstellungen aktivieren (empfohlen)

Desktop-Anwendungen

Windows

Download: https://bitwarden.com/download/
Verfügbare Formate: .exe-Installer, Microsoft Store, Chocolatey, Winget
Installation über Winget: winget install Bitwarden.Bitwarden

macOS

Download: Mac App Store oder direkt von bitwarden.com
Installation über Homebrew: brew install --cask bitwarden
Features: Touch ID-Integration, Safari-Extension-Integration

Linux

Multiple Installationsoptionen verfügbar:

AppImage: Universell lauffähig auf allen Distributionen
.deb-Paket: Für Debian/Ubuntu-basierte Systeme
Snap: snap install bitwarden
Flatpak: flatpak install flathub com.bitwarden.desktop
AUR (Arch Linux): yay -S bitwarden

Command Line Interface (CLI)

Das Bitwarden CLI ist übrigens auch ein mächtiges Tool für Automatisierung und Skripte:

Installation:

# Via npm (Node.js erforderlich)
npm install -g @bitwarden/cli

# Via Snap
snap install bw

# Via Chocolatey (Windows)  
choco install bitwarden-cli

Konfiguration und Nutzung:

# Server konfigurieren
bw config server https://ihr-domain.de

# Anmelden
bw login ihre-email@domain.de

# Vault entsperren (gibt Session-Token zurück)
export BW_SESSION=$(bw unlock --raw)

# Einträge auflisten
bw list items

# Passwort für bestimmte Website abrufen
bw get password github.com

# Neuen Eintrag erstellen
bw create item '{"type":1,"name":"Beispiel","login":{"username":"test@example.com","password":"geheimespasswort"}}'

Backup-Strategien

Automatisches Backup-Script (Linux/macOS)

#!/bin/bash
BACKUP_DIR="/backup/vaultwarden"
DATE=$(date +%Y%m%d_%H%M%S)

# Backup-Verzeichnis erstellen
mkdir -p $BACKUP_DIR

# Container stoppen
docker-compose stop vaultwarden

# Daten sichern
tar -czf $BACKUP_DIR/vaultwarden_backup_$DATE.tar.gz ./vw-data/

# Container starten
docker-compose start vaultwarden

# Alte Backups löschen (älter als 30 Tage)
find $BACKUP_DIR -name "vaultwarden_backup_*.tar.gz" -mtime +30 -delete

Dieses Script als Cronjob einrichten:

# Crontab bearbeiten
crontab -e

# Tägliches Backup um 2:00 Uhr
0 2 * * * /path/to/backup-script.sh

Sicherheitsempfehlungen

1. Starke Authentifizierung

Verwendet immer komplexe Admin-Tokens
Aktiviert am besten auch Zwei-Faktor-Authentifizierung für alle Konten
Deaktiviert die Registrierung nach Setup und ladet stattdessen Nutzer ein

2. Netzwerksicherheit

Verwendet immer HTTPS in der Produktion
Beschränkt den Zugriff über Firewall-Regeln
Implementiert auf alle Fälle auch fail2ban für Brute-Force-Schutz

3. System-Updates

# Regelmäßige Updates des Containers
docker-compose pull
docker-compose up -d

# System-Updates
sudo apt update && sudo apt upgrade

Troubleshooting

Häufige Probleme und Lösungen

Problem: Web-Interface lädt nicht

# Container-Logs prüfen
docker-compose logs vaultwarden

# Port-Konflikte prüfen
netstat -tulpn | grep :8080

Problem: Browser-Extension verbindet nicht

Prüft die Server-URL in den Extension-Einstellungen
Stellt sicher, dass HTTPS aktiviert ist (außer bei localhost)
Überprüft die Firewall-Einstellungen

Problem: E-Mail-Versand funktioniert nicht

SMTP-Einstellungen im Admin-Panel überprüfen
Logs auf SMTP-Authentifizierungsfehler prüfen
E-Mail-Provider-spezifische App-Passwörter verwenden

Fazit

Vaultwarden ist eine hervorragende Alternative für alle, die ihre Passwort-Verwaltung vollständig selbst kontrollieren möchten. Mit geringem Ressourcenverbrauch und vollständiger Kompatibilität zu allen Bitwarden-Clients bietet es eine professionelle Lösung für Private und kleine Unternehmen.

Die einmalige Einrichtung erfordert zwar technisches Verständnis, aber die langfristigen Vorteile in Bezug auf Datenschutz, Kontrolle und Kosteneinsparungen machen den Aufwand mehr als wett. Mit den bereitgestellten Installationsanleitungen und Sicherheitsempfehlungen steht einem erfolgreichen Self-Hosting-Setup nichts im Wege.

Wichtiger Hinweis: Vergesst nie, regelmäßige Backups zu erstellen und eure Installation aktuell zu halten. Die Sicherheit eurer Passwörter liegt bei so einem Setup voll in eurer Verantwortung!

Weiterführende Ressourcen

Offizielle Vaultwarden Wiki: https://github.com/dani-garcia/vaultwarden/wiki
Bitwarden Client / Addons / Download: https://bitwarden.com/download/
Community Support: https://matrix.to/#/#vaultwarden:matrix.org
GitHub Issues: https://github.com/dani-garcia/vaultwarden/issues
Docker Hub: https://hub.docker.com/r/vaultwarden/server

Dieser Artikel wurde mit Informationen aus der offiziellen Vaultwarden-Dokumentation und Community-Erfahrungen zusammengestellt. Stand: August 2025

Vaultwarden: Die Open-Source Alternative zu Bitwarden für deine lokale Installation

Vaultwarden ist eine leichtgewichtige, in Rust entwickelte Server-Implementation der Bitwarden Client API.

Einführung: Was ist Vaultwarden?

Alternative Installationsmethoden

Vorzüge von Vaultwarden

Technische Vorteile

Funktionsumfang

Datenschutz und Sicherheit

Nachteile von Vaultwarden

Technische Herausforderungen

Wartungsaufwand

Detaillierte Installationsanleitungen

1. Installation auf Linux (Ubuntu/Debian)

Voraussetzungen

Schritt-für-Schritt Installation

2. Installation auf Windows

Voraussetzungen

Schritt-für-Schritt Installation

Schritt 1: Arbeitsverzeichnis erstellen**

3. Installation auf macOS

Voraussetzungen

Schritt-für-Schritt Installation

Erweiterte Konfiguration und Verwaltung

Erste Schritte: Das Admin-Panel

Warum solltet ihr das tun?

Okay, und wie erstelle ich den Hash?

1. Der einfache Weg: vaultwarden hash

2. Der DIY-Weg: argon2 CLI

Was mache ich mit dem PHC String?

Den ersten Benutzer erstellen

Organisationen und Gruppen erstellen

Organisation erstellen:

Gruppen aktivieren:

Collections und Zugriffskontrollen:

Zwei-Faktor-Authentifizierung (2FA/MFA) einrichten

Unterstützte 2FA-Methoden:

TOTP (Google Authenticator) einrichten:

Hardware-Key (FIDO2) konfigurieren:

2FA global erzwingen (Enterprise-Feature):

Best Practices für Sicherheit

Admin-Panel ausschließlich für lokalen Zugriff absichern:

Benutzerregistrierung kontrollieren:

E-Mail-Konfiguration für 2FA und Einladungen:

Fehlgeschlagene Anmeldeversuche protokollieren:

Erweiterte Sicherheitsfunktionen

Emergency Access konfigurieren:

Vault Health Reports:

Fail2Ban für Brute-Force-Schutz:

Monitoring und Wartung

Health Check implementieren:

Log-Rotation einrichten:

Bitwarden-Clients und kompatible Tools

Browser-Erweiterungen

Chrome/Chromium-basierte Browser

Firefox

Safari

Konfiguration der Browser-Extension:

Mobile Apps

Android

iOS/iPadOS

Konfiguration der Mobile Apps:

Desktop-Anwendungen

Windows

macOS

Linux

Command Line Interface (CLI)

Backup-Strategien

Automatisches Backup-Script (Linux/macOS)

Sicherheitsempfehlungen

1. Starke Authentifizierung

2. Netzwerksicherheit

3. System-Updates

Troubleshooting

Häufige Probleme und Lösungen

Fazit

Weiterführende Ressourcen

1. Der einfache Weg: `vaultwarden hash`

2. Der DIY-Weg: `argon2` CLI