repetir - generar usuarios aleatorios php

PHP: ¿Cómo generar una cadena alfanumérica aleatoria, única?

Question

¿Cómo sería posible generar una cadena aleatoria y única utilizando números y letras para usar en un enlace de verificación? Como cuando creas una cuenta en un sitio web, te envía un correo electrónico con un enlace y debes hacer clic en ese enlace para verificar tu cuenta ... sí ... una de esas.

¿Cómo puedo generar uno de los que usan PHP?

Actualización: Acabo de recordar acerca de uniqid() . Es una función de PHP que genera un identificador único basado en la hora actual en microsegundos. Creo que voy a usar eso.

Answer 1

Aviso de seguridad : esta solución no debe utilizarse en situaciones en que la calidad de su aleatoriedad pueda afectar la seguridad de una aplicación. En particular, rand() y uniqid() no son generadores de números aleatorios criptográficamente seguros . Vea la respuesta de Scott para una alternativa segura.

Si no es necesario que sea absolutamente único en el tiempo:

md5(uniqid(rand(), true))

De lo contrario (dado que ya ha determinado un inicio de sesión único para su usuario):

md5(uniqid($your_user_login, true))

Answer 2

Versión orientada a objetos de la solución más votada.

He creado una solución orientada a objetos basada en la respuesta de Scott :

<?php

namespace Utils;

/**
 * Class RandomStringGenerator
 * @package Utils
 *
 * Solution taken from here:
 * http://.com/a/13733588/1056679
 */
class RandomStringGenerator
{
    /** @var string */
    protected $alphabet;

    /** @var int */
    protected $alphabetLength;


