Generando una contraseña aleatoria en php

190

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;
}
nunos
fuente
9
Ninguna de las respuestas utiliza un generador de números aleatorios seguro , que desea para una contraseña.
Scott Arciszewski
44
Los visitantes deberían obtener información potencialmente relacionada con la seguridad de una fuente que pueda actualizarse correctamente, no una pregunta que esté cerrada a nuevas respuestas. Estoy borrando las respuestas a este duplicado para que los visitantes puedan leer las respuestas a la pregunta abierta. (Si alguna vez se vuelve a abrir esta pregunta, las respuestas no se recuperarán).
Jeremy Banks
66
@JeremyBanks En ninguna parte la pregunta indica que se requiere una contraseña segura criptográficamente . Para algunas personas, las respuestas que utilizan /dev/randomson suficientes ya que la pregunta no solicita una contraseña " segura " (y no debe editarse para contenerla, ya que alteraría el significado de la pregunta original). Aunque estoy totalmente a favor de la seguridad, creo que esta bomba de alfombra no se pensó por completo. Al igual que el uso mysql_*, las respuestas siguen siendo válidas, pero deben marcarse como inseguras. ¿Quizás esto es algo que SO necesita incluir como software adicional: la capacidad de advertir sobre código inseguro?
Jimbo
66
@JeremyBanks ¿Puede restablecer las respuestas a esta pregunta? El hecho de que sea un duplicado no significa que las respuestas sean incorrectas (voté accidentalmente para volver a abrir, estoy de acuerdo en que es un duplicado). No tiene sentido eliminar las respuestas, considere la posibilidad de eliminar esta pregunta y migrar las respuestas a la otra pregunta (ya lo he visto antes).
Naftali aka Neal
77
@JeremyBanks si desea que no se vuelva a abrir algo, bloquéelo. De lo contrario, el 99% de las personas lo volverán a abrir y crearán un desastre completo. Personalmente, estoy totalmente en desacuerdo con eliminar respuestas altamente calificadas así, pero no puedo pelear contigo por esto
Shadow Wizard is Ear For You el

Respuestas:

258

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

Neal
fuente
24
Parece más sencillo de usar $pass .= $alphabet[$n].
Mateo
33
Generar contraseña usando rand es una muy mala idea. No es un PRNG seguro. (y no mt_randtampoco es mejor)
CodesInChaos
19
La pregunta es sobre la generación de una contraseña . El código para generar una contraseña claramente necesita usar números aleatorios seguros.
CodesInChaos
10
Por la misma razón que esta no es una pregunta duplicada, esta respuesta es incorrecta, ya que la pregunta es sobre la generación de una contraseña y no una cadena aleatoria . Esta respuesta proporciona un enfoque terriblemente inseguro para generar una contraseña. Utilice la respuesta de @ user3260409 a continuación, donde openssl_random_pseudo_bytes()se usa en lugar derand()
Sorry-Im-a-N00b
35
He visto su código inseguro en producción y quiero detenerlo en la fuente. Usted NECESITA aleatoriedad criptográficamente seguro para las contraseñas.
Scott Arciszewski el
122

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;
}
Scott Arciszewski
fuente
2
RandomLib no se ha actualizado durante más de dos años. Usarlo en una compilación PHP reciente (7.1.25 en mi caso) arroja advertencias de desaprobación para varias mcrypt_*funciones. Puedo ver en un hilo de problemas que ha bifurcado la biblioteca porque no pudo obtener @ircmaxell, pero su bifurcación dice 'falla de compilación' en Travis. ¿Te gustaría actualizar esta respuesta (que todavía se muestra bastante alta en Google)?
Janus Bahs Jacquet
1
¡Buena atrapada! Necesita ser removido.
Scott Arciszewski
113

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!

usuario3260409
fuente
13
Si desea una contraseña mayúscula, minúscula y números, intente esto: gist.github.com/zyphlar/7217f566fc83a9633959
willbradley
@ زياد ¿Quién dice? Si el generador usara bytes de 7 bits, estaría de acuerdo con usted, pero openssl_random_pseudo_bytes()es un poderoso generador de aleatoriedad de bytes binarios completos y no necesita más barajado. También aprovecharé la oportunidad para señalar que es peligroso suponer que apilar múltiples métodos de cifrado hará que todo sea más aleatorio, en algunos casos, de hecho, puede ser exactamente lo contrario debido a la acumulación de colisiones de hash.
Havenard el
56

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

