J'essaie de créer une chaîne aléatoire en PHP, et je n'obtiens absolument aucune sortie avec ceci:

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

    RandomString();
    echo $randstring;

Qu'est-ce que je fais mal?

Pour répondre spécifiquement à cette question, deux problèmes:

1. $randstring n'est pas dans la portée lorsque vous l'écho.
2. Les personnages ne sont pas concaténés ensemble dans la boucle.

Voici un extrait de code avec les corrections:

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

Sortez la chaîne aléatoire avec l'appel ci-dessous:

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

Veuillez noter que cela génère des chaînes aléatoires prévisibles. Si vous souhaitez créer des jetons sécurisés, consultez cette réponse .

Remarque: str_shuffle()utilise en interne rand(), ce qui ne convient pas à des fins de cryptographie (par exemple, générer des mots de passe aléatoires). Vous voulez plutôt un générateur de nombres aléatoires sécurisé . Il ne permet pas non plus aux personnages de se répéter.

Encore une façon.

MISE À JOUR (maintenant cela génère n'importe quelle longueur de chaîne):

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

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

C'est ça. :)

Il existe de nombreuses réponses à cette question, mais aucune d'entre elles ne tire parti d'un générateur de nombres pseudo-aléatoires cryptographiquement sécurisé (CSPRNG).

La réponse simple, sûre et correcte consiste à utiliser RandomLib et à ne pas réinventer la roue.

Pour ceux d'entre vous qui insistent pour inventer votre propre solution, PHP 7.0.0 fournira random_int()à cet effet; si vous êtes toujours sur PHP 5.x, nous avons écrit un polyfill PHP 5 pourrandom_int() que vous puissiez utiliser la nouvelle API avant même de passer à PHP 7.

Générer en toute sécurité des nombres entiers aléatoires en PHP n'est pas une tâche triviale. Vous devriez toujours vérifier avec vos experts en cryptographie StackExchange résidents avant de déployer un algorithme local en production.

Avec un générateur d'entiers sécurisé en place, générer une chaîne aléatoire avec un CSPRNG est une promenade dans le parc.

Création d'une chaîne aléatoire et sécurisée

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

Utilisation :

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

Démo : https://3v4l.org/IMJGF (Ignorez les échecs de PHP 5; il a besoin de random_compat)

Cela crée une chaîne hexadécimale longue de 20 caractères:

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

En 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: votre réponse a fonctionné pour moi. J'ai eu le même problème, et je le proposerais à ceux qui recherchent toujours la même réponse. Le voici de @tasmaniski:

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

Voici une vidéo sur YouTube nous montrant comment créer un nombre aléatoire

Selon votre application (je voulais générer des mots de passe), vous pouvez utiliser

$string = base64_encode(openssl_random_pseudo_bytes(30));

Étant base64, ils peuvent contenir =ou -aussi bien que les caractères demandés. Vous pouvez générer une chaîne plus longue, puis la filtrer et la couper pour la supprimer.

openssl_random_pseudo_bytessemble être le moyen recommandé pour générer un nombre aléatoire approprié en php. Pourquoi randn'utilise pas /dev/randomje ne sais pas.

Voici une simple ligne qui génère une vraie chaîne aléatoire sans aucune boucle de niveau de script ni utilisation de bibliothèques OpenSSL.

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

Pour le décomposer afin que les paramètres soient clairs

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

Cette méthode fonctionne en répétant au hasard la liste des caractères, puis mélange la chaîne combinée et renvoie le nombre de caractères spécifié.

Vous pouvez encore randomiser cela, en randomisant la longueur de la chaîne retournée, en la remplaçant $chrRandomLengthpar mt_rand(8, 15)(pour une chaîne aléatoire entre 8 et 15 caractères).

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

Tada!

Une meilleure façon de mettre en œuvre cette fonction est:

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_randest plus aléatoire selon ceci et cela en PHP 7. La randfonction est un alias de mt_rand.

$randstringdans la portée de la fonction n'est pas la même que celle où vous l'appelez. Vous devez affecter la valeur de retour à une variable.

$randstring = RandomString();
echo $randstring;

Ou faites simplement écho à la valeur de retour:

echo RandomString();

De plus, dans votre fonction, vous avez une petite erreur. Dans la boucle for, vous devez utiliser .=pour que chaque caractère soit ajouté à la chaîne. En l'utilisant, =vous l'écrasez avec chaque nouveau caractère au lieu de l'ajouter.

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

Tout d'abord, vous définissez l'alphabet que vous souhaitez utiliser:

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

Ensuite, utilisez openssl_random_pseudo_bytes()pour générer des données aléatoires appropriées:

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

Enfin, vous utilisez ces données aléatoires pour créer le mot de passe. Étant donné que chaque caractère $randompeut être chr(0)jusqu'à chr(255), le code utilise le reste après la division de sa valeur ordinale avec $alphabet_lengthpour s'assurer que seuls les caractères de l'alphabet sont sélectionnés (notez que cela faussera le caractère aléatoire):

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

Alternativement, et généralement mieux, utilisez RandomLib et SecurityLib :

use SecurityLib\Strength;

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

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

Méthodes courtes ..

Voici la méthode la plus courte pour générer la chaîne aléatoire

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

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

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

J'y ai testé les performances des fonctions les plus populaires, le temps nécessaire pour générer 1'000'000 chaînes de 32 symboles sur ma box est:

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

Veuillez noter qu'il n'est pas important de savoir combien de temps il a réellement duré, mais lequel est plus lent et lequel est plus rapide afin que vous puissiez sélectionner en fonction de vos besoins, y compris la préparation à la cryptographie, etc.

substr () autour de MD5 a été ajouté par souci de précision si vous avez besoin d'une chaîne de moins de 32 symboles.

Par souci de réponse: la chaîne n'a pas été concaténée mais écrasée et le résultat de la fonction n'a pas été stocké.

PHP 7+ Générez des octets aléatoires cryptographiquement sécurisés à l'aide de la fonction random_bytes .

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

Sortie possible

da821217e61e33ed4b2dd96f8439056c

PHP 5.3+ Générez des octets pseudo-aléatoires en utilisant la fonction openssl_random_pseudo_bytes .

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

Sortie possible

e2d1254506fbb6cd842cd640333214ad

Le meilleur cas d'utilisation pourrait être

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

Sortie possible

ba8cc342bdf91143

Un moyen très rapide est de faire quelque chose comme:

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

Cela générera une chaîne aléatoire d'une longueur de 10 caractères. Bien sûr, certains pourraient dire que c'est un peu plus lourd du côté du calcul, mais de nos jours les processeurs sont optimisés pour exécuter l'algorithme md5 ou sha256 très rapidement. Et bien sûr, si la rand()fonction renvoie la même valeur, le résultat sera le même, avec 1/32767 chance d'être le même. Si la sécurité est le problème, passez simplement rand()àmt_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;
}

