Come generare una stringa casuale?

Vorrei generare una stringa casuale (ad es. Password, nomi utente, ecc.). Dovrebbe essere possibile specificare la lunghezza necessaria (ad es. 13 caratteri).

Quali strumenti posso usare?

(Per motivi di sicurezza e privacy, è preferibile che le stringhe vengano generate off-line, piuttosto che online su un sito Web.)

Il mio modo preferito per farlo è usare /dev/urandominsieme a trper eliminare i personaggi indesiderati. Ad esempio, per ottenere solo cifre e lettere:

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

In alternativa, per includere più caratteri dall'elenco dei caratteri speciali della password OWASP :

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

Se hai qualche problema a trlamentarti dell'input, prova ad aggiungere inLC_ALL=C questo modo:

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

Per generare una password casuale puoi usare pwgen:

pwgen genera password casuali, insignificanti ma pronunciabili. Queste password contengono solo lettere minuscole o lettere maiuscole e minuscole o cifre inserite. Le lettere maiuscole e le cifre sono posizionate in modo da ricordare la loro posizione quando si memorizza solo la parola.

Genera 7 password di lunghezza 13:

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

Come menzionato nei commenti, puoi evitare di ridurre l'entropia usando l' -sargomento (ovvero generare password più sicure, completamente casuali ma difficili da ricordare):

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

Per generare nomi utente casuali è possibile utilizzare gpw:

Questo pacchetto genera password pronunciabili. Utilizza le statistiche delle combinazioni di tre lettere (trigrafi) tratte da qualsiasi dizionario lo si nutre.

Genera 7 password (nomi utente) di lunghezza 13:

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

Sto usando il opensslcomando, il coltellino svizzero di crittografia.

openssl rand -base64 12

o

openssl rand -hex 12

Ecco come lo faccio. Genera una stringa casuale di 10 caratteri. Puoi ottimizzarlo sostituendo "fold", con altri strumenti di elaborazione delle stringhe.

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

Per generare password con la massima entropia possibile con strumenti Linux standard integrati in ogni distribuzione che utilizzo:

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

Questo genera tutti i caratteri stampabili ASCII - da 32 (spazio) a 126 (tilde, ~). La lunghezza della password può essere controllato con la head's -cbandiera. Ci sono anche altri possibili set di caratteri tr(per non includere lo spazio, solo i caratteri 33-126, usare [:graph:]).

A seconda del livello di casualità desiderato, potresti semplicemente andare con la variabile incorporata di bash (anche zshe ksh, eventualmente, altre) $RANDOM:

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

I metodi che leggono direttamente da /dev/urandomsono molto più semplici, ma per motivi di completamento, puoi anche usare $RANDOM:

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

Importante : questa soluzione produrrà solo stringhe casuali usando le prime 10 lettere dell'alfabeto. Se questo è abbastanza per te dipende da ciò di cui hai bisogno.

Ispirato da Pablo Repetto ho finito con questa soluzione facile da ricordare :

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

-z evita l'output su più righe

-e fa eco al risultato

-r consentire a qualsiasi personaggio di apparire più volte

-n20 stringa casuale con una lunghezza di 20 caratteri

{A..Z} {a..z} {0..9} ha permesso le classi di caratteri

shuf fa parte dei coreutils di Linux ed è ampiamente disponibile o almeno è stato portato.

@Brandin ha spiegato in un commento a un'altra risposta come ottenere al massimo 100 byte /dev/urandomdall'uso head -c 100. Un altro modo per farlo è con dd:

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

Alla 2>/dev/nullfine del ddcomando è di sopprimere l'output "... records in / ... records out".

Non sono a conoscenza di sostanziali vantaggi / svantaggi tra questi due metodi.

Ho avuto un problema con entrambi i metodi per trlamentarmi dell'input. Pensavo che fosse perché non gli piaceva ricevere l'input binario, e quindi suggerivo il primo filtraggio/dev/random con iconv -c -t US. Tuttavia, Gilles ha suggerito una diagnosi e una soluzione diverse, che funzionano per me:

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

APG è incluso per impostazione predefinita su alcune distribuzioni Linux.

Per generare password dalla dimensione 5 alla 10 nei sottoinsiemi Speciale, Numerico, Maiuscolo e Basso, il comando è:

apg -MSNCL -m 5 -x 10

E ritorna

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

Come detto da @landroni nel commento.

È possibile utilizzare uno degli md5strumenti che ha esattamente questo scopo. Nel caso di creazione di una password completamente casuale è possibile utilizzare il md5pass. È uno strumento molto semplice da usare e molto utile, dal momento che puoi usare "testo normale" insieme a un "salt" per saltare la costruzione della stessa password che puoi recuperare in seguito, o in alternativa potresti voler ottenere completamente password casuale per tutto il tempo. L'uso generale è:

md5pass [password] [salt]

dove passwordè una parola scelta che verrà utilizzata per la costruzione della stringa casuale ed saltè il salto in byte da utilizzare. Come questo:

md5pass word

$1$.MUittVW$j.XDTF1QRnxqFdXRUiSLs0

Ciò creerà una password "una sequenza casuale" da utilizzare. Se si utilizza no salt, potrebbe non essere possibile ricreare la stessa stringa in seguito.

Tuttavia, se si utilizza un saltcome questo:

md5pass word 512

