From 07a30e0204f07b0424c0bb898bbdba985d6ed190 Mon Sep 17 00:00:00 2001
From: Thomas Dannenberg <kontakt@bratonien.de>
Date: Wed, 20 Aug 2025 09:34:22 +0000
Subject: [PATCH] Kapitel 6/Tutorial.md aktualisiert

---
 Kapitel 6/Tutorial.md | 269 ++++++++++++++++++++++++++++++------------
 1 file changed, 194 insertions(+), 75 deletions(-)

diff --git a/Kapitel 6/Tutorial.md b/Kapitel 6/Tutorial.md
index 78c67f7..3925f2c 100644
--- a/Kapitel 6/Tutorial.md	
+++ b/Kapitel 6/Tutorial.md	
@@ -1,104 +1,179 @@
-🛠️ Kapitel 6 – Vaultwarden (ohne Docker, systemd) – Tutorial
-Ein Weg, ohne Alternativen. Niveau: wie Readme dieses Kapitels.
+📝 Kapitel 6 – Vaultwarden (ohne Docker, systemd)
 
-——————————
-Ziel
-Vaultwarden als native Binary im Debian‑12‑LXC per systemd betreiben und hinter dem Nginx Proxy Manager veröffentlichen (HTTPS + WebSockets). Öffentliche Registrierung aus, Admin‑Token gesetzt, optional SMTP, Basis‑Backup.
+> **Blog‑Stil, Laienfreundlich, ein Weg ohne Alternativen.**
+> Du führst die Befehle **genau so** aus und ersetzt nur die Platzhalter. Nach jedem Block steht, **warum** du das machst und **woran** du erkennst, dass es geklappt hat.
 
-Voraussetzungen
+---
 
-* LXC: Debian 12 (Bookworm), root
-* NPM in separatem LXC vorhanden (Domain + Let’s Encrypt)
-* LXC‑IP von Vaultwarden: \<VW\_IP> (z. B. 10.0.0.16)
+## 🎯 Was wir bauen (in Klartext)
 
-Kerneinstellungen (fix)
+Wir richten **Vaultwarden** als Passwort‑Tresor ein. Das ist die kompatible Server‑Variante zu Bitwarden. Du bekommst:
 
