Sto cercando di creare una stringa randomizzata in PHP e non ottengo assolutamente alcun output con questo:

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

    RandomString();
    echo $randstring;

Che cosa sto facendo di sbagliato?

Per rispondere specificamente a questa domanda, due problemi:

1. $randstring non rientra nell'ambito quando lo si fa eco.
2. I personaggi non vengono concatenati insieme nel loop.

Ecco uno snippet di codice con le correzioni:

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

Emetti la stringa casuale con la chiamata seguente:

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

Si noti che ciò genera stringhe casuali prevedibili. Se vuoi creare token sicuri, vedi questa risposta .

Nota: str_shuffle()utilizza internamente rand(), che non è adatto a scopi di crittografia (ad es. Generazione di password casuali). Si desidera invece un generatore di numeri casuali sicuro . Inoltre, non consente ai personaggi di ripetere.

Un altro modo.

AGGIORNATO (ora questo genera qualsiasi lunghezza di stringa):

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

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

Questo è tutto. :)

Ci sono molte risposte a questa domanda, ma nessuna di esse sfrutta un generatore di numeri pseudo-casuali crittograficamente sicuro (CSPRNG).

La risposta semplice, sicura e corretta è usare RandomLib e non reinventare la ruota.

Per quelli di voi che insistono nell'inventare la propria soluzione, PHP 7.0.0 fornirà random_int()a tale scopo; se sei ancora su PHP 5.x, abbiamo scritto un polyfill per PHP 5 inrandom_int() modo da poter utilizzare la nuova API anche prima di eseguire l'aggiornamento a PHP 7.

Generare in modo sicuro numeri interi casuali in PHP non è un compito banale. È sempre necessario verificare con gli esperti di crittografia StackExchange residenti prima di distribuire un algoritmo di produzione domestica.

Con un generatore di numeri interi sicuro installato, generare una stringa casuale con un CSPRNG è una passeggiata nel parco.

Creazione di una stringa sicura e casuale

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

Utilizzo :

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

Demo : https://3v4l.org/IMJGF (Ignora gli errori PHP 5; ha bisogno di random_compat)

Questo crea una stringa esadecimale lunga 20 caratteri:

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

In 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: la tua risposta ha funzionato per me. Ho avuto lo stesso problema e lo consiglierei a coloro che sono sempre alla ricerca della stessa risposta. Eccolo da @tasmaniski:

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

Ecco un video di YouTube che ci mostra come creare un numero casuale

A seconda della tua applicazione (volevo generare password), potresti usarla

$string = base64_encode(openssl_random_pseudo_bytes(30));

Essendo base64, possono contenere =o -anche i caratteri richiesti. È possibile generare una stringa più lunga, quindi filtrarla e tagliarla per rimuoverla.

openssl_random_pseudo_bytessembra essere il modo consigliato per generare un numero casuale corretto in php. Perché randnon lo uso /dev/random, non lo so.

Ecco un semplice one-liner che genera una vera stringa casuale senza alcun ciclo a livello di script o utilizzo delle librerie OpenSSL.

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

Per scomporlo in modo che i parametri siano chiari

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

Questo metodo funziona ripetendo casualmente l'elenco dei caratteri, quindi mescola la stringa combinata e restituisce il numero di caratteri specificato.

Puoi randomizzare ulteriormente questo, randomizzando la lunghezza della stringa restituita, sostituendola $chrRandomLengthcon mt_rand(8, 15)(per una stringa casuale compresa tra 8 e 15 caratteri).

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

Tada!

Un modo migliore per implementare questa funzione è:

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_randè più casuale secondo questo e questo in PHP 7. La randfunzione è un alias di mt_rand.

$randstringnell'ambito della funzione non è uguale all'ambito in cui viene chiamato. Devi assegnare il valore restituito a una variabile.

$randstring = RandomString();
echo $randstring;

O rispondi direttamente al valore di ritorno:

echo RandomString();

Inoltre, nella tua funzione hai un piccolo errore. All'interno del ciclo for, è necessario utilizzare in .=modo che ogni carattere venga aggiunto alla stringa. Usandolo =stai sovrascrivendolo con ogni nuovo personaggio invece di aggiungerlo.

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

Innanzitutto, definisci l'alfabeto che desideri utilizzare:

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

Quindi, utilizzare openssl_random_pseudo_bytes()per generare dati casuali corretti:

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

Infine, usi questi dati casuali per creare la password. Poiché ogni carattere in $randompuò essere chr(0)fino a chr(255), il codice utilizza il resto dopo la divisione del suo valore ordinale con $alphabet_lengthper assicurarsi che vengano scelti solo i caratteri dell'alfabeto (notare che in questo modo si distorce la casualità):

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

