---
title: Passwort Manager Profice Dokumentation
description: 
published: true
date: 2026-02-23T10:45:42.508Z
tags: 
editor: markdown
dateCreated: 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](#1-überblick-und-architektur)
2. [Vaultwarden – Server-Installation](#2-vaultwarden--server-installation)
3. [Vaultwarden – Konfiguration](#3-vaultwarden--konfiguration)
4. [Reverse Proxy einrichten](#4-reverse-proxy-einrichten)
5. [SSL/TLS-Zertifikat einrichten](#5-ssltls-zertifikat-einrichten)
6. [Admin-Panel](#6-admin-panel)
7. [Benutzerverwaltung](#7-benutzerverwaltung)
8. [Bitwarden-Clients einrichten](#8-bitwarden-clients-einrichten)
9. [Passwörter verwalten](#9-passwörter-verwalten)
10. [Organisationen und geteilte Tresore](#10-organisationen-und-geteilte-tresore)
11. [Datensicherung und Wiederherstellung](#11-datensicherung-und-wiederherstellung)
12. [Sicherheitshärtung](#12-sicherheitshärtung)
13. [Wartung und Updates](#13-wartung-und-updates)
14. [Fehlerbehebung](#14-fehlerbehebung)
15. [Schnellreferenz – Befehle auf einen Blick](#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

```plantuml
@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

```bash
# 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

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

### 2.3 Installation mit Docker Run

```bash
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)

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

```yaml
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:

```bash
# 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:

```bash
cd /opt/vaultwarden
docker compose up -d
```

### 2.5 Installation prüfen

```bash
# 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)

```yaml
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

```bash
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

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

```nginx
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;
    }
}
```

```bash
# 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.

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

```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}
    }
}
```

```bash
sudo systemctl reload caddy
```

---

## 5. SSL/TLS-Zertifikat einrichten

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

```bash
# 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:

```bash
# 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:

```bash
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:

```yaml
# 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)**

```yaml
# 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**

```yaml
- 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](https://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

```bash
# 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 |

4. QR-Code mit einer Authenticator-App scannen (z. B. Aegis, Authy, Google Authenticator)
5. 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 |

4. **Sammlungszugriff** festlegen (welche Sammlungen sichtbar sein sollen)
5. 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

```bash
# 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)

```bash
# 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

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

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

Backup-Skript erstellen:

```bash
sudo nano /opt/vaultwarden/backup.sh
```

```bash
#!/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"
```

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

### 11.5 Wiederherstellung

```bash
# 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 |

3. Master-Passwort eingeben
4. **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:

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

Fail2Ban-Filter erstellen:

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

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

Jail konfigurieren:

```bash
sudo nano /etc/fail2ban/jail.d/vaultwarden.local
```

```ini
[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
```

```bash
sudo systemctl restart fail2ban
sudo fail2ban-client status vaultwarden
```

### 12.3 Firewall (UFW)

```bash
# 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

```bash
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)

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

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

### Backup

```bash
# 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

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

### Bitwarden CLI

```bash
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:** *23.02.2026*
> **Autor:** *Administrator*
> **Version:** 1.0