Wie erstelle ich eine zufällige Zeichenfolge?

Ich möchte eine zufällige Zeichenfolge generieren (z. B. Passwörter, Benutzernamen usw.). Es sollte möglich sein, die benötigte Länge anzugeben (z. B. 13 Zeichen).

Welche Tools kann ich verwenden?

(Aus Sicherheits- und Datenschutzgründen werden Zeichenfolgen vorzugsweise offline und nicht online auf einer Website generiert.)

Am liebsten lösche ich unerwünschte Zeichen mit /dev/urandomzusammen mit tr. So erhalten Sie beispielsweise nur Ziffern und Buchstaben:

head /dev/urandom | tr -dc A-Za-z0-9 | head -c 13 ; echo ''

Alternativ können Sie auch weitere Zeichen aus der OWASP-Kennwort-Sonderzeichenliste einfügen :

</dev/urandom tr -dc 'A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_`{|}~' | head -c 13  ; echo

Wenn Sie Probleme haben, trsich über die Eingabe zu beschweren, fügen Sie Folgendes hinzuLC_ALL=C :

LC_ALL=C tr -dc 'A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_`{|}~' </dev/urandom | head -c 13 ; echo

Um ein zufälliges Passwort zu generieren, können Sie Folgendes verwenden pwgen:

pwgen generiert zufällige, bedeutungslose, aber aussprechbare Passwörter. Diese Passwörter enthalten entweder nur Kleinbuchstaben oder gemischte Groß- und Kleinbuchstaben oder eingeworfene Ziffern. Großbuchstaben und Ziffern sind so angeordnet, dass sie sich leichter an ihre Position erinnern können, wenn nur das Wort gespeichert wird.

Generieren Sie 7 Passwörter der Länge 13:

geek@liv-inspiron:~$ pwgen 13 7
Eu7Teadiphaec giepahl3Oyaiy iecoo9Aetaib4 phaiChae6Eivi athoo3igee8Co
Iphu4ufeDeelo aesoYi2lie9he 

Wie in den Kommentaren erwähnt, können Sie die Reduzierung der Entropie vermeiden, indem Sie das -sArgument verwenden (dh sicherere, vollständig zufällige, aber schwer zu merkende Passwörter generieren):

geek@liv-inspiron:~$ pwgen -s 13 7
eAfycrPlM4cYv 4MRXmZmyIVNBp D8y71iqjG7Zq7 FQRHcserl4R8O yRCUtPtV3dsqV
0vJpp2h0OrgF1 QTp7MKtJyTrjz 

Um zufällige Benutzernamen zu erzeugen, können Sie Folgendes verwenden gpw:

Dieses Paket generiert aussprechbare Passwörter. Es verwendet die Statistik der Drei-Buchstaben-Kombinationen (Trigraphen), die aus den Wörterbüchern stammen, die Sie verwenden.

Generieren Sie 7 Passwörter (Benutzernamen) der Länge 13:

geek@liv-inspiron:~$ gpw 7 13
sreepoidahsas
risadiestinge
ntodynesssine
deodstestress
natinglumperm
riasigentspir
enderiferback

Ich benutze den opensslBefehl, das Schweizer Taschenmesser der Kryptographie.

openssl rand -base64 12

oder

openssl rand -hex 12

Hier ist, wie ich es mache. Es werden 10 zufällige Zeichenfolgen generiert. Sie können es optimieren, indem Sie die "Falte" durch andere Zeichenkettenverarbeitungswerkzeuge ersetzen.

cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 10 | head -n 1

So generieren Sie ein Passwort mit der höchstmöglichen Entropie mit Standard-Linux-Tools, die in jede von mir verwendete Distribution integriert sind:

< /dev/urandom tr -cd "[:print:]" | head -c 32; echo

Dies gibt alle druckbaren ASCII-Zeichen aus - von 32 (Leerzeichen) bis 126 (Tilde, ~). Die Passwortlänge kann mit dem Flag head's gesteuert werden -c. Es gibt auch andere mögliche Zeichensätze in tr(um das Leerzeichen nicht einzuschließen, verwenden Sie nur die Zeichen 33-126 [:graph:]).

Abhängig von der gewünschten Zufälligkeitsebene können Sie einfach die eingebaute Variable von bash (auch zshund kshmöglicherweise andere) verwenden $RANDOM:

$ echo $RANDOM | tr '[0-9]' '[a-z]'
bfeci
$ echo $RANDOM | tr '[0-9]' '[a-z]'
cijjj

Die Methoden, aus denen direkt gelesen wird, /dev/urandomsind weitaus einfacher, aber zur Vervollständigung können Sie auch Folgendes verwenden $RANDOM:

