PHP willekeurige stringgenerator

Ik probeer een willekeurige string in PHP te maken, en ik krijg hier absoluut geen uitvoer mee:

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

Wat doe ik verkeerd?


Antwoord 1, autoriteit 100%

Om deze vraag specifiek te beantwoorden, twee problemen:

  1. $randstringvalt niet binnen het bereik als je het herhaalt.
  2. De karakters worden niet samengevoegd in de lus.

Hier is een codefragment met de correcties:

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

Voer de willekeurige tekenreeks uit met de onderstaande oproep:

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

Houd er rekening mee dat dit voorspelbare willekeurige reeksen genereert. Als je veilige tokens wilt maken, zie dit antwoord.


Antwoord 2, autoriteit 26%

Opmerking: str_shuffle()gebruikt intern rand(), wat niet geschikt is voor cryptografie (bijv. het genereren van willekeurige wachtwoorden). U wilt in plaats daarvan een beveiligde generator voor willekeurige getallen. Het staat ook niet toe dat tekens worden herhaald.

Nog een manier.

GE-UPDATE(nu genereert dit elke lengte van een string):

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

Dat is het. 🙂


Antwoord 3, autoriteit 25%

Er zijn veel antwoorden op deze vraag, maar geen enkele maakt gebruik van een Cryptografisch beveiligde pseudo-willekeurige nummergenerator(CSPRNG).

Het eenvoudige, veilige en juiste antwoord is om RandomLibte gebruiken en het wiel niet opnieuw uit te vinden.

Voor degenen onder u die erop staan uw eigen oplossing te bedenken, biedt PHP 7.0.0 random_int()voor dit doel; als je nog steeds PHP 5.x gebruikt, hebben we een PHP 5 polyfill geschreven voor random_int()zodat u de nieuwe API kunt gebruiken nog voordat u een upgrade naar PHP 7 uitvoert.

Veilig willekeurige gehele getallen genereren in PHPis geen triviale taak. Neem altijd contact op met uw lokale StackExchange cryptografie-expertsvoordat u een zelf ontwikkeld algoritme in productie gaat nemen.

Met een veilige generator voor gehele getallen is het genereren van een willekeurige reeks met een CSPRNG een fluitje van een cent.

Een veilige, willekeurige reeks maken

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

Gebruik:

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

Demo: https://3v4l.org/IMJGF(Negeer de PHP 5 fouten; het heeft random_compat nodig)


Antwoord 4, autoriteit 11%

Hierdoor ontstaat een hexadecimale tekenreeks van 20 tekens:

$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

Antwoord 5, autoriteit 7%

@tasmaniski: je antwoord werkte voor mij. Ik had hetzelfde probleem, en ik zou het aanraden voor degenen die ooit op zoek zijn naar hetzelfde antwoord. Hier is het van @tasmaniski:

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

Hier is een youtube-video die ons laat zien hoe we een willekeurig getal kunnen maken


Antwoord 6, autoriteit 3%

Afhankelijk van uw toepassing (ik wilde wachtwoorden genereren), zou u kunnen gebruiken

$string = base64_encode(openssl_random_pseudo_bytes(30));

Omdat ze base64 zijn, kunnen ze =of -bevatten, evenals de gevraagde tekens. Je zou een langere string kunnen genereren, deze vervolgens filteren en inkorten om die te verwijderen.

openssl_random_pseudo_byteslijkt de aanbevolen manier te zijn om een correct willekeurig getal in php te genereren. Waarom rand/dev/randomniet gebruikt, weet ik niet.


Antwoord 7, autoriteit 2%

Hier is een eenvoudige one-liner die een echte willekeurige string genereert zonder enige lus op scriptniveau of gebruik van OpenSSL-bibliotheken.

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

Om het op te splitsen zodat de parameters duidelijk zijn

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

Deze methode werkt door willekeurig de tekenlijst te herhalen, vervolgens de gecombineerde tekenreeks te schudden en het opgegeven aantal tekens terug te geven.

Je kunt dit verder willekeurig maken door de lengte van de geretourneerde tekenreeks willekeurig te maken en $chrRandomLengthte vervangen door mt_rand(8, 15)(voor een willekeurige tekenreeks tussen 8 en 15 tekens).


Antwoord 8, autoriteit 2%

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

Tada!


Antwoord 9, autoriteit 2%

Een betere manier om deze functie te implementeren is:

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_randis meer willekeurig volgens dit en dit in php & nbsp; 7. De randFunctie is een alias van mt_rand.


10, Autoriteit 2%

PHP 7 + Genereer cryptografisch veilig willekeurige bytes met Random_Bytes functie.

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

mogelijke uitvoer

DA821217E61E33ED4B2DD96F8439056C

PHP 5.3 + Genereer pseudo-willekeurige bytes met OpenSSL_RANDOM_PSEUDO_BYTES FUNCTION.

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

mogelijke uitvoer

E2D1254506FBB6CD842CD640333214AD

De Beste gebruiksbehuizing kan

zijn

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

Mogelijke uitvoer

ba8cc342bdf91143


Antwoord 11

$randstringin het functiebereik is niet hetzelfde als het bereik waar je het aanroept. U moet de retourwaarde toewijzen aan een variabele.

$randstring = RandomString();
echo $randstring;

Of herhaal gewoon direct de retourwaarde:

echo RandomString();

Ook in je functie heb je een klein foutje. Binnen de for-lus moet je .=gebruiken, zodat elk teken aan de tekenreeks wordt toegevoegd. Door =te gebruiken, overschrijft u het met elk nieuw teken in plaats van toe te voegen.

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

Antwoord 12

