Dipende da cosa intendi per "leggibile". Se si desidera utilizzare solo caratteri esadecimali, saranno necessari 32 di essi per raggiungere 128 bit di entropia; questa linea funzionerà (usando solo i comandi dal pacchetto coreutils ):

head -c16 /dev/urandom | md5sum

Questa variante produce password con solo lettere minuscole, da 'a' a 'p' (questo è ciò che vorresti se dovessi "digitare" la password su uno smartphone):

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

Se vuoi digitare un carattere in meno, prova questo:

head -16 /dev/urandom | md5sum

(Probabilità di ottenere tutti i primi 16 byte casuali come 0x0A, cioè il carattere "newline", è 2 ^-128 , quindi questa riga ottiene ancora 128 bit di entropia.)

Ancora limitandoti ai comandi di coreutils , puoi fare ciò:

mktemp -u XXXXXXXXXXXXXXXXXXXXXX

Questo genera una password di 22 caratteri, usando /dev/urandom come fonte interna di casualità (ho controllato il codice sorgente e una chiamata di strace conferma). I caratteri sono lettere (maiuscole e minuscole) e cifre; poiché 62 ²² è maggiore di 2 ¹²⁸ , i 22 caratteri sono sufficienti.

Ancora un altro:

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

questo mostra otto sequenze di quattro cifre esadecimali. Probabilmente, questa suddivisione in piccole sequenze può aiutare a leggere.

Per una riga molto più lunga e un tipo abbastanza distinto di password, prova questo:

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

(questo funziona solo su un host a 64 bit, noterete perché?). Oltre a coreutils , quella versione richiede anche un file di dizionario, qui quello per l'inglese britannico.

Alcuni suggerimenti favolosi nelle altre risposte. Trovo che makepasswd non sia disponibile ovunque, e l'uso di tr sia (leggermente) complicato, quindi c'è un'altra opzione che usa OpenSSL:

openssl rand -base64 16

Il numero è il numero di byte di casualità - quindi 16 byte per 128 bit di entropia.

Utilizzo di pwgen

Oneliner semplicissimo in assoluto:

pwgen

Cerca di rendere le password facili da ricordare. Per disattivarlo e creare password più sicure, usa il --secure o -s flag.

pwgen -s

Le password generate sono troppo lunghe? Troppo corto? Basta aggiungere la lunghezza desiderata:

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

Strumenti simili

Mi è appena capitato di conoscere pwgen, ci sono altri strumenti là fuori. Li puoi trovare usando la funzione di ricerca dalla tua distribuzione. In Debian questo è:

apt-cache search password generator

Esegue una ricerca esatta (sebbene non sensibile al maiuscolo / minuscolo). L'utilizzo di password generat invece amplia la ricerca.

Prima di installare il pacchetto può essere utile visualizzare la sua descrizione. Di nuovo in Debian:

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

Strumenti che ho trovato in questo modo:

• pwgen
• makepasswd
• apg
• otp (significato per blocchi una tantum, non consigliato)
• gpw (si concentra strongmente sulla pronunciabilità, non consigliato)

Uso degli strumenti Unix standard

Non tutti i sistemi potrebbero avere pwgen disponibile. Come altri hanno risposto, puoi usare md5sum o sha256sum , ma solo gli output 0-9 e a-f. Nessun caso g-z o misto, per non parlare di caratteri speciali. È meglio escludere semplicemente i caratteri non stampabili da /dev/urandom finché non hai una password della lunghezza desiderata:

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

