kind: reference search: Hash, SHA-256, sha256sum, Salz, yescrypt, mkpasswd, AES, openssl, RSA, öffentlicher Schlüssel, privater Schlüssel, Signatur, ssh-keygen, Fingerabdruck, HMAC, Base64, Base32, Zufall

Kryptographie im Terminal

Die Bausteine aus Kryptographie im Terminal und Zwei Faktoren zum Nachschlagen: was ein Hash, ein Schlüssel und eine Unterschrift sind, welcher Befehl was tut, und wie dasselbe in Ruby und Python aussieht. Dazu, welcher Baustein für welche Aufgabe der richtige ist.

1. Welcher Baustein wofür?

  • Prüfen, ob eine Datei unverändert ist: ein Hash (SHA-256), im Terminal sha256sum datei.
  • Passwörter speichern: ein Passwort-Hash mit Salz, absichtlich langsam (yescrypt, bcrypt, Argon2), im Terminal mkpasswd -m yescrypt.
  • Etwas mit einem Passwort verschlüsseln: symmetrisch mit AES, ein Schlüssel für beide Richtungen, im Terminal openssl enc -aes-256-cbc -pbkdf2.
  • Jemandem etwas schicken, das nur er lesen kann: asymmetrisch mit RSA und seinem öffentlichen Schlüssel, im Terminal openssl pkeyutl -encrypt.
  • Zeigen, dass etwas von dir kommt und unverändert ist: eine Signatur mit deinem privaten Schlüssel (Ed25519), im Terminal ssh-keygen -Y sign.
  • Eine Prüfsumme, die nur berechnen kann, wer den Schlüssel hat: HMAC; der Code einer Authenticator-App kommt daher. Wie das geht, steht unter In Programmen.

Ein Passwort wird nie verschlüsselt gespeichert, sondern gehasht: Was sich entschlüsseln lässt, kann jemand entschlüsseln, der an die Datenbank und den Schlüssel kommt.

2. Hashes

Befehl Was er tut
sha256sum datei den SHA-256-Hash einer Datei: 64 Hexziffern, 256 Bit
echo -n text | sha256sum den Hash eines Texts; -n lässt das Zeilenende weg, das echo sonst anhängt und das den Hash ändert
sha256sum *.txt > summen.txt die Hashes aller Textdateien speichern
sha256sum -c summen.txt später prüfen, ob die Dateien noch dieselben sind

Ein Hash ist ein Fingerabdruck: Gleiche Daten geben immer denselben Hash, ein einziges geändertes Zeichen einen völlig anderen. Aus dem Hash lassen sich die Daten nicht zurückrechnen. MD5 und SHA-1 gelten als gebrochen: Man kann zwei Dateien mit demselben Hash bauen. Für Neues nimmst du SHA-256.

Passwörter

mkpasswd -m yescrypt geheim
$y$j9T$mL3J0fX…$k8bH…

$y$ sagt, welches Verfahren es ist, dahinter stehen die Einstellungen, das Salz und der Hash. Das Salz ist bei jedem Aufruf anders, deshalb gibt dasselbe Passwort jedes Mal einen anderen Hash, und eine vorbereitete Tabelle von Hashes häufiger Passwörter nützt einem Angreifer nichts. Ein Passwort-Hash ist außerdem absichtlich langsam (-R stellt ein, wie langsam): Einmal anmelden merkt man nicht, Milliarden Passwörter durchprobieren dauert dagegen Jahre. Ein schneller Hash wie SHA-256 allein ist für Passwörter deshalb falsch.

3. Verschlüsseln

Mit einem Schlüssel: AES

# verschlüsseln, fragt nach einem Passwort
openssl enc -aes-256-cbc -pbkdf2 -in letter.txt -out letter.enc
# die Bytes ansehen: nichts mehr zu erkennen
xxd letter.enc | head
# zurück, mit demselben Passwort
openssl enc -d -aes-256-cbc -pbkdf2 -in letter.enc

