Come sarebbe possibile generare una stringa univoca e casuale utilizzando numeri e lettere da utilizzare in un collegamento di verifica? Come quando crei un account su un sito Web, ti invia un'email con un link e devi fare clic su quel link per verificare il tuo account ... sì ... uno di quelli.

Come posso generare uno di quelli che usano PHP?

Aggiornamento: appena ricordato uniqid(). È una funzione PHP che genera un identificatore univoco basato sull'ora corrente in microsecondi. Penso che lo userò.

Avviso di sicurezza : questa soluzione non deve essere utilizzata in situazioni in cui la qualità della casualità può influire sulla sicurezza di un'applicazione. In particolare, rand()e uniqid()non sono generatori di numeri casuali crittograficamente sicuri . Vedi la risposta di Scott per un'alternativa sicura.

Se non ti serve per essere assolutamente unico nel tempo:

md5(uniqid(rand(), true))

Altrimenti (dato che hai già determinato un accesso univoco per il tuo utente):

md5(uniqid($your_user_login, true))

Stavo solo esaminando come risolvere questo stesso problema, ma voglio anche che la mia funzione crei un token che può essere utilizzato anche per il recupero della password. Ciò significa che devo limitare la capacità del token di essere indovinato. Perché uniqidsi basa sul tempo e secondo php.net "il valore di ritorno è leggermente diverso da microtime ()", uniqidnon soddisfa i criteri. PHP consiglia di utilizzare openssl_random_pseudo_bytes()invece per generare token crittograficamente sicuri.

Una risposta rapida, breve e precisa è:

bin2hex(openssl_random_pseudo_bytes($bytes))

che genererà una stringa casuale di caratteri alfanumerici di lunghezza = $ byte * 2. Sfortunatamente questo ha solo un alfabeto di [a-f][0-9], ma funziona.

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)funziona come un calo in sostituzione di rand()o mt_rand. Usa openssl_random_pseudo_bytes per aiutare a creare un numero casuale tra $ min e $ max.

getToken($length)crea un alfabeto da utilizzare all'interno del token e quindi crea una stringa di lunghezza $length.

EDIT: ho trascurato di citare la fonte - http://us1.php.net/manual/en/function.openssl-random-pseudo-bytes.php#104322

EDIT (PHP7): Con il rilascio di PHP7, la libreria standard ora ha due nuove funzioni che possono sostituire / migliorare / semplificare la funzione crypto_rand_secure sopra. random_bytes($length)erandom_int($min, $max)

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

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

Esempio:

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

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

    return $token;
}

Versione orientata agli oggetti della soluzione più votata

Ho creato una soluzione orientata agli oggetti basata sulla risposta di Scott :

<?php

namespace Utils;

