Gerando uma senha aleatória em php

190

Eu estou tentando gerar uma senha aleatória em php.

No entanto, estou recebendo todos os 'a's e o tipo de retorno é do tipo array e gostaria que fosse uma string. Alguma idéia de como corrigir o código?

Obrigado.

function randomPassword() {
    $alphabet = "abcdefghijklmnopqrstuwxyzABCDEFGHIJKLMNOPQRSTUWXYZ0123456789";
    for ($i = 0; $i < 8; $i++) {
        $n = rand(0, count($alphabet)-1);
        $pass[$i] = $alphabet[$n];
    }
    return $pass;
}
nunos
fonte
9
Nenhuma das respostas usa um gerador de números aleatórios seguro , que você deseja para uma senha.
Scott Arciszewski
4
Os visitantes devem estar recebendo informações potencialmente relacionadas à segurança de uma fonte que possa ser atualizada corretamente, e não de uma pergunta fechada a novas respostas. Estou excluindo as respostas desta duplicata para que os visitantes leiam as respostas da pergunta aberta. (Se esta pergunta é sempre reaberto, respostas serão recuperados.)
Jeremy Banks
6
@JeremyBanks Em nenhum lugar a pergunta declara que uma senha criptograficamente segura é necessária. Para algumas pessoas, as respostas usadas /dev/randomsão suficientes, pois a pergunta não solicita uma senha " segura " (e não deve ser editada para conter isso, pois isso alteraria o significado da pergunta original). Embora eu seja a favor da segurança, acho que essa bomba de carpete não foi totalmente pensada. Como o uso mysql_*, as respostas ainda são válidas, mas devem ser marcadas como inseguras. Talvez isso seja algo que o SO precise incluir como software extra - a capacidade de avisar sobre códigos inseguros?
Jimbo
6
@JeremyBanks Você pode restabelecer as respostas a esta pergunta? Só porque é uma duplicata, não significa que as respostas estejam erradas (votei acidentalmente para reabrir, concordo que seja uma duplicata). Não faz sentido excluir as respostas. Em vez disso, considere remover esta pergunta e migrar as respostas para a outra pergunta (já vi isso antes).
Naftali tcp Neal
7
@ JeremyBanks se você quiser que algo não seja reaberto, bloqueie-o. Caso contrário, 99% das pessoas irão reabri-lo e criar uma bagunça inteira. Pessoalmente eu discordo totalmente com exclusão de respostas altamente marcou apenas como aquele, mas não pode lutar com você sobre isso
Assistente de Sombra é Ear para você

Respostas:

258

Aviso de segurança : rand()não é um gerador de números pseudo-aleatórios criptograficamente seguros. Procure em outro lugar por gerar uma string pseudo-aleatória criptograficamente segura no PHP .

Tente isso (use em strlenvez de count, porque countem uma string é sempre 1):

function randomPassword() {
    $alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890';
    $pass = array(); //remember to declare $pass as an array
    $alphaLength = strlen($alphabet) - 1; //put the length -1 in cache
    for ($i = 0; $i < 8; $i++) {
        $n = rand(0, $alphaLength);
        $pass[] = $alphabet[$n];
    }
    return implode($pass); //turn the array into a string
}

Demonstração: http://codepad.org/UL8k4aYK

Neal
fonte
24
Parece mais simples de usar $pass .= $alphabet[$n].
Mateus
33
Gerar senha usando rand é uma péssima idéia. Não é um PRNG seguro. (e não mt_randé melhor também) #
CodesInChaos
19
A questão é gerar uma senha . O código para gerar uma senha claramente precisa usar números aleatórios seguros.
CodesInChaos
10
Pelo mesmo motivo que não se trata de uma pergunta duplicada, esta resposta está incorreta, pois se trata de gerar uma senha e não uma sequência aleatória . Esta resposta fornece uma abordagem extremamente insegura para gerar uma senha. Por favor, use a resposta do @ user3260409 abaixo, onde openssl_random_pseudo_bytes()é usado em vez derand()
Sorry-Im-a-N00b
35
Vi seu código inseguro em produção e quero pará-lo na fonte. Você PRECISA proteger aleatoriamente criptograficamente as senhas.
Scott Arciszewski
120

TL; DR:

  • Use random_int()e os dados random_str()abaixo.
  • Se você não possui random_int(), use random_compat .

Explicação:

