Gerando uma senha aleatória em php

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

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

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

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!

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.

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

Em uma linha:

substr(str_shuffle('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') , 0 , 10 )

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

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.

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.

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

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)), "=");
}

Sendo um pouco mais inteligente:

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

confira aqui .

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

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

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

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.

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

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

//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

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

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

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