Ihor_Zhekov/WikiJS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7fcdd36f60e913c50cc434d1786c75c619ef4255
WikiJS/IT_Abteilung/Security/PasswortManager.md

34 KiB
Raw Blame History

title, description, published, date, tags, editor, dateCreated
title description published date tags editor dateCreated
Passwort Manager Profice Dokumentation true 2026-02-23T10:43:41.555Z markdown 2026-02-23T10:43:41.555Z

Vaultwarden & Bitwarden – Vollständige Dokumentation

Serverkomponente: Vaultwarden (selbst gehosteter Bitwarden-kompatibler Server) Clientkomponente: Bitwarden (Desktop, Browser, Mobil) Systemumgebung: Debian-basierter Server (Debian 12 / Ubuntu 22.04+)

Inhaltsverzeichnis

  1. Überblick und Architektur
  2. Vaultwarden – Server-Installation
  3. Vaultwarden – Konfiguration
  4. Reverse Proxy einrichten
  5. SSL/TLS-Zertifikat einrichten
  6. Admin-Panel
  7. Benutzerverwaltung
  8. Bitwarden-Clients einrichten
  9. Passwörter verwalten
  10. Organisationen und geteilte Tresore
  11. Datensicherung und Wiederherstellung
  12. Sicherheitshärtung
  13. Wartung und Updates
  14. Fehlerbehebung
  15. Schnellreferenz – Befehle auf einen Blick

1. Überblick und Architektur

Was ist Vaultwarden?

Vaultwarden (ehemals Bitwarden_RS) ist eine in Rust geschriebene, ressourcenschonende Implementierung der Bitwarden-Server-API. Es bietet nahezu alle Funktionen des offiziellen Bitwarden-Servers, einschließlich Organisationen, Anhänge und TOTP – benötigt aber deutlich weniger Ressourcen und keine separate Datenbank-Infrastruktur.

Was ist Bitwarden?

Bitwarden ist ein quelloffener Passwort-Manager. Die Clients (Desktop, Browser-Erweiterung, Mobil-App) verschlüsseln alle Daten lokal mit AES-256, bevor sie an den Server gesendet werden. Der Server speichert ausschließlich verschlüsselte Daten und hat keinen Zugriff auf die Klartext-Passwörter.

Verschlüsselungsprinzip

Benutzer-Master-Passwort
        │
        ▼
   PBKDF2/Argon2 (Key Derivation)
        │
        ▼
   Verschlüsselungsschlüssel (lokal)
        │
        ├──▶ Verschlüsselte Daten ──▶ Vaultwarden-Server
        │                                    │
        └──▶ Entschlüsselung (lokal)  ◀──── │

Wichtig: Der Server sieht niemals unverschlüsselte Passwörter. Die gesamte Ver- und Entschlüsselung findet im Client statt.

Architektur auf diesem Server

@startuml

skinparam shadowing false
skinparam roundCorner 10

package "Debian Server" {

    [Reverse Proxy\n(Nginx/Caddy)] as proxy
    [Vaultwarden\n(Docker)] as vw
    database "SQLite\n/data/db.sqlite3" as db
    folder "Anhänge\n/data/attachments" as att

    proxy --> vw : HTTPS
    vw --> db : Lesen/Schreiben
    vw --> att : Dateien
}

cloud "Bitwarden-Clients" {
    [Desktop-App] as desktop
    [Browser-Extension] as browser
    [Mobile App] as mobile
    [CLI] as cli
}

desktop --> proxy : HTTPS
browser --> proxy : HTTPS
mobile --> proxy : HTTPS
cli --> proxy : HTTPS

@enduml

Systemvoraussetzungen

Komponente Minimum Empfohlen
RAM 256 MB 512 MB
CPU 1 Kern 2 Kerne
Speicherplatz 1 GB 5 GB (mit Anhängen)
Docker 20.10+ Aktuelle Version
Domain mit SSL Erforderlich Erforderlich

2. Vaultwarden – Server-Installation

2.1 Voraussetzungen installieren

# System aktualisieren
sudo apt update && sudo apt upgrade -y

# Docker installieren (falls nicht vorhanden)
curl -fsSL https://get.docker.com | sudo sh

# Docker-Dienst aktivieren
sudo systemctl enable docker
sudo systemctl start docker

# Aktuellen Benutzer zur Docker-Gruppe hinzufügen
sudo usermod -aG docker $USER
# Danach neu einloggen oder: newgrp docker

2.2 Verzeichnisstruktur anlegen

# Datenverzeichnis erstellen
sudo mkdir -p /opt/vaultwarden/data
sudo chown -R 1000:1000 /opt/vaultwarden

2.3 Installation mit Docker Run

docker run -d \
  --name vaultwarden \
  --restart unless-stopped \
  -e DOMAIN=https://vault.example.de \
  -v /opt/vaultwarden/data:/data \
  -p 127.0.0.1:8080:80 \
  vaultwarden/server:latest