In alternativa, e generalmente meglio, è usare RandomLib e SecurityLib :

use SecurityLib\Strength;

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

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

Metodi brevi ..

Ecco alcuni dei metodi più brevi per generare la stringa casuale

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

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

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

Ho testato le prestazioni delle funzioni più popolari lì, il tempo necessario per generare 1'000'000 stringhe di 32 simboli sulla mia scatola è:

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

Si noti che non è importante quanto tempo è stato, ma quale è più lento e quale è più veloce, quindi è possibile selezionare in base alle proprie esigenze, tra cui la predisposizione alla crittografia, ecc.

substr () attorno a MD5 è stato aggiunto per maggiore precisione se è necessaria una stringa più corta di 32 simboli.

Per ragioni di risposta: la stringa non è stata concatenata ma sovrascritta e il risultato della funzione non è stato memorizzato.

PHP 7+ Genera byte casuali crittograficamente sicuri usando la funzione random_bytes .

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

Uscita possibile

da821217e61e33ed4b2dd96f8439056c

PHP 5.3+ Genera byte pseudo-casuali usando la funzione openssl_random_pseudo_bytes .

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

Uscita possibile

e2d1254506fbb6cd842cd640333214ad

Il miglior caso d'uso potrebbe essere

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

Uscita possibile

ba8cc342bdf91143

Un modo molto veloce è fare qualcosa del tipo:

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

Questo genererà una stringa casuale con la lunghezza di 10 caratteri. Naturalmente, alcuni potrebbero dire che è un po 'più pesante dal punto di vista del calcolo, ma oggigiorno i processori sono ottimizzati per eseguire l'algoritmo md5 o sha256 molto rapidamente. E, naturalmente, se la rand()funzione restituisce lo stesso valore, il risultato sarà lo stesso, con una probabilità 1/32767 di essere lo stesso. Se la sicurezza è il problema, basta passare rand()amt_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;
}

Questo è stato preso da fonti di amministrazione :

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

Amministratore , strumento di gestione del database scritto in PHP.

Funzione di supporto dal framework 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);
}

Fonte da http://www.xeweb.net/2011/02/11/generate-a-random-string-az-0-9-in-php/

La versione modificata della funzione funziona bene, ma ho riscontrato solo un problema: hai usato il carattere sbagliato per racchiudere $ caratteri, quindi il carattere a volte fa parte della stringa casuale che viene generata.

Per risolvere questo problema, modifica:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

per:

$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

In questo modo vengono utilizzati solo i caratteri racchiusi e il carattere 'non farà mai parte della stringa casuale generata.

Un altro one-liner, che genera una stringa casuale di 10 caratteri con lettere e numeri. Creerà un array con range(regola il secondo parametro per impostare la dimensione), passa su questo array e assegna un carattere ASCII casuale (intervallo 0-9 o az), quindi implode l'array per ottenere una stringa.

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

Nota: funziona solo in PHP 5.3 e versioni successive

Una fodera

È veloce per stringhe enormi con una certa unicità.

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

Da php7, ci sono le funzioni random_bytes. https://www.php.net/manual/ru/function.random-bytes.php Quindi puoi generare una stringa casuale come quella

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

Mi è piaciuto l'ultimo commento che ha usato openssl_random_pseudo_bytes, ma non è stata una soluzione per me in quanto dovevo ancora rimuovere i caratteri che non volevo e non ero in grado di ottenere una stringa di lunghezza impostata. Ecco la mia soluzione ...

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

Ecco la mia semplice soluzione a una riga per generare una password casuale facile da usare, esclusi i caratteri che assomigliano a "1" e "l", "O" e "0", ecc ... qui ci sono 5 caratteri ma puoi facilmente cambiarlo ovviamente:

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

Ecco un'altra soluzione.

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. Sto usando PHP 7.2 su Ubuntu.

Un altro modo per generare una stringa casuale in PHP è:

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

Ecco come lo sto facendo per ottenere una vera chiave casuale unica:

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

Puoi usare time () poiché è un timestamp Unix ed è sempre unico rispetto ad altri casuali sopra menzionati. È quindi possibile generare il md5sum di quello e prendere la lunghezza desiderata necessaria dalla stringa MD5 generata . In questo caso sto usando 10 caratteri e potrei usare una stringa più lunga se volessi renderlo più unico.

Spero che questo possa essere d'aiuto.

One-liner parametrizzato che utilizza solo funzioni native PHP , funzionante da 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))))))