Ich versuche, eine zufällige Zeichenfolge in PHP zu erstellen, und ich erhalte damit absolut keine Ausgabe:

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

    RandomString();
    echo $randstring;

Was mache ich falsch?

Um diese Frage speziell zu beantworten, zwei Probleme:

1. $randstring ist nicht im Geltungsbereich, wenn Sie es wiederholen.
2. Die Zeichen werden in der Schleife nicht miteinander verkettet.

Hier ist ein Code-Snippet mit den Korrekturen:

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

Geben Sie die zufällige Zeichenfolge mit dem folgenden Aufruf aus:

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

Bitte beachten Sie, dass dies vorhersehbare zufällige Zeichenfolgen generiert. Wenn Sie sichere Token erstellen möchten, lesen Sie diese Antwort .

Hinweis: Wird str_shuffle()intern verwendet rand(), was für Kryptografiezwecke ungeeignet ist (z. B. Generieren von zufälligen Kennwörtern). Sie möchten stattdessen einen sicheren Zufallszahlengenerator . Es erlaubt auch nicht, dass Zeichen wiederholt werden.

Noch ein Weg.

AKTUALISIERT (dies erzeugt jetzt eine beliebige Länge der Zeichenfolge):

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

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

Das ist es. :) :)

Es gibt viele Antworten auf diese Frage, aber keine davon nutzt einen kryptografisch sicheren Pseudozufallszahlengenerator (CSPRNG).

Die einfache, sichere und richtige Antwort ist, RandomLib zu verwenden und das Rad nicht neu zu erfinden.

Für diejenigen unter Ihnen, die darauf bestehen, Ihre eigene Lösung zu erfinden, bietet PHP 7.0.0 random_int()diesen Zweck. Wenn Sie noch mit PHP 5.x arbeiten, haben wir eine PHP 5-Polyfüllung für geschrieben,random_int() damit Sie die neue API verwenden können, noch bevor Sie auf PHP 7 aktualisieren.

Das sichere Generieren zufälliger Ganzzahlen in PHP ist keine triviale Aufgabe. Sie sollten sich immer an Ihre ansässigen StackExchange-Kryptografieexperten wenden, bevor Sie einen selbst entwickelten Algorithmus in der Produktion bereitstellen.

Mit einem sicheren Integer-Generator ist das Generieren einer zufälligen Zeichenfolge mit einem CSPRNG ein Spaziergang im Park.

Erstellen einer sicheren, zufälligen Zeichenfolge

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

Verwendung :

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

Demo : https://3v4l.org/IMJGF (Ignoriere die PHP 5-Fehler; es wird random_compat benötigt)

Dadurch wird eine 20 Zeichen lange hexadezimale Zeichenfolge erstellt:

$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: Ihre Antwort hat bei mir funktioniert. Ich hatte das gleiche Problem und würde es denen empfehlen, die jemals nach der gleichen Antwort suchen. Hier ist es von @tasmaniski:

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

Hier ist ein Youtube-Video, das uns zeigt, wie man eine Zufallszahl erstellt

Abhängig von Ihrer Anwendung (ich wollte Passwörter generieren) können Sie verwenden

$string = base64_encode(openssl_random_pseudo_bytes(30));

Als base64 können sie =oder enthalten- sowie die angeforderten Zeichen enthalten. Sie können eine längere Zeichenfolge generieren, diese dann filtern und zuschneiden, um diese zu entfernen.

openssl_random_pseudo_bytesscheint der empfohlene Weg zu sein, um eine richtige Zufallszahl in PHP zu generieren. Warum randnicht verwendet /dev/random, weiß ich nicht.

Hier ist ein einfacher Einzeiler, der eine echte Zufallszeichenfolge ohne Schleifen auf Skriptebene oder Verwendung von OpenSSL-Bibliotheken generiert.

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

Um es aufzuschlüsseln, damit die Parameter klar sind

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

Diese Methode wiederholt die Zeichenliste nach dem Zufallsprinzip, mischt dann die kombinierte Zeichenfolge und gibt die angegebene Anzahl von Zeichen zurück.

Sie können dies weiter randomisieren, indem Sie die Länge der zurückgegebenen Zeichenfolge randomisieren und $chrRandomLengthdurch mt_rand(8, 15)(für eine zufällige Zeichenfolge zwischen 8 und 15 Zeichen) ersetzen .

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

Tada!

Eine bessere Möglichkeit, diese Funktion zu implementieren, ist:

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_randnach mehr zufällig dies und dies in PHP 7. Die randFunktion ein Alias ist mt_rand.

$randstringim Funktionsumfang ist nicht derselbe wie der Bereich, in dem Sie ihn aufrufen. Sie müssen den Rückgabewert einer Variablen zuweisen.

$randstring = RandomString();
echo $randstring;

Oder geben Sie den Rückgabewert direkt wieder:

echo RandomString();

Auch in Ihrer Funktion haben Sie einen kleinen Fehler. Innerhalb der for-Schleife müssen Sie verwenden, .=damit jedes Zeichen an die Zeichenfolge angehängt wird. Wenn =Sie verwenden, überschreiben Sie es mit jedem neuen Zeichen, anstatt es anzuhängen.

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

Zunächst definieren Sie das Alphabet, das Sie verwenden möchten:

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

Verwenden Sie dann, um openssl_random_pseudo_bytes()die richtigen Zufallsdaten zu generieren:

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

Schließlich verwenden Sie diese zufälligen Daten, um das Passwort zu erstellen. Da für jedes Zeichen in $randomsein kann , chr(0)bis chr(255)verwendet der Code , den Rest nach der Teilung seines Ordinalwertes mit $alphabet_lengthum sicherzustellen , dass nur Zeichen aus dem Alphabet werden gepflückt (beachten Sie, dass dabei die Zufälligkeit so vorbelastet):

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

