segura - str_random php

¿Cómo generar una contraseña aleatoria con PHP?

Question

¿O hay un software para generar automáticamente contraseñas aleatorias?

Answer 1

Aquí hay una solución simple. Contendrá letras y números minúsculos.

substr(str_shuffle(strtolower(sha1(rand() . time() . "my salt string"))),0, $PASSWORD_LENGTH);

Aquí hay una solución más fuerte genera aleatoriamente los códigos de caracteres en el rango de caracteres deseado para una longitud aleatoria dentro de un rango deseado.

function generateRandomPassword() {
//Initialize the random password
$password = '''';
//Initialize a random desired length
$desired_length = rand(8, 12);
for($length = 0; $length < $desired_length; $length++) {
//Append a random ASCII character (including symbols)
$password .= chr(rand(32, 126));
}
return $password;
}

Answer 2

Así es como lo hago.

$pw = "";
for ($i = 0; $i < 13; $i++)
{
$pw .= chr(rand(33, 126));
}

Answer 3

Esta función generará una contraseña más sólida que la solución más utilizada:

function generatePassword($size=8){
$p = openssl_random_pseudo_bytes(ceil($size*0.67), $crypto_strong);
$p = str_replace(''='', '''', base64_encode($p));
$p = strtr($p, ''+/'', ''^*'');
return substr($p, 0, $size);
}

Cada carácter de contraseña será [AZ] o [az] o ^ o *

Answer 4

Esto ayudará a crear una contraseña aleatoria:

<?php
function generatePassword ($length = 8)
{
$genpassword = "";
$possible = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
$i = 0;
while ($i < $length) {
$char = substr($possible, mt_rand(0, strlen($possible)-1), 1);
if (!strstr($genpassword, $char)) {
$genpassword .= $char;
$i++;
}
}
return $genpassword;
}
?>
<input type="text" value="<?php echo generatePassword(); ?>">

Aquí está el ejemplo de trabajo (Demo)

Answer 5

Me gusta mezclar una matriz de caracteres aleatorios

$a = str_split("abcdefghijklmnopqrstuvwxyABCDEFGHIJKLMNOPQRSTUVWXY0123456789");
shuffle($a);
echo implode($a); //maxlength
echo "/n".substr( implode($a), 0, 10 ); //instead of 10 => any length
//As function:
function getMeRandomPwd($length){
$a = str_split("abcdefghijklmnopqrstuvwxyABCDEFGHIJKLMNOPQRSTUVWXY0123456789");
shuffle($a);
return substr( implode($a), 0, $length );
}
echo "/n".getMeRandomPwd(8)."/n".getMeRandomPwd(11);
// Outpus something like:
// 3Ai4Xf6R2I8bYGUmKgB9jpqo7ncV5teuQhkOHJCNrTP0sLFd1wxSMlEWvyaD
// 3Ai4Xf6R2I
// JsBKWFDa
// gfxsjr3dX70

Si necesita que la contraseña sea más larga, simplemente concatenar charlist varias veces :)

Answer 6

Podrías usar el paquete Text_Password de PEAR : admite bastantes algoritmos para generarlos; y libera tu tiempo para ir a otra cosa.

Answer 7

Pwgen-php produce contraseñas guardables, pronunciables (más fáciles de recordar): http://code.google.com/p/pwgen-php/

¿Podría ser eso aceptable?

Answer 8

Quiero jugar el juego La forma más simple sería hacer:

function rand_passwd( $length = 8, $chars = ''abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'' ) {
return substr( str_shuffle( $chars ), 0, $length );
}

Esto es solo una modificación de la primera respuesta. Especifique los caracteres que desea en los segundos parámetros y la longitud de la contraseña en el primero.

Answer 9

Simplemente construye una cadena de az al azar, AZ, 0-9 (o lo que quieras) hasta la longitud deseada. Aquí hay un ejemplo en PHP:

