Der digitale Bunker: Souveränität per Skript

Baue deine eigenen Verschlüsselungs-Tools mit 50 Zeilen Bash.

Echte Privatsphäre basiert auf Transparenz, nicht auf geheimen Apps oder Blackboxes. Diese Anleitung liefert dir zwei auditierbare Bash-Skripte, um sensible Ordner mit Standard-GPG und AES256 zu verschlüsseln und zu entschlüsseln. Keine Cloud, kein Abo, einfach nur reine Mathematik und Linux.

„Don't trust, verify.“
Wir sagen das über Bitcoin-Nodes. Wir sollten es auch über unsere Sicherheits-Tools sagen.

Viele Menschen verlassen sich auf komplexe Apps mit glänzenden Oberflächen, um ihre Daten zu verstecken. Aber Komplexität ist der Feind der Sicherheit. Jede Zeile Code, die du nicht geschrieben hast (und nicht lesen kannst), ist ein potenzielles Sicherheitsrisiko.

Die robusteste Verschlüsselung kommt oft von Werkzeugen, die seit Jahrzehnten getestet werden: GPG und Tar.

Im Folgenden findest du zwei Skripte, die ich nutze, um Daten zu sichern. Sie verwandeln jeden Ordner in ein verschlüsseltes .tar.gz.gpg-Archiv. Sie funktionieren auf deinem High-End-Linux-Desktop und sogar auf deinem Smartphone (via Termux).

Warum Skripte nutzen?

• Auditierbarkeit: Du kannst jede Zeile lesen. Keine versteckten Hintertüren.
• Standardisierung: Der Output ist Standard-OpenPGP. Du kannst es auch in 20 Jahren noch entschlüsseln, selbst wenn diese Skripte verloren gehen.
• Geschwindigkeit: Es kombiniert Archivierung, Komprimierung und Verschlüsselung in einem einzigen Datenstrom (Stream).

1. Das Konzept

Wir erfinden das Rad nicht neu. Wir ketten Standard-Tools aneinander:

• Tar: Bündelt Dateien zusammen.
• Gzip: Komprimiert sie.
• GPG (AES256): Verschlüsselt sie symmetrisch.

2. Teil 1: Das Schild (Verschlüsselung)

Speichere diesen Code als Datei namens encrypt-folder.sh.

#!/bin/bash
# 🔒 Vereinheitlichtes Verschlüsselungs-Skript (TUXEDO + Termux)
# Ausgabe: ~/Verschlüsselt_<Ordner>.tar.gz.gpg (+ .sha256)
#
# S2K-Härtung: SHA512 + AES256 + höchster Hash-Aufwand (65011712 Bytes)
# → jeder Rateversuch kostet überall die maximale Rechenzeit.

set -Eeuo pipefail
umask 077

read -p "📁 Bitte gib den Ordnernamen ein: " ORDNERNAME
if [ -z "${ORDNERNAME:-}" ]; then
  echo "❌ Kein Name eingegeben. Abbruch."
  exit 1
fi

SRC="$HOME/$ORDNERNAME"
if [ ! -d "$SRC" ]; then
  echo "❌ Ordner nicht gefunden: $SRC"
  exit 1
fi

# Zielpfad unterscheiden (PC vs. Termux)
if [ -d "$HOME/storage/downloads" ]; then
  # Termux-Speicher (Android)
  OUTDIR="$HOME/storage/downloads"
else
  # TUXEDO OS / Linux Desktop
  OUTDIR="$HOME"
fi

ZIEL="$OUTDIR/Verschlüsselt_${ORDNERNAME}.tar.gz.gpg"
if [ -f "$ZIEL" ]; then
  ZIEL="$OUTDIR/Verschlüsselt_${ORDNERNAME}_$(date +%F_%H%M).tar.gz.gpg"
fi

echo "📦 Packe & verschlüssele → $ZIEL"

# Packen und verschlüsseln im Stream (kein Klartext-Zwischenschritt)
# S2K-Härtung:
#   --s2k-cipher-algo AES256   → Verschlüsselung mit AES256 (Rückfallwert, falls --cipher-algo fehlt)
#   --s2k-digest-algo SHA512   → SHA512 als Hash (stärker als der ältere Standard SHA1)
#   --s2k-count 65011712       → Höchstwert: 65.011.712 Bytes werden gehasht
#   --no-symkey-cache          → Passwort wird nicht im GPG-Agenten gecacht
tar -C "$HOME" -cf - -- "$ORDNERNAME" \
  | gzip -9 \
  | gpg --symmetric \
      --cipher-algo AES256 \
      --s2k-cipher-algo AES256 \
      --s2k-digest-algo SHA512 \
      --s2k-count 65011712 \
      --compress-level 0 \
      --no-symkey-cache \
      -o "$ZIEL"

# Prüfsumme mit relativem Namen
( cd "$(dirname "$ZIEL")" && sha256sum "$(basename "$ZIEL")" > "$(basename "$ZIEL").sha256" )

# Optional Desktop-Benachrichtigung (nur unter Linux)
if command -v notify-send >/dev/null 2>&1; then
  notify-send "✅ Verschlüsselt" "Archiv: $(basename "$ZIEL")"
fi

echo "✅ Fertig: $(basename "$ZIEL")"
echo "🧩 SHA256-Datei: $(basename "$ZIEL").sha256"

3. Teil 2: Der Schlüssel (Entschlüsselung)

Das Entschlüsselungs-Skript bietet drei Modi — je nachdem was du brauchst:

