Vaultwarden (Bitwarden) Self-Hosted auf Debian 13 — Vollständiger Guide

💡 Hinweis: Dieses Tutorial setzt voraus, dass du einen normalen Benutzer mit sudo-Rechten verwendest — wie im Tutorial Debian 13 Server absichern beschrieben.

Einleitung — Was ist Vaultwarden?

Passwörter sind der Schlüssel zu unserem digitalen Leben — und gleichzeitig eine der größten Schwachstellen. Wer noch immer dasselbe Passwort für mehrere Dienste verwendet oder Zugangsdaten im Browser speichert, lebt gefährlich. Ein Passwort-Manager löst dieses Problem, indem er alle Credentials verschlüsselt in einem Tresor (Vault) speichert.

Bitwarden ist einer der beliebtesten Open-Source Passwort-Manager. Der offizielle Server benötigt allerdings erhebliche Ressourcen (MSSQL-Datenbank, .NET Runtime, mehrere Container). Hier kommt Vaultwarden ins Spiel — eine in Rust geschriebene, inoffizielle Bitwarden-Server-Implementierung, die:

• ✅ Vollständig kompatibel mit allen offiziellen Bitwarden-Clients ist
• ✅ Nur einen einzigen Docker-Container benötigt
• ✅ Mit SQLite auskommt (kein MSSQL nötig)
• ✅ Extrem ressourcenschonend läuft (~50 MB RAM)
• ✅ Viele Premium-Features kostenlos bietet (TOTP, Attachments, Organizations)

Warum Self-Hosted?

Natürlich könnte man einfach bitwarden.com nutzen. Aber es gibt gute Gründe für Self-Hosting:

• Volle Datenkontrolle — Eure Passwörter verlassen nie euren Server
• Keine Abhängigkeit — Wenn Bitwarden down ist, funktioniert euer Vault weiter
• Kostenlos — Alle Premium-Features ohne Abo
• Lerneffekt — Ihr versteht, wie eure Sicherheitsinfrastruktur funktioniert
• Anpassbarkeit — Vollständige Kontrolle über Konfiguration und Backups

Voraussetzungen

Bevor wir starten, braucht ihr folgende Grundlagen:

Vaultwarden mit Docker Compose installieren

Verzeichnisstruktur anlegen

Wie in unserer Tutorial-Reihe üblich, erstellen wir ein sauberes Projektverzeichnis:

sudo mkdir -p /opt/vaultwarden
cd /opt/vaultwarden

Docker Compose Datei

Erstellt die Datei docker-compose.yml:

sudo nano /opt/vaultwarden/docker-compose.yml

Inhalt:

services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    ports:
      - "127.0.0.1:8080:80"
    volumes:
      - ./data:/data
    environment:
      - DOMAIN=https://vault.example.com
      - SIGNUPS_ALLOWED=true
      - ADMIN_TOKEN=${ADMIN_TOKEN}
      - LOG_LEVEL=info
      - EXTENDED_LOGGING=true
    env_file:
      - .env

Container starten

Bevor wir starten, erstellen wir zunächst die .env-Datei (siehe nächster Abschnitt). Danach:

cd /opt/vaultwarden
sudo docker compose up -d

Status prüfen:

sudo docker compose ps
sudo docker compose logs -f

Ihr solltet eine Zeile wie Rocket has launched from http://0.0.0.0:80 sehen — das bedeutet, Vaultwarden läuft.

Umgebungsvariablen & Konfiguration

Erstellt die .env-Datei für sensible Konfigurationswerte:

sudo nano /opt/vaultwarden/.env

Inhalt:

# Domain (HTTPS Pflicht!)
DOMAIN=https://vault.example.com

# Admin-Panel Token (generieren — siehe nächster Abschnitt)
ADMIN_TOKEN=euer_sicherer_admin_token_hier

# Registrierung (nach Setup auf false setzen!)
SIGNUPS_ALLOWED=true

