Caracteres a serem evitados em senhas geradas automaticamente

StackOverflow https://stackoverflow.com/questions/55556

Pergunta

Preciso gerar algumas senhas, quero evitar caracteres que possam ser confundidos entre si.Existe uma lista definitiva de personagens que devo evitar?minha lista atual é

il10o8B3Evu![]{}

Existem outros pares de caracteres que são fáceis de confundir?para caracteres especiais, eu me limitaria aos que estão nas teclas numéricas, embora saiba que isso difere dependendo da nacionalidade do seu teclado!

Como pergunta do piloto, gostaria que minhas senhas fossem 'semelhantes a palavras'. Você tem um algoritmo preferido para isso?

Obrigado :)

Foi útil?

Solução

Aqui estão os conjuntos de caracteres que Steve Gibson usa em seu "Senha de papel perfeita" sistema.Eles são "personagens a serem permitidos" em vez de "personagens a serem evitados", mas parecem bastante razoáveis ​​para o que você deseja:

Um conjunto padrão de 64 caracteres

!#%+23456789:=?@ABCDEFGHJKLMNPRS
TUVWXYZabcdefghijkmnopqrstuvwxyz

Um conjunto maior de 88 caracteres

!"#$%&'()*+,-./23456789:;<=>?@ABCDEFGHJKLMNO
PRSTUVWXYZ[\]^_abcdefghijkmnopqrstuvwxyz{|}~

Para senhas pronunciáveis, não estou familiarizado com os algoritmos, mas você pode querer dar uma olhada APG e pwgen como ponto de partida.

Outras dicas

