random.php

<?php
 
namespace Bitrix\Main\Security;
 
class Random
{
    const RANDOM_BLOCK_LENGTH = 64;
    // ToDo: In future versions (PHP >= 5.6.0) use shift to the left instead this s**t
    const ALPHABET_NUM = 1;
    const ALPHABET_ALPHALOWER = 2;
    const ALPHABET_ALPHAUPPER = 4;
    const ALPHABET_SPECIAL = 8;
    const ALPHABET_ALL = 15;
 
    protected static $alphabet = array(
        self::ALPHABET_NUM => '0123456789',
        self::ALPHABET_ALPHALOWER => 'abcdefghijklmnopqrstuvwxyz',
        self::ALPHABET_ALPHAUPPER => 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        self::ALPHABET_SPECIAL => ',.#!*%$:-^@{}[]()_+=<>?&;'
    );
 
    public static function getInt($min = 0, $max = \PHP_INT_MAX)
    {
        if ($min > $max)
        {
            throw new \Bitrix\Main\ArgumentException(
                'The min parameter must be lower than max parameter'
            );
        }
 
        $range = $max - $min;
 
        if ($range == 0)
            return $max;
 
        if ($range > \PHP_INT_MAX || is_float($range))
        {
            throw new \Bitrix\Main\SystemException(
                'The supplied range is too great'
            );
        }
 
        $bits = static::countBits($range) + 1;
        $length = (int) max(ceil($bits / 8), 1);
        $filter = pow(2, $bits) - 1;
        if ($filter >= \PHP_INT_MAX)
            $filter = \PHP_INT_MAX;
        else
            $filter = (int) $filter;
 
        do
        {
            $rnd = hexdec(bin2hex(self::getBytes($length)));
            $rnd = $rnd & $filter;
        }
        while ($rnd > $range);
 
        return ($min + $rnd);
    }
 
    public static function getString($length, $caseSensitive = false)
    {
        $alphabet = self::ALPHABET_NUM | self::ALPHABET_ALPHALOWER;
        if ($caseSensitive)
        {
            $alphabet |= self::ALPHABET_ALPHAUPPER;
        }
 
        return static::getStringByAlphabet($length, $alphabet);
    }
 
    public static function getStringByAlphabet($length, $alphabet, $requireAll = false)
    {
        $charsetList = static::getCharsetsforAlphabet($alphabet);
 
        if($requireAll && count($charsetList) > 1)
        {
            return static::getStringByArray($length, $charsetList);
        }
        else
        {
            return static::getStringByCharsets($length, implode("", $charsetList));
        }
    }
 
    public static function getStringByCharsets($length, $charsetList)
    {
        $charsetVariants = strlen($charsetList);
        $randomSequence = static::getBytes($length);
 
        $result = '';
        for ($i = 0; $i < $length; $i++)
        {
            $randomNumber = ord($randomSequence[$i]);
            $result .= $charsetList[$randomNumber % $charsetVariants];
        }
        return $result;
    }
 
    public static function getStringByArray(int $length, array $charsetList): string
    {
        $count = count($charsetList);
 
        // take strlen() out of the cycle
        $charsets = [];
        foreach ($charsetList as $charset)
        {
            $charsets[] = [$charset, strlen($charset)];
        }
 
        $randomSequence = static::getBytes($length);
 
        $result = '';
        for ($i = 0; $i < $length; $i += $count)
        {
            shuffle($charsets);
 
            for ($j = 0; $j < $count; $j++)
            {
                $randomNumber = ord($randomSequence[$i + $j]);
 
                $charset = $charsets[$j][0];
                $charsetVariants = $charsets[$j][1];
                $result .= $charset[$randomNumber % $charsetVariants];
 
                if (($i + $j + 1) == $length)
                {
                    break 2;
                }
            }
        }
 
        return $result;
    }
 
    public static function getBytes($length)
    {
        $backup = null;
 
        if ($length <= 0)
        {
            $length = 1;
        }
 
        $bytes = openssl_random_pseudo_bytes($length, $strong);
        if ($bytes && strlen($bytes) >= $length)
        {
            if ($strong)
            {
                return substr($bytes, 0, $length);
            }
            $backup = $bytes;
        }
 
        if (file_exists('/dev/urandom'))
        {
            if ($file = @fopen('/dev/urandom', 'rb'))
            {
                $bytes = @fread($file, $length + 1);
                @fclose($file);
                if ($bytes && strlen($bytes) >= $length)
                {
                    return substr($bytes, 0, $length);
                }
            }
        }
 
        if ($backup && strlen($backup) >= $length)
        {
            return substr($backup, 0, $length);
        }
 
        $bytes = '';
        while (strlen($bytes) < $length)
        {
            $bytes .= static::getPseudoRandomBlock();
        }
 
        return substr($bytes, 0, $length);
    }
 
    protected static function getPseudoRandomBlock()
    {
        $bytes = openssl_random_pseudo_bytes(static::RANDOM_BLOCK_LENGTH);
        if ($bytes && strlen($bytes) >= static::RANDOM_BLOCK_LENGTH)
        {
            return substr($bytes, 0, static::RANDOM_BLOCK_LENGTH);
        }
 
        $bytes = '';
        for ($i=0; $i < static::RANDOM_BLOCK_LENGTH; $i++)
        {
            $bytes .= pack('S', mt_rand(0,0xffff));
        }
 
        return hash('sha512', $bytes, true);
    }
 
    protected static function getCharsetsForAlphabet($alphabet)
    {
        $result = [];
        foreach (static::$alphabet as $mask => $value)
        {
            if ($alphabet & $mask)
            {
                $result[] = $value;
            }
        }
 
        return $result;
    }
 
    protected static function countBits($value)
    {
        $result = 0;
        while ($value >>= 1)
            $result++;
 
        return $result;
    }
}