-* **ROCKET\_ADDRESS = \<VW\_IP>** (weil NPM in separatem LXC läuft)
-* **ROCKET\_PORT = 8000**
-* **WEBSOCKET\_ADDRESS = \<VW\_IP>**, **WEBSOCKET\_PORT = 3012**
-* **DOMAIN = [https://pass.DEINE‑DOMAIN.tld](https://pass.DEINE‑DOMAIN.tld)**
-* **ADMIN\_TOKEN =** sicher, ≥ 64 Zeichen
-* **SIGNUPS\_ALLOWED = false**
+* eine **Web‑Oberfläche** zum Verwalten deiner Passwörter und TOTP‑Codes,
+* **sichere Anmeldung** (Admin‑Token, Registrierungen aus),
+* **HTTPS** über den Nginx Proxy Manager (NPM) und
+* **Live‑Sync** dank WebSockets.
 
-——————————
+Wir betreiben Vaultwarden **ohne Docker** (direkt als Programm), damit es **möglichst wenig RAM** verbraucht.
 
-1. System vorbereiten
+---
+
+## ✅ Voraussetzungen (kurz & klar)
+
+* LXC‑Container: **Debian 12 (Bookworm)**, du bist als **root** angemeldet.
+* NPM läuft (eigenes Kapitel), Domain existiert (z. B. `pass.DEINE-DOMAIN.tld`).
+* Die **IP** deines Vaultwarden‑LXC (Beispiel: `10.0.0.16`).
+
+**Platzhalter, die du gleich ersetzt:**
+
+* `<VW_IP>` → IP deines Vaultwarden‑LXC, z. B. `10.0.0.16`
+* `DEINE-DOMAIN.tld` → deine echte Domain
+
+---
+
+## 1) System vorbereiten
+
+Wir aktualisieren das System, installieren Werkzeuge und richten einen **eigenen Dienst‑Benutzer** ein.
+
+> **Warum ein eigener Dienst‑Benutzer?**
+> Dieser Benutzer ist **nur** für den Vaultwarden‑Dienst da (kein normales Login). Dadurch sind die Tresor‑Dateien vor anderen Diensten geschützt. In früheren Docker‑Kapiteln war diese Trennung im Container bereits vorhanden – **jetzt** übernehmen wir sie auf Systemebene.
 
 ```bash
 apt update && apt upgrade -y
-apt install -y ca-certificates curl unzip openssl
-# Systemnutzer ohne Login
+apt install -y ca-certificates curl unzip openssl nano
+
+# Dienstnutzer ohne Login anlegen (nur für den Dienst, zur Absicherung)
 useradd --system --home /var/lib/vaultwarden --shell /usr/sbin/nologin vaultwarden || true
 
-# Verzeichnisse
+# Arbeits- und Datenordner anlegen
 mkdir -p /opt/vaultwarden
 mkdir -p /var/lib/vaultwarden/data
+
+# Eigentum der Daten an den Dienstbenutzer übergeben (Schutz der Tresor-Daten)
 chown -R vaultwarden:vaultwarden /var/lib/vaultwarden
 ```
 
-Prüfen:
+**So prüfst du das Ergebnis:**
 
 ```bash
 id vaultwarden
 ls -ld /opt/vaultwarden /var/lib/vaultwarden /var/lib/vaultwarden/data
 ```
 
-2. Binary laden und installieren
+Du siehst den Benutzer `vaultwarden` und die Ordner existieren.
 
-> Wir laden immer die **neueste** „x86\_64‑unknown‑linux‑gnu“‑Release von GitHub.
+---
+
+## 2) Vaultwarden herunterladen (immer aktuelle stabile Version)
+
+Wir installieren **immer die neuste stabile Release** direkt von der offiziellen Quelle. So sind **Sicherheitsfixes** sofort enthalten.
 
 ```bash
+# 1) Download-URL der neuesten stabilen Release automatisch ermitteln
 VW_URL=$(curl -s https://api.github.com/repos/dani-garcia/vaultwarden/releases/latest \
   | grep browser_download_url \
   | grep x86_64-unknown-linux-gnu.tar.gz \
   | cut -d '"' -f 4)
 
+# 2) Archiv herunterladen und entpacken
 curl -L "$VW_URL" -o /tmp/vaultwarden.tar.gz
 mkdir -p /tmp/vw && tar -xzf /tmp/vaultwarden.tar.gz -C /tmp/vw
+
+# 3) Programmdatei nach /opt verschieben (wird unser fester Pfad)
 install -m 0755 /tmp/vw/vaultwarden /opt/vaultwarden/vaultwarden
 ```
 
-Prüfen:
+**Woran erkenne ich Erfolg?**
 
 ```bash
 /opt/vaultwarden/vaultwarden --version || true
 ```
 
-3. Konfiguration anlegen
+Du siehst die **Version** der frisch installierten Release.
+
+**Warum so? (Laienfreundlich)**
+
+* „Neuste stabile Release“ = **aktuelle Sicherheitsfixes** ohne Wartezeit.
+* Wir holen die Datei **direkt** von der offiziellen Projektseite.
+* Der Pfad `/opt/vaultwarden/` bleibt gleich – **Updates** sind später nur „Datei tauschen + Dienst neu starten“.
+
+> 🔐 **Sicherheits‑Hinweis:** Wenn die Release‑Seite einen **SHA256‑Wert** angibt, kannst du ihn optional prüfen: `sha256sum /tmp/vaultwarden.tar.gz` ausführen und den Wert mit dem auf der Release‑Seite **visuell vergleichen**.
+
+> 🆙 **Aktualisieren später:** Wiederhole **genau diesen Schritt** (die drei Befehle oben) und starte den Dienst neu: `systemctl restart vaultwarden`. Wenn sich seitdem Oberflächen/Optionen geändert haben, ergänzen wir im Video einen Hinweis und **aktualisieren diesen Blog‑Post**.
+
+---
+
+## 3) Konfigurationsdatei mit **Nano** erstellen
+
+Wir hinterlegen **Domain**, **Admin‑Token**, **Ports** und **WebSockets** in einer `.env`‑Datei. Diese Datei liest der Dienst später automatisch ein.
+
+1. **Sicheres Admin‑Token erzeugen** (kopieren, wir fügen es gleich ein):
 
 ```bash
-cat >/etc/vaultwarden.env <<'EOF'
+openssl rand -base64 48
+```
+
+2. **Datei mit Nano öffnen:**
+
+```bash
+nano /etc/vaultwarden.env
+```
+
+3. **Folgenden Inhalt einfügen** und **Platzhalter ersetzen**:
+
+```
 DOMAIN=https://pass.DEINE-DOMAIN.tld
-ADMIN_TOKEN=$(openssl rand -base64 48)
+ADMIN_TOKEN=HIER_DEIN_ERZEUGTES_TOKEN_EINFÜGEN
 SIGNUPS_ALLOWED=false
 WEBSOCKET_ENABLED=true
+
+# Der Dienst lauscht auf der IP deines LXC (so erreicht NPM ihn)
 ROCKET_ADDRESS=<VW_IP>
 ROCKET_PORT=8000
+
+# WebSocket-Endpunkt für Live-Sync
 WEBSOCKET_ADDRESS=<VW_IP>
 WEBSOCKET_PORT=3012
-# Optional SMTP
+
+# Optional: nur wenn du E-Mails (z. B. Verifizierung/Reset) willst
 # SMTP_HOST=smtp.example.com
 # SMTP_FROM=pass@example.com
 # SMTP_PORT=587
 # SMTP_SECURITY=starttls
 # SMTP_USERNAME=user
 # SMTP_PASSWORD=deinPasswort
-EOF
+```
 
+4. **Speichern in Nano:** `Strg+O` → `Enter` → **Beenden:** `Strg+X`.
+5. **Datei schützen** (damit nur root und der Dienst lesen dürfen):
+
+```bash
 chown root:vaultwarden /etc/vaultwarden.env
 chmod 0640 /etc/vaultwarden.env
 ```
 
-Prüfen:
+**Kurz erklärt:**
+
+* `DOMAIN` braucht **https**, damit Links/Icons korrekt sind.
+* `ADMIN_TOKEN` schützt das **Admin‑Backend** (ohne Token kommt man nicht rein).
+* `SIGNUPS_ALLOWED=false` verhindert **offene Registrierungen**.
+* `ROCKET_*` und `WEBSOCKET_*` sorgen dafür, dass der Dienst auf deiner **LXC‑IP** erreichbar ist und Live‑Sync funktioniert.
+
+---
+
+## 4) Dienstdatei (systemd) anlegen
+
+Die Dienstdatei sagt Linux: *„So startest du Vaultwarden – und bitte automatisch beim Booten.“*
+
+1. **Datei öffnen:**
 
 ```bash
-grep -E '^(DOMAIN|ROCKET_ADDRESS|WEBSOCKET_ADDRESS)=' /etc/vaultwarden.env
+nano /etc/systemd/system/vaultwarden.service
 ```
 
-4. systemd‑Service erstellen
+2. **Inhalt einfügen:**
 
-```bash
-cat >/etc/systemd/system/vaultwarden.service <<'EOF'
+```
 [Unit]
 Description=Vaultwarden (Bitwarden-compatible) – native
 After=network.target
@@ -109,7 +184,8 @@ Group=vaultwarden
 EnvironmentFile=/etc/vaultwarden.env
 ExecStart=/opt/vaultwarden/vaultwarden
 WorkingDirectory=/var/lib/vaultwarden
-# Hardening (schlank & sicher)
+
+# Sicherheit (Dienst hat nur, was er braucht)
 LimitNOFILE=1048576
 PrivateTmp=true
 ProtectSystem=full
@@ -118,75 +194,118 @@ NoNewPrivileges=true
 
 [Install]
 WantedBy=multi-user.target
-EOF
+```
 
+3. **Speichern & schließen:** `Strg+O` → `Enter` → `Strg+X`.
+4. **Dienst laden, aktivieren und starten:**
+
+```bash
 systemctl daemon-reload
 systemctl enable --now vaultwarden
 systemctl status vaultwarden --no-pager
 ```
 
-Prüfen (sollte „active (running)“ sein):
+**Woran erkenne ich Erfolg?**
+
+* Status zeigt **active (running)**.
+* Optional: Ports prüfen
 
 ```bash
 ss -tulpn | grep -E ':8000|:3012'
 ```
 
-5. NPM: Proxy‑Host + WebSockets + SSL
+**Was haben wir gerade gemacht?**
 
-* **Hosts → Proxy Hosts → Add Proxy Host**
+* Den Dienst **systemweit registriert** und **dauerhaft** aktiviert.
+* Vaultwarden läuft jetzt im Hintergrund – automatisch auch nach Neustarts.
 
-  * Domain Names: `pass.DEINE-DOMAIN.tld`
-  * Scheme: http
-  * Forward Hostname / IP: **\<VW\_IP>**
-  * Forward Port: **8000**
-  * Block Common Exploits: an
-  * Websockets Support: an
-* **Custom Locations → Add Location**
+---
 
-  * Location: **/notifications/hub**
-  * Forward Hostname / IP: **\<VW\_IP>**
-  * Forward Port: **3012**
-  * Websockets Support: an
-* **SSL**
+## 5) NPM einrichten (Proxy, WebSockets, Zertifikat)
 
-  * Request a new SSL Certificate (Let’s Encrypt)
-  * Force SSL, HTTP/2, HSTS: an
+So wird deine Instanz über **HTTPS** erreichbar und **Live‑Sync** funktioniert.
 
-Prüfen:
+1. **Proxy Host anlegen**
 
-* `https://pass.DEINE-DOMAIN.tld` öffnet die Login‑Seite.
-* WebSocket: Eintrag von einem zweiten Client ändern → Live‑Sync sichtbar.
+   * **Domain Names:** `pass.DEINE-DOMAIN.tld`
+   * **Scheme:** `http`
+   * **Forward Hostname / IP:** `<VW_IP>`
+   * **Forward Port:** `8000`
+   * **Block Common Exploits:** ✔️
+   * **Websockets Support:** ✔️
 
-6. Erstkonfiguration (Web‑UI)
+2. **Custom Location hinzufügen**
 
-* Admin‑Backend: `https://pass.DEINE-DOMAIN.tld/admin` → **ADMIN\_TOKEN** eingeben.
-* **Signups**: „Signups allowed“ **aus**.
-* Optional **SMTP** eintragen (Testmail senden).
-* Erstes Benutzerkonto anlegen und **2FA (TOTP/FIDO2)** aktivieren.
+   * **Location:** `/notifications/hub`
+   * **Forward Hostname / IP:** `<VW_IP>`
+   * **Forward Port:** `3012`
+   * **Websockets Support:** ✔️
 
-7. Backup (Basis)
+3. **SSL aktivieren (Let’s Encrypt)**
+
+   * **Request a new SSL Certificate**
+   * **Force SSL**, **HTTP/2**, **HSTS**: ✔️
+
+**Test:** Rufe `https://pass.DEINE-DOMAIN.tld` im Browser auf → Loginseite sichtbar.
+
+**Was passiert hier?**
+
+* NPM nimmt Anfragen aus dem Internet an (443) und leitet sie an deinen Dienst weiter.
+* Die **Custom Location** sorgt dafür, dass der **WebSocket‑Kanal** (Live‑Sync) funktioniert.
+
+---
+
+## 6) Erstkonfiguration im Browser
+
+1. **Admin‑Backend öffnen**: `https://pass.DEINE-DOMAIN.tld/admin` → **Admin‑Token** eingeben.
+2. **Registrierung prüfen**: „Signups allowed“ ist **aus** (kommt aus deiner `.env`).
+3. **Optional SMTP** eintragen und **Testmail** senden.
+4. **Erstes Benutzerkonto** anlegen und **2FA (TOTP oder FIDO2)** aktivieren.
+
+**Warum?**
+
+* So bleibt der Server **privat** (nur du legst Accounts an).
+* 2FA schützt deinen Tresor zusätzlich.
+
+---
+
+## 7) Backup (Basis, schnell & sicher)
+
+Wir sichern den **Datenordner**. Damit kannst du den Tresor später wiederherstellen.
 
 ```bash
-# Kurzvariante (läuft online); für 100% Konsistenz ggf. Dienst kurz stoppen
+# Für maximale Konsistenz könntest du kurz stoppen (optional)
 # systemctl stop vaultwarden
 
 tar -czf /root/vaultwarden-backup-$(date +%F).tar.gz -C /var/lib vaultwarden
-
 # systemctl start vaultwarden
 ls -lh /root/vaultwarden-backup-*.tar.gz
 ```
 
-Cron‑Hinweis: Regelmäßig sichern; Restore testweise separat prüfen.
+**Wichtig:** Plane das als **Cron‑Job** ein und teste gelegentlich das **Restore** auf einer Test‑VM.
 
-——————————
-Stolperfallen
+---
 
-* **ROCKET\_/WEBSOCKET\_ADDRESS falsch** → NPM erreicht den Dienst nicht.
-* **WebSockets nicht weitergeleitet** → Live‑Sync/Push funktioniert nicht.
-* **DOMAIN nicht https** → fehlerhafte Links/Icons.
-* **ADMIN\_TOKEN zu kurz/unsicher** → Risiko fürs Admin‑Backend.
-* **Signups offen** → ungewollte Accounts.
+## 🛠️ Wenn etwas nicht klappt
 
-Ergebnis
+* **Seite lädt, aber kein Live‑Sync:** In NPM die **Custom Location** `/notifications/hub` prüfen (Port **3012**, WebSockets ✔️).
+* **Icons/Links seltsam:** In `/etc/vaultwarden.env` muss `DOMAIN` mit **https** beginnen.
+* **Ich komme nicht ins Admin‑Backend:** Stimmt das **ADMIN\_TOKEN** noch? (Zur Not neues Token in der `.env` setzen und `systemctl restart vaultwarden`.)
+* **Dienst startet nicht:**
 
-* Vaultwarden läuft nativ im LXC, ist über `https://pass.DEINE-DOMAIN.tld` erreichbar, WebSockets funktionieren, Registrierungen sind aus, Admin‑Backend ist geschützt; Backups vorhanden.
+  ```bash
+  journalctl -u vaultwarden -b --no-pager | tail -n 50
+  ```
+
+  Die letzten Zeilen zeigen meistens den Fehler (z. B. Tippfehler in der `.env`).
+
+---
+
+## ✅ Ergebnis
+
+* Deine Instanz ist über `https://pass.DEINE-DOMAIN.tld` erreichbar.
+* **Registrierungen sind aus**, Admin‑Backend ist durch **Token** geschützt.
+* **WebSockets** funktionieren (Live‑Sync zwischen Geräten).
+* **Backups** sind eingerichtet.
+
+> **Du hast jetzt einen schlanken, eigenen Passwort‑Server – ohne Docker‑Overhead, mit klaren Sicherungen und Updates.**