-pbkdf2 macht aus dem Passwort einen Schlüssel, langsam und mit Salz, wie bei Passwort-Hashes. Wer entschlüsseln will, braucht dasselbe Passwort und dieselben Angaben. Mit -a kommt das Ergebnis als Text in Base64 heraus, das man in eine Nachricht kopieren kann; beim Entschlüsseln dann ebenfalls -a.

Mit zwei Schlüsseln: RSA

# ein privater Schlüssel; er bleibt bei dir
openssl genpkey -algorithm RSA -out private.pem
# der öffentliche Schlüssel dazu; ihn darf jeder haben
openssl pkey -in private.pem -pubout -out public.pem
# verschlüsseln, mit dem öffentlichen Schlüssel des Empfängers
openssl pkeyutl -encrypt -pubin -inkey public.pem -in a.txt -out a.enc
# entschlüsseln: Das kann nur der private Schlüssel
openssl pkeyutl -decrypt -inkey private.pem -in a.enc

RSA verschlüsselt nur kurze Daten, bei einem Schlüssel mit 2048 Bit höchstens gut 200 Bytes. Für mehr schickt man mit RSA einen zufälligen AES-Schlüssel und verschlüsselt den Rest mit AES; so macht es auch HTTPS.

4. Unterschreiben

# ein Schlüsselpaar: key privat, key.pub öffentlich,
# ohne Passwort (-N ""), mit dem Namen alice als Kommentar
ssh-keygen -t ed25519 -f key -N "" -C "alice"
# unterschreiben; die Unterschrift steht in letter.txt.sig
ssh-keygen -Y sign -f key -n file letter.txt
# eine Liste, wem welcher öffentliche Schlüssel gehört
echo "alice $(cat key.pub)" > allowed_signers
# prüfen: Good "file" signature for alice, oder ein Fehler,
# wenn sich der Brief geändert hat
ssh-keygen -Y verify -f allowed_signers -I alice -n file -s letter.txt.sig < letter.txt
# der Fingerabdruck des Schlüssels, SHA256:…, kurz genug zum Vergleichen
ssh-keygen -lf key.pub

Eine Unterschrift beweist zweierlei: Der Text ist unverändert, und er kommt von dem, der den privaten Schlüssel hat. Ob ein öffentlicher Schlüssel wirklich zu der Person gehört, sagt sie nicht: Das prüft man auf einem anderen Weg, etwa indem man den Fingerabdruck vorliest.

5. Bytes als Text

Schreibweise Zeichen Im Terminal
hexadezimal 0–9, a–f; zwei Zeichen je Byte xxd datei
Base64 A–Z, a–z, 0–9, +, /; vier Zeichen je drei Bytes, = füllt auf base64 datei, zurück mit base64 -d
Base32 A–Z, 2–7; je Zeichen 5 Bit, gut abzutippen base32 datei, zurück mit base32 -d

Alle drei lassen sich ohne Schlüssel zurückverwandeln. Sie machen Bytes nur lesbar und kopierbar, geheim machen sie nichts.

6. In Programmen

In Python sind data und key Bytes, kein Text: "geheim".encode() macht aus einem Text Bytes.

SHA-256

Der Hash von Bytes, als 64 Hexziffern.

require 'digest'
Digest::SHA256.hexdigest(data)
import hashlib
hashlib.sha256(data).hexdigest()

HMAC

Eine Prüfsumme mit Schlüssel, wie sie eine Authenticator-App rechnet, hier mit SHA-1. Heraus kommen Bytes.

require 'openssl'
OpenSSL::HMAC.digest('SHA1', key, data)
import hmac, hashlib
hmac.new(key, data, hashlib.sha1).digest()

Base64

Bytes als Text und zurück.

text = [data].pack('m0')
data = text.unpack1('m0')
import base64
text = base64.b64encode(data)
data = base64.b64decode(text)

Zufällige Bytes

Für Schlüssel und Salz, hier 20 Bytes. Nimm dafür nie rand oder random: Deren Zahlen lassen sich vorhersagen.

require 'securerandom'
SecureRandom.random_bytes(20)
import secrets
secrets.token_bytes(20)

7. Zum Nachschlagen