# Einladungen erlauben
INVITATIONS_ALLOWED=true

# WebSocket-Benachrichtigungen
WEBSOCKET_ENABLED=true

# Logging
LOG_LEVEL=info
EXTENDED_LOGGING=true

# Zeitzone
TZ=Europe/Berlin

Berechtigungen einschränken:

sudo chmod 600 /opt/vaultwarden/.env

Wichtige Umgebungsvariablen im Überblick

Nginx Reverse Proxy + SSL

HTTPS ist für Vaultwarden nicht optional, sondern Pflicht. Die Web Crypto API, die Bitwarden-Clients verwenden, funktioniert nur in sicheren Kontexten (HTTPS).

SSL-Zertifikat mit Certbot

Falls ihr Certbot noch nicht installiert habt:

sudo apt install certbot python3-certbot-nginx -y

Zertifikat beantragen:

sudo certbot certonly --nginx -d vault.example.com

Nginx-Konfiguration

Erstellt die Server-Block-Konfiguration:

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

Inhalt:

upstream vaultwarden {
    zone vaultwarden 64k;
    server 127.0.0.1:8080;
    keepalive 2;
}

# HTTP → HTTPS Redirect
server {
    listen 80;
    listen [::]:80;
    server_name vault.example.com;

    # Let's Encrypt Challenge
    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
    }

    location / {
        return 301 https://$host$request_uri;
    }
}

# HTTPS Server
server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name vault.example.com;

    # SSL-Zertifikate
    ssl_certificate /etc/letsencrypt/live/vault.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/vault.example.com/privkey.pem;

    # SSL-Härtung
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;

    # Security Headers
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header Referrer-Policy "strict-origin-when-cross-origin" always;

    # Max Upload-Größe (für Attachments)
    client_max_body_size 525m;

    # Hauptanwendung
    location / {
        proxy_pass http://vaultwarden;
        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-Unterstützung für Live-Sync
    location /notifications/hub {
        proxy_pass http://vaultwarden;
        proxy_set_header Host $host;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        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;
    }
}

Konfiguration aktivieren und testen:

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

Jetzt sollte https://vault.example.com die Bitwarden Web-Vault-Oberfläche anzeigen.

Automatische Zertifikatsverlängerung

Certbot richtet normalerweise automatisch einen Timer ein. Prüft:

sudo systemctl status certbot.timer

Admin-Panel aktivieren & absichern

Das Admin-Panel gibt euch Zugriff auf die komplette Konfiguration über ein Web-Interface. Es ist standardmäßig deaktiviert und sollte nur mit starkem Token aktiviert werden.

Admin-Token generieren

Seit Vaultwarden 1.28 wird empfohlen, den Token als Argon2-Hash zu speichern:

# Argon2-Hash generieren
sudo docker exec -it vaultwarden /vaultwarden hash --preset owasp

Die Ausgabe sieht so aus:

Generate an Argon2id PHC string using the 'owasp' preset:
Password:
Confirm Password:

ADMIN_TOKEN='$argon2id$v=19$m=19456,t=2,p=1$...'

Tragt den kompletten Hash in eure .env-Datei ein:

ADMIN_TOKEN='$argon2id$v=19$m=19456,t=2,p=1$euer_hash_hier'

Container neu starten:

cd /opt/vaultwarden
sudo docker compose down
sudo docker compose up -d

Das Admin-Panel ist nun erreichbar unter: https://vault.example.com/admin

Admin-Panel absichern

Zusätzlich zum Token empfehle ich, den Zugang zum Admin-Panel auf IP-Ebene in Nginx einzuschränken:

# In der Nginx-Konfiguration hinzufügen:
location /admin {
    # Nur von bestimmten IPs erreichbar
    allow 192.168.1.0/24;    # Lokales Netzwerk
    allow EURE_ÖFFENTLICHE_IP;
    deny all;

    proxy_pass http://vaultwarden;
    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;
}

