🛡️ Der mobile Bunker: Verschlüsselung auf GrapheneOS (Termux Edition)

Souveränität endet nicht an der Schreibtischkante. Nimm deine digitale Festung mit.

Im ersten Teil haben wir den „Digitalen Bunker“ auf dem Linux-Desktop gebaut. Wir haben gelernt, dass wahre Sicherheit auf Auditierbarkeit basiert, nicht auf bunten Apps. Doch Investoren und Strategen sind mobil. Was nützt das sicherste Archiv zu Hause, wenn du unterwegs auf sensitive Dokumente zugreifen oder Daten sicher exfiltrieren musst?

Die meisten mobilen Lösungen sind „Blackboxes“. Du drückst einen Knopf, etwas passiert, und du hoffst, dass der Entwickler keinen Generalschlüssel hat. Das ist inakzeptabel.

Wir nutzen GrapheneOS, das einzige mobile Betriebssystem, das Sicherheitsarchitektur ernst nimmt. Und wir nutzen Termux, einen Terminal-Emulator, der dein Smartphone in einen vollwertigen Linux-Computer verwandelt.

Das Ziel: Ein Workflow. Zwei Geräte. Identische Mathematik.
Ein Archiv, das du auf deinem Tuxedo-Laptop verschlüsselst, muss auf deinem GrapheneOS-Phone zu öffnen sein – und umgekehrt.

1. Die Vorbereitung: Termux startklar machen

Auf GrapheneOS installierst du Termux am besten über F-Droid (nicht über den Play Store, dort ist die Version veraltet).
Sobald du das schwarze Terminal vor dir hast, aktualisieren wir die Pakete und installieren die nötigen Werkzeuge. Das ist das Fundament.

Tippe folgende Befehle nacheinander ein:

pkg update && pkg upgrade
pkg install termux-tools tar gnupg

Der Zugriff auf den Speicher

Termux lebt isoliert. Damit die Skripte auf deine Downloads zugreifen können (wo deine Daten liegen), müssen wir die Brücke zum Android-Dateisystem schlagen.

Führe aus:

termux-setup-storage

Bestätige den Dialog auf dem Bildschirm („Zulassen“).

Lege nun einen Ordner für deine Werkzeuge an:

mkdir -p ~/Skripte

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

Das Skript encrypt-folder.sh für Termux ist intelligent. Es erkennt automatisch, ob es auf einem Android-System läuft, und leitet die Ausgabe in den Ordner Downloads, damit du die verschlüsselte Datei später einfach finden und teilen kannst.

Ein Blick unter die Haube: Die Sicherheits-Mechanik

Bevor wir den Code kopieren, achten wir auf ein Detail, das Profi-Code von Bastel-Skripten unterscheidet. Am Anfang des Skripts findest du den Bereich „Helpers“:

• Die Notbremse (die): Wenn irgendetwas schiefgeht (z. B. Speicher voll, Zugriff verweigert), bricht das Skript sofort hart ab (exit 1). Es macht nicht einfach weiter und produziert korrupte Daten.
• Der Ausrüstungs-Check (need): Bevor auch nur ein Byte verschlüsselt wird, prüft das Skript, ob alle Werkzeuge (tar, gpg) an Bord sind. Fehlt etwas, startet es gar nicht erst.

So sieht Code aus, der dich im Ernstfall nicht im Stich lässt.

Erstelle die Datei:

nano ~/Skripte/encrypt-folder.sh

Füge diesen Code ein:

#!/usr/bin/env bash
# encrypt-folder.sh — Ordner verlustfrei packen und symmetrisch (AES-256) verschlüsseln,
# ohne Klartext-Zwischendatei. Zusätzlich wird eine .sha256 erzeugt.
# Phone (GrapheneOS/Termux): Ausgabe nach ~/storage/downloads
# PC (TUXEDO OS): Ausgabe nach $HOME

set -Eeuo pipefail
umask 077

# -------------------- Helpers --------------------
die() { printf "❌ %s\n" "$*" >&2; exit 1; }
need() { command -v "$1" >/dev/null 2>&1 || die "Benötigtes Programm fehlt: $1"; }

need tar
need gpg
need sha256sum

# Zielausgabe je nach System bestimmen
OUT_DIR="$HOME"
if [ -d "$HOME/storage/downloads" ]; then
  OUT_DIR="$HOME/storage/downloads"
fi

# Eingabe: optional als Argument, sonst Prompt
INPUT="${1-}"
if [ -z "$INPUT" ]; then
  printf "📁 Bitte gib den Ordnernamen ein: "
  IFS= read -r INPUT
fi

[ -n "$INPUT" ] || die "Kein Name eingegeben."