echo $(for((i=1;i<=13;i++)); do printf '%s' "${RANDOM:0:1}"; done) | tr '[0-9]' '[a-z]'

Wichtig : Diese Lösung erzeugt nur zufällige Zeichenfolgen mit den ersten 10 Buchstaben des Alphabets. Ob dies für Sie ausreicht oder nicht, hängt davon ab, wofür Sie es benötigen.

Inspiriert von Pablo Repetto kam ich zu dieser leicht zu merkenden Lösung:

shuf -zer -n20  {A..Z} {a..z} {0..9}

-z vermeidet die Ausgabe mehrerer Zeilen

-e das Ergebnis wiedergeben

-r Lässt zu, dass ein beliebiges Zeichen mehrfach vorkommt

-n20 Zufallszeichenfolge mit einer Länge von 20 Zeichen

{A..Z} {a..z} {0..9} erlaubte Zeichenklassen

shuf ist Teil des Linux-Coreutils und weit verbreitet oder zumindest portiert.

@Brandin hat in einem Kommentar zu einer anderen Antwort erklärt, wie maximal 100 Bytes aus der /dev/urandomVerwendung stammen head -c 100. Ein anderer Weg dies zu tun ist mit dd:

tr -dc A-Za-z0-9 < /dev/urandom | dd bs=100 count=1 2>/dev/null

Am 2>/dev/nullEnde des ddBefehls wird die Ausgabe "... zeichnet auf / ... zeichnet auf" unterdrückt.

Ich kenne keine wesentlichen Vor- / Nachteile zwischen diesen beiden Methoden.

Ich hatte ein Problem mit beiden Methoden, mich trüber die Eingabe zu beschweren. Ich dachte , das war , weil es nicht binär Eingang empfängt getraute und daher vorgeschlagen erste Filterung /dev/randommit iconv -c -t US. Gilles schlug jedoch eine andere Diagnose und Lösung vor, die für mich funktioniert:

LC_ALL=C tr -dc A-Za-z0-9 </dev/urandom | dd bs=100 count=1 2>/dev/null

APG ist bei einigen Linux-Distributionen standardmäßig enthalten.

Der Befehl zum Generieren von Kennwörtern der Größe 5 bis 10 in Teilmengen Special, Numeric, Capital und Lower lautet:

apg -MSNCL -m 5 -x 10

Und kehrt zurück

@OpVeyhym9
3:Glul
3DroomIc?
hed&Os0
NefIj%Ob3
35Quok}

Wie gesagt von @landroni im Kommentar.

Sie können eines der md5Tools verwenden, die genau diesen Zweck erfüllen. Wenn Sie ein völlig zufälliges Passwort erstellen, können Sie das verwenden md5pass. Es ist ein sehr einfaches Tool, das sehr hilfreich ist, da Sie "normalen Text" zusammen mit einem "Salt" verwenden können, um das gleiche Kennwort zu erstellen, das Sie anschließend wiederherstellen können, oder Sie möchten alternativ ein vollständiges Kennwort erhalten zufälliges Passwort die ganze Zeit. Die allgemeine Verwendung ist:

md5pass [password] [salt]

Dabei passwordhandelt es sich um ein ausgewähltes Wort, das für die Konstruktion der Zufallszeichenfolge verwendet wird, und saltum den zu verwendenden Byte-Sprung. So was:

md5pass word

$1$.MUittVW$j.XDTF1QRnxqFdXRUiSLs0

Dadurch wird ein "Zufallssequenz" -Passwort erstellt, das Sie verwenden können. Wenn Sie no verwenden salt, können Sie diese Zeichenfolge möglicherweise nicht mehr erstellen.

Wenn Sie jedoch einen saltwie diesen verwenden:

md5pass word 512

$1$512$.0jcLPQ83jgszaPT8xzds0

Dann können Sie eine Sequenz erstellen, die Sie wiederherstellen können, wenn Sie das Wort in Verbindung mit demselben Salt (oder Sprung) verwenden, wenn es ursprünglich definiert wurde.

Verwenden Sie den xxdBefehl, um die Länge (über -l) anzugeben, die sowohl unter Linux als auch unter OS funktioniert. https://www.howtoforge.com/linux-xxd-command/

xxd -l16 -ps /dev/urandom

Diese beiden Befehle generieren zufällige Passwörter bzw. Passphrasen.

shuf --random-source=/dev/urandom --repeat --head-count=20 file_with_characters | tr --delete '\n'

shuf --random-source=/dev/urandom --repeat --head-count=7 file_with_words | tr '\n' ' '

Für den Kennwortgenerator ist eine Datei mit_Zeichen erforderlich, die alle Zeichen enthält, die vom Kennwort verwendet werden sollen, ein Zeichen pro Zeile und jeweils genau ein Mal. Die Datei darf keine Leerzeilen enthalten, und Zeilen müssen mit einem Zeilenumbruch versehen sein.

