In einem Forum tauchte kürzlich der Wunsch nach einem Passwort Generator auf, der ganz spezielle Anforderungen erfüllen sollte. Wie es oft ist, sind solche eher exotischen Anforderungen nicht vorgefertigt zu haben. Zum Glück kann man sich unter macOS das auch recht einfach selbst zusammen bauen. Und darum gibt es heute hier einen klitze-kleinen Crashkurs in der Programmierung eines Passwort Generators.

Hier nun erst einmal die Anforderungen an den Passwortmanager:

  1. zufällige Zeichen, incl. Sonderzeichen, ausgenommen aber „0oO_iIlqg,.“, da diese bei manchen Schriftbildern oft schwer eindeutig zu identifizieren sind. So wird zum Beispiel „O“ (der Buchstabe) gerne mit „0“ (der Zahl) verwechselt.
  2. Es darf kein Sonderzeichen am Anfang und am Ende stehen
  3. Das Passwort soll direkt in die Zwischenablage gelegt werden, ohne vorherige Anzeige
  4. und das alles soll mit einem global wirksamen Shortcuts, sprich Tastenkombination, aufgerufen werden können

Auch wenn es nach viel Aufwand klingt, ist es doch mit einigen Shell-Befehlen recht einfach zu erledigen.

Als erstes benötigen wir eine zufällige Ausgabe von Zeichen. macOS besitzt für so etwas ein Device, dass zufällige Zahlen erzeugt, die wir dann halt einfach als Zeichen interpretieren. Dieses Device nennt sich /dev/urandom.

Damit wir die von /dev/urandom erzeugte Ausgabe begrenzen können, nehmen wir den Befehl head. Der begrenzt die ihm übermittelten Daten auf die ersten 10 Zeilen. Da /dev/urandom auch sicher mal zufällig Zeilenende-Zeichen generiert, kriegen wir recht elegant ein ausreichend großes Ausgangsmaterial zusammen. Unser Befehl sieht bis jetzt also so aus

head /dev/urandom

Das gibt nun natürlich aber alle möglichen Zeichen, auch nicht darstellbare Zeichen, was uns nicht viel bringt. Und darum filtern wir uns die Ausgabe, so dass nur Buchstaben, Ziffern und Sonderzeichen enthalten sind und alles andere ausgeblendet wird. Dazu eignet sich der Befehl tr hervorragend. Mit dem Parameter -d (delete) bestimmen wir, dass das nachfolgend angegebene Set an Zeichen gelöscht wird, mit dem Parameter -c (complement) legen wir ein Set fest, welche Zeichen nicht im Set enthalten sein sollen, also gelöscht werden können. Das wäre dann das zu behaltende Set '!-Za-z'. Ihr könnt einer ASCII-Tabelle entnehmen, dass die Sonderzeichen, Buchstaben und Ziffern sind, ohne die eckigen oder geschweiften Klammern und ohne Pipe und Backslash, also eigentlich alle, die sich auf einem Mac einfach eingeben lassen.

Da wir die Befehle mit einer Pipe verknüpfen legen wir zu tr noch die Sprache fest, da ansonsten ein Fehler auftauchen würde (illegal byte sequence)

Und somit erhalten wir nun diese Befehlszeile

head /dev/urandom | LANG=C tr -dc '!-Za-z'

Das sieht nun schon deutlich besser aus. Wir müssen aber noch die unerwünschten Buchstaben und Zeichen entfernen und die Länge noch etwas besser begrenzen. Fürs löschen der Zeichen nehmen wir wieder tr, diesmal nur mit -d und dem Set '0oO_iIlqg,.' das wir noch um ein paar weitere schwer zu unterscheidende Zeichen erweitern. Fürs Begrenzen kommt der Befehl cut zum Einsatz. Dort werden mit -c1-16 einfach nur die ersten 16 Zeichen übernommen.

Wenn wir das nun zusammen setzen, erhalten wir fast schon unser Passwort. Bis auf die 2. Anforderung (keine Sonderzeichen am Anfang oder Ende) ist bereits alles erfüllt

head /dev/urandom | LANG=C tr -dc '!-Za-z' | LANG=C tr -d '0oO_iIlqg,.:;"´`'"'" | cut -c1-16  

