Como criar senhas strongs no Linux?

Question

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

    

Answer 1

O pwgen é um dos muitos programas para gerar senhas

    

Answer 2

Pessoalmente, prefiro não usar o gerador de senhas, 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 contêm 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 com 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 depois que tr remove bytes indesejados, já que a idéia é forçá-lo a ter pelo menos um caractere especial. Isso funciona usando o comando fold para agrupar a linha em grupos de 10 e, em seguida, usar grep para buscar somente linhas que contenham um caractere especial. head , em seguida, busca a primeira senha que atende aos requisitos.

    

Answer 3

Eu escrevi este pequeno roteiro há alguns anos e tenho usado desde então. Se alguma coisa, é um abuso interessante de printf e usa um recurso interessante 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

    

Answer 4

Eu também adicionaria o KeePassX , que oferece a opção de usar a entropia do sistema para gerar senhas strongs com alguns recursos interessantes - tudo 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 do KPX se parece:

    

Answer 5

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 esta , sua senha deve ter pelo menos 12 caracteres.

    

Answer 6

Eu uso um não aleatório, mas é variado o suficiente para todos os propósitos 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, escolha algumas das seções e crie uma senha, reorganize-as, deixe algumas para fora, adicione um caractere ou 2 para torná-lo tão bom quanto aleatório. Desde que você consiga lembrar sua semente, você pode regenerar isso e recuperar sua senha (contanto que você não faça muitas modificações)

    

Answer 7

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

    

Answer 8

Aqui está um script único para gerar senhas com estilo XKCD . /usr/share/dict/words não é um ótimo dicionário para isso, já que a maioria das palavras é longa, mas está facilmente disponível. Para senhas mais agradáveis, você pode usar um dicionário de palavras curtas, como a lista de palavras com senha única S / Key .

dict="/usr/share/dict/words"
max="'wc -l <"$dict"'" \
    perl -e '$count=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

    

Answer 9

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 . Ele tem um recurso básico de gerador de senha, em que você só define o tamanho da senha e escolhe se deseja incluir caracteres de pontuação além de letras e dígitos.

    

Answer 10

Corrija-me se estiver errado, mas: Até onde eu entendi, não há nenhuma maneira como um computador pode criar uma string completamente aleatória. Então eu tive a seguinte ideia [e espero que não seja completamente idiota]:

Se alguém lança um dado de 26 lados, a chance de lançar, digamos, 26 é 1:26. Em outras palavras: a chance de jogar 26 é de aproximadamente 0,04%. Além disso, um dado não tem memória nem bugs. Eu tive a seguinte ideia:

• consiga um dado de 26 faces, 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
• jogue uma moeda
• cabeça significa: jogue dados de carta
• caudas significa: lançar dados numéricos

Modelos de papel para imprimir:

• Dados de 10 lados: link
• 26 dados de lados: link

Nota : Eu 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 das minhas próprias ideias sobre o conceito básico.

Também : Eu me pergunto se isso não é apenas um exemplo perfeito para ' escrever seu primeiro cracker de senha de força bruta '. Mas sua pergunta me deu uma razão perfeita para trazer essa ideia para discussão.

    

Answer 11

Eu tenho dois aliases adicionados ao meu arquivo .zshrc.local para criar senhas strongs.

O primeiro é:

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

A saída de digitação pw.graph é de cinco linhas de cada caractere que podem ser digitadas 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/(.)(?=.*?)//g' | head -n 5"

A saída da digitação pw.alnum é toda letra e número imprimíveis em letras maiúsculas e minúsculas:

E6wgCfVBbXjyzYQ8USKl79LqPih0e5mvGrNHd3osaW2OxkJ1RM4nFTtcuZIpDA
GTvQON1dsZSpJmegBMK6bqnEciU7k0AoV2H4Wh53zr9YRfLlDxywXItu8CjPFa
6u1Db9MfyBApZdU7gqoV2PGwH5LcxWi3JNj8nkQCIThezSlYEXsOtrmF04KvaR
VFrsGwI9yAmabEnlRTKgZO23vUq4f6LHkzQP7tMjNW8ph1exuDoBCXSd50JciY
G3r6Em5tlfjQARJx9gWHes7bCVwkzcP48KaSIXyUFBMLqT0op1uDNdih2nYZOv

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

    

Answer 12

Eu uso isso salvo como 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>