Eerst definieert u het alfabet dat u wilt gebruiken:

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

Gebruik vervolgens openssl_random_pseudo_bytes()om de juiste willekeurige gegevens te genereren:

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

Ten slotte gebruikt u deze willekeurige gegevens om het wachtwoord te maken. Omdat elk teken in $randomchr(0)tot chr(255)kan zijn, gebruikt de code de rest na deling van de ordinale waarde met $alphabet_lengthom ervoor te zorgen dat alleen tekens uit het alfabet worden gekozen (merk op dat dit de willekeur vertekent):

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

Als alternatief, en over het algemeen beter, is het gebruik van RandomLiben SecurityLib:

use SecurityLib\Strength;
$factory = new RandomLib\Factory;
$generator = $factory->getGenerator(new Strength(Strength::MEDIUM));
$password = $generator->generateString(12, $alphabet);

Antwoord 13

Ik heb de prestaties van de meest populaire functies daar getest, de tijd die nodig is om 1.000.000 strings van 32 symbolen op mijn box te genereren is:

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

Let op: het is niet belangrijk hoe lang het duurt, maar wat langzamer is en welke sneller is, zodat u kunt selecteren volgens uw vereisten, waaronder cryptografie-gereedheid enz.

Substr () Rond MD5 is toegevoegd omwille van de nauwkeurigheid als u een reeks nodig heeft die korter is dan 32 symbolen.

Omwille van het antwoord: de tekenreeks was niet aangeconcerenteerd, maar overschreven en het resultaat van de functie is niet opgeslagen.


14

korte methoden ..

Hier zijn een kortste methode om de willekeurige string

te genereren

<?php
echo $my_rand_strng = substr(str_shuffle("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), -15); 
echo substr(md5(rand()), 0, 7);
echo str_shuffle(MD5(microtime()));
?>

15

Een zeer snelle manier is om iets te doen als:

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

Hiermee genereert u een willekeurige reeks met de lengte van 10 tekens. Natuurlijk kunnen sommigen zeggen dat het een beetje zwaarder is op de kanten, maar tegenwoordig zijn processors geoptimaliseerd om heel snel MD5- of SHA256-algoritme uit te voeren. En natuurlijk, als de rand()-functie dezelfde waarde retourneert, is het resultaat hetzelfde, met een kans op 1/32767 om hetzelfde te zijn. Als de beveiliging het probleem is, wijzigt u gewoon rand()naar mt_rand()


16

Hier is mijn eenvoudige oplossing voor Ă©Ă©n regel om een ​​gebruiksvriendelijk willekeurig wachtwoord te genereren, met uitzondering van de tekens die lookalike zoals “1” en “L”, “O” en “0”, enz … hier is 5 tekens, maar U kunt het uiteraard eenvoudig wijzigen:

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

17

Helperfunctie van Laravel 5 Framework

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

18

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

19

Deze is genomen van administratiebronnen :

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

administratie , database management tool geschreven in PHP.


20

Sinds PHP7 is er de Random_Bytes-functies.
https://www.php.net/Manual/ru/function.Random -bytes.php
U kunt dus een willekeurige reeks genereren

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

21

Vanaf het YII2-framework

/**
 * Generates a random string of specified length.
 * The string generated matches [A-Za-z0-9_-]+ and is transparent to URL-encoding.
 *
 * @param int $length the length of the key in characters
 * @return string the generated random key
 */
function generateRandomString($length = 10) {
    $bytes = random_bytes($length);
    return substr(strtr(base64_encode($bytes), '+/', '-_'), 0, $length);
}

22

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

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


23

De bewerkte versie van de functie werkt prima, maar er is slechts Ă©Ă©n probleem dat ik heb gevonden: je hebt het verkeerde teken gebruikt om $ tekens bij te sluiten, dus het ‘teken is soms een deel van de willekeurige reeks die wordt gegenereerd.

Om dit te verhelpen, verandert u:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

naar:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

Op deze manier worden alleen de bijgevoegde tekens gebruikt en het ‘teken zal nooit deel uitmaken van de willekeurige reeks die wordt gegenereerd.


24

Nog een oneliner, die een willekeurige reeks van 10 tekens met letters en cijfers genereert. Het maakt een array met range(pas de tweede parameter aan om de grootte in te stellen), loopt over deze array en wijst een willekeurig ASCII-teken toe (bereik 0-9 of az), en implodeert vervolgens de array om te krijgen een tekenreeks.

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

Opmerking: dit werkt alleen in PHP 5.3 en hoger


Antwoord 25

EĂ©n voering.

Het is snel voor enorme snaren met enige uniciteit.

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

Antwoord 26

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

Antwoord 27

Ik vond de laatste opmerking die openssl_random_pseudo_bytes gebruikte leuk, maar het was geen oplossing voor mij omdat ik nog steeds de tekens moest verwijderen die ik niet wilde, en ik kon geen string met een vaste lengte krijgen. Hier is mijn oplossing…

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

Antwoord 28

Hier is hoe ik het doe om een echte unieke willekeurige sleutel te krijgen:

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

U kunt tijd () gebruiken, omdat het een UNIX-tijdstempel is en altijd uniek is in vergelijking met andere willekeurige hierboven genoemde. U kunt dan het MD5SUM van dat genereren en de gewenste lengte nemen die u nodig hebt van de gegenereerde MD5 string. In dit geval gebruik ik 10 tekens, en ik zou een langere string kunnen gebruiken als ik het unieker wil maken.

Ik hoop dat dit helpt.


29

Een andere manier om een ​​willekeurige reeks in PHP te genereren is:

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

Other episodes