Für den Passphrasengenerator ist eine Datei mit_Wörtern erforderlich, die alle Wörter enthält, die von der Passphrase verwendet werden sollen, ein Wort pro Zeile und jeweils genau ein Mal. Die Datei darf keine Leerzeilen enthalten, und Zeilen müssen mit einem Zeilenumbruch versehen sein.

Die Option --head-count gibt die Länge des Kennworts in Zeichen oder Passphrasen in Wörtern an.

Ich habe festgestellt, dass Piping / dev / urandom auf MacOS nicht funktioniert hat. Hier ist ein anderer Weg:

set="abcdefghijklmonpqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
n=6
rand=""
for i in `seq 1 $n`; do
    char=${set:$RANDOM % ${#set}:1}
    rand+=$char
done
echo $rand

Ich benutze:

base64 < /dev/urandom | tr -d 'O0Il1+\' | head -c 44

Das gibt mir 57 mögliche Zeichen. Die Zeichenfolge kann kopiert (entfernt +und \) oder gedruckt und erneut eingegeben werden, da die schwer zu unterscheidenden Zeichen ( I1lO0) entfernt wurden.

• 44 Zeichen geben mir: log ₂ (57 ⁴⁴ )> 256,64 Bit Entropie
• 22 Zeichen geben mir: log ₂ (57 ²² )> 128,32 Bit Entropie

Ich mag das, weil:

• Der Befehl ist einfach zu tippen und einprägsam
• Es werden Standard-System-Tools verwendet - keine zusätzlichen Binärdateien
• "verschwendet" nicht viel Zufälligkeit (verwendet 89% der zufälligen Bits, die es empfängt, gegenüber ~ 24% für Lösungen, die direkt an tr weiterleiten)
• 22 und 44 Zeichen paaren sich recht gut (knapp über der geraden) Potenz zweier Haltepunkte
• Die Ausgabe kann einfach ausgewählt und eingefügt oder gedruckt und mit minimalen menschlichen Fehlerraten neu getippt werden
• kürzer als hexadezimal codierte (32 und 64 anstelle von 22 und 44) ​​Lösungen wie md5sum / sha1sum usw.

Wir danken https://unix.stackexchange.com/a/230676/9583 und insbesondere den Kommentaren für meine anfängliche Inspiration.

Die Unix-Philosophie "viele kleine Werkzeuge, die eines gut machen" kommt Ihnen in diesem Fall sehr entgegen.

• /dev/urandomist ein Strom von zufälligen "Bytes" (die nicht druckbare Zeichen enthalten)
• base64 codiert Bytedaten in [A-Za-z0-9/+] (die vollständig druckbar sind)
• dd Kopiert die Eingabe in die Ausgabe und wendet dabei Modifikatoren an, die als Argumente angegeben werden (einschließlich Blockgröße und Blockanzahl).

OSX

base64     < /dev/urandom | dd bs=1k count=1

Linux

base64 -w0 < /dev/urandom | dd bs=1k count=1

Anmerkungen:

• Wenn Sie eine Teilmenge der Zeichen benötigen, können Sie einen Modifikator in die Pipe einfügen.
  • Bsp .: tr -d '[A-Z/+]'um Großbuchstaben und +und loszuwerden/
• Sie können die bs(Blockgröße) auf die gewünschte Länge einstellen .
• Unter Linux werden die base64Zeilen standardmäßig in 76 Spalten umgebrochen und müssen mit zurückgesetzt werden, -w0sofern Sie dies nicht möchten.

Ich möchte meinen üblichen Befehl zur Generierung eines Passworts beisteuern

$ cat /dev/urandom | base64 | head -n 1 |tr -dc '[:alnum:]' |cut -c -13
b0R55751vWW9V

Um die Länge des Kennworts zu konfigurieren, ändern Sie die Nummer im Befehl cut in die erforderliche Länge, z. B. 24 Zeichen

$ cat /dev/urandom | base64 | head -n 1 |tr -dc '[:alnum:]' |cut -c -24
WFBhVHuKbrnRhd5kdWXPzmZG

Willst du nicht 0 oder O, 1 oder l verwechseln? Filtern Sie es mit einem anderen austr

$ cat /dev/urandom | base64 | head -n 1 |tr -dc '[:alnum:]' | tr -d '0O1l'|cut -c -24
JuCphwvhrhppD9wVqfpP2beG

Ich persönlich bevorzuge nie ein Sonderzeichen im Passwort, deshalb wähle ich nur [:alnum:]für meinen Passwortgenerator

Ich pflege secpwgenin Alpine Linux und behalte die Quellen auf meinem Github .

Es kann zufällige Zeichenfolgen oder Diceware-Sätze erzeugen:

musl64 [~]$ secpwgen
USAGE: secpwgen <-p[e] | -A[adhsy] | -r | -s[e]> N

PASSPHRASE of N words from Diceware dictionary
  -p    generate passphrase
  -pe   generate enhanced (with symbols) passphrase

SKEY PASSWORD of N words from S/Key dictionary
  -s    generate passphrase
  -se   generate enhanced (with symbols) passphrase

ASCII RANDOM of N elements (at least one option MUST be present)
  -A    Each letter adds the following random elements in output:
    a    alphanumeric characters
    d    decimal digits
    h    hexadecimal digits
    s    special characters
    y    3-4 letter syllables

RAW RANDOM
  -r    output BASE64 encoded string of N random BITS
  -k    output koremutake encoding of N random BITS

Um eine zufällige Zeichenfolge mit 13 Zeichen zu generieren, verwenden Sie:

musl64 [~]$ secpwgen -Aas 13
----------------
WK5#*V<]M3<CU ;ENTROPY=67.21 bits
----------------
INFO: destroying random number generator.
INFO: zeroing memory.

musl64 [~]$ secpwgen -Aa 13
----------------
GP0FIEBM9Y3BT ;ENTROPY=67.21 bits
----------------
INFO: destroying random number generator.
INFO: zeroing memory.

Um sich ein Passwort zu merken, verwenden Sie die Diceware-Sätze:

musl64 [~]$ secpwgen -p 5
----------------
wq seen list n8 kerr  ;ENTROPY=65.00 bits
----------------
INFO: destroying random number generator.
INFO: zeroing memory.

Ich persönlich mag:

musl64 [~]$ secpwgen -r 512
----------------
h62lL7G4gwh3/j9c7YteQvVXoqJrQKKPWVR3Lt7az36DcfWZWtUgBT19iwmJBwP4UahNzPe7qYD7OcklUFpCzQ== ;ENTROPY=512.00 bits
----------------
INFO: destroying random number generator.
INFO: zeroing memory.

Mein Weg für ein sehr sicheres Passwort (wobei 16 die Pw-Länge ist):

cat /dev/urandom | tr -cd [:graph:]|head -c 16

Beispielergebnis:

jT@s_Nx]gH<wL~W}

