# Linux - GPG # GPG - Yubikey "not found" ## YubiKey wird von GPG nicht erkannt – Lösung mit pcscd Neustart Wenn der **YubiKey** bereits eingesteckt ist, aber `gpg` oder `gpg2` ihn nicht erkennt (z. B. mit dem Fehler `gpg: selecting card failed: No such device`), liegt das häufig an einem Problem mit dem Smartcard-Dienst `pcscd`. ### Fehlermeldung ``` gpg: selecting card failed: No such device gpg: OpenPGP card not available: No such device ``` ### Lösung: pcscd Dienst neu starten 1. Öffne ein Terminal mit Root-Rechten oder verwende `sudo`. 2. Führe den folgenden Befehl aus, um den Dienst neu zu starten: ``` sudo systemctl restart pcscd ``` Alternativ bei älteren Systemen: ``` sudo service pcscd restart ``` 3. Danach kannst du `gpg2 --card-edit` erneut ausführen: ``` gpg2 --card-edit ``` Nun sollte der YubiKey korrekt erkannt werden und Informationen wie Seriennummer, Hersteller und Kartentyp anzeigen. ### Hinweis - Wenn du den YubiKey erst nach dem Systemstart einsteckst, kann es ebenfalls nötig sein, `pcscd` neu zu starten. - Um dies in Zukunft zu vermeiden, kannst du die automatische Aktivierung mit folgendem Befehl ermöglichen: ``` sudo systemctl enable pcscd.socket ``` Dies stellt sicher, dass der Dienst automatisch gestartet wird, sobald ein Smartcard-Gerät verwendet wird. # GPG Keys exportieren # GPG - Sicheren Schlüssel erstellen und Ordner verschlüsseln
## GPG maximal hart: Schlüssel erstellen & kompletten Ordner sicher verschlüsseln (mit Erklärungen)
**Zielbild:** Wir erzeugen einen modernen ECC-Schlüssel (Curve25519), härten GnuPGs Auswahl (AES-256, SHA-512), nutzen – wo möglich – *AEAD/OCB* für manipulationssichere Verschlüsselung und packen den Ordner zuerst in ein Tar-Archiv, um *Dateinamen und Struktur* zu verbergen. So bekommst du robuste Sicherheit mit wenig Angriffsfläche.
#### 0) Vorbereiten & Umgebung schützen – warum überhaupt? Eine aktuelle GnuPG-Version bringt neue Sicherheitsfeatures (z. B. AEAD/OCB). `GPG_TTY` sorgt für saubere Passphrase-Prompts. `umask 077` und strikte Rechte verhindern, dass Konfigs/Backups aus Versehen für andere lesbar sind.
**Nun musst du folgenden Befehl eingeben:**
``` # Version prüfen (2.4+ ideal): gpg --version # Terminal-Integration: export GPG_TTY=$(tty) # Verzeichnis und Rechte: umask 077 mkdir -p ~/.gnupg && chmod 700 ~/.gnupg ``` #### 1) Sehr starken OpenPGP-Schlüssel anlegen **ECC/Curve25519** liefert heute eine hervorragende Kombination aus Sicherheit, Geschwindigkeit und Kompatibilität: du erhältst einen Ed25519-Signierschlüssel plus X25519-(cv25519)-Verschlüsselungs-Subkey. Das ist „state of the art“ für die meisten Anwendungsfälle.
**Nun musst du folgenden Befehl eingeben:**
``` gpg --expert --full-generate-key # Im Dialog: # Typ: (9) ECC und ECC → Kurve: Curve25519 # Ablaufdatum: z.B. 2y (verlängerbar) # Name/E-Mail setzen # sehr starke Passphrase vergeben ```
**Wann RSA?** Nur wenn du mit sehr alten Gegenstellen sprechen musst, die ECC nicht können; sonst bleib bei Curve25519.
###### 1.1) Fingerprint & Notfall: Widerrufszertifikat Der Fingerprint identifiziert deinen Schlüssel zweifelsfrei. Ein Widerrufszertifikat ist deine „Notbremse“, falls der private Schlüssel verloren/kompromittiert ist.
**Nun musst du folgenden Befehl eingeben:**
``` gpg --list-keys gpg --fingerprint "Dein Name" gpg --output revoke.asc --gen-revoke "Dein Name" ``` #### 3) Einen kompletten Ordner verschlüsseln – Dateinamen & Struktur verbergen Ein simples „alle Dateien einzeln verschlüsseln“ leakt Dateinamen und Ordnerstruktur. Besser: zuerst deterministisch zu `tar` bündeln (glättet Metadaten), dann `gpg` drüber. Ergebnis: `.tar.gpg` – sauber, dicht, auditierbar. ###### 3.0) Pipeline: tar → gpg (maximale Härte)
**Nun musst du folgenden Befehl eingeben:**
``` # Variablen ORDNER="mein_geheimer_ordner" EMPFAENGER="Dein Name " # oder: 40-stelliger Fingerprint OUT="mein_geheimer_ordner.tar.gpg" # Deterministisch packen & sofort verschlüsseln (mit AEAD/OCB): tar --sort=name \ --mtime='UTC 1970-01-01' \ --owner=0 --group=0 --numeric-owner \ -C "$(dirname "$ORDNER")" -cf - "$(basename "$ORDNER")" \ | gpg --encrypt \ --recipient "$EMPFAENGER" \ --cipher-algo AES256 \ --force-ocb \ --output "$OUT" # Kompatibilitätsmodus (ohne OCB): # ... | gpg --encrypt --recipient "$EMPFAENGER" --cipher-algo AES256 -o "$OUT" ```
**Warum diese tar-Optionen?** *--sort=name*, *--mtime='UTC 1970-01-01'* und *--owner/--group/--numeric-owner* reduzieren Metadaten-Leaks und machen das Archiv reproduzierbar/auditierbar.
###### 3.1) Alternative „aus einem Guss“: `gpgtar` `gpgtar` kapselt Archivieren + Verschlüsseln in einem Tool – komfortabel und sicher, Dateinamen bleiben verborgen.
**Nun musst du folgenden Befehl eingeben:**
``` # Erstellen: gpgtar --encrypt --recipient "$EMPFAENGER" --output geheim.gpg "$ORDNER" # Entpacken: gpgtar --decrypt --output entpackt geheim.gpg ``` ###### 3.2) Erfolg prüfen (ohne zu entschlüsseln) Zur Kontrolle, welche Paket-/Algo-Infos tatsächlich drinstecken (nützlich für Audits): ``` gpg --list-packets "$OUT" | sed -n '1,40p' ``` ###### 3.3) Originaldaten entfernen – HDD vs. SSD Auf klassischen HDDs kann `shred` sinnvoll sein. Auf SSDs/Copy-on-Write-FS (btrfs, zfs) sind Überschriften nicht zuverlässig – setze dort lieber auf Voll-Disk-Verschlüsselung (LUKS) und sichere Löschprozesse auf Geräteebene.
**Nun musst du folgenden Befehl eingeben (HDD-Fall):**
``` shred -vzun 3 -r -- "$ORDNER" # ACHTUNG: für SSDs ungeeignet! ```
**SSD-Hinweis:** Nutze LUKS/Full-Disk-Encryption; für komplettes Gerät ggf. „Secure Erase“/`blkdiscard` je nach Hardware/Setup.
#### 4) Entschlüsseln & auspacken – bewusst zweistufig Erst entschlüsseln (fragt nach Passphrase/Token), dann das Tar entpacken – so bleibt der Ablauf transparent und nachvollziehbar.
**Nun musst du folgenden Befehl eingeben:**
``` gpg --output ordner.tar --decrypt mein_geheimer_ordner.tar.gpg tar -xf ordner.tar ```
**Wie GPG intern arbeitet:** Hybrid-Krypto – ein zufälliger Session-Key (z. B. AES-256) verschlüsselt die Daten; dieser Session-Key wird für deinen Public Key eingepackt.
#### 5) Schlüssel sichern & Vertrauen setzen – was braucht’s wirklich? Teile deinen *öffentlichen* Schlüssel, sichere den *privaten* offline, und setze die Vertrauensstufe bewusst, damit dein System Signaturen korrekt bewertet.
**Nun musst du folgenden Befehl eingeben:**
``` # Public Key exportieren: gpg --armor --export "$EMPFAENGER" > publickey.asc # Private Keys sichern (offline aufbewahren!): gpg --armor --export-secret-keys "$EMPFAENGER" > privatekey-backup.asc # Vertrauen setzen (optional): gpg --edit-key "$EMPFAENGER" gpg> trust # 5 = ultimate gpg> save ```
**Wichtig:** *privatekey-backup.asc* nie in die Cloud/VC, sondern offline (z. B. USB im Tresor) + starke Passphrase.
#### 6) Zusätzliche Härtung – wann lohnt sich der Extra-Aufwand? - **Hardware-Token (YubiKey/Smartcard):** Private Keys aufs Token verschieben – Schlüsselmaterial verlässt den Rechner nie. Ideal, wenn Geräte geteilt werden oder du „Defense in Depth“ willst. - **Primärschlüssel offline, Subkeys produktiv:** Primärschlüssel nur als „Root of Trust“ offline lagern, mit Subkeys signieren/verschlüsseln – einfachere Rotation. - **Passphrase-Qualität:** 6–8+ Diceware-Wörter oder 20–30+ zufällige Zeichen aus Passwort-Manager; regelmäßig rotieren. - **Key-Präferenzen am Key selbst setzen & verteilen:** Damit Sender automatisch starke Verfahren wählen (siehe `gpg --edit-key → setpref`). ###### 7) Troubleshooting (kurz & praxisnah) - *OCB wird nicht verwendet?* Prüfe `gpg --version` (2.4+) und ob du `--force-ocb` gesetzt hast; bei Fremd-Stacks bleibt OCB evtl. unverständlich – dann ohne OCB arbeiten. - *Entschlüsseln ist langsam mit „hidden recipients“?* Das ist normal: alle eigenen Keys werden probiert. Für Backups ok, für E-Mail eher abwägen. - *Tar meckert über Zeiten/Owner?* Stelle sicher, dass du GNU tar nutzt und die Optionen wie oben gesetzt sind. ###### 8) Schnellreferenz ``` # Schlüssel (Curve25519): gpg --expert --full-generate-key # Ordner → deterministisches Tar → GPG (mit OCB): tar --sort=name --mtime='UTC 1970-01-01' --owner=0 --group=0 --numeric-owner \ -C "$(dirname "$ORDNER")" -cf - "$(basename "$ORDNER")" \ | gpg --encrypt --recipient "$EMPFAENGER" --cipher-algo AES256 --force-ocb -o "$OUT" # Entschlüsseln: gpg -o ordner.tar -d "$OUT" && tar -xf ordner.tar # gpgtar-Variante: gpgtar --encrypt -r "$EMPFAENGER" -o geheim.gpg "$ORDNER" gpgtar --decrypt -o entpackt geheim.gpg ``` **Kompatibilitätsnotiz:** Für alte Gegenstellen *ohne* `--force-ocb` arbeiten. Für lokale Backups und moderne GnuPG-Umgebungen OCB beibehalten.