random_int - PHP code example

PHP Function Random_Int

Generating random numbers is an essential part of any programming project. Whether you are building an arcade game or a security program you are going to need some method for generating random data. While there are many methods for doing this in PHP, one of the best is the php function random_int. This function uses a cryptographically secure pseudo-random number generator to generate random integers for use in applications that require unbiased results.

When using the php random_int function you can specify an optional min and max value that will limit the generated random number to these values. If no min and max are provided the function will return a random number between 0 and getrandmax().

The php function random_int uses the CSPRNG (Cryptographically Secure Pseudo-Random Number Generator) which is seeded with an initial random value and generates random numbers based on the Mersenne Twister algorithm. This function is recommended in all cases where unbiased results are required over the rand() function which is not cryptographically secure. This function also throws an Exception if it cannot yield sufficient randomness and does not fallback to any insecure RNG sources like rand() does.

As of PHP 7.1.0 the rand() function has been an alias for the mt_rand() function which is said to be four times faster than the old function and produce more random integers that are harder to guess. This is not a good tradeoff for security. Leaking the internal state or seed of a PRNG to attackers allows them to predict future output from that PRNG which violates the Defense in Depth principle.

random_int example

$keywords = ['awesome', 'epic', 'high quality'];

        $products = [];

        $factory = new ProductLineItemFactory(new PriceDefinitionFactory());

        $ids = new IdsCollection();

        $lineItems = [];

        foreach ($taxes as $tax) {
            $price = random_int(100, 200000) / 100.0;

            shuffle($keywords);
            $name = ucfirst(implode(' ', $keywords) . ' product');

            $number = Uuid::randomHex();

            $product = (new ProductBuilder($ids, $number))
                ->price($price)
                ->name($name)
                ->active(true)
                ->tax('test-' . Uuid::randomHex(), $tax)

public function __toString(): string
    {
        return sprintf('%s with 0-%d second jitter', $this->trigger, $this->maxSeconds);
    }

    public function getNextRunDate(\DateTimeImmutable $run): ?\DateTimeImmutable
    {
        if (!$nextRun = $this->trigger->getNextRunDate($run)) {
            return null;
        }

        return $nextRun->add(new \DateInterval(sprintf('PT%sS', random_int(0, $this->maxSeconds))));
    }
}

        $encoder = new Base64Encoder();
        for ($i = 0; $i < 30; ++$i) {
            $input = pack('C', random_int(0, 255));
            $this->assertMatchesRegularExpression('~^[a-zA-Z0-9/\+]{2}==$~', $encoder->encodeString($input), 'A single byte should have 2 bytes of padding');
        }

        for ($i = 0; $i < 30; ++$i) {
            $input = pack('C*', random_int(0, 255), random_int(0, 255));
            $this->assertMatchesRegularExpression('~^[a-zA-Z0-9/\+]{3}=$~', $encoder->encodeString($input), 'Two bytes should have 1 byte of padding');
        }

        for ($i = 0; $i < 30; ++$i) {
            $input = pack('C*', random_int(0, 255), random_int(0, 255), random_int(0, 255));
            $this->assertMatchesRegularExpression('~^[a-zA-Z0-9/\+]{4}$~', $encoder->encodeString($input), 'Three bytes should have no padding');
        }

/** * @param int $length * @param string $keyspace * * @return string */
    public function generateUniqueId($length = 32, $keyspace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')
    {
        $str = '';
        $max = mb_strlen($keyspace, '8bit') - 1;
        for ($i = 0; $i < $length; ++$i) {
            $str .= $keyspace[random_int(0, $max)];
        }

        return $str;
    }

    private function saveUniqueId(string $uniqueId): void
    {
        file_put_contents($this->cacheFilePath, $uniqueId);
    }
}

