Passwörter im Terminal erzeugen: was funktioniert und was still und leise scheitert

Veröffentlicht am von David Carrero

Im Mai erschien auf Medium ein Tutorial mit einem Titel, an dem man schwer vorbeikommt: Generate Unbreakable Passwords in Your Terminal Using Pure Bash. Der Grundgedanke ist gut, und wir teilen ihn: Das Terminal bringt bereits einen hervorragenden Passwortgenerator mit, man muss nichts installieren, und das Passwort verlässt deinen Rechner nicht. Es ist dasselbe, wofür diese Website mit dem Generator im Browser eintritt, nur ohne Browser.

Also haben wir seine Befehle kopiert und auf einem Mac ausgeführt, am 10. November 2026, mit macOS 27.2 und spanischem Gebietsschema. Und zum Vergleich auf einem Linux. Was funktioniert, funktioniert sehr gut. Was scheitert, scheitert in mehreren Fällen, ohne ein Wort zu sagen, und das ist das Schlimmste, was einem Passwortgenerator passieren kann.

Woher der Zufall kommt

Das Tutorial beginnt mit dem, worauf es wirklich ankommt: openssl rand -base64 32 liefert dir 32 zufällige Bytes in Base64, und /dev/urandom ist die Quelle, aus der fast alle anderen Befehle schöpfen.

Eine Einschränkung, denn das Tutorial erzählt es etwas romantischer, als es ist. Weder openssl rand noch /dev/urandom liefern dir „reinen physikalischen Zufall“: Beide sind ein kryptografischer Generator, ein CSPRNG, den das Betriebssystem mit echtem Rauschen aus der Hardware füttert und der von da an Bytes erzeugt, die niemand vorhersagen kann. OpenSSL schreibt es in seiner Dokumentation: Es ist ein deterministischer Generator nach dem Modell von NIST SP 800-90A, der sich selbst aus dem System initialisiert und neu initialisiert. Linux verwendet einen auf Basis von ChaCha20, macOS laut Apples Sicherheitsleitfaden einen, der von Fortuna abgeleitet ist.

Das ist kein Mangel, sondern der Grund, warum es funktioniert: Ein gut initialisierter CSPRNG ist genau das, was man will. Es ist dieselbe Art von Quelle wie crypto.getRandomValues(), die der Generator dieser Website verwendet.

Und noch etwas macht das Tutorial richtig, ohne damit anzugeben, obwohl es das sollte: Der Trick mit tr -dc, nur die Bytes zu behalten, die ins Alphabet fallen, und den Rest wegzuwerfen, erzeugt keine Verzerrung. Das ist der richtige Weg. Der naive Weg, das Byte zu nehmen und den Rest der Division durch die Größe des Alphabets zu bilden, bevorzugt manche Zeichen vor anderen; Verwerfen nicht.

Auf einem Mac liefert der Befehl einen Buchstaben

Das ist der Befehl des Tutorials für ein Passwort aus Buchstaben und Ziffern:

cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c 32

Auf dem Mac mit spanischem Gebietsschema kommt das heraus:

tr: Illegal byte sequence

Und darunter ein E. Ein einziger Buchstabe. Der Exit-Code ist 0: Für das Terminal ist alles glattgegangen.

Die Ursache: Das tr von macOS liest seine Eingabe als Text in der Kodierung deines Gebietsschemas, UTF-8, und zufällige Bytes ergeben fast nie gültiges UTF-8. Sobald es auf das erste stößt, das nicht passt, hört es auf. Was es bis dahin gefiltert hatte, manchmal nichts, manchmal ein paar Zeichen, landet bei head, und head kann nicht wissen, dass es 32 erwartet hat.

Unter Linux passiert das nicht: GNU tr arbeitet mit Bytes und schaut nicht auf das Gebietsschema. Wir haben es in einem Debian-Container ausprobiert, und alle 32 Zeichen kamen heraus. Deshalb kann ein Tutorial, das unter Linux geschrieben und getestet wurde, für seinen Autor völlig in Ordnung sein und auf dem Mac seiner Leser kaputtgehen.

