php - verifizierungs - title tag wordpress




Wie erstelle ich eine zufällige Zeichenfolge mit PHP? (12)

Also, lassen Sie mich zu Beginn mit USE A LIBRARY sprechen . Viele existieren:

Der Kern des Problems ist fast jede Antwort auf dieser Seite ist anfällig für Angriffe. mt_rand() , rand() , lcg_value() und uniqid() sind alle angreifbar .

Ein gutes System verwendet /dev/urandom aus dem Dateisystem oder mcrypt_create_iv() (mit MCRYPT_DEV_URANDOM ) oder openssl_pseudo_random_bytes() . Was alle oben genannten tun. PHP 7 wird mit zwei neuen Funktionen random_bytes($len) und random_int($min, $max) , die ebenfalls sicher sind.

random_int() Sie, dass die meisten dieser Funktionen (außer random_int() ) "rohe Strings" zurückgeben, dh sie können ein beliebiges ASCII-Zeichen von 0 - 255 . Wenn Sie eine druckbare Zeichenfolge möchten, würde ich vorschlagen, das Ergebnis über base64_encode() .

Ich weiß, dass die Rand-Funktion in PHP zufällige Ganzzahlen erzeugt, aber was ist der beste Weg, um eine zufällige Zeichenfolge zu generieren, wie zum Beispiel:

Originalsaite, 9 Zeichen

$string = 'abcdefghi';

Beispiel für eine zufällige Zeichenfolge, die auf 6 Zeichen beschränkt ist

$string = 'ibfeca';

UPDATE: Ich habe Tonnen dieser Arten von Funktionen gefunden, im Grunde versuche ich, die Logik hinter jedem Schritt zu verstehen.

UPDATE: Die Funktion sollte beliebig viele Zeichen generieren.

Bitte kommentiere die Teile, wenn du antwortest.


Das Verbinden von Zeichen am Ende sollte effizienter sein als die wiederholte String-Verkettung.

Edit # 1: Option hinzugefügt, um Zeichenwiederholung zu vermeiden.

Edit # 2: Wirft eine Exception aus, um zu vermeiden, in eine Endlosschleife zu gelangen, wenn $ norepeat ausgewählt ist und $ len größer als der Zeichensatz ist, aus dem ausgewählt werden soll.

Edit # 3: Verwendet Array-Schlüssel zum Speichern ausgewählter zufälliger Zeichen, wenn $ norepeat ausgewählt ist, da das Suchen nach assoziativen Array-Schlüsseln schneller ist als das lineare Durchsuchen des Arrays.

function rand_str($len, $norepeat = true)
{
    $chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    $max = strlen($chars) - 1;

    if ($norepeat && len > $max + 1) {
        throw new Exception("Non repetitive random string can't be longer than charset");
    }

    $rand_chars = array();

    while ($len) {
        $picked = $chars[mt_rand(0, $max)];

        if ($norepeat) {
            if (!array_key_exists($picked, $rand_chars)) {
                $rand_chars[$picked] = true;
                $len--;
            }
        }
        else {
            $rand_chars[] = $picked;
            $len--;
        }
    }

    return implode('', $norepeat ? array_keys($rand_chars) : $rand_chars);   
}

Dies baut auf der Lösung von Gumbo auf, indem Funktionen hinzugefügt werden, um eine Reihe von Zeichen aufzulisten, die im Basiszeichensatz übersprungen werden. Die zufällige Zeichenfolge wählt Zeichen aus $base_charset , die nicht auch in $skip_charset .

/* Make a random string of length using characters from $charset, excluding $skip_chars.
 * @param length (integer) length of return value
 * @param skip_chars (string) characters to be excluded from $charset
 * @param charset (string) characters of posibilities for characters in return val
 * @return (string) random string of length $length    */
function rand_string(
        $length, 
        $skip_charset = '', 
        $base_charset='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'){
  $skip_len = strlen($skip_charset);
  for ($i = 0; $i<$skip_len; $i++){
    $base_charset = str_replace($skip_charset[$i], '', $base_charset);
  }
  cvar_dump($base_charset, '$base_charset after replace');
  $str = '';
  $count = strlen($base_charset);
  while ($length--) {
    $str .= $base_charset[mt_rand(0, $count - 1)];
  }
  return $str;
}

Hier sind einige Anwendungsbeispiele. Die ersten beiden Beispiele verwenden den Standardwert für $base_charset . Das letzte Beispiel definiert explizit $base_charset .