    /**
     * @param string $alphabet
     */
    public function __construct($alphabet = '''')
    {
        if ('''' !== $alphabet) {
            $this->setAlphabet($alphabet);
        } else {
            $this->setAlphabet(
                  implode(range(''a'', ''z''))
                . implode(range(''A'', ''Z''))
                . implode(range(0, 9))
            );
        }
    }

    /**
     * @param string $alphabet
     */
    public function setAlphabet($alphabet)
    {
        $this->alphabet = $alphabet;
        $this->alphabetLength = strlen($alphabet);
    }

    /**
     * @param int $length
     * @return string
     */
    public function generate($length)
    {
        $token = '''';

        for ($i = 0; $i < $length; $i++) {
            $randomKey = $this->getRandomInteger(0, $this->alphabetLength);
            $token .= $this->alphabet[$randomKey];
        }

        return $token;
    }

    /**
     * @param int $min
     * @param int $max
     * @return int
     */
    protected function getRandomInteger($min, $max)
    {
        $range = ($max - $min);

        if ($range < 0) {
            // Not so random...
            return $min;
        }

        $log = log($range, 2);

        // Length in bytes.
        $bytes = (int) ($log / 8) + 1;

        // Length in bits.
        $bits = (int) $log + 1;

        // Set all lower bits to 1.
        $filter = (int) (1 << $bits) - 1;

        do {
            $rnd = hexdec(bin2hex(openssl_random_pseudo_bytes($bytes)));

            // Discard irrelevant bits.
            $rnd = $rnd & $filter;

        } while ($rnd >= $range);

        return ($min + $rnd);
    }
}

Uso

<?php

use Utils/RandomStringGenerator;

// Create new instance of generator class.
$generator = new RandomStringGenerator;

// Set token length.
$tokenLength = 32;

// Call method to generate random string.
$token = $generator->generate($tokenLength);

Alfabeto personalizado

Puede utilizar alfabeto personalizado si es necesario. Simplemente pase una cadena con caracteres compatibles al constructor o definidor:

<?php

$customAlphabet = ''0123456789ABCDEF'';

// Set initial alphabet.
$generator = new RandomStringGenerator($customAlphabet);

// Change alphabet whenever needed.
$generator->setAlphabet($customAlphabet);

Aquí están las muestras de salida

SRniGU2sRQb2K1ylXKnWwZr4HrtdRgrM
q1sRUjNq1K9rG905aneFzyD5IcqD4dlC
I0euIWffrURLKCCJZ5PQFcNUCto6cQfD
AKwPJMEM5ytgJyJyGqoD5FQwxv82YvMr
duoRF6gAawNOEQRICnOUNYmStWmOpEgS
sdHUkEn4565AJoTtkc8EqJ6cC4MLEHUx
eVywMdYXczuZmHaJ50nIVQjOidEVkVna
baJGt7cdLDbIxMctLsEBWgAw5BByP5V0
iqT0B2obq3oerbeXkDVLjZrrLheW4d8f
OUQYCny6tj2TYDlTuu1KsnUyaLkeObwa

Espero que ayude a alguien. ¡Aclamaciones!

Answer 3

1. Genera un número aleatorio usando tu generador favorito de números aleatorios
2. Multiplíquelo y divídalo para obtener un número que coincida con el número de caracteres del alfabeto de su código.
3. Obtenga el elemento en ese índice en su código de alfabeto.
4. Repita desde 1) hasta que tenga la longitud que desea

por ejemplo (en pseudo código)

int myInt = random(0, numcharacters)
char[] codealphabet = ''ABCDEF12345''
char random = codealphabet[i]
repeat until long enough

Answer 4

Aquí está el último generador de identificación único para usted. hecho por mi.

<?php
$d=date ("d");
$m=date ("m");
$y=date ("Y");
$t=time();
$dmt=$d+$m+$y+$t;    
$ran= rand(0,10000000);
$dmtran= $dmt+$ran;
$un=  uniqid();
$dmtun = $dmt.$un;
$mdun = md5($dmtran.$un);
$sort=substr($mdun, 16); // if you want sort length code.

echo $mdun;
?>

puedes hacer eco de cualquier ''var'' para tu id como quieras. pero $ mdun es mejor, puede reemplazar md5 por sha1 para obtener un mejor código, pero eso será muy largo, lo que puede que no necesite.

Gracias.

Answer 5

Creo que el problema con todas las ideas existentes es que probablemente sean únicas, pero no definitivamente únicas (como se señaló en la respuesta de Dariusz Walczak a loletech). Tengo una solución que en realidad es única. Requiere que tu script tenga algún tipo de memoria. Para mí esto es una base de datos SQL. También puedes simplemente escribir en un archivo en alguna parte. Hay dos implementaciones:

Primer método: tiene DOS campos en lugar de 1 que proporcionan singularidad. El primer campo es un número de ID que no es aleatorio pero es único (el primer ID es 1, el segundo 2 ...). Si está utilizando SQL, simplemente defina el campo de ID con la propiedad AUTO_INCREMENT. El segundo campo no es único pero es aleatorio. Esto se puede generar con cualquiera de las otras técnicas que las personas ya han mencionado. La idea de Scott fue buena, pero md5 es conveniente y probablemente lo suficientemente bueno para la mayoría de los propósitos:

$random_token = md5($_SERVER[''HTTP_USER_AGENT''] . time());

Segundo método: básicamente la misma idea, pero inicialmente elija un número máximo de cadenas que se generarán. Esto podría ser un número realmente grande como un billón. Luego haga lo mismo, genere una ID, pero coloque un cero para que todas las ID tengan el mismo número de dígitos. Luego simplemente concatena el ID con la cadena aleatoria. Será lo suficientemente aleatorio para la mayoría de los propósitos, pero la sección de identificación asegurará que también sea única.

Answer 6

Creo que este es el mejor método para usar.

str_shuffle(md5(rand(0,100000)))

Answer 7

Después de leer ejemplos anteriores se me ocurrió esto:

protected static $nonce_length = 32;

public static function getNonce()
{
    $chars = array();
    for ($i = 0; $i < 10; $i++)
        $chars = array_merge($chars, range(0, 9), range(''A'', ''Z''));
    shuffle($chars);
    $start = mt_rand(0, count($chars) - self::$nonce_length);
    return substr(join('''', $chars), $start, self::$nonce_length);
}

Duplico 10 veces la matriz [0-9, AZ] y mezclo los elementos, después de obtener un punto de inicio aleatorio para que substr () sea más "creativo" :) puede agregar [az] y otros elementos a la matriz, duplicar más o menos, sé más creativo que yo

Answer 8