/**
 * Class RandomStringGenerator
 * @package Utils
 *
 * Solution taken from here:
 * http://stackoverflow.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 personalizzato

È possibile utilizzare l'alfabeto personalizzato, se necessario. Basta passare una stringa con caratteri supportati al costruttore o al setter:

<?php

$customAlphabet = '0123456789ABCDEF';

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

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

Ecco i campioni di output

SRniGU2sRQb2K1ylXKnWwZr4HrtdRgrM
q1sRUjNq1K9rG905aneFzyD5IcqD4dlC
I0euIWffrURLKCCJZ5PQFcNUCto6cQfD
AKwPJMEM5ytgJyJyGqoD5FQwxv82YvMr
duoRF6gAawNOEQRICnOUNYmStWmOpEgS
sdHUkEn4565AJoTtkc8EqJ6cC4MLEHUx
eVywMdYXczuZmHaJ50nIVQjOidEVkVna
baJGt7cdLDbIxMctLsEBWgAw5BByP5V0
iqT0B2obq3oerbeXkDVLjZrrLheW4d8f
OUQYCny6tj2TYDlTuu1KsnUyaLkeObwa

Spero che possa aiutare qualcuno. Saluti!

Sono in ritardo ma sono qui con alcuni buoni dati di ricerca basati sulle funzioni fornite dalla risposta di Scott . Quindi ho creato un droplet Digital Ocean solo per questo test automatizzato della durata di 5 giorni e ho archiviato le stringhe uniche generate in un database MySQL.

Durante questo periodo di prova, ho usato 5 diverse lunghezze (5, 10, 15, 20, 50) e sono stati inseriti +/- 0,5 milioni di record per ogni lunghezza. Durante il mio test, solo la lunghezza 5 ha generato duplicati +/- 3K su 0,5 milioni e le lunghezze rimanenti non hanno generato duplicati. Quindi possiamo dire che se usiamo una lunghezza di 15 o superiore con le funzioni di Scott, possiamo generare stringhe uniche altamente affidabili. Ecco la tabella che mostra i miei dati di ricerca:

Aggiornamento: ho creato una semplice app Heroku usando queste funzioni che restituiscono il token come risposta JSON. È possibile accedere all'app a https://uniquestrings.herokuapp.com/api/token?length=15

Spero che questo possa essere d'aiuto.

È possibile utilizzare UUID (Universally Unique Identifier), può essere utilizzato per qualsiasi scopo, dalla stringa di autenticazione dell'utente all'ID della transazione di pagamento.

Un UUID è un numero di 16 ottetti (128 bit). Nella sua forma canonica, un UUID è rappresentato da 32 cifre esadecimali, visualizzate in cinque gruppi separati da trattini, nella forma 8-4-4-4-12 per un totale di 36 caratteri (32 caratteri alfanumerici e quattro trattini).

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

}

// chiamando la funzione

$transationID = generate_uuid();

alcuni output di esempio saranno come:

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

spero che aiuti qualcuno in futuro :)

Questa funzione genererà una chiave casuale usando numeri e lettere:

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

Esempio di output:

zsd16xzv3jsytnp87tk7ygv73k8zmr0ekh6ly7mxaeyeh46oe8

Uso questo one-liner:

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

dove lunghezza è la lunghezza della stringa desiderata (divisibile per 4, altrimenti viene arrotondata per difetto al numero più vicino divisibile per 4)

Utilizzare il codice seguente per generare il numero casuale di 11 caratteri o modificare il numero in base alle proprie esigenze.

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

oppure possiamo usare la funzione personalizzata per generare il numero casuale

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

1. Genera un numero casuale usando il tuo generatore di numeri casuali preferito
2. Moltiplica e dividi per ottenere un numero corrispondente al numero di caratteri dell'alfabeto in codice
3. Ottieni l'elemento in quell'indice nell'alfabeto del codice.
4. Ripeti da 1) fino a ottenere la lunghezza desiderata

ad es. (in pseudo codice)

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

Ecco il generatore di ID unico per te. fatto da me.

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

puoi fare eco a qualsiasi 'var' per il tuo ID come preferisci. ma $ mdun è migliore, puoi sostituire md5 in sha1 per un codice migliore, ma sarà molto lungo e potrebbe non essere necessario.

Grazie.

Per stringhe davvero casuali, puoi usare

<?php

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

uscite:

40a29479ec808ad4bcff288a48a25d5c

quindi anche se provi a generare una stringa più volte nello stesso momento, otterrai un output diverso.

Quando si tenta di generare una password casuale, si sta tentando di:

• Innanzitutto genera un set crittograficamente sicuro di byte casuali

• Il secondo è trasformare quei byte casuali in una stringa stampabile

Ora, ci sono diversi modi per generare byte casuali in php come:

$length = 32;

//PHP 7+
$bytes= random_bytes($length);

//PHP < 7
$bytes= openssl_random_pseudo_bytes($length);

Quindi vuoi trasformare questi byte casuali in una stringa stampabile:

Puoi usare bin2hex :

$string = bin2hex($bytes);

o base64_encode :

$string = base64_encode($bytes);

Tuttavia, si noti che non si controlla la lunghezza della stringa se si utilizza base64. Puoi usare bin2hex per farlo, usando 32 byte si trasformerà in una stringa di 64 caratteri . Ma funzionerà così solo in una stringa EVEN .

Quindi in pratica puoi semplicemente fare :

$length = 32;

if(PHP_VERSION>=7){
    $bytes= random_bytes($length);
}else{
    $bytes= openssl_random_pseudo_bytes($length);
} 

$string = bin2hex($bytes);

Ecco cosa uso:

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

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

 }

Questa è una semplice funzione che ti consente di generare stringhe casuali contenenti lettere e numeri (alfanumerici). Puoi anche limitare la lunghezza della stringa. Queste stringhe casuali possono essere utilizzate per vari scopi, tra cui: Codice di riferimento, Codice promozionale, Codice coupon. La funzione si basa sulle seguenti funzioni 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
*/

dopo aver letto gli esempi precedenti, ho pensato a questo:

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 volte l'array [0-9, AZ] e mischio gli elementi, dopo che ho ottenuto un punto di partenza casuale per substr () per essere più "creativo" :) puoi aggiungere [az] e altri elementi all'array, duplicare più o meno, sii più creativo di me

Mi piace usare le chiavi hash quando si gestiscono i collegamenti di verifica. Consiglierei di usare il microtime e l'hashing usando MD5 poiché non ci dovrebbero essere ragioni per cui i tasti dovrebbero essere gli stessi poiché ha hash basato sul microtime.

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

<?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 funzione sopra genererà una stringa casuale della lunghezza di 11 caratteri.

Se vuoi generare una stringa univoca in PHP, prova a seguire.

md5(uniqid().mt_rand());

In questo,

uniqid()- Genererà una stringa univoca. Questa funzione restituisce un identificatore univoco basato su data / ora come stringa.

mt_rand() - Genera numero casuale.

md5() - Genererà la stringa hash.

