gravityview / GravityView

vendor/paragonie/sodium_compat/src/Core/Util.php

Indentation +936 added lines, -936 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_Util', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,939 +9,939 @@ 
  */
 abstract class ParagonIE_Sodium_Core_Util
 {
-    /**
-     * @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 << 3) - 1;
-        if ($size) {
-            --$size;
-        } else {
-            /** @var int $size */
-            $size = $realSize;
-        }
-
-        $negative = -(($integer >> $size) & 1);
-        return (int) (
-            ($integer ^ $negative)
-                +
-            (($negative >> $realSize) & 1)
-        );
-    }
-
-    /**
-     * 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('Argument 1 must be a string, ' . gettype($binaryString) . ' given.');
-        }
-
-        $hex = '';
-        $len = self::strlen($binaryString);
-        for ($i = 0; $i < $len; ++$i) {
-            /** @var array<int, int> $chunk */
-            $chunk = unpack('C', $binaryString[$i]);
-            /** @var int $c */
-            $c = $chunk[1] & 0xf;
-            /** @var int $b */
-            $b = $chunk[1] >> 4;
-            $hex .= pack(
-                'CC',
-                (87 + $b + ((($b - 10) >> 8) & ~38)),
-                (87 + $c + ((($c - 10) >> 8) & ~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 = '';
-        $len = self::strlen($bin_string);
-        for ($i = 0; $i < $len; ++$i) {
-            /** @var array<int, int> $chunk */
-            $chunk = unpack('C', $bin_string[$i]);
-            /**
-             * Lower 16 bits
-             *
-             * @var int $c
-             */
-            $c = $chunk[1] & 0xf;
-
-            /**
-             * Upper 16 bits
-             * @var int $b
-             */
-            $b = $chunk[1] >> 4;
-
-            /**
-             * Use pack() and binary operators to turn the two integers
-             * into hexadecimal characters. We don't use chr() here, because
-             * it uses a lookup table internally and we want to avoid
-             * cache-timing side-channels.
-             */
-            $hex .= pack(
-                'CC',
-                (55 + $b + ((($b - 10) >> 8) & ~6)),
-                (55 + $c + ((($c - 10) >> 8) & ~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('Argument 1 must be a string, ' . gettype($chr) . ' given.');
-        }
-        if (self::strlen($chr) !== 1) {
-            throw new SodiumException('chrToInt() expects a string that is exactly 1 character long');
-        }
-        /** @var array<int, int> $chunk */
-        $chunk = unpack('C', $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, "\x00", STR_PAD_RIGHT);
-            $right = str_pad($right, $len, "\x00", STR_PAD_RIGHT);
-        }
-
-        $gt = 0;
-        $eq = 1;
-        $i = $len;
-        while ($i !== 0) {
-            --$i;
-            $gt |= ((self::chrToInt($right[$i]) - self::chrToInt($left[$i])) >> 8) & $eq;
-            $eq &= ((self::chrToInt($right[$i]) ^ self::chrToInt($left[$i])) - 1) >> 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(&$mixedVar = null, $type = 'void', $argumentIndex = 0)
-    {
-        if (func_num_args() === 0) {
-            /* Tautology, by default */
-            return;
-        }
-        if (func_num_args() === 1) {
-            throw new TypeError('Declared void, but passed a variable');
-        }
-        $realType = strtolower(gettype($mixedVar));
-        $type = strtolower($type);
-        switch ($type) {
-            case 'null':
-                if ($mixedVar !== null) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be null, ' . $realType . ' given.');
-                }
-                break;
-            case 'integer':
-            case 'int':
-                $allow = array('int', 'integer');
-                if (!in_array($type, $allow)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be an integer, ' . $realType . ' given.');
-                }
-                $mixedVar = (int) $mixedVar;
-                break;
-            case 'boolean':
-            case 'bool':
-                $allow = array('bool', 'boolean');
-                if (!in_array($type, $allow)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be a boolean, ' . $realType . ' given.');
-                }
-                $mixedVar = (bool) $mixedVar;
-                break;
-            case 'string':
-                if (!is_string($mixedVar)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be a string, ' . $realType . ' given.');
-                }
-                $mixedVar = (string) $mixedVar;
-                break;
-            case 'decimal':
-            case 'double':
-            case 'float':
-                $allow = array('decimal', 'double', 'float');
-                if (!in_array($type, $allow)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be a float, ' . $realType . ' given.');
-                }
-                $mixedVar = (float) $mixedVar;
-                break;
-            case 'object':
-                if (!is_object($mixedVar)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be an object, ' . $realType . ' given.');
-                }
-                break;
-            case 'array':
-                if (!is_array($mixedVar)) {
-                    if (is_object($mixedVar)) {
-                        if ($mixedVar instanceof ArrayAccess) {
-                            return;
-                        }
-                    }
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be an array, ' . $realType . ' given.');
-                }
-                break;
-            default:
-                throw new SodiumException('Unknown type (' . $realType .') does not match expect type (' . $type . ')');
-        }
-    }
-
-    /**
-     * 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('Argument 1 must be a string, ' . gettype($left) . ' given.');
-        }
-        if (!is_string($right)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($right) . ' given.');
-        }
-
-        if (is_callable('hash_equals')) {
-            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 < $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 &$hs
-     * @param string $data
-     * @return void
-     * @throws SodiumException
-     * @psalm-suppress PossiblyInvalidArgument
-     */
-    protected static function hash_update(&$hs, $data)
-    {
-        if (!hash_update($hs, $data)) {
-            throw new SodiumException('hash_update() failed');
-        }
-    }
-
-    /**
-     * 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 bool $strictPadding
-     * @return string (raw binary)
-     * @throws RangeException
-     * @throws TypeError
-     */
-    public static function hex2bin($hexString, $strictPadding = false)
-    {
-        /* Type checks: */
-        if (!is_string($hexString)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($hexString) . ' given.');
-        }
-
-        /** @var int $hex_pos */
-        $hex_pos = 0;
-        /** @var string $bin */
-        $bin = '';
-        /** @var int $c_acc */
-        $c_acc = 0;
-        /** @var int $hex_len */
-        $hex_len = self::strlen($hexString);
-        /** @var int $state */
-        $state = 0;
-        if (($hex_len & 1) !== 0) {
-            if ($strictPadding) {
-                throw new RangeException(
-                    'Expected an even number of hexadecimal characters'
-                );
-            } else {
-                $hexString = '0' . $hexString;
-                ++$hex_len;
-            }
-        }
-
-        $chunk = unpack('C*', $hexString);
-        while ($hex_pos < $hex_len) {
-            ++$hex_pos;
-            /** @var int $c */
-            $c = $chunk[$hex_pos];
-            /** @var int $c_num */
-            $c_num = $c ^ 48;
-            /** @var int $c_num0 */
-            $c_num0 = ($c_num - 10) >> 8;
-            /** @var int $c_alpha */
-            $c_alpha = ($c & ~32) - 55;
-            /** @var int $c_alpha0 */
-            $c_alpha0 = (($c_alpha - 10) ^ ($c_alpha - 16)) >> 8;
-            if (($c_num0 | $c_alpha0) === 0) {
-                throw new RangeException(
-                    'hex2bin() only expects hexadecimal characters'
-                );
-            }
-            /** @var int $c_val */
-            $c_val = ($c_num0 & $c_num) | ($c_alpha & $c_alpha0);
-            if ($state === 0) {
-                $c_acc = $c_val * 16;
-            } else {
-                $bin .= pack('C', $c_acc | $c_val);
-            }
-            $state ^= 1;
-        }
-        return $bin;
-    }
-
-    /**
-     * Turn an array of integers into a string
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param array<int, int> $ints
-     * @return string
-     */
-    public static function intArrayToString(array $ints)
-    {
-        /** @var array<int, int> $args */
-        $args = $ints;
-        foreach ($args as $i => $v) {
-            $args[$i] = (int) ($v & 0xff);
-        }
-        array_unshift($args, str_repeat('C', count($ints)));
-        return (string) (call_user_func_array('pack', $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('C', $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('Argument 1 must be a string, ' . gettype($string) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($string) < 3) {
-            throw new RangeException(
-                'String must be 3 bytes or more; ' . self::strlen($string) . ' given.'
-            );
-        }
-        /** @var array<int, int> $unpacked */
-        $unpacked = unpack('V', $string . "\0");
-        return (int) ($unpacked[1] & 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('Argument 1 must be a string, ' . gettype($string) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($string) < 4) {
-            throw new RangeException(
-                'String must be 4 bytes or more; ' . self::strlen($string) . ' given.'
-            );
-        }
-        /** @var array<int, int> $unpacked */
-        $unpacked = unpack('V', $string);
-        return (int) ($unpacked[1] & 0xffffffff);
-    }
-
-    /**
-     * 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('Argument 1 must be a string, ' . gettype($string) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($string) < 4) {
-            throw new RangeException(
-                'String must be 4 bytes or more; ' . self::strlen($string) . ' given.'
-            );
-        }
-        if (PHP_VERSION_ID >= 50603 && PHP_INT_SIZE === 8) {
-            /** @var array<int, int> $unpacked */
-            $unpacked = unpack('P', $string);
-            return (int) $unpacked[1];
-        }
-
-        /** @var int $result */
-        $result  = (self::chrToInt($string[0]) & 0xff);
-        $result |= (self::chrToInt($string[1]) & 0xff) <<  8;
-        $result |= (self::chrToInt($string[2]) & 0xff) << 16;
-        $result |= (self::chrToInt($string[3]) & 0xff) << 24;
-        $result |= (self::chrToInt($string[4]) & 0xff) << 32;
-        $result |= (self::chrToInt($string[5]) & 0xff) << 40;
-        $result |= (self::chrToInt($string[6]) & 0xff) << 48;
-        $result |= (self::chrToInt($string[7]) & 0xff) << 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)
-    {
-        if (self::hashEquals($left, $right)) {
-            return 0;
-        }
-        return -1;
-    }
-
-    /**
-     * 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 << 3) - 1;
-        }
-        if ($size < 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 >> ((int) $defaultSize)) & 1);
-
-        /**
-         * Ensure $b is a positive integer, without creating
-         * a branching side-channel
-         *
-         * @var int $b
-         */
-        $b = ($b & ~$mask) | ($mask & -$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 >= 0; --$i) {
-            $c += (int) ($a & -($b & 1));
-            $a <<= 1;
-            $b >>= 1;
-        }
-        $c = (int) @($c & -1);
-
-        /**
-         * If $b was negative, we then apply the same value to $c here.
-         * It doesn'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 >>= 1 never return 0, so we would end up with incorrect
-         * results.
-         *
-         * The end result is what we'd expect from integer multiplication.
-         */
-        return (int) (($c & ~$mask) | ($mask & -$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<int, int>
-     */
-    public static function numericTo64BitInteger($num)
-    {
-        $high = 0;
-        /** @var int $low */
-        $low = $num & 0xffffffff;
-
-        if ((+(abs($num))) >= 1) {
-            if ($num > 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('Argument 1 must be an integer, ' . gettype($int) . ' given.');
-            }
-        }
-        /** @var string $packed */
-        $packed = pack('N', $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('Argument 1 must be an integer, ' . gettype($int) . ' given.');
-            }
-        }
-
-        /** @var string $packed */
-        $packed = pack('V', $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('Argument 1 must be an integer, ' . gettype($int) . ' given.');
-            }
-        }
-
-        /** @var string $packed */
-        $packed = pack('N', $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('Argument 1 must be an integer, ' . gettype($int) . ' given.');
-            }
-        }
-
-        if (PHP_INT_SIZE === 8) {
-            if (PHP_VERSION_ID >= 50603) {
-                /** @var string $packed */
-                $packed = pack('P', $int);
-                return $packed;
-            }
-            return self::intToChr($int & 0xff) .
-                self::intToChr(($int >>  8) & 0xff) .
-                self::intToChr(($int >> 16) & 0xff) .
-                self::intToChr(($int >> 24) & 0xff) .
-                self::intToChr(($int >> 32) & 0xff) .
-                self::intToChr(($int >> 40) & 0xff) .
-                self::intToChr(($int >> 48) & 0xff) .
-                self::intToChr(($int >> 56) & 0xff);
-        }
-        if ($int > PHP_INT_MAX) {
-            list($hiB, $int) = self::numericTo64BitInteger($int);
-        } else {
-            $hiB = 0;
-        }
-        return
-            self::intToChr(($int      ) & 0xff) .
-            self::intToChr(($int >>  8) & 0xff) .
-            self::intToChr(($int >> 16) & 0xff) .
-            self::intToChr(($int >> 24) & 0xff) .
-            self::intToChr($hiB & 0xff) .
-            self::intToChr(($hiB >>  8) & 0xff) .
-            self::intToChr(($hiB >> 16) & 0xff) .
-            self::intToChr(($hiB >> 24) & 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('String expected');
-        }
-
-        return (int) (
-        self::isMbStringOverride()
-            ? mb_strlen($str, '8bit')
-            : 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<int, int>
-     * @throws TypeError
-     */
-    public static function stringToIntArray($string)
-    {
-        if (!is_string($string)) {
-            throw new TypeError('String expected');
-        }
-        /**
-         * @var array<int, int>
-         */
-        $values = array_values(
-            unpack('C*', $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('String expected');
-        }
-
-        if ($length === 0) {
-            return '';
-        }
-
-        if (self::isMbStringOverride()) {
-            if (PHP_VERSION_ID < 50400 && $length === null) {
-                $length = self::strlen($str);
-            }
-            $sub = (string) mb_substr($str, $start, $length, '8bit');
-        } elseif ($length === null) {
-            $sub = (string) substr($str, $start);
-        } else {
-            $sub = (string) substr($str, $start, $length);
-        }
-        if ($sub !== '') {
-            return $sub;
-        }
-        return '';
-    }
-
-    /**
-     * 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('String expected');
-        }
-        if (!is_string($b)) {
-            throw new TypeError('String expected');
-        }
-        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('String expected');
-        }
-        if (!is_string($b)) {
-            throw new TypeError('String expected');
-        }
-        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('Argument 1 must be a string');
-        }
-        if (!is_string($b)) {
-            throw new TypeError('Argument 2 must be a string');
-        }
-
-        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't reference the constant
-     * (for nuisance-free PHP 8 support)
-     *
-     * @return bool
-     */
-    protected static function isMbStringOverride()
-    {
-        static $mbstring = null;
-
-        if ($mbstring === null) {
-            if (!defined('MB_OVERLOAD_STRING')) {
-                $mbstring = false;
-                return $mbstring;
-            }
-            $mbstring = extension_loaded('mbstring')
-                && defined('MB_OVERLOAD_STRING')
-                &&
-            ((int) (ini_get('mbstring.func_overload')) & 2);
-            // MB_OVERLOAD_STRING === 2
-        }
-        /** @var bool $mbstring */
-
-        return $mbstring;
-    }
+	/**
+	 * @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 << 3) - 1;
+		if ($size) {
+			--$size;
+		} else {
+			/** @var int $size */
+			$size = $realSize;
+		}
+
+		$negative = -(($integer >> $size) & 1);
+		return (int) (
+			($integer ^ $negative)
+				+
+			(($negative >> $realSize) & 1)
+		);
+	}
+
+	/**
+	 * 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('Argument 1 must be a string, ' . gettype($binaryString) . ' given.');
+		}
+
+		$hex = '';
+		$len = self::strlen($binaryString);
+		for ($i = 0; $i < $len; ++$i) {
+			/** @var array<int, int> $chunk */
+			$chunk = unpack('C', $binaryString[$i]);
+			/** @var int $c */
+			$c = $chunk[1] & 0xf;
+			/** @var int $b */
+			$b = $chunk[1] >> 4;
+			$hex .= pack(
+				'CC',
+				(87 + $b + ((($b - 10) >> 8) & ~38)),
+				(87 + $c + ((($c - 10) >> 8) & ~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 = '';
+		$len = self::strlen($bin_string);
+		for ($i = 0; $i < $len; ++$i) {
+			/** @var array<int, int> $chunk */
+			$chunk = unpack('C', $bin_string[$i]);
+			/**
+			 * Lower 16 bits
+			 *
+			 * @var int $c
+			 */
+			$c = $chunk[1] & 0xf;
+
+			/**
+			 * Upper 16 bits
+			 * @var int $b
+			 */
+			$b = $chunk[1] >> 4;
+
+			/**
+			 * Use pack() and binary operators to turn the two integers
+			 * into hexadecimal characters. We don't use chr() here, because
+			 * it uses a lookup table internally and we want to avoid
+			 * cache-timing side-channels.
+			 */
+			$hex .= pack(
+				'CC',
+				(55 + $b + ((($b - 10) >> 8) & ~6)),
+				(55 + $c + ((($c - 10) >> 8) & ~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('Argument 1 must be a string, ' . gettype($chr) . ' given.');
+		}
+		if (self::strlen($chr) !== 1) {
+			throw new SodiumException('chrToInt() expects a string that is exactly 1 character long');
+		}
+		/** @var array<int, int> $chunk */
+		$chunk = unpack('C', $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, "\x00", STR_PAD_RIGHT);
+			$right = str_pad($right, $len, "\x00", STR_PAD_RIGHT);
+		}
+
+		$gt = 0;
+		$eq = 1;
+		$i = $len;
+		while ($i !== 0) {
+			--$i;
+			$gt |= ((self::chrToInt($right[$i]) - self::chrToInt($left[$i])) >> 8) & $eq;
+			$eq &= ((self::chrToInt($right[$i]) ^ self::chrToInt($left[$i])) - 1) >> 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(&$mixedVar = null, $type = 'void', $argumentIndex = 0)
+	{
+		if (func_num_args() === 0) {
+			/* Tautology, by default */
+			return;
+		}
+		if (func_num_args() === 1) {
+			throw new TypeError('Declared void, but passed a variable');
+		}
+		$realType = strtolower(gettype($mixedVar));
+		$type = strtolower($type);
+		switch ($type) {
+			case 'null':
+				if ($mixedVar !== null) {
+					throw new TypeError('Argument ' . $argumentIndex . ' must be null, ' . $realType . ' given.');
+				}
+				break;
+			case 'integer':
+			case 'int':
+				$allow = array('int', 'integer');
+				if (!in_array($type, $allow)) {
+					throw new TypeError('Argument ' . $argumentIndex . ' must be an integer, ' . $realType . ' given.');
+				}
+				$mixedVar = (int) $mixedVar;
+				break;
+			case 'boolean':
+			case 'bool':
+				$allow = array('bool', 'boolean');
+				if (!in_array($type, $allow)) {
+					throw new TypeError('Argument ' . $argumentIndex . ' must be a boolean, ' . $realType . ' given.');
+				}
+				$mixedVar = (bool) $mixedVar;
+				break;
+			case 'string':
+				if (!is_string($mixedVar)) {
+					throw new TypeError('Argument ' . $argumentIndex . ' must be a string, ' . $realType . ' given.');
+				}
+				$mixedVar = (string) $mixedVar;
+				break;
+			case 'decimal':
+			case 'double':
+			case 'float':
+				$allow = array('decimal', 'double', 'float');
+				if (!in_array($type, $allow)) {
+					throw new TypeError('Argument ' . $argumentIndex . ' must be a float, ' . $realType . ' given.');
+				}
+				$mixedVar = (float) $mixedVar;
+				break;
+			case 'object':
+				if (!is_object($mixedVar)) {
+					throw new TypeError('Argument ' . $argumentIndex . ' must be an object, ' . $realType . ' given.');
+				}
+				break;
+			case 'array':
+				if (!is_array($mixedVar)) {
+					if (is_object($mixedVar)) {
+						if ($mixedVar instanceof ArrayAccess) {
+							return;
+						}
+					}
+					throw new TypeError('Argument ' . $argumentIndex . ' must be an array, ' . $realType . ' given.');
+				}
+				break;
+			default:
+				throw new SodiumException('Unknown type (' . $realType .') does not match expect type (' . $type . ')');
+		}
+	}
+
+	/**
+	 * 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('Argument 1 must be a string, ' . gettype($left) . ' given.');
+		}
+		if (!is_string($right)) {
+			throw new TypeError('Argument 2 must be a string, ' . gettype($right) . ' given.');
+		}
+
+		if (is_callable('hash_equals')) {
+			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 < $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 &$hs
+	 * @param string $data
+	 * @return void
+	 * @throws SodiumException
+	 * @psalm-suppress PossiblyInvalidArgument
+	 */
+	protected static function hash_update(&$hs, $data)
+	{
+		if (!hash_update($hs, $data)) {
+			throw new SodiumException('hash_update() failed');
+		}
+	}
+
+	/**
+	 * 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 bool $strictPadding
+	 * @return string (raw binary)
+	 * @throws RangeException
+	 * @throws TypeError
+	 */
+	public static function hex2bin($hexString, $strictPadding = false)
+	{
+		/* Type checks: */
+		if (!is_string($hexString)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($hexString) . ' given.');
+		}
+
+		/** @var int $hex_pos */
+		$hex_pos = 0;
+		/** @var string $bin */
+		$bin = '';
+		/** @var int $c_acc */
+		$c_acc = 0;
+		/** @var int $hex_len */
+		$hex_len = self::strlen($hexString);
+		/** @var int $state */
+		$state = 0;
+		if (($hex_len & 1) !== 0) {
+			if ($strictPadding) {
+				throw new RangeException(
+					'Expected an even number of hexadecimal characters'
+				);
+			} else {
+				$hexString = '0' . $hexString;
+				++$hex_len;
+			}
+		}
+
+		$chunk = unpack('C*', $hexString);
+		while ($hex_pos < $hex_len) {
+			++$hex_pos;
+			/** @var int $c */
+			$c = $chunk[$hex_pos];
+			/** @var int $c_num */
+			$c_num = $c ^ 48;
+			/** @var int $c_num0 */
+			$c_num0 = ($c_num - 10) >> 8;
+			/** @var int $c_alpha */
+			$c_alpha = ($c & ~32) - 55;
+			/** @var int $c_alpha0 */
+			$c_alpha0 = (($c_alpha - 10) ^ ($c_alpha - 16)) >> 8;
+			if (($c_num0 | $c_alpha0) === 0) {
+				throw new RangeException(
+					'hex2bin() only expects hexadecimal characters'
+				);
+			}
+			/** @var int $c_val */
+			$c_val = ($c_num0 & $c_num) | ($c_alpha & $c_alpha0);
+			if ($state === 0) {
+				$c_acc = $c_val * 16;
+			} else {
+				$bin .= pack('C', $c_acc | $c_val);
+			}
+			$state ^= 1;
+		}
+		return $bin;
+	}
+
+	/**
+	 * Turn an array of integers into a string
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param array<int, int> $ints
+	 * @return string
+	 */
+	public static function intArrayToString(array $ints)
+	{
+		/** @var array<int, int> $args */
+		$args = $ints;
+		foreach ($args as $i => $v) {
+			$args[$i] = (int) ($v & 0xff);
+		}
+		array_unshift($args, str_repeat('C', count($ints)));
+		return (string) (call_user_func_array('pack', $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('C', $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('Argument 1 must be a string, ' . gettype($string) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($string) < 3) {
+			throw new RangeException(
+				'String must be 3 bytes or more; ' . self::strlen($string) . ' given.'
+			);
+		}
+		/** @var array<int, int> $unpacked */
+		$unpacked = unpack('V', $string . "\0");
+		return (int) ($unpacked[1] & 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('Argument 1 must be a string, ' . gettype($string) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($string) < 4) {
+			throw new RangeException(
+				'String must be 4 bytes or more; ' . self::strlen($string) . ' given.'
+			);
+		}
+		/** @var array<int, int> $unpacked */
+		$unpacked = unpack('V', $string);
+		return (int) ($unpacked[1] & 0xffffffff);
+	}
+
+	/**
+	 * 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('Argument 1 must be a string, ' . gettype($string) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($string) < 4) {
+			throw new RangeException(
+				'String must be 4 bytes or more; ' . self::strlen($string) . ' given.'
+			);
+		}
+		if (PHP_VERSION_ID >= 50603 && PHP_INT_SIZE === 8) {
+			/** @var array<int, int> $unpacked */
+			$unpacked = unpack('P', $string);
+			return (int) $unpacked[1];
+		}
+
+		/** @var int $result */
+		$result  = (self::chrToInt($string[0]) & 0xff);
+		$result |= (self::chrToInt($string[1]) & 0xff) <<  8;
+		$result |= (self::chrToInt($string[2]) & 0xff) << 16;
+		$result |= (self::chrToInt($string[3]) & 0xff) << 24;
+		$result |= (self::chrToInt($string[4]) & 0xff) << 32;
+		$result |= (self::chrToInt($string[5]) & 0xff) << 40;
+		$result |= (self::chrToInt($string[6]) & 0xff) << 48;
+		$result |= (self::chrToInt($string[7]) & 0xff) << 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)
+	{
+		if (self::hashEquals($left, $right)) {
+			return 0;
+		}
+		return -1;
+	}
+
+	/**
+	 * 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 << 3) - 1;
+		}
+		if ($size < 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 >> ((int) $defaultSize)) & 1);
+
+		/**
+		 * Ensure $b is a positive integer, without creating
+		 * a branching side-channel
+		 *
+		 * @var int $b
+		 */
+		$b = ($b & ~$mask) | ($mask & -$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 >= 0; --$i) {
+			$c += (int) ($a & -($b & 1));
+			$a <<= 1;
+			$b >>= 1;
+		}
+		$c = (int) @($c & -1);
+
+		/**
+		 * If $b was negative, we then apply the same value to $c here.
+		 * It doesn'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 >>= 1 never return 0, so we would end up with incorrect
+		 * results.
+		 *
+		 * The end result is what we'd expect from integer multiplication.
+		 */
+		return (int) (($c & ~$mask) | ($mask & -$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<int, int>
+	 */
+	public static function numericTo64BitInteger($num)
+	{
+		$high = 0;
+		/** @var int $low */
+		$low = $num & 0xffffffff;
+
+		if ((+(abs($num))) >= 1) {
+			if ($num > 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('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+			}
+		}
+		/** @var string $packed */
+		$packed = pack('N', $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('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+			}
+		}
+
+		/** @var string $packed */
+		$packed = pack('V', $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('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+			}
+		}
+
+		/** @var string $packed */
+		$packed = pack('N', $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('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+			}
+		}
+
+		if (PHP_INT_SIZE === 8) {
+			if (PHP_VERSION_ID >= 50603) {
+				/** @var string $packed */
+				$packed = pack('P', $int);
+				return $packed;
+			}
+			return self::intToChr($int & 0xff) .
+				self::intToChr(($int >>  8) & 0xff) .
+				self::intToChr(($int >> 16) & 0xff) .
+				self::intToChr(($int >> 24) & 0xff) .
+				self::intToChr(($int >> 32) & 0xff) .
+				self::intToChr(($int >> 40) & 0xff) .
+				self::intToChr(($int >> 48) & 0xff) .
+				self::intToChr(($int >> 56) & 0xff);
+		}
+		if ($int > PHP_INT_MAX) {
+			list($hiB, $int) = self::numericTo64BitInteger($int);
+		} else {
+			$hiB = 0;
+		}
+		return
+			self::intToChr(($int      ) & 0xff) .
+			self::intToChr(($int >>  8) & 0xff) .
+			self::intToChr(($int >> 16) & 0xff) .
+			self::intToChr(($int >> 24) & 0xff) .
+			self::intToChr($hiB & 0xff) .
+			self::intToChr(($hiB >>  8) & 0xff) .
+			self::intToChr(($hiB >> 16) & 0xff) .
+			self::intToChr(($hiB >> 24) & 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('String expected');
+		}
+
+		return (int) (
+		self::isMbStringOverride()
+			? mb_strlen($str, '8bit')
+			: 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<int, int>
+	 * @throws TypeError
+	 */
+	public static function stringToIntArray($string)
+	{
+		if (!is_string($string)) {
+			throw new TypeError('String expected');
+		}
+		/**
+		 * @var array<int, int>
+		 */
+		$values = array_values(
+			unpack('C*', $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('String expected');
+		}
+
+		if ($length === 0) {
+			return '';
+		}
+
+		if (self::isMbStringOverride()) {
+			if (PHP_VERSION_ID < 50400 && $length === null) {
+				$length = self::strlen($str);
+			}
+			$sub = (string) mb_substr($str, $start, $length, '8bit');
+		} elseif ($length === null) {
+			$sub = (string) substr($str, $start);
+		} else {
+			$sub = (string) substr($str, $start, $length);
+		}
+		if ($sub !== '') {
+			return $sub;
+		}
+		return '';
+	}
+
+	/**
+	 * 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('String expected');
+		}
+		if (!is_string($b)) {
+			throw new TypeError('String expected');
+		}
+		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('String expected');
+		}
+		if (!is_string($b)) {
+			throw new TypeError('String expected');
+		}
+		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('Argument 1 must be a string');
+		}
+		if (!is_string($b)) {
+			throw new TypeError('Argument 2 must be a string');
+		}
+
+		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't reference the constant
+	 * (for nuisance-free PHP 8 support)
+	 *
+	 * @return bool
+	 */
+	protected static function isMbStringOverride()
+	{
+		static $mbstring = null;
+
+		if ($mbstring === null) {
+			if (!defined('MB_OVERLOAD_STRING')) {
+				$mbstring = false;
+				return $mbstring;
+			}
+			$mbstring = extension_loaded('mbstring')
+				&& defined('MB_OVERLOAD_STRING')
+				&&
+			((int) (ini_get('mbstring.func_overload')) & 2);
+			// MB_OVERLOAD_STRING === 2
+		}
+		/** @var bool $mbstring */
+
+		return $mbstring;
+	}
 }

vendor/paragonie/sodium_compat/src/Core/SipHash.php

Indentation +293 added lines, -293 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_SipHash', false)) {
-    return;
+	return;
 }
 
 /**
@@ -11,296 +11,296 @@ 
  */
 class ParagonIE_Sodium_Core_SipHash extends ParagonIE_Sodium_Core_Util
 {
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param int[] $v
-     * @return int[]
-     *
-     */
-    public static function sipRound(array $v)
-    {
-        # v0 += v1;
-        list($v[0], $v[1]) = self::add(
-            array($v[0], $v[1]),
-            array($v[2], $v[3])
-        );
-
-        #  v1=ROTL(v1,13);
-        list($v[2], $v[3]) = self::rotl_64((int) $v[2], (int) $v[3], 13);
-
-        #  v1 ^= v0;
-        $v[2] = (int) $v[2] ^ (int) $v[0];
-        $v[3] = (int) $v[3] ^ (int) $v[1];
-
-        #  v0=ROTL(v0,32);
-        list($v[0], $v[1]) = self::rotl_64((int) $v[0], (int) $v[1], 32);
-
-        # v2 += v3;
-        list($v[4], $v[5]) = self::add(
-            array((int) $v[4], (int) $v[5]),
-            array((int) $v[6], (int) $v[7])
-        );
-
-        # v3=ROTL(v3,16);
-        list($v[6], $v[7]) = self::rotl_64((int) $v[6], (int) $v[7], 16);
-
-        #  v3 ^= v2;
-        $v[6] = (int) $v[6] ^ (int) $v[4];
-        $v[7] = (int) $v[7] ^ (int) $v[5];
-
-        # v0 += v3;
-        list($v[0], $v[1]) = self::add(
-            array((int) $v[0], (int) $v[1]),
-            array((int) $v[6], (int) $v[7])
-        );
-
-        # v3=ROTL(v3,21);
-        list($v[6], $v[7]) = self::rotl_64((int) $v[6], (int) $v[7], 21);
-
-        # v3 ^= v0;
-        $v[6] = (int) $v[6] ^ (int) $v[0];
-        $v[7] = (int) $v[7] ^ (int) $v[1];
-
-        # v2 += v1;
-        list($v[4], $v[5]) = self::add(
-            array((int) $v[4], (int) $v[5]),
-            array((int) $v[2], (int) $v[3])
-        );
-
-        # v1=ROTL(v1,17);
-        list($v[2], $v[3]) = self::rotl_64((int) $v[2], (int) $v[3], 17);
-
-        #  v1 ^= v2;;
-        $v[2] = (int) $v[2] ^ (int) $v[4];
-        $v[3] = (int) $v[3] ^ (int) $v[5];
-
-        # v2=ROTL(v2,32)
-        list($v[4], $v[5]) = self::rotl_64((int) $v[4], (int) $v[5], 32);
-
-        return $v;
-    }
-
-    /**
-     * Add two 32 bit integers representing a 64-bit integer.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int[] $a
-     * @param int[] $b
-     * @return array<int, mixed>
-     */
-    public static function add(array $a, array $b)
-    {
-        /** @var int $x1 */
-        $x1 = $a[1] + $b[1];
-        /** @var int $c */
-        $c = $x1 >> 32; // Carry if ($a + $b) > 0xffffffff
-        /** @var int $x0 */
-        $x0 = $a[0] + $b[0] + $c;
-        return array(
-            $x0 & 0xffffffff,
-            $x1 & 0xffffffff
-        );
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param int $int0
-     * @param int $int1
-     * @param int $c
-     * @return array<int, mixed>
-     */
-    public static function rotl_64($int0, $int1, $c)
-    {
-        $int0 &= 0xffffffff;
-        $int1 &= 0xffffffff;
-        $c &= 63;
-        if ($c === 32) {
-            return array($int1, $int0);
-        }
-        if ($c > 31) {
-            $tmp = $int1;
-            $int1 = $int0;
-            $int0 = $tmp;
-            $c &= 31;
-        }
-        if ($c === 0) {
-            return array($int0, $int1);
-        }
-        return array(
-            0xffffffff & (
-                ($int0 << $c)
-                    |
-                ($int1 >> (32 - $c))
-            ),
-            0xffffffff & (
-                ($int1 << $c)
-                    |
-                ($int0 >> (32 - $c))
-            ),
-        );
-    }
-
-    /**
-     * Implements Siphash-2-4 using only 32-bit numbers.
-     *
-     * When we split an int into two, the higher bits go to the lower index.
-     * e.g. 0xDEADBEEFAB10C92D becomes [
-     *     0 => 0xDEADBEEF,
-     *     1 => 0xAB10C92D
-     * ].
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $in
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function sipHash24($in, $key)
-    {
-        $inlen = self::strlen($in);
-
-        # /* "somepseudorandomlygeneratedbytes" */
-        # u64 v0 = 0x736f6d6570736575ULL;
-        # u64 v1 = 0x646f72616e646f6dULL;
-        # u64 v2 = 0x6c7967656e657261ULL;
-        # u64 v3 = 0x7465646279746573ULL;
-        $v = array(
-            0x736f6d65, // 0
-            0x70736575, // 1
-            0x646f7261, // 2
-            0x6e646f6d, // 3
-            0x6c796765, // 4
-            0x6e657261, // 5
-            0x74656462, // 6
-            0x79746573  // 7
-        );
-        // v0 => $v[0], $v[1]
-        // v1 => $v[2], $v[3]
-        // v2 => $v[4], $v[5]
-        // v3 => $v[6], $v[7]
-
-        # u64 k0 = LOAD64_LE( k );
-        # u64 k1 = LOAD64_LE( k + 8 );
-        $k = array(
-            self::load_4(self::substr($key, 4, 4)),
-            self::load_4(self::substr($key, 0, 4)),
-            self::load_4(self::substr($key, 12, 4)),
-            self::load_4(self::substr($key, 8, 4))
-        );
-        // k0 => $k[0], $k[1]
-        // k1 => $k[2], $k[3]
-
-        # b = ( ( u64 )inlen ) << 56;
-        $b = array(
-            $inlen << 24,
-            0
-        );
-        // See docblock for why the 0th index gets the higher bits.
-
-        # v3 ^= k1;
-        $v[6] ^= $k[2];
-        $v[7] ^= $k[3];
-        # v2 ^= k0;
-        $v[4] ^= $k[0];
-        $v[5] ^= $k[1];
-        # v1 ^= k1;
-        $v[2] ^= $k[2];
-        $v[3] ^= $k[3];
-        # v0 ^= k0;
-        $v[0] ^= $k[0];
-        $v[1] ^= $k[1];
-
-        $left = $inlen;
-        # for ( ; in != end; in += 8 )
-        while ($left >= 8) {
-            # m = LOAD64_LE( in );
-            $m = array(
-                self::load_4(self::substr($in, 4, 4)),
-                self::load_4(self::substr($in, 0, 4))
-            );
-
-            # v3 ^= m;
-            $v[6] ^= $m[0];
-            $v[7] ^= $m[1];
-
-            # SIPROUND;
-            # SIPROUND;
-            $v = self::sipRound($v);
-            $v = self::sipRound($v);
-
-            # v0 ^= m;
-            $v[0] ^= $m[0];
-            $v[1] ^= $m[1];
-
-            $in = self::substr($in, 8);
-            $left -= 8;
-        }
-
-        # switch( left )
-        #  {
-        #     case 7: b |= ( ( u64 )in[ 6] )  << 48;
-        #     case 6: b |= ( ( u64 )in[ 5] )  << 40;
-        #     case 5: b |= ( ( u64 )in[ 4] )  << 32;
-        #     case 4: b |= ( ( u64 )in[ 3] )  << 24;
-        #     case 3: b |= ( ( u64 )in[ 2] )  << 16;
-        #     case 2: b |= ( ( u64 )in[ 1] )  <<  8;
-        #     case 1: b |= ( ( u64 )in[ 0] ); break;
-        #     case 0: break;
-        # }
-        switch ($left) {
-            case 7:
-                $b[0] |= self::chrToInt($in[6]) << 16;
-            case 6:
-                $b[0] |= self::chrToInt($in[5]) << 8;
-            case 5:
-                $b[0] |= self::chrToInt($in[4]);
-            case 4:
-                $b[1] |= self::chrToInt($in[3]) << 24;
-            case 3:
-                $b[1] |= self::chrToInt($in[2]) << 16;
-            case 2:
-                $b[1] |= self::chrToInt($in[1]) << 8;
-            case 1:
-                $b[1] |= self::chrToInt($in[0]);
-            case 0:
-                break;
-        }
-        // See docblock for why the 0th index gets the higher bits.
-
-        # v3 ^= b;
-        $v[6] ^= $b[0];
-        $v[7] ^= $b[1];
-
-        # SIPROUND;
-        # SIPROUND;
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
-
-        # v0 ^= b;
-        $v[0] ^= $b[0];
-        $v[1] ^= $b[1];
-
-        // Flip the lower 8 bits of v2 which is ($v[4], $v[5]) in our implementation
-        # v2 ^= 0xff;
-        $v[5] ^= 0xff;
-
-        # SIPROUND;
-        # SIPROUND;
-        # SIPROUND;
-        # SIPROUND;
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
-
-        # b = v0 ^ v1 ^ v2 ^ v3;
-        # STORE64_LE( out, b );
-        return  self::store32_le($v[1] ^ $v[3] ^ $v[5] ^ $v[7]) .
-            self::store32_le($v[0] ^ $v[2] ^ $v[4] ^ $v[6]);
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int[] $v
+	 * @return int[]
+	 *
+	 */
+	public static function sipRound(array $v)
+	{
+		# v0 += v1;
+		list($v[0], $v[1]) = self::add(
+			array($v[0], $v[1]),
+			array($v[2], $v[3])
+		);
+
+		#  v1=ROTL(v1,13);
+		list($v[2], $v[3]) = self::rotl_64((int) $v[2], (int) $v[3], 13);
+
+		#  v1 ^= v0;
+		$v[2] = (int) $v[2] ^ (int) $v[0];
+		$v[3] = (int) $v[3] ^ (int) $v[1];
+
+		#  v0=ROTL(v0,32);
+		list($v[0], $v[1]) = self::rotl_64((int) $v[0], (int) $v[1], 32);
+
+		# v2 += v3;
+		list($v[4], $v[5]) = self::add(
+			array((int) $v[4], (int) $v[5]),
+			array((int) $v[6], (int) $v[7])
+		);
+
+		# v3=ROTL(v3,16);
+		list($v[6], $v[7]) = self::rotl_64((int) $v[6], (int) $v[7], 16);
+
+		#  v3 ^= v2;
+		$v[6] = (int) $v[6] ^ (int) $v[4];
+		$v[7] = (int) $v[7] ^ (int) $v[5];
+
+		# v0 += v3;
+		list($v[0], $v[1]) = self::add(
+			array((int) $v[0], (int) $v[1]),
+			array((int) $v[6], (int) $v[7])
+		);
+
+		# v3=ROTL(v3,21);
+		list($v[6], $v[7]) = self::rotl_64((int) $v[6], (int) $v[7], 21);
+
+		# v3 ^= v0;
+		$v[6] = (int) $v[6] ^ (int) $v[0];
+		$v[7] = (int) $v[7] ^ (int) $v[1];
+
+		# v2 += v1;
+		list($v[4], $v[5]) = self::add(
+			array((int) $v[4], (int) $v[5]),
+			array((int) $v[2], (int) $v[3])
+		);
+
+		# v1=ROTL(v1,17);
+		list($v[2], $v[3]) = self::rotl_64((int) $v[2], (int) $v[3], 17);
+
+		#  v1 ^= v2;;
+		$v[2] = (int) $v[2] ^ (int) $v[4];
+		$v[3] = (int) $v[3] ^ (int) $v[5];
+
+		# v2=ROTL(v2,32)
+		list($v[4], $v[5]) = self::rotl_64((int) $v[4], (int) $v[5], 32);
+
+		return $v;
+	}
+
+	/**
+	 * Add two 32 bit integers representing a 64-bit integer.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int[] $a
+	 * @param int[] $b
+	 * @return array<int, mixed>
+	 */
+	public static function add(array $a, array $b)
+	{
+		/** @var int $x1 */
+		$x1 = $a[1] + $b[1];
+		/** @var int $c */
+		$c = $x1 >> 32; // Carry if ($a + $b) > 0xffffffff
+		/** @var int $x0 */
+		$x0 = $a[0] + $b[0] + $c;
+		return array(
+			$x0 & 0xffffffff,
+			$x1 & 0xffffffff
+		);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $int0
+	 * @param int $int1
+	 * @param int $c
+	 * @return array<int, mixed>
+	 */
+	public static function rotl_64($int0, $int1, $c)
+	{
+		$int0 &= 0xffffffff;
+		$int1 &= 0xffffffff;
+		$c &= 63;
+		if ($c === 32) {
+			return array($int1, $int0);
+		}
+		if ($c > 31) {
+			$tmp = $int1;
+			$int1 = $int0;
+			$int0 = $tmp;
+			$c &= 31;
+		}
+		if ($c === 0) {
+			return array($int0, $int1);
+		}
+		return array(
+			0xffffffff & (
+				($int0 << $c)
+					|
+				($int1 >> (32 - $c))
+			),
+			0xffffffff & (
+				($int1 << $c)
+					|
+				($int0 >> (32 - $c))
+			),
+		);
+	}
+
+	/**
+	 * Implements Siphash-2-4 using only 32-bit numbers.
+	 *
+	 * When we split an int into two, the higher bits go to the lower index.
+	 * e.g. 0xDEADBEEFAB10C92D becomes [
+	 *     0 => 0xDEADBEEF,
+	 *     1 => 0xAB10C92D
+	 * ].
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $in
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function sipHash24($in, $key)
+	{
+		$inlen = self::strlen($in);
+
+		# /* "somepseudorandomlygeneratedbytes" */
+		# u64 v0 = 0x736f6d6570736575ULL;
+		# u64 v1 = 0x646f72616e646f6dULL;
+		# u64 v2 = 0x6c7967656e657261ULL;
+		# u64 v3 = 0x7465646279746573ULL;
+		$v = array(
+			0x736f6d65, // 0
+			0x70736575, // 1
+			0x646f7261, // 2
+			0x6e646f6d, // 3
+			0x6c796765, // 4
+			0x6e657261, // 5
+			0x74656462, // 6
+			0x79746573  // 7
+		);
+		// v0 => $v[0], $v[1]
+		// v1 => $v[2], $v[3]
+		// v2 => $v[4], $v[5]
+		// v3 => $v[6], $v[7]
+
+		# u64 k0 = LOAD64_LE( k );
+		# u64 k1 = LOAD64_LE( k + 8 );
+		$k = array(
+			self::load_4(self::substr($key, 4, 4)),
+			self::load_4(self::substr($key, 0, 4)),
+			self::load_4(self::substr($key, 12, 4)),
+			self::load_4(self::substr($key, 8, 4))
+		);
+		// k0 => $k[0], $k[1]
+		// k1 => $k[2], $k[3]
+
+		# b = ( ( u64 )inlen ) << 56;
+		$b = array(
+			$inlen << 24,
+			0
+		);
+		// See docblock for why the 0th index gets the higher bits.
+
+		# v3 ^= k1;
+		$v[6] ^= $k[2];
+		$v[7] ^= $k[3];
+		# v2 ^= k0;
+		$v[4] ^= $k[0];
+		$v[5] ^= $k[1];
+		# v1 ^= k1;
+		$v[2] ^= $k[2];
+		$v[3] ^= $k[3];
+		# v0 ^= k0;
+		$v[0] ^= $k[0];
+		$v[1] ^= $k[1];
+
+		$left = $inlen;
+		# for ( ; in != end; in += 8 )
+		while ($left >= 8) {
+			# m = LOAD64_LE( in );
+			$m = array(
+				self::load_4(self::substr($in, 4, 4)),
+				self::load_4(self::substr($in, 0, 4))
+			);
+
+			# v3 ^= m;
+			$v[6] ^= $m[0];
+			$v[7] ^= $m[1];
+
+			# SIPROUND;
+			# SIPROUND;
+			$v = self::sipRound($v);
+			$v = self::sipRound($v);
+
+			# v0 ^= m;
+			$v[0] ^= $m[0];
+			$v[1] ^= $m[1];
+
+			$in = self::substr($in, 8);
+			$left -= 8;
+		}
+
+		# switch( left )
+		#  {
+		#     case 7: b |= ( ( u64 )in[ 6] )  << 48;
+		#     case 6: b |= ( ( u64 )in[ 5] )  << 40;
+		#     case 5: b |= ( ( u64 )in[ 4] )  << 32;
+		#     case 4: b |= ( ( u64 )in[ 3] )  << 24;
+		#     case 3: b |= ( ( u64 )in[ 2] )  << 16;
+		#     case 2: b |= ( ( u64 )in[ 1] )  <<  8;
+		#     case 1: b |= ( ( u64 )in[ 0] ); break;
+		#     case 0: break;
+		# }
+		switch ($left) {
+			case 7:
+				$b[0] |= self::chrToInt($in[6]) << 16;
+			case 6:
+				$b[0] |= self::chrToInt($in[5]) << 8;
+			case 5:
+				$b[0] |= self::chrToInt($in[4]);
+			case 4:
+				$b[1] |= self::chrToInt($in[3]) << 24;
+			case 3:
+				$b[1] |= self::chrToInt($in[2]) << 16;
+			case 2:
+				$b[1] |= self::chrToInt($in[1]) << 8;
+			case 1:
+				$b[1] |= self::chrToInt($in[0]);
+			case 0:
+				break;
+		}
+		// See docblock for why the 0th index gets the higher bits.
+
+		# v3 ^= b;
+		$v[6] ^= $b[0];
+		$v[7] ^= $b[1];
+
+		# SIPROUND;
+		# SIPROUND;
+		$v = self::sipRound($v);
+		$v = self::sipRound($v);
+
+		# v0 ^= b;
+		$v[0] ^= $b[0];
+		$v[1] ^= $b[1];
+
+		// Flip the lower 8 bits of v2 which is ($v[4], $v[5]) in our implementation
+		# v2 ^= 0xff;
+		$v[5] ^= 0xff;
+
+		# SIPROUND;
+		# SIPROUND;
+		# SIPROUND;
+		# SIPROUND;
+		$v = self::sipRound($v);
+		$v = self::sipRound($v);
+		$v = self::sipRound($v);
+		$v = self::sipRound($v);
+
+		# b = v0 ^ v1 ^ v2 ^ v3;
+		# STORE64_LE( out, b );
+		return  self::store32_le($v[1] ^ $v[3] ^ $v[5] ^ $v[7]) .
+			self::store32_le($v[0] ^ $v[2] ^ $v[4] ^ $v[6]);
+	}
 }

vendor/paragonie/sodium_compat/src/Core/XChaCha20.php

Indentation +103 added lines, -103 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_XChaCha20', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,109 +9,109 @@ 
  */
 class ParagonIE_Sodium_Core_XChaCha20 extends ParagonIE_Sodium_Core_HChaCha20
 {
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param int $len
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function stream($len = 64, $nonce = '', $key = '')
-    {
-        if (self::strlen($nonce) !== 24) {
-            throw new SodiumException('Nonce must be 24 bytes long');
-        }
-        return self::encryptBytes(
-            new ParagonIE_Sodium_Core_ChaCha20_Ctx(
-                self::hChaCha20(
-                    self::substr($nonce, 0, 16),
-                    $key
-                ),
-                self::substr($nonce, 16, 8)
-            ),
-            str_repeat("\x00", $len)
-        );
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $len
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function stream($len = 64, $nonce = '', $key = '')
+	{
+		if (self::strlen($nonce) !== 24) {
+			throw new SodiumException('Nonce must be 24 bytes long');
+		}
+		return self::encryptBytes(
+			new ParagonIE_Sodium_Core_ChaCha20_Ctx(
+				self::hChaCha20(
+					self::substr($nonce, 0, 16),
+					$key
+				),
+				self::substr($nonce, 16, 8)
+			),
+			str_repeat("\x00", $len)
+		);
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param int $len
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function ietfStream($len = 64, $nonce = '', $key = '')
-    {
-        if (self::strlen($nonce) !== 24) {
-            throw new SodiumException('Nonce must be 24 bytes long');
-        }
-        return self::encryptBytes(
-            new ParagonIE_Sodium_Core_ChaCha20_IetfCtx(
-                self::hChaCha20(
-                    self::substr($nonce, 0, 16),
-                    $key
-                ),
-                "\x00\x00\x00\x00" . self::substr($nonce, 16, 8)
-            ),
-            str_repeat("\x00", $len)
-        );
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $len
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function ietfStream($len = 64, $nonce = '', $key = '')
+	{
+		if (self::strlen($nonce) !== 24) {
+			throw new SodiumException('Nonce must be 24 bytes long');
+		}
+		return self::encryptBytes(
+			new ParagonIE_Sodium_Core_ChaCha20_IetfCtx(
+				self::hChaCha20(
+					self::substr($nonce, 0, 16),
+					$key
+				),
+				"\x00\x00\x00\x00" . self::substr($nonce, 16, 8)
+			),
+			str_repeat("\x00", $len)
+		);
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $message
-     * @param string $nonce
-     * @param string $key
-     * @param string $ic
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function streamXorIc($message, $nonce = '', $key = '', $ic = '')
-    {
-        if (self::strlen($nonce) !== 24) {
-            throw new SodiumException('Nonce must be 24 bytes long');
-        }
-        return self::encryptBytes(
-            new ParagonIE_Sodium_Core_ChaCha20_Ctx(
-                self::hChaCha20(self::substr($nonce, 0, 16), $key),
-                self::substr($nonce, 16, 8),
-                $ic
-            ),
-            $message
-        );
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $key
+	 * @param string $ic
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function streamXorIc($message, $nonce = '', $key = '', $ic = '')
+	{
+		if (self::strlen($nonce) !== 24) {
+			throw new SodiumException('Nonce must be 24 bytes long');
+		}
+		return self::encryptBytes(
+			new ParagonIE_Sodium_Core_ChaCha20_Ctx(
+				self::hChaCha20(self::substr($nonce, 0, 16), $key),
+				self::substr($nonce, 16, 8),
+				$ic
+			),
+			$message
+		);
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $message
-     * @param string $nonce
-     * @param string $key
-     * @param string $ic
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function ietfStreamXorIc($message, $nonce = '', $key = '', $ic = '')
-    {
-        if (self::strlen($nonce) !== 24) {
-            throw new SodiumException('Nonce must be 24 bytes long');
-        }
-        return self::encryptBytes(
-            new ParagonIE_Sodium_Core_ChaCha20_IetfCtx(
-                self::hChaCha20(self::substr($nonce, 0, 16), $key),
-                "\x00\x00\x00\x00" . self::substr($nonce, 16, 8),
-                $ic
-            ),
-            $message
-        );
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $key
+	 * @param string $ic
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function ietfStreamXorIc($message, $nonce = '', $key = '', $ic = '')
+	{
+		if (self::strlen($nonce) !== 24) {
+			throw new SodiumException('Nonce must be 24 bytes long');
+		}
+		return self::encryptBytes(
+			new ParagonIE_Sodium_Core_ChaCha20_IetfCtx(
+				self::hChaCha20(self::substr($nonce, 0, 16), $key),
+				"\x00\x00\x00\x00" . self::substr($nonce, 16, 8),
+				$ic
+			),
+			$message
+		);
+	}
 }

vendor/paragonie/sodium_compat/src/Core/X25519.php

Indentation +316 added lines, -316 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_X25519', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,319 +9,319 @@ 
  */
 abstract class ParagonIE_Sodium_Core_X25519 extends ParagonIE_Sodium_Core_Curve25519
 {
-    /**
-     * Alters the objects passed to this method in place.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
-     * @param ParagonIE_Sodium_Core_Curve25519_Fe $g
-     * @param int $b
-     * @return void
-     * @psalm-suppress MixedAssignment
-     */
-    public static function fe_cswap(
-        ParagonIE_Sodium_Core_Curve25519_Fe $f,
-        ParagonIE_Sodium_Core_Curve25519_Fe $g,
-        $b = 0
-    ) {
-        $f0 = (int) $f[0];
-        $f1 = (int) $f[1];
-        $f2 = (int) $f[2];
-        $f3 = (int) $f[3];
-        $f4 = (int) $f[4];
-        $f5 = (int) $f[5];
-        $f6 = (int) $f[6];
-        $f7 = (int) $f[7];
-        $f8 = (int) $f[8];
-        $f9 = (int) $f[9];
-        $g0 = (int) $g[0];
-        $g1 = (int) $g[1];
-        $g2 = (int) $g[2];
-        $g3 = (int) $g[3];
-        $g4 = (int) $g[4];
-        $g5 = (int) $g[5];
-        $g6 = (int) $g[6];
-        $g7 = (int) $g[7];
-        $g8 = (int) $g[8];
-        $g9 = (int) $g[9];
-        $b = -$b;
-        $x0 = ($f0 ^ $g0) & $b;
-        $x1 = ($f1 ^ $g1) & $b;
-        $x2 = ($f2 ^ $g2) & $b;
-        $x3 = ($f3 ^ $g3) & $b;
-        $x4 = ($f4 ^ $g4) & $b;
-        $x5 = ($f5 ^ $g5) & $b;
-        $x6 = ($f6 ^ $g6) & $b;
-        $x7 = ($f7 ^ $g7) & $b;
-        $x8 = ($f8 ^ $g8) & $b;
-        $x9 = ($f9 ^ $g9) & $b;
-        $f[0] = $f0 ^ $x0;
-        $f[1] = $f1 ^ $x1;
-        $f[2] = $f2 ^ $x2;
-        $f[3] = $f3 ^ $x3;
-        $f[4] = $f4 ^ $x4;
-        $f[5] = $f5 ^ $x5;
-        $f[6] = $f6 ^ $x6;
-        $f[7] = $f7 ^ $x7;
-        $f[8] = $f8 ^ $x8;
-        $f[9] = $f9 ^ $x9;
-        $g[0] = $g0 ^ $x0;
-        $g[1] = $g1 ^ $x1;
-        $g[2] = $g2 ^ $x2;
-        $g[3] = $g3 ^ $x3;
-        $g[4] = $g4 ^ $x4;
-        $g[5] = $g5 ^ $x5;
-        $g[6] = $g6 ^ $x6;
-        $g[7] = $g7 ^ $x7;
-        $g[8] = $g8 ^ $x8;
-        $g[9] = $g9 ^ $x9;
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
-     * @return ParagonIE_Sodium_Core_Curve25519_Fe
-     */
-    public static function fe_mul121666(ParagonIE_Sodium_Core_Curve25519_Fe $f)
-    {
-        $h = array(
-            self::mul((int) $f[0], 121666, 17),
-            self::mul((int) $f[1], 121666, 17),
-            self::mul((int) $f[2], 121666, 17),
-            self::mul((int) $f[3], 121666, 17),
-            self::mul((int) $f[4], 121666, 17),
-            self::mul((int) $f[5], 121666, 17),
-            self::mul((int) $f[6], 121666, 17),
-            self::mul((int) $f[7], 121666, 17),
-            self::mul((int) $f[8], 121666, 17),
-            self::mul((int) $f[9], 121666, 17)
-        );
-
-        /** @var int $carry9 */
-        $carry9 = ($h[9] + (1 << 24)) >> 25;
-        $h[0] += self::mul($carry9, 19, 5);
-        $h[9] -= $carry9 << 25;
-        /** @var int $carry1 */
-        $carry1 = ($h[1] + (1 << 24)) >> 25;
-        $h[2] += $carry1;
-        $h[1] -= $carry1 << 25;
-        /** @var int $carry3 */
-        $carry3 = ($h[3] + (1 << 24)) >> 25;
-        $h[4] += $carry3;
-        $h[3] -= $carry3 << 25;
-        /** @var int $carry5 */
-        $carry5 = ($h[5] + (1 << 24)) >> 25;
-        $h[6] += $carry5;
-        $h[5] -= $carry5 << 25;
-        /** @var int $carry7 */
-        $carry7 = ($h[7] + (1 << 24)) >> 25;
-        $h[8] += $carry7;
-        $h[7] -= $carry7 << 25;
-
-        /** @var int $carry0 */
-        $carry0 = ($h[0] + (1 << 25)) >> 26;
-        $h[1] += $carry0;
-        $h[0] -= $carry0 << 26;
-        /** @var int $carry2 */
-        $carry2 = ($h[2] + (1 << 25)) >> 26;
-        $h[3] += $carry2;
-        $h[2] -= $carry2 << 26;
-        /** @var int $carry4 */
-        $carry4 = ($h[4] + (1 << 25)) >> 26;
-        $h[5] += $carry4;
-        $h[4] -= $carry4 << 26;
-        /** @var int $carry6 */
-        $carry6 = ($h[6] + (1 << 25)) >> 26;
-        $h[7] += $carry6;
-        $h[6] -= $carry6 << 26;
-        /** @var int $carry8 */
-        $carry8 = ($h[8] + (1 << 25)) >> 26;
-        $h[9] += $carry8;
-        $h[8] -= $carry8 << 26;
-
-        foreach ($h as $i => $value) {
-            $h[$i] = (int) $value;
-        }
-        return ParagonIE_Sodium_Core_Curve25519_Fe::fromArray($h);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * Inline comments preceded by # are from libsodium's ref10 code.
-     *
-     * @param string $n
-     * @param string $p
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function crypto_scalarmult_curve25519_ref10($n, $p)
-    {
-        # for (i = 0;i < 32;++i) e[i] = n[i];
-        $e = '' . $n;
-        # e[0] &= 248;
-        $e[0] = self::intToChr(
-            self::chrToInt($e[0]) & 248
-        );
-        # e[31] &= 127;
-        # e[31] |= 64;
-        $e[31] = self::intToChr(
-            (self::chrToInt($e[31]) & 127) | 64
-        );
-        # fe_frombytes(x1,p);
-        $x1 = self::fe_frombytes($p);
-        # fe_1(x2);
-        $x2 = self::fe_1();
-        # fe_0(z2);
-        $z2 = self::fe_0();
-        # fe_copy(x3,x1);
-        $x3 = self::fe_copy($x1);
-        # fe_1(z3);
-        $z3 = self::fe_1();
-
-        # swap = 0;
-        /** @var int $swap */
-        $swap = 0;
-
-        # for (pos = 254;pos >= 0;--pos) {
-        for ($pos = 254; $pos >= 0; --$pos) {
-            # b = e[pos / 8] >> (pos & 7);
-            /** @var int $b */
-            $b = self::chrToInt(
-                    $e[(int) floor($pos / 8)]
-                ) >> ($pos & 7);
-            # b &= 1;
-            $b &= 1;
-            # swap ^= b;
-            $swap ^= $b;
-            # fe_cswap(x2,x3,swap);
-            self::fe_cswap($x2, $x3, $swap);
-            # fe_cswap(z2,z3,swap);
-            self::fe_cswap($z2, $z3, $swap);
-            # swap = b;
-            $swap = $b;
-            # fe_sub(tmp0,x3,z3);
-            $tmp0 = self::fe_sub($x3, $z3);
-            # fe_sub(tmp1,x2,z2);
-            $tmp1 = self::fe_sub($x2, $z2);
-
-            # fe_add(x2,x2,z2);
-            $x2 = self::fe_add($x2, $z2);
-
-            # fe_add(z2,x3,z3);
-            $z2 = self::fe_add($x3, $z3);
-
-            # fe_mul(z3,tmp0,x2);
-            $z3 = self::fe_mul($tmp0, $x2);
-
-            # fe_mul(z2,z2,tmp1);
-            $z2 = self::fe_mul($z2, $tmp1);
-
-            # fe_sq(tmp0,tmp1);
-            $tmp0 = self::fe_sq($tmp1);
-
-            # fe_sq(tmp1,x2);
-            $tmp1 = self::fe_sq($x2);
-
-            # fe_add(x3,z3,z2);
-            $x3 = self::fe_add($z3, $z2);
-
-            # fe_sub(z2,z3,z2);
-            $z2 = self::fe_sub($z3, $z2);
-
-            # fe_mul(x2,tmp1,tmp0);
-            $x2 = self::fe_mul($tmp1, $tmp0);
-
-            # fe_sub(tmp1,tmp1,tmp0);
-            $tmp1 = self::fe_sub($tmp1, $tmp0);
-
-            # fe_sq(z2,z2);
-            $z2 = self::fe_sq($z2);
-
-            # fe_mul121666(z3,tmp1);
-            $z3 = self::fe_mul121666($tmp1);
-
-            # fe_sq(x3,x3);
-            $x3 = self::fe_sq($x3);
-
-            # fe_add(tmp0,tmp0,z3);
-            $tmp0 = self::fe_add($tmp0, $z3);
-
-            # fe_mul(z3,x1,z2);
-            $z3 = self::fe_mul($x1, $z2);
-
-            # fe_mul(z2,tmp1,tmp0);
-            $z2 = self::fe_mul($tmp1, $tmp0);
-        }
-
-        # fe_cswap(x2,x3,swap);
-        self::fe_cswap($x2, $x3, $swap);
-
-        # fe_cswap(z2,z3,swap);
-        self::fe_cswap($z2, $z3, $swap);
-
-        # fe_invert(z2,z2);
-        $z2 = self::fe_invert($z2);
-
-        # fe_mul(x2,x2,z2);
-        $x2 = self::fe_mul($x2, $z2);
-        # fe_tobytes(q,x2);
-        return self::fe_tobytes($x2);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param ParagonIE_Sodium_Core_Curve25519_Fe $edwardsY
-     * @param ParagonIE_Sodium_Core_Curve25519_Fe $edwardsZ
-     * @return ParagonIE_Sodium_Core_Curve25519_Fe
-     */
-    public static function edwards_to_montgomery(
-        ParagonIE_Sodium_Core_Curve25519_Fe $edwardsY,
-        ParagonIE_Sodium_Core_Curve25519_Fe $edwardsZ
-    ) {
-        $tempX = self::fe_add($edwardsZ, $edwardsY);
-        $tempZ = self::fe_sub($edwardsZ, $edwardsY);
-        $tempZ = self::fe_invert($tempZ);
-        return self::fe_mul($tempX, $tempZ);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $n
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function crypto_scalarmult_curve25519_ref10_base($n)
-    {
-        # for (i = 0;i < 32;++i) e[i] = n[i];
-        $e = '' . $n;
-
-        # e[0] &= 248;
-        $e[0] = self::intToChr(
-            self::chrToInt($e[0]) & 248
-        );
-
-        # e[31] &= 127;
-        # e[31] |= 64;
-        $e[31] = self::intToChr(
-            (self::chrToInt($e[31]) & 127) | 64
-        );
-
-        $A = self::ge_scalarmult_base($e);
-        if (
-            !($A->Y instanceof ParagonIE_Sodium_Core_Curve25519_Fe)
-                ||
-            !($A->Z instanceof ParagonIE_Sodium_Core_Curve25519_Fe)
-        ) {
-            throw new TypeError('Null points encountered');
-        }
-        $pk = self::edwards_to_montgomery($A->Y, $A->Z);
-        return self::fe_tobytes($pk);
-    }
+	/**
+	 * Alters the objects passed to this method in place.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
+	 * @param ParagonIE_Sodium_Core_Curve25519_Fe $g
+	 * @param int $b
+	 * @return void
+	 * @psalm-suppress MixedAssignment
+	 */
+	public static function fe_cswap(
+		ParagonIE_Sodium_Core_Curve25519_Fe $f,
+		ParagonIE_Sodium_Core_Curve25519_Fe $g,
+		$b = 0
+	) {
+		$f0 = (int) $f[0];
+		$f1 = (int) $f[1];
+		$f2 = (int) $f[2];
+		$f3 = (int) $f[3];
+		$f4 = (int) $f[4];
+		$f5 = (int) $f[5];
+		$f6 = (int) $f[6];
+		$f7 = (int) $f[7];
+		$f8 = (int) $f[8];
+		$f9 = (int) $f[9];
+		$g0 = (int) $g[0];
+		$g1 = (int) $g[1];
+		$g2 = (int) $g[2];
+		$g3 = (int) $g[3];
+		$g4 = (int) $g[4];
+		$g5 = (int) $g[5];
+		$g6 = (int) $g[6];
+		$g7 = (int) $g[7];
+		$g8 = (int) $g[8];
+		$g9 = (int) $g[9];
+		$b = -$b;
+		$x0 = ($f0 ^ $g0) & $b;
+		$x1 = ($f1 ^ $g1) & $b;
+		$x2 = ($f2 ^ $g2) & $b;
+		$x3 = ($f3 ^ $g3) & $b;
+		$x4 = ($f4 ^ $g4) & $b;
+		$x5 = ($f5 ^ $g5) & $b;
+		$x6 = ($f6 ^ $g6) & $b;
+		$x7 = ($f7 ^ $g7) & $b;
+		$x8 = ($f8 ^ $g8) & $b;
+		$x9 = ($f9 ^ $g9) & $b;
+		$f[0] = $f0 ^ $x0;
+		$f[1] = $f1 ^ $x1;
+		$f[2] = $f2 ^ $x2;
+		$f[3] = $f3 ^ $x3;
+		$f[4] = $f4 ^ $x4;
+		$f[5] = $f5 ^ $x5;
+		$f[6] = $f6 ^ $x6;
+		$f[7] = $f7 ^ $x7;
+		$f[8] = $f8 ^ $x8;
+		$f[9] = $f9 ^ $x9;
+		$g[0] = $g0 ^ $x0;
+		$g[1] = $g1 ^ $x1;
+		$g[2] = $g2 ^ $x2;
+		$g[3] = $g3 ^ $x3;
+		$g[4] = $g4 ^ $x4;
+		$g[5] = $g5 ^ $x5;
+		$g[6] = $g6 ^ $x6;
+		$g[7] = $g7 ^ $x7;
+		$g[8] = $g8 ^ $x8;
+		$g[9] = $g9 ^ $x9;
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
+	 * @return ParagonIE_Sodium_Core_Curve25519_Fe
+	 */
+	public static function fe_mul121666(ParagonIE_Sodium_Core_Curve25519_Fe $f)
+	{
+		$h = array(
+			self::mul((int) $f[0], 121666, 17),
+			self::mul((int) $f[1], 121666, 17),
+			self::mul((int) $f[2], 121666, 17),
+			self::mul((int) $f[3], 121666, 17),
+			self::mul((int) $f[4], 121666, 17),
+			self::mul((int) $f[5], 121666, 17),
+			self::mul((int) $f[6], 121666, 17),
+			self::mul((int) $f[7], 121666, 17),
+			self::mul((int) $f[8], 121666, 17),
+			self::mul((int) $f[9], 121666, 17)
+		);
+
+		/** @var int $carry9 */
+		$carry9 = ($h[9] + (1 << 24)) >> 25;
+		$h[0] += self::mul($carry9, 19, 5);
+		$h[9] -= $carry9 << 25;
+		/** @var int $carry1 */
+		$carry1 = ($h[1] + (1 << 24)) >> 25;
+		$h[2] += $carry1;
+		$h[1] -= $carry1 << 25;
+		/** @var int $carry3 */
+		$carry3 = ($h[3] + (1 << 24)) >> 25;
+		$h[4] += $carry3;
+		$h[3] -= $carry3 << 25;
+		/** @var int $carry5 */
+		$carry5 = ($h[5] + (1 << 24)) >> 25;
+		$h[6] += $carry5;
+		$h[5] -= $carry5 << 25;
+		/** @var int $carry7 */
+		$carry7 = ($h[7] + (1 << 24)) >> 25;
+		$h[8] += $carry7;
+		$h[7] -= $carry7 << 25;
+
+		/** @var int $carry0 */
+		$carry0 = ($h[0] + (1 << 25)) >> 26;
+		$h[1] += $carry0;
+		$h[0] -= $carry0 << 26;
+		/** @var int $carry2 */
+		$carry2 = ($h[2] + (1 << 25)) >> 26;
+		$h[3] += $carry2;
+		$h[2] -= $carry2 << 26;
+		/** @var int $carry4 */
+		$carry4 = ($h[4] + (1 << 25)) >> 26;
+		$h[5] += $carry4;
+		$h[4] -= $carry4 << 26;
+		/** @var int $carry6 */
+		$carry6 = ($h[6] + (1 << 25)) >> 26;
+		$h[7] += $carry6;
+		$h[6] -= $carry6 << 26;
+		/** @var int $carry8 */
+		$carry8 = ($h[8] + (1 << 25)) >> 26;
+		$h[9] += $carry8;
+		$h[8] -= $carry8 << 26;
+
+		foreach ($h as $i => $value) {
+			$h[$i] = (int) $value;
+		}
+		return ParagonIE_Sodium_Core_Curve25519_Fe::fromArray($h);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * Inline comments preceded by # are from libsodium's ref10 code.
+	 *
+	 * @param string $n
+	 * @param string $p
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function crypto_scalarmult_curve25519_ref10($n, $p)
+	{
+		# for (i = 0;i < 32;++i) e[i] = n[i];
+		$e = '' . $n;
+		# e[0] &= 248;
+		$e[0] = self::intToChr(
+			self::chrToInt($e[0]) & 248
+		);
+		# e[31] &= 127;
+		# e[31] |= 64;
+		$e[31] = self::intToChr(
+			(self::chrToInt($e[31]) & 127) | 64
+		);
+		# fe_frombytes(x1,p);
+		$x1 = self::fe_frombytes($p);
+		# fe_1(x2);
+		$x2 = self::fe_1();
+		# fe_0(z2);
+		$z2 = self::fe_0();
+		# fe_copy(x3,x1);
+		$x3 = self::fe_copy($x1);
+		# fe_1(z3);
+		$z3 = self::fe_1();
+
+		# swap = 0;
+		/** @var int $swap */
+		$swap = 0;
+
+		# for (pos = 254;pos >= 0;--pos) {
+		for ($pos = 254; $pos >= 0; --$pos) {
+			# b = e[pos / 8] >> (pos & 7);
+			/** @var int $b */
+			$b = self::chrToInt(
+					$e[(int) floor($pos / 8)]
+				) >> ($pos & 7);
+			# b &= 1;
+			$b &= 1;
+			# swap ^= b;
+			$swap ^= $b;
+			# fe_cswap(x2,x3,swap);
+			self::fe_cswap($x2, $x3, $swap);
+			# fe_cswap(z2,z3,swap);
+			self::fe_cswap($z2, $z3, $swap);
+			# swap = b;
+			$swap = $b;
+			# fe_sub(tmp0,x3,z3);
+			$tmp0 = self::fe_sub($x3, $z3);
+			# fe_sub(tmp1,x2,z2);
+			$tmp1 = self::fe_sub($x2, $z2);
+
+			# fe_add(x2,x2,z2);
+			$x2 = self::fe_add($x2, $z2);
+
+			# fe_add(z2,x3,z3);
+			$z2 = self::fe_add($x3, $z3);
+
+			# fe_mul(z3,tmp0,x2);
+			$z3 = self::fe_mul($tmp0, $x2);
+
+			# fe_mul(z2,z2,tmp1);
+			$z2 = self::fe_mul($z2, $tmp1);
+
+			# fe_sq(tmp0,tmp1);
+			$tmp0 = self::fe_sq($tmp1);
+
+			# fe_sq(tmp1,x2);
+			$tmp1 = self::fe_sq($x2);
+
+			# fe_add(x3,z3,z2);
+			$x3 = self::fe_add($z3, $z2);
+
+			# fe_sub(z2,z3,z2);
+			$z2 = self::fe_sub($z3, $z2);
+
+			# fe_mul(x2,tmp1,tmp0);
+			$x2 = self::fe_mul($tmp1, $tmp0);
+
+			# fe_sub(tmp1,tmp1,tmp0);
+			$tmp1 = self::fe_sub($tmp1, $tmp0);
+
+			# fe_sq(z2,z2);
+			$z2 = self::fe_sq($z2);
+
+			# fe_mul121666(z3,tmp1);
+			$z3 = self::fe_mul121666($tmp1);
+
+			# fe_sq(x3,x3);
+			$x3 = self::fe_sq($x3);
+
+			# fe_add(tmp0,tmp0,z3);
+			$tmp0 = self::fe_add($tmp0, $z3);
+
+			# fe_mul(z3,x1,z2);
+			$z3 = self::fe_mul($x1, $z2);
+
+			# fe_mul(z2,tmp1,tmp0);
+			$z2 = self::fe_mul($tmp1, $tmp0);
+		}
+
+		# fe_cswap(x2,x3,swap);
+		self::fe_cswap($x2, $x3, $swap);
+
+		# fe_cswap(z2,z3,swap);
+		self::fe_cswap($z2, $z3, $swap);
+
+		# fe_invert(z2,z2);
+		$z2 = self::fe_invert($z2);
+
+		# fe_mul(x2,x2,z2);
+		$x2 = self::fe_mul($x2, $z2);
+		# fe_tobytes(q,x2);
+		return self::fe_tobytes($x2);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param ParagonIE_Sodium_Core_Curve25519_Fe $edwardsY
+	 * @param ParagonIE_Sodium_Core_Curve25519_Fe $edwardsZ
+	 * @return ParagonIE_Sodium_Core_Curve25519_Fe
+	 */
+	public static function edwards_to_montgomery(
+		ParagonIE_Sodium_Core_Curve25519_Fe $edwardsY,
+		ParagonIE_Sodium_Core_Curve25519_Fe $edwardsZ
+	) {
+		$tempX = self::fe_add($edwardsZ, $edwardsY);
+		$tempZ = self::fe_sub($edwardsZ, $edwardsY);
+		$tempZ = self::fe_invert($tempZ);
+		return self::fe_mul($tempX, $tempZ);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $n
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function crypto_scalarmult_curve25519_ref10_base($n)
+	{
+		# for (i = 0;i < 32;++i) e[i] = n[i];
+		$e = '' . $n;
+
+		# e[0] &= 248;
+		$e[0] = self::intToChr(
+			self::chrToInt($e[0]) & 248
+		);
+
+		# e[31] &= 127;
+		# e[31] |= 64;
+		$e[31] = self::intToChr(
+			(self::chrToInt($e[31]) & 127) | 64
+		);
+
+		$A = self::ge_scalarmult_base($e);
+		if (
+			!($A->Y instanceof ParagonIE_Sodium_Core_Curve25519_Fe)
+				||
+			!($A->Z instanceof ParagonIE_Sodium_Core_Curve25519_Fe)
+		) {
+			throw new TypeError('Null points encountered');
+		}
+		$pk = self::edwards_to_montgomery($A->Y, $A->Z);
+		return self::fe_tobytes($pk);
+	}
 }

vendor/paragonie/sodium_compat/src/Core/Poly1305.php

Indentation +50 added lines, -50 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_Poly1305', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,55 +9,55 @@ 
  */
 abstract class ParagonIE_Sodium_Core_Poly1305 extends ParagonIE_Sodium_Core_Util
 {
-    const BLOCK_SIZE = 16;
+	const BLOCK_SIZE = 16;
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $m
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function onetimeauth($m, $key)
-    {
-        if (self::strlen($key) < 32) {
-            throw new InvalidArgumentException(
-                'Key must be 32 bytes long.'
-            );
-        }
-        $state = new ParagonIE_Sodium_Core_Poly1305_State(
-            self::substr($key, 0, 32)
-        );
-        return $state
-            ->update($m)
-            ->finish();
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $m
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function onetimeauth($m, $key)
+	{
+		if (self::strlen($key) < 32) {
+			throw new InvalidArgumentException(
+				'Key must be 32 bytes long.'
+			);
+		}
+		$state = new ParagonIE_Sodium_Core_Poly1305_State(
+			self::substr($key, 0, 32)
+		);
+		return $state
+			->update($m)
+			->finish();
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $mac
-     * @param string $m
-     * @param string $key
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function onetimeauth_verify($mac, $m, $key)
-    {
-        if (self::strlen($key) < 32) {
-            throw new InvalidArgumentException(
-                'Key must be 32 bytes long.'
-            );
-        }
-        $state = new ParagonIE_Sodium_Core_Poly1305_State(
-            self::substr($key, 0, 32)
-        );
-        $calc = $state
-            ->update($m)
-            ->finish();
-        return self::verify_16($calc, $mac);
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $mac
+	 * @param string $m
+	 * @param string $key
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function onetimeauth_verify($mac, $m, $key)
+	{
+		if (self::strlen($key) < 32) {
+			throw new InvalidArgumentException(
+				'Key must be 32 bytes long.'
+			);
+		}
+		$state = new ParagonIE_Sodium_Core_Poly1305_State(
+			self::substr($key, 0, 32)
+		);
+		$calc = $state
+			->update($m)
+			->finish();
+		return self::verify_16($calc, $mac);
+	}
 }

vendor/paragonie/sodium_compat/src/Core/XSalsa20.php

Indentation +45 added lines, -45 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_XSalsa20', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,49 +9,49 @@ 
  */
 abstract class ParagonIE_Sodium_Core_XSalsa20 extends ParagonIE_Sodium_Core_HSalsa20
 {
-    /**
-     * Expand a key and nonce into an xsalsa20 keystream.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int $len
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function xsalsa20($len, $nonce, $key)
-    {
-        $ret = self::salsa20(
-            $len,
-            self::substr($nonce, 16, 8),
-            self::hsalsa20($nonce, $key)
-        );
-        return $ret;
-    }
+	/**
+	 * Expand a key and nonce into an xsalsa20 keystream.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $len
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function xsalsa20($len, $nonce, $key)
+	{
+		$ret = self::salsa20(
+			$len,
+			self::substr($nonce, 16, 8),
+			self::hsalsa20($nonce, $key)
+		);
+		return $ret;
+	}
 
-    /**
-     * Encrypt a string with XSalsa20. Doesn't provide integrity.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $message
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function xsalsa20_xor($message, $nonce, $key)
-    {
-        return self::xorStrings(
-            $message,
-            self::xsalsa20(
-                self::strlen($message),
-                $nonce,
-                $key
-            )
-        );
-    }
+	/**
+	 * Encrypt a string with XSalsa20. Doesn't provide integrity.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function xsalsa20_xor($message, $nonce, $key)
+	{
+		return self::xorStrings(
+			$message,
+			self::xsalsa20(
+				self::strlen($message),
+				$nonce,
+				$key
+			)
+		);
+	}
 }

vendor/paragonie/sodium_compat/src/Core/ChaCha20.php

Indentation +285 added lines, -285 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_ChaCha20', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,80 +9,80 @@ 
  */
 class ParagonIE_Sodium_Core_ChaCha20 extends ParagonIE_Sodium_Core_Util
 {
-    /**
-     * Bitwise left rotation
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int $v
-     * @param int $n
-     * @return int
-     */
-    public static function rotate($v, $n)
-    {
-        $v &= 0xffffffff;
-        $n &= 31;
-        return (int) (
-            0xffffffff & (
-                ($v << $n)
-                    |
-                ($v >> (32 - $n))
-            )
-        );
-    }
+	/**
+	 * Bitwise left rotation
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $v
+	 * @param int $n
+	 * @return int
+	 */
+	public static function rotate($v, $n)
+	{
+		$v &= 0xffffffff;
+		$n &= 31;
+		return (int) (
+			0xffffffff & (
+				($v << $n)
+					|
+				($v >> (32 - $n))
+			)
+		);
+	}
 
-    /**
-     * The ChaCha20 quarter round function. Works on four 32-bit integers.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int $a
-     * @param int $b
-     * @param int $c
-     * @param int $d
-     * @return array<int, int>
-     */
-    protected static function quarterRound($a, $b, $c, $d)
-    {
-        # a = PLUS(a,b); d = ROTATE(XOR(d,a),16);
-        /** @var int $a */
-        $a = ($a + $b) & 0xffffffff;
-        $d = self::rotate($d ^ $a, 16);
+	/**
+	 * The ChaCha20 quarter round function. Works on four 32-bit integers.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $a
+	 * @param int $b
+	 * @param int $c
+	 * @param int $d
+	 * @return array<int, int>
+	 */
+	protected static function quarterRound($a, $b, $c, $d)
+	{
+		# a = PLUS(a,b); d = ROTATE(XOR(d,a),16);
+		/** @var int $a */
+		$a = ($a + $b) & 0xffffffff;
+		$d = self::rotate($d ^ $a, 16);
 
-        # c = PLUS(c,d); b = ROTATE(XOR(b,c),12);
-        /** @var int $c */
-        $c = ($c + $d) & 0xffffffff;
-        $b = self::rotate($b ^ $c, 12);
+		# c = PLUS(c,d); b = ROTATE(XOR(b,c),12);
+		/** @var int $c */
+		$c = ($c + $d) & 0xffffffff;
+		$b = self::rotate($b ^ $c, 12);
 
-        # a = PLUS(a,b); d = ROTATE(XOR(d,a), 8);
-        /** @var int $a */
-        $a = ($a + $b) & 0xffffffff;
-        $d = self::rotate($d ^ $a, 8);
+		# a = PLUS(a,b); d = ROTATE(XOR(d,a), 8);
+		/** @var int $a */
+		$a = ($a + $b) & 0xffffffff;
+		$d = self::rotate($d ^ $a, 8);
 
-        # c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
-        /** @var int $c */
-        $c = ($c + $d) & 0xffffffff;
-        $b = self::rotate($b ^ $c, 7);
-        return array((int) $a, (int) $b, (int) $c, (int) $d);
-    }
+		# c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
+		/** @var int $c */
+		$c = ($c + $d) & 0xffffffff;
+		$b = self::rotate($b ^ $c, 7);
+		return array((int) $a, (int) $b, (int) $c, (int) $d);
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param ParagonIE_Sodium_Core_ChaCha20_Ctx $ctx
-     * @param string $message
-     *
-     * @return string
-     * @throws TypeError
-     * @throws SodiumException
-     */
-    public static function encryptBytes(
-        ParagonIE_Sodium_Core_ChaCha20_Ctx $ctx,
-        $message = ''
-    ) {
-        $bytes = self::strlen($message);
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param ParagonIE_Sodium_Core_ChaCha20_Ctx $ctx
+	 * @param string $message
+	 *
+	 * @return string
+	 * @throws TypeError
+	 * @throws SodiumException
+	 */
+	public static function encryptBytes(
+		ParagonIE_Sodium_Core_ChaCha20_Ctx $ctx,
+		$message = ''
+	) {
+		$bytes = self::strlen($message);
 
-        /*
+		/*
         j0 = ctx->input[0];
         j1 = ctx->input[1];
         j2 = ctx->input[2];
@@ -100,73 +100,73 @@ 
         j14 = ctx->input[14];
         j15 = ctx->input[15];
         */
-        $j0  = (int) $ctx[0];
-        $j1  = (int) $ctx[1];
-        $j2  = (int) $ctx[2];
-        $j3  = (int) $ctx[3];
-        $j4  = (int) $ctx[4];
-        $j5  = (int) $ctx[5];
-        $j6  = (int) $ctx[6];
-        $j7  = (int) $ctx[7];
-        $j8  = (int) $ctx[8];
-        $j9  = (int) $ctx[9];
-        $j10 = (int) $ctx[10];
-        $j11 = (int) $ctx[11];
-        $j12 = (int) $ctx[12];
-        $j13 = (int) $ctx[13];
-        $j14 = (int) $ctx[14];
-        $j15 = (int) $ctx[15];
+		$j0  = (int) $ctx[0];
+		$j1  = (int) $ctx[1];
+		$j2  = (int) $ctx[2];
+		$j3  = (int) $ctx[3];
+		$j4  = (int) $ctx[4];
+		$j5  = (int) $ctx[5];
+		$j6  = (int) $ctx[6];
+		$j7  = (int) $ctx[7];
+		$j8  = (int) $ctx[8];
+		$j9  = (int) $ctx[9];
+		$j10 = (int) $ctx[10];
+		$j11 = (int) $ctx[11];
+		$j12 = (int) $ctx[12];
+		$j13 = (int) $ctx[13];
+		$j14 = (int) $ctx[14];
+		$j15 = (int) $ctx[15];
 
-        $c = '';
-        for (;;) {
-            if ($bytes < 64) {
-                $message .= str_repeat("\x00", 64 - $bytes);
-            }
+		$c = '';
+		for (;;) {
+			if ($bytes < 64) {
+				$message .= str_repeat("\x00", 64 - $bytes);
+			}
 
-            $x0 =  (int) $j0;
-            $x1 =  (int) $j1;
-            $x2 =  (int) $j2;
-            $x3 =  (int) $j3;
-            $x4 =  (int) $j4;
-            $x5 =  (int) $j5;
-            $x6 =  (int) $j6;
-            $x7 =  (int) $j7;
-            $x8 =  (int) $j8;
-            $x9 =  (int) $j9;
-            $x10 = (int) $j10;
-            $x11 = (int) $j11;
-            $x12 = (int) $j12;
-            $x13 = (int) $j13;
-            $x14 = (int) $j14;
-            $x15 = (int) $j15;
+			$x0 =  (int) $j0;
+			$x1 =  (int) $j1;
+			$x2 =  (int) $j2;
+			$x3 =  (int) $j3;
+			$x4 =  (int) $j4;
+			$x5 =  (int) $j5;
+			$x6 =  (int) $j6;
+			$x7 =  (int) $j7;
+			$x8 =  (int) $j8;
+			$x9 =  (int) $j9;
+			$x10 = (int) $j10;
+			$x11 = (int) $j11;
+			$x12 = (int) $j12;
+			$x13 = (int) $j13;
+			$x14 = (int) $j14;
+			$x15 = (int) $j15;
 
-            # for (i = 20; i > 0; i -= 2) {
-            for ($i = 20; $i > 0; $i -= 2) {
-                # QUARTERROUND( x0,  x4,  x8,  x12)
-                list($x0, $x4, $x8, $x12) = self::quarterRound($x0, $x4, $x8, $x12);
+			# for (i = 20; i > 0; i -= 2) {
+			for ($i = 20; $i > 0; $i -= 2) {
+				# QUARTERROUND( x0,  x4,  x8,  x12)
+				list($x0, $x4, $x8, $x12) = self::quarterRound($x0, $x4, $x8, $x12);
 
-                # QUARTERROUND( x1,  x5,  x9,  x13)
-                list($x1, $x5, $x9, $x13) = self::quarterRound($x1, $x5, $x9, $x13);
+				# QUARTERROUND( x1,  x5,  x9,  x13)
+				list($x1, $x5, $x9, $x13) = self::quarterRound($x1, $x5, $x9, $x13);
 
-                # QUARTERROUND( x2,  x6,  x10,  x14)
-                list($x2, $x6, $x10, $x14) = self::quarterRound($x2, $x6, $x10, $x14);
+				# QUARTERROUND( x2,  x6,  x10,  x14)
+				list($x2, $x6, $x10, $x14) = self::quarterRound($x2, $x6, $x10, $x14);
 
-                # QUARTERROUND( x3,  x7,  x11,  x15)
-                list($x3, $x7, $x11, $x15) = self::quarterRound($x3, $x7, $x11, $x15);
+				# QUARTERROUND( x3,  x7,  x11,  x15)
+				list($x3, $x7, $x11, $x15) = self::quarterRound($x3, $x7, $x11, $x15);
 
-                # QUARTERROUND( x0,  x5,  x10,  x15)
-                list($x0, $x5, $x10, $x15) = self::quarterRound($x0, $x5, $x10, $x15);
+				# QUARTERROUND( x0,  x5,  x10,  x15)
+				list($x0, $x5, $x10, $x15) = self::quarterRound($x0, $x5, $x10, $x15);
 
-                # QUARTERROUND( x1,  x6,  x11,  x12)
-                list($x1, $x6, $x11, $x12) = self::quarterRound($x1, $x6, $x11, $x12);
+				# QUARTERROUND( x1,  x6,  x11,  x12)
+				list($x1, $x6, $x11, $x12) = self::quarterRound($x1, $x6, $x11, $x12);
 
-                # QUARTERROUND( x2,  x7,  x8,  x13)
-                list($x2, $x7, $x8, $x13) = self::quarterRound($x2, $x7, $x8, $x13);
+				# QUARTERROUND( x2,  x7,  x8,  x13)
+				list($x2, $x7, $x8, $x13) = self::quarterRound($x2, $x7, $x8, $x13);
 
-                # QUARTERROUND( x3,  x4,  x9,  x14)
-                list($x3, $x4, $x9, $x14) = self::quarterRound($x3, $x4, $x9, $x14);
-            }
-            /*
+				# QUARTERROUND( x3,  x4,  x9,  x14)
+				list($x3, $x4, $x9, $x14) = self::quarterRound($x3, $x4, $x9, $x14);
+			}
+			/*
             x0 = PLUS(x0, j0);
             x1 = PLUS(x1, j1);
             x2 = PLUS(x2, j2);
@@ -184,40 +184,40 @@ 
             x14 = PLUS(x14, j14);
             x15 = PLUS(x15, j15);
             */
-            /** @var int $x0 */
-            $x0  = ($x0 & 0xffffffff) + $j0;
-            /** @var int $x1 */
-            $x1  = ($x1 & 0xffffffff) + $j1;
-            /** @var int $x2 */
-            $x2  = ($x2 & 0xffffffff) + $j2;
-            /** @var int $x3 */
-            $x3  = ($x3 & 0xffffffff) + $j3;
-            /** @var int $x4 */
-            $x4  = ($x4 & 0xffffffff) + $j4;
-            /** @var int $x5 */
-            $x5  = ($x5 & 0xffffffff) + $j5;
-            /** @var int $x6 */
-            $x6  = ($x6 & 0xffffffff) + $j6;
-            /** @var int $x7 */
-            $x7  = ($x7 & 0xffffffff) + $j7;
-            /** @var int $x8 */
-            $x8  = ($x8 & 0xffffffff) + $j8;
-            /** @var int $x9 */
-            $x9  = ($x9 & 0xffffffff) + $j9;
-            /** @var int $x10 */
-            $x10 = ($x10 & 0xffffffff) + $j10;
-            /** @var int $x11 */
-            $x11 = ($x11 & 0xffffffff) + $j11;
-            /** @var int $x12 */
-            $x12 = ($x12 & 0xffffffff) + $j12;
-            /** @var int $x13 */
-            $x13 = ($x13 & 0xffffffff) + $j13;
-            /** @var int $x14 */
-            $x14 = ($x14 & 0xffffffff) + $j14;
-            /** @var int $x15 */
-            $x15 = ($x15 & 0xffffffff) + $j15;
+			/** @var int $x0 */
+			$x0  = ($x0 & 0xffffffff) + $j0;
+			/** @var int $x1 */
+			$x1  = ($x1 & 0xffffffff) + $j1;
+			/** @var int $x2 */
+			$x2  = ($x2 & 0xffffffff) + $j2;
+			/** @var int $x3 */
+			$x3  = ($x3 & 0xffffffff) + $j3;
+			/** @var int $x4 */
+			$x4  = ($x4 & 0xffffffff) + $j4;
+			/** @var int $x5 */
+			$x5  = ($x5 & 0xffffffff) + $j5;
+			/** @var int $x6 */
+			$x6  = ($x6 & 0xffffffff) + $j6;
+			/** @var int $x7 */
+			$x7  = ($x7 & 0xffffffff) + $j7;
+			/** @var int $x8 */
+			$x8  = ($x8 & 0xffffffff) + $j8;
+			/** @var int $x9 */
+			$x9  = ($x9 & 0xffffffff) + $j9;
+			/** @var int $x10 */
+			$x10 = ($x10 & 0xffffffff) + $j10;
+			/** @var int $x11 */
+			$x11 = ($x11 & 0xffffffff) + $j11;
+			/** @var int $x12 */
+			$x12 = ($x12 & 0xffffffff) + $j12;
+			/** @var int $x13 */
+			$x13 = ($x13 & 0xffffffff) + $j13;
+			/** @var int $x14 */
+			$x14 = ($x14 & 0xffffffff) + $j14;
+			/** @var int $x15 */
+			$x15 = ($x15 & 0xffffffff) + $j15;
 
-            /*
+			/*
             x0 = XOR(x0, LOAD32_LE(m + 0));
             x1 = XOR(x1, LOAD32_LE(m + 4));
             x2 = XOR(x2, LOAD32_LE(m + 8));
@@ -235,35 +235,35 @@ 
             x14 = XOR(x14, LOAD32_LE(m + 56));
             x15 = XOR(x15, LOAD32_LE(m + 60));
             */
-            $x0  ^= self::load_4(self::substr($message, 0, 4));
-            $x1  ^= self::load_4(self::substr($message, 4, 4));
-            $x2  ^= self::load_4(self::substr($message, 8, 4));
-            $x3  ^= self::load_4(self::substr($message, 12, 4));
-            $x4  ^= self::load_4(self::substr($message, 16, 4));
-            $x5  ^= self::load_4(self::substr($message, 20, 4));
-            $x6  ^= self::load_4(self::substr($message, 24, 4));
-            $x7  ^= self::load_4(self::substr($message, 28, 4));
-            $x8  ^= self::load_4(self::substr($message, 32, 4));
-            $x9  ^= self::load_4(self::substr($message, 36, 4));
-            $x10 ^= self::load_4(self::substr($message, 40, 4));
-            $x11 ^= self::load_4(self::substr($message, 44, 4));
-            $x12 ^= self::load_4(self::substr($message, 48, 4));
-            $x13 ^= self::load_4(self::substr($message, 52, 4));
-            $x14 ^= self::load_4(self::substr($message, 56, 4));
-            $x15 ^= self::load_4(self::substr($message, 60, 4));
+			$x0  ^= self::load_4(self::substr($message, 0, 4));
+			$x1  ^= self::load_4(self::substr($message, 4, 4));
+			$x2  ^= self::load_4(self::substr($message, 8, 4));
+			$x3  ^= self::load_4(self::substr($message, 12, 4));
+			$x4  ^= self::load_4(self::substr($message, 16, 4));
+			$x5  ^= self::load_4(self::substr($message, 20, 4));
+			$x6  ^= self::load_4(self::substr($message, 24, 4));
+			$x7  ^= self::load_4(self::substr($message, 28, 4));
+			$x8  ^= self::load_4(self::substr($message, 32, 4));
+			$x9  ^= self::load_4(self::substr($message, 36, 4));
+			$x10 ^= self::load_4(self::substr($message, 40, 4));
+			$x11 ^= self::load_4(self::substr($message, 44, 4));
+			$x12 ^= self::load_4(self::substr($message, 48, 4));
+			$x13 ^= self::load_4(self::substr($message, 52, 4));
+			$x14 ^= self::load_4(self::substr($message, 56, 4));
+			$x15 ^= self::load_4(self::substr($message, 60, 4));
 
-            /*
+			/*
                 j12 = PLUSONE(j12);
                 if (!j12) {
                     j13 = PLUSONE(j13);
                 }
              */
-            ++$j12;
-            if ($j12 & 0xf0000000) {
-                throw new SodiumException('Overflow');
-            }
+			++$j12;
+			if ($j12 & 0xf0000000) {
+				throw new SodiumException('Overflow');
+			}
 
-            /*
+			/*
             STORE32_LE(c + 0, x0);
             STORE32_LE(c + 4, x1);
             STORE32_LE(c + 8, x2);
@@ -281,115 +281,115 @@ 
             STORE32_LE(c + 56, x14);
             STORE32_LE(c + 60, x15);
             */
-            $block = self::store32_le((int) ($x0  & 0xffffffff)) .
-                 self::store32_le((int) ($x1  & 0xffffffff)) .
-                 self::store32_le((int) ($x2  & 0xffffffff)) .
-                 self::store32_le((int) ($x3  & 0xffffffff)) .
-                 self::store32_le((int) ($x4  & 0xffffffff)) .
-                 self::store32_le((int) ($x5  & 0xffffffff)) .
-                 self::store32_le((int) ($x6  & 0xffffffff)) .
-                 self::store32_le((int) ($x7  & 0xffffffff)) .
-                 self::store32_le((int) ($x8  & 0xffffffff)) .
-                 self::store32_le((int) ($x9  & 0xffffffff)) .
-                 self::store32_le((int) ($x10 & 0xffffffff)) .
-                 self::store32_le((int) ($x11 & 0xffffffff)) .
-                 self::store32_le((int) ($x12 & 0xffffffff)) .
-                 self::store32_le((int) ($x13 & 0xffffffff)) .
-                 self::store32_le((int) ($x14 & 0xffffffff)) .
-                 self::store32_le((int) ($x15 & 0xffffffff));
+			$block = self::store32_le((int) ($x0  & 0xffffffff)) .
+				 self::store32_le((int) ($x1  & 0xffffffff)) .
+				 self::store32_le((int) ($x2  & 0xffffffff)) .
+				 self::store32_le((int) ($x3  & 0xffffffff)) .
+				 self::store32_le((int) ($x4  & 0xffffffff)) .
+				 self::store32_le((int) ($x5  & 0xffffffff)) .
+				 self::store32_le((int) ($x6  & 0xffffffff)) .
+				 self::store32_le((int) ($x7  & 0xffffffff)) .
+				 self::store32_le((int) ($x8  & 0xffffffff)) .
+				 self::store32_le((int) ($x9  & 0xffffffff)) .
+				 self::store32_le((int) ($x10 & 0xffffffff)) .
+				 self::store32_le((int) ($x11 & 0xffffffff)) .
+				 self::store32_le((int) ($x12 & 0xffffffff)) .
+				 self::store32_le((int) ($x13 & 0xffffffff)) .
+				 self::store32_le((int) ($x14 & 0xffffffff)) .
+				 self::store32_le((int) ($x15 & 0xffffffff));
 
-            /* Partial block */
-            if ($bytes < 64) {
-                $c .= self::substr($block, 0, $bytes);
-                break;
-            }
+			/* Partial block */
+			if ($bytes < 64) {
+				$c .= self::substr($block, 0, $bytes);
+				break;
+			}
 
-            /* Full block */
-            $c .= $block;
-            $bytes -= 64;
-            if ($bytes <= 0) {
-                break;
-            }
-            $message = self::substr($message, 64);
-        }
-        /* end for(;;) loop */
+			/* Full block */
+			$c .= $block;
+			$bytes -= 64;
+			if ($bytes <= 0) {
+				break;
+			}
+			$message = self::substr($message, 64);
+		}
+		/* end for(;;) loop */
 
-        $ctx[12] = $j12;
-        $ctx[13] = $j13;
-        return $c;
-    }
+		$ctx[12] = $j12;
+		$ctx[13] = $j13;
+		return $c;
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param int $len
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function stream($len = 64, $nonce = '', $key = '')
-    {
-        return self::encryptBytes(
-            new ParagonIE_Sodium_Core_ChaCha20_Ctx($key, $nonce),
-            str_repeat("\x00", $len)
-        );
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $len
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function stream($len = 64, $nonce = '', $key = '')
+	{
+		return self::encryptBytes(
+			new ParagonIE_Sodium_Core_ChaCha20_Ctx($key, $nonce),
+			str_repeat("\x00", $len)
+		);
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param int $len
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function ietfStream($len, $nonce = '', $key = '')
-    {
-        return self::encryptBytes(
-            new ParagonIE_Sodium_Core_ChaCha20_IetfCtx($key, $nonce),
-            str_repeat("\x00", $len)
-        );
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $len
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function ietfStream($len, $nonce = '', $key = '')
+	{
+		return self::encryptBytes(
+			new ParagonIE_Sodium_Core_ChaCha20_IetfCtx($key, $nonce),
+			str_repeat("\x00", $len)
+		);
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $message
-     * @param string $nonce
-     * @param string $key
-     * @param string $ic
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function ietfStreamXorIc($message, $nonce = '', $key = '', $ic = '')
-    {
-        return self::encryptBytes(
-            new ParagonIE_Sodium_Core_ChaCha20_IetfCtx($key, $nonce, $ic),
-            $message
-        );
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $key
+	 * @param string $ic
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function ietfStreamXorIc($message, $nonce = '', $key = '', $ic = '')
+	{
+		return self::encryptBytes(
+			new ParagonIE_Sodium_Core_ChaCha20_IetfCtx($key, $nonce, $ic),
+			$message
+		);
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $message
-     * @param string $nonce
-     * @param string $key
-     * @param string $ic
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function streamXorIc($message, $nonce = '', $key = '', $ic = '')
-    {
-        return self::encryptBytes(
-            new ParagonIE_Sodium_Core_ChaCha20_Ctx($key, $nonce, $ic),
-            $message
-        );
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $key
+	 * @param string $ic
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function streamXorIc($message, $nonce = '', $key = '', $ic = '')
+	{
+		return self::encryptBytes(
+			new ParagonIE_Sodium_Core_ChaCha20_Ctx($key, $nonce, $ic),
+			$message
+		);
+	}
 }

vendor/paragonie/sodium_compat/src/Core/HChaCha20.php

Indentation +86 added lines, -86 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_HChaCha20', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,100 +9,100 @@ 
  */
 class ParagonIE_Sodium_Core_HChaCha20 extends ParagonIE_Sodium_Core_ChaCha20
 {
-    /**
-     * @param string $in
-     * @param string $key
-     * @param string|null $c
-     * @return string
-     * @throws TypeError
-     */
-    public static function hChaCha20($in = '', $key = '', $c = null)
-    {
-        $ctx = array();
+	/**
+	 * @param string $in
+	 * @param string $key
+	 * @param string|null $c
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function hChaCha20($in = '', $key = '', $c = null)
+	{
+		$ctx = array();
 
-        if ($c === null) {
-            $ctx[0] = 0x61707865;
-            $ctx[1] = 0x3320646e;
-            $ctx[2] = 0x79622d32;
-            $ctx[3] = 0x6b206574;
-        } else {
-            $ctx[0] = self::load_4(self::substr($c,  0, 4));
-            $ctx[1] = self::load_4(self::substr($c,  4, 4));
-            $ctx[2] = self::load_4(self::substr($c,  8, 4));
-            $ctx[3] = self::load_4(self::substr($c, 12, 4));
-        }
-        $ctx[4]  = self::load_4(self::substr($key,  0, 4));
-        $ctx[5]  = self::load_4(self::substr($key,  4, 4));
-        $ctx[6]  = self::load_4(self::substr($key,  8, 4));
-        $ctx[7]  = self::load_4(self::substr($key, 12, 4));
-        $ctx[8]  = self::load_4(self::substr($key, 16, 4));
-        $ctx[9]  = self::load_4(self::substr($key, 20, 4));
-        $ctx[10] = self::load_4(self::substr($key, 24, 4));
-        $ctx[11] = self::load_4(self::substr($key, 28, 4));
-        $ctx[12] = self::load_4(self::substr($in,   0, 4));
-        $ctx[13] = self::load_4(self::substr($in,   4, 4));
-        $ctx[14] = self::load_4(self::substr($in,   8, 4));
-        $ctx[15] = self::load_4(self::substr($in,  12, 4));
-        return self::hChaCha20Bytes($ctx);
-    }
+		if ($c === null) {
+			$ctx[0] = 0x61707865;
+			$ctx[1] = 0x3320646e;
+			$ctx[2] = 0x79622d32;
+			$ctx[3] = 0x6b206574;
+		} else {
+			$ctx[0] = self::load_4(self::substr($c,  0, 4));
+			$ctx[1] = self::load_4(self::substr($c,  4, 4));
+			$ctx[2] = self::load_4(self::substr($c,  8, 4));
+			$ctx[3] = self::load_4(self::substr($c, 12, 4));
+		}
+		$ctx[4]  = self::load_4(self::substr($key,  0, 4));
+		$ctx[5]  = self::load_4(self::substr($key,  4, 4));
+		$ctx[6]  = self::load_4(self::substr($key,  8, 4));
+		$ctx[7]  = self::load_4(self::substr($key, 12, 4));
+		$ctx[8]  = self::load_4(self::substr($key, 16, 4));
+		$ctx[9]  = self::load_4(self::substr($key, 20, 4));
+		$ctx[10] = self::load_4(self::substr($key, 24, 4));
+		$ctx[11] = self::load_4(self::substr($key, 28, 4));
+		$ctx[12] = self::load_4(self::substr($in,   0, 4));
+		$ctx[13] = self::load_4(self::substr($in,   4, 4));
+		$ctx[14] = self::load_4(self::substr($in,   8, 4));
+		$ctx[15] = self::load_4(self::substr($in,  12, 4));
+		return self::hChaCha20Bytes($ctx);
+	}
 
-    /**
-     * @param array $ctx
-     * @return string
-     * @throws TypeError
-     */
-    protected static function hChaCha20Bytes(array $ctx)
-    {
-        $x0  = (int) $ctx[0];
-        $x1  = (int) $ctx[1];
-        $x2  = (int) $ctx[2];
-        $x3  = (int) $ctx[3];
-        $x4  = (int) $ctx[4];
-        $x5  = (int) $ctx[5];
-        $x6  = (int) $ctx[6];
-        $x7  = (int) $ctx[7];
-        $x8  = (int) $ctx[8];
-        $x9  = (int) $ctx[9];
-        $x10 = (int) $ctx[10];
-        $x11 = (int) $ctx[11];
-        $x12 = (int) $ctx[12];
-        $x13 = (int) $ctx[13];
-        $x14 = (int) $ctx[14];
-        $x15 = (int) $ctx[15];
+	/**
+	 * @param array $ctx
+	 * @return string
+	 * @throws TypeError
+	 */
+	protected static function hChaCha20Bytes(array $ctx)
+	{
+		$x0  = (int) $ctx[0];
+		$x1  = (int) $ctx[1];
+		$x2  = (int) $ctx[2];
+		$x3  = (int) $ctx[3];
+		$x4  = (int) $ctx[4];
+		$x5  = (int) $ctx[5];
+		$x6  = (int) $ctx[6];
+		$x7  = (int) $ctx[7];
+		$x8  = (int) $ctx[8];
+		$x9  = (int) $ctx[9];
+		$x10 = (int) $ctx[10];
+		$x11 = (int) $ctx[11];
+		$x12 = (int) $ctx[12];
+		$x13 = (int) $ctx[13];
+		$x14 = (int) $ctx[14];
+		$x15 = (int) $ctx[15];
 
-        for ($i = 0; $i < 10; ++$i) {
-            # QUARTERROUND( x0,  x4,  x8,  x12)
-            list($x0, $x4, $x8, $x12) = self::quarterRound($x0, $x4, $x8, $x12);
+		for ($i = 0; $i < 10; ++$i) {
+			# QUARTERROUND( x0,  x4,  x8,  x12)
+			list($x0, $x4, $x8, $x12) = self::quarterRound($x0, $x4, $x8, $x12);
 
-            # QUARTERROUND( x1,  x5,  x9,  x13)
-            list($x1, $x5, $x9, $x13) = self::quarterRound($x1, $x5, $x9, $x13);
+			# QUARTERROUND( x1,  x5,  x9,  x13)
+			list($x1, $x5, $x9, $x13) = self::quarterRound($x1, $x5, $x9, $x13);
 
-            # QUARTERROUND( x2,  x6,  x10,  x14)
-            list($x2, $x6, $x10, $x14) = self::quarterRound($x2, $x6, $x10, $x14);
+			# QUARTERROUND( x2,  x6,  x10,  x14)
+			list($x2, $x6, $x10, $x14) = self::quarterRound($x2, $x6, $x10, $x14);
 
-            # QUARTERROUND( x3,  x7,  x11,  x15)
-            list($x3, $x7, $x11, $x15) = self::quarterRound($x3, $x7, $x11, $x15);
+			# QUARTERROUND( x3,  x7,  x11,  x15)
+			list($x3, $x7, $x11, $x15) = self::quarterRound($x3, $x7, $x11, $x15);
 
-            # QUARTERROUND( x0,  x5,  x10,  x15)
-            list($x0, $x5, $x10, $x15) = self::quarterRound($x0, $x5, $x10, $x15);
+			# QUARTERROUND( x0,  x5,  x10,  x15)
+			list($x0, $x5, $x10, $x15) = self::quarterRound($x0, $x5, $x10, $x15);
 
-            # QUARTERROUND( x1,  x6,  x11,  x12)
-            list($x1, $x6, $x11, $x12) = self::quarterRound($x1, $x6, $x11, $x12);
+			# QUARTERROUND( x1,  x6,  x11,  x12)
+			list($x1, $x6, $x11, $x12) = self::quarterRound($x1, $x6, $x11, $x12);
 
-            # QUARTERROUND( x2,  x7,  x8,  x13)
-            list($x2, $x7, $x8, $x13) = self::quarterRound($x2, $x7, $x8, $x13);
+			# QUARTERROUND( x2,  x7,  x8,  x13)
+			list($x2, $x7, $x8, $x13) = self::quarterRound($x2, $x7, $x8, $x13);
 
-            # QUARTERROUND( x3,  x4,  x9,  x14)
-            list($x3, $x4, $x9, $x14) = self::quarterRound($x3, $x4, $x9, $x14);
-        }
+			# QUARTERROUND( x3,  x4,  x9,  x14)
+			list($x3, $x4, $x9, $x14) = self::quarterRound($x3, $x4, $x9, $x14);
+		}
 
-        return self::store32_le((int) ($x0  & 0xffffffff)) .
-            self::store32_le((int) ($x1  & 0xffffffff)) .
-            self::store32_le((int) ($x2  & 0xffffffff)) .
-            self::store32_le((int) ($x3  & 0xffffffff)) .
-            self::store32_le((int) ($x12 & 0xffffffff)) .
-            self::store32_le((int) ($x13 & 0xffffffff)) .
-            self::store32_le((int) ($x14 & 0xffffffff)) .
-            self::store32_le((int) ($x15 & 0xffffffff));
-    }
+		return self::store32_le((int) ($x0  & 0xffffffff)) .
+			self::store32_le((int) ($x1  & 0xffffffff)) .
+			self::store32_le((int) ($x2  & 0xffffffff)) .
+			self::store32_le((int) ($x3  & 0xffffffff)) .
+			self::store32_le((int) ($x12 & 0xffffffff)) .
+			self::store32_le((int) ($x13 & 0xffffffff)) .
+			self::store32_le((int) ($x14 & 0xffffffff)) .
+			self::store32_le((int) ($x15 & 0xffffffff));
+	}
 }

vendor/paragonie/sodium_compat/src/Core/HSalsa20.php

Indentation +83 added lines, -83 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_HSalsa20', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,88 +9,88 @@ 
  */
 abstract class ParagonIE_Sodium_Core_HSalsa20 extends ParagonIE_Sodium_Core_Salsa20
 {
-    /**
-     * Calculate an hsalsa20 hash of a single block
-     *
-     * HSalsa20 doesn't have a counter and will never be used for more than
-     * one block (used to derive a subkey for xsalsa20).
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $in
-     * @param string $k
-     * @param string|null $c
-     * @return string
-     * @throws TypeError
-     */
-    public static function hsalsa20($in, $k, $c = null)
-    {
-        if ($c === null) {
-            $x0  = 0x61707865;
-            $x5  = 0x3320646e;
-            $x10 = 0x79622d32;
-            $x15 = 0x6b206574;
-        } else {
-            $x0  = self::load_4(self::substr($c, 0, 4));
-            $x5  = self::load_4(self::substr($c, 4, 4));
-            $x10 = self::load_4(self::substr($c, 8, 4));
-            $x15 = self::load_4(self::substr($c, 12, 4));
-        }
-        $x1  = self::load_4(self::substr($k, 0, 4));
-        $x2  = self::load_4(self::substr($k, 4, 4));
-        $x3  = self::load_4(self::substr($k, 8, 4));
-        $x4  = self::load_4(self::substr($k, 12, 4));
-        $x11 = self::load_4(self::substr($k, 16, 4));
-        $x12 = self::load_4(self::substr($k, 20, 4));
-        $x13 = self::load_4(self::substr($k, 24, 4));
-        $x14 = self::load_4(self::substr($k, 28, 4));
-        $x6  = self::load_4(self::substr($in, 0, 4));
-        $x7  = self::load_4(self::substr($in, 4, 4));
-        $x8  = self::load_4(self::substr($in, 8, 4));
-        $x9  = self::load_4(self::substr($in, 12, 4));
+	/**
+	 * Calculate an hsalsa20 hash of a single block
+	 *
+	 * HSalsa20 doesn't have a counter and will never be used for more than
+	 * one block (used to derive a subkey for xsalsa20).
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $in
+	 * @param string $k
+	 * @param string|null $c
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function hsalsa20($in, $k, $c = null)
+	{
+		if ($c === null) {
+			$x0  = 0x61707865;
+			$x5  = 0x3320646e;
+			$x10 = 0x79622d32;
+			$x15 = 0x6b206574;
+		} else {
+			$x0  = self::load_4(self::substr($c, 0, 4));
+			$x5  = self::load_4(self::substr($c, 4, 4));
+			$x10 = self::load_4(self::substr($c, 8, 4));
+			$x15 = self::load_4(self::substr($c, 12, 4));
+		}
+		$x1  = self::load_4(self::substr($k, 0, 4));
+		$x2  = self::load_4(self::substr($k, 4, 4));
+		$x3  = self::load_4(self::substr($k, 8, 4));
+		$x4  = self::load_4(self::substr($k, 12, 4));
+		$x11 = self::load_4(self::substr($k, 16, 4));
+		$x12 = self::load_4(self::substr($k, 20, 4));
+		$x13 = self::load_4(self::substr($k, 24, 4));
+		$x14 = self::load_4(self::substr($k, 28, 4));
+		$x6  = self::load_4(self::substr($in, 0, 4));
+		$x7  = self::load_4(self::substr($in, 4, 4));
+		$x8  = self::load_4(self::substr($in, 8, 4));
+		$x9  = self::load_4(self::substr($in, 12, 4));
 
-        for ($i = self::ROUNDS; $i > 0; $i -= 2) {
-            $x4 ^= self::rotate($x0 + $x12, 7);
-            $x8 ^= self::rotate($x4 + $x0, 9);
-            $x12 ^= self::rotate($x8 + $x4, 13);
-            $x0 ^= self::rotate($x12 + $x8, 18);
-            $x9 ^= self::rotate($x5 + $x1, 7);
-            $x13 ^= self::rotate($x9 + $x5, 9);
-            $x1 ^= self::rotate($x13 + $x9, 13);
-            $x5 ^= self::rotate($x1 + $x13, 18);
-            $x14 ^= self::rotate($x10 + $x6, 7);
-            $x2 ^= self::rotate($x14 + $x10, 9);
-            $x6 ^= self::rotate($x2 + $x14, 13);
-            $x10 ^= self::rotate($x6 + $x2, 18);
-            $x3 ^= self::rotate($x15 + $x11, 7);
-            $x7 ^= self::rotate($x3 + $x15, 9);
-            $x11 ^= self::rotate($x7 + $x3, 13);
-            $x15 ^= self::rotate($x11 + $x7, 18);
-            $x1 ^= self::rotate($x0 + $x3, 7);
-            $x2 ^= self::rotate($x1 + $x0, 9);
-            $x3 ^= self::rotate($x2 + $x1, 13);
-            $x0 ^= self::rotate($x3 + $x2, 18);
-            $x6 ^= self::rotate($x5 + $x4, 7);
-            $x7 ^= self::rotate($x6 + $x5, 9);
-            $x4 ^= self::rotate($x7 + $x6, 13);
-            $x5 ^= self::rotate($x4 + $x7, 18);
-            $x11 ^= self::rotate($x10 + $x9, 7);
-            $x8 ^= self::rotate($x11 + $x10, 9);
-            $x9 ^= self::rotate($x8 + $x11, 13);
-            $x10 ^= self::rotate($x9 + $x8, 18);
-            $x12 ^= self::rotate($x15 + $x14, 7);
-            $x13 ^= self::rotate($x12 + $x15, 9);
-            $x14 ^= self::rotate($x13 + $x12, 13);
-            $x15 ^= self::rotate($x14 + $x13, 18);
-        }
+		for ($i = self::ROUNDS; $i > 0; $i -= 2) {
+			$x4 ^= self::rotate($x0 + $x12, 7);
+			$x8 ^= self::rotate($x4 + $x0, 9);
+			$x12 ^= self::rotate($x8 + $x4, 13);
+			$x0 ^= self::rotate($x12 + $x8, 18);
+			$x9 ^= self::rotate($x5 + $x1, 7);
+			$x13 ^= self::rotate($x9 + $x5, 9);
+			$x1 ^= self::rotate($x13 + $x9, 13);
+			$x5 ^= self::rotate($x1 + $x13, 18);
+			$x14 ^= self::rotate($x10 + $x6, 7);
+			$x2 ^= self::rotate($x14 + $x10, 9);
+			$x6 ^= self::rotate($x2 + $x14, 13);
+			$x10 ^= self::rotate($x6 + $x2, 18);
+			$x3 ^= self::rotate($x15 + $x11, 7);
+			$x7 ^= self::rotate($x3 + $x15, 9);
+			$x11 ^= self::rotate($x7 + $x3, 13);
+			$x15 ^= self::rotate($x11 + $x7, 18);
+			$x1 ^= self::rotate($x0 + $x3, 7);
+			$x2 ^= self::rotate($x1 + $x0, 9);
+			$x3 ^= self::rotate($x2 + $x1, 13);
+			$x0 ^= self::rotate($x3 + $x2, 18);
+			$x6 ^= self::rotate($x5 + $x4, 7);
+			$x7 ^= self::rotate($x6 + $x5, 9);
+			$x4 ^= self::rotate($x7 + $x6, 13);
+			$x5 ^= self::rotate($x4 + $x7, 18);
+			$x11 ^= self::rotate($x10 + $x9, 7);
+			$x8 ^= self::rotate($x11 + $x10, 9);
+			$x9 ^= self::rotate($x8 + $x11, 13);
+			$x10 ^= self::rotate($x9 + $x8, 18);
+			$x12 ^= self::rotate($x15 + $x14, 7);
+			$x13 ^= self::rotate($x12 + $x15, 9);
+			$x14 ^= self::rotate($x13 + $x12, 13);
+			$x15 ^= self::rotate($x14 + $x13, 18);
+		}
 
-        return self::store32_le($x0) .
-            self::store32_le($x5) .
-            self::store32_le($x10) .
-            self::store32_le($x15) .
-            self::store32_le($x6) .
-            self::store32_le($x7) .
-            self::store32_le($x8) .
-            self::store32_le($x9);
-    }
+		return self::store32_le($x0) .
+			self::store32_le($x5) .
+			self::store32_le($x10) .
+			self::store32_le($x15) .
+			self::store32_le($x6) .
+			self::store32_le($x7) .
+			self::store32_le($x8) .
+			self::store32_le($x9);
+	}
 }