Come creare password complesse in Linux?
Risposte:
pwgen è uno dei molti programmi per generare password
Personalmente, preferisco non usare il generatore di password poiché le password generate sono molto difficili da ricordare, ma una soluzione portatile è usare / dev / urandom
La creazione di password casuali che non contiene caratteri speciali, è lunga 10 caratteri:
$ cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c 10`
dyxJRKldvp
Funziona catturando byte da / dev / urandom, eliminando quelli che non si adattano al modello specificato nel trcomando e limitandolo a 10 caratteri con head.
La creazione di password casuali che contiene caratteri speciali, è lunga 10 caratteri:
$ cat /dev/urandom | tr -dc 'a-zA-Z0-9-_!@#$%^&*()_+{}|:<>?=' | fold -w 10 | grep -i '[!@#$%^&*()_+{}|:<>?=]' | head -n 1
MSF4wj@vP0
Questo utilizza una tecnica leggermente diversa dopo aver trrimosso i byte indesiderati, poiché l'idea è di forzarlo ad avere almeno un carattere speciale. Funziona usando il foldcomando per avvolgere la linea in gruppi di 10, quindi usando grepper recuperare solo le linee che contengono un carattere speciale. headquindi recupera la prima password che soddisfa i requisiti.
Ho scritto questa piccola sceneggiatura qualche anno fa e la utilizzo da allora. Se non altro, si tratta di un abuso di interessante printfe utilizza una caratteristica bella di BASH che io, purtroppo, raramente vedo negli script: 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
Aggiungerei anche KeePassX che ti dà la possibilità di usare l'entropia di sistema per generare password complesse con alcune belle funzionalità, tutte usando la GUI. Ti dà anche la possibilità di gestire le tue password e salvarle in un file crittografato.
Ecco come appare l'interfaccia del generatore di password KPX:
apg non è una cattiva scelta se si desidera una password che può essere facilmente memorizzata.
; 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)
Tieni presente che, in base a ciò , la password deve contenere almeno 12 caratteri.
Uso un metodo non casuale, ma è abbastanza vario per tutti gli scopi di attacco ... password principale e ultimo passaggio per generare altre password. Ecco come posso generare la password principale.
echo -n "some seed" | openssl dgst -binary -sha1 | base64 | sed -e 's/.\{4\}/& /g'
e l'uscita
H1sI Wpbj JE2P CdVJ A1qb 9B/e u7M=
ora basta selezionare alcune sezioni e creare una password, riorganizzarle, lasciarne un po 'fuori, aggiungere un carattere o 2 per renderlo casuale. Se riesci a ricordare il tuo seed puoi rigenerarlo e recuperare la tua password (purché non apporti troppe modifiche)
Ecco uno script unico per la generazione di passphrase in stile XKCD . /usr/share/dict/wordsnon è un grande dizionario per questo poiché la maggior parte delle parole sono lunghe, ma è facilmente disponibile. Per passphrase più belle, è possibile utilizzare un dizionario di parole brevi come l' elenco di parole con password singola S / Key .
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
Se sei un utente GNOME e devi anche archiviare le password per i tuoi vari account, puoi provare Revelation password manager. Ha una funzione di base per la generazione di password, in quanto imposti solo la lunghezza della password e scegli se includere caratteri di punteggiatura oltre a lettere e cifre.
Correggimi se sbaglio, ma: per quanto ho capito, non c'è modo che un computer possa inventare una stringa completamente casuale. Quindi mi è venuta l'idea seguente [e spero che non sia del tutto stupida]:
Se uno lancia un dado a 26 facce, la possibilità di lanciare, diciamo 26 è 1:26. In altre parole: la possibilità di lanciare 26 è di circa lo 0,04%. Inoltre, un dado non ha memoria né bug. Mi è venuta l'idea seguente:
- prendi un dado a 26 facce, dove ogni lato corrisponde a una lettera dell'alfabeto
- prendi un dado a dieci facce dove ogni parte corrisponde a un numero compreso tra 0 e 9
- lanciare una moneta
- testa significa: lanciare i dadi lettera
- croce significa: lanciare il numero di dadi
Modelli di carta da stampare:
- Dadi a 10 facce: http://www.korthalsaltes.com/model.php?name_en=decahedron
- Dadi a 26 facce: http://www.korthalsaltes.com/model.php?name_en=rhombicuboctahedron
Nota : non sono un professionista della matematica e mi è venuta questa idea dopo aver letto un articolo sulla rivista 2600 che lo descriveva. Ho appena aggiunto alcune delle mie idee sul concetto di base.
Inoltre : mi chiedo se questo non sia solo un esempio perfetto per " scrivi il tuo primo cracker della forza bruta ". Ma la tua domanda mi ha dato una ragione perfetta per far emergere questa idea per essere discussa.
Ho due alias aggiunti al mio file .zshrc.local per creare password complesse.
Il primo è:
alias pw.graph="cat /dev/urandom | tr -dc '[:graph:]' | fold -w 1000 | perl -pe 's/(.)(?=.*?\1)//g' | head -n 5"
L'output di digitare pw.graph è di cinque righe di ogni carattere che può essere digitato su una tastiera ad eccezione della barra spaziatrice:
/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?}
Il secondo è:
alias pw.alnum="cat /dev/urandom | tr -dc '[:alnum:]' | fold -w 1000 | perl -pe 's/(.)(?=.*?\1)//g' | head -n 5"
L'output di digitare pw.alnum è ogni lettera e numero stampabile sia in maiuscolo che in minuscolo:
E6wgCfVBbXjyzYQ8USKl79LqPih0e5mvGrNHd3osaW2OxkJ1RM4nFTtcuZIpDA
GTvQON1dsZSpJmegBMK6bqnEciU7k0AoV2H4Wh53zr9YRfLlDxywXItu8CjPFa
6u1Db9MfyBApZdU7gqoV2PGwH5LcxWi3JNj8nkQCIThezSlYEXsOtrmF04KvaR
VFrsGwI9yAmabEnlRTKgZO23vUq4f6LHkzQP7tMjNW8ph1exuDoBCXSd50JciY
G3r6Em5tlfjQARJx9gWHes7bCVwkzcP48KaSIXyUFBMLqT0op1uDNdih2nYZOv
Di solito uso pw.graph e copio una porzione casuale della linea. Alcune password non consentono i simboli, quindi per questo uso una porzione di pw.alnum.
Uso questo salvato come file .html:
<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>
[:print:]pertr(tr -dc '[:print:]'), se sei un po 'paranoico. Il problema saranno quindi i simboli disponibili sulla tastiera ...