Che dà qualcosa come XiVsdn[y o V@FPV^lY . Puoi modificare 8 alla fine della lunghezza della password desiderata. Puoi anche modificare la parte @-~ per limitare i caratteri. Ad esempio questo stamperà solo caratteri alfanumerici:

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

Questo è quasi identico a quello che farebbe pwgen -s e fornirà password come nZiUzNtE .

Come bonus, lo strumento tr è incluso in quasi tutti i sistemi operativi (Mac OS X, GNU / Linux, Android / Linux, Solaris, FreeBSD, ecc.) eccetto Microsoft Windows.

A seconda del tipo di caratteri che puoi includere, un semplice comando per creare una password leggibile con 128 bit di entropia è simile a questo:

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

(Tratto da qui ). [:graph:] sono tutti caratteri prettamente ascii tranne lo spazio.

Spiegazione:

128 bit sono equivalenti alle combinazioni 3.40e + 38 . Se stai utilizzando i 94 caratteri ASCII leggibili (eccetto lo spazio) , avrai bisogno di 20 caratteri per raggiungere almeno quella quantità di combinazioni: 94 ^ 20 = 2.90e + 39 .

Se, ad esempio, ti è consentito solo utilizzare _A-Za-z0-9 :

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

Per 63 possibili caratteri: 63 ^ 22 = 3.85e + 39 . Aggiunge solo due caratteri per raggiungere l'intera entropia.

Per le password esadecimali:

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

Esadecimale è facile: 128 bit sono 32 volte i bit di un carattere esadecimale.

Avviso importante : la maggior parte delle situazioni in cui è necessaria una password, verrà utilizzata una funzione di hash dietro, che effettivamente deriverà la stringa reale che verrà utilizzata. Questa analisi è soggetta al modo in cui la password viene cancellata / utilizzata.

Nota aggiuntiva : /dev/urandom è sicuro per questa operazione. Per favore controlla È un rand di / dev / urandom sicuro per una chiave di accesso? .

Nota aggiuntiva : se stai utilizzando più di una iterazione con una funzione di hash, puoi sottrarre i bit necessari per esprimere l'iterazione delle quantità totali di bit che puoi raggiungere, ad esempio:

65536 iterations = 2 ^ 16 iterazioni, aggiungi all'incirca 16 bit (2 byte) di entropia alla password scelta, perché in un attacco brute force, è necessario eseguire 2 ^ 16 iterazioni aggiuntive prima di calcolare l'hash utilizzato.

Solo per la cronaca, andando oltre i 128 bit di entropia, è inutile come spiegato qui: Quantità di operazioni semplici che sono al sicuro fuori dalla portata di tutta l'umanità?

Ma se la tua paranoia va oltre, ecco alcuni numeri utili:

Tutti gli ascii leggibili ( 29 caratteri , 1.6e + 57 combinazioni), 192 bit (6.28e + 57 combinazioni) di entropia:

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

_A-Za-z0-9 ( 32 caratteri , 3.79e + 57 combinazioni), 192 bit (6.28e + 57 combinazioni) di entropia:

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

A-F0-9 ( 48 caratteri , 16 ^ 48 combinazioni), 192 bit (2 ^ 192 combinazioni) di entropia:

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

Tutti gli ascii leggibili ( 39 caratteri , combinazioni 8.95e + 76), 256 bit (1.16e + 77 combinazioni) di entropia:

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

_A-Za-z0-9 ( 43 caratteri , 2.35e + 77 combinazioni), 256 bit (1.16e + 77 combinazioni) di entropia:

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

A-F0-9 ( 64 caratteri , 16 ^ 64 combinazioni), 256 bit (2 ^ 256 combinazioni) di entropia:

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

Considerando che le ultime sei opzioni sono già paranoiche, è completamente inutile scegliere password più complesse o più grandi di quelle sopra descritte.

Un one-liner per creare una password leggibile e relativamente facile da ricordare:

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

Esempio di output:

correct horse battery staple

Se desideri una password più lunga, cambia il numero 4 in un numero più alto. Per una password senza spazi, aggiungi uno spazio di escape alla fine della riga:

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

C'è un pacchetto chiamato makepasswd che può farlo.

 $ makepasswd --chars 64

Vorrei usare apg con seme da 16 byte da / dev / urandom (massimo consentito)

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

Puoi concatenare i comandi apg in modo da avere una password più lunga da più entropia.

Affinché le informazioni casuali siano leggibili, possiamo codificarle in base64. Un personaggio in base64 ha 6 bit di entropia. Pertanto, per 128 bit di entropia sono necessari 22 caratteri (128/6 = 21 + ⅓).

Questo ci porta al comando:

base64 < /dev/urandom | head -c 22

Che può essere tradotto in inglese da "generare dati casuali di qualità crittografica con / dev / urandom e convertirlo in base64, mantenere i primi 22 caratteri".

Potresti voler aggiungere un carattere extra di fine riga alla fine dell'output:

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

So che hai chiesto una linea, ma è molto più robusta con altro. ; -)

Il lavoro principale può essere ridotto a una riga se si desidera eliminare il controllo degli errori e la compatibilità tra le diverse versioni dell'utilità base64 ; questa implementazione funziona sia su OS X che Linux. (vedi la funzione create_password e sostituisci do_base64 con solo base64 con gli argomenti appropriati.) Puoi sostituire la funzione do_base64 con la tua funzione per selezionare i caratteri ASCII in base a un input binario, ma usando base64 (con un sed per eliminare / , + e = ) questo ti consente di ottenere lettere maiuscole, minuscole e numeri. ( 26 + 26 + 10 = 62 ; non sono sicuro di quali 94 caratteri hai inteso.)

Specifica la lunghezza della password che desideri come argomento.

#!/bin/bash

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

function do_base64 {
    WRAP=""
    base64 --help | grep -q -- --wrap && WRAP="-w 0"
    base64 $WRAP $@
}

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

Esempio di output:

$ mkpasswd 16
2LjxTkQHP7Lv4z0J

$ mkpasswd 24
txhhbeHfGZSl0UNRvsz78yFo

$ mkpasswd 64
TykZF3hMXcZp0rP4ig0d9zRsuVEDxHjIcLHGcNaf0ROhk66VCPc7tE8GXcVv7AKh

Inoltre, probabilmente vorrai sostituire /dev/urandom con /dev/random se ti interessa ottenere l'entropia corretta. (L'ho cambiato in /dev/urandom durante lo sviluppo da quando il mio pool di entropia era esaurito.)

uuidgen

ti fornirà un UUID; ricorda di controllare quale versione dell'UUID viene generata sul tuo computer in quanto alcune versioni permetteranno a qualcuno che sporge la tua password di rintracciarlo sul tuo computer, il che potrebbe (probabilmente è) un problema di sicurezza. Puoi usare

uuidgen -r

per assicurarti che l'ID sia composto solo da cifre casuali (ish) e che non possa essere tracciato per te. La stringa sarà composta da [a-z0-9] e -. Esempio di uscita:

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

La qualità della stringa dipende dalla capacità del tuo sistema operativo di generare numeri casuali ( /dev/random ).

Ecco una funzione che crea una password con un minimo di 128 bit di entropia usando numeri casuali compresi tra 33 e 126.

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
}

La funzione calcola la lunghezza minima richiesta per soddisfare i requisiti entropici (lunghezza di 20 in questo caso) e restituisce la password di quella lunghezza.

Il primo argomento può specificare la lunghezza della password scritta su stdout, purché sia maggiore della lunghezza minima per soddisfare il requisito di entropia.

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