Esta es una función simple que le permite generar cadenas aleatorias que contienen letras y números (alfanuméricos). También puede limitar la longitud de la cadena. Estas cadenas aleatorias se pueden usar para varios propósitos, entre ellos: Código de referencia, Código promocional, Código de cupón. La función se basa en las siguientes funciones de PHP: base_convert, sha1, uniqid, mt_rand

function random_code($length)
{
  return substr(base_convert(sha1(uniqid(mt_rand())), 16, 36), 0, $length);
}

echo random_code(6);

/*sample output
* a7d9e8
* 3klo93
*/

Answer 9

Esta función generará una clave aleatoria usando números y letras:

function random_string($length) {
    $key = '''';
    $keys = array_merge(range(0, 9), range(''a'', ''z''));

    for ($i = 0; $i < $length; $i++) {
        $key .= $keys[array_rand($keys)];
    }

    return $key;
}

echo random_string(50);

Ejemplo de salida:

zsd16xzv3jsytnp87tk7ygv73k8zmr0ekh6ly7mxaeyeh46oe8

Answer 10

Esto es lo que estoy usando en uno de mis proyectos, funciona bien y genera un TOKEN ALEATORIO ÚNICO :

$timestampz=time();

function generateRandomString($length = 60) {
    $characters = ''0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'';
    $charactersLength = strlen($characters);
    $randomString = '''';
    for ($i = 0; $i < $length; $i++) {
        $randomString .= $characters[rand(0, $charactersLength - 1)];
    }
    return $randomString;
}


$tokenparta = generateRandomString();


$token = $timestampz*3 . $tokenparta;

echo $token;

Tenga en cuenta que multiplicé la marca de tiempo por tres para crear una confusión para cualquier usuario que se esté preguntando cómo se genera este token;)

Espero que ayude :)

Answer 11

Esto es lo que yo uso:

md5(time() . rand());    
// Creates something like 0c947c3b1047334f5bb8a3b7adc1d97b

Answer 12

Llego tarde pero estoy aquí con algunos buenos datos de investigación basados ​​en las funciones proporcionadas por la respuesta de Scott . Así que configuré una gota de Digital Ocean solo para esta prueba automatizada de 5 días y almacené las cadenas únicas generadas en una base de datos MySQL.

Durante este período de prueba, utilicé 5 longitudes diferentes (5, 10, 15, 20, 50) y se insertaron +/- 0,5 millones de registros para cada longitud. Durante mi prueba, solo la longitud 5 generó +/- 3K duplicados de 0.5 millones y las longitudes restantes no generaron ningún duplicado. Entonces, podemos decir que si usamos una longitud de 15 o más con las funciones de Scott, podemos generar cadenas únicas altamente confiables. Aquí está la tabla que muestra mis datos de investigación:

Espero que esto ayude.

Answer 13

Me gusta usar claves hash cuando se trata de enlaces de verificación. Recomendaría usar el microtiempo y el hashing que el uso de MD5, ya que no debería haber ninguna razón por la que las claves deban ser las mismas, ya que se basa en el microtiempo.

1. $key = md5(rand());
2. $key = md5(microtime());

Answer 14

Para cadenas realmente aleatorias, puedes usar

<?php

echo md5(microtime(true).mt_Rand());

salidas:

40a29479ec808ad4bcff288a48a25d5c

así que incluso si intenta generar una cadena varias veces al mismo tiempo, obtendrá un resultado diferente.

Answer 15

Podemos usar estas dos líneas de código para generar una cadena única que hemos probado alrededor de 10000000 veces de iteración

  $sffledStr= str_shuffle(''abscdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()_-+'');
    $uniqueString = md5(time().$sffledStr);

Answer 16

Puede usar UUID (identificador único universal), puede usarse para cualquier propósito, desde la cadena de autenticación del usuario hasta la identificación de la transacción de pago.

Un UUID es un número de 16 octetos (128 bits). En su forma canónica, un UUID se representa con 32 dígitos hexadecimales, que se muestran en cinco grupos separados por guiones, en la forma 8-4-4-4-12 para un total de 36 caracteres (32 caracteres alfanuméricos y cuatro guiones).

