it-swarm.com.de

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 erforderliche Länge anzugeben (z. B. 13 Zeichen).

Welche Tools kann ich verwenden?

(Aus Sicherheits- und Datenschutzgründen ist es vorzuziehen, dass Zeichenfolgen offline generiert werden, anstatt online auf einer Website.)

248
landroni

Am liebsten verwende ich /dev/urandom Zusammen mit tr, um unerwünschte Zeichen zu löschen. Zum Beispiel, um nur Ziffern und Buchstaben zu erhalten:

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

Alternativ zu include weitere Zeichen aus der OWASP-Passwort-Sonderzeichenliste :

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

Wenn Sie Probleme mit tr haben, sich über die Eingabe zu beschweren, fügen Sie LC_ALL=C Hinz wie folgt:

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

Ich benutze den Befehl openssl, das Schweizer Taschenmesser der Kryptographie.

openssl Rand -base64 12

oder

openssl Rand -hex 12
158
400 the Cat

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

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 werden so platziert, dass das Speichern ihrer Position erleichtert wird, wenn nur das Wort gespeichert wird.

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

[email protected]:~$ 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 Argument -s Verwenden (d. H. Sicherere, vollständig zufällige, aber schwer zu merkende Kennwörter generieren):

[email protected]:~$ pwgen -s 13 7
eAfycrPlM4cYv 4MRXmZmyIVNBp D8y71iqjG7Zq7 FQRHcserl4R8O yRCUtPtV3dsqV
0vJpp2h0OrgF1 QTp7MKtJyTrjz 

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

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

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

[email protected]:~$ gpw 7 13
sreepoidahsas
risadiestinge
ntodynesssine
deodstestress
natinglumperm
riasigentspir
enderiferback
155
landroni

Hier ist wie, ich mache es. Es wird eine zufällige Zeichenfolge mit 10 Zeichen generiert. Sie können es optimieren, indem Sie die "Falte" durch andere Zeichenfolgenverarbeitungswerkzeuge ersetzen.

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

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 Echo das Ergebnis

-r lässt jedes Zeichen mehrmals erscheinen

-n20 zufällige Zeichenfolge mit einer Länge von 20 Zeichen

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

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

12
entwicklerseite

So generieren Sie ein Kennwort 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 Zeichen ASCII - von 32 (Leerzeichen) bis 126 (Tilde, ~) Aus. Die Kennwortlänge kann mit den heads gesteuert werden -c Flag. Es gibt auch andere mögliche Zeichensätze in tr (um das Leerzeichen nicht einzuschließen, verwenden Sie nur die Zeichen 33-126, [:graph:]).

12
drws

Abhängig von der gewünschten Zufälligkeit können Sie einfach die in die Variable $RANDOM Eingebaute Variable bash (auch zsh und ksh, möglicherweise andere) verwenden:

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

Die Methoden, die direkt aus /dev/urandom Lesen, sind viel einfacher, aber zur Vervollständigung können Sie auch $RANDOM Verwenden:

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 das für Sie ausreicht oder nicht, hängt davon ab, wofür Sie dies benötigen.

9
terdon

@Brandin erklärte in einem Kommentar zu einer anderen Antwort, wie man mit /dev/urandom Höchstens 100 Bytes von head -c 100 Erhält. Eine andere Möglichkeit, dies zu tun, ist mit dd:

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

Der 2>/dev/null Am Ende des Befehls dd dient zum Unterdrücken der Ausgabe "... Datensätze ein/... Datensätze aus".

Mir sind keine wesentlichen Vor- und Nachteile zwischen diesen beiden Methoden bekannt.

Ich hatte ein Problem mit beiden Methoden von tr, sich über die Eingabe zu beschweren. Ich dachte, das lag daran, dass es keine Binäreingabe empfangen wollte, und schlug daher vor, zuerst /dev/random Mit iconv -c -t US Zu filtern. 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
5
dubiousjim

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

xxd -l16 -ps /dev/urandom
5
northtree

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

Der Befehl lautet, um Kennwörter der Größe 5 bis 10 in den Teilmengen Special, Numeric, Capital und Lower zu generieren:

apg -MSNCL -m 5 -x 10

Und kehrt zurück

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

Wie von @landroni im Kommentar gesagt.

4
Sandburg

Sie können eines von md5 Werkzeuge, die genau diesen Zweck haben. Wenn Sie ein völlig zufälliges Passwort erstellen, können Sie das md5pass. Es ist ein sehr einfaches und sehr hilfreiches Tool, da Sie "normalen Text" zusammen mit einem "Salt" verwenden können, um das gleiche Passwort zu springen, das Sie später wiederherstellen können, oder alternativ möchten Sie möglicherweise ein vollständiges erhalten zufälliges Passwort die ganze Zeit. Die allgemeine Verwendung ist:

md5pass [password] [salt]