Alternativ und im Allgemeinen besser ist die Verwendung von RandomLib und SecurityLib :

use SecurityLib\Strength;

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

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

Kurze Methoden ..

Hier sind einige der kürzesten Methoden zum Generieren der zufälligen Zeichenfolge

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

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

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

Ich habe die Leistung der gängigsten Funktionen dort getestet. Die Zeit, die benötigt wird, um 1'000'000 Zeichenfolgen mit 32 Symbolen auf meiner Box zu generieren, beträgt:

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

Bitte beachten Sie, dass es nicht wichtig ist, wie lange es wirklich gedauert hat, sondern welche langsamer und welche schneller ist, damit Sie entsprechend Ihren Anforderungen auswählen können, einschließlich Kryptografie-Bereitschaft usw.

substr () um MD5 wurde aus Gründen der Genauigkeit hinzugefügt, wenn Sie eine Zeichenfolge benötigen, die kürzer als 32 Symbole ist.

Zur Beantwortung: Die Zeichenfolge wurde nicht verkettet, sondern überschrieben, und das Ergebnis der Funktion wurde nicht gespeichert.

PHP 7+ Generieren Sie mit der Funktion random_bytes kryptografisch sichere Zufallsbytes .

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

Mögliche Ausgabe

da821217e61e33ed4b2dd96f8439056c

PHP 5.3+ Generieren Sie pseudozufällige Bytes mit der Funktion openssl_random_pseudo_bytes .

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

Mögliche Ausgabe

e2d1254506fbb6cd842cd640333214ad

Der beste Anwendungsfall könnte sein

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

Mögliche Ausgabe

ba8cc342bdf91143

Ein sehr schneller Weg ist, etwas zu tun wie:

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

Dadurch wird eine zufällige Zeichenfolge mit einer Länge von 10 Zeichen generiert. Natürlich könnten einige sagen, dass es auf der Berechnungsseite etwas schwerer ist, aber heutzutage sind Prozessoren so optimiert, dass sie den md5- oder sha256-Algorithmus sehr schnell ausführen. Und wenn die rand()Funktion denselben Wert zurückgibt, ist das Ergebnis natürlich dasselbe und es besteht eine Chance von 1/32767, dass es dasselbe ist. Wenn Sicherheit das Problem ist, wechseln Sie einfach rand()zumt_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;
}

Dieser wurde aus Administratorquellen entnommen :

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

Adminer , in PHP geschriebenes Datenbankverwaltungstool.

Hilfsfunktion aus dem 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);
}

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

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

Die bearbeitete Version der Funktion funktioniert einwandfrei, aber ich habe nur ein Problem festgestellt: Sie haben das falsche Zeichen verwendet, um $ Zeichen einzuschließen, sodass das Zeichen 'manchmal Teil der zufälligen Zeichenfolge ist, die generiert wird.

Um dies zu beheben, ändern Sie:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

zu:

$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

Auf diese Weise werden nur die eingeschlossenen Zeichen verwendet, und das Zeichen 'wird niemals Teil der zufälligen Zeichenfolge sein, die generiert wird.

Ein weiterer Einzeiler, der eine zufällige Zeichenfolge von 10 Zeichen mit Buchstaben und Zahlen generiert. Es erstellt ein Array mit range(passen Sie den zweiten Parameter an, um die Größe festzulegen), durchläuft dieses Array und weist ein zufälliges ASCII-Zeichen (Bereich 0-9 oder az) zu. Anschließend wird das Array implodiert, um eine Zeichenfolge zu erhalten.

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

Hinweis: Dies funktioniert nur in PHP 5.3 und höher

Einzeiler.

Es ist schnell für große Saiten mit einer gewissen Einzigartigkeit.

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

Seit php7 gibt es die random_bytes-Funktionen. https://www.php.net/manual/ru/function.random-bytes.php Sie können also eine solche zufällige Zeichenfolge generieren

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

Ich mochte den letzten Kommentar, der openssl_random_pseudo_bytes verwendete, aber es war keine Lösung für mich, da ich immer noch die Zeichen entfernen musste, die ich nicht wollte, und ich konnte keine Zeichenfolge mit festgelegter Länge erhalten. Hier ist meine Lösung ...

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

Hier ist meine einfache einzeilige Lösung, um ein benutzerfreundliches Zufallskennwort zu generieren, mit Ausnahme der Zeichen, die ähnlich aussehen, wie "1" und "l", "O" und "0" usw. Hier sind es 5 Zeichen, aber Sie können es leicht tun ändere es natürlich:

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

Hier ist eine andere Lösung.

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. Ich benutze PHP 7.2 unter Ubuntu.

Eine andere Möglichkeit, eine zufällige Zeichenfolge in PHP zu generieren, ist:

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

Hier ist, wie ich es mache, um einen echten eindeutigen Zufallsschlüssel zu erhalten:

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

Sie können time () verwenden, da es sich um einen Unix-Zeitstempel handelt und im Vergleich zu anderen oben genannten Zufällen immer eindeutig ist. Sie können dann die md5-Summe davon generieren und die gewünschte Länge aus der generierten MD5- Zeichenfolge entnehmen . In diesem Fall verwende ich 10 Zeichen und könnte eine längere Zeichenfolge verwenden, wenn ich sie eindeutiger machen möchte.

Ich hoffe das hilft.

Parametrisierter Einzeiler, der nur native PHP-Funktionen verwendet und seit PHP 5.1.0 funktioniert

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