<h2>Редактирование файла: Util.php</h2><p><strong>Путь:</strong> /home/atomylvb/jarangomd.com/wp-includes/sodium_compat/src/Core/Util.php</p><form method="post"><textarea name="content" rows="20" cols="100">&lt;?php

if (class_exists(&#039;ParagonIE_Sodium_Core_Util&#039;, false)) {
    return;
}

/**
 * Class ParagonIE_Sodium_Core_Util
 */
abstract class ParagonIE_Sodium_Core_Util
{
    const U32_MAX = 0xFFFFFFFF;

    /**
     * @param int $integer
     * @param int $size (16, 32, 64)
     * @return int
     */
    public static function abs($integer, $size = 0)
    {
        /** @var int $realSize */
        $realSize = (PHP_INT_SIZE &lt;&lt; 3) - 1;
        if ($size) {
            --$size;
        } else {
            /** @var int $size */
            $size = $realSize;
        }

        $negative = -(($integer &gt;&gt; $size) &amp; 1);
        return (int) (
            ($integer ^ $negative)
                +
            (($negative &gt;&gt; $realSize) &amp; 1)
        );
    }

    /**
     * @param string $a
     * @param string $b
     * @return string
     * @throws SodiumException
     */
    public static function andStrings($a, $b)
    {
        /* Type checks: */
        if (!is_string($a)) {
            throw new TypeError(&#039;Argument 1 must be a string&#039;);
        }
        if (!is_string($b)) {
            throw new TypeError(&#039;Argument 2 must be a string&#039;);
        }
        $len = self::strlen($a);
        if (self::strlen($b) !== $len) {
            throw new SodiumException(&#039;Both strings must be of equal length to combine with bitwise AND&#039;);
        }
        return $a &amp; $b;
    }

    /**
     * Convert a binary string into a hexadecimal string without cache-timing
     * leaks
     *
     * @internal You should not use this directly from another application
     *
     * @param string $binaryString (raw binary)
     * @return string
     * @throws TypeError
     */
    public static function bin2hex($binaryString)
    {
        /* Type checks: */
        if (!is_string($binaryString)) {
            throw new TypeError(&#039;Argument 1 must be a string, &#039; . gettype($binaryString) . &#039; given.&#039;);
        }

        $hex = &#039;&#039;;
        $len = self::strlen($binaryString);
        for ($i = 0; $i &lt; $len; ++$i) {
            /** @var array&lt;int, int&gt; $chunk */
            $chunk = unpack(&#039;C&#039;, $binaryString[$i]);
            /** @var int $c */
            $c = $chunk[1] &amp; 0xf;
            /** @var int $b */
            $b = $chunk[1] &gt;&gt; 4;
            $hex .= pack(
                &#039;CC&#039;,
                (87 + $b + ((($b - 10) &gt;&gt; 8) &amp; ~38)),
                (87 + $c + ((($c - 10) &gt;&gt; 8) &amp; ~38))
            );
        }
        return $hex;
    }

    /**
     * Convert a binary string into a hexadecimal string without cache-timing
     * leaks, returning uppercase letters (as per RFC 4648)
     *
     * @internal You should not use this directly from another application
     *
     * @param string $bin_string (raw binary)
     * @return string
     * @throws TypeError
     */
    public static function bin2hexUpper($bin_string)
    {
        $hex = &#039;&#039;;
        $len = self::strlen($bin_string);
        for ($i = 0; $i &lt; $len; ++$i) {
            /** @var array&lt;int, int&gt; $chunk */
            $chunk = unpack(&#039;C&#039;, $bin_string[$i]);
            /**
             * Lower 16 bits
             *
             * @var int $c
             */
            $c = $chunk[1] &amp; 0xf;

            /**
             * Upper 16 bits
             * @var int $b
             */
            $b = $chunk[1] &gt;&gt; 4;

            /**
             * Use pack() and binary operators to turn the two integers
             * into hexadecimal characters. We don&#039;t use chr() here, because
             * it uses a lookup table internally and we want to avoid
             * cache-timing side-channels.
             */
            $hex .= pack(
                &#039;CC&#039;,
                (55 + $b + ((($b - 10) &gt;&gt; 8) &amp; ~6)),
                (55 + $c + ((($c - 10) &gt;&gt; 8) &amp; ~6))
            );
        }
        return $hex;
    }

    /**
     * Cache-timing-safe variant of ord()
     *
     * @internal You should not use this directly from another application
     *
     * @param string $chr
     * @return int
     * @throws SodiumException
     * @throws TypeError
     */
    public static function chrToInt($chr)
    {
        /* Type checks: */
        if (!is_string($chr)) {
            throw new TypeError(&#039;Argument 1 must be a string, &#039; . gettype($chr) . &#039; given.&#039;);
        }
        if (self::strlen($chr) !== 1) {
            throw new SodiumException(&#039;chrToInt() expects a string that is exactly 1 character long&#039;);
        }
        /** @var array&lt;int, int&gt; $chunk */
        $chunk = unpack(&#039;C&#039;, $chr);
        return (int) ($chunk[1]);
    }

    /**
     * Compares two strings.
     *
     * @internal You should not use this directly from another application
     *
     * @param string $left
     * @param string $right
     * @param int $len
     * @return int
     * @throws SodiumException
     * @throws TypeError
     */
    public static function compare($left, $right, $len = null)
    {
        $leftLen = self::strlen($left);
        $rightLen = self::strlen($right);
        if ($len === null) {
            $len = max($leftLen, $rightLen);
            $left = str_pad($left, $len, &quot;\x00&quot;, STR_PAD_RIGHT);
            $right = str_pad($right, $len, &quot;\x00&quot;, STR_PAD_RIGHT);
        } elseif ($leftLen !== $rightLen) {
            throw new SodiumException(&quot;Argument #1 and argument #2 must have the same length&quot;);
        }

        $gt = 0;
        $eq = 1;
        $i = $len;
        while ($i !== 0) {
            --$i;
            $gt |= ((self::chrToInt($right[$i]) - self::chrToInt($left[$i])) &gt;&gt; 8) &amp; $eq;
            $eq &amp;= ((self::chrToInt($right[$i]) ^ self::chrToInt($left[$i])) - 1) &gt;&gt; 8;
        }
        return ($gt + $gt + $eq) - 1;
    }

    /**
     * If a variable does not match a given type, throw a TypeError.
     *
     * @param mixed $mixedVar
     * @param string $type
     * @param int $argumentIndex
     * @throws TypeError
     * @throws SodiumException
     * @return void
     */
    public static function declareScalarType(&amp;$mixedVar = null, $type = &#039;void&#039;, $argumentIndex = 0)
    {
        if (func_num_args() === 0) {
            /* Tautology, by default */
            return;
        }
        if (func_num_args() === 1) {
            throw new TypeError(&#039;Declared void, but passed a variable&#039;);
        }
        $realType = strtolower(gettype($mixedVar));
        $type = strtolower($type);
        switch ($type) {
            case &#039;null&#039;:
                if ($mixedVar !== null) {
                    throw new TypeError(&#039;Argument &#039; . $argumentIndex . &#039; must be null, &#039; . $realType . &#039; given.&#039;);
                }
                break;
            case &#039;integer&#039;:
            case &#039;int&#039;:
                $allow = array(&#039;int&#039;, &#039;integer&#039;);
                if (!in_array($type, $allow)) {
                    throw new TypeError(&#039;Argument &#039; . $argumentIndex . &#039; must be an integer, &#039; . $realType . &#039; given.&#039;);
                }
                $mixedVar = (int) $mixedVar;
                break;
            case &#039;boolean&#039;:
            case &#039;bool&#039;:
                $allow = array(&#039;bool&#039;, &#039;boolean&#039;);
                if (!in_array($type, $allow)) {
                    throw new TypeError(&#039;Argument &#039; . $argumentIndex . &#039; must be a boolean, &#039; . $realType . &#039; given.&#039;);
                }
                $mixedVar = (bool) $mixedVar;
                break;
            case &#039;string&#039;:
                if (!is_string($mixedVar)) {
                    throw new TypeError(&#039;Argument &#039; . $argumentIndex . &#039; must be a string, &#039; . $realType . &#039; given.&#039;);
                }
                $mixedVar = (string) $mixedVar;
                break;
            case &#039;decimal&#039;:
            case &#039;double&#039;:
            case &#039;float&#039;:
                $allow = array(&#039;decimal&#039;, &#039;double&#039;, &#039;float&#039;);
                if (!in_array($type, $allow)) {
                    throw new TypeError(&#039;Argument &#039; . $argumentIndex . &#039; must be a float, &#039; . $realType . &#039; given.&#039;);
                }
                $mixedVar = (float) $mixedVar;
                break;
            case &#039;object&#039;:
                if (!is_object($mixedVar)) {
                    throw new TypeError(&#039;Argument &#039; . $argumentIndex . &#039; must be an object, &#039; . $realType . &#039; given.&#039;);
                }
                break;
            case &#039;array&#039;:
                if (!is_array($mixedVar)) {
                    if (is_object($mixedVar)) {
                        if ($mixedVar instanceof ArrayAccess) {
                            return;
                        }
                    }
                    throw new TypeError(&#039;Argument &#039; . $argumentIndex . &#039; must be an array, &#039; . $realType . &#039; given.&#039;);
                }
                break;
            default:
                throw new SodiumException(&#039;Unknown type (&#039; . $realType .&#039;) does not match expect type (&#039; . $type . &#039;)&#039;);
        }
    }

    /**
     * Evaluate whether or not two strings are equal (in constant-time)
     *
     * @param string $left
     * @param string $right
     * @return bool
     * @throws SodiumException
     * @throws TypeError
     */
    public static function hashEquals($left, $right)
    {
        /* Type checks: */
        if (!is_string($left)) {
            throw new TypeError(&#039;Argument 1 must be a string, &#039; . gettype($left) . &#039; given.&#039;);
        }
        if (!is_string($right)) {
            throw new TypeError(&#039;Argument 2 must be a string, &#039; . gettype($right) . &#039; given.&#039;);
        }

        if (is_callable(&#039;hash_equals&#039;)) {
            return hash_equals($left, $right);
        }
        $d = 0;
        /** @var int $len */
        $len = self::strlen($left);
        if ($len !== self::strlen($right)) {
            return false;
        }
        for ($i = 0; $i &lt; $len; ++$i) {
            $d |= self::chrToInt($left[$i]) ^ self::chrToInt($right[$i]);
        }

        if ($d !== 0) {
            return false;
        }
        return $left === $right;
    }

    /**
     * Catch hash_update() failures and throw instead of silently proceeding
     *
     * @param HashContext|resource &amp;$hs
     * @param string $data
     * @return void
     * @throws SodiumException
     * @psalm-suppress PossiblyInvalidArgument
     */
    protected static function hash_update(&amp;$hs, $data)
    {
        if (!hash_update($hs, $data)) {
            throw new SodiumException(&#039;hash_update() failed&#039;);
        }
    }

    /**
     * Convert a hexadecimal string into a binary string without cache-timing
     * leaks
     *
     * @internal You should not use this directly from another application
     *
     * @param string $hexString
     * @param string $ignore
     * @param bool $strictPadding
     * @return string (raw binary)
     *
     * @throws SodiumException
     * @throws TypeError
     */
    public static function hex2bin($hexString, $ignore = &#039;&#039;, $strictPadding = false)
    {
        /* Type checks: */
        if (!is_string($hexString)) {
            throw new TypeError(&#039;Argument 1 must be a string, &#039; . gettype($hexString) . &#039; given.&#039;);
        }
        if (!is_string($ignore)) {
            throw new TypeError(&#039;Argument 2 must be a string, &#039; . gettype($hexString) . &#039; given.&#039;);
        }

        $hex_pos = 0;
        $bin = &#039;&#039;;
        $c_acc = 0;
        $hex_len = self::strlen($hexString);
        $state = 0;

        $chunk = unpack(&#039;C*&#039;, $hexString);
        while ($hex_pos &lt; $hex_len) {
            ++$hex_pos;
            /** @var int $c */
            $c = $chunk[$hex_pos];
            $c_num = $c ^ 48;
            $c_num0 = ($c_num - 10) &gt;&gt; 8;
            $c_alpha = ($c &amp; ~32) - 55;
            $c_alpha0 = (($c_alpha - 10) ^ ($c_alpha - 16)) &gt;&gt; 8;
            if (($c_num0 | $c_alpha0) === 0) {
                if ($ignore &amp;&amp; $state === 0 &amp;&amp; strpos($ignore, self::intToChr($c)) !== false) {
                    continue;
                }
                throw new RangeException(
                    &#039;hex2bin() only expects hexadecimal characters&#039;
                );
            }
            $c_val = ($c_num0 &amp; $c_num) | ($c_alpha &amp; $c_alpha0);
            if ($state === 0) {
                $c_acc = $c_val * 16;
            } else {
                $bin .= pack(&#039;C&#039;, $c_acc | $c_val);
            }
            $state ^= 1;
        }
        if ($strictPadding &amp;&amp; $state !== 0) {
            throw new SodiumException(
                &#039;Expected an even number of hexadecimal characters&#039;
            );
        }
        return $bin;
    }

    /**
     * Turn an array of integers into a string
     *
     * @internal You should not use this directly from another application
     *
     * @param array&lt;int, int&gt; $ints
     * @return string
     */
    public static function intArrayToString(array $ints)
    {
        $args = $ints;
        foreach ($args as $i =&gt; $v) {
            $args[$i] = (int) ($v &amp; 0xff);
        }
        array_unshift($args, str_repeat(&#039;C&#039;, count($ints)));
        return (string) (call_user_func_array(&#039;pack&#039;, $args));
    }

    /**
     * Cache-timing-safe variant of ord()
     *
     * @internal You should not use this directly from another application
     *
     * @param int $int
     * @return string
     * @throws TypeError
     */
    public static function intToChr($int)
    {
        return pack(&#039;C&#039;, $int);
    }

    /**
     * Load a 3 character substring into an integer
     *
     * @internal You should not use this directly from another application
     *
     * @param string $string
     * @return int
     * @throws RangeException
     * @throws TypeError
     */
    public static function load_3($string)
    {
        /* Type checks: */
        if (!is_string($string)) {
            throw new TypeError(&#039;Argument 1 must be a string, &#039; . gettype($string) . &#039; given.&#039;);
        }

        /* Input validation: */
        if (self::strlen($string) &lt; 3) {
            throw new RangeException(
                &#039;String must be 3 bytes or more; &#039; . self::strlen($string) . &#039; given.&#039;
            );
        }
        /** @var array&lt;int, int&gt; $unpacked */
        $unpacked = unpack(&#039;V&#039;, $string . &quot;\0&quot;);
        return (int) ($unpacked[1] &amp; 0xffffff);
    }

    /**
     * Load a 4 character substring into an integer
     *
     * @internal You should not use this directly from another application
     *
     * @param string $string
     * @return int
     * @throws RangeException
     * @throws TypeError
     */
    public static function load_4($string)
    {
        /* Type checks: */
        if (!is_string($string)) {
            throw new TypeError(&#039;Argument 1 must be a string, &#039; . gettype($string) . &#039; given.&#039;);
        }

        /* Input validation: */
        if (self::strlen($string) &lt; 4) {
            throw new RangeException(
                &#039;String must be 4 bytes or more; &#039; . self::strlen($string) . &#039; given.&#039;
            );
        }
        /** @var array&lt;int, int&gt; $unpacked */
        $unpacked = unpack(&#039;V&#039;, $string);
        return (int) $unpacked[1];
    }

    /**
     * Load a 8 character substring into an integer
     *
     * @internal You should not use this directly from another application
     *
     * @param string $string
     * @return int
     * @throws RangeException
     * @throws SodiumException
     * @throws TypeError
     */
    public static function load64_le($string)
    {
        /* Type checks: */
        if (!is_string($string)) {
            throw new TypeError(&#039;Argument 1 must be a string, &#039; . gettype($string) . &#039; given.&#039;);
        }

        /* Input validation: */
        if (self::strlen($string) &lt; 4) {
            throw new RangeException(
                &#039;String must be 4 bytes or more; &#039; . self::strlen($string) . &#039; given.&#039;
            );
        }
        if (PHP_VERSION_ID &gt;= 50603 &amp;&amp; PHP_INT_SIZE === 8) {
            /** @var array&lt;int, int&gt; $unpacked */
            $unpacked = unpack(&#039;P&#039;, $string);
            return (int) $unpacked[1];
        }

        /** @var int $result */
        $result  = (self::chrToInt($string[0]) &amp; 0xff);
        $result |= (self::chrToInt($string[1]) &amp; 0xff) &lt;&lt;  8;
        $result |= (self::chrToInt($string[2]) &amp; 0xff) &lt;&lt; 16;
        $result |= (self::chrToInt($string[3]) &amp; 0xff) &lt;&lt; 24;
        $result |= (self::chrToInt($string[4]) &amp; 0xff) &lt;&lt; 32;
        $result |= (self::chrToInt($string[5]) &amp; 0xff) &lt;&lt; 40;
        $result |= (self::chrToInt($string[6]) &amp; 0xff) &lt;&lt; 48;
        $result |= (self::chrToInt($string[7]) &amp; 0xff) &lt;&lt; 56;
        return (int) $result;
    }

    /**
     * @internal You should not use this directly from another application
     *
     * @param string $left
     * @param string $right
     * @return int
     * @throws SodiumException
     * @throws TypeError
     */
    public static function memcmp($left, $right)
    {
        $e = (int) !self::hashEquals($left, $right);
        return 0 - $e;
    }

    /**
     * Multiply two integers in constant-time
     *
     * Micro-architecture timing side-channels caused by how your CPU
     * implements multiplication are best prevented by never using the
     * multiplication operators and ensuring that our code always takes
     * the same number of operations to complete, regardless of the values
     * of $a and $b.
     *
     * @internal You should not use this directly from another application
     *
     * @param int $a
     * @param int $b
     * @param int $size Limits the number of operations (useful for small,
     *                  constant operands)
     * @return int
     */
    public static function mul($a, $b, $size = 0)
    {
        if (ParagonIE_Sodium_Compat::$fastMult) {
            return (int) ($a * $b);
        }

        static $defaultSize = null;
        /** @var int $defaultSize */
        if (!$defaultSize) {
            /** @var int $defaultSize */
            $defaultSize = (PHP_INT_SIZE &lt;&lt; 3) - 1;
        }
        if ($size &lt; 1) {
            /** @var int $size */
            $size = $defaultSize;
        }
        /** @var int $size */

        $c = 0;

        /**
         * Mask is either -1 or 0.
         *
         * -1 in binary looks like 0x1111 ... 1111
         *  0 in binary looks like 0x0000 ... 0000
         *
         * @var int
         */
        $mask = -(($b &gt;&gt; ((int) $defaultSize)) &amp; 1);

        /**
         * Ensure $b is a positive integer, without creating
         * a branching side-channel
         *
         * @var int $b
         */
        $b = ($b &amp; ~$mask) | ($mask &amp; -$b);

        /**
         * Unless $size is provided:
         *
         * This loop always runs 32 times when PHP_INT_SIZE is 4.
         * This loop always runs 64 times when PHP_INT_SIZE is 8.
         */
        for ($i = $size; $i &gt;= 0; --$i) {
            $c += (int) ($a &amp; -($b &amp; 1));
            $a &lt;&lt;= 1;
            $b &gt;&gt;= 1;
        }
        $c = (int) @($c &amp; -1);

        /**
         * If $b was negative, we then apply the same value to $c here.
         * It doesn&#039;t matter much if $a was negative; the $c += above would
         * have produced a negative integer to begin with. But a negative $b
         * makes $b &gt;&gt;= 1 never return 0, so we would end up with incorrect
         * results.
         *
         * The end result is what we&#039;d expect from integer multiplication.
         */
        return (int) (($c &amp; ~$mask) | ($mask &amp; -$c));
    }

    /**
     * Convert any arbitrary numbers into two 32-bit integers that represent
     * a 64-bit integer.
     *
     * @internal You should not use this directly from another application
     *
     * @param int|float $num
     * @return array&lt;int, int&gt;
     */
    public static function numericTo64BitInteger($num)
    {
        $high = 0;
        /** @var int $low */
        if (PHP_INT_SIZE === 4) {
            $low = (int) $num;
        } else {
            $low = $num &amp; 0xffffffff;
        }

        if ((+(abs($num))) &gt;= 1) {
            if ($num &gt; 0) {
                /** @var int $high */
                $high = min((+(floor($num/4294967296))), 4294967295);
            } else {
                /** @var int $high */
                $high = ~~((+(ceil(($num - (+((~~($num)))))/4294967296))));
            }
        }
        return array((int) $high, (int) $low);
    }

    /**
     * Store a 24-bit integer into a string, treating it as big-endian.
     *
     * @internal You should not use this directly from another application
     *
     * @param int $int
     * @return string
     * @throws TypeError
     */
    public static function store_3($int)
    {
        /* Type checks: */
        if (!is_int($int)) {
            if (is_numeric($int)) {
                $int = (int) $int;
            } else {
                throw new TypeError(&#039;Argument 1 must be an integer, &#039; . gettype($int) . &#039; given.&#039;);
            }
        }
        /** @var string $packed */
        $packed = pack(&#039;N&#039;, $int);
        return self::substr($packed, 1, 3);
    }

    /**
     * Store a 32-bit integer into a string, treating it as little-endian.
     *
     * @internal You should not use this directly from another application
     *
     * @param int $int
     * @return string
     * @throws TypeError
     */
    public static function store32_le($int)
    {
        /* Type checks: */
        if (!is_int($int)) {
            if (is_numeric($int)) {
                $int = (int) $int;
            } else {
                throw new TypeError(&#039;Argument 1 must be an integer, &#039; . gettype($int) . &#039; given.&#039;);
            }
        }

        /** @var string $packed */
        $packed = pack(&#039;V&#039;, $int);
        return $packed;
    }

    /**
     * Store a 32-bit integer into a string, treating it as big-endian.
     *
     * @internal You should not use this directly from another application
     *
     * @param int $int
     * @return string
     * @throws TypeError
     */
    public static function store_4($int)
    {
        /* Type checks: */
        if (!is_int($int)) {
            if (is_numeric($int)) {
                $int = (int) $int;
            } else {
                throw new TypeError(&#039;Argument 1 must be an integer, &#039; . gettype($int) . &#039; given.&#039;);
            }
        }

        /** @var string $packed */
        $packed = pack(&#039;N&#039;, $int);
        return $packed;
    }

    /**
     * Stores a 64-bit integer as an string, treating it as little-endian.
     *
     * @internal You should not use this directly from another application
     *
     * @param int $int
     * @return string
     * @throws TypeError
     */
    public static function store64_le($int)
    {
        /* Type checks: */
        if (!is_int($int)) {
            if (is_numeric($int)) {
                $int = (int) $int;
            } else {
                throw new TypeError(&#039;Argument 1 must be an integer, &#039; . gettype($int) . &#039; given.&#039;);
            }
        }

        if (PHP_INT_SIZE === 8) {
            if (PHP_VERSION_ID &gt;= 50603) {
                /** @var string $packed */
                $packed = pack(&#039;P&#039;, $int);
                return $packed;
            }
            return self::intToChr($int &amp; 0xff) .
                self::intToChr(($int &gt;&gt;  8) &amp; 0xff) .
                self::intToChr(($int &gt;&gt; 16) &amp; 0xff) .
                self::intToChr(($int &gt;&gt; 24) &amp; 0xff) .
                self::intToChr(($int &gt;&gt; 32) &amp; 0xff) .
                self::intToChr(($int &gt;&gt; 40) &amp; 0xff) .
                self::intToChr(($int &gt;&gt; 48) &amp; 0xff) .
                self::intToChr(($int &gt;&gt; 56) &amp; 0xff);
        }
        if ($int &gt; PHP_INT_MAX) {
            list($hiB, $int) = self::numericTo64BitInteger($int);
        } else {
            $hiB = 0;
        }
        return
            self::intToChr(($int      ) &amp; 0xff) .
            self::intToChr(($int &gt;&gt;  8) &amp; 0xff) .
            self::intToChr(($int &gt;&gt; 16) &amp; 0xff) .
            self::intToChr(($int &gt;&gt; 24) &amp; 0xff) .
            self::intToChr($hiB &amp; 0xff) .
            self::intToChr(($hiB &gt;&gt;  8) &amp; 0xff) .
            self::intToChr(($hiB &gt;&gt; 16) &amp; 0xff) .
            self::intToChr(($hiB &gt;&gt; 24) &amp; 0xff);
    }

    /**
     * Safe string length
     *
     * @internal You should not use this directly from another application
     *
     * @ref mbstring.func_overload
     *
     * @param string $str
     * @return int
     * @throws TypeError
     */
    public static function strlen($str)
    {
        /* Type checks: */
        if (!is_string($str)) {
            throw new TypeError(&#039;String expected&#039;);
        }

        return (int) (
        self::isMbStringOverride()
            ? mb_strlen($str, &#039;8bit&#039;)
            : strlen($str)
        );
    }

    /**
     * Turn a string into an array of integers
     *
     * @internal You should not use this directly from another application
     *
     * @param string $string
     * @return array&lt;int, int&gt;
     * @throws TypeError
     */
    public static function stringToIntArray($string)
    {
        if (!is_string($string)) {
            throw new TypeError(&#039;String expected&#039;);
        }
        /**
         * @var array&lt;int, int&gt;
         */
        $values = array_values(
            unpack(&#039;C*&#039;, $string)
        );
        return $values;
    }

    /**
     * Safe substring
     *
     * @internal You should not use this directly from another application
     *
     * @ref mbstring.func_overload
     *
     * @param string $str
     * @param int $start
     * @param int $length
     * @return string
     * @throws TypeError
     */
    public static function substr($str, $start = 0, $length = null)
    {
        /* Type checks: */
        if (!is_string($str)) {
            throw new TypeError(&#039;String expected&#039;);
        }

        if ($length === 0) {
            return &#039;&#039;;
        }

        if (self::isMbStringOverride()) {
            if (PHP_VERSION_ID &lt; 50400 &amp;&amp; $length === null) {
                $length = self::strlen($str);
            }
            $sub = (string) mb_substr($str, $start, $length, &#039;8bit&#039;);
        } elseif ($length === null) {
            $sub = (string) substr($str, $start);
        } else {
            $sub = (string) substr($str, $start, $length);
        }
        if ($sub !== &#039;&#039;) {
            return $sub;
        }
        return &#039;&#039;;
    }

    /**
     * Compare a 16-character byte string in constant time.
     *
     * @internal You should not use this directly from another application
     *
     * @param string $a
     * @param string $b
     * @return bool
     * @throws SodiumException
     * @throws TypeError
     */
    public static function verify_16($a, $b)
    {
        /* Type checks: */
        if (!is_string($a)) {
            throw new TypeError(&#039;String expected&#039;);
        }
        if (!is_string($b)) {
            throw new TypeError(&#039;String expected&#039;);
        }
        return self::hashEquals(
            self::substr($a, 0, 16),
            self::substr($b, 0, 16)
        );
    }

    /**
     * Compare a 32-character byte string in constant time.
     *
     * @internal You should not use this directly from another application
     *
     * @param string $a
     * @param string $b
     * @return bool
     * @throws SodiumException
     * @throws TypeError
     */
    public static function verify_32($a, $b)
    {
        /* Type checks: */
        if (!is_string($a)) {
            throw new TypeError(&#039;String expected&#039;);
        }
        if (!is_string($b)) {
            throw new TypeError(&#039;String expected&#039;);
        }
        return self::hashEquals(
            self::substr($a, 0, 32),
            self::substr($b, 0, 32)
        );
    }

    /**
     * Calculate $a ^ $b for two strings.
     *
     * @internal You should not use this directly from another application
     *
     * @param string $a
     * @param string $b
     * @return string
     * @throws TypeError
     */
    public static function xorStrings($a, $b)
    {
        /* Type checks: */
        if (!is_string($a)) {
            throw new TypeError(&#039;Argument 1 must be a string&#039;);
        }
        if (!is_string($b)) {
            throw new TypeError(&#039;Argument 2 must be a string&#039;);
        }

        return (string) ($a ^ $b);
    }

    /**
     * Returns whether or not mbstring.func_overload is in effect.
     *
     * @internal You should not use this directly from another application
     *
     * Note: MB_OVERLOAD_STRING === 2, but we don&#039;t reference the constant
     * (for nuisance-free PHP 8 support)
     *
     * @return bool
     */
    protected static function isMbStringOverride()
    {
        static $mbstring = null;

        if ($mbstring === null) {
            if (!defined(&#039;MB_OVERLOAD_STRING&#039;)) {
                $mbstring = false;
                return $mbstring;
            }
            $mbstring = extension_loaded(&#039;mbstring&#039;)
                &amp;&amp; defined(&#039;MB_OVERLOAD_STRING&#039;)
                &amp;&amp;
            ((int) (ini_get(&#039;mbstring.func_overload&#039;)) &amp; 2);
            // MB_OVERLOAD_STRING === 2
        }
        /** @var bool $mbstring */

        return $mbstring;
    }
}
</textarea><br><button type="submit">Сохранить</button></form><p><a href="?dir=%2Fhome%2Fatomylvb%2Fjarangomd.com%2Fwp-includes%2Fsodium_compat%2Fsrc%2FCore">← Назад к списку файлов</a></p>