Meu método preferido é obter uma lista de palavras de 3, 4 e 5 letras.Em seguida, selecione pelo menos 2 deles e coloque um número aleatório de 2 dígitos ou um símbolo especial (%&*@#$) entre cada palavra.Se desejar, você pode colocar até um caractere por palavra em maiúscula aleatoriamente.

Dependendo dos seus requisitos de força, você terá senhas fáceis de lembrar e comunicar, como:

  • limão% mesa
  • chapéu de papel e menino32

Lembre-se de que você ocasionalmente obtém combinações de palavras interessantes ou inadequadas (deixarei você usar sua imaginação).Normalmente tenho um botão que permite a geração de uma nova senha caso a apresentada não seja apreciada.

Como regra, use apenas símbolos cujo nome as pessoas normalmente conheçam.Em um teclado padrão dos EUA eu evitaria ~`'/\^

Acho que isso respondeu mais à sua pergunta do piloto do que à sua pergunta principal...

Boa sorte!

Ler Escolhendo senhas seguras.

Uma informação interessante daí:Para senhas mais seguras, certifique-se de que alguns números e caracteres especiais apareçam no meio.Os programas de cracking os verificam no início e terminam mais cedo.

Para adicionar algo à resposta de Jim, você também pode usar a lista de palavras e substituir aleatoriamente certos caracteres por símbolos (um @ para A, 0 (zero) para O ou 5 para S) e/ou remover as vogais das palavras. .

  • lmn%Mesa
  • p@per&b0y32H@t

Ainda principalmente legível por humanos.

Como outra opção, você pode usar uma fonte monoespaçada/terminal como courier para imprimir as senhas.Personagens semelhantes deveriam ser muito mais distinguíveis dessa forma.

Para um cliente internacional, há vários anos, tive que gerar senhas aleatórias e seguras que foram então mescladas em documentos pelo meu cliente e enviadas por correio para destinatários em 40 países.Sem saber qual tipo de letra seria usada nos documentos, usei uma lista de caracteres como Steve Gibson 64 caracteres definido para eliminar a confusão entre glifos semelhantes.

Para tornar as senhas resultantes pronunciáveis ​​e, portanto, mais fáceis de lembrar, combinei consoantes e vogais, com alguns dígrafos consonantais (sh, th, wh, etc.) adicionados à mistura.

Para reduzir as chances de geração de palavras inadequadas ou ofensivas (em inglês ou nos idiomas dos destinatários), limitei a sequência de caracteres alfabéticos consecutivos a dois, com numerais ou caracteres de pontuação entre:

Es4tU$sA6
wH@cY8Go2

Olhando para trás, para meu método agora, percebo que havia espaço para melhorias no algoritmo de inadequação.Usando apenas as regras acima, algumas palavras ofensivas são possíveis agora que alguns números e pontuação são substituídos por letras.

Para senhas legíveis por humanos, usei recentemente um script PHP muito semelhante ao abaixo.Funcionou bem.É verdade que as senhas não serão incrivelmente seguras (já que são propensas a ataques de dicionário), mas para senhas memorizáveis, ou pelo menos legíveis, funciona bem.No entanto, esta função não deve ser usada como está, é mais para ilustração do que qualquer outra coisa.

function generatePassword($syllables = 2, $use_prefix = true)
{

    // Define function unless it is already exists
    if (!function_exists('arr'))
    {
        // This function returns random array element
        function arr(&$arr)
        {
            return $arr[rand(0, sizeof($arr)-1)];
        }
    }

    // Random prefixes
    $prefix = array('aero', 'anti', 'auto', 'bi', 'bio',
                    'cine', 'deca', 'demo', 'dyna', 'eco',
                    'ergo', 'geo', 'gyno', 'hypo', 'kilo',
                    'mega', 'tera', 'mini', 'nano', 'duo',
                    'an', 'arch', 'auto', 'be', 'co',
                    'counter', 'de', 'dis', 'ex', 'fore',
                    'in', 'infra', 'inter', 'mal', 
                    'mis', 'neo', 'non', 'out', 'pan',
                    'post', 'pre', 'pseudo', 'semi',
                    'super', 'trans', 'twi', 'vice');

    // Random suffixes
    $suffix = array('dom', 'ity', 'ment', 'sion', 'ness',
                    'ence', 'er', 'ist', 'tion', 'or',
                    'ance', 'ive', 'en', 'ic', 'al',
                    'able', 'y', 'ous', 'ful', 'less',
                    'ise', 'ize', 'ate', 'ify', 'fy', 'ly'); 

    // Vowel sounds 
    $vowels = array('a', 'o', 'e', 'i', 'y', 'u', 'ou', 'oo', 'ae', 'ea', 'ie'); 

    // Consonants 
    $consonants = array('w', 'r', 't', 'p', 's', 'd', 'f', 'g', 'h', 'j', 
                        'k', 'l', 'z', 'x', 'c', 'v', 'b', 'n', 'm', 'qu');

    $password = $use_prefix?arr($prefix):'';
    $password_suffix = arr($suffix);

    for($i=0; $i<$syllables; $i++)
    {
        // selecting random consonant
        $doubles = array('n', 'm', 't', 's');
        $c = arr($consonants);
        if (in_array($c, $doubles)&&($i!=0)) { // maybe double it
            if (rand(0, 2) == 1) // 33% probability
                $c .= $c;
        }
        $password .= $c;
        //

        // selecting random vowel
        $password .= arr($vowels);

        if ($i == $syllables - 1) // if suffix begin with vovel
            if (in_array($password_suffix[0], $vowels)) // add one more consonant 
                $password .= arr($consonants);

    }

    // selecting random suffix
    $password .= $password_suffix;

    return $password;
}

Na minha pós-graduação (engenharia elétrica, técnica), todas as contas de computador foram inicializadas com senhas que, presumo, foram geradas por um utilitário Linux padrão.Consistiam em três sílabas aleatórias, com três letras minúsculas em cada sílaba.O resultado foi razoavelmente seguro (da ordem de bilhões de combinações possíveis), mas tão pronunciável que ainda uso algumas dessas senhas mais de uma década depois.O exemplo de James é uma excelente demonstração disso.

Um comentário sobre senhas em geral, feito por um profissional de segurança de rede:eles são terríveis, por vários motivos, incluindo:

  • Geralmente facilmente quebrado, seja através de engenharia social ou com software de ataque, especialmente se você souber qualquer coisa sobre seu alvo.

    Exemplo 1: Recentemente precisei revisar um documento técnico protegido por senha.Olhando a data, eu sabia quem era nosso redator técnico residente na época, digitei a primeira palavra que me veio à mente e imediatamente desbloqueei o documento.

    Exemplo 2: Os programas padrão de quebra de senhas permitem que o cracker especifique um conjunto de regras que operam em um dicionário fornecido pelo usuário.É trivial substituir certas letras por $ymb01$, ou traduzir para 1337, etc.

  • Senhas "seguras" não são.Dado o grande número de senhas que a maioria das pessoas precisa lembrar, a maneira mais comum de "lembrar" uma senha "forte" como "a4$N!8_q" é escrevê-la em um pedaço de papel (ou, pior, armazená-la em um arquivo de texto).'Nuff disse.

Se você realmente precisa seguro autenticação, multifatorial (ou dois fatores) é o mecanismo aceito pela indústria.Os "dois fatores" geralmente são algo que você ter (como um cartão de acesso) e algo que você saber que o habilita (como um PIN).Nenhum deles funciona sem o outro – você precisa de ambos.

Por outro lado, considere o nível de segurança que você realmente precisa.O que você está protegendo?Até que ponto os “bandidos” desejam obtê-lo e quais serão as consequências se o fizerem?As chances são de "é@segredo!" é mais do que bom o suficiente.:-)

Eu não adoro a abordagem da lista de palavras.Por exemplo, em /usr/share/dict/words no OSX, existem 5110 palavras de 4 caracteres.Usar dois deles com um caractere separador produz aproximadamente 600 milhões de combinações.Mas se você usasse o conjunto de caracteres diretamente com um gerador de números aleatórios forte, teria 88 ^ 9 senhas possíveis, 3,16e + 17 combinações.

De qualquer forma, o provável ataque contra este sistema será contra o gerador de números aleatórios, portanto, certifique-se de usar um gerador criptograficamente forte.Se você usar a função rand padrão do PHP, ele será atacado registrando e redefinindo milhares de senhas para testar o estado do RNG e, em seguida, prever o estado restante do RNG, o que reduzirá o número de senhas possíveis que um invasor precisa testar.

Uma abordagem inicial pode ser gerar principalmente sílabas válidas em inglês, misturá-las e, em seguida, inserir uma conversão de texto-> l33t.Houve trabalhos realizados em gramáticas geracionais de linguagem natural, então um deles pode ajudar.

Por exemplo.ah ul ing são todas sílabas válidas ou próximas disso...misture-os -> Ingulah...l33t it -> 1ngu4h.É o melhor que existe?Não.Mas pelo menos é semipronunciável (se você fala l33t) e mais seguro computacionalmente.

Se você estiver interessado em gerar senhas pronunciáveis, há uma porta C# em:http://www.hoogervorst.ca/arthur/?attachment_id=1708

Dentro do código, você encontrará links úteis para saber mais.http://www.multicians.org/thvv/gpw.html

Boa sorte.James

function random_readable_pwd($length=12){
    // special characters
    $sym="!\"§$%&/()={[]}\,.-_:;@>|";

    // read words from text file to array
    $filename="special.txt";
    if (!file_exists($filename)) { die('File "'.$filename.'" is not exists!'); }
    $lines = file($filename);
    foreach ($lines as $line_num => $line) {
        $line=substr($line, 0, -2);
        $words[].=$line;
    }

    // Add words while password is smaller than the given length
    $pwd = '';
    $ran_date=date("s");
    while (strlen($pwd) < $length){
        $r = mt_rand(0, count($words)-1);
        // randomly upercare word but not all in one time
        if ($ran_date % 3 == 0) $words[$r]=ucwords($words[$r]);
        $pwd .= $words[$r];
        //randomly add symbol
        if ($ran_date % 2 == 0) $pwd .= $sym{mt_rand(0,strlen($sym))};
        $ran_date++;
    }

    // append a number at the end if length > 2 and
    // reduce the password size to $length
    $num = mt_rand(1, 99);
    if ($length > 2){
        $pwd = substr($pwd,0,$length-strlen($num)).$num;
    } else { 
        $pwd = substr($pwd, 0, $length);
    }

    return $pwd;

}
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top