PHP-Funktion zum Generieren der v4-UUID

Also habe ich ein bisschen herumgegraben und versucht, eine Funktion zusammenzusetzen, die eine gültige v4-UUID in PHP generiert. Dies ist der nächste, den ich kommen konnte. Mein Wissen über hexadezimale, dezimale, binäre, bitweise PHP-Operatoren und dergleichen ist nahezu nicht vorhanden. Diese Funktion generiert eine gültige v4-UUID bis zu einem Bereich. Eine v4-UUID sollte folgende Form haben:

xxxxxxxx-xxxx- 4 xxx- y xxx-xxxxxxxxxxxx

Dabei ist y 8, 9, A oder B. Hier schlagen die Funktionen fehl, da sie sich nicht daran halten.

Ich hatte gehofft, jemand mit mehr Wissen als ich in diesem Bereich könnte mir helfen und mir helfen, diese Funktion zu reparieren, damit sie dieser Regel entspricht.

Die Funktion ist wie folgt:

<?php

function gen_uuid() {
 $uuid = array(
  'time_low'  => 0,
  'time_mid'  => 0,
  'time_hi'  => 0,
  'clock_seq_hi' => 0,
  'clock_seq_low' => 0,
  'node'   => array()
 );

 $uuid['time_low'] = mt_rand(0, 0xffff) + (mt_rand(0, 0xffff) << 16);
 $uuid['time_mid'] = mt_rand(0, 0xffff);
 $uuid['time_hi'] = (4 << 12) | (mt_rand(0, 0x1000));
 $uuid['clock_seq_hi'] = (1 << 7) | (mt_rand(0, 128));
 $uuid['clock_seq_low'] = mt_rand(0, 255);

 for ($i = 0; $i < 6; $i++) {
  $uuid['node'][$i] = mt_rand(0, 255);
 }

 $uuid = sprintf('%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x',
  $uuid['time_low'],
  $uuid['time_mid'],
  $uuid['time_hi'],
  $uuid['clock_seq_hi'],
  $uuid['clock_seq_low'],
  $uuid['node'][0],
  $uuid['node'][1],
  $uuid['node'][2],
  $uuid['node'][3],
  $uuid['node'][4],
  $uuid['node'][5]
 );

 return $uuid;
}

?>

Vielen Dank an alle, die mir helfen können.

Aus diesem Kommentar im PHP-Handbuch können Sie Folgendes verwenden:

function gen_uuid() {
    return sprintf( '%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
        // 32 bits for "time_low"
        mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff ),

        // 16 bits for "time_mid"
        mt_rand( 0, 0xffff ),

        // 16 bits for "time_hi_and_version",
        // four most significant bits holds version number 4
        mt_rand( 0, 0x0fff ) | 0x4000,

        // 16 bits, 8 bits for "clk_seq_hi_res",
        // 8 bits for "clk_seq_low",
        // two most significant bits holds zero and one for variant DCE1.1
        mt_rand( 0, 0x3fff ) | 0x8000,

        // 48 bits for "node"
        mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff )
    );
}

Anstatt es in einzelne Felder zu unterteilen, ist es einfacher, einen zufälligen Datenblock zu generieren und die einzelnen Bytepositionen zu ändern. Sie sollten auch einen besseren Zufallszahlengenerator als mt_rand () verwenden.

Gemäß RFC 4122 - Abschnitt 4.4 müssen Sie diese Felder ändern:

1. time_hi_and_version (Bits 4-7 des 7. Oktetts),
2. clock_seq_hi_and_reserved (Bit 6 & 7 des 9. Oktetts)

Alle anderen 122 Bits sollten ausreichend zufällig sein.

Der folgende Ansatz generiert 128 Bit zufälliger Daten unter Verwendung openssl_random_pseudo_bytes(), führt die Permutationen für die Oktette durch und verwendet bin2hex()und führt vsprintf()dann die endgültige Formatierung durch.

function guidv4($data)
{
    assert(strlen($data) == 16);

    $data[6] = chr(ord($data[6]) & 0x0f | 0x40); // set version to 0100
    $data[8] = chr(ord($data[8]) & 0x3f | 0x80); // set bits 6-7 to 10

    return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
}

echo guidv4(openssl_random_pseudo_bytes(16));

Mit PHP 7 ist das Generieren von zufälligen Byte-Sequenzen noch einfacher, wenn random_bytes():

function guidv4($data = null)
{
    $data = $data ?? random_bytes(16);
    // ...
}

Wenn Sie Composer- Abhängigkeiten verwenden, sollten Sie diese Bibliothek in Betracht ziehen: https://github.com/ramsey/uuid

Einfacher geht es nicht:

Uuid::uuid4();

Verwenden Sie auf Unix-Systemen den Systemkern, um eine UUID für Sie zu generieren.

file_get_contents('/proc/sys/kernel/random/uuid')

Credit Samveen unter https://serverfault.com/a/529319/210994

Hinweis!: Wenn Sie diese Methode verwenden, um eine UUID zu erhalten, wird der Entropiepool tatsächlich sehr schnell erschöpft! Ich würde es vermeiden, dies dort zu verwenden, wo es häufig aufgerufen wird.

Bei meiner Suche nach einer v4-UUID bin ich zuerst auf diese Seite gekommen und habe diese dann auf http://php.net/manual/en/function.com-create-guid.php gefunden

function guidv4()
{
    if (function_exists('com_create_guid') === true)
        return trim(com_create_guid(), '{}');

    $data = openssl_random_pseudo_bytes(16);
    $data[6] = chr(ord($data[6]) & 0x0f | 0x40); // set version to 0100
    $data[8] = chr(ord($data[8]) & 0x3f | 0x80); // set bits 6-7 to 10
    return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
}