function generatePassword($length = 8) {
$chars = ''abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'';
$count = mb_strlen($chars);
for ($i = 0, $result = ''''; $i < $length; $i++) {
$index = rand(0, $count - 1);
$result .= mb_substr($chars, $index, 1);
}
return $result;
}

Para optimizar, puede definir $ chars como una variable estática o constante en el método (o clase principal) si va a llamar a esta función muchas veces durante una sola ejecución.

Answer 10

También puedes probar una función que escribí y está disponible desde mi blog. La ventaja de esta función es que otorga la misma importancia a minúsculas, mayúsculas, números y caracteres especiales. Se puede encontrar aquí PHP función de generador de contraseñas aleatorias

Answer 11

Una buena contraseña debe ser una mezcla de mayúsculas, minúsculas, tiene números, letras, tiene caracteres especiales y tiene más de 6 caracteres. Aquí está la función que uso en mis aplicaciones.

function randomPassword( $length = 8 )
{
$chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_-=+;:,.?";
$length = rand(10, 16);
$password = substr( str_shuffle(sha1(rand() . time()) . $chars ), 0, $length );
return $password;
}

Answer 12

aquí hay una función que genera una contraseña con una longitud mínima, un número mínimo de dígitos y un número mínimo de letras.

function generatePassword() {
$min_length=8; //Minimum length of the password
$min_numbers=2; //Minimum of numbers AND special characters
$min_letters=2; //Minimum of letters
$password = '''';
$numbers=0;
$letters=0;
$length=0;
while ( $length <= $min_length OR $numbers <= $min_numbers OR $letters <= $min_letters) {
$length+=1;
$type=rand(1, 3);
if ($type==1) {
$password .= chr(rand(33, 64)); //Numbers and special characters
$numbers+=1;
}elseif ($type==2) {
$password .= chr(rand(65, 90)); //A->Z
$letters+=1;
}else {
$password .= chr(rand(97, 122)); //a->z
$letters+=1;
}
}
return $password;
}

Answer 13

usar hackzilla/password-generator

tiene muchas opciones para crear diferentes tipos de contraseñas:

• ComputerPasswordGenerator()
• HybridPasswordGenerator() -> sjgX-PFjH-zxMz-PRDz-G6mx-wMJ4-ST24
• HumanPasswordGenerator() -> Verkuemmerungen-verlottertet-dreinzuschauen (lista de palabras basada, en este caso, una lista de palabras alemanas)
• RequirementPasswordGenerator()

ComputerPasswordGenerator

$generator
->setOptionValue(ComputerPasswordGenerator::OPTION_UPPER_CASE, true)
->setOptionValue(ComputerPasswordGenerator::OPTION_LOWER_CASE, true)
->setOptionValue(ComputerPasswordGenerator::OPTION_NUMBERS, true)
->setOptionValue(ComputerPasswordGenerator::OPTION_SYMBOLS, false)
;
$password = $generator->generatePassword();

RequirementPasswordGenerator

$generator
->setLength(16)
->setOptionValue(RequirementPasswordGenerator::OPTION_UPPER_CASE, true)
->setOptionValue(RequirementPasswordGenerator::OPTION_LOWER_CASE, true)
->setOptionValue(RequirementPasswordGenerator::OPTION_NUMBERS, true)
->setOptionValue(RequirementPasswordGenerator::OPTION_SYMBOLS, true)
->setMinimumCount(RequirementPasswordGenerator::OPTION_UPPER_CASE, 2)
->setMinimumCount(RequirementPasswordGenerator::OPTION_LOWER_CASE, 2)
->setMinimumCount(RequirementPasswordGenerator::OPTION_NUMBERS, 2)
->setMinimumCount(RequirementPasswordGenerator::OPTION_SYMBOLS, 2)
->setMaximumCount(RequirementPasswordGenerator::OPTION_UPPER_CASE, 8)
->setMaximumCount(RequirementPasswordGenerator::OPTION_LOWER_CASE, 8)
->setMaximumCount(RequirementPasswordGenerator::OPTION_NUMBERS, 8)
->setMaximumCount(RequirementPasswordGenerator::OPTION_SYMBOLS, 8)
;
$password = $generator->generatePassword();

Answer 14

$password = hash(''sha512'', rand());

No debería ser demasiado difícil de recordar. Sin embargo, esto podría ser más fácil de recordar:

$password = substr(hash(''sha512'',rand()),0,12); // Reduces the size to 12 chars

Solo se usan 16 caracteres posibles, pero aún hay 16 ^ 12 contraseñas posibles (con 300,000 contraseñas / segundo, llevaría 29 años crackear).

Answer 15

function generate_password($length = 6) {
$password = '''';
$chars = array_merge(range(''a'', ''z''), range(''A'', ''Z''), range(0, 9));
for ($i = 0; $i < $length; $i ++) {
$password .= $chars[array_rand($chars)];
}
return $password;
}