Hinweis: Der Port wird nur auf 127.0.0.1 gebunden, damit kein direkter Zugriff von außen möglich ist. Der Zugriff erfolgt über den Reverse Proxy.

2.4 Installation mit Docker Compose (empfohlen)

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

version: "3.8"

services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    environment:
      - DOMAIN=https://vault.example.de
      - SIGNUPS_ALLOWED=false
      - INVITATIONS_ALLOWED=true
      - ADMIN_TOKEN=${ADMIN_TOKEN}
      - LOG_FILE=/data/vaultwarden.log
      - LOG_LEVEL=info
      - TZ=Europe/Berlin
    volumes:
      - /opt/vaultwarden/data:/data
    ports:
      - "127.0.0.1:8080:80"
      - "127.0.0.1:3012:3012"  # WebSocket für Live-Sync

Admin-Token sicher generieren und in .env-Datei speichern:

# Sicheren Admin-Token generieren
openssl rand -base64 48 > /opt/vaultwarden/.admin_token

# .env-Datei erstellen
echo "ADMIN_TOKEN=$(cat /opt/vaultwarden/.admin_token)" > /opt/vaultwarden/.env

# Berechtigungen einschränken
chmod 600 /opt/vaultwarden/.env /opt/vaultwarden/.admin_token

Container starten:

cd /opt/vaultwarden
docker compose up -d

2.5 Installation prüfen

# Container-Status prüfen
docker ps | grep vaultwarden

# Logs prüfen
docker logs vaultwarden --tail 50

# Erreichbarkeit testen (lokal)
curl -s http://127.0.0.1:8080/alive
# Erwartete Antwort: leer (HTTP 200)

3. Vaultwarden – Konfiguration

3.1 Alle Umgebungsvariablen

Die Konfiguration erfolgt über Umgebungsvariablen in docker-compose.yml oder der .env-Datei.

Grundeinstellungen

Variable Beschreibung Empfohlener Wert
DOMAIN Öffentliche URL des Servers https://vault.example.de
TZ Zeitzone Europe/Berlin
LOG_FILE Pfad zur Logdatei /data/vaultwarden.log
LOG_LEVEL Log-Detailgrad info
ROCKET_PORT Interner Port 80 (Standard)

Registrierung und Einladungen

Variable Beschreibung Empfohlener Wert
SIGNUPS_ALLOWED Offene Registrierung erlauben false
INVITATIONS_ALLOWED Einladungen per E-Mail erlauben true
SIGNUPS_DOMAINS_WHITELIST Nur bestimmte E-Mail-Domains example.de,firma.de
SIGNUPS_VERIFY E-Mail-Verifizierung erzwingen true

Admin-Panel

Variable Beschreibung Empfohlener Wert
ADMIN_TOKEN Passwort für das Admin-Panel Langer zufälliger String
DISABLE_ADMIN_TOKEN Admin-Panel deaktivieren false

E-Mail (SMTP)

Variable Beschreibung Beispiel
SMTP_HOST SMTP-Server smtp.example.de
SMTP_PORT SMTP-Port 587
SMTP_FROM Absenderadresse vault@example.de
SMTP_FROM_NAME Absendername Vaultwarden
SMTP_SECURITY Verschlüsselung starttls
SMTP_USERNAME SMTP-Benutzername vault@example.de
SMTP_PASSWORD SMTP-Passwort geheim

WebSocket (Live-Sync)

Variable Beschreibung Empfohlener Wert
WEBSOCKET_ENABLED WebSocket für Echtzeit-Sync true
WEBSOCKET_PORT WebSocket-Port 3012

Sicherheit

Variable Beschreibung Empfohlener Wert
PASSWORD_HINTS_ALLOWED Passwort-Hinweise erlauben false
SHOW_PASSWORD_HINT Hinweise auf der Login-Seite false
SENDS_ALLOWED Bitwarden Send-Funktion true
EMERGENCY_ACCESS_ALLOWED Notfallzugriff true
ORG_CREATION_USERS Wer darf Organisationen erstellen admin@example.de

3.2 Vollständige docker-compose.yml (Produktiv)

version: "3.8"