function generate_uuid() {
    return sprintf( ''%04x%04x-%04x-%04x-%04x-%04x%04x%04x'',
        mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff ),
        mt_rand( 0, 0xffff ),
        mt_rand( 0, 0x0C2f ) | 0x4000,
        mt_rand( 0, 0x3fff ) | 0x8000,
        mt_rand( 0, 0x2Aff ), mt_rand( 0, 0xffD3 ), mt_rand( 0, 0xff4B )
    );

}

// llamando a la función

$transationID = generate_uuid();

algunos ejemplos de salidas serán como:

E302D66D-87E3-4450-8CB6-17531895BF14
22D288BC-7289-442B-BEEA-286777D559F2
51B4DE29-3B71-4FD2-9E6C-071703E1FF31
3777C8C6-9FF5-4C78-AAA2-08A47F555E81
54B91C72-2CF4-4501-A6E9-02A60DCBAE4C
60F75C7C-1AE3-417B-82C8-14D456542CD7
8DE0168D-01D3-4502-9E59-10D665CEBCB2

Espero que ayude a alguien en el futuro :)

Answer 17

Puedes usar este código, espero que te sea útil.

function rand_code($len)
{
 $min_lenght= 0;
 $max_lenght = 100;
 $bigL = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 $smallL = "abcdefghijklmnopqrstuvwxyz";
 $number = "0123456789";
 $bigB = str_shuffle($bigL);
 $smallS = str_shuffle($smallL);
 $numberS = str_shuffle($number);
 $subA = substr($bigB,0,5);
 $subB = substr($bigB,6,5);
 $subC = substr($bigB,10,5);
 $subD = substr($smallS,0,5);
 $subE = substr($smallS,6,5);
 $subF = substr($smallS,10,5);
 $subG = substr($numberS,0,5);
 $subH = substr($numberS,6,5);
 $subI = substr($numberS,10,5);
 $RandCode1 = str_shuffle($subA.$subD.$subB.$subF.$subC.$subE);
 $RandCode2 = str_shuffle($RandCode1);
 $RandCode = $RandCode1.$RandCode2;
 if ($len>$min_lenght && $len<$max_lenght)
 {
 $CodeEX = substr($RandCode,0,$len);
 }
 else
 {
 $CodeEX = $RandCode;
 }
 return $CodeEX;
}

Detalles sobre el generador de código aleatorio en PHP

Answer 18

Scott, sí, eres muy bueno y buena solución! Gracias.

También debo generar un token de API único para cada usuario. Siguiendo mi enfoque, usé información de usuario (nombre de usuario y nombre de usuario):

