Próbuję utworzyć losowy ciąg w PHP i nie otrzymuję absolutnie żadnych danych wyjściowych z tym:

<?php
    function RandomString()
    {
        $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
        $randstring = '';
        for ($i = 0; $i < 10; $i++) {
            $randstring = $characters[rand(0, strlen($characters))];
        }
        return $randstring;
    }

    RandomString();
    echo $randstring;

Co ja robię źle?

Aby odpowiedzieć konkretnie na to pytanie, dwa problemy:

1. $randstring nie jest objęty zakresem, gdy go echo.
2. Postacie nie łączą się w pętli.

Oto fragment kodu z poprawkami:

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

Wypisz losowy ciąg za pomocą wywołania poniżej:

// Echo the random string.
// Optionally, you can give it a desired string length.
echo generateRandomString();

Należy pamiętać, że generuje to przewidywalne losowe ciągi. Jeśli chcesz utworzyć bezpieczne tokeny, zapoznaj się z tą odpowiedzią .

Uwaga: str_shuffle()zastosowania wewnętrzne rand(), które nie są odpowiednie do celów kryptograficznych (np. Generowanie losowych haseł). Zamiast tego potrzebujesz bezpiecznego generatora liczb losowych . Nie pozwala również na powtarzanie się znaków.

Jeszcze jeden sposób.

AKTUALIZACJA (teraz generuje dowolną długość łańcucha):

function generateRandomString($length = 10) {
    return substr(str_shuffle(str_repeat($x='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', ceil($length/strlen($x)) )),1,$length);
}

echo  generateRandomString();  // OR: generateRandomString(24)

Otóż ​​to. :)

Istnieje wiele odpowiedzi na to pytanie, ale żadna z nich nie wykorzystuje kryptograficznie bezpiecznego generatora liczb pseudolosowych (CSPRNG).

Prostą, bezpieczną i poprawną odpowiedzią jest użycie RandomLib i nie wymyślanie koła na nowo.

Dla tych z was, którzy nalegają na wymyślenie własnego rozwiązania, PHP 7.0.0 zapewni random_int()w tym celu; jeśli nadal korzystasz z PHP 5.x, napisaliśmy polifill dla PHP 5random_int() , abyś mógł korzystać z nowego API nawet przed uaktualnieniem do PHP 7.

Bezpieczne generowanie losowych liczb całkowitych w PHP nie jest łatwym zadaniem. Zawsze powinieneś skonsultować się z ekspertami w dziedzinie kryptografii StackExchange przed wdrożeniem domowego algorytmu w produkcji.

Dzięki bezpiecznemu generatorowi liczb całkowitych generowanie losowego ciągu za pomocą CSPRNG jest spacerkiem po parku.

Tworzenie bezpiecznego, losowego ciągu