Como você está gerando uma senha , é necessário garantir que a senha que você gera seja imprevisível, e a única maneira de garantir que essa propriedade esteja presente em sua implementação é usar um gerador de números pseudo-aleatórios criptograficamente seguros (CSPRNG).

O requisito para um CSPRNG pode ser relaxado para o caso geral de seqüências aleatórias, mas não quando a segurança está envolvida.

A resposta simples, segura e correta à geração de senhas no PHP é usar o RandomLib e não reinventar a roda. Essa biblioteca foi auditada por especialistas em segurança do setor e por mim.

Para desenvolvedores que preferem inventar sua própria solução, o PHP 7.0.0 fornecerá random_int()esse propósito. Se você ainda está no PHP 5.x, criamos um polyfill do PHP 5 pararandom_int() que você possa usar a nova API antes do lançamento do PHP 7. Usar nosso random_int()polyfill é provavelmente mais seguro do que escrever sua própria implementação.

Com um gerador inteiro aleatório seguro disponível, gerar uma sequência aleatória segura é mais fácil do que pie:

<?php
/**
 * Generate a random string, using a cryptographically secure 
 * pseudorandom number generator (random_int)
 * 
 * For PHP 7, random_int is a PHP core function
 * For PHP 5.x, depends on https://github.com/paragonie/random_compat
 * 
 * @param int $length      How many characters do we want?
 * @param string $keyspace A string of all possible characters
 *                         to select from
 * @return string
 */
function random_str(
    $length,
    $keyspace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
) {
    $str = '';
    $max = mb_strlen($keyspace, '8bit') - 1;
    if ($max < 1) {
        throw new Exception('$keyspace must be at least two characters long');
    }
    for ($i = 0; $i < $length; ++$i) {
        $str .= $keyspace[random_int(0, $max)];
    }
    return $str;
}
Scott Arciszewski
fonte
2
O RandomLib não foi atualizado há mais de dois anos. Usá-lo em uma versão recente do PHP (7.1.25 no meu caso) lança avisos de reprovação para várias mcrypt_*funções. Eu posso ver em um tópico de problema que você invadiu a biblioteca por não conseguir acessar o @ircmaxell, mas seu fork diz 'falha na compilação' em Travis. Gostaria de atualizar esta resposta (que ainda aparece bastante no Google)?
Janus Bahs Jacquet
1
Boa pegada! Isso precisa ser removido.
Scott Arciszewski
113

Sei que você está tentando gerar sua senha de uma maneira específica, mas também pode querer usar esse método ...

$bytes = openssl_random_pseudo_bytes(2);

$pwd = bin2hex($bytes);

Ele foi retirado do site php.net e cria uma string com o dobro do número que você coloca na função openssl_random_pseudo_bytes. Portanto, o acima criaria uma senha com 4 caracteres.

Em resumo...

$pwd = bin2hex(openssl_random_pseudo_bytes(4));

Criaria uma senha com 8 caracteres.

Observe, no entanto, que a senha contém apenas os números 0-9 e letras minúsculas af!

user3260409
fonte
13
Se você quer uma senha que é maiúsculas, minúsculas e números, tente o seguinte: gist.github.com/zyphlar/7217f566fc83a9633959
willbradley
@ زياد Diz quem? Se o gerador estivesse usando bytes de 7 bits, eu concordaria com você, mas openssl_random_pseudo_bytes()é um poderoso gerador de aleatoriedade de bytes binários completos e não precisa de nenhuma alteração posterior. Também aproveitarei a oportunidade para ressaltar que é perigoso supor que o empilhamento de vários métodos de criptografia tornará qualquer coisa mais aleatória; em alguns casos, pode ser exatamente o oposto por causa da acumulação de colisões de hash.
Havenard 7/08
56

Código minúsculo com 2 linhas.

demo: http://codepad.org/5rHMHwnH

function rand_string( $length ) {

    $chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    return substr(str_shuffle($chars),0,$length);

}

echo rand_string(8);

com rand_string, você pode definir quanto caractere será criado.