services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    environment:
      # Grundeinstellungen
      - DOMAIN=https://vault.example.de
      - TZ=Europe/Berlin
      - LOG_FILE=/data/vaultwarden.log
      - LOG_LEVEL=info

      # Registrierung
      - SIGNUPS_ALLOWED=false
      - INVITATIONS_ALLOWED=true
      - SIGNUPS_VERIFY=true

      # Admin
      - ADMIN_TOKEN=${ADMIN_TOKEN}

      # E-Mail
      - SMTP_HOST=smtp.example.de
      - SMTP_PORT=587
      - SMTP_FROM=vault@example.de
      - SMTP_FROM_NAME=Vaultwarden
      - SMTP_SECURITY=starttls
      - SMTP_USERNAME=vault@example.de
      - SMTP_PASSWORD=${SMTP_PASSWORD}

      # WebSocket
      - WEBSOCKET_ENABLED=true
      - WEBSOCKET_PORT=3012

      # Sicherheit
      - PASSWORD_HINTS_ALLOWED=false
      - SHOW_PASSWORD_HINT=false
      - SENDS_ALLOWED=true
      - EMERGENCY_ACCESS_ALLOWED=true
      - ORG_CREATION_USERS=admin@example.de
    volumes:
      - /opt/vaultwarden/data:/data
    ports:
      - "127.0.0.1:8080:80"
      - "127.0.0.1:3012:3012"

3.3 Konfigurationsänderungen anwenden

cd /opt/vaultwarden

# Container mit neuer Konfiguration neu erstellen
docker compose down
docker compose up -d

# Prüfen, ob der Container läuft
docker ps | grep vaultwarden

4. Reverse Proxy einrichten

Vaultwarden benötigt HTTPS. Ein Reverse Proxy leitet die Anfragen vom Internet an den Docker-Container weiter.

4.1 Variante A: Nginx

sudo apt install -y nginx
sudo nano /etc/nginx/sites-available/vaultwarden

upstream vaultwarden {
    server 127.0.0.1:8080;
}

upstream vaultwarden-ws {
    server 127.0.0.1:3012;
}

