Jak utworzyć silne hasła w systemie Linux?

Zastanawiam się, jak mogę stworzyć silne hasła w systemie Linux (zarówno dla zwykłych użytkowników, jak i dla administratorów) i czy są do tego specjalne programy.

pwgen to jeden z wielu programów do generowania haseł

Osobiście wolę nie używać generatora haseł, ponieważ generowanie haseł jest bardzo trudne do zapamiętania, ale jednym przenośnym rozwiązaniem jest użycie / dev / urandom

Tworzenie losowych haseł, które nie zawierają znaków specjalnych, ma 10 znaków:

$ cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c 10` 
dyxJRKldvp

Działa to poprzez pobieranie bajtów z / dev / urandom, usuwanie tych, które nie pasują do wzorca określonego w trpoleceniu i ograniczanie go do 10 znaków za pomocą head.

Tworzenie losowych haseł zawierających znaki specjalne ma długość 10 znaków:

$ cat /dev/urandom | tr -dc 'a-zA-Z0-9-_!@#$%^&*()_+{}|:<>?=' | fold -w 10 | grep -i '[!@#$%^&*()_+{}|:<>?=]' | head -n 1
MSF4wj@vP0

Używa nieco innej techniki po trusunięciu niechcianych bajtów, ponieważ chodzi o to, aby zmusić ją do posiadania co najmniej jednego znaku specjalnego. Działa to za pomocą foldpolecenia, aby owinąć linię w grupy po 10, a następnie użyć, grepaby pobrać tylko linie zawierające znak specjalny. headnastępnie pobiera pierwsze hasło, które spełnia wymagania.

Napisałem ten mały skrypt kilka lat temu i od tego czasu go używam. Jeśli już, to ciekawe nadużywanie printfi wykorzystuje piękny funkcji bash, że niestety rzadko widzieć w skryptach 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

Dodałbym również KeePassX, który daje opcję użycia entropii systemu do generowania silnych haseł z kilkoma fajnymi funkcjami - wszystko przy użyciu GUI. Daje także opcję zarządzania hasłami i zapisywania ich w zaszyfrowanym pliku.

Tak wygląda interfejs generatora haseł KPX:

apg nie jest złym wyborem, jeśli chcesz hasło, które można łatwo zapamiętać.

; 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)

Pamiętaj, że zgodnie z tym hasło powinno mieć co najmniej 12 znaków.

Używam nieprzypadkowego, ale jest wystarczająco zróżnicowany do wszystkich celów ataku ... hasło główne i ostatnie przejście, aby wygenerować inne hasła. Oto jak wygeneruję hasło główne.

echo -n "some seed" |  openssl dgst -binary -sha1 | base64 | sed -e 's/.\{4\}/& /g'

i wynik

H1sI Wpbj JE2P CdVJ A1qb 9B/e u7M= 

teraz wystarczy wybrać kilka sekcji i utworzyć hasło, zmienić ich kolejność, pominąć niektóre, dodać znak lub 2, aby było tak dobre, jak losowe. Tak długo, jak pamiętasz ziarno, możesz je zregenerować i odzyskać hasło (o ile nie wprowadzasz zbyt wielu modyfikacji)

pwgen jest cudownym, małym narzędziem cli, które pozwala określić liczbę parametrów do ustawienia złożoności, klas znaków, liczbę haseł do wygenerowania, długość itp.

Oto jednorazowy skrypt do generowania haseł typu XKCD . /usr/share/dict/wordsnie jest świetnym słownikiem do tego, ponieważ większość słów jest długa, ale jest łatwo dostępna. Dla lepszych haseł możesz użyć słownika krótkich słów, takiego jak lista słów S / Key One-Time Password .

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

Jeśli jesteś użytkownikiem GNOME i musisz przechowywać hasła do różnych kont, możesz wypróbować menedżera haseł Revelation . Ma podstawową funkcję generatora haseł, polegającą na tym, że ustawiasz tylko długość hasła i wybierasz, czy oprócz liter i cyfr mają być uwzględniane znaki interpunkcyjne.

Popraw mnie, jeśli się mylę, ale: O ile rozumiem, nie ma mowy, aby komputer mógł wymyślić zupełnie losowy ciąg. Więc wpadłem na następujący pomysł [i mam nadzieję, że to nie jest całkowicie głupie]:

Jeśli ktoś rzuci kostką 26-stronną, szansa na rzucenie, powiedzmy 26 to 1:26. Innymi słowy: Szansa na rzucenie 26 wynosi około 0,04%. Co więcej, kostka nie ma pamięci i błędów. Wpadłem na następujący pomysł:

• zdobądź 26-stronne kostki, z których każda strona pasuje do litery alfabetu
• zdobądź dziesięciościenne kości, w których każda strona odpowiada liczbie od 0 do 9
• rzuć monetą
• głowa oznacza: rzuć kostką z literą
• ogony oznaczają: rzuć kostką

Modele papieru do wydrukowania:

• Kostki 10-stronne: http://www.korthalsaltes.com/model.php?name_en=decahedron
• Kostki 26-stronne: http://www.korthalsaltes.com/model.php?name_en=rhombicuboctahedron

Uwaga : nie jestem matematykiem i wpadłem na ten pomysł po przeczytaniu artykułu w magazynie 2600, który to opisał. Właśnie dodałem kilka własnych pomysłów dotyczących podstawowej koncepcji.

Ponadto : Zastanawiam się, czy nie jest to idealny przykład na „ napisanie swojego pierwszego narzędzia do łamania haseł ”. Ale twoje pytanie dało mi idealny powód do przedstawienia tego pomysłu na dyskusję.

Mam dwa aliasy dodane do mojego pliku .zshrc.local, aby utworzyć silne hasła.

Pierwszy to:

alias pw.graph="cat /dev/urandom | tr -dc '[:graph:]' | fold -w 1000 | perl -pe 's/(.)(?=.*?\1)//g' | head -n 5"

Wynikiem pisania pw.graph jest pięć wierszy każdego znaku, który można wpisać na klawiaturze, z wyjątkiem spacji:

/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?}

Drugi to:

alias pw.alnum="cat /dev/urandom | tr -dc '[:alnum:]' | fold -w 1000 | perl -pe 's/(.)(?=.*?\1)//g' | head -n 5"

Wynikiem wpisywania pw.alnum jest każda drukowana litera i cyfra, zarówno wielkie, jak i małe:

E6wgCfVBbXjyzYQ8USKl79LqPih0e5mvGrNHd3osaW2OxkJ1RM4nFTtcuZIpDA
GTvQON1dsZSpJmegBMK6bqnEciU7k0AoV2H4Wh53zr9YRfLlDxywXItu8CjPFa
6u1Db9MfyBApZdU7gqoV2PGwH5LcxWi3JNj8nkQCIThezSlYEXsOtrmF04KvaR
VFrsGwI9yAmabEnlRTKgZO23vUq4f6LHkzQP7tMjNW8ph1exuDoBCXSd50JciY
G3r6Em5tlfjQARJx9gWHes7bCVwkzcP48KaSIXyUFBMLqT0op1uDNdih2nYZOv

Zwykle używam pw.graph i kopiuję losową część linii. Niektóre hasła nie zezwalają na symbole, dlatego używam do tego części pw.alnum.

Używam tego zapisanego jako plik .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>