Die Lösung ist eine vorangestellte Variable: LC_ALL=C tr -dc …, die tr sagt, die Eingabe als Bytes zu behandeln. Wichtig ist aber nicht die Lösung, sondern die Art des Fehlers. Steht die Funktion genpass aus dem Tutorial in der .bashrc eines Macs, gibt sie dieses E aus, als wäre es ein Passwort. Fügst du es ungeprüft in ein Feld ohne Mindestlänge ein, ist es schon dein Passwort.

Der Bindestrich, der keiner war

Für die Version „mit Sonderzeichen“ verwendet das Tutorial dieses Alphabet:

tr -dc 'a-zA-Z0-9!@#$%^&*()_+-=[]{}'

Die Absicht ist klar: Buchstaben, Ziffern und achtzehn Sonderzeichen. Aber für tr ist ein Bindestrich zwischen zwei Zeichen ein Bereich, genau wie in a-z. +-= bedeutet also nicht „Plus, Bindestrich, Gleich“, sondern alles, was in der ASCII-Tabelle zwischen + und = liegt, und dazu gehören das Komma, der Punkt, der Schrägstrich, die zehn Ziffern, der Doppelpunkt, das Semikolon und das Kleiner-als-Zeichen.

Wir haben es gemessen, indem wir zwei Millionen Bytes erzeugt und die verschiedenen Zeichen gezählt haben, die herauskamen: 86, nicht die beabsichtigten 80. Unter macOS genauso wie unter Linux. Ein Sicherheitsproblem ist das nicht, sechs Zeichen mehr bringen etwas mehr Entropie, nicht weniger; das Problem ist, dass man nicht weiß, was man erzeugt. Wenn das System, in das das Passwort soll, ein ; oder ein < ablehnt, scheitert der Befehl ab und zu, und es gibt keine Möglichkeit zu erraten, warum. Die Regel lautet: den Bindestrich ans Ende der Menge setzen, wo tr ihn als Bindestrich liest.

Und wir sagen das in aller Bescheidenheit, denn beim Schreiben der korrigierten Version weiter unten sind wir in eine Falle derselben Familie getappt: Wir hatten das Alphabet als Standardwert eines Parameters eingesetzt, ${2:-…{}-}, und die erste schließende geschweifte Klammer des Alphabets schloss den Parameter. Das Ergebnis erzeugte ein |, das niemand bestellt hatte, und hatte den Bindestrich verloren. Wir haben es nur bemerkt, weil wir die Zeichen gezählt haben, die herauskamen.

64 Zeichen, die manchmal 58 sind

Der Standardmodus der Funktion macht Folgendes:

openssl rand -base64 48 | tr -dc 'a-zA-Z0-9' | head -c "$LENGTH"

48 Bytes in Base64 ergeben 64 Zeichen. Base64 enthält aber + und /, und der Filter wirft sie weg, also bleibt etwas weniger als 64 übrig. Für die 32 der Standardlänge reicht das locker. Für genpass 64 nicht: Wir haben es 200-mal ausgeführt, und nur 28 kamen mit 64 Zeichen heraus; der Rest mit 58 bis 63. Ohne Warnung.

Der Hex-Modus hat seine eigene Version desselben Problems: Er teilt die Länge durch zwei, um die Bytes zu berechnen, also liefert genpass 15 hex 14.

Der Bewerter, der P@ssw0rd applaudiert

Das Tutorial schließt mit einem Skript, das Passwörter bewertet: Punkte für die Länge, einer für Kleinbuchstaben, einer für Großbuchstaben, einer für Ziffern und zwei für Sonderzeichen. Wir haben es mit ein paar Passwörtern laufen lassen:

  • P@ssw0rd — STRONG
  • Sommer2026! — STRONG
  • correct-horse-battery-staple — STRONG
  • 35-mal der Buchstabe a — MODERATE