• [T] TAR schreiben (Standard): Gibt die entschlüsselte .tar.gz ins Home-Verzeichnis aus — ohne zu entpacken.
• [E] Entpacken: Entschlüsselt und entpackt direkt in ~/Restore/.
• [L] Liste: Zeigt den Inhalt des Archivs an, ohne etwas zu schreiben.

Vorher prüft das Skript die Prüfsumme. Stimmt sie nicht, fragt es nach und bricht ab, wenn du nicht ausdrücklich mit j bestätigst. Die Passphrase wird dabei nicht im GPG-Agenten zwischengespeichert.

Speichere diesen Code als Datei namens decrypt-folder.sh.

#!/usr/bin/env bash
# decrypt-folder.sh – Entschlüsselt <NAME>[.tar.gz].gpg aus ~ oder ~/Downloads.
# Modi: SHA256-Check, Loopback-Fallback, Entpacken (E), Liste (L), Standard: TAR schreiben (T)

set -Eeuo pipefail
umask 077
export GPG_TTY="${GPG_TTY:-$(tty 2>/dev/null || true)}"

die(){ printf "❌ %s\n" "$*" >&2; exit 1; }

# --- Eingabe: Name oder Pfad, mit/ohne .gpg ---
NAME="${1-}"
if [ -z "$NAME" ]; then
  printf "Wie heißt die verschlüsselte Datei (ohne .gpg)? "
  IFS= read -r NAME
fi
[ -n "$NAME" ] || die "Kein Name."

# Falls Nutzer doch .gpg mitgegeben hat → abstreifen
NAME="${NAME%.gpg}"

# Kandidaten-Pfade für die .gpg finden
CAND=(
  "$HOME/${NAME}.gpg"
  "$HOME/Downloads/${NAME}.gpg"
  "$PWD/${NAME}.gpg"
)
INPUT=""
for p in "${CAND[@]}"; do
  [ -f "$p" ] && INPUT="$p" && break
done
[ -n "$INPUT" ] || die "Nicht gefunden: ${NAME}.gpg (in ~ oder ~/Downloads)."

# Ziele
OUT_TAR="$HOME/${NAME}"                                # z.B. ~/Verschlüsselt_SAP.tar.gz
STAMP="$(date +%F_%H%M%S)"
RESTORE="$HOME/Restore/${NAME}_${STAMP}"
mkdir -p "$HOME/Restore"

# Optionaler SHA-Check (pfadunabhängig vergleichen)
if [ -f "${INPUT}.sha256" ]; then
  echo "🔎 Prüfe SHA256 ..."
  exp="$(awk '{print $1}' "${INPUT}.sha256")"
  act="$(sha256sum "$INPUT" | awk '{print $1}')"
  if [ "$exp" = "$act" ]; then
    echo "✅ SHA256 OK"
  else
    echo "❌ SHA256 MISMATCH!"
    echo "   Erwartet:  $exp"
    echo "   Berechnet: $act"
    echo "   Die Datei weicht von ihrer Prüfsumme ab — beschädigt oder verändert."
    echo "   Hinweis: die .sha256 liegt daneben und ist kein Echtheitsnachweis;"
    echo "   sie fängt Transportfehler ab, keinen gezielten Austausch."
    printf "   Trotzdem fortfahren? [j/N] "
    read -r antwort </dev/tty || antwort=""
    if [[ "$antwort" =~ ^[jJyY]$ ]]; then
      echo "   ⚠️  Fortsetzung auf ausdrücklichen Wunsch."
    else
      die "Abgebrochen wegen SHA256-Mismatch."
    fi
  fi
fi

# Modus abfragen
printf "Modus: [T]AR schreiben (Standard) / [E]ntpacken / [L]iste: "
read -r -n1 MODE || true; echo
MODE=${MODE:-T}

# Helfer-Funktionen (mit Loopback-Fallback)
decrypt_to_tar() {
  gpg --no-symkey-cache --decrypt "$INPUT" | tar -xz -C "$RESTORE" && return 0
  echo "⚠️  Versuch mit loopback …"
  gpg --no-symkey-cache --pinentry-mode loopback --decrypt "$INPUT" | tar -xz -C "$RESTORE"
}
decrypt_to_file() {
  gpg --no-symkey-cache --output "$OUT_TAR" --decrypt "$INPUT" && return 0
  echo "⚠️  Versuch mit loopback …"
  gpg --no-symkey-cache --pinentry-mode loopback --output "$OUT_TAR" --decrypt "$INPUT"
}

case "$MODE" in
  L|l)
    gpg --no-symkey-cache --decrypt "$INPUT" | tar -tz || \
    gpg --no-symkey-cache --pinentry-mode loopback --decrypt "$INPUT" | tar -tz
    ;;
  E|e)
    mkdir -p "$RESTORE"
    echo "📦 Entpacke nach: $RESTORE"
    decrypt_to_tar
    command -v notify-send >/dev/null && notify-send "✅ Entpackt" "$RESTORE"
    echo "✅ Fertig: $RESTORE"
    ;;
  T|t|*)
    # Standard: entschlüsselte .tar.gz im HOME schreiben
    [ -f "$OUT_TAR" ] && rm -f "$OUT_TAR"
    echo "📝 Schreibe: $OUT_TAR"
    decrypt_to_file
    command -v notify-send >/dev/null && notify-send "✅ Entschlüsselt" "$OUT_TAR"
    echo "✅ Fertig: $OUT_TAR"
    ;;
esac