# Pfad normalisieren:
# Erlaubt: SAP | storage/downloads/SAP | ~/storage/downloads/SAP
#          /sdcard/Download/SAP | /storage/emulated/0/Download/SAP | /voller/pfad/SAP
case "$INPUT" in
  ~/*) SRC="$HOME/${INPUT#~/}" ;;
  storage/*) SRC="$HOME/$INPUT" ;;  # Termux-Symlink
  /sdcard/Download/*)
      SRC="$HOME/storage/downloads/${INPUT#/sdcard/Download/}" ;;
  /storage/emulated/0/Download/*)
      SRC="$HOME/storage/downloads/${INPUT#/storage/emulated/0/Download/}" ;;
  /*) SRC="$INPUT" ;;
  *)
      if [ -d "$HOME/storage/downloads/$INPUT" ]; then
        SRC="$HOME/storage/downloads/$INPUT"
      else
        SRC="$HOME/$INPUT"
      fi
      ;;
esac

[ -e "$SRC" ] || die "Pfad nicht gefunden: $SRC"
[ -d "$SRC" ] || die "Das ist keine Ordner-Struktur: $SRC"

BASE="$(basename "$SRC")"

# Optional: Leerzeichen im Namen durch Unterstrich ersetzen (nur für die Zieldatei)
BASE_SAFE="${BASE// /_}"

OUT_FILE="$OUT_DIR/Verschlüsselt_${BASE_SAFE}.tar.gz.gpg"

# Kollision vermeiden
if [ -e "$OUT_FILE" ]; then
  OUT_FILE="$OUT_DIR/Verschlüsselt_${BASE_SAFE}_$(date +%Y-%m-%d_%H-%M-%S).tar.gz.gpg"
fi

printf "📦 Packe & verschlüssele → %s\n" "$OUT_FILE"

# Archivieren + Verschlüsseln ohne Klartext-Zwischendatei
# Tipp: Für loopback-Pinentry (ohne curses-Prompt): ~/.gnupg/gpg.conf -> allow-loopback-pinentry
# und unten: --pinentry-mode loopback ergänzen.
tar -C "$(dirname "$SRC")" -cz "$BASE" \
| gpg --symmetric --cipher-algo AES256 -o "$OUT_FILE" \
|| die "gpg fehlgeschlagen"

# Prüfsumme schreiben
sha256sum "$OUT_FILE" > "${OUT_FILE}.sha256"

printf "✅ Fertig:\n   %s\n   %s\n   Standort: %s\n" \
  "$(basename "$OUT_FILE")" "$(basename "${OUT_FILE}.sha256")" "$OUT_DIR"

(Speichern in nano mit STRG+O, Enter, dann STRG+X)

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

Unterwegs hast du oft ein Problem: Cloud-Dienste oder Downloads benennen Dateien um. Aus Datei.gpg wird plötzlich Datei.gpg.pgp oder Datei (1).gpg.
Dieses Skript ist die „Cloud-Edition“. Es ist extrem robust, findet deine Datei auch bei falschen Endungen und prüft die SHA256-Summe.

Erstelle die Datei:

nano ~/Skripte/decrypt-folder.sh

Füge diesen Code ein:

#!/usr/bin/env bash
# decrypt-folder.sh (Cloud-Edition)
# - Findet .gpg UND .pgp (Doppel-Endung durch Cloud/Download)
# - Smarter SHA-Check (prüft auch, ob das .pgp zu viel ist)

set -Eeuo pipefail
umask 077

export GPG_TTY="${GPG_TTY:-$(tty 2>/dev/null || true)}"

DL_DIR="$HOME/storage/downloads"

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

# --- 1. Automatische Dateiwahl (GPG & PGP) ---
NAME="${1-}"
INPUT=""

if [ -z "$NAME" ]; then
  # Sucht nach .gpg ODER .pgp, sortiert nach Zeit (neueste zuerst)
  # 2>/dev/null unterdrückt Fehler, falls eine Art nicht da ist
  LATEST="$(ls -t "$DL_DIR"/*.gpg "$DL_DIR"/*.pgp 2>/dev/null | head -n1 || true)"
  
  if [ -n "$LATEST" ]; then
    INPUT="$LATEST"
    printf "🤖 Datei gefunden: %s\n" "$(basename "$INPUT")"
  else
    printf "Keine Datei gefunden. Name eingeben: "
    IFS= read -r NAME
    [ -n "$NAME" ] || die "Abbruch."
  fi
fi

# Fallback: Manuelle Pfadsuche
if [ -z "$INPUT" ]; then
    # Wir probieren diverse Varianten durch
    VARIANTS=(
      "${NAME}"
      "${NAME}.gpg"
      "${NAME}.pgp"
      "${NAME}.gpg.pgp"
      "Verschlüsselt_${NAME}.gpg"
    )
    
    for v in "${VARIANTS[@]}"; do
        # Prüfen in PWD und Downloads
        if [ -f "$PWD/$v" ]; then INPUT="$PWD/$v"; break; fi
        if [ -f "$DL_DIR/$v" ]; then INPUT="$DL_DIR/$v"; break; fi
    done
fi

[ -n "$INPUT" ] || die "Quelldatei nicht gefunden."

# --- 2. Intelligenter SHA256 Check ---
# Fall A: Standard (Datei.gpg.sha256)
SHA_CANDIDATE_1="${INPUT}.sha256"

# Fall B: Cloud-Fehler (Datei.gpg.pgp -> Datei.gpg.sha256)
SHA_CANDIDATE_2="${INPUT%.pgp}.sha256"

SHA_FILE=""

if [ -f "$SHA_CANDIDATE_1" ]; then
    SHA_FILE="$SHA_CANDIDATE_1"
elif [ -f "$SHA_CANDIDATE_2" ]; then
    SHA_FILE="$SHA_CANDIDATE_2"
    echo "ℹ️  Korrigiere SHA-Pfad (ignoriere .pgp Endung)..."
fi

if [ -n "$SHA_FILE" ]; then
    printf "🔎 Prüfe Integrität (SHA256)..."
    EXPECTED=$(awk '{print $1}' "$SHA_FILE")
    ACTUAL=$(sha256sum "$INPUT" | awk '{print $1}')

    if [ "$EXPECTED" = "$ACTUAL" ]; then
        echo " ✅ OK."
    else
        echo " ❌ FEHLER!"
        echo "   WARNUNG: Checksummen stimmen nicht überein!"
        echo "   Datei könnte korrupt sein."
        printf "   Trotzdem fortfahren? (j/N) "
        read -r -n 1 REPLY
        echo
        if [[ ! $REPLY =~ ^[Jj]$ ]]; then
            die "Abbruch."
        fi
    fi
else
    echo "ℹ️  Keine .sha256 Datei gefunden (Check übersprungen)."
fi

# --- 3. Entschlüsseln & Entpacken ---
printf "🔓 Entschlüssle & Entpacke..."

if gpg --quiet --decrypt "$INPUT" | tar -xz; then
    echo " ✅ Fertig."
    echo "📂 Ordner liegt in: $PWD"
elif gpg --quiet --pinentry-mode loopback --decrypt "$INPUT" | tar -xz; then
    echo " ✅ Fertig."
    echo "📂 Ordner liegt in: $PWD"
else
    die "Fehler."
fi

Mach beide Skripte ausführbar:

chmod +x ~/Skripte/encrypt-folder.sh ~/Skripte/decrypt-folder.sh

4. Der Workflow im Feld

Hier ist der taktische Ablauf, um deine Daten sicher zu bewegen.

Szenario A: Verschlüsseln und Entschlüsseln auf dem Telefon (Loop)

1. Du hast einen Ordner (z.B. Finanzen) in deinem Download-Bereich.
2. Öffne Termux.
3. Starte das Skript: ~/Skripte/encrypt-folder.sh
4. Tippe den Ordnernamen ein: Finanzen
5. Ergebnis: In deinem normalen Download-Ordner liegen nun Verschlüsselt_Finanzen.tar.gz.gpg und die Checksumme.
6. Willst du sie testen/entschlüsseln? Führe einfach ~/Skripte/decrypt-folder.sh aus. Die entschlüsselten Dateien liegen dann im Termux Home (siehe Schritt 3)

Szenario B: Daten vom PC entschlüsseln (Der Ernstfall)

Du hast eine verschlüsselte Datei (z. B. Verschlüsselt_Backup.tar.gz.gpg) von deinem PC auf dein Handy übertragen.

• Schritt 1: Speicherort
  Stelle sicher, dass die Datei im Android-Download-Ordner liegt. Mein Skript sucht dort automatisch nach der neuesten Datei.
• Schritt 2: Feuer frei
  Öffne Termux und starte das Skript:
  

  ~/Skripte/decrypt-folder.sh

• Schritt 3: Wo sind die Daten?
  Das Skript entschlüsselt die Daten standardmäßig in das Termux-Home-Verzeichnis (nicht zurück nach Downloads, um Chaos zu vermeiden).
  Öffne deine „Dateien“-App. Du findest dort in der Seitenleiste oder unter „Speicherorte“ einen Eintrag namens Termux. Dort liegt dein entschlüsselter Ordner, bereit zur Einsicht. Dies ist ein gespiegelter Bereich, auf den du bequem zugreifen kannst.

5. Warum „Auditierbarkeit“ King ist

Du könntest eine App aus dem AppStore laden, die „AES Safe Box“ heißt. Aber weißt du, was sie mit deinen Keys macht?

Keine Magie. Nur Mathematik. Das ist der Weg des Alien Investors.

Mit diesen Skripten siehst du jeden Befehl:

• Tar packt.
• GPG verschlüsselt.
• SHA256 verifiziert.