P@ssw0rd bekommt dieselbe Note wie vier zufällige Wörter. Es gehört zu den ersten, die jedes Angriffswörterbuch ausprobiert. Das Skript kann das nicht wissen, weil es nicht darauf schaut, was das Passwort ist, sondern nur, aus welchen Zeichenarten es besteht. Es ist genau die Regel „ein Großbuchstabe, eine Zahl und ein Sonderzeichen“, die NIST seit 2017 nicht mehr empfiehlt und über die wir schon in das Passwort-Spiel geschrieben haben.

Es gibt noch ein zweites, praktischeres Problem: Das Skript bekommt das Passwort als Argument, ./scorepass.sh "P@ssw0rd". Damit steht es in der History deiner Shell, in ~/.zsh_history oder ~/.bash_history, und ist, während es läuft, für jeden anderen Benutzer des Rechners sichtbar, der sich die Prozesse auflisten lässt. Um ein echtes Passwort zu testen, prüft der Passwort-Checker dieser Website Muster, Wörterbücher und Ersetzungen wie @ statt a, und das in deinem Browser, ohne etwas zu verschicken.

Wie viel genug ist

Das Tutorial verkauft die 256 Bit von openssl rand -base64 32 als „dieselbe Stärke, die Banktransaktionen schützt“. Die Zahl stimmt, der Vergleich ist überflüssig: 256 Bit sind weit mehr, als ein Passwort braucht. Mit dem Angriffsmodell, das überall auf dieser Website gilt, 10¹² Versuche pro Sekunde, offline und mit schnellem Hash, kommen 128 Bit schon auf 10¹⁹ Jahre. Es spricht nichts dagegen, 256 zu nehmen, aber man sollte „mehr“ nicht mit „nötig“ verwechseln. Ausführlich erklären wir das in wie lange es dauert, ein Passwort zu knacken.

Zwei Details zu den Formaten, bei denen es nicht um Sicherheit geht, sondern um die Benutzung:

  • Base64 ist nicht URL-sicher, auch wenn das Tutorial das behauptet: Es enthält +, / und das = am Ende. Dieses = ist Auffüllung, kein Zufall; die 256 Bit stecken in den 43 Zeichen davor. Es gibt eine Variante, base64url, die + und / durch - und _ ersetzt, aber openssl rand -base64 verwendet sie nicht.
  • Hexadezimal liefert 4 Bit pro Zeichen, halb so viel wie ein Alphabet aus Buchstaben, Ziffern und Sonderzeichen. openssl rand -hex 32 erzeugt 64 Zeichen und 256 Bit: perfekt für einen API-Schlüssel. Aber genpass 16 hex liefert 16 Zeichen und 64 Bit, die mit demselben Angriffsmodell im Schnitt nach etwa 107 Tagen geknackt sind. Es sieht lang aus; so lang ist es nicht.

Die Wörter, und ein Beispiel, das aus keinem Befehl stammt

Der Modus words holt Wörter mit shuf aus /usr/share/dict/words. Auf einem Mac gibt es shuf nicht: Es gehört zu GNU, und macOS bringt es nicht mit, also funktioniert dieser Modus schlicht nicht. Die Liste ist aber da, und sie hat 235.976 Wörter, was mit vier davon etwa 71 Bit ergäbe. Viel. Das Problem ist, dass ein guter Teil davon Wörter sind, die du noch nie gesehen hast, und der ganze Witz einer Passphrase ist, dass man sie sich merken kann.

Die Beispielausgabe im Tutorial, correct-horse-battery-staple, hat kein Befehl erzeugt: Es ist der Satz aus dem XKCD-Comic 936 von 2011. Der Comic hat recht mit dem, was er sagt, nämlich dass vier zufällig gewählte Wörter ein Wort mit Ersetzungen schlagen, aber das Tutorial fasst ihn als „Länge schlägt immer Komplexität“ zusammen, und das sagt er nicht. Was gewinnt, ist die Zahl der Möglichkeiten, aus denen zufällig gewählt wurde. Fünfunddreißig a haben Länge im Überfluss und keinerlei Entropie. Wenn du gut gemachte Passphrasen willst, verwendet Diceware eine Liste von 7.776 Wörtern, die zum Merken ausgewählt sind, mit 12,9 Bit pro Wort.