server {
    listen 80;
    server_name vault.example.de;

    # Weiterleitung auf HTTPS
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name vault.example.de;

    # SSL-Zertifikate (siehe Abschnitt 5)
    ssl_certificate /etc/letsencrypt/live/vault.example.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/vault.example.de/privkey.pem;

    # Sicherheitsheader
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-XSS-Protection "1; mode=block" always;

    # Maximale Upload-Größe (für Anhänge)
    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 für Live-Sync
    location /notifications/hub {
        proxy_pass http://vaultwarden-ws;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    # Admin-Bereich – optional: IP-Beschränkung
    location /admin {
        # Nur aus dem internen Netzwerk erreichbar
        # allow 192.168.1.0/24;
        # 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;
    }
}

# Konfiguration aktivieren
sudo ln -sf /etc/nginx/sites-available/vaultwarden /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

4.2 Variante B: Caddy (einfacher)

Caddy generiert und erneuert SSL-Zertifikate automatisch.

sudo apt install -y caddy
sudo nano /etc/caddy/Caddyfile

vault.example.de {
    # Maximale Upload-Größe
    request_body {
        max_size 525MB
    }

    # Sicherheitsheader
    header {
        Strict-Transport-Security "max-age=63072000; includeSubDomains"
        X-Content-Type-Options "nosniff"
        X-Frame-Options "SAMEORIGIN"
    }

    # WebSocket
    reverse_proxy /notifications/hub 127.0.0.1:3012

    # Hauptanwendung
    reverse_proxy 127.0.0.1:8080 {
        header_up X-Real-IP {remote_host}
    }
}

sudo systemctl reload caddy

5. SSL/TLS-Zertifikat einrichten

5.1 Let's Encrypt mit Certbot (für Nginx)

# Certbot installieren
sudo apt install -y certbot python3-certbot-nginx

# Zertifikat anfordern
sudo certbot --nginx -d vault.example.de

# Automatische Erneuerung testen
sudo certbot renew --dry-run

Die automatische Erneuerung wird durch einen Systemd-Timer verwaltet:

# Status prüfen
sudo systemctl status certbot.timer

5.2 Let's Encrypt mit Caddy

Bei Caddy ist keine manuelle SSL-Konfiguration nötig. Caddy fordert automatisch ein Let's Encrypt-Zertifikat an und erneuert es selbständig.

5.3 Selbstsigniertes Zertifikat (nur intern)

Falls kein öffentlicher Zugriff nötig ist:

sudo mkdir -p /etc/ssl/vaultwarden

sudo openssl req -x509 -nodes -days 3650 \
  -newkey rsa:4096 \
  -keyout /etc/ssl/vaultwarden/privkey.pem \
  -out /etc/ssl/vaultwarden/fullchain.pem \
  -subj "/CN=vault.example.de"

Wichtig: Bei selbstsignierten Zertifikaten muss das Zertifikat auf allen Clients als vertrauenswürdig importiert werden.

6. Admin-Panel

6.1 Zugriff

Das Admin-Panel ist erreichbar unter:

https://vault.example.de/admin

Anmeldung mit dem ADMIN_TOKEN aus der Konfiguration.

6.2 Funktionen des Admin-Panels

Bereich Möglichkeiten
Benutzer Alle Benutzer anzeigen, einladen, deaktivieren, löschen
Organisationen Organisationen einsehen und verwalten
Einstellungen Laufzeitkonfiguration ändern (überschreibt Umgebungsvariablen)
Diagnose Serverinformationen, Datenbankgröße, Version

6.3 Benutzer einladen (über Admin-Panel)

  1. Admin-Panel öffnen → Reiter Benutzer
  2. E-Mail-Adresse eingeben
  3. Einladen klicken
  4. Der Benutzer erhält eine E-Mail mit einem Registrierungslink

Hinweis: Für E-Mail-Einladungen muss SMTP konfiguriert sein (siehe Abschnitt 3.1).

6.4 Admin-Panel absichern

Empfohlene Maßnahmen:

  • IP-Beschränkung im Reverse Proxy (siehe Abschnitt 4.1, /admin-Block)
  • Starken Admin-Token verwenden (mindestens 48 Zeichen)
  • Admin-Panel nach der Ersteinrichtung optional deaktivieren:
# In docker-compose.yml
- DISABLE_ADMIN_TOKEN=true

7. Benutzerverwaltung

7.1 Neuen Benutzer anlegen

Methode 1: Einladung per E-Mail (empfohlen)

  1. Admin-Panel → Benutzer → E-Mail eingeben → Einladen
  2. Benutzer klickt den Link in der E-Mail
  3. Benutzer erstellt sein Konto mit Master-Passwort

Methode 2: Offene Registrierung (temporär)

# Temporär in docker-compose.yml aktivieren
- SIGNUPS_ALLOWED=true

Nach der Registrierung wieder auf false setzen und Container neu starten.

Methode 3: Domain-beschränkte Registrierung

- SIGNUPS_ALLOWED=true
- SIGNUPS_DOMAINS_WHITELIST=example.de,firma.de

7.2 Benutzer deaktivieren oder löschen

Über das Admin-Panel:

  1. Benutzer → gewünschten Benutzer finden
  2. Deaktivieren: Benutzer kann sich nicht mehr anmelden, Daten bleiben erhalten
  3. Löschen: Benutzer und alle zugehörigen Daten werden permanent entfernt

Vorsicht: Das Löschen eines Benutzers ist unwiderruflich. Alle Tresordaten dieses Benutzers gehen verloren.

7.3 Master-Passwort

Das Master-Passwort wird vom Benutzer selbst im Client festgelegt. Es gibt keine Möglichkeit, das Master-Passwort serverseitig einzusehen oder zurückzusetzen. Bei einem vergessenen Master-Passwort muss das Konto gelöscht und neu erstellt werden (alle Daten gehen verloren).

Empfehlungen für das Master-Passwort:

  • Mindestens 14 Zeichen
  • Kombination aus Groß-/Kleinbuchstaben, Zahlen und Sonderzeichen
  • Alternativ: Lange Passphrase (z. B. 4+ zufällige Wörter)
  • Nirgendwo anders verwenden
  • Optional auf Papier notieren und sicher aufbewahren

8. Bitwarden-Clients einrichten

8.1 Verfügbare Clients

Client Plattform Download
Desktop-App Windows, macOS, Linux bitwarden.com/download
Browser-Erweiterung Chrome, Firefox, Edge, Safari Jeweiliger Extension-Store
Mobile App Android, iOS App Store / Google Play
CLI Alle Plattformen npm install -g @bitwarden/cli
Web-Tresor Browser https://vault.example.de (die eigene Instanz)

8.2 Client mit eigenem Server verbinden

Alle Bitwarden-Clients verwenden standardmäßig die offiziellen Bitwarden-Server. Für die Verbindung zum eigenen Vaultwarden-Server muss die Server-URL geändert werden.

Desktop-App

  1. Bitwarden Desktop-App öffnen
  2. Auf dem Anmeldebildschirm auf Einloggen klicken
  3. Auf das Zahnrad-Symbol (Einstellungen) oder „Selbst gehostet" klicken
  4. Unter Server-URL die eigene Domain eintragen: 
    https://vault.example.de
  5. Speichern klicken
  6. Mit E-Mail und Master-Passwort anmelden

Browser-Erweiterung

  1. Bitwarden-Erweiterung installieren
  2. Auf das Bitwarden-Symbol klicken
  3. Auf dem Anmeldebildschirm auf das Zahnrad-Symbol klicken
  4. Unter Server-URL eingeben: 
    https://vault.example.de
  5. Speichern und anmelden

Mobile App

  1. Bitwarden-App aus dem Store installieren
  2. Auf dem Anmeldebildschirm auf „Selbst gehostet" oder das Zahnrad-Symbol tippen
  3. Server-URL eintragen: 
    https://vault.example.de
  4. Speichern und anmelden

CLI

# Server-URL setzen
bw config server https://vault.example.de

# Anmelden
bw login benutzer@example.de

# Tresor entsperren (nach Anmeldung)
bw unlock

# Status prüfen
bw status

8.3 Zwei-Faktor-Authentifizierung (2FA) einrichten

Dringend empfohlen für alle Benutzer:

  1. Im Web-Tresor oder der Desktop-App anmelden
  2. Einstellungen → Sicherheit → Zwei-Faktor-Authentifizierung
  3. Methode wählen:
Methode Sicherheit Empfehlung
TOTP-App (Authenticator) Hoch Empfohlen
E-Mail Mittel Fallback
YubiKey / FIDO2 Sehr hoch Ideal für Admins
  1. QR-Code mit einer Authenticator-App scannen (z. B. Aegis, Authy, Google Authenticator)
  2. Wiederherstellungscode sicher aufbewahren

Wichtig: Den Wiederherstellungscode an einem sicheren Ort aufbewahren (z. B. ausgedruckt in einem Tresor). Ohne diesen Code und ohne 2FA-Gerät ist der Zugriff auf den Tresor nicht mehr möglich.

9. Passwörter verwalten

9.1 Tresoreinträge – Typen

Bitwarden unterstützt vier Eintragstypen:

Typ Beschreibung Beispiel
Anmeldung Benutzername + Passwort + URL Webseiten-Logins
Karte Kreditkartendaten Visa, Mastercard
Identität Persönliche Daten Name, Adresse, Telefon
Sichere Notiz Freitextfeld (verschlüsselt) Lizenzen, PINs, Notizen

9.2 Neuen Eintrag erstellen

  1. Im Client auf „+" oder „Neuer Eintrag" klicken
  2. Typ auswählen (z. B. Anmeldung)
  3. Felder ausfüllen:
    • Name: Bezeichnung des Eintrags
    • Benutzername: Login-Name oder E-Mail
    • Passwort: Manuell eingeben oder Generator nutzen
    • URI: Webseiten-URL (für Autofill)
    • Notizen: Zusätzliche Informationen
  4. Optional: Ordner zuweisen
  5. Speichern

9.3 Passwort-Generator

Der integrierte Passwort-Generator erstellt sichere Passwörter:

Einstellung Empfohlener Wert
Typ Passwort oder Passphrase
Länge (Passwort) Mindestens 20 Zeichen
Großbuchstaben ✅
Kleinbuchstaben ✅
Zahlen ✅
Sonderzeichen ✅
Wörter (Passphrase) Mindestens 4 Wörter

9.4 Autofill (automatisches Ausfüllen)

Die Browser-Erweiterung kann Login-Felder automatisch ausfüllen:

  1. Webseite mit gespeichertem Login öffnen
  2. Bitwarden-Symbol in der Symbolleiste klicken
  3. Passenden Eintrag auswählen → Felder werden ausgefüllt

Tastenkombination (Standard):

  • Windows/Linux: Strg + Shift + L
  • macOS: Cmd + Shift + L

9.5 Ordner und Sammlungen

Konzept Sichtbarkeit Verwendung
Ordner Nur für den eigenen Tresor Persönliche Organisation
Sammlungen Innerhalb einer Organisation geteilt Team-Passwörter

9.6 Bitwarden Send

Bitwarden Send ermöglicht das sichere Teilen von Texten oder Dateien:

  1. Send → Neuer Send
  2. Text oder Datei hinzufügen
  3. Optionen:
    • Ablaufdatum setzen
    • Maximale Zugriffe begrenzen
    • Passwort für den Send festlegen
    • Selbstzerstörung nach Ablauf
  4. Link wird generiert und kann geteilt werden

10. Organisationen und geteilte Tresore

10.1 Organisation erstellen

Organisationen ermöglichen das Teilen von Passwörtern im Team.

  1. Web-Tresor öffnen (https://vault.example.de)
  2. Neue Organisation → Name und E-Mail eingeben
  3. Organisation wird erstellt

Hinweis: In Vaultwarden ist die Anzahl der Organisationen und Mitglieder nicht beschränkt.

10.2 Mitglieder einladen

  1. Organisation → Mitglieder → Einladen
  2. E-Mail-Adresse eingeben
  3. Rolle zuweisen:
Rolle Rechte
Benutzer Kann zugewiesene Sammlungen sehen und nutzen
Manager Kann Sammlungen verwalten und Benutzer zuweisen
Admin Volle Verwaltungsrechte der Organisation
Eigentümer Alles, einschließlich Löschen der Organisation
  1. Sammlungszugriff festlegen (welche Sammlungen sichtbar sein sollen)
  2. Einladung senden

10.3 Sammlungen erstellen und verwalten

Sammlungen sind Gruppen von Einträgen innerhalb einer Organisation.

Beispielstruktur:

Organisation: "Firma GmbH"
├── Sammlung: "Allgemein"           → Alle Mitarbeiter
├── Sammlung: "Entwicklung"         → Entwickler-Team
├── Sammlung: "Server & Infrastruktur" → Admins
└── Sammlung: "Social Media"        → Marketing-Team
  1. Organisation → Sammlungen → Neue Sammlung
  2. Name vergeben
  3. Zugriffsberechtigungen setzen (welche Benutzer/Gruppen)

10.4 Einträge mit der Organisation teilen

  1. Eintrag öffnen → Bearbeiten
  2. Eigentum → Organisation auswählen
  3. Sammlungen auswählen, in denen der Eintrag erscheinen soll
  4. Speichern

Wichtig: Einmal an eine Organisation übertragene Einträge gehören der Organisation und nicht mehr dem Benutzer.

11. Datensicherung und Wiederherstellung

11.1 Was wird gesichert?

Datei/Verzeichnis Inhalt Wichtigkeit
/opt/vaultwarden/data/db.sqlite3 Alle Benutzer, Einträge, Organisationen Kritisch
/opt/vaultwarden/data/attachments/ Dateianhänge Hoch
/opt/vaultwarden/data/sends/ Bitwarden-Send-Dateien Mittel
/opt/vaultwarden/data/config.json Admin-Panel-Konfiguration Mittel
/opt/vaultwarden/data/rsa_key* RSA-Schlüsselpaar Kritisch
/opt/vaultwarden/docker-compose.yml Container-Konfiguration Hoch
/opt/vaultwarden/.env Umgebungsvariablen Hoch

Wichtig: Die rsa_key-Dateien sind für die Authentifizierung zwingend erforderlich. Ohne sie können sich Benutzer nicht mehr anmelden.

11.2 Manuelles Backup

# Vaultwarden stoppen (für konsistentes Backup)
cd /opt/vaultwarden
docker compose stop

# Backup erstellen
BACKUP_DIR="/backup/vaultwarden"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

mkdir -p "$BACKUP_DIR"

# Gesamtes Datenverzeichnis sichern
tar -czf "$BACKUP_DIR/vaultwarden_${TIMESTAMP}.tar.gz" \
  -C /opt/vaultwarden \
  data/ docker-compose.yml .env

# Vaultwarden wieder starten
docker compose start

echo "Backup erstellt: $BACKUP_DIR/vaultwarden_${TIMESTAMP}.tar.gz"

11.3 SQLite-Datenbank separat sichern (ohne Stopp)

# Online-Backup der SQLite-Datenbank (kein Stopp nötig)
sqlite3 /opt/vaultwarden/data/db.sqlite3 ".backup '/backup/vaultwarden/db_$(date +%Y%m%d).sqlite3'"

Hinweis: sqlite3 muss installiert sein (sudo apt install -y sqlite3).

11.4 Automatisches Backup per Cronjob

sudo nano /etc/cron.d/vaultwarden-backup

# Tägliches Backup um 03:00 Uhr
0 3 * * * root /opt/vaultwarden/backup.sh >> /var/log/vaultwarden-backup.log 2>&1

Backup-Skript erstellen:

sudo nano /opt/vaultwarden/backup.sh

#!/bin/bash
set -e

BACKUP_DIR="/backup/vaultwarden"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
KEEP_DAYS=30

mkdir -p "$BACKUP_DIR"

# SQLite Online-Backup
sqlite3 /opt/vaultwarden/data/db.sqlite3 \
  ".backup '${BACKUP_DIR}/db_${TIMESTAMP}.sqlite3'"

# Anhänge und Konfiguration sichern
tar -czf "${BACKUP_DIR}/files_${TIMESTAMP}.tar.gz" \
  -C /opt/vaultwarden \
  data/attachments/ data/sends/ data/config.json data/rsa_key* \
  docker-compose.yml .env 2>/dev/null || true

# Alte Backups löschen
find "$BACKUP_DIR" -name "*.sqlite3" -mtime +$KEEP_DAYS -delete
find "$BACKUP_DIR" -name "*.tar.gz" -mtime +$KEEP_DAYS -delete

echo "[$(date)] Backup erfolgreich: db_${TIMESTAMP}.sqlite3"

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

11.5 Wiederherstellung

# Container stoppen
cd /opt/vaultwarden
docker compose down

# Daten aus Backup wiederherstellen
tar -xzf /backup/vaultwarden/vaultwarden_20240101_030000.tar.gz \
  -C /opt/vaultwarden/

# Oder nur die Datenbank
cp /backup/vaultwarden/db_20240101.sqlite3 \
   /opt/vaultwarden/data/db.sqlite3

# Berechtigungen setzen
sudo chown -R 1000:1000 /opt/vaultwarden/data

# Container starten
docker compose up -d

11.6 Client-seitiger Export (Tresor-Export)

Jeder Benutzer kann seinen Tresor exportieren:

  1. Einstellungen → Tresor exportieren
  2. Format wählen:
Format Beschreibung Sicherheit
.json Klartext-JSON Unverschlüsselt – nur temporär nutzen
.csv Kommagetrennt Unverschlüsselt – nur für Import in andere Systeme
.json (verschlüsselt) Verschlüsselt mit dem Kontoschlüssel Empfohlen – nur in Bitwarden wiederherstellbar
  1. Master-Passwort eingeben
  2. Exportieren

Warnung: Unverschlüsselte Exporte enthalten alle Passwörter im Klartext. Diese Dateien nach dem Import sofort sicher löschen.

12. Sicherheitshärtung

12.1 Checkliste

  • Offene Registrierung deaktivieren (SIGNUPS_ALLOWED=false)
  • Starken Admin-Token setzen (mindestens 48 Zeichen, zufällig generiert)
  • HTTPS erzwingen (SSL/TLS über Reverse Proxy)
  • Passwort-Hinweise deaktivieren (PASSWORD_HINTS_ALLOWED=false)
  • 2FA für alle Benutzer aktivieren (mindestens TOTP)
  • Admin-Panel per IP beschränken (Nginx-Konfiguration)
  • SMTP konfigurieren (für Einladungen und E-Mail-Verifizierung)
  • Regelmäßige Backups konfiguriert und getestet
  • Vaultwarden aktuell halten (Docker-Image regelmäßig aktualisieren)
  • Fail2Ban einrichten (Brute-Force-Schutz)
  • Firewall konfigurieren (nur Port 443 öffentlich)

12.2 Fail2Ban für Vaultwarden

Fail2Ban schützt vor Brute-Force-Angriffen auf die Login-Seite.

Vaultwarden-Logging aktivieren:

# In docker-compose.yml hinzufügen
- LOG_FILE=/data/vaultwarden.log
- LOG_LEVEL=warn

Fail2Ban-Filter erstellen:

sudo nano /etc/fail2ban/filter.d/vaultwarden.conf

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

Jail konfigurieren:

sudo nano /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 = 3600
findtime = 600

sudo systemctl restart fail2ban
sudo fail2ban-client status vaultwarden

12.3 Firewall (UFW)

# UFW installieren und aktivieren
sudo apt install -y ufw

# Standard: Alles blockieren
sudo ufw default deny incoming
sudo ufw default allow outgoing

# SSH erlauben
sudo ufw allow ssh

# HTTPS erlauben
sudo ufw allow 443/tcp

# HTTP erlauben (für Let's Encrypt Redirect)
sudo ufw allow 80/tcp

# Firewall aktivieren
sudo ufw enable
sudo ufw status verbose

13. Wartung und Updates

13.1 Vaultwarden aktualisieren

cd /opt/vaultwarden

# Aktuelles Image herunterladen
docker compose pull

# Container mit neuem Image neu erstellen
docker compose up -d

# Altes Image aufräumen
docker image prune -f

# Version prüfen
docker logs vaultwarden 2>&1 | head -5

13.2 Automatische Update-Benachrichtigung

Vaultwarden prüft automatisch auf neue Versionen. Im Admin-Panel wird ein Hinweis angezeigt, wenn eine neue Version verfügbar ist.

13.3 Datenbankwartung (SQLite)

# Datenbankgröße prüfen
ls -lh /opt/vaultwarden/data/db.sqlite3

# Datenbank optimieren (VACUUM)
sqlite3 /opt/vaultwarden/data/db.sqlite3 "VACUUM;"

# Integrität prüfen
sqlite3 /opt/vaultwarden/data/db.sqlite3 "PRAGMA integrity_check;"
# Erwartete Ausgabe: ok

13.4 Logdateien verwalten

# Aktuelle Logs anzeigen
docker logs vaultwarden --tail 100

# Logdatei prüfen (falls konfiguriert)
tail -50 /opt/vaultwarden/data/vaultwarden.log

# Logdatei rotieren (logrotate)
sudo nano /etc/logrotate.d/vaultwarden

/opt/vaultwarden/data/vaultwarden.log {
    daily
    rotate 14
    compress
    delaycompress
    missingok
    notifempty
    copytruncate
}

13.5 Docker-System aufräumen

# Ungenutzte Images entfernen
docker image prune -af

# Ungenutzte Volumes entfernen (Vorsicht!)
docker volume prune -f

# Gesamten ungenutzten Docker-Speicher freigeben
docker system prune -af

14. Fehlerbehebung

14.1 Vaultwarden startet nicht

# Container-Status prüfen
docker ps -a | grep vaultwarden

# Logs anzeigen
docker logs vaultwarden --tail 100

# Container manuell starten (interaktiv für Fehlerausgabe)
docker compose down
docker compose up  # ohne -d, um Ausgabe zu sehen

Häufige Ursachen:

  • Port bereits belegt: sudo ss -tlnp | grep 8080
  • Berechtigungsfehler: sudo chown -R 1000:1000 /opt/vaultwarden/data
  • Ungültiger Admin-Token: Sonderzeichen in .env müssen escaped werden

14.2 Client kann sich nicht verbinden

Problem Lösung
„Server nicht erreichbar" Server-URL prüfen, HTTPS sicherstellen
SSL-Fehler Zertifikat prüfen, bei selbstsigniert: Zertifikat importieren
„Ungültiges Passwort" Groß-/Kleinschreibung prüfen, Caps Lock
„Konto existiert nicht" Benutzer wurde evtl. auf dem Server gelöscht
Sync funktioniert nicht WebSocket-Konfiguration prüfen (Port 3012)

14.3 WebSocket / Live-Sync funktioniert nicht

# WebSocket-Port prüfen
curl -i http://127.0.0.1:3012

# In docker-compose.yml sicherstellen:
# - WEBSOCKET_ENABLED=true
# - Port 3012 ist gemappt

# Reverse Proxy: /notifications/hub muss korrekt weitergeleitet werden

14.4 E-Mail-Versand funktioniert nicht

# Im Admin-Panel → Diagnose → „Test-E-Mail senden" nutzen

# SMTP-Konfiguration prüfen
docker logs vaultwarden 2>&1 | grep -i "smtp\|mail\|email"

# Häufige SMTP-Probleme:
# - Port 465 benötigt SMTP_SECURITY=force_tls
# - Port 587 benötigt SMTP_SECURITY=starttls
# - App-Passwort nötig (z.B. bei Gmail, Outlook)

14.5 Datenbank beschädigt

# Integrität prüfen
sqlite3 /opt/vaultwarden/data/db.sqlite3 "PRAGMA integrity_check;"

# Bei Beschädigung: Aus Backup wiederherstellen
docker compose down
cp /backup/vaultwarden/db_YYYYMMDD.sqlite3 /opt/vaultwarden/data/db.sqlite3
sudo chown 1000:1000 /opt/vaultwarden/data/db.sqlite3
docker compose up -d

14.6 Container-Ressourcen prüfen

# CPU- und RAM-Nutzung
docker stats vaultwarden --no-stream

# Speicherplatz
du -sh /opt/vaultwarden/data/
du -sh /opt/vaultwarden/data/db.sqlite3
du -sh /opt/vaultwarden/data/attachments/

15. Schnellreferenz – Befehle auf einen Blick

Docker-Befehle

# Container starten
cd /opt/vaultwarden && docker compose up -d

# Container stoppen
docker compose down

# Container neu starten
docker compose restart

# Logs anzeigen
docker logs vaultwarden --tail 50 -f

# Container-Status
docker ps | grep vaultwarden

# In den Container wechseln (Debugging)
docker exec -it vaultwarden /bin/sh

Update-Prozess

cd /opt/vaultwarden
docker compose pull
docker compose up -d
docker image prune -f

Backup

# Schnelles Datenbank-Backup (online)
sqlite3 /opt/vaultwarden/data/db.sqlite3 ".backup '/backup/vw_$(date +%Y%m%d).db'"

# Vollbackup
docker compose stop
tar -czf /backup/vw_full_$(date +%Y%m%d).tar.gz -C /opt/vaultwarden data/ docker-compose.yml .env
docker compose start

SQLite-Wartung

sqlite3 /opt/vaultwarden/data/db.sqlite3 "VACUUM;"
sqlite3 /opt/vaultwarden/data/db.sqlite3 "PRAGMA integrity_check;"

Bitwarden CLI

bw config server https://vault.example.de    # Server setzen
bw login benutzer@example.de                  # Anmelden
bw unlock                                      # Tresor entsperren
bw sync                                        # Manuell synchronisieren
bw list items --search "github"               # Einträge suchen
bw get password "GitHub"                       # Passwort abrufen
bw generate -ulns --length 24                 # Passwort generieren
bw export --format json                        # Tresor exportieren

Wichtige URLs

Web-Tresor:   https://vault.example.de
Admin-Panel:  https://vault.example.de/admin
API:          https://vault.example.de/api
WebSocket:    wss://vault.example.de/notifications/hub

Wichtige Dateipfade

/opt/vaultwarden/
├── docker-compose.yml        # Container-Konfiguration
├── .env                      # Umgebungsvariablen (Secrets)
└── data/
    ├── db.sqlite3            # Datenbank (alle Tresordaten)
    ├── rsa_key.pem           # RSA-Schlüssel (Authentifizierung)
    ├── rsa_key.pub.pem       # RSA Public Key
    ├── config.json           # Admin-Panel-Konfiguration
    ├── vaultwarden.log       # Logdatei
    ├── attachments/          # Dateianhänge
    ├── sends/                # Bitwarden Send-Dateien
    └── icon_cache/           # Favicon-Cache

Letzte Aktualisierung: Datum hier eintragen Autor: Name hier eintragen Version: 1.0

Reference in New Issue View Git Blame Copy Permalink