Wie erstelle ich sichere Passwörter unter Linux?

Ich frage mich, wie ich unter Linux sichere Passwörter erstellen kann (sowohl für normale Benutzer als auch für Administratoren) und ob es dafür spezielle Programme gibt.

pwgen ist eines von vielen Programmen zur Generierung von Passwörtern

Persönlich bevorzuge ich es, keinen Passwortgenerator zu verwenden, da das generierte Passwort sehr schwer zu merken ist, aber eine tragbare Lösung ist / dev / urandom

Das Erstellen von zufälligen Passwörtern, die keine Sonderzeichen enthalten, hat eine Länge von 10 Zeichen:

$ cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c 10` 
dyxJRKldvp

Dies funktioniert, indem Bytes aus / dev / urandom abgerufen, diejenigen gelöscht werden, die nicht zu dem im trBefehl angegebenen Muster passen , und auf 10 Zeichen mit beschränkt werden head.

Das Erstellen von zufälligen Passwörtern, die Sonderzeichen enthalten, hat eine Länge von 10 Zeichen:

$ cat /dev/urandom | tr -dc 'a-zA-Z0-9-_!@#$%^&*()_+{}|:<>?=' | fold -w 10 | grep -i '[!@#$%^&*()_+{}|:<>?=]' | head -n 1
MSF4wj@vP0

Dies verwendet eine etwas andere Technik, nachdem trunerwünschte Bytes entfernt wurden, da erzwungen werden soll, mindestens ein Sonderzeichen zu haben. Dies funktioniert, indem Sie den foldBefehl verwenden, um die Zeile in Zehnergruppen umzubrechen und dann grepnur Zeilen abzurufen, die ein Sonderzeichen enthalten. headRuft dann das erste Kennwort ab, das die Anforderungen erfüllt.

Ich habe dieses kleine Drehbuch vor ein paar Jahren geschrieben und benutze es seitdem. Wenn überhaupt, dann ist es ein interessanter Missbrauch printfund verwendet ein schönes Merkmal BASH , dass ich leider nur selten in Skripten finden Sie unter : typeset.

#!/usr/bin/env bash
# Released into public domain
# Aaron Bockover, 2005
# http://abock.org

typeset -i length; length=$1
typeset -i rounds; rounds=$2
[ $rounds -lt 1 ] && rounds=1
[ $length -lt 1 ] && {
    echo "Usage: $0 <length> [<rounds>]" 2>/dev/null; exit 1;
}
for ((i=0; i < $rounds; i++)); do
    for ((j=0; j < $length; j++)); do
        set=$(($RANDOM % 20))
        if   [ $set -le 6 ];  then o=65; l=26; # 35% uppercase
        elif [ $set -le 13 ]; then o=97; l=26; # 35% lowercase
        elif [ $set -le 17 ]; then o=48; l=10; # 20% numeric
        elif [ $set -le 18 ]; then o=58; l=7;  # 10% symbolic
        elif [ $set -le 19 ]; then o=33; l=15; fi
        ord=$(($o + $RANDOM % $l))
        printf \\$(($ord / 64 * 100 + $ord % 64 / 8 * 10 + $ord % 8))
    done
    echo
done

Ich möchte auch KeePassX hinzufügen , mit dem Sie mithilfe der Systementropie sichere Kennwörter mit ein paar nützlichen Funktionen generieren können - und das alles über die GUI. Außerdem haben Sie die Möglichkeit, Ihre Passwörter zu verwalten und in einer verschlüsselten Datei zu speichern.

So sieht die Benutzeroberfläche des KPX-Passwortgenerators aus:

apg ist keine schlechte Wahl, wenn Sie ein Passwort möchten, an das Sie sich leicht erinnern können.

; apg -m 16 -a 0 -t
ByajNudgolIston9 (Byaj-Nud-gol-Ist-on-NINE)
Af}ockhuecUjrak8 (Af-RIGHT_BRACE-ock-huec-Uj-rak-EIGHT)
IakijKadmomIvgig (Iak-ij-Kad-mom-Iv-gig)
NutIlOsyahodBeef (Nut-Il-Os-ya-hod-Beef)
anMechOybekazell (an-Mech-Oyb-ek-az-ell)
VumushCummAd{fra (Vum-ush-Cumm-Ad-LEFT_BRACE-fra)

Beachten Sie, dass nach dieser , Ihr Passwort aus mindestens 12 Zeichen lang sein sollte.

Ich benutze eine nicht zufällig, sondern ist genug für alle Angriffszwecke ... Master - Passwort verändert, und letzten Durchgang zu anderen Passwörter zu generieren. So generiere ich das Master-Passwort.

echo -n "some seed" |  openssl dgst -binary -sha1 | base64 | sed -e 's/.\{4\}/& /g'

und die Ausgabe

H1sI Wpbj JE2P CdVJ A1qb 9B/e u7M= 

Wählen Sie jetzt nur einige der Abschnitte aus und erstellen Sie ein Passwort, ordnen Sie sie neu an, lassen Sie einige weg, fügen Sie ein Zeichen oder 2 hinzu, um es so gut wie zufällig zu machen. Solange Sie sich an Ihren Startwert erinnern können, können Sie diesen neu generieren und Ihr Kennwort wiederherstellen (sofern Sie nicht zu viele Änderungen vornehmen).

pwgen ist ein wunderbares kleines CLI-Tool, mit dem Sie eine Reihe von Parametern angeben können, um die Komplexität, die Anzahl der zu generierenden Kennwörter, die Länge usw. festzulegen.

Hier ist ein einmaliges Skript zum Generieren von Passphrasen im XKCD-Stil . /usr/share/dict/wordsist kein großartiges Wörterbuch dafür, da die meisten Wörter lang sind, aber es ist leicht verfügbar. Für schönere Passphrasen können Sie ein Wörterbuch mit kurzen Wörtern wie die S / Key One-Time Password-Wortliste verwenden .

dict="/usr/share/dict/words"
max="`wc -l <"$dict"`" \
    perl -e '$count=4;
        $/=\4; while (<>) {
            print unpack('L') % $ENV{max} + 1, qq(\n); last unless --$count
        }' /dev/urandom | 
    while read n ; do 
        tail -n "+$n" "$dict" | head -1
    done

Wenn Sie ein GNOME-Benutzer sind und auch Kennwörter für Ihre verschiedenen Konten speichern müssen, können Sie den Revelation- Kennwortmanager ausprobieren . Es verfügt über eine grundlegende Kennwortgenerierungsfunktion, bei der Sie nur die Kennwortlänge festlegen und festlegen, ob neben Buchstaben und Ziffern auch Interpunktionszeichen verwendet werden sollen.

Korrigieren Sie mich, wenn ich falsch liege, aber: Soweit ich es verstanden habe, kann ein Computer keine völlig zufällige Zeichenfolge finden. Also bin ich auf folgende Idee gekommen [und hoffe, es ist nicht ganz dumm]:

Wenn man einen 26-seitigen Würfel wirft, ist die Chance, 26 zu werfen, 1:26. Mit anderen Worten: Die Chance, 26 zu werfen, liegt bei etwa 0,04%. Außerdem hat ein Würfel kein Gedächtnis und keine Bugs. Ich bin auf folgende Idee gekommen:

• Du erhältst einen 26-seitigen Würfel, wobei jede Seite mit einem Buchstaben des Alphabets übereinstimmt
• Holen Sie sich einen Zehn-Seiten-Würfel, bei dem jede Seite mit einer Zahl zwischen 0 und 9 übereinstimmt
• eine Münze werfen
• Kopf bedeutet: Buchstabenwürfel werfen
• Schwänze bedeutet: Anzahl Würfel werfen

Papiermodelle zum Ausdrucken:

• 10 seitige Würfel: http://www.korthalsaltes.com/model.php?name_en=decahedron
• 26 seitige Würfel: http://www.korthalsaltes.com/model.php?name_en=rhombicuboctahedron

Hinweis : Ich bin kein Mathematikprofi und kam auf diese Idee, nachdem ich einen Artikel im 2600-Magazin gelesen hatte, in dem dies beschrieben wurde. Ich habe nur einige meiner eigenen Ideen zum Grundkonzept hinzugefügt.

Außerdem : Ich frage mich, ob dies nicht nur ein perfektes Beispiel für " Schreibe deinen ersten Brute-Force-Passwort-Cracker " ist. Aber Ihre Frage gab mir einen guten Grund, diese Idee zur Diskussion zu stellen.

Ich habe zwei Aliase zu meiner .zshrc.local-Datei hinzugefügt, um sichere Passwörter zu erstellen.

Das erste ist:

alias pw.graph="cat /dev/urandom | tr -dc '[:graph:]' | fold -w 1000 | perl -pe 's/(.)(?=.*?\1)//g' | head -n 5"

Die Ausgabe von pw.graph besteht aus fünf Zeilen jedes Zeichens, das mit Ausnahme der Leertaste auf einer Tastatur eingegeben werden kann:

/d=|&mRq!g$QaNZ'L;CfEli,D3\)*h-jkerzv?{y"_Ic(0BtxJwF59:@G}KV1X2o>S~[#]s+W%A.<6bpTO^uP7U4HMYn`8
RIdW87{a4O3][?&rTn=m/:Y`_u*hqy2c%s@!ZPM$5to1f-.U9ClK,)'jDi0"pw>EzN^|gX~BSAJk\VFG(H<bx}+Q6#vL;e
s^H@yEo/X$|d?_jw7-n'l>m"Cb\W5.tTe0APB1D!#69[p+(8x}F&~RM`q3Q%vhfOiUZz]ucJk:)*agGV;=NY4{,K2SLrI<
$/t|!s}og5u:X~hcJUyYHf>;l<zDedL`.T*K8]CBSW[(xw+Mm^E3r16b-97%'@jVR{ZG#0p4AP=,I?\n&"a)vqNkQ2iO_F
,7n|^Y\%MpeBqvhI3mE<9zPS/~+sU`4ZoCWl&uxd'ft"kjcOy0X!{a-T_6RKiVg5Hb21D)w>@*N8;A[(rLG=$Q:.#]FJ?}