Oder alternativ, um mehrere Passwörter zu generieren:

katze / dev / urandom | tr -cd [: graph:] | fold -w 16 | head -6

Beispielergebnis:

7ck%G7'|f&}_8(]s
<?*]E.CG[NB'gK#A
:tF-WPTOa3!i7S(h
2xy(>=%3=Kb1B$`6
*98Lf{d?Jzb}6q1\
E7uCEAN2Hz]]y|5*

Etwas weniger sicher (kleinerer Zeichensatz):

cat /dev/urandom |base64 -w 0|fold -w 16|head -6

Beispielergebnis:

rJqYxYZLOTV+A45w
PUKQ+BoBf6yfZw5m
+LRfpsN9CsLRiN8V
yMS6zDpL6NHmG17s
yTUWPG7Rum97schi
cognvjVwaKaAyPRK

Eine supereinfache und einfache (wahrscheinlich einfachere) Möglichkeit, dies zu erreichen, besteht darin, eine Zufallszahl in einem bestimmten Bereich zu generieren, diese Zahl in das entsprechende ASCII-Zeichen umzuwandeln und an das Ende einer Zeichenfolge anzuhängen .

Hier ist ein einfaches Beispiel in Python:

import random # import random library  
passFile = open("passwords.txt", 'w') # create file passwords.txt
passNum = int(input("Number of passwords: ")) # get number of  passwords
passLength = int(input("Password length: ")) # get length of passwords  
for i in range(passNum):
    password = "" # reset password
    for i in range(passLength):
        num = random.randint(65, 122) # get random number
        while num in range(91, 97): # Don't include punctuation
            num = random.randint(65, 122)
        password += chr(num) # add character to current password 
    passFile.write(password + "\n") # add current password to file  
passFile.close() # close file

BEARBEITEN: Kommentare und Code hinzugefügt, um mehrere Passwörter zu generieren und in eine Datei zu schreiben

Ich hätte gerne diesen Befehl:

date +%s | sha256sum | base64 | head -c 12

Ich gehe zu http://passwordsgenerator.net/. Dort können Zeichenfolgen mit bis zu 2048 zufälligen Zeichen generiert werden. Dabei werden Groß- und Kleinbuchstaben, Ziffern von 0 bis 9, Satzzeichen oder eine beliebige Kombination ausgewählt.