Generar una contraseña aleatoria en php

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

$bytes = openssl_random_pseudo_bytes(2);

$pwd = bin2hex($bytes);

Está tomado de la php.net y crea una cadena que es el doble de la longitud del número que puso en la función openssl_random_pseudo_bytes. Por lo tanto, lo anterior crearía una contraseña de 4 caracteres de largo.

En resumen...

$pwd = bin2hex(openssl_random_pseudo_bytes(4));

Crearía una contraseña de 8 caracteres.

Tenga en cuenta, sin embargo, que la contraseña solo contiene números 0-9 y letras minúsculas a-f!

TL; DR:

• Use RandomLib.
• Si no puedes usar RandomLib, usa random_int() y el random_str() dado.
• Si no tienes random_int(), usa random_compat.

Explicación:

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

El requisito para un CSPRNG puede ser relajado para el caso general de cadenas aleatorias, pero no cuando la seguridad está involucrada.

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ás en PHP 5.x, escribimos un PHP 5 polyfill para random_int() así que puede usar la nueva API antes de que PHP 7 sea lanzado. Usar nuestro random_int()polyfill es probablemente más seguro que escribir su propia implementación.

Con un generador de enteros aleatorios seguro a mano, generar una cadena aleatoria segura es más fácil 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;
}

Código pequeño con 2 línea.

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

function rand_string( $length ) {

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

}

echo rand_string(8);

Con rand_string puede definir cuánto carácter se creará.

En una línea:

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

Si estás en PHP7 podrías usar el 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;
}

Su mejor apuesta es la Biblioteca RandomLib por 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 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).

Desea strlen($alphabet), no count de la constante alphabet (equivalente a 'alphabet').

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

En su lugar, lea desde /dev/urandom para 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 del que querías 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 algunos 3rd biblioteca de partido y pensé que podría ser interesante para mostrar lo que podría tomar para hacerlo usted mismo

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

Dividamos el problema en las partes constituyentes que son:{[16]]}

1. utilice alguna fuente segura de aleatoriedad para obtener datos aleatorios
2. utilice 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 mientras la mayoría de los sistemas utilizan un algoritmo criptográficamente fuerte, usted tiene que comprobar por lo que vamos a utilizar un 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 la segunda parte, usaremos base64_encode ya 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 importara tener +, / y = los caracteres aparecen en la cadena final y queremos un resultado de al menos $n caracteres largos, simplemente podríamos usar:

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

El 3/4 factor se debe al hecho de que la codificación base64 resulta en una cadena que tiene una longitud al menos un tercio mayor que la cadena de bytes. El resultado será exacto para $n siendo un múltiplo de 4 y hasta 3 caracteres más largos de lo contrario. Dado que los caracteres adicionales son predominantemente el carácter de relleno =, si por alguna razón teníamos una restricción de que la contraseña tuviera una longitud exacta, entonces podemos truncarla a la longitud que queramos. Esto es especialmente porque para un $n dado, todas las contraseñas terminaría con el mismo número de estos, por lo que un atacante que tenía acceso a una contraseña de resultado, tendría hasta 2 caracteres menos para adivinar.

Para obtener crédito adicional, si queríamos cumplir con la especificación exacta como en la pregunta de la 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 a la entrada de 62 largo alfabeto.

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 resulta en una cadena no más corta que la que OP quería. Entonces podemos simplemente truncarlo para bajar 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 más pequeña del resultado intermedio para que pueda implementar un enfoque más delgado, si el drenaje de la piscina de entropía utilizada para el PRNG es una preocupación.

Esto es básicamente lo mismo que el mucho más simple substr(md5(uniqid()), 0, 8);

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

Eg. e0m6ngefmj4

EDITAR

Como he mencionado 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 "qué tan seguro era el generador aleatorio."La seguridad, específicamente para este caso de uso, debe complementar la usabilidad, por lo que la solución anterior es realmente lo suficientemente buena para el problema requerido.