Benutzer registrieren & Registrierung deaktivieren

Ersten Benutzer anlegen

Nach dem Start ist die Registrierung offen. Öffnet https://vault.example.com im Browser und klickt auf „Konto erstellen“.

Wählt ein starkes Master-Passwort — dieses Passwort verschlüsselt euren gesamten Vault. Tipps:

• Mindestens 14 Zeichen
• Am besten eine Passphrase: korrekt-pferd-batterie-heftklammer
• Notiert es offline (z. B. auf Papier in einem Safe)
• Dieses Passwort kann nicht zurückgesetzt werden!

Registrierung deaktivieren

Nachdem alle gewünschten Benutzer angelegt sind, deaktiviert die öffentliche Registrierung sofort:

In der .env-Datei:

SIGNUPS_ALLOWED=false

Container neu starten:

cd /opt/vaultwarden
sudo docker compose down && sudo docker compose up -d

Alternativ könnt ihr die Registrierung auf bestimmte Domains beschränken:

# Nur E-Mail-Adressen dieser Domains dürfen sich registrieren
SIGNUPS_DOMAINS_WHITELIST=example.com,family.org

Benutzer über Admin-Panel einladen

Wenn die Registrierung geschlossen ist, könnt ihr trotzdem neue Benutzer über das Admin-Panel einladen:

1. Öffnet https://vault.example.com/admin
2. Geht zu Users
3. Gebt die E-Mail-Adresse ein und klickt Invite
4. Der Benutzer erhält eine Einladungs-E-Mail (SMTP muss konfiguriert sein)

Browser-Extensions & Apps verbinden

Die Stärke von Vaultwarden: Alle offiziellen Bitwarden-Clients funktionieren! Hier die Einrichtung:

Browser-Extension

1. Installiert die offizielle Bitwarden Browser-Extension (bitwarden.com/download)
2. Klickt auf das Bitwarden-Icon → „Self-Hosted“ wählen (oder Region-Dropdown → Self-hosted)
3. Gebt eure Server-URL ein: https://vault.example.com
4. Speichern → Jetzt mit euren Zugangsdaten anmelden

Desktop-App

1. Bitwarden Desktop-App herunterladen (bitwarden.com/download)
2. Vor dem Login: Einstellungen (Zahnrad-Icon) → Self-Hosted-Server-URL eintragen
3. Anmelden

Mobile App (iOS/Android)

1. Bitwarden aus dem App Store / Play Store installieren
2. Auf dem Login-Screen: Self-Hosted wählen (oben links Region-Auswahl)
3. Server-URL: https://vault.example.com
4. Anmelden

CLI

# Bitwarden CLI installieren
npm install -g @bitwarden/cli

# Server konfigurieren
bw config server https://vault.example.com

# Anmelden
bw login email@example.com

Organisationen & Sharing

Organisationen ermöglichen das Teilen von Passwörtern und Notizen zwischen mehreren Benutzern — perfekt für Familien oder kleine Teams.

Organisation erstellen