Der zweite ist:

alias pw.alnum="cat /dev/urandom | tr -dc '[:alnum:]' | fold -w 1000 | perl -pe 's/(.)(?=.*?\1)//g' | head -n 5"

Die Ausgabe von pw.alnum ist jeder druckbare Buchstabe und jede druckbare Zahl in Groß- und Kleinschreibung:

E6wgCfVBbXjyzYQ8USKl79LqPih0e5mvGrNHd3osaW2OxkJ1RM4nFTtcuZIpDA
GTvQON1dsZSpJmegBMK6bqnEciU7k0AoV2H4Wh53zr9YRfLlDxywXItu8CjPFa
6u1Db9MfyBApZdU7gqoV2PGwH5LcxWi3JNj8nkQCIThezSlYEXsOtrmF04KvaR
VFrsGwI9yAmabEnlRTKgZO23vUq4f6LHkzQP7tMjNW8ph1exuDoBCXSd50JciY
G3r6Em5tlfjQARJx9gWHes7bCVwkzcP48KaSIXyUFBMLqT0op1uDNdih2nYZOv

Normalerweise benutze ich pw.graph und kopiere einen zufälligen Teil der Zeile. Einige Passwörter erlauben keine Symbole, deshalb benutze ich einen Teil von pw.alnum dafür.

Ich benutze diese als .html-Datei gespeichert:

<script>
var keylist="abcdefghijklmnopqrstuvwxyzABCEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*_"
var temp=''

function generatepass(plength){
temp=''
for (i=0;i<plength;i++)
temp+=keylist.charAt(Math.floor(Math.random()*keylist.length))
return temp
}

function populateform(enterlength){
document.pgenerate.output.value=generatepass(enterlength)
}
</script>

<form name="pgenerate">
<input type="text" size=32 name="output">
<input type="button" value="Generate Password" onClick="populateform(this.form.thelength.value)"><br />
<b>Password Length:</b> <input type="text" name="thelength" size=3 value="32">
</form>