it-swarm.com.de

Ein Liner zum Erstellen von Passwörtern unter Linux?

Wie erstellt man ein lesbares Passwort mit bash mit einer Zeile? Was ist, wenn ich nach 128 Bit Entropie suche?

[~ # ~] edit [~ # ~]

Mit lesbar meine ich die 94 druckbare ASCII-Zeichen (ohne Leerzeichen). Es kann weniger als diese Zeichen verwenden, solange es mindestens 128 Entropiebits hat.

32
Andras Gyomrey

Es kommt darauf an, was Sie unter "lesbar" verstehen. Wenn Sie nur hexadezimale Zeichen verwenden möchten, benötigen Sie 32 davon, um 128 Entropiebits zu erreichen. Diese Zeile funktioniert (nur mit Befehlen aus dem Paket coreutils):

head -c16 /dev/urandom | md5sum

Diese Variante erzeugt Passwörter mit nur Kleinbuchstaben von 'a' bis 'p' (dies ist das, was Sie wollen, wenn Sie das Passwort auf einem Smartphone "eingeben" müssen):

head -c16 /dev/urandom | md5sum | tr 0-9 g-p

Wenn Sie ein Zeichen weniger eingeben möchten, versuchen Sie Folgendes:

head -16 /dev/urandom | md5sum

(Die Wahrscheinlichkeit, alle ersten 16 zufälligen Bytes als 0x0A zu erhalten, d. H. Das "Zeilenumbruch" -Zeichen, beträgt 2-128, daher erhält diese Zeile immer noch 128 Bit Entropie.)

Sie beschränken sich immer noch auf Befehle von coreutils und können dies tun:

mktemp -u XXXXXXXXXXXXXXXXXXXXXX

Dieser generiert ein 22-stelliges Passwort mit /dev/urandom als interne Quelle der Zufälligkeit (Ich habe den Quellcode eingecheckt und ein strace -Aufruf bestätigt). Die Zeichen sind Buchstaben (Groß- und Kleinbuchstaben) und Ziffern. seit 6222 ist größer als 2128sind die 22 Zeichen ausreichend.

Noch eine:

od -An -x /dev/urandom | head -1

dies zeigt acht Sequenzen mit vier hexadezimalen Ziffern an. Möglicherweise kann diese Aufteilung in kleine Sequenzen das Lesen erleichtern.

Versuchen Sie Folgendes, um eine viel längere Zeile und ein ganz anderes Passwort zu erhalten:

for i in {1..8} ; do head -$(expr $(head -c7 /dev/urandom | od -An -t dL) % $(wc -l < /usr/share/dict/british-english)) /usr/share/dict/british-english | tail -1 ; done

(Dieser funktioniert nur auf einem 64-Bit-Host. Werden Sie feststellen, warum?). Abgesehen von coreutils erfordert diese Version auch eine Wörterbuchdatei, hier die für britisches Englisch.

53
Thomas Pornin

Einige tolle Vorschläge in den anderen Antworten. Ich finde, dass makepasswd nicht überall verfügbar ist und die Verwendung von tr (etwas) schwierig ist, daher gibt es eine andere Option, die OpenSSL verwendet:

openssl Rand -base64 16

Die Anzahl ist die Anzahl der Bytes der Zufälligkeit - also 16 Bytes für 128-Bit-Entropie.

22
paj28

Mit pwgen

Einfachster Oneliner aller Zeiten:

pwgen

Es wird versucht, Kennwörter zu erstellen, die leicht zu merken sind. Um dies zu deaktivieren und sicherere Passwörter zu erstellen, verwenden Sie das Flag --secure Oder -s.

pwgen -s

Sind die generierten Passwörter zu lang? Zu kurz? Fügen Sie einfach die gewünschte Länge hinzu:

pwgen 9
# Or
pwgen -s 9
# Or
pwgen 9 -s

Ähnliche Werkzeuge

Ich kenne pwgen einfach, es gibt andere Tools da draußen. Sie können sie mit der Suchfunktion Ihrer Distribution finden. In Debian ist dies:

apt-cache search password generator

Es wird eine genaue Suche durchgeführt (wobei die Groß- und Kleinschreibung nicht berücksichtigt wird). Die Verwendung von password generat Erweitert stattdessen die Suche.

Vor der Installation des Pakets kann es hilfreich sein, die Beschreibung anzuzeigen. Wieder in Debian:

apt-cache show $DESIRED_PACKAGE
# E.g.
apt-cache show pwgen

Werkzeuge, die ich so finden konnte:

  • pwgen
  • makepasswd
  • apg
  • otp (für einmalige Pads gedacht, nicht empfohlen)
  • gpw (konzentriert sich stark auf die Aussprache, nicht empfohlen)

Verwenden von Standard-Unix-Tools

Möglicherweise ist nicht für alle Systeme pwgen verfügbar. Wie andere geantwortet haben, können Sie md5sum Oder sha256sum Verwenden, aber das gibt nur 0-9 und a-f aus. Kein g-z oder gemischter Fall, geschweige denn Sonderzeichen. Es ist besser, nicht druckbare Zeichen einfach aus /dev/urandom Herauszufiltern, bis Sie ein Passwort mit der gewünschten Länge haben:

cat /dev/urandom | tr -cd '@-~' | head -c 8

Was so etwas wie XiVsdn[y Oder [email protected]^lY Gibt. Sie können das 8 Am Ende für die gewünschte Passwortlänge ändern. Sie können auch den Teil @-~ Ändern, um die Zeichen zu begrenzen. Dies gibt beispielsweise nur alphanumerische Zeichen aus:

cat /dev/urandom | tr -cd 'a-zA-Z0-9' | head -c 8

Dies ist fast identisch mit dem, was pwgen -s Tun würde, und gibt Passwörter wie nZiUzNtE an.

Als Bonus ist das Tool tr in fast allen Betriebssystemen (Mac OS X, GNU/Linux, Android/Linux, Solaris, FreeBSD usw.) außer Microsoft Windows enthalten.

11
Luc

Abhängig von der Art der Zeichen, die Sie einschließen können, sieht ein einfacher Befehl zum Erstellen eines lesbaren Kennworts mit 128 Entropiebits folgendermaßen aus:

< /dev/urandom tr -dc [:graph:] | head -c20; echo;

(Entnommen aus hier ). [:graph:] Sind alle ASCII-Zeichen außer Leerzeichen.

Erläuterung:

128 Bit entsprechen 3.40e + 38 Kombinationen. Wenn Sie 94 lesbare ASCII-Zeichen (außer Leerzeichen) verwenden, benötigen Sie 20 Zeichen , um zu erreichen mindestens diese Anzahl von Kombinationen: 94 ^ 20 = 2.90e + 39 .

Wenn Sie zum Beispiel nur _A-Za-z0-9 Verwenden dürfen:

< /dev/urandom tr -dc '_A-Za-z0-9' | head -c22; echo;

Für 63 mögliche Zeichen: 63 ^ 22 = 3.85e + 39 . Es werden nur zwei Zeichen hinzugefügt, um die volle Entropie zu erreichen.

Für hexadezimale Passwörter:

< /dev/urandom tr -dc 'A-F0-9' | head -c32; echo;

Hexadezimal ist einfach: 128 Bit sind 32-mal so groß wie ein Hexadezimalzeichen.

Wichtiger Hinweis : In den meisten Situationen, in denen Sie ein Passwort benötigen, verwenden Sie eine Hash-Funktion, die tatsächlich die tatsächliche Zeichenfolge ableitet verwendet werden. Diese Analyse hängt davon ab, wie das Passwort gehasht/verwendet wird.

Zusätzlicher Hinweis : /dev/urandom Ist für diesen Vorgang sicher. Bitte überprüfen Sie Ist ein Rand aus/dev/urandom für einen Anmeldeschlüssel sicher? .

Zusätzlicher Hinweis : Wenn Sie mehr als eine Iteration mit einer Hash-Funktion verwenden, können Sie die Bits subtrahieren, die zum Ausdrücken der Iteration der Gesamtbeträge von erforderlich sind Bits, die Sie erreichen können, z.

65536 Iterationen = 2 ^ 16 Iterationen, ungefähr hinzufügen 16 Bit (2 Byte) Entropie zum gewählten Passwort, da Sie bei einem Brute-Force-Angriff 2 ^ 16 zusätzliche Iterationen durchführen müssen, bevor Sie den verwendeten Hash berechnen.

Nur für die Aufzeichnung ist es unnötig, über 128 Bit Entropie hinauszugehen, wie hier erläutert: Anzahl einfacher Operationen, die für die gesamte Menschheit sicher unerreichbar sind?

Aber wenn Ihre Paranoia darüber hinausgeht, sind hier einige nützliche Zahlen:

Alle ASCII lesbar ( 29 Zeichen , 1.6e + 57 Kombinationen), 192 Bit (6.28e + 57 Kombinationen) der Entropie:

< /dev/urandom tr -dc [:graph:] | head -c29; echo;

_A-Za-z0-9 ( 32 Zeichen , 3.79e + 57 Kombinationen), 192 Bits (6.28e + 57 Kombinationen) der Entropie:

< /dev/urandom tr -dc '_A-Za-z0-9' | head -c32; echo;

A-F0-9 ( 48 Zeichen , 16 ^ 48 Kombinationen ), 192 Bits (2 ^ 192 Kombinationen) der Entropie:

< /dev/urandom tr -dc 'A-F0-9' | head -c48; echo;

Alle ASCII lesbar ( 39 Zeichen , 8,95e + 76 Kombinationen), 256 Bit (1.16e + 77 Kombinationen) Entropie:

< /dev/urandom tr -dc [:graph:] | head -c39; echo;

_A-Za-z0-9 ( 43 Zeichen , 2.35e + 77 Kombinationen), 256 Bit (1.16e + 77 Kombinationen) der Entropie:

< /dev/urandom tr -dc '_A-Za-z0-9' | head -c43; echo;

A-F0-9 ( 64 Zeichen , 16 ^ 64 Kombinationen ), 256 Bit (2 ^ 256 Kombinationen) der Entropie:

< /dev/urandom tr -dc 'A-F0-9' | head -c64; echo;

Angesichts der Tatsache, dass die letzten sechs Optionen bereits paranoid sind, ist es völlig sinnlos, komplexere oder größere Passwörter als die oben beschriebenen zu wählen.

10
Andras Gyomrey

Ein Einzeiler zum Erstellen eines lesbaren und relativ leicht zu merkenden Passworts:

cat /usr/share/dict/words | shuf -n 4 | tr '\n' ' '| tr -d \'

Beispielausgabe:

correct horse battery staple

Wenn Sie ein längeres Passwort wünschen, ändern Sie die 4 in eine höhere Zahl. Fügen Sie für ein Kennwort ohne Leerzeichen am Ende der Zeile ein Leerzeichen ein:

cat /usr/share/dict/words | shuf -n 4 | tr '\n' ' ' | tr -d \ \'
5
ONOZ

Es gibt ein Paket namens makepasswd, das dies kann.

 $ makepasswd --chars 64
3
Fred Concklin

Ich würde apg mit 16-Byte-Seed aus/dev/urandom verwenden (maximal erlaubt)

apg -a 0 -d -m 15 -n 1 -c "`head -c16 /dev/urandom`"; echo

Sie können die apg-Befehle verketten, um ein längeres Passwort für mehr Entropie zu erhalten.

Damit die zufälligen Informationen lesbar sind, können wir sie in base64 codieren. Ein Zeichen in base64 hat 6 Entropiebits. Für 128 Bit Entropie benötigen Sie also 22 Zeichen (128/6 = 21 + ⅓).

Dies führt uns zu dem Befehl:

base64 < /dev/urandom | head -c 22

Was in Englisch übersetzt werden kann durch "Generieren von Zufallsdaten in kryptografischer Qualität mit/dev/urandom und Konvertieren in base64, behalten Sie die ersten 22 Zeichen".

Möglicherweise möchten Sie am Ende der Ausgabe ein zusätzliches Zeichen für das Zeilenende hinzufügen:

echo $(base64 < /dev/urandom | head -c 22)
1
uuidgen

wird Ihnen eine UUID zur Verfügung stellen; Denken Sie daran, zu überprüfen, welche UUID-Version auf Ihrem Computer generiert wird, da einige Versionen es jemandem ermöglichen, der Ihr Kennwort abruft, es auf Ihrem Computer zu verfolgen, was (wahrscheinlich) ein Sicherheitsproblem darstellt. Sie können verwenden

uuidgen -r

um sicherzustellen, dass die ID nur aus zufälligen (ish) Ziffern besteht und nicht zu Ihnen verfolgt werden kann. Die Zeichenfolge besteht aus [a-z0-9] und -. Beispielausgabe:

4bc1b05b-77b5-4a4c-8300-e9dc53350fcb

Die Qualität der Zeichenfolge hängt von der Fähigkeit Ihres Betriebssystems ab, Zufallszahlen zu generieren (/dev/random).

0
Clearer

Ich weiß, dass Sie nach einer Zeile gefragt haben, aber sie ist mit mehr wirklich robuster. ;-);

Die Hauptarbeit kann auf eine Zeile komprimiert werden, wenn Sie die Fehlerprüfung und Kompatibilität zwischen verschiedenen Versionen des Dienstprogramms base64 Beseitigen möchten. Diese Implementierung funktioniert sowohl unter OS X als auch unter Linux. (Siehe die Funktion create_password und ersetzen Sie do_base64 durch einfaches base64 durch die entsprechenden Argumente.) Sie können die Funktion do_base64 durch Ihre eigene Funktion für ersetzen Auswahl von ASCII Zeichen basierend auf einer Binäreingabe, aber unter Verwendung von base64 (mit einem sed, um / zu eliminieren, + und =) Damit erhalten Sie Groß-, Klein- und Kleinbuchstaben. (26 + 26 + 10 = 62; nicht sicher, welche 94 Zeichen Sie gemeint haben.)

Geben Sie die gewünschte Kennwortlänge als Argument an.

#!/bin/bash

function abort {
    echo "Error: $*"
    exit 2
}

function do_base64 {
    WRAP=""
    base64 --help | grep -q -- --wrap && WRAP="-w 0"
    base64 $WRAP [email protected]
}

function create_password {
    let bytes=$1*2
    dd if=/dev/urandom 2> /dev/null bs=$bytes count=1 \
        | do_base64 \
        | sed s/[\/\+=]//g \
        | cut -c 1-${1}
}

if [ "$1" == "" ]; then
    echo "Usage: $0 <desired-password-length>"
    exit 1
fi
let length=0+"$1" 2> /dev/null || abort "Password length must be numeric"

create_password $1

Beispielausgabe:

$ mkpasswd 16
2LjxTkQHP7Lv4z0J

$ mkpasswd 24
txhhbeHfGZSl0UNRvsz78yFo

$ mkpasswd 64
TykZF3hMXcZp0rP4ig0d9zRsuVEDxHjIcLHGcNaf0ROhk66VCPc7tE8GXcVv7AKh

Außerdem möchten Sie wahrscheinlich /dev/urandom Durch /dev/random Ersetzen, wenn Sie die richtige Entropie erhalten möchten. (Ich habe es während der Entwicklung in /dev/urandom Geändert, da mein Entropiepool erschöpft war.)

0
mpontillo

Hier ist eine Funktion, die ein Passwort mit mindestens 128 Entropiebits unter Verwendung von Zufallszahlen zwischen 33 und 126 erstellt.

pgen() {
    local start=33 end=126 # printable, non-whitespace characters
    local entropy=128

    # Calculate minimum length to meet required entropy
    local length=$(echo "($entropy/(l($((end+1-start)))/l(2)))" | bc -l)
    length=$(echo "scale=0; ($length+0.5)/1" | bc) # round result up

    # Use $1 as length if it has enough entropy
    [ -n "$1" ] && [ $1 -gt $length 2>/dev/null ] && length=$1

    for _ in $(seq $length); do
        printf \\$(printf '%03o' \
            $(shuf --random-source=/dev/urandom -i $start-$end -n1))
    done
    echo
}

Die Funktion berechnet die Mindestlänge, die erforderlich ist, um die Entropieanforderungen zu erfüllen (in diesem Fall Länge 20), und gibt ein Kennwort dieser Länge aus.

Das erste Argument kann die Länge des in stdout geschriebenen Kennworts angeben, sofern es größer als die Mindestlänge ist, um die Entropieanforderung zu erfüllen.

$ pgen
xx6r6e%Og;_8<4)o#aPO
0
John B