Como criar senhas fortes no Linux?

pwgen é um dos muitos programas para gerar senhas

Pessoalmente, prefiro não usar o gerador de senha, pois a senha gerada é muito difícil de lembrar, mas uma solução portátil é usar / dev/urandom

A criação de senhas aleatórias que não contenham caracteres especiais tem 10 caracteres:

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

Isso funciona capturando bytes de/dev/urandom, excluindo aqueles que não se encaixam no padrão especificado no comando tr e limitando-o a 10 caracteres com head.

A criação de senhas aleatórias que contenham caracteres especiais tem 10 caracteres:

$ cat /dev/urandom | tr -dc '[email protected]#$%^&*()_+{}|:<>?=' | fold -w 10 | grep -i '[[email protected]#$%^&*()_+{}|:<>?=]' | head -n 1
[email protected]

Isso usa uma técnica ligeiramente diferente depois que tr remove bytes indesejados, pois a ideia é forçá-lo a ter pelo menos um caractere especial. Isso funciona usando o comando fold para quebrar a linha em grupos de 10, então usando grep para buscar apenas linhas que contenham um caractere especial. head então busca a primeira senha que atenda aos requisitos.

Escrevi este pequeno script há alguns anos e tenho usado desde então. De qualquer forma, é um abuso interessante de printf e usa um recurso adorável do BASH que infelizmente raramente vejo em scripts: 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

Eu também adicionaria KeePassX que dá a você a opção de usar a entropia do sistema para gerar senhas fortes com alguns recursos interessantes - todos usando GUI. Também oferece a opção de gerenciar suas senhas e salvá-las em um arquivo criptografado.

Esta é a aparência da interface do gerador de senha KPX:

apg não é uma escolha ruim se você deseja uma senha que possa ser facilmente lembrada.

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

Observe que de acordo com this , sua senha deve ter pelo menos 12 caracteres.

Eu uso um não aleatório, mas é variado o suficiente para todos os fins de ataque ... senha mestra, e última passagem para gerar outras senhas. Veja como eu gero a senha mestra.

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

e a saída

H1sI Wpbj JE2P CdVJ A1qb 9B/e u7M= 

agora é só escolher algumas das seções e criar uma senha, reorganizá-las, deixar algumas de fora, adicionar um caractere ou 2 para torná-las tão boas quanto aleatórias. Contanto que você possa se lembrar de sua semente, você pode regenerá-la e recuperar sua senha (contanto que você não faça muitas modificações)

Aqui está um script único para gerar estilo XKCD senhas. /usr/share/dict/words não é um ótimo dicionário para isso, pois a maioria das palavras são longas, mas está facilmente disponível. Para frases-senha mais agradáveis, você pode usar um dicionário de palavras curtas, como lista de palavras-chave de uso único 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

pwgen é uma pequena e maravilhosa ferramenta CLI que permite que você especifique uma série de parâmetros para definir a complexidade, classes de caracteres, número de senhas a gerar, comprimento, etc.

Corrija-me se eu estiver errado, mas: Pelo que entendi, não há nenhuma maneira de um computador criar uma string completamente aleatória. Então eu tive a seguinte ideia [e espero que não seja completamente estúpida]:

Se alguém joga um dado de 26 lados, a chance de jogar, digamos, 26 é 1:26. Em outras palavras: a chance de acertar 26 é de cerca de 0,04%. Além disso, um dado não tem memória nem bugs. Tive a seguinte ideia:

• obtenha um dado de 26 lados, onde cada lado corresponde a uma letra do alfabeto
• obtenha um dado de dez lados onde cada lado corresponde a um número entre 0 e 9
• lançar uma moeda
• cabeça significa: jogar dados de cartas
• coroa significa: lançar dados numéricos

Modelos de papel para imprimir:

• Dados de 10 lados: http://www.korthalsaltes.com/model.php?name_en=decahedron
• Dados de 26 lados: http://www.korthalsaltes.com/model.php?name_en=rhombicuboctahedron

Nota : Não sou um profissional de matemática e tive essa ideia depois de ler um artigo na revista 2600 que descreveu isso. Acabei de adicionar algumas de minhas próprias idéias sobre o conceito básico.

Além disso : Eu me pergunto se este não é apenas um exemplo perfeito para ' escreva seu primeiro cracker de senha de força bruta' . Mas sua pergunta me deu um motivo perfeito para trazer essa ideia a ser discutida.

Tenho dois aliases adicionados ao meu arquivo .zshrc.local para criar senhas fortes.

O primeiro é:

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

A saída de digitar pw.graph são cinco linhas de cada caractere que pode ser digitado em um teclado, com exceção da barra de espaço:

/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%[email protected]!ZPM$5to1f-.U9ClK,)'jDi0"pw>EzN^|gX~BSAJk\VFG(H<bx}+Q6#vL;e
s^[email protected]/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?}

O segundo é:

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

A saída de digitar pw.alnum é cada letra e número imprimível em maiúsculas e minúsculas:

E6wgCfVBbXjyzYQ8USKl79LqPih0e5mvGrNHd3osaW2OxkJ1RM4nFTtcuZIpDA
GTvQON1dsZSpJmegBMK6bqnEciU7k0AoV2H4Wh53zr9YRfLlDxywXItu8CjPFa
6u1Db9MfyBApZdU7gqoV2PGwH5LcxWi3JNj8nkQCIThezSlYEXsOtrmF04KvaR
VFrsGwI9yAmabEnlRTKgZO23vUq4f6LHkzQP7tMjNW8ph1exuDoBCXSd50JciY
G3r6Em5tlfjQARJx9gWHes7bCVwkzcP48KaSIXyUFBMLqT0op1uDNdih2nYZOv

Eu normalmente uso pw.graph e copio uma parte aleatória da linha. Algumas senhas não permitem símbolos, então eu uso uma parte do pw.alnum para isso.

Eu uso isso salvo como um arquivo .html:

<script>
var keylist="[email protected]#$%^&*_"
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>

Se você é um usuário GNOME e também precisa armazenar senhas para suas várias contas, você pode tentar o Revelação gerenciador de senhas. Ele tem um recurso gerador de senha básico, em que você apenas define o comprimento da senha e escolhe se deseja incluir caracteres de pontuação além de letras e dígitos.