if (is_numeric($range)) {
                $range = (int) $range;
            } else {
                throw new TypeError(
                    'Argument 1 must be an integer, ' . gettype($range) . ' given.'
                );
            }
        }
        if (self::use_fallback('randombytes_uniform')) {
            return (int) call_user_func('\\Sodium\\randombytes_uniform', $range);
        }
        return random_int(0, $range - 1);
    }

    /** * Generate a random 16-bit integer. * * @return int * @throws Exception * @throws Error * @throws TypeError */
    public static function randombytes_random16()
    {

$cart = new Cart('a-b-c');

        $keywords = ['awesome', 'epic', 'high quality'];

        $products = [];

        $factory = new ProductLineItemFactory(new PriceDefinitionFactory());

        for ($i = 0; $i < $lineItemCount; ++$i) {
            $id = Uuid::randomHex();

            $price = random_int(100, 200000) / 100.0;

            shuffle($keywords);
            $name = ucfirst(implode(' ', $keywords) . ' product');

            $products[] = [
                'id' => $id,
                'name' => $name,
                'price' => [
                    ['currencyId' => Defaults::CURRENCY, 'gross' => $price, 'net' => $price, 'linked' => false],
                ],
                'productNumber' => Uuid::randomHex(),

$payload = [];
        for ($i = 0; $i < $numberOfItems; ++$i) {
            $id = Uuid::randomHex();
            $firstName = $context->getFaker()->firstName();
            $lastName = $context->getFaker()->format('lastName');
            $salutationId = Uuid::fromBytesToHex($this->getRandomSalutationId());
            $title = $this->getRandomTitle();

            $addresses = [];

            $aCount = random_int(2, 5);
            for ($x = 1; $x < $aCount; ++$x) {
                $addresses[] = [
                    'id' => Uuid::randomHex(),
                    'countryId' => Uuid::fromBytesToHex($context->getFaker()->randomElement($countries)),
                    'salutationId' => $salutationId,
                    'title' => $title,
                    'firstName' => $firstName,
                    'lastName' => $lastName,
                    'street' => $context->getFaker()->format('streetName'),
                    'zipcode' => $context->getFaker()->format('postcode'),
                    'city' => $context->getFaker()->format('city'),
                ];

static::assertCount(1, $this->fetchAllCustomers());

        $input = new ArrayInput(['type' => 'guests'], $this->createInputDefinition());
        $this->getCommand()->run($input, new BufferedOutput());

        static::assertCount(1, $this->fetchAllCustomers());
    }

    public function testCommandRemovesOnlyGuestsByDays(): void
    {
        $numberOfGuests = random_int(2, 6);
        $numberOfNoGuests = random_int(1, $numberOfGuests);

        for ($i = 0; $i < $numberOfGuests; ++$i) {
            $this->createGuest();
        }

        for ($i = 0; $i < $numberOfNoGuests; ++$i) {
            $this->createGuest(false);
        }

        $this->connection->executeStatement(

return self::SUCCESS;
    }

    private function generateInstanceId(): string
    {
        $length = 32;
        $keySpace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

        $str = '';
        $max = mb_strlen($keySpace, '8bit') - 1;
        for ($i = 0; $i < $length; ++$i) {
            $str .= $keySpace[random_int(0, $max)];
        }

        return $str;
    }

    private function getDefault(string $var, string $default): string
    {
        return (string) EnvironmentHelper::getVariable($var, $default);
    }
}

    public function testPayloadPercentageWithoutAdvancedPricesWithCurrencyFactor(): void
    {
        $currencyFactor = random_int(0, mt_getrandmax()) / mt_getrandmax();
        $maxValue = 23.0;
        $discount = new PromotionDiscountEntity();
        $discount->setId('P123');
        $discount->setType(PromotionDiscountEntity::TYPE_PERCENTAGE);
        $discount->setValue(50);
        $discount->setMaxValue($maxValue);
        $discount->setScope(PromotionDiscountEntity::SCOPE_CART);

        $builder = new PromotionItemBuilder();

        $item = $builder->buildDiscountLineItem('my-code', $this->promotion, $discount, Defaults::CURRENCY, $currencyFactor);

// MySQL was able to parse the prefix as a value, which we don't want. Bail.             wp_die( __( '<strong>Error:</strong> "Table Prefix" is invalid.' ) );
        }

        // Generate keys and salts using secure CSPRNG; fallback to API if enabled; further fallback to original wp_generate_password().         try {
            $chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_ []{}<>~`+=,.;:/?|';
            $max   = strlen( $chars ) - 1;
            for ( $i = 0; $i < 8; $i++ ) {
                $key = '';
                for ( $j = 0; $j < 64; $j++ ) {
                    $key .= substr( $chars, random_int( 0, $max ), 1 );
                }
                $secret_keys[] = $key;
            }
        } catch ( Exception $ex ) {
            $no_api = isset( $_POST['noapi'] );

            if ( ! $no_api ) {
                $secret_keys = wp_remote_get( 'https://api.wordpress.org/secret-key/1.1/salt/' );
            }

            if ( $no_api || is_wp_error( $secret_keys ) ) {

$this->saveUniqueId($uniqueId);

        return $uniqueId;
    }

    private function generateUniqueId(): string
    {
        $keyspace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
        $str = '';
        $max = mb_strlen($keyspace, '8bit') - 1;
        for ($i = 0; $i < 32; ++$i) {
            $str .= $keyspace[random_int(0, $max)];
        }

        return $str;
    }

    private function saveUniqueId(string $uniqueId): void
    {
        file_put_contents($this->cacheFilePath, $uniqueId);
    }
}

/** * @return mixed */
    private function export($value)
    {
        if (null !== $this->targetDirRegex && \is_string($value) && preg_match($this->targetDirRegex, $value, $matches, \PREG_OFFSET_CAPTURE)) {
            $suffix = $matches[0][1] + \strlen($matches[0][0]);
            $matches[0][1] += \strlen($matches[1][0]);
            $prefix = $matches[0][1] ? $this->doExport(substr($value, 0, $matches[0][1]), true).'.' : '';

            if ('\\' === \DIRECTORY_SEPARATOR && isset($value[$suffix])) {
                $cookie = '\\'.random_int(100000, \PHP_INT_MAX);
                $suffix = '.'.$this->doExport(str_replace('\\', $cookie, substr($value, $suffix)), true);
                $suffix = str_replace('\\'.$cookie, "'.\\DIRECTORY_SEPARATOR.'", $suffix);
            } else {
                $suffix = isset($value[$suffix]) ? '.'.$this->doExport(substr($value, $suffix), true) : '';
            }

            $dirname = $this->asFiles ? '$this->containerDir' : '__DIR__';
            $offset = 2 + $this->targetDirMaxMatches - \count($matches);

            if (0 < $offset) {
                $dirname = sprintf('\dirname(__DIR__, %d)', $offset + (int) $this->asFiles);
            }

try {
            $this->store->save($key);
        } catch (LockConflictedException $e) {
            // Catch the exception given this is not what we want to assert in this tests         }
    }

    public function testputOffExpirationThrowsExceptionOnFailure()
    {
        $this->expectException(LockConflictedException::class);
        $key = new Key(uniqid(__METHOD__, true));
        $ttl = random_int(1, 10);

        $this->store1
            ->expects($this->once())
            ->method('putOffExpiration')
            ->with($key, $this->lessThanOrEqual($ttl))
            ->willThrowException(new LockConflictedException());
        $this->store2
            ->expects($this->once())
            ->method('putOffExpiration')
            ->with($key, $this->lessThanOrEqual($ttl))
            ->willThrowException(new LockConflictedException());