Como criar senhas fortes no Linux?

Gostaria de saber como posso criar senhas fortes no Linux (para usuários normais e administradores) e se existem programas específicos para fazer isso.

O pwgen é um dos muitos programas para gerar senhas

Pessoalmente, prefiro não usar o gerador de senhas, pois as senhas geradas são muito difíceis 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 pegando bytes de / dev / urandom, excluindo aqueles que não se encaixam no padrão especificado no trcomando e limitando-o a 10 caracteres head.

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

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

Isso usa uma técnica ligeiramente diferente após trremover bytes indesejados, pois a idéia é forçá-lo a ter pelo menos um caractere especial. Isso funciona usando o foldcomando para quebrar a linha em grupos de 10 e, em seguida, usando greppara buscar apenas linhas que contêm um caractere especial. headentão busca a primeira senha que atenda aos requisitos.

Escrevi este pequeno script alguns anos atrás e o uso desde então. Se alguma coisa, é um abuso interessante printfe usa um recurso encantador do bash que eu, infelizmente, raramente se vê 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 o KeePassX, que oferece a opção de usar 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.

É assim que a interface do gerador de senhas KPX se parece:

apg não é uma má escolha se você quiser 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 isso , 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 último passe 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, basta escolher algumas das seções e criar uma senha, reorganizá-las, deixar algumas de fora, adicionar um caractere ou 2 para torná-lo tão aleatório quanto possível. Contanto que você se lembre da sua semente, poderá regenerar isso e recuperar sua senha (desde que não faça muitas modificações)

pwgen é uma ferramenta pequena e maravilhosa que permite especificar vários parâmetros para definir complexidade, classes de caracteres, número de senhas para gerar, tamanho, etc.

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

Se você é um usuário do GNOME e também precisa armazenar senhas para suas várias contas, tente o gerenciador de senhas do Revelation . Possui um recurso básico de gerador de senha, no qual você define apenas o tamanho da senha e escolhe se deseja incluir caracteres de pontuação além de letras e dígitos.

Corrija-me se estiver errado, mas: Até onde eu entendi, não há como um computador criar uma string completamente aleatória. Então, 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 jogar 26 é de cerca de 0,04%. Além disso, um dado não tem memória nem erros. Eu tive a seguinte ideia:

• obter um dado de 26 lados, em que cada lado corresponde a uma letra do alfabeto
• obter dados de dez lados em que cada lado corresponde a um número entre 0 e 9
• jogar uma moeda
• cabeça significa: jogar dados da letra
• caudas significa: jogue 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 : Eu não sou um profissional de matemática e tive essa ideia depois de ler um artigo na revista 2600 que descrevia isso. Acabei de adicionar algumas das minhas próprias idéias sobre o conceito básico.

Além disso : Gostaria de saber se este não é apenas um exemplo perfeito para ' escreva seu primeiro cracker de senha de força bruta '. Mas sua pergunta me deu uma razão perfeita para trazer essa idéia para ser discutida.

Eu 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 da digitação do pw.graph é de 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%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?}

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 para digitar pw.alnum é toda letra e número imprimível em maiúsculas e minúsculas:

E6wgCfVBbXjyzYQ8USKl79LqPih0e5mvGrNHd3osaW2OxkJ1RM4nFTtcuZIpDA
GTvQON1dsZSpJmegBMK6bqnEciU7k0AoV2H4Wh53zr9YRfLlDxywXItu8CjPFa
6u1Db9MfyBApZdU7gqoV2PGwH5LcxWi3JNj8nkQCIThezSlYEXsOtrmF04KvaR
VFrsGwI9yAmabEnlRTKgZO23vUq4f6LHkzQP7tMjNW8ph1exuDoBCXSd50JciY
G3r6Em5tlfjQARJx9gWHes7bCVwkzcP48KaSIXyUFBMLqT0op1uDNdih2nYZOv

Normalmente, uso o 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="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>