Sin embargo, en caso de que te topes con esta respuesta mientras buscas para un generador de cadenas aleatorias seguro (como supongo que algunas personas 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)), "=");
}

Prueba Esto con Mayúsculas, Minúsculas, Números 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 Pasar 10 dígitos

echo generatePassword(10);  

Ejemplo de Salida(s) :

, IZCQ_IV \ 7

@wlqsfhT (d

1!8 + 1\4 @ uD

Utilice este código simple para generar med-contraseña fuerte 12 longitud

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

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 solo caracteres hexadecimales, 0-9,a-f. Para algo que no parece hexadecimal, prueba 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
• rtrim elimina 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. Aumenta el número de caracteres para tener en cuenta la falta de caracteres especiales.

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

Siendo un poco más inteligente:

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

Compruébalo aquí.

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

<?php
    // We can generate without large code..
    $length = 8;
    $chars = array_merge(range(0,9), range('a','z'),range('A','Z'),['!','@','#','$','%','&','*','?']);
    //$chars = array_merge(range(0,1), range('A','Z'));
    shuffle($chars);
    $code = implode(array_slice($chars, 0, $length));
    $arr = array($code);
    $password = implode("",$arr);
    echo $password;

Si desea 8 caracteres con 1 mayúscula y 1 número.

  $p_lc_letters = substr(str_shuffle('abcdefghijklmnopqrstuvwxyz'), 0, 6); // Generate 6 lowercase letters
  $p_uc_letters = substr(str_shuffle('ABCDEFGHIJKLMNOPQRSTUVWXYZ'), 0, 1); // Generate 1 uppercase letter
  $p_numbers = substr(str_shuffle('0123456789'), 0, 1); // Generate 1 number

  echo $password = substr(str_shuffle($p_lc_letters.''.$p_uc_letters.''.$p_numbers), 0, 8);

He querido intentar implementar mi propio generador de contraseñas "seguro" y "aleatorio".

Pensé que sería interesante y más flexible proporcionar un parámetro length y type a la función.

Aquí hay una función que realiza algunas comprobaciones para asegurarse de que el length no es demasiado corto o largo (también permite longitud variable). También permite la posibilidad de elegir su conjunto de caracteres de contraseña en el parámetro type.

Devuelve null si los length o type son inválido y usa la función mt_rand() de PHP que es más "aleatoria" que rand().

<?php

/**
* Generates a random password with the given length and of the given type.
*
* @param int $length
* @param string $type 
* @return string | null
*/
function random_password($length=8, $type='alpha_numeric') {

    if ($length < 1 || $length > 1024) return null;

    $lower = 'abcdefghijklmnopqrstuvwxy';
    $upper = strtoupper($lower);
    $numbers = '1234567890';
    $dash = '-';
    $underscore = '_';
    $symbols = '`~!@#$%^&*()+=[]\\{}|:";\'<>?,./';

    switch ($type) {
        case 'lower':
            $chars = $lower;
            break;
        case 'upper':
            $chars = $upper;
            break;
        case 'numeric':
            $chars = $numbers;
            break;
        case 'alpha':
            $chars = $lower . $upper;
            break;
        case 'symbol':
            $chars = $symbols . $dash . $underscore;
            break;
        case 'alpha_numeric':
            $chars = $lower . $upper . $numbers;
            break;
        case 'alpha_numeric_dash':
            $chars = $lower . $upper . $numbers . $dash;
            break;
        case 'alpha_numeric_underscore':
            $chars = $lower . $upper . $numbers . $underscore;
            break;
        case 'alpha_numeric_dash_underscore':
            $chars = $lower . $upper . $numbers . $underscore . $dash;
            break;
        case 'all':
            $chars = $lower . $upper . $numbers . $underscore . $dash . $symbols;
            break;
        default:
            return null;
    }

    $min = 0;
    $max = strlen($chars) - 1;

    $password = '';

    for ($i = 0; $i < $length; $i++) {
        $random = mt_rand($min, $max);
        $char = substr($chars, $random, 1);
        $password .= $char;
    }

    return $password;
}