$1$512$.0jcLPQ83jgszaPT8xzds0

quindi puoi creare una sequenza che puoi recuperare se usi la parola insieme allo stesso salt (o salta) se era stata originariamente definita.

Utilizzare il xxdcomando per specificare la lunghezza (tramite -l) che funziona sia in Linux che nel sistema operativo. https://www.howtoforge.com/linux-xxd-command/

xxd -l16 -ps /dev/urandom

Questi due comandi generano password e passphrase casuali, rispettivamente.

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' ' '

Il generatore di password richiede un file_with_characters contenente tutti i caratteri che si desidera utilizzare la password, un carattere per riga ed esattamente una volta ciascuno. Il file non deve contenere righe vuote e le righe devono essere terminate a fine riga.

Il generatore di passphrase richiede un file_with_words contenente tutte le parole che si desidera utilizzare la passphrase, una parola per riga e esattamente una volta ciascuna. Il file non deve contenere righe vuote e le righe devono essere terminate a fine riga.

L'opzione --head-count specifica la lunghezza della password - in caratteri - o passphrase - in parole.

Ho scoperto che piping / dev / urandom su tr su macOS non ha funzionato. Ecco un altro modo:

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

Io uso:

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

Questo mi dà 57 possibili personaggi. La stringa può essere incollata (rimossa +e \) o stampata e riscritta poiché i caratteri difficili da distinguere ( I1lO0) sono stati rimossi.

• 44 caratteri mi dà: log ₂ (57 ⁴⁴ )> 256.64 bit di entropia
• 22 caratteri mi dà: log ₂ (57 ²² )> 128.32 bit di entropia

Mi piace perché:

• il comando è semplice da digitare e memorabile
• utilizza strumenti di sistema standard, senza binari aggiuntivi
• non "spreca" molta casualità (utilizza l'89% dei bit casuali che riceve vs ~ 24% per le soluzioni che eseguono il piping diretto a tr)
• 22 e 44 personaggi si accoppiano abbastanza bene (appena sopra anche) il potere comune di due punti di interruzione
• l'output può essere facilmente selezionato e incollato o stampato e riscritto con tassi di errore umani minimi
• soluzioni più brevi di quelle con codifica esadecimale (32 e 64 anziché 22 e 44) come md5sum / sha1sum, ecc.

Ringraziamo https://unix.stackexchange.com/a/230676/9583 e in particolare i commenti per la mia ispirazione iniziale.

La filosofia Unix di "molti piccoli strumenti che fanno bene una cosa" ti offre molto bene in questo caso.

• /dev/urandomè un flusso di "byte" casuali (che includono caratteri non stampabili)
• base64 codifica i dati byte in [A-Za-z0-9/+] (che è interamente stampabile)
• dd copia l'input nell'output applicando i modificatori forniti come argomenti (che possono includere la dimensione e il conteggio dei blocchi)

OSX

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

Linux

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

Appunti:

• Se è necessario un sottoinsieme di caratteri, è possibile inserire un modificatore nella pipe.
  • Es: tr -d '[A-Z/+]'liberarsi delle lettere maiuscole e +e/
• È possibile impostare la bs(dimensione del blocco) su qualsiasi lunghezza sia necessaria.
• Su Linux, base64esegue il wrapping su 76 colonne per impostazione predefinita e deve essere ripristinato con, a -w0meno che tu non lo desideri.

Vorrei contribuire con il mio solito comando per generare una password

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

Per configurare la lunghezza della password, modificare il numero nel comando cut con la lunghezza richiesta, ad esempio 24 caratteri

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

Non vuoi confondere 0 o O, 1 o l? Filtra con un altrotr

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

Personalmente non preferisco mai un carattere speciale nella password, ecco perché scelgo solo [:alnum:]per il mio generatore di password

Mantengo secpwgenin Alpine Linux e mantengo le fonti sul mio Github .

Può produrre stringhe casuali o frasi di dadi:

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

Per generare una stringa casuale di 13 caratteri dovrai usare:

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.

Per gli utenti di ricordare una password utilizzare le frasi diceware:

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

Personalmente mi piace:

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

La mia strada per una password molto sicura (dove 16 è la lunghezza pw):

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

Risultato di esempio:

jT@s_Nx]gH<wL~W}

O in alternativa, per generare più password:

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

Risultato di esempio:

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*

Poco meno sicuro (set di caratteri più piccolo):

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

Risultato di esempio:

rJqYxYZLOTV+A45w
PUKQ+BoBf6yfZw5m
+LRfpsN9CsLRiN8V
yMS6zDpL6NHmG17s
yTUWPG7Rum97schi
cognvjVwaKaAyPRK

Un modo super facile e semplice (probabilmente più semplice di quello che stai cercando) per raggiungere questo obiettivo sarebbe quello di generare un numero casuale in un determinato intervallo, convertire quel numero nel suo carattere ASCII equivalente e aggiungerlo alla fine di una stringa .

Ecco un esempio di base 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

EDIT: aggiunti commenti e codice aggiunto per generare più password e scriverle in un file

Vorrei questo comando:

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

Vado su http://passwordsgenerator.net/ che consente di generare stringhe di caratteri casuali fino a 2048 caratteri, selezionando lettere maiuscole, lettere minuscole, cifre da 0 a 9, segni di punteggiatura o qualsiasi combinazione.