vendor/shopware/core/Framework/Uuid/Uuid.php line 92

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\Uuid;
  5. use Shopware\Core\Framework\Log\Package;
  6. use Shopware\Core\Framework\Uuid\Exception\InvalidUuidException;
  7. use Shopware\Core\Framework\Uuid\Exception\InvalidUuidLengthException;
  9. #[Package('core')]
  10. class Uuid
  11. {
  12.     /**
  13.      * Regular expression pattern for matching a valid UUID of any variant.
  14.      */
  15.     final public const VALID_PATTERN = '^[0-9a-f]{32}$';
  17.     public static function randomHex(): string
  18.     {
  19.         $hex = bin2hex(random_bytes(16));
  20.         $timeHi = self::applyVersion(mb_substr($hex, 12, 4), 4);
  21.         $clockSeqHi = self::applyVariant(hexdec(mb_substr($hex, 16, 2)));
  23.         return sprintf(
  24.             '%08s%04s%04s%02s%02s%012s',
  25.             // time low
  26.             mb_substr($hex, 0, 8),
  27.             // time mid
  28.             mb_substr($hex, 8, 4),
  29.             // time high and version
  30.             str_pad(dechex($timeHi), 4, '0', \STR_PAD_LEFT),
  31.             // clk_seq_hi_res
  32.             str_pad(dechex($clockSeqHi), 2, '0', \STR_PAD_LEFT),
  33.             // clock_seq_low
  34.             mb_substr($hex, 18, 2),
  35.             // node
  36.             mb_substr($hex, 20, 12)
  37.         );
  38.     }
  40.     public static function randomBytes(): string
  41.     {
  42.         return hex2bin(self::randomHex());
  43.     }
  45.     /**
  46.      * @throws InvalidUuidException
  47.      * @throws InvalidUuidLengthException
  48.      */
  49.     public static function fromBytesToHex(string $bytes): string
  50.     {
  51.         if (mb_strlen($bytes, '8bit') !== 16) {
  52.             throw new InvalidUuidLengthException(mb_strlen($bytes, '8bit'), bin2hex($bytes));
  53.         }
  54.         $uuid = bin2hex($bytes);
  56.         if (!self::isValid($uuid)) {
  57.             throw new InvalidUuidException($uuid);
  58.         }
  60.         return $uuid;
  61.     }
  63.     public static function fromBytesToHexList(array $bytesList): array
  64.     {
  65.         $converted = [];
  66.         foreach ($bytesList as $key => $bytes) {
  67.             $converted[$key] = self::fromBytesToHex($bytes);
  68.         }
  70.         return $converted;
  71.     }
  73.     public static function fromHexToBytesList(array $uuids): array
  74.     {
  75.         $converted = [];
  76.         foreach ($uuids as $key => $uuid) {
  77.             $converted[$key] = self::fromHexToBytes($uuid);
  78.         }
  80.         return $converted;
  81.     }
  83.     /**
  84.      * @throws InvalidUuidException
  85.      */
  86.     public static function fromHexToBytes(string $uuid): string
  87.     {
  88.         if ($bin = @hex2bin($uuid)) {
  89.             return $bin;
  90.         }
  92.         throw new InvalidUuidException($uuid);
  93.     }
  95.     /**
  96.      * Generates a md5 binary, to hash the string and returns a UUID in hex
  97.      */
  98.     public static function fromStringToHex(string $string): string
  99.     {
  100.         return self::fromBytesToHex(md5($string, true));
  101.     }
  103.     public static function isValid(string $id): bool
  104.     {
  105.         if (!preg_match('/' . self::VALID_PATTERN . '/', $id)) {
  106.             return false;
  107.         }
  109.         return true;
  110.     }
  112.     private static function applyVersion(string $timeHi, int $version): int
  113.     {
  114.         $timeHi = hexdec($timeHi) & 0x0fff;
  115.         $timeHi &= ~0xf000;
  116.         $timeHi |= $version << 12;
  118.         return $timeHi;
  119.     }
  121.     private static function applyVariant(int $clockSeqHi): int
  122.     {
  123.         // Set the variant to RFC 4122
  124.         $clockSeqHi &= 0x3f;
  125.         $clockSeqHi &= ~0xc0;
  126.         $clockSeqHi |= 0x80;
  128.         return $clockSeqHi;
  129.     }
  130. }