Eine Version, die laut scheitert

Das schlagen wir vor. Vor der Veröffentlichung haben wir sie in bash und zsh unter macOS und in bash unter Linux getestet:

genpass() {
  local n="${1:-20}" set='A-Za-z0-9!@#%^&*()_+=-' pw
  [ -n "$2" ] && set="$2"
  pw=$(LC_ALL=C tr -dc "$set" < /dev/urandom | head -c "$n")
  [ "${#pw}" -eq "$n" ] || { echo "genpass: fehlgeschlagen" >&2; return 1; }
  printf '%s\n' "$pw"
}

Drei Entscheidungen, jede wegen eines der Fehler oben:

  • LC_ALL=C vor tr, damit es auf einem Mac Bytes liest und nicht abbricht.
  • Der Bindestrich am Ende des Alphabets, damit er ein Bindestrich ist. Wir haben es durch Zählen überprüft: Es kommen genau die 75 Zeichen heraus, die dort stehen, keines mehr.
  • Die Längenprüfung. Wenn das Passwort aus welchem Grund auch immer kürzer ausfällt als verlangt, gibt die Funktion es nicht aus, meldet sich auf der Fehlerausgabe und liefert einen Code ungleich 0. Dass ein Generator scheitert, ist in Ordnung. Dass er scheitert und trotzdem etwas ausliefert, darf nicht passieren.

genpass liefert 20 Zeichen aus diesem Alphabet, etwa 124 Bit. genpass 32 liefert 32. genpass 6 0-9 liefert eine PIN. Das Alphabet lässt absichtlich $, den Backtick und die Anführungszeichen weg: Das sind die Zeichen, die eine Shell oder eine Konfigurationsdatei interpretiert, und ein Passwort, das beim Einfügen in eine .env kaputtgeht, ist nicht sicherer, sondern nur lästiger.

Was das Tutorial am Ende richtig macht

Der letzte Abschnitt des Tutorials ist der beste: Erzeugen ist leicht, schwer ist, nichts wiederzuverwenden. Ein 256-Bit-Passwort, das auf zwei Websites benutzt wird, ist auf beiden kompromittiert, sobald eine der beiden ein Datenleck hat. Sein Vorschlag, im Terminal erzeugen und in einem Passwort-Manager wie Bitwarden oder KeePass speichern, ist genau die einzige Regel, die überlebt hat.

Eine letzte Warnung zu seinem anderen Vorschlag, mit pbcopy oder xclip in die Zwischenablage zu kopieren. Das ist besser, als das Passwort auf dem Bildschirm auszugeben, aber die Zwischenablage ist kein privater Ort: Zwischenablage-Manager führen einen Verlauf, und auf einem Mac mit aktiviertem Handoff kann das, was du kopierst, auch auf deinem iPhone auftauchen. Kopieren, einfügen und etwas anderes darüber kopieren.


Quellen: das Tutorial „Generate Unbreakable Passwords in Your Terminal Using Pure Bash“, veröffentlicht auf Medium am 12. Mai 2026 · alle Befehle wurden am 10. November 2026 unter macOS 27.2 (bash 3.2, zsh, das tr des Systems, OpenSSL 4.1) und in einem stabilen Debian-Container mit GNU coreutils 9.7 ausgeführt · OpenSSL-Dokumentation, RAND(7): deterministischer Generator nach NIST SP 800-90A Rev. 1, initialisiert aus dem Betriebssystem · Linux-Manpage random(4) · Apple, Apple Platform Security, Zufallszahlenerzeugung · XKCD 936, „Password Strength“ (2011) · NIST SP 800-63B (2017) zu den Zusammensetzungsregeln · das Angriffsmodell, 10¹² Versuche pro Sekunde offline mit schnellem Hash, ist dasselbe wie im Rest der Website.

Foto von Luis Gomes · Pexels

← Zurück zum Blog