BSQ
fonte
21
Bom, embora você não obtenha caracteres repetidos usando essa abordagem, o que pode ser indesejável.
Hobo
11
Essa função é terrível para gerar senhas longas. Primeiro, se $ length for maior que a string $ chars, você não receberá uma string pelo tamanho digitado, mas pelo comprimento da string chars. Além disso, você tem a garantia de apenas 1 de cada personagem sem duplicatas. Ele também não garante o uso de uma letra maiúscula ou um número que é muitas vezes um requisito (exceto, claro, se o seu comprimento é de mais de 26, devido à falha anterior)
Programster
Que tal esse @Programster e @Hobo? substr(str_shuffle(str_repeat($chars,$length)),0,$length);
Charles-Édouard Coste
@ Charles-EdouardCoste parece funcionar bem o suficiente (especialmente se você adicionar alguns caracteres especiais). Embora ainda não garanta pelo menos um de cada tipo de personagem. A única coisa que me incomoda é repetir todo o conjunto de caracteres pelo comprimento da senha desejada, mas garante que os caracteres na senha gerada não precisem ser exclusivos e não tenham um impacto perceptível no desempenho em um único uso.
Programster
Eu concordo. Provavelmente é melhor não escolher um algoritmo em seu número de linhas. A propósito, se o objetivo principal é apenas gerar uma senha temporária ao criar um novo usuário em um site, isso atenderia às necessidades, eu acho.
Charles-Édouard Coste
40

Se você estiver no PHP7, poderá usar a random_int()função:

function generate_password($length = 20){
  $chars =  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.
            '0123456789`-=~!@#$%^&*()_+,./<>?;:[]{}\|';

  $str = '';
  $max = strlen($chars) - 1;

  for ($i=0; $i < $length; $i++)
    $str .= $chars[random_int(0, $max)];

  return $str;
}

Antiga resposta abaixo:

function generate_password($length = 20){
  $chars =  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.
            '0123456789`-=~!@#$%^&*()_+,./<>?;:[]{}\|';

  $str = '';
  $max = strlen($chars) - 1;

  for ($i=0; $i < $length; $i++)
    $str .= $chars[mt_rand(0, $max)];

  return $str;
}
PeeHaa
fonte
12
não use mt_randpara gerar uma senha.
CodesInChaos
2
@CodesInChaos é melhor que rand (), que é o que o exemplo acima usa. O openssl_random_pseudo_bytes () é preferido de acordo com o manual do PHP.
willbradley
4
@willbradley A qualidade da semente também é ruim mt_rand, portanto ainda é inadequada para qualquer uso de segurança.
CodesInChaos
2
você vê que é isso que me irrita + ChaosInCodes. Você não examinou a questão, apenas fez algumas afirmações genéricas repetindo uma carga de crenças mal mantidas. Em resumo: conselho certo para uma pergunta totalmente diferente. Senhas aleatórias são boas. Eles provavelmente são apenas "x" usados. Honestamente, se você está projetando seu sistema sem bloqueios cronometrados e detecção do DOS e "x tenta então -> bloqueado", está fazendo algo errado. É IMPOSSÍVEL adivinhar uma senha mt_rand com essas medidas em vigor. Por outro lado, o uso do mt_rand não tornará mais fácil a força bruta de uma senha. Simplesmente não vai.
Heelis 9/08/16
1
Eu não usaria \ in$chars
CONvid19
36

Em uma linha:

substr(str_shuffle('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') , 0 , 10 )
Sandra
fonte
11
Isso evita a reutilização das mesmas letras, pois elas são aleatórias, mas não ocorrem mais de uma vez.
Nickdnk
8
Escusado será dizer que ninguém deve otimizar sua função de geração de senha com base na contagem de linhas. Mesmo que o RNG usado seja seguro (não é), evitar caracteres repetidos ao gerar uma senha de 10 caracteres reduz de ~ 52 bits de entropia para ~ 50 bits de entropia (~ 4x mais rápido para quebrar). Se você estender para 20 caracteres, a não repetição reduzirá de ~ 103 bits para ~ 94 bits (~ 512x mais rápido para quebrar).
11302 Jeremy Banks
1
Este método me lembra a falha no código Enigma Lol
hatef
4
substr(str_shuffle(str_repeat($chars,$length)),0,$length); Entropia restaurada
Charles-Édouard Coste
27

Sua melhor aposta é a biblioteca RandomLib da ircmaxell .

Exemplo de uso:

$factory = new RandomLib\Factory;
$generator = $factory->getGenerator(new SecurityLib\Strength(SecurityLib\Strength::MEDIUM));

$passwordLength = 8; // Or more
$randomPassword = $generator->generateString($passwordLength);

Produz seqüências que são mais fortemente aleatórias do que as funções normais de aleatoriedade, como ( shuffle()e rand()é o que você geralmente deseja para informações confidenciais, como senhas, sais e chaves).

