Właśnie zastanawiałem się, jak rozwiązać ten sam problem, ale chcę również, aby moja funkcja stworzyła token, który może być również używany do wyszukiwania haseł. Oznacza to, że muszę ograniczyć możliwość odgadnięcia tokena. Ponieważ uniqid opiera się na czasie i zgodnie z php.net "wartość zwracana niewiele różni się od microtime()", uniqid nie spełnia kryteriów. PHP zaleca użycie openssl_random_pseudo_bytes() zamiast generowania kryptograficznie bezpiecznych tokenów.

Szybki, krótka i rzeczowa odpowiedź brzmi:

bin2hex(openssl_random_pseudo_bytes($bytes))

Który wygeneruje losowy ciąg znaków alfanumerycznych o długości = $bajty * 2. Niestety ma tylko alfabet [a-f][0-9], ale działa.

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) działa jako zamiennik rand() lub mt_rand. Używa openssl_random_pseudo_bytes, aby pomóc stworzyć losową liczbę między $min i $ max.

getToken($length) tworzy alfabet do użycia w tokenie, a następnie tworzy ciąg o długości $length.

EDIT: zaniedbałem przytoczyć źródło - http://us1.php.net/manual/en/function.openssl-random-pseudo-bytes.php#104322

EDIT (PHP7): wraz z wydaniem PHP7 biblioteka standardowa ma teraz dwie nowe funkcje, które mogą zastąpić / ulepszyć/uprościć powyższą funkcję crypto_rand_secure. random_bytes($length) i random_int($min, $max)

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

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

Przykład:

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

Obiektowa wersja najczęściej głosowanego rozwiązania

Stworzyłem rozwiązanie zorientowane obiektowo w oparciu o odpowiedź Scotta :

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

Użycie

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

Własny alfabet

W razie potrzeby możesz użyć własnego alfabetu. Wystarczy przekazać ciąg znaków ze wsparciem do konstruktora lub settera:

<?php

$customAlphabet = '0123456789ABCDEF';

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

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

Oto próbki wyjściowe

SRniGU2sRQb2K1ylXKnWwZr4HrtdRgrM
q1sRUjNq1K9rG905aneFzyD5IcqD4dlC
I0euIWffrURLKCCJZ5PQFcNUCto6cQfD
AKwPJMEM5ytgJyJyGqoD5FQwxv82YvMr
duoRF6gAawNOEQRICnOUNYmStWmOpEgS
sdHUkEn4565AJoTtkc8EqJ6cC4MLEHUx
eVywMdYXczuZmHaJ50nIVQjOidEVkVna
baJGt7cdLDbIxMctLsEBWgAw5BByP5V0
iqT0B2obq3oerbeXkDVLjZrrLheW4d8f
OUQYCny6tj2TYDlTuu1KsnUyaLkeObwa

Ta funkcja wygeneruje losowy klucz za pomocą cyfr i liter:

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

Przykładowe wyjście:

zsd16xzv3jsytnp87tk7ygv73k8zmr0ekh6ly7mxaeyeh46oe8

Jestem spóźniony, ale jestem tutaj z dobrymi danymi badawczymi na podstawie funkcji dostarczonych przez ODPOWIEDŹ Scotta. Więc skonfigurowałem cyfrową kroplę Oceanu tylko dla tego 5-dniowego automatycznego testu i zapisałem wygenerowane unikalne ciągi w bazie danych MySQL.

W tym okresie testowym użyłem 5 różnych długości (5, 10, 15, 20, 50) i + / -0,5 miliona rekordów wstawiono dla każdej długości. Podczas mojego testu tylko długość 5 wygenerowanych +/-3K duplikuje się z 0,5 miliona, a pozostałe długość nie generowała żadnych duplikatów. Możemy więc powiedzieć, że jeśli użyjemy długości 15 lub wyższej z funkcjami Scotta, to możemy wygenerować wysoce niezawodne unikalne ciągi. Oto tabela pokazująca moje dane badawcze:

Mam nadzieję, że to pomoże.

Możesz użyć UUID(Universal Unique Identifier), może być używany do dowolnego celu, od łańcucha uwierzytelniania użytkownika po identyfikator transakcji płatniczej.

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

}

/ / wywołanie funtion

$transationID = generate_uuid();

Niektóre przykładowe wyjścia będą like:

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

Mam nadzieję, że to komuś pomoże w przyszłości:)

Używam tego jednowarstwowego:

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

Gdzie długość jest długością pożądanego ciągu (podzielna przez 4, w przeciwnym razie jest zaokrąglana w dół do najbliższej liczby podzielnej przez 4)

1. Wygeneruj losową liczbę za pomocą Twój ulubiony losowy numer generator
2. Mnożenie i dzielenie aby uzyskać liczbę pasującą do liczby znaków w alfabecie kodu
3. Get the item at that index in Twój alfabet kodu.
4. Powtórz od 1) aż będziesz miał długość want

E. g (w pseudo kodzie)

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

