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 finden Sie 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 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 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
cd /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 32
      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 ihr-domain.de;  # ZWINGEND ÄNDERN: Ihre Domain

    # SSL-Zertifikatspfade (werden von Certbot automatisch gesetzt)
    ssl_certificate /etc/letsencrypt/live/ihr-domain.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/ihr-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 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 Erstellen Sie eine Datei namens docker-compose.yml (verwenden Sie 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 Öffnen Sie 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 Sie Vaultwarden im Netzwerk verfügbar machen möchten:

:: 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 verwenden Sie 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 Verwenden Sie 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 erstellen Sie eine LaunchAgent-Datei:

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

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

LaunchAgent-Konfiguration (passen Sie 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önnen Sie 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 Ihren Vaultwarden-Server:

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

Den ersten Benutzer erstellen

Die Ersteinrichtung eines Administrator-Kontos:

Registrierung: Navigieren Sie zu https://ihr-domain.de (Hauptseite)
Konto erstellen: Klicken Sie auf „Konto erstellen“ – Dies funktioniert nur, wenn SIGNUPS_ALLOWED: "true" gesetzt ist
Sichere Anmeldedaten:
- Verwenden Sie eine gültige E-Mail-Adresse (für 2FA und Recovery wichtig)
- Wählen Sie ein starkes 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 sollten Sie SIGNUPS_ALLOWED auf "false" setzen!# Vaultwarden: Die ultimative Open-Source Alternative zu Bitwarden für lokale 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önnen Sie 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://ihr-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üssen Sie die Extension auf Ihren Vaultwarden-Server verweisen:

Extension installieren und öffnen
Auf das Einstellungen-Symbol (Zahnrad) klicken
Server-URL ändern zu: https://ihr-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://ihr-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 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

Verwenden Sie komplexe Admin-Tokens
Aktivieren Sie Zwei-Faktor-Authentifizierung für alle Konten
Deaktivieren Sie Registrierungen nach Setup

2. Netzwerksicherheit

Verwenden Sie immer HTTPS in der Produktion
Beschränken Sie Zugriff über Firewall-Regeln
Implementieren Sie 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üfen Sie die Server-URL in den Extension-Einstellungen
Stellen Sie sicher, dass HTTPS aktiviert ist (außer bei localhost)
Überprüfen Sie 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

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