Celui-ci a été tiré de sources d'administrateur :

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

Administrateur , outil de gestion de base de données écrit en PHP.

Fonction d'aide du 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);
}

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

La version modifiée de la fonction fonctionne très bien, mais j'ai trouvé un seul problème: vous avez utilisé le mauvais caractère pour entourer les caractères $, de sorte que le caractère 'fait parfois partie de la chaîne aléatoire qui est générée.

Pour résoudre ce problème, modifiez:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

à:

$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

De cette façon, seuls les caractères inclus sont utilisés et le caractère 'ne fera jamais partie de la chaîne aléatoire générée.

Un autre à une ligne, qui génère une chaîne aléatoire de 10 caractères avec des lettres et des chiffres. Il créera un tableau avec range(ajustez le deuxième paramètre pour définir la taille), boucle sur ce tableau et attribue un caractère ASCII aléatoire (plage 0-9 ou az), puis implose le tableau pour obtenir une chaîne.

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

Remarque: cela ne fonctionne qu'en PHP 5.3 et versions ultérieures

Bon mot.

Il est rapide pour les énormes cordes avec un certain caractère unique.

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

Depuis php7, il y a les fonctions random_bytes. https://www.php.net/manual/ru/function.random-bytes.php Vous pouvez donc générer une chaîne aléatoire comme celle-ci

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

J'ai aimé le dernier commentaire qui a utilisé openssl_random_pseudo_bytes, mais ce n'était pas une solution pour moi car je devais encore supprimer les caractères que je ne voulais pas, et je n'ai pas pu obtenir une chaîne de longueur définie. Voici ma solution ...

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

Voici ma solution simple en une ligne pour générer un mot de passe aléatoire convivial, excluant les caractères qui se ressemblent tels que "1" et "l", "O" et "0", etc ... ici, c'est 5 caractères mais vous pouvez facilement changez-le bien sûr:

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

Voici une autre solution.

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. J'utilise PHP 7.2 sur Ubuntu.

Une autre façon de générer une chaîne aléatoire en PHP est:

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

Voici comment je le fais pour obtenir une véritable clé aléatoire unique:

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

Vous pouvez utiliser time () car il s'agit d'un horodatage Unix et est toujours unique par rapport aux autres aléatoires mentionnés ci-dessus. Vous pouvez ensuite générer la somme md5 de cela et prendre la longueur souhaitée dont vous avez besoin à partir du MD5 généré chaîne . Dans ce cas, j'utilise 10 caractères et je pourrais utiliser une chaîne plus longue si je veux la rendre plus unique.

J'espère que ça aide.

One-liner paramétré utilisant uniquement des fonctions natives PHP , fonctionnant depuis 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))))))