Scott, sì, sei molto bravo a scrivere e un'ottima soluzione! Grazie.

Sono inoltre tenuto a generare un token API univoco per ciascun utente. Di seguito è il mio approccio, ho usato le informazioni dell'utente (Userid e Username):

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

Per favore, dai un'occhiata e fammi sapere se posso fare qualche miglioramento. Grazie

Ecco quello che sto usando su uno dei miei progetti, sta funzionando alla grande e genera un TOKEN UNICO CASUALE :

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

Si noti che ho moltiplicato il timestamp per tre per creare confusione per chiunque si stia chiedendo come viene generato questo token;)

Spero possa essere d'aiuto :)

Penso che questo sia il metodo migliore da usare.

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

possiamo usare queste due righe di codice per generare stringhe univoche che abbiamo testato circa 10000000 volte di iterazione

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

Uso sempre questa mia funzione per generare una stringa alfanumerica casuale personalizzata ... Spero che questo aiuto.

<?php
  function random_alphanumeric($length) {
    $chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345689';
    $my_string = '';
    for ($i = 0; $i < $length; $i++) {
      $pos = mt_rand(0, strlen($chars) -1);
      $my_string .= substr($chars, $pos, 1);
    }
    return $my_string;
  }
  echo random_alphanumeric(50); // 50 characters
?>

Genera ad esempio: Y1FypdjVbFCFK6Gh9FDJpe6dciwJEfV6MQGpJqAfuijaYSZ86g

Se vuoi confrontare con un'altra stringa per essere sicuro che si tratti di una sequenza unica puoi usare questo trucco ...

$string_1 = random_alphanumeric(50);
$string_2 = random_alphanumeric(50);
while ($string_1 == $string_2) {
  $string_1 = random_alphanumeric(50);
  $string_2 = random_alphanumeric(50);
  if ($string_1 != $string_2) {
     break;
  }
}
echo $string_1;
echo "<br>\n";
echo $string_2;

genera due stringhe uniche:

qsBDs4JOoVRfFxyLAOGECYIsWvpcpMzAO9pypwxsqPKeAmYLOi

Ti3kE1WfGgTNxQVXtbNNbhhvvapnaUfGMVJecHkUjHbuCb85pF

Spero che questo sia ciò che stai cercando...

Una soluzione semplice è convertire la base 64 in alfanumerica eliminando i caratteri non alfanumerici.

Questo usa random_bytes () per un risultato crittograficamente sicuro.

function random_alphanumeric(int $length): string
{
    $result='';
    do
    {
        //Base 64 produces 4 characters for each 3 bytes, so most times this will give enough bytes in a single pass
        $bytes=random_bytes(($length+3-strlen($result))*2);
        //Discard non-alhpanumeric characters
        $result.=str_replace(['/','+','='],['','',''],base64_encode($bytes));
        //Keep adding characters until the string is long enough
        //Add a few extra because the last 2 or 3 characters of a base 64 string tend to be less diverse
    }while(strlen($result)<$length+3);
    return substr($result,0,$length);
}

Penso che questa sia la soluzione migliore

Str::uuid()->toString()

Credo che il problema con tutte le idee esistenti sia che sono probabilmente uniche, ma non assolutamente uniche (come sottolineato nella risposta di Dariusz Walczak a Loletech). Ho una soluzione che è davvero unica. Richiede che la tua sceneggiatura abbia una sorta di memoria. Per me questo è un database SQL. Potresti anche semplicemente scrivere su un file da qualche parte. Esistono due implementazioni:

Primo metodo: avere DUE campi anziché 1 che forniscono unicità. Il primo campo è un numero ID che non è casuale ma è univoco (Il primo ID è 1, il secondo 2 ...). Se si utilizza SQL, è sufficiente definire il campo ID con la proprietà AUTO_INCREMENT. Il secondo campo non è unico ma è casuale. Questo può essere generato con una qualsiasi delle altre tecniche che le persone hanno già menzionato. L'idea di Scott era buona, ma md5 è conveniente e probabilmente abbastanza buono per la maggior parte degli scopi:

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

Secondo metodo: sostanzialmente la stessa idea, ma inizialmente scegli un numero massimo di stringhe che verranno mai generate. Questo potrebbe essere solo un numero davvero grande come un trilione. Quindi fai la stessa cosa, genera un ID, ma zero lo pad in modo che tutti gli ID abbiano lo stesso numero di cifre. Quindi concatena l'ID con la stringa casuale. Sarà abbastanza casuale per la maggior parte degli scopi, ma la sezione ID assicurerà che sia anche unica.

Puoi usare questo codice, spero che ti sia utile.

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

Dettagli sul generatore di codice casuale in PHP

Semplificare il codice di Scotts sopra rimuovendo i loop non necessari che rallentano gravemente e non lo rendono più sicuro della chiamata openssl_random_pseudo_bytes una sola volta

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