Für alles weitere benötigen wir ein Shell-Script, in das wir nun erst mal diese Befehlszeile aufnehmen und die Ausgabe einer Variablen zuweisen, die den mittleren Teil unseres Passwortes darstellt. Anschließend werden wir nach dem gleichen Muster zwei Variablen anlegen, die das erste und das letzte Zeichen gemäß der 2. Anforderung aufnehmen. Die Spracheinstellung können wir zudem für das ganze Script vorgeben. Unser Shell-Script sieht dann bis hierher so aus:

#!/bin/zsh
LANG=C
first=$(head /dev/urandom | tr -dc 'a-zA-Z0-9' | tr -d '0oOiIlqg' | cut -c1)
last=$(head /dev/urandom | tr -dc 'a-zA-Z0-9' | tr -d '0oOiIlqg' | cut -c1)
between=$(head /dev/urandom | tr -dc '!-Za-z' | tr -d '0oO_iIlqg,.:;"´`'"'" | cut -c1-14)

Wenn wir die Variablen zusammenfügen, haben wir unsere Passwort. Um das in die Zwischenablage zu bringen, bietet uns macOS den Befehl pbcopy an. Und so ist unser Passwort fertig (2. Anforderung) und direkt in der Zwischenablage gelandet (3. Anforderung).

#!/bin/zsh
LANG=C
first=$(head /dev/urandom | tr -dc 'a-zA-Z0-9' | tr -d '0oOiIlqg' | cut -c1)
last=$(head /dev/urandom | tr -dc 'a-zA-Z0-9' | tr -d '0oOiIlqg' | cut -c1)
between=$(head /dev/urandom | tr -dc '!-Za-z' | tr -d '0oO_iIlqg,.:;"´`'"'" | cut -c1-14)

echo -n $first$between$last | pbcopy

Nun fehlt nur noch die 4. Anforderung einer global wirksamen Tastenkombination. Als macOS-User:in kennt ihr sicherlich Automator.app. Damit können wir einen „Dienst“ (oder auch „Schnellaktion“ genannt) erstellen, dem einen Tastenkombination zugewiesen werden kann. Dieser Dienst enthält unser oben erstelltes Shell-Script.

Dazu startet ihr Automator, erstellt ein neues Dokument und wählt „Schnellaktion“ als Art aus.

In der linken Rubrik wählt ihr „Dienstprogramme“ und zieht dann aus der Spalte daneben das Symbol „Shell-Skript ausführen“ ins rechte Fenster. Im oberen Teil stellt ihr „Arbeitsablauf empfängt“ auf „keine Eingabe“ und in auf „in jedem Programm“. Im „Shell-Skript ausführen“-Fenster stellt ihr „Eingabe übergeben“ auf „Als Argumente“ und löscht den dann erscheinenden Vorgabetext und kopiert dafür unser obiges Script hinein. (Die erste Zeile mit #!/bin/zsh lasst ihr weg) Das sieht dann so aus:

Nun speichert das Script als z.B. „PassGen“. Für die Tastenkombination geht ihr im Menü auf Automator -> Dienste -> Diensteeinstellungen und sucht euch den gerade gespeicherten Dienst PassGen. Wenn ihr den auswählt, erscheint der Button „Kurzbefehl hinzufügen“. Dort klickt ihr drauf und drückt dann im Eingabefeld die gewünschte Tastenkombination. Nachdem ihr einen anderen Lsiteneintrag angeklickt habt, seht ihr auch euren soeben angelegten Shortcuts. Ich habe in meinem Beispiel CTRL + CMD + P verwendet.

Fertig.

Nun könnt ihr also mit CTRL + CMD + P ein zufälliges Passwort direkt in die Zwischenablage hinein erzeugen und anschließend von dort aus mit CMD + V in einen beliebige Anwendung hinein kopieren.

Ich hoffe, dieser kleine Crashkurs in Sachen Shell- und Dienste-Programmierung hat euch Spaß gemacht und ihr habt Lust bekommen, die Möglichkeiten von macOS selbst weiter zu erkunden.

Update:
Ich habe die letzte Zeile des Scripts ergänzt, so dass kein newline mit in die Zwischenablage wandert und somit das Einfügen problemlos nur das Passwort ohne abschließendes Return heran zieht.


0 Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.

Bitte löse die kleine Aufgabe, um den Kommentar abzuschicken. *