BSQ
fuente
21
Agradable, aunque no obtendrá caracteres repetidos utilizando este enfoque, lo que podría ser indeseable.
Hobo
11
Esta función es terrible para generar contraseñas largas. Primero, si $ length es más largo que la cadena $ chars, entonces no recibirá una cadena tan larga como la longitud que ingresó, sino la longitud de la cadena chars. Además, tiene garantizado solo 1 de cada personaje sin duplicados. Tampoco garantiza el uso de una letra mayúscula o un número que a menudo es un requisito (excepto, por supuesto, si su longitud es superior a 26 debido a la falla anterior)
Programador
¿Qué pasa con este @Programster y @Hobo? substr(str_shuffle(str_repeat($chars,$length)),0,$length);
Charles-Édouard Coste
@ Charles-EdouardCoste parece funcionar lo suficientemente bien (especialmente si agrega algunos caracteres especiales). Aunque todavía no garantiza al menos uno de cada tipo de carácter. Lo único que me molesta es repetir todo el conjunto de caracteres por la longitud de la contraseña deseada, pero eso garantiza que los caracteres en la contraseña generada no tengan que ser únicos y no tengan un impacto notable en el rendimiento en un solo uso.
Programador
Estoy de acuerdo. Probablemente sea mejor no elegir un algoritmo en su número de líneas. Por cierto, si el objetivo principal es solo generar una contraseña temporal al crear un nuevo usuario en un sitio web, supongo que esto satisfaría las necesidades.
Charles-Édouard Coste
40

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;
}
PeeHaa
fuente
12
No lo use mt_randpara generar una contraseña.
CodesInChaos
2
@CodesInChaos es mejor que rand (), que es lo que usa el ejemplo anterior. openssl_random_pseudo_bytes () se prefiere de acuerdo con el manual de PHP.
willbradley
44
@willbradley La calidad de la semilla es igual de mala mt_rand, por lo que sigue siendo inadecuada para cualquier uso de seguridad.
CodesInChaos
2
ves esto es lo que me molesta + ChaosInCodes. No ha mirado la pregunta, acaba de hacer algunas declaraciones genéricas que repiten una carga de creencias mal sostenidas. En resumen: consejo correcto para una pregunta totalmente diferente. Las contraseñas aleatorias están bien. Probablemente solo sean "x". Honestamente, si está diseñando su sistema sin bloqueos temporizados y detección de DOS y "x intenta entonces -> bloqueado", entonces lo está haciendo mal. ES IMPOSIBLE adivinar una contraseña mt_rand con tales medidas implementadas. Por el contrario, usar mt_rand no hará que sea MÁS FÁCIL forzar la fuerza bruta de una contraseña. Simplemente no lo hará.
Sr. Heelis el
1
No usaría \ en$chars
CONvid19
36

En una línea:

substr(str_shuffle('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') , 0 , 10 )
Sandra
fuente
11
Esto evita la reutilización de las mismas letras, ya que simplemente se mezclan pero no ocurren más de una vez.
nickdnk
8
No hace falta decir que nadie debería optimizar su función de generación de contraseñas en función del recuento de líneas. Incluso si el RNG que usaba era seguro (no lo es), evitar caracteres repetidos al generar una contraseña de 10 caracteres lo lleva de ~ 52 bits de entropía a ~ 50 bits de entropía (~ 4 veces más rápido de descifrar). Si extendió esto a 20 caracteres, la no repetición lo reduciría de ~ 103 bits a ~ 94 bits (~ 512x más rápido de descifrar).
Jeremy Banks
1
Este método me recuerda la falla en el código Enigma Lol
hatef
44
substr(str_shuffle(str_repeat($chars,$length)),0,$length); Entropía restaurada
Charles-Édouard Coste
27

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

El fantasma de Madara
fuente
44
Esta es la respuesta correcta. No uses rand()o mt_rand().
Scott Arciszewski
1
Puede ser la respuesta más segura (no estoy seguro de cómo se compara random_bytes), pero eso no hace que las randrespuestas sean incorrectas.
Cerbrus
8
@Cerbrus: Claro que esta respuesta no hace que las respuestas sean rand()incorrectas. ¡Son incorrectos por sí solos!
Deduplicador
14

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.

phihag
fuente
14

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.

jeteon
fuente
1
Gracias por esta adición. Ninguna de las respuestas existentes señaló que openssl_random_pseudo_bytespodría producir un resultado débil. No me di cuenta de que ese era el caso.
Jeremy Banks
12

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);
    }
}
srcspider
fuente
1
PD: esto es PHP, solo usa \ para denotar el espacio de nombres global.
Bob Gregor
Excepto que uniqid no es criptográficamente seguro. Utilice rand () en su lugar: base_convert (rand (78364164096, 2821109907455), 10, 36);
Benubird
77
@Benubird rand () tampoco es criptográficamente seguro, según el manual de PHP. El manual sugiere openssl_random_pseudo_bytes () en su lugar.
willbradley
Para la mayoría de los casos de uso, específicamente donde el atacante no tiene acceso al tiempo exacto, esto está perfectamente bien y produce una buena contraseña "temporal" más o menos amigable para los humanos. Si lleváramos esto al extremo, la longitud aquí es mucho más problemática que la función utilizada para generar el número aleatorio.
srcspider
He agregado un ejemplo para generar cadenas completamente seguras, para aquellos interesados; pero no recomiendo usar esto al generar contraseñas temporales para los usuarios. Incluso usando la versión segura, el problema de longitud aún se aplica.
srcspider
9

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)), "=");
}
Askarel
fuente
1
Leer 1024 bytes para comprimir en un hash criptográfico de 128 bits de la entropía es un poco inútil. Además, fread()almacena de forma predeterminada 8192 bytes, por lo que siempre leerá tantos /dev/urandomcon el código dado. Esto tampoco funcionará en Windows. Sin embargo, felicitaciones por usar un CSPRNG.
Scott Arciszewski
9

Ser un poco más inteligente:

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

compruébalo aquí .

Amir Fo
fuente
7

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);
Pablo Martinez
fuente
Esto es realmente (¿muy?) Incorrecto. En realidad, usa todos los caracteres del alfabeto solo una vez, por lo que reduce severamente el espacio de todos los valores posibles (relevantes para el craqueo).
Radoslav Bodo
6

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

Sanjeev
fuente
la randfunción no es criptográficamente segura, por lo que podría ser un riesgo generar una contraseña al usarla
jeteon
3

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);
Cornelius Parkin
fuente
3

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.

Adán
fuente
3
  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);
        }
    
    }
    
    ?>
waz
fuente
2

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);
monrejames
fuente
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
fuente
Esto es realmente (¿muy?) Incorrecto. En realidad, usa todos los caracteres del alfabeto solo una vez, por lo que reduce severamente el espacio de todos los valores posibles (relevantes para el craqueo).
Radoslav Bodo
0

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();
Zihad Ul Islam
fuente
0

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;
}
Behiry
fuente
0

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);
}
Sebastian Sulinski
fuente