dabei ist password ein ausgewähltes Wort, das für die Konstruktion der Zufallszeichenfolge verwendet wird, und salt ist der zu verwendende Sprung in Bytes. So was:

md5pass Word

$1$.MUittVW$j.XDTF1QRnxqFdXRUiSLs0

Dadurch wird ein Passwort für eine "zufällige Reihenfolge" erstellt, das Sie verwenden können. Wenn Sie kein salt verwenden, können Sie möglicherweise denselben String danach nicht mehr neu erstellen.

Wenn Sie jedoch ein salt wie folgt 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 Salz (oder Sprung) verwenden, wenn es ursprünglich definiert wurde.

4
Joke Sr. OK

Diese beiden Befehle erzeugen 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' ' '

Der Kennwortgenerator benötigt eine Datei mit Zeichen, die alle Zeichen enthält, die das Kennwort verwenden soll, ein Zeichen pro Zeile und jeweils genau einmal. Die Datei darf keine Leerzeilen enthalten, und Zeilen müssen mit Zeilenumbruch abgeschlossen sein.

Der Passphrasengenerator benötigt eine Datei mit Wörtern, die alle Wörter enthält, die die Passphrase verwenden soll, ein Wort pro Zeile und jeweils genau einmal. Die Datei darf keine Leerzeilen enthalten, und Zeilen müssen mit Zeilenumbruch abgeschlossen sein.

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

2
Pablo Repetto

Die Unix-Philosophie "viele kleine Tools, die eines gut können" dient Ihnen in diesem Fall sehr gut.

  • /dev/urandom Ist ein Stream von zufällig "Bytes" (die nicht druckbare Zeichen enthalten)
  • base64codiert Bytedaten in[A-Za-z0-9/+] (Vollständig druckbar)
  • dd kopiert die Eingabe in die Ausgabe, wobei als Argumente angegebene Modifikatoren angewendet 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.
    • Beispiel: tr -d '[A-Z/+]', Um Großbuchstaben und + Und / Zu entfernen.
  • Sie können bs (Blockgröße) auf die gewünschte Länge einstellen.
  • Unter Linux wird base64 Standardmäßig in 76 Spalten eingeschlossen und muss mit -w0 Zurückgesetzt werden, sofern Sie dies nicht möchten.
1
Bruno Bronosky

Ich habe festgestellt, dass Piping/dev/urandom to tr unter 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
1
Jake

Ich möchte meinen üblichen Befehl zum Generieren eines Passworts einbringen

$ 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 auf die Länge, die Sie benötigen, 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 verwirren? Filtern Sie es mit einem anderen tr heraus

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

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

Ich benutze:

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

Dies 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 gibt mir: log2(5744)> 256,64 Bit Entropie
  • 22 Zeichen gibt mir: log2(5722)> 128,32 Bit Entropie

Ich mag das, weil:

  • der Befehl ist einfach einzugeben und einprägsam
  • es werden Standardsystem-Tools verwendet - keine zusätzlichen Binärdateien
  • "verschwendet" nicht viel Zufälligkeit (verwendet 89% der empfangenen Zufallsbits gegenüber ~ 24% für Lösungen, die direkt an tr weitergeleitet werden)
  • 22 und 44 Zeichen paaren sich recht gut (knapp über der geraden) gemeinsamen Potenz zweier Haltepunkte
  • die Ausgabe kann einfach ausgewählt und eingefügt oder gedruckt und mit minimalen menschlichen Fehlerraten erneut eingegeben werden
  • kürzer als hexadezimal codierte (32 und 64 statt 22 und 44) ​​Lösungen wie md5sum/sha1sum usw.

Dank an https://unix.stackexchange.com/a/230676/958 und insbesondere an die Kommentare für meine erste Inspiration.

1
Iiridayn

Keine der bisherigen Antworten ist wirklich betriebssystemübergreifend.

Die Hauptfehler werden durch die Gebietsschemadefinition (MacOS-Fall) und tr dargestellt, die keine Intervalle von Zeichen erkennen können (Solaris-Fall).

Sie sollten versuchen, shlibs . Es ist frisch und wirklich betriebssystemübergreifend. Der Code zum Abrufen einer zufälligen Zeichenfolge lautet shlibs str005 (./shlibs str005).

Holen Sie sich eine zufällige Zeichenfolge von 50 Zeichen, einschließlich Puntuation, schließen Sie Zahlen aus:

shlibs str005 50 -p -xd
0
Nicolae Iotu

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:

[email protected]_Nx]gH<wL~W}

Oder alternativ, um mehrere Passwörter zu generieren:

cat/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
0
Zibri

Ich pflege secpwgen in Alpine Linux & behalte die Quellen auf meinem Github .

Es können zufällige Zeichenfolgen oder Diceware-Sätze erzeugt werden:

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, würden Sie Folgendes verwenden:

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.

Damit sich Benutzer ein Passwort merken können, 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.
0
Stuart Cardall