1. Meldet euch im Web-Vault an (https://vault.example.com)
2. Klickt auf „Neue Organisation“
3. Vergebt einen Namen (z. B. „Familie Koch“)
4. Die Organisation wird sofort erstellt — kostenlos bei Vaultwarden!

Mitglieder einladen

1. In der Organisation → Mitglieder → Einladen
2. E-Mail-Adresse eingeben
3. Rolle wählen:
   • Owner — Volle Kontrolle
   • Admin — Kann Sammlungen und Mitglieder verwalten
   • User — Normaler Zugriff auf zugewiesene Sammlungen
   • Manager — Kann zugewiesene Sammlungen verwalten
   • Einladung muss vom Owner/Admin bestätigt werden

Sammlungen (Collections)

Sammlungen sind wie Ordner innerhalb einer Organisation. Beispiele:

• Streaming — Netflix, Disney+, Spotify
• Smart Home — WLAN, Router, IoT-Zugänge
• Finanzen — Banking, Versicherungen
• Shared — Geteilte Familien-Accounts

Items können in mehreren Sammlungen gleichzeitig sein, und Benutzer erhalten Zugriff auf Sammlungsebene.

Backups einrichten

Eure Passwörter sind kritische Daten. Ohne Backup seid ihr einen Docker-Crash vom Totalverlust entfernt.

Was muss gesichert werden?

Backup-Script

Erstellt ein Backup-Script:

sudo nano /opt/vaultwarden/backup.sh

Inhalt:

#!/bin/bash
# Vaultwarden Backup Script
# Empfehlung: Täglich per Cron ausführen

BACKUP_DIR="/opt/backups/vaultwarden"
SOURCE_DIR="/opt/vaultwarden"
DATE=$(date +%Y-%m-%d_%H%M)
KEEP_DAYS=30

mkdir -p "$BACKUP_DIR"

# SQLite-Datenbank sicher kopieren (online backup)
sqlite3 "$SOURCE_DIR/data/db.sqlite3" ".backup '$BACKUP_DIR/db_${DATE}.sqlite3'"

# Gesamtes data-Verzeichnis + .env archivieren
tar czf "$BACKUP_DIR/vaultwarden_${DATE}.tar.gz" \
    -C "$SOURCE_DIR" data/ .env docker-compose.yml

# Alte Backups aufräumen
find "$BACKUP_DIR" -name "*.tar.gz" -mtime +$KEEP_DAYS -delete
find "$BACKUP_DIR" -name "db_*.sqlite3" -mtime +$KEEP_DAYS -delete

echo "[$(date)] Backup abgeschlossen: vaultwarden_${DATE}.tar.gz"

sudo chmod +x /opt/vaultwarden/backup.sh

Cron-Job einrichten

# Tägliches Backup um 3:00 Uhr
sudo crontab -e

# Diese Zeile hinzufügen:
0 3 * * * /opt/vaultwarden/backup.sh >> /var/log/vaultwarden-backup.log 2>&1

Offsite-Backup

Ein lokales Backup ist gut, aber nicht genug. Kopiert das Backup regelmäßig auf einen externen Speicher:

# Per rsync auf einen Remote-Server
rsync -avz /opt/backups/vaultwarden/ backup-user@remote-server:/backups/vaultwarden/

# Oder per rclone in die Cloud (verschlüsselt!)
rclone sync /opt/backups/vaultwarden/ remote:vaultwarden-backups --crypt-remote

SMTP für E-Mail-Benachrichtigungen

Ohne E-Mail-Konfiguration funktionieren Einladungen, Passwort-Hinweise und 2FA-E-Mails nicht. Fügt folgende Variablen in eure .env ein:

# SMTP-Konfiguration
SMTP_HOST=smtp.example.com
SMTP_FROM=vault@example.com
SMTP_FROM_NAME=Vaultwarden
SMTP_PORT=587
SMTP_SECURITY=starttls
SMTP_USERNAME=vault@example.com
SMTP_PASSWORD=euer_smtp_passwort

# Optional: Timeout in Sekunden
SMTP_TIMEOUT=15

Beispiele für gängige SMTP-Provider

Gmail (App-Passwort nötig):

SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_SECURITY=starttls
SMTP_USERNAME=euer.name@gmail.com
SMTP_PASSWORD=xxxx_xxxx_xxxx_xxxx

Mailbox.org:

SMTP_HOST=smtp.mailbox.org
SMTP_PORT=465
SMTP_SECURITY=force_tls
SMTP_USERNAME=euer.name@mailbox.org
SMTP_PASSWORD=euer_passwort

eigener Mailserver (Postfix lokal):

SMTP_HOST=localhost
SMTP_PORT=25
SMTP_SECURITY=off
SMTP_USERNAME=
SMTP_PASSWORD=

Nach dem Ändern Container neu starten und im Admin-Panel unter SMTP Email Settings eine Test-Mail senden.

2FA & Security Best Practices

Ein Passwort-Manager ist nur so sicher wie sein Zugang. Hier die wichtigsten Härtungsmaßnahmen:

Zwei-Faktor-Authentifizierung (2FA)

Vaultwarden unterstützt mehrere 2FA-Methoden:

• TOTP (Authenticator App) — Google Authenticator, Aegis, etc. ✅ Empfohlen
• FIDO2 / WebAuthn — YubiKey, Security Key ✅ Beste Option
• E-Mail-Code — Als Fallback (SMTP muss konfiguriert sein)
• Duo Security — Enterprise 2FA-Lösung

2FA aktivieren:

1. Web-Vault → Einstellungen → Sicherheit → Zwei-Faktor-Authentifizierung
2. Methode wählen und einrichten
3. Recovery-Code sichern! Ohne diesen verliert ihr bei Verlust des 2FA-Geräts den Zugang

Security Best Practices

1. Starkes Master-Passwort — Mindestens 14 Zeichen, Passphrase bevorzugt
2. 2FA für alle Benutzer erzwingen — Im Admin-Panel unter Policies
3. Registrierung deaktivieren — SIGNUPS_ALLOWED=false
4. Fail2Ban einrichten — Brute-Force-Schutz für den Login:

   # /etc/fail2ban/filter.d/vaultwarden.conf
   [Definition]
   failregex = ^.*Username or password is incorrect\. Try again\. IP: <HOST>\. Username:.*$
   ignoreregex =
   
   # /etc/fail2ban/jail.d/vaultwarden.local
   [vaultwarden]
   enabled = true
   port = 80,443
   filter = vaultwarden
   action = iptables-allports[name=vaultwarden, chain=FORWARD]
   logpath = /opt/vaultwarden/data/vaultwarden.log
   maxretry = 5
   bantime = 14400
   findtime = 14400

5. Admin-Panel sperren — Zugriff nur von vertrauenswürdigen IPs
6. Regelmäßige Updates — Sicherheitslücken werden schnell gepatcht
7. Firewall — Nur Ports 80 und 443 öffnen, Docker-Port (8080) bleibt auf localhost
8. Log-Level auf warn setzen — In Produktion weniger loggen: LOG_LEVEL=warn

Für Fail2Ban muss das Logging auf eine Datei umgestellt werden. Fügt in die .env ein:

LOG_FILE=/data/vaultwarden.log
USE_SYSLOG=false
LOG_LEVEL=warn

Danach Fail2Ban aktivieren:

sudo apt install fail2ban -y
sudo systemctl enable fail2ban
sudo systemctl restart fail2ban

# Status prüfen
sudo fail2ban-client status vaultwarden

Updates

Vaultwarden wird aktiv weiterentwickelt. Regelmäßige Updates sind wichtig für Sicherheit und neue Features.

Manuelles Update

cd /opt/vaultwarden

# 1. Backup erstellen!
sudo ./backup.sh

# 2. Neues Image herunterladen
sudo docker compose pull

# 3. Container neu starten
sudo docker compose down
sudo docker compose up -d

# 4. Alte Images aufräumen
sudo docker image prune -f

# 5. Prüfen ob alles läuft
sudo docker compose logs -f --tail=50

Automatische Update-Benachrichtigung

Statt automatischer Updates (riskant für einen Passwort-Manager!) empfehle ich eine Benachrichtigung. Erstellt ein Script:

sudo nano /opt/vaultwarden/check-update.sh

#!/bin/bash
# Prüft ob ein neues Vaultwarden-Image verfügbar ist

CURRENT=$(docker inspect --format='{{.Image}}' vaultwarden 2>/dev/null)
docker pull vaultwarden/server:latest -q > /dev/null 2>&1
LATEST=$(docker inspect --format='{{.Id}}' vaultwarden/server:latest 2>/dev/null)

if [ "$CURRENT" != "$LATEST" ]; then
    echo "[$(date)] Neues Vaultwarden-Update verfügbar!"
    # Optional: E-Mail-Benachrichtigung
    # echo "Neues Vaultwarden-Update" | mail -s "Vaultwarden Update" admin@example.com
fi

sudo chmod +x /opt/vaultwarden/check-update.sh

# Wöchentlich prüfen (Sonntag, 10:00 Uhr)
sudo crontab -e
0 10 * * 0 /opt/vaultwarden/check-update.sh >> /var/log/vaultwarden-updates.log 2>&1

Zusammenfassung & Checkliste

Hier eure Checkliste für eine sichere Vaultwarden-Installation:

Troubleshooting

Web-Vault zeigt leere Seite oder Fehler

# Logs prüfen
sudo docker compose logs -f --tail=100

# Häufigste Ursache: DOMAIN-Variable stimmt nicht überein
# Muss exakt mit der URL im Browser übereinstimmen (inkl. https://)

„An error has occurred“ beim Login

• HTTPS nicht korrekt konfiguriert → Zertifikat und Nginx prüfen
• Mixed Content → DOMAIN muss mit https:// beginnen
• X-Forwarded-Proto Header fehlt in der Nginx-Konfiguration

WebSocket-Verbindung fehlgeschlagen

# Prüfen ob der /notifications/hub Endpunkt erreichbar ist
curl -i https://vault.example.com/notifications/hub/negotiate

# Nginx muss Upgrade-Header weiterleiten (siehe Nginx-Konfiguration oben)

E-Mails kommen nicht an

• SMTP-Konfiguration im Admin-Panel prüfen
• Test-Mail über Admin-Panel senden
• Logs auf SMTP-Fehler prüfen: docker compose logs | grep -i smtp
• Firewall: Ist Port 587/465 offen für ausgehende Verbindungen?

Container startet nicht

# Detaillierte Logs
sudo docker compose logs vaultwarden

# Berechtigungen prüfen
ls -la /opt/vaultwarden/data/

# data-Verzeichnis muss für den Container beschreibbar sein
sudo chown -R 1000:1000 /opt/vaultwarden/data/

502 Bad Gateway in Nginx

• Container läuft nicht → docker compose ps
• Port-Mapping falsch → Port 8080 muss erreichbar sein
• upstream in Nginx zeigt auf falschen Port

Datenbank gesperrt (database is locked)

# Tritt auf wenn mehrere Prozesse gleichzeitig auf SQLite zugreifen
# Backup-Script verwendet deshalb sqlite3 .backup

# Prüfen ob WAL-Modus aktiv ist
sqlite3 /opt/vaultwarden/data/db.sqlite3 "PRAGMA journal_mode;"

Nächste Schritte

Euer Vaultwarden läuft — und jetzt? Hier einige Ideen für die Weiterentwicklung:

• Monitoring einrichten — Uptime-Checks mit Uptime Kuma oder Healthchecks.io. Vaultwarden bietet einen Health-Endpunkt unter /alive
• Watchtower für Update-Benachrichtigungen — Automatische Docker-Image-Prüfung (nur Benachrichtigung, kein Auto-Update empfohlen)
• Bitwarden CLI für Automatisierung — Scripted Secret-Management in CI/CD-Pipelines
• YubiKey / Hardware-Token — Die sicherste 2FA-Methode für euren Vault
• Passwort-Migration — Bestehende Passwörter aus Chrome, Firefox, LastPass oder 1Password importieren (Web-Vault → Extras → Daten importieren)
• Notfallzugriff konfigurieren — Vertrauensperson, die im Notfall Zugang erhält

Fragen oder Probleme? Schreibt einen Kommentar — ich helfe gerne!