echo rand_string(15, 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz');
//  470620078953298
echo rand_string(8, 'abcdefghijklmnopqrstuvwxyz0123456789');
//  UKLIHOTFSUZMFPU
echo rand_string(15, 'def', 'abcdef');
//  cbcbbccbabccaba

Dies erzeugt eine zufällige Zeichenfolge

function generateRandomString($length=10) {
    $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 generateRandomString(6);

Möchten Sie Ihr Passwort durch eine zufällige Permutation der ursprünglichen Buchstaben erstellen? Sollte es nur einzigartige Charaktere enthalten?

Verwenden Sie rand , um zufällige Buchstaben nach Index auszuwählen.


Mein Favorit:

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

Nun, ich suchte nach einer Lösung und nutzte @Chad Birchs Lösung, die mit der von @ Gumbo verschmolzen wurde. Das ist, was ich mir ausgedacht habe:

function get_random_string($length, $valid_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123456790!·$%&/()=?¿¡',.-;:+*`+´ç")
{
    $random_string = "";
    $num_valid_chars = strlen($valid_chars);
    for ($i = 0; $i < $length; $i++, $random_string .= $valid_chars[mt_rand(1, $num_valid_chars)-1]);
    return $random_string;
}

Ich denke, Kommentare sind ziemlich unnötig, da die Antworten, die ich verwendet habe, bereits ausführlich kommentiert wurden. Prost!


Sie könnten ein Array von Zeichen erstellen und dann mit rand () einen Buchstaben aus dem Array auswählen und zu einer Zeichenfolge hinzufügen.

$letters = array( [0] => 'a' [1] => 'b' [2] => 'c' [3] => 'd' ... [25] = 'z');

$lengthOfString = 10;
$str = '';

while( $lengthOfString-- )
{
   $str .= $letters[rand(0,25)];
}
echo $str;

* Beachten Sie, dass dies Wiederholungszeichen erlaubt


Wenn Sie sich wiederholende Zeichenereignisse erlauben möchten, können Sie diese Funktion verwenden:

function randString($length, $charset='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789')
{
    $str = '';
    $count = strlen($charset);
    while ($length--) {
        $str .= $charset[mt_rand(0, $count-1)];
    }
    return $str;
}

Der grundlegende Algorithmus besteht darin, < Länge > mal eine Zufallszahl zwischen 0 und < Anzahl der Zeichen > zu erzeugen - 1 benutzen wir als Index, um ein Zeichen aus unserer Menge auszuwählen und diese Zeichen zu verketten. Die 0 und < Anzahl der Zeichen > - 1 Grenzen repräsentieren die Grenzen der Zeichenkette $charset da das erste Zeichen mit $charset[0] und das letzte mit $charset[count($charset) - 1] adressiert wird.


Wozu brauchst du eine zufällige Zeichenfolge?

Wird dies für alles verwendet, was einem Passwort analog ist?

Wenn Ihre zufällige Zeichenfolge überhaupt Sicherheitseigenschaften erfordert, sollten Sie die random_int() Funktion von PHP 7 anstelle aller unsicheren mt_rand() -Antworten in diesem Thread verwenden.

/**
 * Generate a random string
 * 
 * @link https://paragonie.com/b/JvICXzh_jhLyt4y3
 *
 * @param int $length - How long should our random string be?
 * @param string $charset - A string of all possible characters to choose from
 * @return string
 */
function random_str($length = 32, $charset = 'abcdefghijklmnopqrstuvwxyz')
{
    // Type checks:
    if (!is_numeric($length)) {
        throw new InvalidArgumentException(
            'random_str - Argument 1 - expected an integer'
        );
    }
    if (!is_string($charset)) {
        throw new InvalidArgumentException(
            'random_str - Argument 2 - expected a string'
        );
    }

    if ($length < 1) {
        // Just return an empty string. Any value < 1 is meaningless.
        return '';
    }
    // This is the maximum index for all of the characters in the string $charset
    $charset_max = strlen($charset) - 1;
    if ($charset_max < 1) {
        // Avoid letting users do: random_str($int, 'a'); -> 'aaaaa...'
        throw new LogicException(
            'random_str - Argument 2 - expected a string at least 2 characters long'
        );
    }
    // Now that we have good data, this is the meat of our function:
    $random_str = '';
    for ($i = 0; $i < $length; ++$i) {
        $r = random_int(0, $charset_max);
        $random_str .= $charset[$r];
    }
    return $random_str;
}

Wenn Sie noch nicht auf PHP 7 sind (was wahrscheinlich der Fall ist, da es noch nicht veröffentlicht wurde), dann wollen Sie paragonie/random_compat , welches eine random_bytes() Implementierung von random_bytes() und random_int() für PHP 5 Projekte.

Verwenden random_int() für Sicherheitskontexte immer random_int() , nicht rand() , mt_rand() usw. Siehe auch ircmaxells Antwort .


// @author http://codeascraft.etsy.com/2012/07/19/better-random-numbers-in-php-using-devurandom/                                                
function devurandom_rand($min = 0, $max = 0x7FFFFFFF)
{
    $diff = $max - $min;
    if ($diff < 0 || $diff > 0x7FFFFFFF) {
        throw new RuntimeException('Bad range');
    }
    $bytes = mcrypt_create_iv(4, MCRYPT_DEV_URANDOM);
    if ($bytes === false || strlen($bytes) != 4) {
        throw new RuntimeException('Unable to get 4 bytes');
    }
    $ary = unpack('Nint', $bytes);
    $val = $ary['int'] & 0x7FFFFFFF; // 32-bit safe                           
    $fp = (float) $val / 2147483647.0; // convert to [0,1]                          
    return round($fp * $diff) + $min;
}

function build_token($length = 60, $characters_map = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') {
    $map_length = mb_strlen($characters_map)-1;
    $token = '';
    while ($length--) {
        $token .= mb_substr($characters_map, devurandom_rand(0,$map_length),1);
    }
    return $token;
}

Dies funktioniert nur in einer UNIX-Umgebung, in der PHP mit mcrypt kompiliert mcrypt .


function generate_random_string($name_length = 8) {
    $alpha_numeric = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    return substr(str_shuffle(str_repeat($alpha_numeric, $name_length)), 0, $name_length);
}

Der Code wurde mzhang dem großen Vorschlag von mzhang in den Kommentaren unten aktualisiert.





random