Fantasma de Madara
fonte
4
Essa é a resposta correta. Não use rand()ou mt_rand().
23926 Scott Arciszewski
1
Pode ser a resposta mais segura (não sei como ela se compara random_bytes), mas isso não torna as randrespostas incorretas.
Cerbrus 06/07/2015
8
@ Cerbrus: Certifique-se de que esta resposta não responda rand()incorretamente. Eles estão incorretos por conta própria!
Deduplicator
14

Você quer strlen($alphabet), não counta constante alphabet(equivalente a'alphabet' ).

No entanto, randnão é uma função aleatória adequada para esse fim. Sua saída pode ser facilmente prevista, pois é implícita semeada com o tempo atual. Além disso, randnão é criptograficamente seguro; portanto, é relativamente fácil determinar seu estado interno a partir da saída.

Em vez disso, leia de /dev/urandompara obter dados criptograficamente aleatórios.

phihag
fonte
14

Vou postar uma resposta porque algumas das respostas existentes são próximas, mas têm uma das seguintes:

  • um espaço de caracteres menor do que o desejado, para que a força bruta seja mais fácil ou a senha precise ser maior para a mesma entropia
  • um RNG que não é considerado criptograficamente seguro
  • um requisito para uma biblioteca de terceiros e achei interessante mostrar o que é necessário para fazer você mesmo

Esta resposta contornará o count/strlenproblema, pois a segurança da senha gerada, pelo menos IMHO, transcende como você está chegando lá. Também vou assumir o PHP> 5.3.0.

Vamos dividir o problema nas partes constituintes que são:

  1. use alguma fonte segura de aleatoriedade para obter dados aleatórios
  2. use esses dados e os represente como uma sequência imprimível

Para a primeira parte, o PHP> 5.3.0 fornece a função openssl_random_pseudo_bytes. Observe que, embora a maioria dos sistemas use um algoritmo criptograficamente forte, você deve verificar se usaremos um wrapper:

/**
 * @param int $length
 */
function strong_random_bytes($length)
{
    $strong = false; // Flag for whether a strong algorithm was used
    $bytes = openssl_random_pseudo_bytes($length, $strong);

    if ( ! $strong)
    {
        // System did not use a cryptographically strong algorithm 
        throw new Exception('Strong algorithm not available for PRNG.');
    }        

    return $bytes;
}

Para a segunda parte, usaremos base64_encodeuma vez que é necessária uma sequência de bytes e produzirá uma série de caracteres que possuem um alfabeto muito próximo ao especificado na pergunta original. Se não nos importássemos em ter +, /e os =caracteres aparecerem na sequência final e quisermos um resultado com pelo menos $ncaracteres, poderíamos simplesmente usar:

base64_encode(strong_random_bytes(intval(ceil($n * 3 / 4))));

O 3/4fator se deve ao fato de a codificação base64 resultar em uma sequência que possui um comprimento pelo menos um terço maior que a sequência de bytes. $nCaso contrário, o resultado será exato por ter múltiplos de 4 e até 3 caracteres. Como os caracteres extras são predominantemente o caractere de preenchimento =, se, por algum motivo, tivermos uma restrição de que a senha tenha um tamanho exato, poderemos truncá-la para o tamanho desejado. Isso ocorre principalmente porque, para um determinado dado $n, todas as senhas terminariam com o mesmo número delas, de modo que um invasor que tivesse acesso a uma senha de resultado teria até 2 caracteres a menos para adivinhar.


Para crédito extra, se quiséssemos atender às especificações exatas, como na pergunta do OP, teríamos que trabalhar um pouco mais. Vou renunciar à abordagem de conversão de base aqui e seguir uma rápida e suja. Ambos precisam gerar mais aleatoriedade do que será usado no resultado de qualquer maneira, devido ao alfabeto de 62 entradas.

Para os caracteres extras no resultado, podemos simplesmente descartá-los da sequência resultante. Se começarmos com 8 bytes em nossa cadeia de bytes, até cerca de 25% dos caracteres base64 seriam esses caracteres "indesejáveis", de modo que simplesmente descartar esses caracteres resultará em uma cadeia não menor que o OP desejado. Em seguida, podemos simplesmente truncá-lo para obter o tamanho exato:

