Fonction PHP pour générer l'UUID v4

J'ai donc fait quelques recherches et j'ai essayé de reconstituer une fonction qui génère un UUID v4 valide en PHP. C'est le plus proche que j'ai pu venir. Mes connaissances en hexadécimal, décimal, binaire, opérateurs bit à bit de PHP et similaires sont presque inexistantes. Cette fonction génère un UUID v4 valide jusqu'à une zone. Un UUID v4 doit se présenter sous la forme de:

xxxxxxxx-xxxx- 4 xxx- y xxx-xxxxxxxxxxxx

où y est 8, 9, A ou B. C'est là que les fonctions échouent car elles n'y adhèrent pas.

J'espérais que quelqu'un avec plus de connaissances que moi dans ce domaine pourrait me donner un coup de main et m'aider à corriger cette fonction pour qu'elle respecte cette règle.

La fonction est la suivante:

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

?>

Merci à tous ceux qui peuvent m'aider.

Tiré de ce commentaire sur le manuel PHP, vous pouvez utiliser ceci:

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

Au lieu de le décomposer en champs individuels, il est plus facile de générer un bloc de données aléatoire et de modifier les positions d'octets individuelles. Vous devriez également utiliser un meilleur générateur de nombres aléatoires que mt_rand ().

Selon RFC 4122 - Section 4.4 , vous devez modifier ces champs:

1. time_hi_and_version (bits 4-7 du 7e octet),
2. clock_seq_hi_and_reserved (bits 6 et 7 du 9e octet)

Tous les 122 autres bits doivent être suffisamment aléatoires.

L'approche suivante génère 128 bits de données aléatoires en utilisant openssl_random_pseudo_bytes(), effectue les permutations sur les octets, puis utilise bin2hex()et vsprintf()pour effectuer le formatage final.

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

Avec PHP 7, la génération de séquences d'octets aléatoires est encore plus simple en utilisant random_bytes():

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

Quiconque utilise des dépendances de compositeur , vous voudrez peut-être envisager cette bibliothèque: https://github.com/ramsey/uuid

Ce n'est pas plus simple que ça:

Uuid::uuid4();

sur les systèmes unix, utilisez le noyau du système pour générer un uuid pour vous.

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

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

Remarque!: L'utilisation de cette méthode pour obtenir un uuid épuise en fait le pool d'entropie, très rapidement! J'éviterais d'utiliser ceci où il serait appelé fréquemment.

Dans ma recherche d'une création d'un uuid v4, je suis d'abord arrivé sur cette page, puis j'ai trouvé ceci sur http://php.net/manual/en/function.com-create-guid.php

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

crédit: pavel.volyntsev

Edit: pour clarifier, cette fonction vous donnera toujours un uuid v4 (PHP> = 5.3.0).

Lorsque la fonction com_create_guid est disponible (généralement uniquement sous Windows), elle l'utilisera et supprimera les accolades.

S'il n'est pas présent (Linux), il se rabattra sur cette fonction opensl_random_pseudo_bytes aléatoire forte, il utilisera ensuite vsprintf pour le formater en uuid v4.

Ma réponse est basée sur le commentaire d' un utilisateur uniqid mais utilise la fonction openssl_random_pseudo_bytes pour générer une chaîne aléatoire au lieu de lire à partir de/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

Si vous utilisez, CakePHPvous pouvez utiliser leur méthode CakeText::uuid();de la classe CakeText pour générer un uuid RFC4122.

Une légère variation sur la réponse de Jack pour ajouter le support de PHP <7:

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

Inspiré par broofa réponse de là .

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

Ou en cas d'impossibilité d'utiliser des fonctions anonymes.

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

Après avoir recherché exactement la même chose et presque implémenté une version de cela moi-même, j'ai pensé qu'il valait la peine de mentionner que, si vous le faites dans un cadre WordPress , WP a sa propre fonction très pratique pour exactement cela:

$myUUID = wp_generate_uuid4();

Vous pouvez lire la description et la source ici .

Que diriez-vous d'utiliser mysql pour générer l'uuid pour vous?

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

De tom, sur 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])

Je suis sûr qu'il existe une façon plus élégante de faire la conversion de binaire en décimal pour les portions 4xxxet yxxx. Mais si vous souhaitez l'utiliser openssl_random_pseudo_bytescomme générateur de nombres sécurisé sur le plan cryptographique, voici ce que j'utilise:

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

Utiliser Symfony Polyfill / Uuid
Ensuite, vous pouvez simplement générer uuid comme fonction php native:

$uuid = uuid_create(UUID_TYPE_RANDOM);

Pour en savoir plus, lisez le post officiel de Blop Symfony - https://symfony.com/blog/introducing-the-new-symfony-uuid-polyfill