Użyj poniższego kodu, aby wygenerować losową liczbę 11 znaków lub zmienić liczbę zgodnie z wymaganiami.

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

Oto ostateczny unikalny Generator id dla Ciebie. zrobione przeze mnie.

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

Możesz echo dowolnego 'var' dla swojego identyfikatora, jak chcesz. ale $mdun jest lepszy, można zastąpić md5 do sha1 dla lepszego kodu, ale to będzie bardzo długo, co może nie trzeba.

Oto czego używam:

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

Lubię używać kluczy hashowych przy kontaktach z linkami weryfikacyjnymi. Polecam korzystanie z microtime i hashowanie za pomocą MD5, ponieważ nie powinno być powodu, dla którego klucze powinny być takie same, ponieważ hashuje na podstawie microtime.

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

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

 }

Scott, tak, jesteś bardzo pisać i dobre rozwiązanie! Dzięki.

Jestem również zobowiązany do wygenerowania unikalnego tokena API dla każdego mojego użytkownika. Poniżej znajduje się moje podejście, użyłem informacji o użytkowniku (Userid i 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;
}

Proszę spojrzeć i dać mi znać, jeśli jakaś poprawa mogę zrobić. Dzięki

Po przeczytaniu poprzednich przykładów wpadłem na to:

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

Powielam 10 razy tablicę [0-9, A-Z] i przetasowuję elementy, po tym jak uzyskam losowy punkt startowy dla podstr (), aby był bardziej "kreatywny" :) możesz dodawać [a-Z] i inne elementy do tablicy, powielać mniej lub bardziej, być bardziej kreatywnym niż ja

Oto, czego używam w jednym z moich projektów, działa świetnie i generuje unikalny losowy TOKEN :

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

Proszę zauważyć, że pomnożyłem znacznik czasu przez trzy, aby stworzyć zamieszanie dla każdego, kto może zastanawiać się, jak ten token jest generowany;)

Mam nadzieję, że to pomoże:)

Myślę, że to najlepsza metoda.

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

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

}

?>

Powyższa funkcja wygeneruje losowy ciąg znaków o długości 11 znaków.

Możemy użyć tych dwóch linii kodu do wygenerowania unikalnego ciągu przetestowaliśmy około 10000000 razy iteracji

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

Dla naprawdę losowych ciągów możesz użyć

<?php

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

Wyjścia:

40a29479ec808ad4bcff288a48a25d5c

Więc nawet jeśli spróbujesz wygenerować łańcuch wiele razy w tym samym czasie, otrzymasz inny wynik.

Jest to prosta funkcja, która pozwala na generowanie losowych ciągów zawierających litery i cyfry (alfanumerycznych). Można również ograniczyć długość łańcucha. Te losowe ciągi mogą być używane do różnych celów, w tym: kod polecający, kod promocyjny, Kod kuponu. Funkcja opiera się na następujących funkcjach 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
*/

Uważam, że problem ze wszystkimi istniejącymi pomysłami polega na tym, że są one prawdopodobnie unikalne, ale niezdecydowanie unikalne (jak zaznaczono w odpowiedzi Dariusza Walczaka do loletecha). Mam rozwiązanie, które jest unikalne. Wymaga to, aby twój skrypt miał jakąś pamięć. Dla mnie jest to baza danych SQL. Możesz też po prostu zapisać gdzieś plik. Istnieją dwie implementacje:

Pierwsza metoda: posiada dwa pola zamiast 1, które zapewniają unikalność. Pierwsze pole jest numerem identyfikacyjnym, który nie jest losowy, ale jest unikalny (pierwszy IDENTYFIKATOR to 1, drugi 2...). Jeśli używasz SQL, po prostu zdefiniuj pole ID za pomocą właściwości AUTO_INCREMENT. Drugie pole nie jest unikalne, ale jest losowe. Można to wygenerować za pomocą dowolnej z innych technik, o których już wspomniano. Pomysł Scotta był dobry, ale md5 jest wygodny i prawdopodobnie wystarczająco dobry dla większości celów: {]}

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

Druga metoda: zasadniczo ten sam pomysł, ale początkowo wybierz maksymalną liczbę ciągów, które nigdy nie zostanie wygenerowany. To może być naprawdę duża liczba, jak bilion. Następnie zrób to samo, Wygeneruj identyfikator, ale Zeruj go tak, aby wszystkie identyfikatory były taką samą liczbą cyfr. Następnie po prostu połącz identyfikator z losowym ciągiem znaków. Będzie to wystarczająco losowe dla większości celów, ale sekcja ID zapewni, że jest również unikalna.

Możesz użyć tego kodu, Mam nadzieję, że to ci pomoże.

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

Szczegóły o generatorze kodu losowego w PHP

Uproszczenie powyższego kodu przez usunięcie niepotrzebnych pętli, co bardzo spowalnia i nie czyni go bezpieczniejszym niż wywołanie openssl_random_pseudo_bytes tylko raz

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