$dirty_pass = base64_encode(strong_random_bytes(8)));
$pass = substr(str_replace(['/', '+', '='], ['', '', ''], $dirty_pass, 0, 8);

Se você gerar senhas mais longas, o caractere de preenchimento =formará uma proporção cada vez menor do resultado intermediário, para que você possa implementar uma abordagem mais enxuta, se for necessário drenar o pool de entropia usado para o PRNG.

jeteon
fonte
1
Obrigado por esta adição. Nenhuma das respostas existentes observou que openssl_random_pseudo_bytespoderia produzir um resultado fraco. Não sabia que era esse o caso.
11555 Jeremy Banks
12

base_convert(uniqid('pass', true), 10, 36);

por exemplo. e0m6ngefmj4

EDITAR

Como mencionei nos comentários, o tamanho significa que os ataques de força bruta funcionariam melhor contra eles do que os ataques de tempo, portanto, não é realmente relevante se preocupar com "quão seguro o gerador aleatório era". A segurança, especificamente para este caso de uso, precisa complementar a usabilidade, para que a solução acima seja realmente boa o suficiente para o problema necessário.

No entanto, no caso de você ter encontrado essa resposta enquanto procurava por um gerador de seqüências aleatórias seguras (como suponho que algumas pessoas tenham baseado nas respostas), por algo como gerar tokens, veja como um gerador desses códigos se pareceria:

function base64urlEncode($data) {
    return rtrim(strtr(base64_encode($data), '+/', '-_'), '=');
}

function secureId($length = 32) {

    if (function_exists('openssl_random_pseudo_bytes')) {
        $bytes = openssl_random_pseudo_bytes($length);
        return rtrim(strtr(base64_encode($bytes), '+/', '0a'), '=');
    }
    else { // fallback to system bytes

        error_log("Missing support for openssl_random_pseudo_bytes");

        $pr_bits = '';

        $fp = @fopen('/dev/urandom', 'rb');
        if ($fp !== false) {
            $pr_bits .= @fread($fp, $length);
            @fclose($fp);
        }

        if (strlen($pr_bits) < $length) {
            error_log('unable to read /dev/urandom');
            throw new \Exception('unable to read /dev/urandom');
        }

        return base64urlEncode($pr_bits);
    }
}
srcspider
fonte
1
PS - isto é PHP - apenas usando \ para indicar o espaço para nome global.
Bob Gregor
Exceto que o uniqid não é criptograficamente seguro. Use rand (): base_convert (rand (78364164096, 2821109907455), 10, 36);
Benubird
7
O @Benubird rand () também não é criptograficamente seguro, de acordo com o manual do PHP. O manual sugere openssl_random_pseudo_bytes ().
willbradley
Para a maioria dos casos de uso, especificamente nos casos em que o invasor não tem acesso à hora exata, isso é perfeitamente aceitável e produz uma senha "temporária" amigável, mais ou menos amigável ao ser humano. Se levarmos isso ao extremo, o comprimento aqui é muito mais problemático, então qual função foi usada para gerar o número aleatório.
Srcpider
Adicionei um exemplo para gerar seqüências de caracteres totalmente seguras, para os interessados; mas não é recomendável usá-lo ao gerar senhas temporárias para os usuários. Mesmo usando a versão segura, o problema de comprimento ainda se aplica.
Srcpider
9

Outro (somente linux)

function randompassword()
{
    $fp = fopen ("/dev/urandom", 'r');
    if (!$fp) { die ("Can't access /dev/urandom to get random data. Aborting."); }
    $random = fread ($fp, 1024); # 1024 bytes should be enough
    fclose ($fp);
    return trim (base64_encode ( md5 ($random, true)), "=");
}
Askarel
fonte
1
Ler 1024 bytes para compactar em um hash criptográfico de 128 bits da entropia é um pouco inútil. Além disso, fread()armazena em buffer para 8192 bytes por padrão, para que você sempre leia muitos deles /dev/urandomcom o código fornecido. Isso também não funcionará no Windows. Kudos por usar um CSPRNG, no entanto.
Scott Arciszewski
9

Sendo um pouco mais inteligente:

function strand($length){
  if($length > 0)
    return chr(rand(33, 126)) . strand($length - 1);
}

confira aqui .

Amir Fo
fonte
7

Use este código simples para gerar uma senha de senha forte e mediana 12

$password_string = '!@#$%*&abcdefghijklmnpqrstuwxyzABCDEFGHJKLMNPQRSTUWXYZ23456789';
$password = substr(str_shuffle($password_string), 0, 12);
Pablo Martinez
fonte
Isso está realmente (muito?) Errado. Na verdade, ele usa todos os caracteres do alfabeto apenas uma vez, diminuindo bastante o espaço de todos os valores possíveis (relevantes para o cracking).
Radoslav Bodo
6

Experimente com letras maiúsculas, minúsculas, caracteres numéricos e especiais

function generatePassword($_len) {

    $_alphaSmall = 'abcdefghijklmnopqrstuvwxyz';            // small letters
    $_alphaCaps  = strtoupper($_alphaSmall);                // CAPITAL LETTERS
    $_numerics   = '1234567890';                            // numerics
    $_specialChars = '`~!@#$%^&*()-_=+]}[{;:,<.>/?\'"\|';   // Special Characters

    $_container = $_alphaSmall.$_alphaCaps.$_numerics.$_specialChars;   // Contains all characters
    $password = '';         // will contain the desired pass

    for($i = 0; $i < $_len; $i++) {                                 // Loop till the length mentioned
        $_rand = rand(0, strlen($_container) - 1);                  // Get Randomized Length
        $password .= substr($_container, $_rand, 1);                // returns part of the string [ high tensile strength ;) ] 
    }

    return $password;       // Returns the generated Pass
}

Digamos que precisamos de 10 dígitos

echo generatePassword(10);  

Exemplo (s) de saída:

, IZCQ_IV \ 7

@wlqsfhT (d

1! 8 + 1 \ 4 @ uD

Sanjeev
fonte
a randfunção não é realmente criptograficamente segura por isso pode ser um grande risco para gerar uma senha de usá-lo
jeteon
3

Rápido. Formato simples, limpo e consistente, se é isso que você deseja

$pw = chr(mt_rand(97,122)).mt_rand(0,9).chr(mt_rand(97,122)).mt_rand(10,99).chr(mt_rand(97,122)).mt_rand(100,999);
Cornelius Parkin
fonte
3

Isso se baseia em outra resposta nesta página, https://stackoverflow.com/a/21498316/525649

Esta resposta gera apenas caracteres hexadecimais 0-9,a-f,. Para algo que não se parece com hexadecimal, tente o seguinte:

str_shuffle(
  rtrim(
    base64_encode(bin2hex(openssl_random_pseudo_bytes(5))),
    '='
  ). 
  strtoupper(bin2hex(openssl_random_pseudo_bytes(7))).
  bin2hex(openssl_random_pseudo_bytes(13))
)
  • base64_encode retorna uma propagação mais ampla de caracteres alfanuméricos
  • rtrimremove as =vezes no final

Exemplos:

  • 32eFVfGDg891Be5e7293e54z1D23110M3ZU3FMjb30Z9a740Ej0jz4
  • b280R72b48eOm77a25YCj093DE5d9549Gc73Jg8TdD9Z0Nj4b98760
  • 051b33654C0Eg201cfW0e6NA4b9614ze8D2FN49E12Y0zY557aUCb8
  • y67Q86ffd83G0z00M0Z152f7O2ADcY313gD7a774fc5FF069zdb5b7

Isso não é muito configurável para criar uma interface para os usuários, mas, para alguns propósitos, tudo bem. Aumente o número de caracteres para explicar a falta de caracteres especiais.

Adão
fonte
3
  1. Crie um arquivo com este código.
  2. Chame como nos comentários.

    <?php 
    
    /**
    * @usage  :
    *       include_once($path . '/Password.php');
    *       $Password = new Password;
    *       $pwd = $Password->createPassword(10);
    *       return $pwd;
    * 
    */
    
    class Password {
    
        public function createPassword($length = 15) {
            $response = [];
            $response['pwd'] = $this->generate($length);
            $response['hashPwd'] = $this->hashPwd( $response['pwd'] );
            return $response;
        }
    
        private function generate($length = 15) {
            $chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*(){}/?,><";
            return substr(str_shuffle($chars),0,$length);
        }
    
        private function hashPwd($pwd) {
            return hash('sha256', $pwd);
        }
    
    }
    
    ?>
waz
fonte
2

Criei um script de senha mais abrangente e seguro. Isso criará uma combinação de dois caracteres maiúsculos, dois minúsculos, dois números e dois caracteres especiais. Total de 8 caracteres.

$char = [range('A','Z'),range('a','z'),range(0,9),['*','%','$','#','@','!','+','?','.']];
$pw = '';
for($a = 0; $a < count($char); $a++)
{
    $randomkeys = array_rand($char[$a], 2);
    $pw .= $char[$a][$randomkeys[0]].$char[$a][$randomkeys[1]];
}
$userPassword = str_shuffle($pw);
monrejames
fonte
1
//define a function. It is only 3 lines!   
function generateRandomPassword($length = 5){
    $chars = "0123456789bcdfghjkmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ";
    return substr(str_shuffle($chars),0,$length);
}

//usage
echo generateRandomPassword(5); //random password legth: 5
echo generateRandomPassword(6); //random password legth: 6
echo generateRandomPassword(7); //random password legth: 7
hakiko
fonte
Isso está realmente (muito?) Errado. Na verdade, ele usa todos os caracteres do alfabeto apenas uma vez, diminuindo bastante o espaço de todos os valores possíveis (relevantes para o cracking).
Radoslav Bodo
0

Gera uma senha forte de comprimento 8 que contém pelo menos uma letra minúscula, uma letra maiúscula, um dígito e um caractere especial. Você também pode alterar o tamanho do código.

function checkForCharacterCondition($string) {
    return (bool) preg_match('/(?=.*([A-Z]))(?=.*([a-z]))(?=.*([0-9]))(?=.*([~`\!@#\$%\^&\*\(\)_\{\}\[\]]))/', $string);
}

$j = 1;

function generate_pass() {
    global $j;
    $allowedCharacters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`!@#$%^&*()_{}[]';
    $pass = '';
    $length = 8;
    $max = mb_strlen($allowedCharacters, '8bit') - 1;
    for ($i = 0; $i < $length; ++$i) {
        $pass .= $allowedCharacters[random_int(0, $max)];
    }

    if (checkForCharacterCondition($pass)){
        return '<br><strong>Selected password: </strong>'.$pass;
    }else{
        echo 'Iteration '.$j.':  <strong>'.$pass.'</strong>  Rejected<br>';
        $j++;
        return generate_pass();
    }

}

echo generate_pass();
Zihad Ul Islam
fonte
0

Esta função irá gerar uma senha com base nas regras nos parâmetros

function random_password( $length = 8, $characters = true, $numbers = true, $case_sensitive = true, $hash = true ) {

    $password = '';

    if($characters)
    {
        $charLength = $length;
        if($numbers) $charLength-=2;
        if($case_sensitive) $charLength-=2;
        if($hash) $charLength-=2;
        $chars = "abcdefghijklmnopqrstuvwxyz";
        $password.= substr( str_shuffle( $chars ), 0, $charLength );
    }

    if($numbers)
    {
        $numbersLength = $length;
        if($characters) $numbersLength-=2;
        if($case_sensitive) $numbersLength-=2;
        if($hash) $numbersLength-=2;
        $chars = "0123456789";
        $password.= substr( str_shuffle( $chars ), 0, $numbersLength );
    }

    if($case_sensitive)
    {
        $UpperCaseLength = $length;
        if($characters) $UpperCaseLength-=2;
        if($numbers) $UpperCaseLength-=2;
        if($hash) $UpperCaseLength-=2;
        $chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        $password.= substr( str_shuffle( $chars ), 0, $UpperCaseLength );
    }

    if($hash)
    {
        $hashLength = $length;
        if($characters) $hashLength-=2;
        if($numbers) $hashLength-=2;
        if($case_sensitive) $hashLength-=2;
        $chars = "!@#$%^&*()_-=+;:,.?";
        $password.= substr( str_shuffle( $chars ), 0, $hashLength );
    }

    $password = str_shuffle( $password );
    return $password;
}
Behiry
fonte
0

Aqui está minha opinião sobre o auxiliar de geração de senha simples e aleatória.

Ele garante que a senha tenha números, letras maiúsculas e minúsculas, além de no mínimo 3 caracteres especiais.

O comprimento da senha será entre 11 e 30.

function plainPassword(): string
{
    $numbers = array_rand(range(0, 9), rand(3, 9));
    $uppercase = array_rand(array_flip(range('A', 'Z')), rand(2, 8));
    $lowercase = array_rand(array_flip(range('a', 'z')), rand(3, 8));
    $special = array_rand(array_flip(['@', '#', '$', '!', '%', '*', '?', '&']), rand(3, 5));

    $password = array_merge(
        $numbers,
        $uppercase,
        $lowercase,
        $special
    );

    shuffle($password);

    return implode($password);
}
Sebastian Sulinski
fonte