public function generateUniqueToken($userid, $username){

        $rand = mt_rand(100,999);
    $md5 = md5($userid.''!(&^ 532567_465 ///''.$username);

    $md53 = substr($md5,0,3);
    $md5_remaining = substr($md5,3);

    $md5 = $md53. $rand. $userid. $md5_remaining;

    return $md5;
}

Por favor, eche un vistazo y hágame saber si puedo mejorar algo. Gracias

Answer 19

Simplificar el código de Scotts de arriba eliminando los bucles innecesarios, que se ralentizan mucho y no lo hacen más seguro que llamar a openssl_random_pseudo_bytes solo una vez

function crypto_rand_secure($min, $max)
{
 $range = $max - $min;
 if ($range < 1) return $min; // not so random...
 $log = ceil(log($range, 2));
 $bytes = (int) ($log / 8) + 1; // length in bytes
 $rnd = hexdec(bin2hex(openssl_random_pseudo_bytes($bytes)));
 return $min + $rnd%$range;
}

function getToken($length)
{
 return bin2hex(openssl_random_pseudo_bytes($length)
}

Answer 20

Solo estaba buscando la forma de resolver este mismo problema, pero también quiero que mi función cree un token que también pueda usarse para recuperar la contraseña. Esto significa que necesito limitar la capacidad del token para ser adivinado. Debido a que uniqid() se basa en el tiempo y según php.net "el valor de retorno es un poco diferente de microtime ()", uniqid no cumple con los criterios. PHP recomienda usar openssl_random_pseudo_bytes() lugar de generar tokens criptográficamente seguros.

Una respuesta rápida, corta y puntual es:

bin2hex(openssl_random_pseudo_bytes($bytes))

que generará una cadena aleatoria de caracteres alfanuméricos de longitud = $ bytes * 2. Desafortunadamente, esto solo tiene un alfabeto de [af][0-9] , pero funciona.

A continuación se muestra la función más sólida que podría cumplir que cumple con los criterios (esta es una versión implementada de la respuesta de Erik).

function crypto_rand_secure($min, $max)
{
    $range = $max - $min;
    if ($range < 1) return $min; // not so random...
    $log = ceil(log($range, 2));
    $bytes = (int) ($log / 8) + 1; // length in bytes
    $bits = (int) $log + 1; // length in bits
    $filter = (int) (1 << $bits) - 1; // set all lower bits to 1
    do {
        $rnd = hexdec(bin2hex(openssl_random_pseudo_bytes($bytes)));
        $rnd = $rnd & $filter; // discard irrelevant bits
    } while ($rnd > $range);
    return $min + $rnd;
}

function getToken($length)
{
    $token = "";
    $codeAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    $codeAlphabet.= "abcdefghijklmnopqrstuvwxyz";
    $codeAlphabet.= "0123456789";
    $max = strlen($codeAlphabet); // edited

    for ($i=0; $i < $length; $i++) {
        $token .= $codeAlphabet[crypto_rand_secure(0, $max-1)];
    }

    return $token;
}

crypto_rand_secure($min, $max) funciona como un reemplazo del rand() o mt_rand . Utiliza openssl_random_pseudo_bytes para ayudar a crear un número aleatorio entre $ min y $ max.

getToken($length) crea un alfabeto para usar dentro del token y luego crea una cadena de longitud $length .

EDITAR: me olvidé de citar la fuente - http://us1.php.net/manual/en/function.openssl-random-pseudo-bytes.php#104322

EDITAR (PHP7): con el lanzamiento de PHP7, la biblioteca estándar ahora tiene dos nuevas funciones que pueden reemplazar / mejorar / simplificar la función crypto_rand_secure arriba. random_bytes($length) y random_int($min, $max)

http://php.net/manual/en/function.random-bytes.php

http://php.net/manual/en/function.random-int.php

Ejemplo:

function getToken($length){
     $token = "";
     $codeAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     $codeAlphabet.= "abcdefghijklmnopqrstuvwxyz";
     $codeAlphabet.= "0123456789";
     $max = strlen($codeAlphabet); // edited

    for ($i=0; $i < $length; $i++) {
        $token .= $codeAlphabet[random_int(0, $max-1)];
    }

    return $token;
}

Answer 21

Utilice el código de abajo para generar el número aleatorio de 11 caracteres o cambie el número según su requisito.

$randomNum=substr(str_shuffle("0123456789abcdefghijklmnopqrstvwxyz"), 0, 11);

or we can use custom function to generate the random number

 function randomNumber($length){
     $numbers = range(0,9);
     shuffle($numbers);
     for($i = 0;$i < $length;$i++)
        $digits .= $numbers[$i];
     return $digits;
 }

 //generate random number
 $randomNum=randomNumber(11);

Answer 22

Yo uso este de una sola línea:

base64_encode(openssl_random_pseudo_bytes(3 * ($length >> 2)));

donde longitud es la longitud de la cadena deseada (divisible por 4, de lo contrario se redondea al número más cercano divisible por 4)

Answer 23

<?php
function generateRandomString($length = 11) {
    $characters = ''0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'';
    $charactersLength = strlen($characters);
    $randomString = '''';
    for ($i = 0; $i < $length; $i++) {
        $randomString .= $characters[rand(0, $charactersLength - 1)];
    }
    return $randomString;

}

?>

La función anterior le generará una cadena aleatoria que tiene una longitud de 11 caracteres.

Answer 24

function random_string($length = 8) {
    $alphabets = range(''A'',''Z'');
    $numbers = range(''0'',''9'');
    $additional_characters = array(''_'',''='');
    $final_array = array_merge($alphabets,$numbers,$additional_characters);
       while($length--) {
      $key = array_rand($final_array);

      $password .= $final_array[$key];
                        }
  if (preg_match(''/[A-Za-z0-9]/'', $password))
    {
     return $password;
    }else{
    return  random_string();
    }

 }