Generando una contraseña aleatoria en php

Estoy tratando de generar una contraseña aleatoria en php.

Sin embargo, obtengo todas las 'a' y el tipo de retorno es de tipo matriz y me gustaría que sea una cadena. ¿Alguna idea sobre cómo corregir el código?

Gracias.

function randomPassword() {
    $alphabet = "abcdefghijklmnopqrstuwxyzABCDEFGHIJKLMNOPQRSTUWXYZ0123456789";
    for ($i = 0; $i < 8; $i++) {
        $n = rand(0, count($alphabet)-1);
        $pass[$i] = $alphabet[$n];
    }
    return $pass;
}

Advertencia de seguridad : rand()no es un generador de números pseudoaleatorios criptográficamente seguro. Busque en otro lugar para generar una cadena pseudoaleatoria criptográficamente segura en PHP .

Pruebe esto (use en strlenlugar de count, porque counten una cadena siempre es 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
}

Demostración: http://codepad.org/UL8k4aYK

TL; DR:

• Utilizar random_int() y lo dadorandom_str() continuación.
• Si no tiene random_int(), use random_compat .

Explicación:

Como está generando una contraseña , debe asegurarse de que la contraseña que genera sea impredecible, y la única forma de garantizar que esta propiedad esté presente en su implementación es usar un generador de números pseudoaleatorios criptográficamente seguro (CSPRNG).

El requisito de un CSPRNG se puede relajar para el caso general de cadenas aleatorias, pero no cuando se trata de seguridad.

La respuesta simple, segura y correcta a la generación de contraseñas en PHP es usar RandomLib y no reinventar la rueda. Esta biblioteca ha sido auditada por expertos en seguridad de la industria, así como por mí mismo.

Para los desarrolladores que prefieren inventar su propia solución, PHP 7.0.0 proporcionará random_int()para este propósito. Si todavía está en PHP 5.x, escribimos un polyfill de PHP 5 pararandom_int() que pueda usar la nueva API antes de que se lance PHP 7. Usar nuestro random_int()polyfill es probablemente más seguro que escribir su propia implementación.

Con un generador de entero aleatorio seguro en la mano, generar una cadena aleatoria segura es más fácil que el pastel:

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

Sé que está intentando generar su contraseña de una manera específica, pero es posible que también desee ver este método ...

$bytes = openssl_random_pseudo_bytes(2);

$pwd = bin2hex($bytes);

Está tomado del sitio php.net y crea una cadena que es dos veces la longitud del número que pones en la función openssl_random_pseudo_bytes. Entonces, lo anterior crearía una contraseña de 4 caracteres de longitud.

En breve...

$pwd = bin2hex(openssl_random_pseudo_bytes(4));

Crearía una contraseña de 8 caracteres de longitud.

Sin embargo, tenga en cuenta que la contraseña solo contiene los números 0-9 y letras minúsculas af!

Código minúsculo con 2 líneas.

demostración: http://codepad.org/5rHMHwnH

function rand_string( $length ) {

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

}

echo rand_string(8);

con rand_string puedes definir cuánto carácter se creará.

Si está en PHP7, podría usar la random_int()función:

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

Antigua respuesta a continuación:

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

En una línea:

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

Su mejor apuesta es la biblioteca RandomLib de ircmaxell .

Ejemplo de uso:

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

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

Produce cadenas que son más fuertemente aleatorias que las funciones normales de aleatoriedad como shuffle()y rand()(que es lo que generalmente desea para información confidencial como contraseñas, sales y claves).

Usted quiere strlen($alphabet), no countde la constante alphabet(equivalente a 'alphabet').

Sin embargo, randno es una función aleatoria adecuada para este propósito. Su salida se puede predecir fácilmente ya que se siembra implícitamente con la hora actual. Además, randno es criptográficamente seguro; Por lo tanto, es relativamente fácil determinar su estado interno a partir de la salida.

En su lugar, lea /dev/urandompara obtener datos criptográficamente aleatorios.

Voy a publicar una respuesta porque algunas de las respuestas existentes están cerca pero tienen una de:

• un espacio de caracteres más pequeño que el deseado para que el forzamiento bruto sea más fácil o la contraseña debe ser más larga para la misma entropía
• un RNG que no se considera criptográficamente seguro
• un requisito para una biblioteca de terceros y pensé que podría ser interesante mostrar lo que se necesita para hacerlo usted mismo

Esta respuesta eludirá el count/strlenproblema ya que la seguridad de la contraseña generada, al menos en mi humilde opinión, trasciende cómo está llegando allí. También voy a asumir PHP> 5.3.0.

Analicemos el problema en las partes constituyentes que son:

1. use alguna fuente segura de aleatoriedad para obtener datos aleatorios
2. usar esos datos y representarlos como una cadena imprimible

Para la primera parte, PHP> 5.3.0 proporciona la función openssl_random_pseudo_bytes. Tenga en cuenta que, si bien la mayoría de los sistemas usan un algoritmo criptográficamente fuerte, debe verificarlo, así que usaremos un contenedor:

