🔐 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
# 🔒 Unified Encryption Script
# Output: ~/Encrypted_<Folder>.tar.gz.gpg (+ .sha256)

set -Eeuo pipefail
umask 077

read -p "📁 Enter folder name to encrypt: " FOLDERNAME

if [ -z "${FOLDERNAME:-}" ]; then
  echo "❌ No name entered. Aborting."
  exit 1
fi

SRC="$HOME/$FOLDERNAME"

if [ ! -d "$SRC" ]; then
  echo "❌ Folder not found: $SRC"
  exit 1
fi

# Determine output path (Desktop vs. Termux)
if [ -d "$HOME/storage/downloads" ]; then
  # Termux (Android)
  OUTDIR="$HOME/storage/downloads"
else
  # Linux Desktop
  OUTDIR="$HOME"
fi

TARGET="$OUTDIR/Encrypted_${FOLDERNAME}.tar.gz.gpg"

if [ -f "$TARGET" ]; then
  TARGET="$OUTDIR/Encrypted_${FOLDERNAME}_$(date +%F_%H%M).tar.gz.gpg"
fi

echo "📦 Packing & Encrypting → $TARGET"

# Stream: Tar -> Gzip -> GPG (AES256)
# No unencrypted temporary files are created on disk.
tar -C "$HOME" -cf - -- "$FOLDERNAME" \
  | gzip -9 \
  | gpg --symmetric --cipher-algo AES256 --compress-level 0 --no-symkey-cache \
  -o "$TARGET"

# Create checksum
( cd "$(dirname "$TARGET")" && sha256sum "$(basename "$TARGET")" > "$(basename "$TARGET").sha256" )

# Notify (Linux only)
if command -v notify-send >/dev/null 2>&1; then
  notify-send "✅ Encrypted" "Archive: $(basename "$TARGET")"
fi

echo "✅ Done: $(basename "$TARGET")"
echo "🧩 SHA256: $(basename "$TARGET").sha256"

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

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

#!/usr/bin/env bash
# decrypt-folder.sh – Decrypts <NAME>[.tar.gz].gpg from ~ or ~/Downloads.
# Features: SHA256 check, Loopback fallback, Auto-Extract (E), List (L), Default: Write TAR (T)

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

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

# --- Input: Name or path, with or without .gpg ---
NAME="${1-}"
if [ -z "$NAME" ]; then
  printf "Enter the filename of the encrypted archive (without .gpg): "
  IFS= read -r NAME
fi
[ -n "$NAME" ] || die "No name provided."

# Strip .gpg if user provided it
NAME="${NAME%.gpg}"

# Find candidate paths for the .gpg file
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 "Not found: ${NAME}.gpg (checked ~, ~/Downloads, and PWD)."

# Destinations
OUT_TAR="$HOME/${NAME}"                                # e.g. ~/Encrypted_Data.tar.gz
STAMP="$(date +%F_%H%M%S)"
RESTORE="$HOME/Restore/${NAME}_${STAMP}"
mkdir -p "$HOME/Restore"

# Optional SHA-Check (path-independent comparison)
if [ -f "${INPUT}.sha256" ]; then
  echo "🔎 Checking SHA256 ..."
  exp="$(awk '{print $1}' "${INPUT}.sha256")"
  act="$(sha256sum "$INPUT" | awk '{print $1}')"
  if [ "$exp" = "$act" ]; then
    echo "✅ SHA256 OK"
  else
    echo "⚠️  SHA256 Mismatch! Proceed with caution."
  fi
fi

# Select Mode
printf "Mode: [T]AR Write (Default) / [E]xtract / [L]ist: "
read -r -n1 MODE || true; echo
MODE=${MODE:-T}

# Helper Functions (with Loopback Fallback for stability)
decrypt_to_tar() {
  gpg --decrypt "$INPUT" | tar -xz -C "$RESTORE" && return 0
  echo "⚠️  Standard input failed. Attempting loopback mode..."
  gpg --pinentry-mode loopback --decrypt "$INPUT" | tar -xz -C "$RESTORE"
}
decrypt_to_file() {
  gpg --output "$OUT_TAR" --decrypt "$INPUT" && return 0
  echo "⚠️  Standard input failed. Attempting loopback mode..."
  gpg --pinentry-mode loopback --output "$OUT_TAR" --decrypt "$INPUT"
}

case "$MODE" in
  L|l)
    gpg --decrypt "$INPUT" | tar -tz || \
    gpg --pinentry-mode loopback --decrypt "$INPUT" | tar -tz
    ;;
  E|e)
    mkdir -p "$RESTORE"
    echo "📦 Extracting to: $RESTORE"
    decrypt_to_tar
    if command -v notify-send >/dev/null 2>&1; then
      notify-send "✅ Extracted" "$RESTORE"
    fi
    echo "✅ Finished: $RESTORE"
    ;;
  T|t|*)
    # Default: Write decrypted .tar.gz to HOME
    [ -f "$OUT_TAR" ] && rm -f "$OUT_TAR"
    echo "📝 Writing: $OUT_TAR"
    decrypt_to_file
    if command -v notify-send >/dev/null 2>&1; then
      notify-send "✅ Decrypted" "$OUT_TAR"
    fi
    echo "✅ Finished: $OUT_TAR"
    ;;
esac