/**
 * Generate a random string, using a cryptographically secure 
 * pseudorandom number generator (random_int)
 *
 * This function uses type hints now (PHP 7+ only), but it was originally
 * written for PHP 5 as well.
 * 
 * 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(
    int $length = 64,
    string $keyspace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
): string {
    if ($length < 1) {
        throw new \RangeException("Length must be a positive integer");
    }
    $pieces = [];
    $max = mb_strlen($keyspace, '8bit') - 1;
    for ($i = 0; $i < $length; ++$i) {
        $pieces []= $keyspace[random_int(0, $max)];
    }
    return implode('', $pieces);
}

Zastosowanie :

$a = random_str(32);
$b = random_str(8, 'abcdefghijklmnopqrstuvwxyz');
$c = random_str();

Demo : https://3v4l.org/IMJGF (Zignoruj ​​awarie PHP 5; wymaga random_compat)

Spowoduje to utworzenie ciągu szesnastkowego o długości 20 znaków:

$string = bin2hex(openssl_random_pseudo_bytes(10)); // 20 chars

W PHP 7 ( random_bytes () ):

$string = base64_encode(random_bytes(10)); // ~14 characters, includes /=+
// or
$string = substr(str_replace(['+', '/', '='], '', base64_encode(random_bytes(32))), 0, 32); // 32 characters, without /=+
// or
$string = bin2hex(random_bytes(10)); // 20 characters, only 0-9a-f

@tasmaniski: twoja odpowiedź zadziałała dla mnie. Miałem ten sam problem i sugerowałbym go tym, którzy kiedykolwiek szukają tej samej odpowiedzi. Oto z @tasmaniski:

<?php 
    $random = substr(md5(mt_rand()), 0, 7);
    echo $random;
?>

Oto film z YouTube pokazujący, jak utworzyć losową liczbę

W zależności od aplikacji (chciałem generować hasła) możesz użyć

$string = base64_encode(openssl_random_pseudo_bytes(30));

Będąc base64, mogą zawierać =lub- żądane znaki. Możesz wygenerować dłuższy ciąg, a następnie filtrować i przycinać go, aby je usunąć.

openssl_random_pseudo_byteswydaje się być zalecanym sposobem na wygenerowanie odpowiedniej liczby losowej w php. Dlaczego randnie używa? /dev/randomNie wiem.

Oto prosty jednowierszowy, który generuje prawdziwy losowy ciąg bez zapętlania poziomu skryptu lub korzystania z bibliotek OpenSSL.

echo substr(str_shuffle(str_repeat('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', mt_rand(1,10))), 1, 10);

Aby go rozbić, aby parametry były jasne

// Character List to Pick from
$chrList = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

// Minimum/Maximum times to repeat character List to seed from
$chrRepeatMin = 1; // Minimum times to repeat the seed string
$chrRepeatMax = 10; // Maximum times to repeat the seed string

// Length of Random String returned
$chrRandomLength = 10;

// The ONE LINE random command with the above variables.
echo substr(str_shuffle(str_repeat($chrList, mt_rand($chrRepeatMin,$chrRepeatMax))), 1, $chrRandomLength);

Ta metoda polega na losowym powtarzaniu listy znaków, a następnie tasuje połączony ciąg znaków i zwraca określoną liczbę znaków.

Możesz dalej losować to, losując długość zwracanego ciągu, zastępując $chrRandomLengthgo mt_rand(8, 15)(dla losowego ciągu od 8 do 15 znaków).

function generateRandomString($length = 15)
{
    return substr(sha1(rand()), 0, $length);
}

Tada!

Lepszym sposobem na wdrożenie tej funkcji jest:

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

    $key = "";
    for($i=0; $i < $length; $i++) {
        $key .= $keys[mt_rand(0, count($keys) - 1)];
    }
    return $key;
}

echo RandomString(20);

mt_randjest bardziej losowy zgodnie z tym i tym w PHP 7. randFunkcja jest aliasem mt_rand.

$randstringzakres funkcji nie jest taki sam jak zakres, w którym go wywołujesz. Musisz przypisać wartość zwracaną do zmiennej.

$randstring = RandomString();
echo $randstring;

Lub po prostu echo zwracanej wartości:

echo RandomString();

Również w swojej funkcji masz mały błąd. W pętli for należy użyć, .=aby każdy znak był dołączany do ciągu. Korzystając z niego =, zastępujesz go każdą nową postacią zamiast dodawać.

$randstring .= $characters[rand(0, strlen($characters))];

Najpierw określ alfabet, którego chcesz użyć:

$alphanum = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
$special  = '~!@#$%^&*(){}[],./?';
$alphabet = $alphanum . $special;

Następnie użyj openssl_random_pseudo_bytes()do wygenerowania odpowiednich danych losowych:

$len = 12; // length of password
$random = openssl_random_pseudo_bytes($len);

Wreszcie, wykorzystujesz te losowe dane, aby utworzyć hasło. Ponieważ każdy znak $randommoże być chr(0)do chr(255), kod używa reszty po podzieleniu jego wartości porządkowej, $alphabet_lengthaby upewnić się, że wybierane są tylko znaki z alfabetu (pamiętaj, że w ten sposób wpływa to na losowość):

$alphabet_length = strlen($alphabet);
$password = '';
for ($i = 0; $i < $len; ++$i) {
    $password .= $alphabet[ord($random[$i]) % $alphabet_length];
}

Alternatywnie i ogólnie lepiej jest użyć RandomLib i SecurityLib :

use SecurityLib\Strength;

$factory = new RandomLib\Factory;
$generator = $factory->getGenerator(new Strength(Strength::MEDIUM));

$password = $generator->generateString(12, $alphabet);

Krótkie metody ..

Oto kilka najkrótszych metod generowania losowego ciągu

<?php
echo $my_rand_strng = substr(str_shuffle("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), -15); 

echo substr(md5(rand()), 0, 7);

echo str_shuffle(MD5(microtime()));
?>

Testowałem tam wydajność najpopularniejszych funkcji, czas potrzebny do wygenerowania 1 000 000 ciągów 32 symboli na moim urządzeniu to:

2.5 $s = substr(str_shuffle(str_repeat($x='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', ceil($length/strlen($x)) )),1,32);
1.9 $s = base64_encode(openssl_random_pseudo_bytes(24));
1.68 $s = bin2hex(openssl_random_pseudo_bytes(16));
0.63 $s = base64_encode(random_bytes(24));
0.62 $s = bin2hex(random_bytes(16));
0.37 $s = substr(md5(rand()), 0, 32);
0.37 $s = substr(md5(mt_rand()), 0, 32);

Należy pamiętać, że nie jest ważne, jak naprawdę to było, ale które jest wolniejsze, a które jest szybsze, dzięki czemu można wybrać zgodnie z wymaganiami, w tym gotowość do kryptografii itp.

substr () wokół MD5 został dodany ze względu na dokładność, jeśli potrzebujesz łańcucha, który jest krótszy niż 32 symbole.

W odpowiedzi: ciąg nie został połączony, ale nadpisany, a wynik funkcji nie został zapisany.

PHP 7+ Generuj kryptograficznie bezpieczne losowe bajty za pomocą funkcji random_bytes .

$bytes = random_bytes(16);
echo bin2hex($bytes);

Możliwe wyjście

da821217e61e33ed4b2dd96f8439056c

PHP 5.3+ Generuj pseudolosowe bajty za pomocą funkcji openssl_random_pseudo_bytes .

$bytes = openssl_random_pseudo_bytes(16);
echo bin2hex($bytes);

Możliwe wyjście

e2d1254506fbb6cd842cd640333214ad

Najlepszy przypadek użycia może być

function getRandomBytes($length = 16)
{
    if (function_exists('random_bytes')) {
        $bytes = random_bytes($length / 2);
    } else {
        $bytes = openssl_random_pseudo_bytes($length / 2);
    }
    return bin2hex($bytes);
}
echo getRandomBytes();

Możliwe wyjście

ba8cc342bdf91143

Jednym bardzo szybkim sposobem jest zrobienie czegoś takiego:

substr(md5(rand()),0,10);

To wygeneruje losowy ciąg o długości 10 znaków. Oczywiście, niektórzy mogą powiedzieć, że jest nieco bardziej obciążony po stronie obliczeniowej, ale obecnie procesory są zoptymalizowane do szybkiego uruchamiania algorytmu md5 lub sha256. I oczywiście, jeśli rand()funkcja zwróci tę samą wartość, wynik będzie taki sam, z szansą 1/32767 na bycie takim samym. Jeśli problemem są zabezpieczenia, po prostu zmień rand()namt_rand()

function rndStr($len = 64) {
     $randomData = file_get_contents('/dev/urandom', false, null, 0, $len) . uniqid(mt_rand(), true);
     $str = substr(str_replace(array('/','=','+'),'', base64_encode($randomData)),0,$len);
    return $str;
}

Ten został pobrany ze źródeł administratora :

/** Get a random string
* @return string 32 hexadecimal characters
*/
function rand_string() {
    return md5(uniqid(mt_rand(), true));
}