/**
 * @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 la segunda parte, usaremos base64_encodeya que toma una cadena de bytes y producirá una serie de caracteres que tienen un alfabeto muy cercano al especificado en la pregunta original. Si no nos importa tener +, /y los =caracteres aparecen en la cadena final y queremos un resultado de al menos $ncaracteres largos, simplemente podríamos usar:

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

El 3/4factor se debe al hecho de que la codificación base64 da como resultado una cadena que tiene una longitud al menos un tercio más grande que la cadena de bytes. El resultado será exacto por $nser un múltiplo de 4 y hasta 3 caracteres más de lo contrario. Dado que los caracteres adicionales son predominantemente el carácter de relleno =, si por alguna razón tuvimos la restricción de que la contraseña tenga una longitud exacta, entonces podemos truncarla a la longitud que queramos. Esto se debe especialmente a que, para un determinado $n, todas las contraseñas terminarían con el mismo número de ellas, de modo que un atacante que tuviera acceso a una contraseña resultante, tendría hasta 2 caracteres menos para adivinar.

Para obtener crédito adicional, si quisiéramos cumplir con las especificaciones exactas como en la pregunta del OP, entonces tendríamos que hacer un poco más de trabajo. Voy a renunciar al enfoque de conversión de base aquí e ir con uno rápido y sucio. Ambos necesitan generar más aleatoriedad de la que se utilizará en el resultado de todos modos debido al alfabeto largo de 62 entradas.

Para los caracteres adicionales en el resultado, simplemente podemos descartarlos de la cadena resultante. Si comenzamos con 8 bytes en nuestra cadena de bytes, entonces hasta aproximadamente el 25% de los caracteres base64 serían estos caracteres "indeseables", de modo que simplemente descartar estos caracteres da como resultado una cadena no más corta que la OP deseada. Entonces podemos simplemente truncarlo para llegar a la longitud exacta:

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

Si genera contraseñas más largas, el carácter de relleno =forma una proporción cada vez menor del resultado intermedio para que pueda implementar un enfoque más ágil, si es preocupante drenar el grupo de entropía utilizado para el PRNG.

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

p.ej. e0m6ngefmj4

EDITAR

Como mencioné en los comentarios, la longitud significa que los ataques de fuerza bruta funcionarían mejor contra él que los ataques de tiempo, por lo que no es realmente relevante preocuparse por "cuán seguro era el generador aleatorio". La seguridad, específicamente para este caso de uso, debe complementar la usabilidad para que la solución anterior sea realmente lo suficientemente buena para el problema requerido.

Sin embargo, en caso de que haya encontrado esta respuesta mientras buscaba un generador de cadenas aleatorias seguro (como supongo que algunas personas se han basado en las respuestas), para algo como generar tokens, así es como se vería un generador de dichos códigos:

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

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

Ser un poco más inteligente:

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

compruébalo aquí .

Use este código simple para generar una contraseña med-strong de longitud 12

$password_string = '!@#$%*&abcdefghijklmnpqrstuwxyzABCDEFGHJKLMNPQRSTUWXYZ23456789';
$password = substr(str_shuffle($password_string), 0, 12);

Pruebe esto con letras mayúsculas, minúsculas, numéricos y caracteres especiales

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 necesitamos un pase de 10 dígitos

echo generatePassword(10);  

Ejemplo de salida (s):

, IZCQ_IV \ 7

@wlqsfhT (d

1! 8 + 1 \ 4 @ uD

Uno rápido Formato simple, limpio y consistente si eso es lo que quieres

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

Esto se basa en otra respuesta en esta página, https://stackoverflow.com/a/21498316/525649

Esta respuesta genera caracteres hexadecimales solo, 0-9,a-f. Para algo que no parece hexadecimal, intente esto:

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 devuelve una extensión más amplia de caracteres alfanuméricos
• rtrimelimina el a =veces al final

Ejemplos:

• 32eFVfGDg891Be5e7293e54z1D23110M3ZU3FMjb30Z9a740Ej0jz4
• b280R72b48eOm77a25YCj093DE5d9549Gc73Jg8TdD9Z0Nj4b98760
• 051b33654C0Eg201cfW0e6NA4b9614ze8D2FN49E12Y0zY557aUCb8
• y67Q86ffd83G0z00M0Z152f7O2ADcY313gD7a774fc5FF069zdb5b7

Esto no es muy configurable para crear una interfaz para los usuarios, pero para algunos propósitos está bien. Aumente la cantidad de caracteres para explicar la falta de caracteres especiales.

1. Crea un archivo con este código.

2. Llámalo como en los comentarios.

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

Creé un script de contraseña más completo y seguro. Esto creará una combinación de dos mayúsculas, dos minúsculas, dos números y dos caracteres especiales. 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

Genera una contraseña segura de longitud 8 que contiene al menos una letra minúscula, una letra mayúscula, un dígito y un carácter especial. También puede cambiar la longitud en el 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 función generará una contraseña basada en las reglas de los 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;
}

Aquí está mi asistente de generación de contraseña simple al azar.

Asegura que la contraseña tenga números, letras mayúsculas y minúsculas, así como un mínimo de 3 caracteres especiales.

La longitud de la contraseña será entre 11 y 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);
}