Kredit: pavel.volyntsev

Bearbeiten: Zur Verdeutlichung erhalten Sie mit dieser Funktion immer eine v4-UUID (PHP> = 5.3.0).

Wenn die Funktion com_create_guid verfügbar ist (normalerweise nur unter Windows), wird sie verwendet und die geschweiften Klammern entfernt.

Wenn es nicht vorhanden ist (Linux), greift es auf diese starke zufällige Funktion openssl_random_pseudo_bytes zurück und formatiert sie dann mit vsprintf in v4 uuid.

Meine Antwort basiert auf einem Kommentar uniqid Benutzerkommentar , verwendet jedoch die Funktion openssl_random_pseudo_bytes , um eine zufällige Zeichenfolge zu generieren, anstatt aus zu lesen/dev/urandom

function guid()
{
    $randomString = openssl_random_pseudo_bytes(16);
    $time_low = bin2hex(substr($randomString, 0, 4));
    $time_mid = bin2hex(substr($randomString, 4, 2));
    $time_hi_and_version = bin2hex(substr($randomString, 6, 2));
    $clock_seq_hi_and_reserved = bin2hex(substr($randomString, 8, 2));
    $node = bin2hex(substr($randomString, 10, 6));

    /**
     * Set the four most significant bits (bits 12 through 15) of the
     * time_hi_and_version field to the 4-bit version number from
     * Section 4.1.3.
     * @see http://tools.ietf.org/html/rfc4122#section-4.1.3
    */
    $time_hi_and_version = hexdec($time_hi_and_version);
    $time_hi_and_version = $time_hi_and_version >> 4;
    $time_hi_and_version = $time_hi_and_version | 0x4000;

    /**
     * Set the two most significant bits (bits 6 and 7) of the
     * clock_seq_hi_and_reserved to zero and one, respectively.
     */
    $clock_seq_hi_and_reserved = hexdec($clock_seq_hi_and_reserved);
    $clock_seq_hi_and_reserved = $clock_seq_hi_and_reserved >> 2;
    $clock_seq_hi_and_reserved = $clock_seq_hi_and_reserved | 0x8000;

    return sprintf('%08s-%04s-%04x-%04x-%012s', $time_low, $time_mid, $time_hi_and_version, $clock_seq_hi_and_reserved, $node);
} // guid

Wenn Sie verwenden CakePHP, können Sie ihre Methode CakeText::uuid();aus der CakeText- Klasse verwenden, um eine RFC4122- UUID zu generieren.

Eine leichte Variation von Jacks Antwort , um Unterstützung für PHP <7 hinzuzufügen:

// Get an RFC-4122 compliant globaly unique identifier
function get_guid() {
    $data = PHP_MAJOR_VERSION < 7 ? openssl_random_pseudo_bytes(16) : random_bytes(16);
    $data[6] = chr(ord($data[6]) & 0x0f | 0x40);    // Set version to 0100
    $data[8] = chr(ord($data[8]) & 0x3f | 0x80);    // Set bits 6-7 to 10
    return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
}

Inspiriert von Broofas Antwort hier .

preg_replace_callback('/[xy]/', function ($matches)
{
  return dechex('x' == $matches[0] ? mt_rand(0, 15) : (mt_rand(0, 15) & 0x3 | 0x8));
}
, 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx');

Oder wenn anonyme Funktionen nicht verwendet werden können.

preg_replace_callback('/[xy]/', create_function(
  '$matches',
  'return dechex("x" == $matches[0] ? mt_rand(0, 15) : (mt_rand(0, 15) & 0x3 | 0x8));'
)
, 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx');

Nachdem ich genau das Gleiche gesucht und fast selbst eine Version davon implementiert hatte, fand ich es erwähnenswert, dass WP , wenn Sie dies in einem WordPress- Framework tun , eine eigene superhandliche Funktion für genau dies hat:

$myUUID = wp_generate_uuid4();

Die Beschreibung und die Quelle können Sie hier lesen .

Wie wäre es mit MySQL, um die UUID für Sie zu generieren?

$conn = new mysqli($servername, $username, $password, $dbname, $port);

$query = 'SELECT UUID()';
echo $conn->query($query)->fetch_row()[0];

$uuid = vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex(random_bytes(16)), 4));

Von Tom auf http://www.php.net/manual/en/function.uniqid.php

$r = unpack('v*', fread(fopen('/dev/random', 'r'),16));
$uuid = sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
    $r[1], $r[2], $r[3], $r[4] & 0x0fff | 0x4000,
    $r[5] & 0x3fff | 0x8000, $r[6], $r[7], $r[8])

Ich bin sicher, es gibt eine elegantere Möglichkeit, die Konvertierung von binär in dezimal für die Teile 4xxxund yxxxdurchzuführen. Aber wenn Sie openssl_random_pseudo_bytesals Ihren krytographisch sicheren Zahlengenerator verwenden möchten, verwende ich Folgendes:

return sprintf('%s-%s-%04x-%04x-%s',
    bin2hex(openssl_random_pseudo_bytes(4)),
    bin2hex(openssl_random_pseudo_bytes(2)),
    hexdec(bin2hex(openssl_random_pseudo_bytes(2))) & 0x0fff | 0x4000,
    hexdec(bin2hex(openssl_random_pseudo_bytes(2))) & 0x3fff | 0x8000,
    bin2hex(openssl_random_pseudo_bytes(6))
    );

Verwenden Symfony Polyfill / Uuid
Dann können Sie einfach UUID als native PHP - Funktion erzeugen:

$uuid = uuid_create(UUID_TYPE_RANDOM);

Weitere Informationen finden Sie im offiziellen Symfony-Blop-Beitrag - https://symfony.com/blog/introducing-the-new-symfony-uuid-polyfill