Administrator , narzędzie do zarządzania bazami danych napisane w PHP.

Funkcja pomocnicza z frameworka Laravel 5

/**
 * Generate a "random" alpha-numeric string.
 *
 * Should not be considered sufficient for cryptography, etc.
 *
 * @param  int  $length
 * @return string
 */
function str_random($length = 16)
{
    $pool = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

    return substr(str_shuffle(str_repeat($pool, $length)), 0, $length);
}

/**
 * @param int $length
 * @param string $abc
 * @return string
 */
function generateRandomString($length = 10, $abc = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
{
    return substr(str_shuffle($abc), 0, $length);
}

Źródło: http://www.xeweb.net/2011/02/11/generate-a-random-string-az-0-9-in-php/

Zmodyfikowana wersja funkcji działa dobrze, ale znalazłem tylko jeden problem: użyłeś niewłaściwego znaku do umieszczenia znaków $, więc znak „jest czasem częścią generowanego ciągu losowego.

Aby to naprawić, zmień:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

do:

$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

W ten sposób używane są tylko zamknięte znaki, a znak „nigdy nie będzie częścią generowanego ciągu losowego.

Kolejna linijka, która generuje losowy ciąg 10 znaków z literami i cyframi. Utworzy tablicę za pomocą range(dostosuje drugi parametr, aby ustawić rozmiar), zapętli tę tablicę i przypisze losowy znak ASCII (zakres 0-9 lub az), a następnie wszczepi tablicę w celu uzyskania łańcucha.

$str = implode('', array_map(function () { return chr(rand(0, 1) ? rand(48, 57) : rand(97, 122)); }, range(0, 9)));

Uwaga: działa to tylko w PHP 5.3 i nowszych

Jedna wkładka.

Jest szybki dla ogromnych strun z pewną wyjątkowością.

function random_string($length){
    return substr(str_repeat(md5(rand()), ceil($length/32)), 0, $length);
}

Od php7 istnieją funkcje random_bytes. https://www.php.net/manual/ru/function.random-bytes.php Abyś mógł wygenerować taki ciąg losowy

<?php
$bytes = random_bytes(5);
var_dump(bin2hex($bytes));
?>

Podobał mi się ostatni komentarz, który używał openssl_random_pseudo_bytes, ale nie było to dla mnie rozwiązaniem, ponieważ wciąż musiałem usuwać znaki, których nie chciałem, i nie byłem w stanie uzyskać łańcucha o ustalonej długości. Oto moje rozwiązanie ...

function rndStr($len = 20) {
    $rnd='';
    for($i=0;$i<$len;$i++) {
        do {
            $byte = openssl_random_pseudo_bytes(1);
            $asc = chr(base_convert(substr(bin2hex($byte),0,2),16,10));
        } while(!ctype_alnum($asc));
        $rnd .= $asc;
    }
    return $rnd;
}

function randomString($length = 5) {
    return substr(str_shuffle(implode(array_merge(range('A','Z'), range('a','z'), range(0,9)))), 0, $length);
}

Oto moje proste jednoliniowe rozwiązanie do generowania przyjaznego losowego hasła, z wyłączeniem znaków, które wyglądają podobnie, jak „1” i „l”, „O” i „0” itd.… Tutaj jest 5 znaków, ale możesz łatwo zmień to oczywiście:

$user_password = substr(str_shuffle('abcdefghjkmnpqrstuvwxyzABCDEFGHJKMNPQRSTUVWXYZ23456789'),0,5);

Oto inne rozwiązanie.

function genRandomString($length = 10)
{
    if($length < 1)
        $length = 1;
    return substr(preg_replace("/[^A-Za-z0-9]/", '', base64_encode(openssl_random_pseudo_bytes($length * 2))), 0, $length);
}

PS. Używam PHP 7.2 na Ubuntu.

Innym sposobem generowania losowego ciągu w PHP jest:

function RandomString($length) {
    $original_string = array_merge(range(0,9), range('a','z'), range('A', 'Z'));
    $original_string = implode("", $original_string);
    return substr(str_shuffle($original_string), 0, $length);
}
echo RandomString(6);

Oto jak to zrobić, aby uzyskać prawdziwy unikalny losowy klucz:

$Length = 10;
$RandomString = substr(str_shuffle(md5(time())), 0, $Length);
echo $RandomString;

Możesz użyć time (), ponieważ jest to uniksowy znacznik czasu i zawsze jest unikalny w porównaniu z innymi losowymi wymienionymi powyżej. Następnie możesz wygenerować sumę md5 i pobrać żądaną długość z wygenerowanego MD5 ciągu . W tym przypadku używam 10 znaków i mógłbym użyć dłuższego łańcucha, jeśli chciałbym, aby był bardziej unikalny.

Mam nadzieję, że to pomoże.

Sparametryzowany jednowierszowy, wykorzystujący tylko natywne funkcje PHP , działający od PHP 5.1.0

str_shuffle(implode('', (array_intersect_key(($map =  array_map('chr', array_merge(array_map('mt_rand', array_fill(0, $length = 25, 48), array_fill(0,$length,57)),array_map('mt_rand', array_fill(0, $length, 65), array_fill(0,$length,90)),array_map('mt_rand', array_fill(0, $length, 97), array_fill(0,$length,122))))), array_flip($keys = array_rand($map, $length))))))