gravityview / GravityView

vendor/paragonie/sodium_compat/src/SodiumException.php

Indentation +6 added lines, -6 removed lines

@@ -1,11 +1,11 @@
 <?php
 
 if (!class_exists('SodiumException', false)) {
-    /**
-     * Class SodiumException
-     */
-    class SodiumException extends Exception
-    {
+	/**
+	 * Class SodiumException
+	 */
+	class SodiumException extends Exception
+	{
 
-    }
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -1,6 +1,6 @@
 <?php
 
-if (!class_exists('SodiumException', false)) {
+if ( ! class_exists( 'SodiumException', false ) ) {
     /**
      * Class SodiumException
      */

Braces +1 added lines, -2 removed lines

@@ -4,8 +4,7 @@
     /**
      * Class SodiumException
      */
-    class SodiumException extends Exception
-    {
+    class SodiumException extends Exception {
 
     }
 }

vendor/paragonie/sodium_compat/src/Core32/BLAKE2b.php

Indentation +701 added lines, -701 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_BLAKE2b', false)) {
-    return;
+	return;
 }
 
 /**
@@ -11,709 +11,709 @@ 
  */
 abstract class ParagonIE_Sodium_Core32_BLAKE2b extends ParagonIE_Sodium_Core_Util
 {
-    /**
-     * @var SplFixedArray
-     */
-    public static $iv;
-
-    /**
-     * @var array<int, array<int, int>>
-     */
-    public static $sigma = array(
-        array(  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15),
-        array( 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3),
-        array( 11,  8, 12,  0,  5,  2, 15, 13, 10, 14,  3,  6,  7,  1,  9,  4),
-        array(  7,  9,  3,  1, 13, 12, 11, 14,  2,  6,  5, 10,  4,  0, 15,  8),
-        array(  9,  0,  5,  7,  2,  4, 10, 15, 14,  1, 11, 12,  6,  8,  3, 13),
-        array(  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9),
-        array( 12,  5,  1, 15, 14, 13,  4, 10,  0,  7,  6,  3,  9,  2,  8, 11),
-        array( 13, 11,  7, 14, 12,  1,  3,  9,  5,  0, 15,  4,  8,  6,  2, 10),
-        array(  6, 15, 14,  9, 11,  3,  0,  8, 12,  2, 13,  7,  1,  4, 10,  5),
-        array( 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0),
-        array(  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15),
-        array( 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3)
-    );
-
-    const BLOCKBYTES = 128;
-    const OUTBYTES   = 64;
-    const KEYBYTES   = 64;
-
-    /**
-     * Turn two 32-bit integers into a fixed array representing a 64-bit integer.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int $high
-     * @param int $low
-     * @return ParagonIE_Sodium_Core32_Int64
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function new64($high, $low)
-    {
-        return ParagonIE_Sodium_Core32_Int64::fromInts($low, $high);
-    }
-
-    /**
-     * Convert an arbitrary number into an SplFixedArray of two 32-bit integers
-     * that represents a 64-bit integer.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int $num
-     * @return ParagonIE_Sodium_Core32_Int64
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    protected static function to64($num)
-    {
-        list($hi, $lo) = self::numericTo64BitInteger($num);
-        return self::new64($hi, $lo);
-    }
-
-    /**
-     * Adds two 64-bit integers together, returning their sum as a SplFixedArray
-     * containing two 32-bit integers (representing a 64-bit integer).
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param ParagonIE_Sodium_Core32_Int64 $x
-     * @param ParagonIE_Sodium_Core32_Int64 $y
-     * @return ParagonIE_Sodium_Core32_Int64
-     */
-    protected static function add64($x, $y)
-    {
-        return $x->addInt64($y);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param ParagonIE_Sodium_Core32_Int64 $x
-     * @param ParagonIE_Sodium_Core32_Int64 $y
-     * @param ParagonIE_Sodium_Core32_Int64 $z
-     * @return ParagonIE_Sodium_Core32_Int64
-     */
-    public static function add364($x, $y, $z)
-    {
-        return $x->addInt64($y)->addInt64($z);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param ParagonIE_Sodium_Core32_Int64 $x
-     * @param ParagonIE_Sodium_Core32_Int64 $y
-     * @return ParagonIE_Sodium_Core32_Int64
-     * @throws TypeError
-     */
-    public static function xor64(ParagonIE_Sodium_Core32_Int64 $x, ParagonIE_Sodium_Core32_Int64 $y)
-    {
-        return $x->xorInt64($y);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param ParagonIE_Sodium_Core32_Int64 $x
-     * @param int $c
-     * @return ParagonIE_Sodium_Core32_Int64
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function rotr64(ParagonIE_Sodium_Core32_Int64 $x, $c)
-    {
-        return $x->rotateRight($c);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param SplFixedArray $x
-     * @param int $i
-     * @return ParagonIE_Sodium_Core32_Int64
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function load64($x, $i)
-    {
-        /** @var int $l */
-        $l = (int) ($x[$i])
-             | ((int) ($x[$i+1]) << 8)
-             | ((int) ($x[$i+2]) << 16)
-             | ((int) ($x[$i+3]) << 24);
-        /** @var int $h */
-        $h = (int) ($x[$i+4])
-             | ((int) ($x[$i+5]) << 8)
-             | ((int) ($x[$i+6]) << 16)
-             | ((int) ($x[$i+7]) << 24);
-        return self::new64($h, $l);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param SplFixedArray $x
-     * @param int $i
-     * @param ParagonIE_Sodium_Core32_Int64 $u
-     * @return void
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedAssignment
-     * @psalm-suppress MixedArrayAccess
-     * @psalm-suppress MixedArrayAssignment
-     * @psalm-suppress MixedArrayOffset
-     */
-    public static function store64(SplFixedArray $x, $i, ParagonIE_Sodium_Core32_Int64 $u)
-    {
-        $v = clone $u;
-        $maxLength = $x->getSize() - 1;
-        for ($j = 0; $j < 8; ++$j) {
-            $k = 3 - ($j >> 1);
-            $x[$i] = $v->limbs[$k] & 0xff;
-            if (++$i > $maxLength) {
-                return;
-            }
-            $v->limbs[$k] >>= 8;
-        }
-    }
-
-    /**
-     * This just sets the $iv static variable.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @return void
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function pseudoConstructor()
-    {
-        static $called = false;
-        if ($called) {
-            return;
-        }
-        self::$iv = new SplFixedArray(8);
-        self::$iv[0] = self::new64(0x6a09e667, 0xf3bcc908);
-        self::$iv[1] = self::new64(0xbb67ae85, 0x84caa73b);
-        self::$iv[2] = self::new64(0x3c6ef372, 0xfe94f82b);
-        self::$iv[3] = self::new64(0xa54ff53a, 0x5f1d36f1);
-        self::$iv[4] = self::new64(0x510e527f, 0xade682d1);
-        self::$iv[5] = self::new64(0x9b05688c, 0x2b3e6c1f);
-        self::$iv[6] = self::new64(0x1f83d9ab, 0xfb41bd6b);
-        self::$iv[7] = self::new64(0x5be0cd19, 0x137e2179);
-
-        $called = true;
-    }
-
-    /**
-     * Returns a fresh BLAKE2 context.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @return SplFixedArray
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedAssignment
-     * @psalm-suppress MixedArrayAccess
-     * @psalm-suppress MixedArrayAssignment
-     * @psalm-suppress MixedArrayOffset
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    protected static function context()
-    {
-        $ctx    = new SplFixedArray(6);
-        $ctx[0] = new SplFixedArray(8);   // h
-        $ctx[1] = new SplFixedArray(2);   // t
-        $ctx[2] = new SplFixedArray(2);   // f
-        $ctx[3] = new SplFixedArray(256); // buf
-        $ctx[4] = 0;                      // buflen
-        $ctx[5] = 0;                      // last_node (uint8_t)
-
-        for ($i = 8; $i--;) {
-            $ctx[0][$i] = self::$iv[$i];
-        }
-        for ($i = 256; $i--;) {
-            $ctx[3][$i] = 0;
-        }
-
-        $zero = self::new64(0, 0);
-        $ctx[1][0] = $zero;
-        $ctx[1][1] = $zero;
-        $ctx[2][0] = $zero;
-        $ctx[2][1] = $zero;
-
-        return $ctx;
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param SplFixedArray $ctx
-     * @param SplFixedArray $buf
-     * @return void
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedArrayAccess
-     * @psalm-suppress MixedArrayAssignment
-     * @psalm-suppress MixedAssignment
-     */
-    protected static function compress(SplFixedArray $ctx, SplFixedArray $buf)
-    {
-        $m = new SplFixedArray(16);
-        $v = new SplFixedArray(16);
-
-        for ($i = 16; $i--;) {
-            $m[$i] = self::load64($buf, $i << 3);
-        }
-
-        for ($i = 8; $i--;) {
-            $v[$i] = $ctx[0][$i];
-        }
-
-        $v[ 8] = self::$iv[0];
-        $v[ 9] = self::$iv[1];
-        $v[10] = self::$iv[2];
-        $v[11] = self::$iv[3];
-
-        $v[12] = self::xor64($ctx[1][0], self::$iv[4]);
-        $v[13] = self::xor64($ctx[1][1], self::$iv[5]);
-        $v[14] = self::xor64($ctx[2][0], self::$iv[6]);
-        $v[15] = self::xor64($ctx[2][1], self::$iv[7]);
-
-        for ($r = 0; $r < 12; ++$r) {
-            $v = self::G($r, 0, 0, 4, 8, 12, $v, $m);
-            $v = self::G($r, 1, 1, 5, 9, 13, $v, $m);
-            $v = self::G($r, 2, 2, 6, 10, 14, $v, $m);
-            $v = self::G($r, 3, 3, 7, 11, 15, $v, $m);
-            $v = self::G($r, 4, 0, 5, 10, 15, $v, $m);
-            $v = self::G($r, 5, 1, 6, 11, 12, $v, $m);
-            $v = self::G($r, 6, 2, 7, 8, 13, $v, $m);
-            $v = self::G($r, 7, 3, 4, 9, 14, $v, $m);
-        }
-
-        for ($i = 8; $i--;) {
-            $ctx[0][$i] = self::xor64(
-                $ctx[0][$i], self::xor64($v[$i], $v[$i+8])
-            );
-        }
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param int $r
-     * @param int $i
-     * @param int $a
-     * @param int $b
-     * @param int $c
-     * @param int $d
-     * @param SplFixedArray $v
-     * @param SplFixedArray $m
-     * @return SplFixedArray
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedArrayOffset
-     */
-    public static function G($r, $i, $a, $b, $c, $d, SplFixedArray $v, SplFixedArray $m)
-    {
-        $v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][$i << 1]]);
-        $v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 32);
-        $v[$c] = self::add64($v[$c], $v[$d]);
-        $v[$b] = self::rotr64(self::xor64($v[$b], $v[$c]), 24);
-        $v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][($i << 1) + 1]]);
-        $v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 16);
-        $v[$c] = self::add64($v[$c], $v[$d]);
-        $v[$b] = self::rotr64(self::xor64($v[$b], $v[$c]), 63);
-        return $v;
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param SplFixedArray $ctx
-     * @param int $inc
-     * @return void
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedArrayAccess
-     * @psalm-suppress MixedArrayAssignment
-     */
-    public static function increment_counter($ctx, $inc)
-    {
-        if ($inc < 0) {
-            throw new SodiumException('Increasing by a negative number makes no sense.');
-        }
-        $t = self::to64($inc);
-        # S->t is $ctx[1] in our implementation
-
-        # S->t[0] = ( uint64_t )( t >> 0 );
-        $ctx[1][0] = self::add64($ctx[1][0], $t);
-
-        # S->t[1] += ( S->t[0] < inc );
-        if (!($ctx[1][0] instanceof ParagonIE_Sodium_Core32_Int64)) {
-            throw new TypeError('Not an int64');
-        }
-        /** @var ParagonIE_Sodium_Core32_Int64 $c*/
-        $c = $ctx[1][0];
-        if ($c->isLessThanInt($inc)) {
-            $ctx[1][1] = self::add64($ctx[1][1], self::to64(1));
-        }
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param SplFixedArray $ctx
-     * @param SplFixedArray $p
-     * @param int $plen
-     * @return void
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedAssignment
-     * @psalm-suppress MixedArrayAccess
-     * @psalm-suppress MixedArrayAssignment
-     * @psalm-suppress MixedArrayOffset
-     * @psalm-suppress MixedMethodCall
-     * @psalm-suppress MixedOperand
-     */
-    public static function update(SplFixedArray $ctx, SplFixedArray $p, $plen)
-    {
-        self::pseudoConstructor();
-
-        $offset = 0;
-        while ($plen > 0) {
-            $left = $ctx[4];
-            $fill = 256 - $left;
-
-            if ($plen > $fill) {
-                # memcpy( S->buf + left, in, fill ); /* Fill buffer */
-                for ($i = $fill; $i--;) {
-                    $ctx[3][$i + $left] = $p[$i + $offset];
-                }
-
-                # S->buflen += fill;
-                $ctx[4] += $fill;
-
-                # blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
-                self::increment_counter($ctx, 128);
-
-                # blake2b_compress( S, S->buf ); /* Compress */
-                self::compress($ctx, $ctx[3]);
-
-                # memcpy( S->buf, S->buf + BLAKE2B_BLOCKBYTES, BLAKE2B_BLOCKBYTES ); /* Shift buffer left */
-                for ($i = 128; $i--;) {
-                    $ctx[3][$i] = $ctx[3][$i + 128];
-                }
-
-                # S->buflen -= BLAKE2B_BLOCKBYTES;
-                $ctx[4] -= 128;
-
-                # in += fill;
-                $offset += $fill;
-
-                # inlen -= fill;
-                $plen -= $fill;
-            } else {
-                for ($i = $plen; $i--;) {
-                    $ctx[3][$i + $left] = $p[$i + $offset];
-                }
-                $ctx[4] += $plen;
-                $offset += $plen;
-                $plen -= $plen;
-            }
-        }
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param SplFixedArray $ctx
-     * @param SplFixedArray $out
-     * @return SplFixedArray
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedAssignment
-     * @psalm-suppress MixedArrayAccess
-     * @psalm-suppress MixedArrayAssignment
-     * @psalm-suppress MixedArrayOffset
-     * @psalm-suppress MixedMethodCall
-     * @psalm-suppress MixedOperand
-     */
-    public static function finish(SplFixedArray $ctx, SplFixedArray $out)
-    {
-        self::pseudoConstructor();
-        if ($ctx[4] > 128) {
-            self::increment_counter($ctx, 128);
-            self::compress($ctx, $ctx[3]);
-            $ctx[4] -= 128;
-            if ($ctx[4] > 128) {
-                throw new SodiumException('Failed to assert that buflen <= 128 bytes');
-            }
-            for ($i = $ctx[4]; $i--;) {
-                $ctx[3][$i] = $ctx[3][$i + 128];
-            }
-        }
-
-        self::increment_counter($ctx, $ctx[4]);
-        $ctx[2][0] = self::new64(0xffffffff, 0xffffffff);
-
-        for ($i = 256 - $ctx[4]; $i--;) {
-            /** @var int $i */
-            $ctx[3][$i + $ctx[4]] = 0;
-        }
-
-        self::compress($ctx, $ctx[3]);
-
-        $i = (int) (($out->getSize() - 1) / 8);
-        for (; $i >= 0; --$i) {
-            self::store64($out, $i << 3, $ctx[0][$i]);
-        }
-        return $out;
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param SplFixedArray|null $key
-     * @param int $outlen
-     * @param SplFixedArray|null $salt
-     * @param SplFixedArray|null $personal
-     * @return SplFixedArray
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedAssignment
-     * @psalm-suppress MixedArrayAccess
-     * @psalm-suppress MixedArrayAssignment
-     * @psalm-suppress MixedMethodCall
-     */
-    public static function init(
-        $key = null,
-        $outlen = 64,
-        $salt = null,
-        $personal = null
-    ) {
-        self::pseudoConstructor();
-        $klen = 0;
-
-        if ($key !== null) {
-            if (count($key) > 64) {
-                throw new SodiumException('Invalid key size');
-            }
-            $klen = count($key);
-        }
-
-        if ($outlen > 64) {
-            throw new SodiumException('Invalid output size');
-        }
-
-        $ctx = self::context();
-
-        $p = new SplFixedArray(64);
-        // Zero our param buffer...
-        for ($i = 64; --$i;) {
-            $p[$i] = 0;
-        }
-
-        $p[0] = $outlen; // digest_length
-        $p[1] = $klen;   // key_length
-        $p[2] = 1;       // fanout
-        $p[3] = 1;       // depth
-
-        if ($salt instanceof SplFixedArray) {
-            // salt: [32] through [47]
-            for ($i = 0; $i < 16; ++$i) {
-                $p[32 + $i] = (int) $salt[$i];
-            }
-        }
-        if ($personal instanceof SplFixedArray) {
-            // personal: [48] through [63]
-            for ($i = 0; $i < 16; ++$i) {
-                $p[48 + $i] = (int) $personal[$i];
-            }
-        }
-
-        $ctx[0][0] = self::xor64(
-            $ctx[0][0],
-            self::load64($p, 0)
-        );
-
-        if ($salt instanceof SplFixedArray || $personal instanceof SplFixedArray) {
-            // We need to do what blake2b_init_param() does:
-            for ($i = 1; $i < 8; ++$i) {
-                $ctx[0][$i] = self::xor64(
-                    $ctx[0][$i],
-                    self::load64($p, $i << 3)
-                );
-            }
-        }
-
-        if ($klen > 0 && $key instanceof SplFixedArray) {
-            $block = new SplFixedArray(128);
-            for ($i = 128; $i--;) {
-                $block[$i] = 0;
-            }
-            for ($i = $klen; $i--;) {
-                $block[$i] = $key[$i];
-            }
-            self::update($ctx, $block, 128);
-            $ctx[4] = 128;
-        }
-
-        return $ctx;
-    }
-
-    /**
-     * Convert a string into an SplFixedArray of integers
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $str
-     * @return SplFixedArray
-     * @psalm-suppress MixedArgumentTypeCoercion
-     */
-    public static function stringToSplFixedArray($str = '')
-    {
-        $values = unpack('C*', $str);
-        return SplFixedArray::fromArray(array_values($values));
-    }
-
-    /**
-     * Convert an SplFixedArray of integers into a string
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param SplFixedArray $a
-     * @return string
-     */
-    public static function SplFixedArrayToString(SplFixedArray $a)
-    {
-        /**
-         * @var array<int, string|int>
-         */
-        $arr = $a->toArray();
-        $c = $a->count();
-        array_unshift($arr, str_repeat('C', $c));
-        return (string) (call_user_func_array('pack', $arr));
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param SplFixedArray $ctx
-     * @return string
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedArrayAccess
-     * @psalm-suppress MixedArrayAssignment
-     * @psalm-suppress MixedMethodCall
-     */
-    public static function contextToString(SplFixedArray $ctx)
-    {
-        $str = '';
-        /** @var array<int, ParagonIE_Sodium_Core32_Int64> $ctxA */
-        $ctxA = $ctx[0]->toArray();
-
-        # uint64_t h[8];
-        for ($i = 0; $i < 8; ++$i) {
-            if (!($ctxA[$i] instanceof ParagonIE_Sodium_Core32_Int64)) {
-                throw new TypeError('Not an instance of Int64');
-            }
-            /** @var ParagonIE_Sodium_Core32_Int64 $ctxAi */
-            $ctxAi = $ctxA[$i];
-            $str .= $ctxAi->toReverseString();
-        }
-
-        # uint64_t t[2];
-        # uint64_t f[2];
-        for ($i = 1; $i < 3; ++$i) {
-            /** @var array<int, ParagonIE_Sodium_Core32_Int64> $ctxA */
-            $ctxA = $ctx[$i]->toArray();
-            /** @var ParagonIE_Sodium_Core32_Int64 $ctxA1 */
-            $ctxA1 = $ctxA[0];
-            /** @var ParagonIE_Sodium_Core32_Int64 $ctxA2 */
-            $ctxA2 = $ctxA[1];
-
-            $str .= $ctxA1->toReverseString();
-            $str .= $ctxA2->toReverseString();
-        }
-
-        # uint8_t buf[2 * 128];
-        $str .= self::SplFixedArrayToString($ctx[3]);
-
-        /** @var int $ctx4 */
-        $ctx4 = $ctx[4];
-
-        # size_t buflen;
-        $str .= implode('', array(
-            self::intToChr($ctx4 & 0xff),
-            self::intToChr(($ctx4 >> 8) & 0xff),
-            self::intToChr(($ctx4 >> 16) & 0xff),
-            self::intToChr(($ctx4 >> 24) & 0xff),
-            "\x00\x00\x00\x00"
-            /*
+	/**
+	 * @var SplFixedArray
+	 */
+	public static $iv;
+
+	/**
+	 * @var array<int, array<int, int>>
+	 */
+	public static $sigma = array(
+		array(  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15),
+		array( 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3),
+		array( 11,  8, 12,  0,  5,  2, 15, 13, 10, 14,  3,  6,  7,  1,  9,  4),
+		array(  7,  9,  3,  1, 13, 12, 11, 14,  2,  6,  5, 10,  4,  0, 15,  8),
+		array(  9,  0,  5,  7,  2,  4, 10, 15, 14,  1, 11, 12,  6,  8,  3, 13),
+		array(  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9),
+		array( 12,  5,  1, 15, 14, 13,  4, 10,  0,  7,  6,  3,  9,  2,  8, 11),
+		array( 13, 11,  7, 14, 12,  1,  3,  9,  5,  0, 15,  4,  8,  6,  2, 10),
+		array(  6, 15, 14,  9, 11,  3,  0,  8, 12,  2, 13,  7,  1,  4, 10,  5),
+		array( 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0),
+		array(  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15),
+		array( 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3)
+	);
+
+	const BLOCKBYTES = 128;
+	const OUTBYTES   = 64;
+	const KEYBYTES   = 64;
+
+	/**
+	 * Turn two 32-bit integers into a fixed array representing a 64-bit integer.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $high
+	 * @param int $low
+	 * @return ParagonIE_Sodium_Core32_Int64
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function new64($high, $low)
+	{
+		return ParagonIE_Sodium_Core32_Int64::fromInts($low, $high);
+	}
+
+	/**
+	 * Convert an arbitrary number into an SplFixedArray of two 32-bit integers
+	 * that represents a 64-bit integer.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $num
+	 * @return ParagonIE_Sodium_Core32_Int64
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	protected static function to64($num)
+	{
+		list($hi, $lo) = self::numericTo64BitInteger($num);
+		return self::new64($hi, $lo);
+	}
+
+	/**
+	 * Adds two 64-bit integers together, returning their sum as a SplFixedArray
+	 * containing two 32-bit integers (representing a 64-bit integer).
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param ParagonIE_Sodium_Core32_Int64 $x
+	 * @param ParagonIE_Sodium_Core32_Int64 $y
+	 * @return ParagonIE_Sodium_Core32_Int64
+	 */
+	protected static function add64($x, $y)
+	{
+		return $x->addInt64($y);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param ParagonIE_Sodium_Core32_Int64 $x
+	 * @param ParagonIE_Sodium_Core32_Int64 $y
+	 * @param ParagonIE_Sodium_Core32_Int64 $z
+	 * @return ParagonIE_Sodium_Core32_Int64
+	 */
+	public static function add364($x, $y, $z)
+	{
+		return $x->addInt64($y)->addInt64($z);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param ParagonIE_Sodium_Core32_Int64 $x
+	 * @param ParagonIE_Sodium_Core32_Int64 $y
+	 * @return ParagonIE_Sodium_Core32_Int64
+	 * @throws TypeError
+	 */
+	public static function xor64(ParagonIE_Sodium_Core32_Int64 $x, ParagonIE_Sodium_Core32_Int64 $y)
+	{
+		return $x->xorInt64($y);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param ParagonIE_Sodium_Core32_Int64 $x
+	 * @param int $c
+	 * @return ParagonIE_Sodium_Core32_Int64
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function rotr64(ParagonIE_Sodium_Core32_Int64 $x, $c)
+	{
+		return $x->rotateRight($c);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param SplFixedArray $x
+	 * @param int $i
+	 * @return ParagonIE_Sodium_Core32_Int64
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function load64($x, $i)
+	{
+		/** @var int $l */
+		$l = (int) ($x[$i])
+			 | ((int) ($x[$i+1]) << 8)
+			 | ((int) ($x[$i+2]) << 16)
+			 | ((int) ($x[$i+3]) << 24);
+		/** @var int $h */
+		$h = (int) ($x[$i+4])
+			 | ((int) ($x[$i+5]) << 8)
+			 | ((int) ($x[$i+6]) << 16)
+			 | ((int) ($x[$i+7]) << 24);
+		return self::new64($h, $l);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param SplFixedArray $x
+	 * @param int $i
+	 * @param ParagonIE_Sodium_Core32_Int64 $u
+	 * @return void
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedAssignment
+	 * @psalm-suppress MixedArrayAccess
+	 * @psalm-suppress MixedArrayAssignment
+	 * @psalm-suppress MixedArrayOffset
+	 */
+	public static function store64(SplFixedArray $x, $i, ParagonIE_Sodium_Core32_Int64 $u)
+	{
+		$v = clone $u;
+		$maxLength = $x->getSize() - 1;
+		for ($j = 0; $j < 8; ++$j) {
+			$k = 3 - ($j >> 1);
+			$x[$i] = $v->limbs[$k] & 0xff;
+			if (++$i > $maxLength) {
+				return;
+			}
+			$v->limbs[$k] >>= 8;
+		}
+	}
+
+	/**
+	 * This just sets the $iv static variable.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @return void
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function pseudoConstructor()
+	{
+		static $called = false;
+		if ($called) {
+			return;
+		}
+		self::$iv = new SplFixedArray(8);
+		self::$iv[0] = self::new64(0x6a09e667, 0xf3bcc908);
+		self::$iv[1] = self::new64(0xbb67ae85, 0x84caa73b);
+		self::$iv[2] = self::new64(0x3c6ef372, 0xfe94f82b);
+		self::$iv[3] = self::new64(0xa54ff53a, 0x5f1d36f1);
+		self::$iv[4] = self::new64(0x510e527f, 0xade682d1);
+		self::$iv[5] = self::new64(0x9b05688c, 0x2b3e6c1f);
+		self::$iv[6] = self::new64(0x1f83d9ab, 0xfb41bd6b);
+		self::$iv[7] = self::new64(0x5be0cd19, 0x137e2179);
+
+		$called = true;
+	}
+
+	/**
+	 * Returns a fresh BLAKE2 context.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @return SplFixedArray
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedAssignment
+	 * @psalm-suppress MixedArrayAccess
+	 * @psalm-suppress MixedArrayAssignment
+	 * @psalm-suppress MixedArrayOffset
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	protected static function context()
+	{
+		$ctx    = new SplFixedArray(6);
+		$ctx[0] = new SplFixedArray(8);   // h
+		$ctx[1] = new SplFixedArray(2);   // t
+		$ctx[2] = new SplFixedArray(2);   // f
+		$ctx[3] = new SplFixedArray(256); // buf
+		$ctx[4] = 0;                      // buflen
+		$ctx[5] = 0;                      // last_node (uint8_t)
+
+		for ($i = 8; $i--;) {
+			$ctx[0][$i] = self::$iv[$i];
+		}
+		for ($i = 256; $i--;) {
+			$ctx[3][$i] = 0;
+		}
+
+		$zero = self::new64(0, 0);
+		$ctx[1][0] = $zero;
+		$ctx[1][1] = $zero;
+		$ctx[2][0] = $zero;
+		$ctx[2][1] = $zero;
+
+		return $ctx;
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param SplFixedArray $ctx
+	 * @param SplFixedArray $buf
+	 * @return void
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedArrayAccess
+	 * @psalm-suppress MixedArrayAssignment
+	 * @psalm-suppress MixedAssignment
+	 */
+	protected static function compress(SplFixedArray $ctx, SplFixedArray $buf)
+	{
+		$m = new SplFixedArray(16);
+		$v = new SplFixedArray(16);
+
+		for ($i = 16; $i--;) {
+			$m[$i] = self::load64($buf, $i << 3);
+		}
+
+		for ($i = 8; $i--;) {
+			$v[$i] = $ctx[0][$i];
+		}
+
+		$v[ 8] = self::$iv[0];
+		$v[ 9] = self::$iv[1];
+		$v[10] = self::$iv[2];
+		$v[11] = self::$iv[3];
+
+		$v[12] = self::xor64($ctx[1][0], self::$iv[4]);
+		$v[13] = self::xor64($ctx[1][1], self::$iv[5]);
+		$v[14] = self::xor64($ctx[2][0], self::$iv[6]);
+		$v[15] = self::xor64($ctx[2][1], self::$iv[7]);
+
+		for ($r = 0; $r < 12; ++$r) {
+			$v = self::G($r, 0, 0, 4, 8, 12, $v, $m);
+			$v = self::G($r, 1, 1, 5, 9, 13, $v, $m);
+			$v = self::G($r, 2, 2, 6, 10, 14, $v, $m);
+			$v = self::G($r, 3, 3, 7, 11, 15, $v, $m);
+			$v = self::G($r, 4, 0, 5, 10, 15, $v, $m);
+			$v = self::G($r, 5, 1, 6, 11, 12, $v, $m);
+			$v = self::G($r, 6, 2, 7, 8, 13, $v, $m);
+			$v = self::G($r, 7, 3, 4, 9, 14, $v, $m);
+		}
+
+		for ($i = 8; $i--;) {
+			$ctx[0][$i] = self::xor64(
+				$ctx[0][$i], self::xor64($v[$i], $v[$i+8])
+			);
+		}
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $r
+	 * @param int $i
+	 * @param int $a
+	 * @param int $b
+	 * @param int $c
+	 * @param int $d
+	 * @param SplFixedArray $v
+	 * @param SplFixedArray $m
+	 * @return SplFixedArray
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedArrayOffset
+	 */
+	public static function G($r, $i, $a, $b, $c, $d, SplFixedArray $v, SplFixedArray $m)
+	{
+		$v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][$i << 1]]);
+		$v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 32);
+		$v[$c] = self::add64($v[$c], $v[$d]);
+		$v[$b] = self::rotr64(self::xor64($v[$b], $v[$c]), 24);
+		$v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][($i << 1) + 1]]);
+		$v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 16);
+		$v[$c] = self::add64($v[$c], $v[$d]);
+		$v[$b] = self::rotr64(self::xor64($v[$b], $v[$c]), 63);
+		return $v;
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param SplFixedArray $ctx
+	 * @param int $inc
+	 * @return void
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedArrayAccess
+	 * @psalm-suppress MixedArrayAssignment
+	 */
+	public static function increment_counter($ctx, $inc)
+	{
+		if ($inc < 0) {
+			throw new SodiumException('Increasing by a negative number makes no sense.');
+		}
+		$t = self::to64($inc);
+		# S->t is $ctx[1] in our implementation
+
+		# S->t[0] = ( uint64_t )( t >> 0 );
+		$ctx[1][0] = self::add64($ctx[1][0], $t);
+
+		# S->t[1] += ( S->t[0] < inc );
+		if (!($ctx[1][0] instanceof ParagonIE_Sodium_Core32_Int64)) {
+			throw new TypeError('Not an int64');
+		}
+		/** @var ParagonIE_Sodium_Core32_Int64 $c*/
+		$c = $ctx[1][0];
+		if ($c->isLessThanInt($inc)) {
+			$ctx[1][1] = self::add64($ctx[1][1], self::to64(1));
+		}
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param SplFixedArray $ctx
+	 * @param SplFixedArray $p
+	 * @param int $plen
+	 * @return void
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedAssignment
+	 * @psalm-suppress MixedArrayAccess
+	 * @psalm-suppress MixedArrayAssignment
+	 * @psalm-suppress MixedArrayOffset
+	 * @psalm-suppress MixedMethodCall
+	 * @psalm-suppress MixedOperand
+	 */
+	public static function update(SplFixedArray $ctx, SplFixedArray $p, $plen)
+	{
+		self::pseudoConstructor();
+
+		$offset = 0;
+		while ($plen > 0) {
+			$left = $ctx[4];
+			$fill = 256 - $left;
+
+			if ($plen > $fill) {
+				# memcpy( S->buf + left, in, fill ); /* Fill buffer */
+				for ($i = $fill; $i--;) {
+					$ctx[3][$i + $left] = $p[$i + $offset];
+				}
+
+				# S->buflen += fill;
+				$ctx[4] += $fill;
+
+				# blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
+				self::increment_counter($ctx, 128);
+
+				# blake2b_compress( S, S->buf ); /* Compress */
+				self::compress($ctx, $ctx[3]);
+
+				# memcpy( S->buf, S->buf + BLAKE2B_BLOCKBYTES, BLAKE2B_BLOCKBYTES ); /* Shift buffer left */
+				for ($i = 128; $i--;) {
+					$ctx[3][$i] = $ctx[3][$i + 128];
+				}
+
+				# S->buflen -= BLAKE2B_BLOCKBYTES;
+				$ctx[4] -= 128;
+
+				# in += fill;
+				$offset += $fill;
+
+				# inlen -= fill;
+				$plen -= $fill;
+			} else {
+				for ($i = $plen; $i--;) {
+					$ctx[3][$i + $left] = $p[$i + $offset];
+				}
+				$ctx[4] += $plen;
+				$offset += $plen;
+				$plen -= $plen;
+			}
+		}
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param SplFixedArray $ctx
+	 * @param SplFixedArray $out
+	 * @return SplFixedArray
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedAssignment
+	 * @psalm-suppress MixedArrayAccess
+	 * @psalm-suppress MixedArrayAssignment
+	 * @psalm-suppress MixedArrayOffset
+	 * @psalm-suppress MixedMethodCall
+	 * @psalm-suppress MixedOperand
+	 */
+	public static function finish(SplFixedArray $ctx, SplFixedArray $out)
+	{
+		self::pseudoConstructor();
+		if ($ctx[4] > 128) {
+			self::increment_counter($ctx, 128);
+			self::compress($ctx, $ctx[3]);
+			$ctx[4] -= 128;
+			if ($ctx[4] > 128) {
+				throw new SodiumException('Failed to assert that buflen <= 128 bytes');
+			}
+			for ($i = $ctx[4]; $i--;) {
+				$ctx[3][$i] = $ctx[3][$i + 128];
+			}
+		}
+
+		self::increment_counter($ctx, $ctx[4]);
+		$ctx[2][0] = self::new64(0xffffffff, 0xffffffff);
+
+		for ($i = 256 - $ctx[4]; $i--;) {
+			/** @var int $i */
+			$ctx[3][$i + $ctx[4]] = 0;
+		}
+
+		self::compress($ctx, $ctx[3]);
+
+		$i = (int) (($out->getSize() - 1) / 8);
+		for (; $i >= 0; --$i) {
+			self::store64($out, $i << 3, $ctx[0][$i]);
+		}
+		return $out;
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param SplFixedArray|null $key
+	 * @param int $outlen
+	 * @param SplFixedArray|null $salt
+	 * @param SplFixedArray|null $personal
+	 * @return SplFixedArray
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedAssignment
+	 * @psalm-suppress MixedArrayAccess
+	 * @psalm-suppress MixedArrayAssignment
+	 * @psalm-suppress MixedMethodCall
+	 */
+	public static function init(
+		$key = null,
+		$outlen = 64,
+		$salt = null,
+		$personal = null
+	) {
+		self::pseudoConstructor();
+		$klen = 0;
+
+		if ($key !== null) {
+			if (count($key) > 64) {
+				throw new SodiumException('Invalid key size');
+			}
+			$klen = count($key);
+		}
+
+		if ($outlen > 64) {
+			throw new SodiumException('Invalid output size');
+		}
+
+		$ctx = self::context();
+
+		$p = new SplFixedArray(64);
+		// Zero our param buffer...
+		for ($i = 64; --$i;) {
+			$p[$i] = 0;
+		}
+
+		$p[0] = $outlen; // digest_length
+		$p[1] = $klen;   // key_length
+		$p[2] = 1;       // fanout
+		$p[3] = 1;       // depth
+
+		if ($salt instanceof SplFixedArray) {
+			// salt: [32] through [47]
+			for ($i = 0; $i < 16; ++$i) {
+				$p[32 + $i] = (int) $salt[$i];
+			}
+		}
+		if ($personal instanceof SplFixedArray) {
+			// personal: [48] through [63]
+			for ($i = 0; $i < 16; ++$i) {
+				$p[48 + $i] = (int) $personal[$i];
+			}
+		}
+
+		$ctx[0][0] = self::xor64(
+			$ctx[0][0],
+			self::load64($p, 0)
+		);
+
+		if ($salt instanceof SplFixedArray || $personal instanceof SplFixedArray) {
+			// We need to do what blake2b_init_param() does:
+			for ($i = 1; $i < 8; ++$i) {
+				$ctx[0][$i] = self::xor64(
+					$ctx[0][$i],
+					self::load64($p, $i << 3)
+				);
+			}
+		}
+
+		if ($klen > 0 && $key instanceof SplFixedArray) {
+			$block = new SplFixedArray(128);
+			for ($i = 128; $i--;) {
+				$block[$i] = 0;
+			}
+			for ($i = $klen; $i--;) {
+				$block[$i] = $key[$i];
+			}
+			self::update($ctx, $block, 128);
+			$ctx[4] = 128;
+		}
+
+		return $ctx;
+	}
+
+	/**
+	 * Convert a string into an SplFixedArray of integers
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $str
+	 * @return SplFixedArray
+	 * @psalm-suppress MixedArgumentTypeCoercion
+	 */
+	public static function stringToSplFixedArray($str = '')
+	{
+		$values = unpack('C*', $str);
+		return SplFixedArray::fromArray(array_values($values));
+	}
+
+	/**
+	 * Convert an SplFixedArray of integers into a string
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param SplFixedArray $a
+	 * @return string
+	 */
+	public static function SplFixedArrayToString(SplFixedArray $a)
+	{
+		/**
+		 * @var array<int, string|int>
+		 */
+		$arr = $a->toArray();
+		$c = $a->count();
+		array_unshift($arr, str_repeat('C', $c));
+		return (string) (call_user_func_array('pack', $arr));
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param SplFixedArray $ctx
+	 * @return string
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedArrayAccess
+	 * @psalm-suppress MixedArrayAssignment
+	 * @psalm-suppress MixedMethodCall
+	 */
+	public static function contextToString(SplFixedArray $ctx)
+	{
+		$str = '';
+		/** @var array<int, ParagonIE_Sodium_Core32_Int64> $ctxA */
+		$ctxA = $ctx[0]->toArray();
+
+		# uint64_t h[8];
+		for ($i = 0; $i < 8; ++$i) {
+			if (!($ctxA[$i] instanceof ParagonIE_Sodium_Core32_Int64)) {
+				throw new TypeError('Not an instance of Int64');
+			}
+			/** @var ParagonIE_Sodium_Core32_Int64 $ctxAi */
+			$ctxAi = $ctxA[$i];
+			$str .= $ctxAi->toReverseString();
+		}
+
+		# uint64_t t[2];
+		# uint64_t f[2];
+		for ($i = 1; $i < 3; ++$i) {
+			/** @var array<int, ParagonIE_Sodium_Core32_Int64> $ctxA */
+			$ctxA = $ctx[$i]->toArray();
+			/** @var ParagonIE_Sodium_Core32_Int64 $ctxA1 */
+			$ctxA1 = $ctxA[0];
+			/** @var ParagonIE_Sodium_Core32_Int64 $ctxA2 */
+			$ctxA2 = $ctxA[1];
+
+			$str .= $ctxA1->toReverseString();
+			$str .= $ctxA2->toReverseString();
+		}
+
+		# uint8_t buf[2 * 128];
+		$str .= self::SplFixedArrayToString($ctx[3]);
+
+		/** @var int $ctx4 */
+		$ctx4 = $ctx[4];
+
+		# size_t buflen;
+		$str .= implode('', array(
+			self::intToChr($ctx4 & 0xff),
+			self::intToChr(($ctx4 >> 8) & 0xff),
+			self::intToChr(($ctx4 >> 16) & 0xff),
+			self::intToChr(($ctx4 >> 24) & 0xff),
+			"\x00\x00\x00\x00"
+			/*
             self::intToChr(($ctx4 >> 32) & 0xff),
             self::intToChr(($ctx4 >> 40) & 0xff),
             self::intToChr(($ctx4 >> 48) & 0xff),
             self::intToChr(($ctx4 >> 56) & 0xff)
             */
-        ));
-        # uint8_t last_node;
-        return $str . self::intToChr($ctx[5]) . str_repeat("\x00", 23);
-    }
-
-    /**
-     * Creates an SplFixedArray containing other SplFixedArray elements, from
-     * a string (compatible with \Sodium\crypto_generichash_{init, update, final})
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $string
-     * @return SplFixedArray
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArrayAccess
-     * @psalm-suppress MixedArrayAssignment
-     */
-    public static function stringToContext($string)
-    {
-        $ctx = self::context();
-
-        # uint64_t h[8];
-        for ($i = 0; $i < 8; ++$i) {
-            $ctx[0][$i] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
-                self::substr($string, (($i << 3) + 0), 8)
-            );
-        }
-
-        # uint64_t t[2];
-        # uint64_t f[2];
-        for ($i = 1; $i < 3; ++$i) {
-            $ctx[$i][1] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
-                self::substr($string, 72 + (($i - 1) << 4), 8)
-            );
-            $ctx[$i][0] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
-                self::substr($string, 64 + (($i - 1) << 4), 8)
-            );
-        }
-
-        # uint8_t buf[2 * 128];
-        $ctx[3] = self::stringToSplFixedArray(self::substr($string, 96, 256));
-
-        # uint8_t buf[2 * 128];
-        $int = 0;
-        for ($i = 0; $i < 8; ++$i) {
-            $int |= self::chrToInt($string[352 + $i]) << ($i << 3);
-        }
-        $ctx[4] = $int;
-
-        return $ctx;
-    }
+		));
+		# uint8_t last_node;
+		return $str . self::intToChr($ctx[5]) . str_repeat("\x00", 23);
+	}
+
+	/**
+	 * Creates an SplFixedArray containing other SplFixedArray elements, from
+	 * a string (compatible with \Sodium\crypto_generichash_{init, update, final})
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $string
+	 * @return SplFixedArray
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArrayAccess
+	 * @psalm-suppress MixedArrayAssignment
+	 */
+	public static function stringToContext($string)
+	{
+		$ctx = self::context();
+
+		# uint64_t h[8];
+		for ($i = 0; $i < 8; ++$i) {
+			$ctx[0][$i] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
+				self::substr($string, (($i << 3) + 0), 8)
+			);
+		}
+
+		# uint64_t t[2];
+		# uint64_t f[2];
+		for ($i = 1; $i < 3; ++$i) {
+			$ctx[$i][1] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
+				self::substr($string, 72 + (($i - 1) << 4), 8)
+			);
+			$ctx[$i][0] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
+				self::substr($string, 64 + (($i - 1) << 4), 8)
+			);
+		}
+
+		# uint8_t buf[2 * 128];
+		$ctx[3] = self::stringToSplFixedArray(self::substr($string, 96, 256));
+
+		# uint8_t buf[2 * 128];
+		$int = 0;
+		for ($i = 0; $i < 8; ++$i) {
+			$int |= self::chrToInt($string[352 + $i]) << ($i << 3);
+		}
+		$ctx[4] = $int;
+
+		return $ctx;
+	}
 }

Spacing +221 added lines, -221 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_BLAKE2b', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_BLAKE2b', false ) ) {
     return;
 }
 
@@ -20,18 +20,18 @@ 
      * @var array<int, array<int, int>>
      */
     public static $sigma = array(
-        array(  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15),
-        array( 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3),
-        array( 11,  8, 12,  0,  5,  2, 15, 13, 10, 14,  3,  6,  7,  1,  9,  4),
-        array(  7,  9,  3,  1, 13, 12, 11, 14,  2,  6,  5, 10,  4,  0, 15,  8),
-        array(  9,  0,  5,  7,  2,  4, 10, 15, 14,  1, 11, 12,  6,  8,  3, 13),
-        array(  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9),
-        array( 12,  5,  1, 15, 14, 13,  4, 10,  0,  7,  6,  3,  9,  2,  8, 11),
-        array( 13, 11,  7, 14, 12,  1,  3,  9,  5,  0, 15,  4,  8,  6,  2, 10),
-        array(  6, 15, 14,  9, 11,  3,  0,  8, 12,  2, 13,  7,  1,  4, 10,  5),
-        array( 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0),
-        array(  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15),
-        array( 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3)
+        array( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ),
+        array( 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 ),
+        array( 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 ),
+        array( 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 ),
+        array( 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 ),
+        array( 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 ),
+        array( 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 ),
+        array( 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 ),
+        array( 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 ),
+        array( 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 ),
+        array( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ),
+        array( 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 )
     );
 
     const BLOCKBYTES = 128;
@@ -49,9 +49,9 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function new64($high, $low)
+    public static function new64( $high, $low )
     {
-        return ParagonIE_Sodium_Core32_Int64::fromInts($low, $high);
+        return ParagonIE_Sodium_Core32_Int64::fromInts( $low, $high );
     }
 
     /**
@@ -65,10 +65,10 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function to64($num)
+    protected static function to64( $num )
     {
-        list($hi, $lo) = self::numericTo64BitInteger($num);
-        return self::new64($hi, $lo);
+        list( $hi, $lo ) = self::numericTo64BitInteger( $num );
+        return self::new64( $hi, $lo );
     }
 
     /**
@@ -81,9 +81,9 @@ 
      * @param ParagonIE_Sodium_Core32_Int64 $y
      * @return ParagonIE_Sodium_Core32_Int64
      */
-    protected static function add64($x, $y)
+    protected static function add64( $x, $y )
     {
-        return $x->addInt64($y);
+        return $x->addInt64( $y );
     }
 
     /**
@@ -94,9 +94,9 @@ 
      * @param ParagonIE_Sodium_Core32_Int64 $z
      * @return ParagonIE_Sodium_Core32_Int64
      */
-    public static function add364($x, $y, $z)
+    public static function add364( $x, $y, $z )
     {
-        return $x->addInt64($y)->addInt64($z);
+        return $x->addInt64( $y )->addInt64( $z );
     }
 
     /**
@@ -107,9 +107,9 @@ 
      * @return ParagonIE_Sodium_Core32_Int64
      * @throws TypeError
      */
-    public static function xor64(ParagonIE_Sodium_Core32_Int64 $x, ParagonIE_Sodium_Core32_Int64 $y)
+    public static function xor64( ParagonIE_Sodium_Core32_Int64 $x, ParagonIE_Sodium_Core32_Int64 $y )
     {
-        return $x->xorInt64($y);
+        return $x->xorInt64( $y );
     }
 
     /**
@@ -121,9 +121,9 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function rotr64(ParagonIE_Sodium_Core32_Int64 $x, $c)
+    public static function rotr64( ParagonIE_Sodium_Core32_Int64 $x, $c )
     {
-        return $x->rotateRight($c);
+        return $x->rotateRight( $c );
     }
 
     /**
@@ -135,19 +135,19 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function load64($x, $i)
+    public static function load64( $x, $i )
     {
         /** @var int $l */
-        $l = (int) ($x[$i])
-             | ((int) ($x[$i+1]) << 8)
-             | ((int) ($x[$i+2]) << 16)
-             | ((int) ($x[$i+3]) << 24);
+        $l = (int)( $x[ $i ] )
+             | ( (int)( $x[ $i + 1 ] ) << 8 )
+             | ( (int)( $x[ $i + 2 ] ) << 16 )
+             | ( (int)( $x[ $i + 3 ] ) << 24 );
         /** @var int $h */
-        $h = (int) ($x[$i+4])
-             | ((int) ($x[$i+5]) << 8)
-             | ((int) ($x[$i+6]) << 16)
-             | ((int) ($x[$i+7]) << 24);
-        return self::new64($h, $l);
+        $h = (int)( $x[ $i + 4 ] )
+             | ( (int)( $x[ $i + 5 ] ) << 8 )
+             | ( (int)( $x[ $i + 6 ] ) << 16 )
+             | ( (int)( $x[ $i + 7 ] ) << 24 );
+        return self::new64( $h, $l );
     }
 
     /**
@@ -164,17 +164,17 @@ 
      * @psalm-suppress MixedArrayAssignment
      * @psalm-suppress MixedArrayOffset
      */
-    public static function store64(SplFixedArray $x, $i, ParagonIE_Sodium_Core32_Int64 $u)
+    public static function store64( SplFixedArray $x, $i, ParagonIE_Sodium_Core32_Int64 $u )
     {
         $v = clone $u;
         $maxLength = $x->getSize() - 1;
-        for ($j = 0; $j < 8; ++$j) {
-            $k = 3 - ($j >> 1);
-            $x[$i] = $v->limbs[$k] & 0xff;
+        for ( $j = 0; $j < 8; ++$j ) {
+            $k = 3 - ( $j >> 1 );
+            $x[ $i ] = $v->limbs[ $k ] & 0xff;
             if (++$i > $maxLength) {
                 return;
             }
-            $v->limbs[$k] >>= 8;
+            $v->limbs[ $k ] >>= 8;
         }
     }
 
@@ -190,18 +190,18 @@ 
     public static function pseudoConstructor()
     {
         static $called = false;
-        if ($called) {
+        if ( $called ) {
             return;
         }
-        self::$iv = new SplFixedArray(8);
-        self::$iv[0] = self::new64(0x6a09e667, 0xf3bcc908);
-        self::$iv[1] = self::new64(0xbb67ae85, 0x84caa73b);
-        self::$iv[2] = self::new64(0x3c6ef372, 0xfe94f82b);
-        self::$iv[3] = self::new64(0xa54ff53a, 0x5f1d36f1);
-        self::$iv[4] = self::new64(0x510e527f, 0xade682d1);
-        self::$iv[5] = self::new64(0x9b05688c, 0x2b3e6c1f);
-        self::$iv[6] = self::new64(0x1f83d9ab, 0xfb41bd6b);
-        self::$iv[7] = self::new64(0x5be0cd19, 0x137e2179);
+        self::$iv = new SplFixedArray( 8 );
+        self::$iv[ 0 ] = self::new64( 0x6a09e667, 0xf3bcc908 );
+        self::$iv[ 1 ] = self::new64( 0xbb67ae85, 0x84caa73b );
+        self::$iv[ 2 ] = self::new64( 0x3c6ef372, 0xfe94f82b );
+        self::$iv[ 3 ] = self::new64( 0xa54ff53a, 0x5f1d36f1 );
+        self::$iv[ 4 ] = self::new64( 0x510e527f, 0xade682d1 );
+        self::$iv[ 5 ] = self::new64( 0x9b05688c, 0x2b3e6c1f );
+        self::$iv[ 6 ] = self::new64( 0x1f83d9ab, 0xfb41bd6b );
+        self::$iv[ 7 ] = self::new64( 0x5be0cd19, 0x137e2179 );
 
         $called = true;
     }
@@ -223,26 +223,26 @@ 
      */
     protected static function context()
     {
-        $ctx    = new SplFixedArray(6);
-        $ctx[0] = new SplFixedArray(8);   // h
-        $ctx[1] = new SplFixedArray(2);   // t
-        $ctx[2] = new SplFixedArray(2);   // f
-        $ctx[3] = new SplFixedArray(256); // buf
-        $ctx[4] = 0;                      // buflen
-        $ctx[5] = 0;                      // last_node (uint8_t)
-
-        for ($i = 8; $i--;) {
-            $ctx[0][$i] = self::$iv[$i];
+        $ctx    = new SplFixedArray( 6 );
+        $ctx[ 0 ] = new SplFixedArray( 8 ); // h
+        $ctx[ 1 ] = new SplFixedArray( 2 ); // t
+        $ctx[ 2 ] = new SplFixedArray( 2 ); // f
+        $ctx[ 3 ] = new SplFixedArray( 256 ); // buf
+        $ctx[ 4 ] = 0; // buflen
+        $ctx[ 5 ] = 0; // last_node (uint8_t)
+
+        for ( $i = 8; $i--; ) {
+            $ctx[ 0 ][ $i ] = self::$iv[ $i ];
         }
-        for ($i = 256; $i--;) {
-            $ctx[3][$i] = 0;
+        for ( $i = 256; $i--; ) {
+            $ctx[ 3 ][ $i ] = 0;
         }
 
-        $zero = self::new64(0, 0);
-        $ctx[1][0] = $zero;
-        $ctx[1][1] = $zero;
-        $ctx[2][0] = $zero;
-        $ctx[2][1] = $zero;
+        $zero = self::new64( 0, 0 );
+        $ctx[ 1 ][ 0 ] = $zero;
+        $ctx[ 1 ][ 1 ] = $zero;
+        $ctx[ 2 ][ 0 ] = $zero;
+        $ctx[ 2 ][ 1 ] = $zero;
 
         return $ctx;
     }
@@ -260,43 +260,43 @@ 
      * @psalm-suppress MixedArrayAssignment
      * @psalm-suppress MixedAssignment
      */
-    protected static function compress(SplFixedArray $ctx, SplFixedArray $buf)
+    protected static function compress( SplFixedArray $ctx, SplFixedArray $buf )
     {
-        $m = new SplFixedArray(16);
-        $v = new SplFixedArray(16);
+        $m = new SplFixedArray( 16 );
+        $v = new SplFixedArray( 16 );
 
-        for ($i = 16; $i--;) {
-            $m[$i] = self::load64($buf, $i << 3);
+        for ( $i = 16; $i--; ) {
+            $m[ $i ] = self::load64( $buf, $i << 3 );
         }
 
-        for ($i = 8; $i--;) {
-            $v[$i] = $ctx[0][$i];
+        for ( $i = 8; $i--; ) {
+            $v[ $i ] = $ctx[ 0 ][ $i ];
         }
 
-        $v[ 8] = self::$iv[0];
-        $v[ 9] = self::$iv[1];
-        $v[10] = self::$iv[2];
-        $v[11] = self::$iv[3];
-
-        $v[12] = self::xor64($ctx[1][0], self::$iv[4]);
-        $v[13] = self::xor64($ctx[1][1], self::$iv[5]);
-        $v[14] = self::xor64($ctx[2][0], self::$iv[6]);
-        $v[15] = self::xor64($ctx[2][1], self::$iv[7]);
-
-        for ($r = 0; $r < 12; ++$r) {
-            $v = self::G($r, 0, 0, 4, 8, 12, $v, $m);
-            $v = self::G($r, 1, 1, 5, 9, 13, $v, $m);
-            $v = self::G($r, 2, 2, 6, 10, 14, $v, $m);
-            $v = self::G($r, 3, 3, 7, 11, 15, $v, $m);
-            $v = self::G($r, 4, 0, 5, 10, 15, $v, $m);
-            $v = self::G($r, 5, 1, 6, 11, 12, $v, $m);
-            $v = self::G($r, 6, 2, 7, 8, 13, $v, $m);
-            $v = self::G($r, 7, 3, 4, 9, 14, $v, $m);
+        $v[ 8 ] = self::$iv[ 0 ];
+        $v[ 9 ] = self::$iv[ 1 ];
+        $v[ 10 ] = self::$iv[ 2 ];
+        $v[ 11 ] = self::$iv[ 3 ];
+
+        $v[ 12 ] = self::xor64( $ctx[ 1 ][ 0 ], self::$iv[ 4 ] );
+        $v[ 13 ] = self::xor64( $ctx[ 1 ][ 1 ], self::$iv[ 5 ] );
+        $v[ 14 ] = self::xor64( $ctx[ 2 ][ 0 ], self::$iv[ 6 ] );
+        $v[ 15 ] = self::xor64( $ctx[ 2 ][ 1 ], self::$iv[ 7 ] );
+
+        for ( $r = 0; $r < 12; ++$r ) {
+            $v = self::G( $r, 0, 0, 4, 8, 12, $v, $m );
+            $v = self::G( $r, 1, 1, 5, 9, 13, $v, $m );
+            $v = self::G( $r, 2, 2, 6, 10, 14, $v, $m );
+            $v = self::G( $r, 3, 3, 7, 11, 15, $v, $m );
+            $v = self::G( $r, 4, 0, 5, 10, 15, $v, $m );
+            $v = self::G( $r, 5, 1, 6, 11, 12, $v, $m );
+            $v = self::G( $r, 6, 2, 7, 8, 13, $v, $m );
+            $v = self::G( $r, 7, 3, 4, 9, 14, $v, $m );
         }
 
-        for ($i = 8; $i--;) {
-            $ctx[0][$i] = self::xor64(
-                $ctx[0][$i], self::xor64($v[$i], $v[$i+8])
+        for ( $i = 8; $i--; ) {
+            $ctx[ 0 ][ $i ] = self::xor64(
+                $ctx[ 0 ][ $i ], self::xor64( $v[ $i ], $v[ $i + 8 ] )
             );
         }
     }
@@ -318,16 +318,16 @@ 
      * @psalm-suppress MixedArgument
      * @psalm-suppress MixedArrayOffset
      */
-    public static function G($r, $i, $a, $b, $c, $d, SplFixedArray $v, SplFixedArray $m)
+    public static function G( $r, $i, $a, $b, $c, $d, SplFixedArray $v, SplFixedArray $m )
     {
-        $v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][$i << 1]]);
-        $v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 32);
-        $v[$c] = self::add64($v[$c], $v[$d]);
-        $v[$b] = self::rotr64(self::xor64($v[$b], $v[$c]), 24);
-        $v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][($i << 1) + 1]]);
-        $v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 16);
-        $v[$c] = self::add64($v[$c], $v[$d]);
-        $v[$b] = self::rotr64(self::xor64($v[$b], $v[$c]), 63);
+        $v[ $a ] = self::add364( $v[ $a ], $v[ $b ], $m[ self::$sigma[ $r ][ $i << 1 ] ] );
+        $v[ $d ] = self::rotr64( self::xor64( $v[ $d ], $v[ $a ] ), 32 );
+        $v[ $c ] = self::add64( $v[ $c ], $v[ $d ] );
+        $v[ $b ] = self::rotr64( self::xor64( $v[ $b ], $v[ $c ] ), 24 );
+        $v[ $a ] = self::add364( $v[ $a ], $v[ $b ], $m[ self::$sigma[ $r ][ ( $i << 1 ) + 1 ] ] );
+        $v[ $d ] = self::rotr64( self::xor64( $v[ $d ], $v[ $a ] ), 16 );
+        $v[ $c ] = self::add64( $v[ $c ], $v[ $d ] );
+        $v[ $b ] = self::rotr64( self::xor64( $v[ $b ], $v[ $c ] ), 63 );
         return $v;
     }
 
@@ -343,25 +343,25 @@ 
      * @psalm-suppress MixedArrayAccess
      * @psalm-suppress MixedArrayAssignment
      */
-    public static function increment_counter($ctx, $inc)
+    public static function increment_counter( $ctx, $inc )
     {
-        if ($inc < 0) {
-            throw new SodiumException('Increasing by a negative number makes no sense.');
+        if ( $inc < 0 ) {
+            throw new SodiumException( 'Increasing by a negative number makes no sense.' );
         }
-        $t = self::to64($inc);
+        $t = self::to64( $inc );
         # S->t is $ctx[1] in our implementation
 
         # S->t[0] = ( uint64_t )( t >> 0 );
-        $ctx[1][0] = self::add64($ctx[1][0], $t);
+        $ctx[ 1 ][ 0 ] = self::add64( $ctx[ 1 ][ 0 ], $t );
 
         # S->t[1] += ( S->t[0] < inc );
-        if (!($ctx[1][0] instanceof ParagonIE_Sodium_Core32_Int64)) {
-            throw new TypeError('Not an int64');
+        if ( ! ( $ctx[ 1 ][ 0 ] instanceof ParagonIE_Sodium_Core32_Int64 ) ) {
+            throw new TypeError( 'Not an int64' );
         }
         /** @var ParagonIE_Sodium_Core32_Int64 $c*/
-        $c = $ctx[1][0];
-        if ($c->isLessThanInt($inc)) {
-            $ctx[1][1] = self::add64($ctx[1][1], self::to64(1));
+        $c = $ctx[ 1 ][ 0 ];
+        if ( $c->isLessThanInt( $inc ) ) {
+            $ctx[ 1 ][ 1 ] = self::add64( $ctx[ 1 ][ 1 ], self::to64( 1 ) );
         }
     }
 
@@ -382,37 +382,37 @@ 
      * @psalm-suppress MixedMethodCall
      * @psalm-suppress MixedOperand
      */
-    public static function update(SplFixedArray $ctx, SplFixedArray $p, $plen)
+    public static function update( SplFixedArray $ctx, SplFixedArray $p, $plen )
     {
         self::pseudoConstructor();
 
         $offset = 0;
-        while ($plen > 0) {
-            $left = $ctx[4];
+        while ( $plen > 0 ) {
+            $left = $ctx[ 4 ];
             $fill = 256 - $left;
 
-            if ($plen > $fill) {
+            if ( $plen > $fill ) {
                 # memcpy( S->buf + left, in, fill ); /* Fill buffer */
-                for ($i = $fill; $i--;) {
-                    $ctx[3][$i + $left] = $p[$i + $offset];
+                for ( $i = $fill; $i--; ) {
+                    $ctx[ 3 ][ $i + $left ] = $p[ $i + $offset ];
                 }
 
                 # S->buflen += fill;
-                $ctx[4] += $fill;
+                $ctx[ 4 ] += $fill;
 
                 # blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
-                self::increment_counter($ctx, 128);
+                self::increment_counter( $ctx, 128 );
 
                 # blake2b_compress( S, S->buf ); /* Compress */
-                self::compress($ctx, $ctx[3]);
+                self::compress( $ctx, $ctx[ 3 ] );
 
                 # memcpy( S->buf, S->buf + BLAKE2B_BLOCKBYTES, BLAKE2B_BLOCKBYTES ); /* Shift buffer left */
-                for ($i = 128; $i--;) {
-                    $ctx[3][$i] = $ctx[3][$i + 128];
+                for ( $i = 128; $i--; ) {
+                    $ctx[ 3 ][ $i ] = $ctx[ 3 ][ $i + 128 ];
                 }
 
                 # S->buflen -= BLAKE2B_BLOCKBYTES;
-                $ctx[4] -= 128;
+                $ctx[ 4 ] -= 128;
 
                 # in += fill;
                 $offset += $fill;
@@ -420,10 +420,10 @@ 
                 # inlen -= fill;
                 $plen -= $fill;
             } else {
-                for ($i = $plen; $i--;) {
-                    $ctx[3][$i + $left] = $p[$i + $offset];
+                for ( $i = $plen; $i--; ) {
+                    $ctx[ 3 ][ $i + $left ] = $p[ $i + $offset ];
                 }
-                $ctx[4] += $plen;
+                $ctx[ 4 ] += $plen;
                 $offset += $plen;
                 $plen -= $plen;
             }
@@ -446,34 +446,34 @@ 
      * @psalm-suppress MixedMethodCall
      * @psalm-suppress MixedOperand
      */
-    public static function finish(SplFixedArray $ctx, SplFixedArray $out)
+    public static function finish( SplFixedArray $ctx, SplFixedArray $out )
     {
         self::pseudoConstructor();
-        if ($ctx[4] > 128) {
-            self::increment_counter($ctx, 128);
-            self::compress($ctx, $ctx[3]);
-            $ctx[4] -= 128;
-            if ($ctx[4] > 128) {
-                throw new SodiumException('Failed to assert that buflen <= 128 bytes');
+        if ( $ctx[ 4 ] > 128 ) {
+            self::increment_counter( $ctx, 128 );
+            self::compress( $ctx, $ctx[ 3 ] );
+            $ctx[ 4 ] -= 128;
+            if ( $ctx[ 4 ] > 128 ) {
+                throw new SodiumException( 'Failed to assert that buflen <= 128 bytes' );
             }
-            for ($i = $ctx[4]; $i--;) {
-                $ctx[3][$i] = $ctx[3][$i + 128];
+            for ( $i = $ctx[ 4 ]; $i--; ) {
+                $ctx[ 3 ][ $i ] = $ctx[ 3 ][ $i + 128 ];
             }
         }
 
-        self::increment_counter($ctx, $ctx[4]);
-        $ctx[2][0] = self::new64(0xffffffff, 0xffffffff);
+        self::increment_counter( $ctx, $ctx[ 4 ] );
+        $ctx[ 2 ][ 0 ] = self::new64( 0xffffffff, 0xffffffff );
 
-        for ($i = 256 - $ctx[4]; $i--;) {
+        for ( $i = 256 - $ctx[ 4 ]; $i--; ) {
             /** @var int $i */
-            $ctx[3][$i + $ctx[4]] = 0;
+            $ctx[ 3 ][ $i + $ctx[ 4 ] ] = 0;
         }
 
-        self::compress($ctx, $ctx[3]);
+        self::compress( $ctx, $ctx[ 3 ] );
 
-        $i = (int) (($out->getSize() - 1) / 8);
-        for (; $i >= 0; --$i) {
-            self::store64($out, $i << 3, $ctx[0][$i]);
+        $i = (int)( ( $out->getSize() - 1 ) / 8 );
+        for ( ; $i >= 0; --$i ) {
+            self::store64( $out, $i << 3, $ctx[ 0 ][ $i ] );
         }
         return $out;
     }
@@ -503,68 +503,68 @@ 
         self::pseudoConstructor();
         $klen = 0;
 
-        if ($key !== null) {
-            if (count($key) > 64) {
-                throw new SodiumException('Invalid key size');
+        if ( $key !== null ) {
+            if ( count( $key ) > 64 ) {
+                throw new SodiumException( 'Invalid key size' );
             }
-            $klen = count($key);
+            $klen = count( $key );
         }
 
-        if ($outlen > 64) {
-            throw new SodiumException('Invalid output size');
+        if ( $outlen > 64 ) {
+            throw new SodiumException( 'Invalid output size' );
         }
 
         $ctx = self::context();
 
-        $p = new SplFixedArray(64);
+        $p = new SplFixedArray( 64 );
         // Zero our param buffer...
-        for ($i = 64; --$i;) {
-            $p[$i] = 0;
+        for ( $i = 64; --$i; ) {
+            $p[ $i ] = 0;
         }
 
-        $p[0] = $outlen; // digest_length
-        $p[1] = $klen;   // key_length
-        $p[2] = 1;       // fanout
-        $p[3] = 1;       // depth
+        $p[ 0 ] = $outlen; // digest_length
+        $p[ 1 ] = $klen; // key_length
+        $p[ 2 ] = 1; // fanout
+        $p[ 3 ] = 1; // depth
 
-        if ($salt instanceof SplFixedArray) {
+        if ( $salt instanceof SplFixedArray ) {
             // salt: [32] through [47]
-            for ($i = 0; $i < 16; ++$i) {
-                $p[32 + $i] = (int) $salt[$i];
+            for ( $i = 0; $i < 16; ++$i ) {
+                $p[ 32 + $i ] = (int)$salt[ $i ];
             }
         }
-        if ($personal instanceof SplFixedArray) {
+        if ( $personal instanceof SplFixedArray ) {
             // personal: [48] through [63]
-            for ($i = 0; $i < 16; ++$i) {
-                $p[48 + $i] = (int) $personal[$i];
+            for ( $i = 0; $i < 16; ++$i ) {
+                $p[ 48 + $i ] = (int)$personal[ $i ];
             }
         }
 
-        $ctx[0][0] = self::xor64(
-            $ctx[0][0],
-            self::load64($p, 0)
+        $ctx[ 0 ][ 0 ] = self::xor64(
+            $ctx[ 0 ][ 0 ],
+            self::load64( $p, 0 )
         );
 
-        if ($salt instanceof SplFixedArray || $personal instanceof SplFixedArray) {
+        if ( $salt instanceof SplFixedArray || $personal instanceof SplFixedArray ) {
             // We need to do what blake2b_init_param() does:
-            for ($i = 1; $i < 8; ++$i) {
-                $ctx[0][$i] = self::xor64(
-                    $ctx[0][$i],
-                    self::load64($p, $i << 3)
+            for ( $i = 1; $i < 8; ++$i ) {
+                $ctx[ 0 ][ $i ] = self::xor64(
+                    $ctx[ 0 ][ $i ],
+                    self::load64( $p, $i << 3 )
                 );
             }
         }
 
-        if ($klen > 0 && $key instanceof SplFixedArray) {
-            $block = new SplFixedArray(128);
-            for ($i = 128; $i--;) {
-                $block[$i] = 0;
+        if ( $klen > 0 && $key instanceof SplFixedArray ) {
+            $block = new SplFixedArray( 128 );
+            for ( $i = 128; $i--; ) {
+                $block[ $i ] = 0;
             }
-            for ($i = $klen; $i--;) {
-                $block[$i] = $key[$i];
+            for ( $i = $klen; $i--; ) {
+                $block[ $i ] = $key[ $i ];
             }
-            self::update($ctx, $block, 128);
-            $ctx[4] = 128;
+            self::update( $ctx, $block, 128 );
+            $ctx[ 4 ] = 128;
         }
 
         return $ctx;
@@ -579,10 +579,10 @@ 
      * @return SplFixedArray
      * @psalm-suppress MixedArgumentTypeCoercion
      */
-    public static function stringToSplFixedArray($str = '')
+    public static function stringToSplFixedArray( $str = '' )
     {
-        $values = unpack('C*', $str);
-        return SplFixedArray::fromArray(array_values($values));
+        $values = unpack( 'C*', $str );
+        return SplFixedArray::fromArray( array_values( $values ) );
     }
 
     /**
@@ -593,15 +593,15 @@ 
      * @param SplFixedArray $a
      * @return string
      */
-    public static function SplFixedArrayToString(SplFixedArray $a)
+    public static function SplFixedArrayToString( SplFixedArray $a )
     {
         /**
          * @var array<int, string|int>
          */
         $arr = $a->toArray();
         $c = $a->count();
-        array_unshift($arr, str_repeat('C', $c));
-        return (string) (call_user_func_array('pack', $arr));
+        array_unshift( $arr, str_repeat( 'C', $c ) );
+        return (string)( call_user_func_array( 'pack', $arr ) );
     }
 
     /**
@@ -615,48 +615,48 @@ 
      * @psalm-suppress MixedArrayAssignment
      * @psalm-suppress MixedMethodCall
      */
-    public static function contextToString(SplFixedArray $ctx)
+    public static function contextToString( SplFixedArray $ctx )
     {
         $str = '';
         /** @var array<int, ParagonIE_Sodium_Core32_Int64> $ctxA */
-        $ctxA = $ctx[0]->toArray();
+        $ctxA = $ctx[ 0 ]->toArray();
 
         # uint64_t h[8];
-        for ($i = 0; $i < 8; ++$i) {
-            if (!($ctxA[$i] instanceof ParagonIE_Sodium_Core32_Int64)) {
-                throw new TypeError('Not an instance of Int64');
+        for ( $i = 0; $i < 8; ++$i ) {
+            if ( ! ( $ctxA[ $i ] instanceof ParagonIE_Sodium_Core32_Int64 ) ) {
+                throw new TypeError( 'Not an instance of Int64' );
             }
             /** @var ParagonIE_Sodium_Core32_Int64 $ctxAi */
-            $ctxAi = $ctxA[$i];
+            $ctxAi = $ctxA[ $i ];
             $str .= $ctxAi->toReverseString();
         }
 
         # uint64_t t[2];
         # uint64_t f[2];
-        for ($i = 1; $i < 3; ++$i) {
+        for ( $i = 1; $i < 3; ++$i ) {
             /** @var array<int, ParagonIE_Sodium_Core32_Int64> $ctxA */
-            $ctxA = $ctx[$i]->toArray();
+            $ctxA = $ctx[ $i ]->toArray();
             /** @var ParagonIE_Sodium_Core32_Int64 $ctxA1 */
-            $ctxA1 = $ctxA[0];
+            $ctxA1 = $ctxA[ 0 ];
             /** @var ParagonIE_Sodium_Core32_Int64 $ctxA2 */
-            $ctxA2 = $ctxA[1];
+            $ctxA2 = $ctxA[ 1 ];
 
             $str .= $ctxA1->toReverseString();
             $str .= $ctxA2->toReverseString();
         }
 
         # uint8_t buf[2 * 128];
-        $str .= self::SplFixedArrayToString($ctx[3]);
+        $str .= self::SplFixedArrayToString( $ctx[ 3 ] );
 
         /** @var int $ctx4 */
-        $ctx4 = $ctx[4];
+        $ctx4 = $ctx[ 4 ];
 
         # size_t buflen;
-        $str .= implode('', array(
-            self::intToChr($ctx4 & 0xff),
-            self::intToChr(($ctx4 >> 8) & 0xff),
-            self::intToChr(($ctx4 >> 16) & 0xff),
-            self::intToChr(($ctx4 >> 24) & 0xff),
+        $str .= implode( '', array(
+            self::intToChr( $ctx4 & 0xff ),
+            self::intToChr( ( $ctx4 >> 8 ) & 0xff ),
+            self::intToChr( ( $ctx4 >> 16 ) & 0xff ),
+            self::intToChr( ( $ctx4 >> 24 ) & 0xff ),
             "\x00\x00\x00\x00"
             /*
             self::intToChr(($ctx4 >> 32) & 0xff),
@@ -664,9 +664,9 @@ 
             self::intToChr(($ctx4 >> 48) & 0xff),
             self::intToChr(($ctx4 >> 56) & 0xff)
             */
-        ));
+        ) );
         # uint8_t last_node;
-        return $str . self::intToChr($ctx[5]) . str_repeat("\x00", 23);
+        return $str . self::intToChr( $ctx[ 5 ] ) . str_repeat( "\x00", 23 );
     }
 
     /**
@@ -682,37 +682,37 @@ 
      * @psalm-suppress MixedArrayAccess
      * @psalm-suppress MixedArrayAssignment
      */
-    public static function stringToContext($string)
+    public static function stringToContext( $string )
     {
         $ctx = self::context();
 
         # uint64_t h[8];
-        for ($i = 0; $i < 8; ++$i) {
-            $ctx[0][$i] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
-                self::substr($string, (($i << 3) + 0), 8)
+        for ( $i = 0; $i < 8; ++$i ) {
+            $ctx[ 0 ][ $i ] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
+                self::substr( $string, ( ( $i << 3 ) + 0 ), 8 )
             );
         }
 
         # uint64_t t[2];
         # uint64_t f[2];
-        for ($i = 1; $i < 3; ++$i) {
-            $ctx[$i][1] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
-                self::substr($string, 72 + (($i - 1) << 4), 8)
+        for ( $i = 1; $i < 3; ++$i ) {
+            $ctx[ $i ][ 1 ] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
+                self::substr( $string, 72 + ( ( $i - 1 ) << 4 ), 8 )
             );
-            $ctx[$i][0] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
-                self::substr($string, 64 + (($i - 1) << 4), 8)
+            $ctx[ $i ][ 0 ] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
+                self::substr( $string, 64 + ( ( $i - 1 ) << 4 ), 8 )
             );
         }
 
         # uint8_t buf[2 * 128];
-        $ctx[3] = self::stringToSplFixedArray(self::substr($string, 96, 256));
+        $ctx[ 3 ] = self::stringToSplFixedArray( self::substr( $string, 96, 256 ) );
 
         # uint8_t buf[2 * 128];
         $int = 0;
-        for ($i = 0; $i < 8; ++$i) {
-            $int |= self::chrToInt($string[352 + $i]) << ($i << 3);
+        for ( $i = 0; $i < 8; ++$i ) {
+            $int |= self::chrToInt( $string[ 352 + $i ] ) << ( $i << 3 );
         }
-        $ctx[4] = $int;
+        $ctx[ 4 ] = $int;
 
         return $ctx;
     }

Braces +20 added lines, -40 removed lines

@@ -9,8 +9,7 @@ 
  *
  * Based on the work of Devi Mandiri in devi/salt.
  */
-abstract class ParagonIE_Sodium_Core32_BLAKE2b extends ParagonIE_Sodium_Core_Util
-{
+abstract class ParagonIE_Sodium_Core32_BLAKE2b extends ParagonIE_Sodium_Core_Util {
     /**
      * @var SplFixedArray
      */
@@ -49,8 +48,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function new64($high, $low)
-    {
+    public static function new64($high, $low) {
         return ParagonIE_Sodium_Core32_Int64::fromInts($low, $high);
     }
 
@@ -65,8 +63,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function to64($num)
-    {
+    protected static function to64($num) {
         list($hi, $lo) = self::numericTo64BitInteger($num);
         return self::new64($hi, $lo);
     }
@@ -81,8 +78,7 @@ 
      * @param ParagonIE_Sodium_Core32_Int64 $y
      * @return ParagonIE_Sodium_Core32_Int64
      */
-    protected static function add64($x, $y)
-    {
+    protected static function add64($x, $y) {
         return $x->addInt64($y);
     }
 
@@ -94,8 +90,7 @@ 
      * @param ParagonIE_Sodium_Core32_Int64 $z
      * @return ParagonIE_Sodium_Core32_Int64
      */
-    public static function add364($x, $y, $z)
-    {
+    public static function add364($x, $y, $z) {
         return $x->addInt64($y)->addInt64($z);
     }
 
@@ -107,8 +102,7 @@ 
      * @return ParagonIE_Sodium_Core32_Int64
      * @throws TypeError
      */
-    public static function xor64(ParagonIE_Sodium_Core32_Int64 $x, ParagonIE_Sodium_Core32_Int64 $y)
-    {
+    public static function xor64(ParagonIE_Sodium_Core32_Int64 $x, ParagonIE_Sodium_Core32_Int64 $y) {
         return $x->xorInt64($y);
     }
 
@@ -121,8 +115,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function rotr64(ParagonIE_Sodium_Core32_Int64 $x, $c)
-    {
+    public static function rotr64(ParagonIE_Sodium_Core32_Int64 $x, $c) {
         return $x->rotateRight($c);
     }
 
@@ -135,8 +128,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function load64($x, $i)
-    {
+    public static function load64($x, $i) {
         /** @var int $l */
         $l = (int) ($x[$i])
              | ((int) ($x[$i+1]) << 8)
@@ -164,8 +156,7 @@ 
      * @psalm-suppress MixedArrayAssignment
      * @psalm-suppress MixedArrayOffset
      */
-    public static function store64(SplFixedArray $x, $i, ParagonIE_Sodium_Core32_Int64 $u)
-    {
+    public static function store64(SplFixedArray $x, $i, ParagonIE_Sodium_Core32_Int64 $u) {
         $v = clone $u;
         $maxLength = $x->getSize() - 1;
         for ($j = 0; $j < 8; ++$j) {
@@ -187,8 +178,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function pseudoConstructor()
-    {
+    public static function pseudoConstructor() {
         static $called = false;
         if ($called) {
             return;
@@ -221,8 +211,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function context()
-    {
+    protected static function context() {
         $ctx    = new SplFixedArray(6);
         $ctx[0] = new SplFixedArray(8);   // h
         $ctx[1] = new SplFixedArray(2);   // t
@@ -260,8 +249,7 @@ 
      * @psalm-suppress MixedArrayAssignment
      * @psalm-suppress MixedAssignment
      */
-    protected static function compress(SplFixedArray $ctx, SplFixedArray $buf)
-    {
+    protected static function compress(SplFixedArray $ctx, SplFixedArray $buf) {
         $m = new SplFixedArray(16);
         $v = new SplFixedArray(16);
 
@@ -318,8 +306,7 @@ 
      * @psalm-suppress MixedArgument
      * @psalm-suppress MixedArrayOffset
      */
-    public static function G($r, $i, $a, $b, $c, $d, SplFixedArray $v, SplFixedArray $m)
-    {
+    public static function G($r, $i, $a, $b, $c, $d, SplFixedArray $v, SplFixedArray $m) {
         $v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][$i << 1]]);
         $v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 32);
         $v[$c] = self::add64($v[$c], $v[$d]);
@@ -343,8 +330,7 @@ 
      * @psalm-suppress MixedArrayAccess
      * @psalm-suppress MixedArrayAssignment
      */
-    public static function increment_counter($ctx, $inc)
-    {
+    public static function increment_counter($ctx, $inc) {
         if ($inc < 0) {
             throw new SodiumException('Increasing by a negative number makes no sense.');
         }
@@ -382,8 +368,7 @@ 
      * @psalm-suppress MixedMethodCall
      * @psalm-suppress MixedOperand
      */
-    public static function update(SplFixedArray $ctx, SplFixedArray $p, $plen)
-    {
+    public static function update(SplFixedArray $ctx, SplFixedArray $p, $plen) {
         self::pseudoConstructor();
 
         $offset = 0;
@@ -446,8 +431,7 @@ 
      * @psalm-suppress MixedMethodCall
      * @psalm-suppress MixedOperand
      */
-    public static function finish(SplFixedArray $ctx, SplFixedArray $out)
-    {
+    public static function finish(SplFixedArray $ctx, SplFixedArray $out) {
         self::pseudoConstructor();
         if ($ctx[4] > 128) {
             self::increment_counter($ctx, 128);
@@ -579,8 +563,7 @@ 
      * @return SplFixedArray
      * @psalm-suppress MixedArgumentTypeCoercion
      */
-    public static function stringToSplFixedArray($str = '')
-    {
+    public static function stringToSplFixedArray($str = '') {
         $values = unpack('C*', $str);
         return SplFixedArray::fromArray(array_values($values));
     }
@@ -593,8 +576,7 @@ 
      * @param SplFixedArray $a
      * @return string
      */
-    public static function SplFixedArrayToString(SplFixedArray $a)
-    {
+    public static function SplFixedArrayToString(SplFixedArray $a) {
         /**
          * @var array<int, string|int>
          */
@@ -615,8 +597,7 @@ 
      * @psalm-suppress MixedArrayAssignment
      * @psalm-suppress MixedMethodCall
      */
-    public static function contextToString(SplFixedArray $ctx)
-    {
+    public static function contextToString(SplFixedArray $ctx) {
         $str = '';
         /** @var array<int, ParagonIE_Sodium_Core32_Int64> $ctxA */
         $ctxA = $ctx[0]->toArray();
@@ -682,8 +663,7 @@ 
      * @psalm-suppress MixedArrayAccess
      * @psalm-suppress MixedArrayAssignment
      */
-    public static function stringToContext($string)
-    {
+    public static function stringToContext($string) {
         $ctx = self::context();
 
         # uint64_t h[8];

vendor/paragonie/sodium_compat/src/Core32/Ed25519.php

Indentation +471 added lines, -471 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core32_Ed25519', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,474 +9,474 @@ 
  */
 abstract class ParagonIE_Sodium_Core32_Ed25519 extends ParagonIE_Sodium_Core32_Curve25519
 {
-    const KEYPAIR_BYTES = 96;
-    const SEED_BYTES = 32;
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @return string (96 bytes)
-     * @throws Exception
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function keypair()
-    {
-        $seed = random_bytes(self::SEED_BYTES);
-        $pk = '';
-        $sk = '';
-        self::seed_keypair($pk, $sk, $seed);
-        return $sk . $pk;
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $pk
-     * @param string $sk
-     * @param string $seed
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function seed_keypair(&$pk, &$sk, $seed)
-    {
-        if (self::strlen($seed) !== self::SEED_BYTES) {
-            throw new RangeException('crypto_sign keypair seed must be 32 bytes long');
-        }
-
-        /** @var string $pk */
-        $pk = self::publickey_from_secretkey($seed);
-        $sk = $seed . $pk;
-        return $sk;
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $keypair
-     * @return string
-     * @throws TypeError
-     */
-    public static function secretkey($keypair)
-    {
-        if (self::strlen($keypair) !== self::KEYPAIR_BYTES) {
-            throw new RangeException('crypto_sign keypair must be 96 bytes long');
-        }
-        return self::substr($keypair, 0, 64);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $keypair
-     * @return string
-     * @throws RangeException
-     * @throws TypeError
-     */
-    public static function publickey($keypair)
-    {
-        if (self::strlen($keypair) !== self::KEYPAIR_BYTES) {
-            throw new RangeException('crypto_sign keypair must be 96 bytes long');
-        }
-        return self::substr($keypair, 64, 32);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $sk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function publickey_from_secretkey($sk)
-    {
-        /** @var string $sk */
-        $sk = hash('sha512', self::substr($sk, 0, 32), true);
-        $sk[0] = self::intToChr(
-            self::chrToInt($sk[0]) & 248
-        );
-        $sk[31] = self::intToChr(
-            (self::chrToInt($sk[31]) & 63) | 64
-        );
-        return self::sk_to_pk($sk);
-    }
-
-    /**
-     * @param string $pk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function pk_to_curve25519($pk)
-    {
-        if (self::small_order($pk)) {
-            throw new SodiumException('Public key is on a small order');
-        }
-        $A = self::ge_frombytes_negate_vartime($pk);
-        $p1 = self::ge_mul_l($A);
-        if (!self::fe_isnonzero($p1->X)) {
-            throw new SodiumException('Unexpected zero result');
-        }
-
-        # fe_1(one_minus_y);
-        # fe_sub(one_minus_y, one_minus_y, A.Y);
-        # fe_invert(one_minus_y, one_minus_y);
-        $one_minux_y = self::fe_invert(
-            self::fe_sub(
-                self::fe_1(),
-                $A->Y
-            )
-        );
-
-
-        # fe_1(x);
-        # fe_add(x, x, A.Y);
-        # fe_mul(x, x, one_minus_y);
-        $x = self::fe_mul(
-            self::fe_add(self::fe_1(), $A->Y),
-            $one_minux_y
-        );
-
-        # fe_tobytes(curve25519_pk, x);
-        return self::fe_tobytes($x);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $sk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function sk_to_pk($sk)
-    {
-        return self::ge_p3_tobytes(
-            self::ge_scalarmult_base(
-                self::substr($sk, 0, 32)
-            )
-        );
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $message
-     * @param string $sk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function sign($message, $sk)
-    {
-        /** @var string $signature */
-        $signature = self::sign_detached($message, $sk);
-        return $signature . $message;
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $message A signed message
-     * @param string $pk      Public key
-     * @return string         Message (without signature)
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function sign_open($message, $pk)
-    {
-        /** @var string $signature */
-        $signature = self::substr($message, 0, 64);
-
-        /** @var string $message */
-        $message = self::substr($message, 64);
-
-        if (self::verify_detached($signature, $message, $pk)) {
-            return $message;
-        }
-        throw new SodiumException('Invalid signature');
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $message
-     * @param string $sk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress PossiblyInvalidArgument
-     */
-    public static function sign_detached($message, $sk)
-    {
-        # crypto_hash_sha512(az, sk, 32);
-        $az =  hash('sha512', self::substr($sk, 0, 32), true);
-
-        # az[0] &= 248;
-        # az[31] &= 63;
-        # az[31] |= 64;
-        $az[0] = self::intToChr(self::chrToInt($az[0]) & 248);
-        $az[31] = self::intToChr((self::chrToInt($az[31]) & 63) | 64);
-
-        # crypto_hash_sha512_init(&hs);
-        # crypto_hash_sha512_update(&hs, az + 32, 32);
-        # crypto_hash_sha512_update(&hs, m, mlen);
-        # crypto_hash_sha512_final(&hs, nonce);
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($az, 32, 32));
-        self::hash_update($hs, $message);
-        $nonceHash = hash_final($hs, true);
-
-        # memmove(sig + 32, sk + 32, 32);
-        $pk = self::substr($sk, 32, 32);
-
-        # sc_reduce(nonce);
-        # ge_scalarmult_base(&R, nonce);
-        # ge_p3_tobytes(sig, &R);
-        $nonce = self::sc_reduce($nonceHash) . self::substr($nonceHash, 32);
-        $sig = self::ge_p3_tobytes(
-            self::ge_scalarmult_base($nonce)
-        );
-
-        # crypto_hash_sha512_init(&hs);
-        # crypto_hash_sha512_update(&hs, sig, 64);
-        # crypto_hash_sha512_update(&hs, m, mlen);
-        # crypto_hash_sha512_final(&hs, hram);
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($sig, 0, 32));
-        self::hash_update($hs, self::substr($pk, 0, 32));
-        self::hash_update($hs, $message);
-        $hramHash = hash_final($hs, true);
-
-        # sc_reduce(hram);
-        # sc_muladd(sig + 32, hram, az, nonce);
-        $hram = self::sc_reduce($hramHash);
-        $sigAfter = self::sc_muladd($hram, $az, $nonce);
-        $sig = self::substr($sig, 0, 32) . self::substr($sigAfter, 0, 32);
-
-        try {
-            ParagonIE_Sodium_Compat::memzero($az);
-        } catch (SodiumException $ex) {
-            $az = null;
-        }
-        return $sig;
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $sig
-     * @param string $message
-     * @param string $pk
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function verify_detached($sig, $message, $pk)
-    {
-        if (self::strlen($sig) < 64) {
-            throw new SodiumException('Signature is too short');
-        }
-        if ((self::chrToInt($sig[63]) & 240) && self::check_S_lt_L(self::substr($sig, 32, 32))) {
-            throw new SodiumException('S < L - Invalid signature');
-        }
-        if (self::small_order($sig)) {
-            throw new SodiumException('Signature is on too small of an order');
-        }
-        if ((self::chrToInt($sig[63]) & 224) !== 0) {
-            throw new SodiumException('Invalid signature');
-        }
-        $d = 0;
-        for ($i = 0; $i < 32; ++$i) {
-            $d |= self::chrToInt($pk[$i]);
-        }
-        if ($d === 0) {
-            throw new SodiumException('All zero public key');
-        }
-
-        /** @var bool The original value of ParagonIE_Sodium_Compat::$fastMult */
-        $orig = ParagonIE_Sodium_Compat::$fastMult;
-
-        // Set ParagonIE_Sodium_Compat::$fastMult to true to speed up verification.
-        ParagonIE_Sodium_Compat::$fastMult = true;
-
-        /** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P3 $A */
-        $A = self::ge_frombytes_negate_vartime($pk);
-
-        /** @var string $hDigest */
-        $hDigest = hash(
-            'sha512',
-            self::substr($sig, 0, 32) .
-            self::substr($pk, 0, 32) .
-            $message,
-            true
-        );
-
-        /** @var string $h */
-        $h = self::sc_reduce($hDigest) . self::substr($hDigest, 32);
-
-        /** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P2 $R */
-        $R = self::ge_double_scalarmult_vartime(
-            $h,
-            $A,
-            self::substr($sig, 32)
-        );
-
-        /** @var string $rcheck */
-        $rcheck = self::ge_tobytes($R);
-
-        // Reset ParagonIE_Sodium_Compat::$fastMult to what it was before.
-        ParagonIE_Sodium_Compat::$fastMult = $orig;
-
-        return self::verify_32($rcheck, self::substr($sig, 0, 32));
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $S
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function check_S_lt_L($S)
-    {
-        if (self::strlen($S) < 32) {
-            throw new SodiumException('Signature must be 32 bytes');
-        }
-        static $L = array(
-            0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58,
-            0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10
-        );
-        /** @var array<int, int> $L */
-        $c = 0;
-        $n = 1;
-        $i = 32;
-
-        do {
-            --$i;
-            $x = self::chrToInt($S[$i]);
-            $c |= (
-                (($x - $L[$i]) >> 8) & $n
-            );
-            $n &= (
-                (($x ^ $L[$i]) - 1) >> 8
-            );
-        } while ($i !== 0);
-
-        return $c === 0;
-    }
-
-    /**
-     * @param string $R
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function small_order($R)
-    {
-        static $blocklist = array(
-            /* 0 (order 4) */
-            array(
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-            ),
-            /* 1 (order 1) */
-            array(
-                0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-            ),
-            /* 2707385501144840649318225287225658788936804267575313519463743609750303402022 (order 8) */
-            array(
-                0x26, 0xe8, 0x95, 0x8f, 0xc2, 0xb2, 0x27, 0xb0,
-                0x45, 0xc3, 0xf4, 0x89, 0xf2, 0xef, 0x98, 0xf0,
-                0xd5, 0xdf, 0xac, 0x05, 0xd3, 0xc6, 0x33, 0x39,
-                0xb1, 0x38, 0x02, 0x88, 0x6d, 0x53, 0xfc, 0x05
-            ),
-            /* 55188659117513257062467267217118295137698188065244968500265048394206261417927 (order 8) */
-            array(
-                0xc7, 0x17, 0x6a, 0x70, 0x3d, 0x4d, 0xd8, 0x4f,
-                0xba, 0x3c, 0x0b, 0x76, 0x0d, 0x10, 0x67, 0x0f,
-                0x2a, 0x20, 0x53, 0xfa, 0x2c, 0x39, 0xcc, 0xc6,
-                0x4e, 0xc7, 0xfd, 0x77, 0x92, 0xac, 0x03, 0x7a
-            ),
-            /* p-1 (order 2) */
-            array(
-                0x13, 0xe8, 0x95, 0x8f, 0xc2, 0xb2, 0x27, 0xb0,
-                0x45, 0xc3, 0xf4, 0x89, 0xf2, 0xef, 0x98, 0xf0,
-                0xd5, 0xdf, 0xac, 0x05, 0xd3, 0xc6, 0x33, 0x39,
-                0xb1, 0x38, 0x02, 0x88, 0x6d, 0x53, 0xfc, 0x85
-            ),
-            /* p (order 4) */
-            array(
-                0xb4, 0x17, 0x6a, 0x70, 0x3d, 0x4d, 0xd8, 0x4f,
-                0xba, 0x3c, 0x0b, 0x76, 0x0d, 0x10, 0x67, 0x0f,
-                0x2a, 0x20, 0x53, 0xfa, 0x2c, 0x39, 0xcc, 0xc6,
-                0x4e, 0xc7, 0xfd, 0x77, 0x92, 0xac, 0x03, 0xfa
-            ),
-            /* p+1 (order 1) */
-            array(
-                0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f
-            ),
-            /* p+2707385501144840649318225287225658788936804267575313519463743609750303402022 (order 8) */
-            array(
-                0xed, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f
-            ),
-            /* p+55188659117513257062467267217118295137698188065244968500265048394206261417927 (order 8) */
-            array(
-                0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f
-            ),
-            /* 2p-1 (order 2) */
-            array(
-                0xd9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
-            ),
-            /* 2p (order 4) */
-            array(
-                0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
-            ),
-            /* 2p+1 (order 1) */
-            array(
-                0xdb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-                0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
-            )
-        );
-        /** @var array<int, array<int, int>> $blocklist */
-        $countBlocklist = count($blocklist);
-
-        for ($i = 0; $i < $countBlocklist; ++$i) {
-            $c = 0;
-            for ($j = 0; $j < 32; ++$j) {
-                $c |= self::chrToInt($R[$j]) ^ $blocklist[$i][$j];
-            }
-            if ($c === 0) {
-                return true;
-            }
-        }
-        return false;
-    }
+	const KEYPAIR_BYTES = 96;
+	const SEED_BYTES = 32;
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @return string (96 bytes)
+	 * @throws Exception
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function keypair()
+	{
+		$seed = random_bytes(self::SEED_BYTES);
+		$pk = '';
+		$sk = '';
+		self::seed_keypair($pk, $sk, $seed);
+		return $sk . $pk;
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $pk
+	 * @param string $sk
+	 * @param string $seed
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function seed_keypair(&$pk, &$sk, $seed)
+	{
+		if (self::strlen($seed) !== self::SEED_BYTES) {
+			throw new RangeException('crypto_sign keypair seed must be 32 bytes long');
+		}
+
+		/** @var string $pk */
+		$pk = self::publickey_from_secretkey($seed);
+		$sk = $seed . $pk;
+		return $sk;
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $keypair
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function secretkey($keypair)
+	{
+		if (self::strlen($keypair) !== self::KEYPAIR_BYTES) {
+			throw new RangeException('crypto_sign keypair must be 96 bytes long');
+		}
+		return self::substr($keypair, 0, 64);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $keypair
+	 * @return string
+	 * @throws RangeException
+	 * @throws TypeError
+	 */
+	public static function publickey($keypair)
+	{
+		if (self::strlen($keypair) !== self::KEYPAIR_BYTES) {
+			throw new RangeException('crypto_sign keypair must be 96 bytes long');
+		}
+		return self::substr($keypair, 64, 32);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $sk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function publickey_from_secretkey($sk)
+	{
+		/** @var string $sk */
+		$sk = hash('sha512', self::substr($sk, 0, 32), true);
+		$sk[0] = self::intToChr(
+			self::chrToInt($sk[0]) & 248
+		);
+		$sk[31] = self::intToChr(
+			(self::chrToInt($sk[31]) & 63) | 64
+		);
+		return self::sk_to_pk($sk);
+	}
+
+	/**
+	 * @param string $pk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function pk_to_curve25519($pk)
+	{
+		if (self::small_order($pk)) {
+			throw new SodiumException('Public key is on a small order');
+		}
+		$A = self::ge_frombytes_negate_vartime($pk);
+		$p1 = self::ge_mul_l($A);
+		if (!self::fe_isnonzero($p1->X)) {
+			throw new SodiumException('Unexpected zero result');
+		}
+
+		# fe_1(one_minus_y);
+		# fe_sub(one_minus_y, one_minus_y, A.Y);
+		# fe_invert(one_minus_y, one_minus_y);
+		$one_minux_y = self::fe_invert(
+			self::fe_sub(
+				self::fe_1(),
+				$A->Y
+			)
+		);
+
+
+		# fe_1(x);
+		# fe_add(x, x, A.Y);
+		# fe_mul(x, x, one_minus_y);
+		$x = self::fe_mul(
+			self::fe_add(self::fe_1(), $A->Y),
+			$one_minux_y
+		);
+
+		# fe_tobytes(curve25519_pk, x);
+		return self::fe_tobytes($x);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $sk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function sk_to_pk($sk)
+	{
+		return self::ge_p3_tobytes(
+			self::ge_scalarmult_base(
+				self::substr($sk, 0, 32)
+			)
+		);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $message
+	 * @param string $sk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function sign($message, $sk)
+	{
+		/** @var string $signature */
+		$signature = self::sign_detached($message, $sk);
+		return $signature . $message;
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $message A signed message
+	 * @param string $pk      Public key
+	 * @return string         Message (without signature)
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function sign_open($message, $pk)
+	{
+		/** @var string $signature */
+		$signature = self::substr($message, 0, 64);
+
+		/** @var string $message */
+		$message = self::substr($message, 64);
+
+		if (self::verify_detached($signature, $message, $pk)) {
+			return $message;
+		}
+		throw new SodiumException('Invalid signature');
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $message
+	 * @param string $sk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress PossiblyInvalidArgument
+	 */
+	public static function sign_detached($message, $sk)
+	{
+		# crypto_hash_sha512(az, sk, 32);
+		$az =  hash('sha512', self::substr($sk, 0, 32), true);
+
+		# az[0] &= 248;
+		# az[31] &= 63;
+		# az[31] |= 64;
+		$az[0] = self::intToChr(self::chrToInt($az[0]) & 248);
+		$az[31] = self::intToChr((self::chrToInt($az[31]) & 63) | 64);
+
+		# crypto_hash_sha512_init(&hs);
+		# crypto_hash_sha512_update(&hs, az + 32, 32);
+		# crypto_hash_sha512_update(&hs, m, mlen);
+		# crypto_hash_sha512_final(&hs, nonce);
+		$hs = hash_init('sha512');
+		self::hash_update($hs, self::substr($az, 32, 32));
+		self::hash_update($hs, $message);
+		$nonceHash = hash_final($hs, true);
+
+		# memmove(sig + 32, sk + 32, 32);
+		$pk = self::substr($sk, 32, 32);
+
+		# sc_reduce(nonce);
+		# ge_scalarmult_base(&R, nonce);
+		# ge_p3_tobytes(sig, &R);
+		$nonce = self::sc_reduce($nonceHash) . self::substr($nonceHash, 32);
+		$sig = self::ge_p3_tobytes(
+			self::ge_scalarmult_base($nonce)
+		);
+
+		# crypto_hash_sha512_init(&hs);
+		# crypto_hash_sha512_update(&hs, sig, 64);
+		# crypto_hash_sha512_update(&hs, m, mlen);
+		# crypto_hash_sha512_final(&hs, hram);
+		$hs = hash_init('sha512');
+		self::hash_update($hs, self::substr($sig, 0, 32));
+		self::hash_update($hs, self::substr($pk, 0, 32));
+		self::hash_update($hs, $message);
+		$hramHash = hash_final($hs, true);
+
+		# sc_reduce(hram);
+		# sc_muladd(sig + 32, hram, az, nonce);
+		$hram = self::sc_reduce($hramHash);
+		$sigAfter = self::sc_muladd($hram, $az, $nonce);
+		$sig = self::substr($sig, 0, 32) . self::substr($sigAfter, 0, 32);
+
+		try {
+			ParagonIE_Sodium_Compat::memzero($az);
+		} catch (SodiumException $ex) {
+			$az = null;
+		}
+		return $sig;
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $sig
+	 * @param string $message
+	 * @param string $pk
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function verify_detached($sig, $message, $pk)
+	{
+		if (self::strlen($sig) < 64) {
+			throw new SodiumException('Signature is too short');
+		}
+		if ((self::chrToInt($sig[63]) & 240) && self::check_S_lt_L(self::substr($sig, 32, 32))) {
+			throw new SodiumException('S < L - Invalid signature');
+		}
+		if (self::small_order($sig)) {
+			throw new SodiumException('Signature is on too small of an order');
+		}
+		if ((self::chrToInt($sig[63]) & 224) !== 0) {
+			throw new SodiumException('Invalid signature');
+		}
+		$d = 0;
+		for ($i = 0; $i < 32; ++$i) {
+			$d |= self::chrToInt($pk[$i]);
+		}
+		if ($d === 0) {
+			throw new SodiumException('All zero public key');
+		}
+
+		/** @var bool The original value of ParagonIE_Sodium_Compat::$fastMult */
+		$orig = ParagonIE_Sodium_Compat::$fastMult;
+
+		// Set ParagonIE_Sodium_Compat::$fastMult to true to speed up verification.
+		ParagonIE_Sodium_Compat::$fastMult = true;
+
+		/** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P3 $A */
+		$A = self::ge_frombytes_negate_vartime($pk);
+
+		/** @var string $hDigest */
+		$hDigest = hash(
+			'sha512',
+			self::substr($sig, 0, 32) .
+			self::substr($pk, 0, 32) .
+			$message,
+			true
+		);
+
+		/** @var string $h */
+		$h = self::sc_reduce($hDigest) . self::substr($hDigest, 32);
+
+		/** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P2 $R */
+		$R = self::ge_double_scalarmult_vartime(
+			$h,
+			$A,
+			self::substr($sig, 32)
+		);
+
+		/** @var string $rcheck */
+		$rcheck = self::ge_tobytes($R);
+
+		// Reset ParagonIE_Sodium_Compat::$fastMult to what it was before.
+		ParagonIE_Sodium_Compat::$fastMult = $orig;
+
+		return self::verify_32($rcheck, self::substr($sig, 0, 32));
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $S
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function check_S_lt_L($S)
+	{
+		if (self::strlen($S) < 32) {
+			throw new SodiumException('Signature must be 32 bytes');
+		}
+		static $L = array(
+			0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58,
+			0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10
+		);
+		/** @var array<int, int> $L */
+		$c = 0;
+		$n = 1;
+		$i = 32;
+
+		do {
+			--$i;
+			$x = self::chrToInt($S[$i]);
+			$c |= (
+				(($x - $L[$i]) >> 8) & $n
+			);
+			$n &= (
+				(($x ^ $L[$i]) - 1) >> 8
+			);
+		} while ($i !== 0);
+
+		return $c === 0;
+	}
+
+	/**
+	 * @param string $R
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function small_order($R)
+	{
+		static $blocklist = array(
+			/* 0 (order 4) */
+			array(
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+			),
+			/* 1 (order 1) */
+			array(
+				0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+			),
+			/* 2707385501144840649318225287225658788936804267575313519463743609750303402022 (order 8) */
+			array(
+				0x26, 0xe8, 0x95, 0x8f, 0xc2, 0xb2, 0x27, 0xb0,
+				0x45, 0xc3, 0xf4, 0x89, 0xf2, 0xef, 0x98, 0xf0,
+				0xd5, 0xdf, 0xac, 0x05, 0xd3, 0xc6, 0x33, 0x39,
+				0xb1, 0x38, 0x02, 0x88, 0x6d, 0x53, 0xfc, 0x05
+			),
+			/* 55188659117513257062467267217118295137698188065244968500265048394206261417927 (order 8) */
+			array(
+				0xc7, 0x17, 0x6a, 0x70, 0x3d, 0x4d, 0xd8, 0x4f,
+				0xba, 0x3c, 0x0b, 0x76, 0x0d, 0x10, 0x67, 0x0f,
+				0x2a, 0x20, 0x53, 0xfa, 0x2c, 0x39, 0xcc, 0xc6,
+				0x4e, 0xc7, 0xfd, 0x77, 0x92, 0xac, 0x03, 0x7a
+			),
+			/* p-1 (order 2) */
+			array(
+				0x13, 0xe8, 0x95, 0x8f, 0xc2, 0xb2, 0x27, 0xb0,
+				0x45, 0xc3, 0xf4, 0x89, 0xf2, 0xef, 0x98, 0xf0,
+				0xd5, 0xdf, 0xac, 0x05, 0xd3, 0xc6, 0x33, 0x39,
+				0xb1, 0x38, 0x02, 0x88, 0x6d, 0x53, 0xfc, 0x85
+			),
+			/* p (order 4) */
+			array(
+				0xb4, 0x17, 0x6a, 0x70, 0x3d, 0x4d, 0xd8, 0x4f,
+				0xba, 0x3c, 0x0b, 0x76, 0x0d, 0x10, 0x67, 0x0f,
+				0x2a, 0x20, 0x53, 0xfa, 0x2c, 0x39, 0xcc, 0xc6,
+				0x4e, 0xc7, 0xfd, 0x77, 0x92, 0xac, 0x03, 0xfa
+			),
+			/* p+1 (order 1) */
+			array(
+				0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f
+			),
+			/* p+2707385501144840649318225287225658788936804267575313519463743609750303402022 (order 8) */
+			array(
+				0xed, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f
+			),
+			/* p+55188659117513257062467267217118295137698188065244968500265048394206261417927 (order 8) */
+			array(
+				0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f
+			),
+			/* 2p-1 (order 2) */
+			array(
+				0xd9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+			),
+			/* 2p (order 4) */
+			array(
+				0xda, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+			),
+			/* 2p+1 (order 1) */
+			array(
+				0xdb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+			)
+		);
+		/** @var array<int, array<int, int>> $blocklist */
+		$countBlocklist = count($blocklist);
+
+		for ($i = 0; $i < $countBlocklist; ++$i) {
+			$c = 0;
+			for ($j = 0; $j < 32; ++$j) {
+				$c |= self::chrToInt($R[$j]) ^ $blocklist[$i][$j];
+			}
+			if ($c === 0) {
+				return true;
+			}
+		}
+		return false;
+	}
 }

Spacing +94 added lines, -94 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core32_Ed25519', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core32_Ed25519', false ) ) {
     return;
 }
 
@@ -22,10 +22,10 @@ 
      */
     public static function keypair()
     {
-        $seed = random_bytes(self::SEED_BYTES);
+        $seed = random_bytes( self::SEED_BYTES );
         $pk = '';
         $sk = '';
-        self::seed_keypair($pk, $sk, $seed);
+        self::seed_keypair( $pk, $sk, $seed );
         return $sk . $pk;
     }
 
@@ -39,14 +39,14 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function seed_keypair(&$pk, &$sk, $seed)
+    public static function seed_keypair( &$pk, &$sk, $seed )
     {
-        if (self::strlen($seed) !== self::SEED_BYTES) {
-            throw new RangeException('crypto_sign keypair seed must be 32 bytes long');
+        if ( self::strlen( $seed ) !== self::SEED_BYTES ) {
+            throw new RangeException( 'crypto_sign keypair seed must be 32 bytes long' );
         }
 
         /** @var string $pk */
-        $pk = self::publickey_from_secretkey($seed);
+        $pk = self::publickey_from_secretkey( $seed );
         $sk = $seed . $pk;
         return $sk;
     }
@@ -58,12 +58,12 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function secretkey($keypair)
+    public static function secretkey( $keypair )
     {
-        if (self::strlen($keypair) !== self::KEYPAIR_BYTES) {
-            throw new RangeException('crypto_sign keypair must be 96 bytes long');
+        if ( self::strlen( $keypair ) !== self::KEYPAIR_BYTES ) {
+            throw new RangeException( 'crypto_sign keypair must be 96 bytes long' );
         }
-        return self::substr($keypair, 0, 64);
+        return self::substr( $keypair, 0, 64 );
     }
 
     /**
@@ -74,12 +74,12 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function publickey($keypair)
+    public static function publickey( $keypair )
     {
-        if (self::strlen($keypair) !== self::KEYPAIR_BYTES) {
-            throw new RangeException('crypto_sign keypair must be 96 bytes long');
+        if ( self::strlen( $keypair ) !== self::KEYPAIR_BYTES ) {
+            throw new RangeException( 'crypto_sign keypair must be 96 bytes long' );
         }
-        return self::substr($keypair, 64, 32);
+        return self::substr( $keypair, 64, 32 );
     }
 
     /**
@@ -90,17 +90,17 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function publickey_from_secretkey($sk)
+    public static function publickey_from_secretkey( $sk )
     {
         /** @var string $sk */
-        $sk = hash('sha512', self::substr($sk, 0, 32), true);
-        $sk[0] = self::intToChr(
-            self::chrToInt($sk[0]) & 248
+        $sk = hash( 'sha512', self::substr( $sk, 0, 32 ), true );
+        $sk[ 0 ] = self::intToChr(
+            self::chrToInt( $sk[ 0 ] ) & 248
         );
-        $sk[31] = self::intToChr(
-            (self::chrToInt($sk[31]) & 63) | 64
+        $sk[ 31 ] = self::intToChr(
+            ( self::chrToInt( $sk[ 31 ] ) & 63 ) | 64
         );
-        return self::sk_to_pk($sk);
+        return self::sk_to_pk( $sk );
     }
 
     /**
@@ -109,15 +109,15 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function pk_to_curve25519($pk)
+    public static function pk_to_curve25519( $pk )
     {
-        if (self::small_order($pk)) {
-            throw new SodiumException('Public key is on a small order');
+        if ( self::small_order( $pk ) ) {
+            throw new SodiumException( 'Public key is on a small order' );
         }
-        $A = self::ge_frombytes_negate_vartime($pk);
-        $p1 = self::ge_mul_l($A);
-        if (!self::fe_isnonzero($p1->X)) {
-            throw new SodiumException('Unexpected zero result');
+        $A = self::ge_frombytes_negate_vartime( $pk );
+        $p1 = self::ge_mul_l( $A );
+        if ( ! self::fe_isnonzero( $p1->X ) ) {
+            throw new SodiumException( 'Unexpected zero result' );
         }
 
         # fe_1(one_minus_y);
@@ -135,12 +135,12 @@ 
         # fe_add(x, x, A.Y);
         # fe_mul(x, x, one_minus_y);
         $x = self::fe_mul(
-            self::fe_add(self::fe_1(), $A->Y),
+            self::fe_add( self::fe_1(), $A->Y ),
             $one_minux_y
         );
 
         # fe_tobytes(curve25519_pk, x);
-        return self::fe_tobytes($x);
+        return self::fe_tobytes( $x );
     }
 
     /**
@@ -151,11 +151,11 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sk_to_pk($sk)
+    public static function sk_to_pk( $sk )
     {
         return self::ge_p3_tobytes(
             self::ge_scalarmult_base(
-                self::substr($sk, 0, 32)
+                self::substr( $sk, 0, 32 )
             )
         );
     }
@@ -169,10 +169,10 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign($message, $sk)
+    public static function sign( $message, $sk )
     {
         /** @var string $signature */
-        $signature = self::sign_detached($message, $sk);
+        $signature = self::sign_detached( $message, $sk );
         return $signature . $message;
     }
 
@@ -185,18 +185,18 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign_open($message, $pk)
+    public static function sign_open( $message, $pk )
     {
         /** @var string $signature */
-        $signature = self::substr($message, 0, 64);
+        $signature = self::substr( $message, 0, 64 );
 
         /** @var string $message */
-        $message = self::substr($message, 64);
+        $message = self::substr( $message, 64 );
 
-        if (self::verify_detached($signature, $message, $pk)) {
+        if ( self::verify_detached( $signature, $message, $pk ) ) {
             return $message;
         }
-        throw new SodiumException('Invalid signature');
+        throw new SodiumException( 'Invalid signature' );
     }
 
     /**
@@ -209,56 +209,56 @@ 
      * @throws TypeError
      * @psalm-suppress PossiblyInvalidArgument
      */
-    public static function sign_detached($message, $sk)
+    public static function sign_detached( $message, $sk )
     {
         # crypto_hash_sha512(az, sk, 32);
-        $az =  hash('sha512', self::substr($sk, 0, 32), true);
+        $az = hash( 'sha512', self::substr( $sk, 0, 32 ), true );
 
         # az[0] &= 248;
         # az[31] &= 63;
         # az[31] |= 64;
-        $az[0] = self::intToChr(self::chrToInt($az[0]) & 248);
-        $az[31] = self::intToChr((self::chrToInt($az[31]) & 63) | 64);
+        $az[ 0 ] = self::intToChr( self::chrToInt( $az[ 0 ] ) & 248 );
+        $az[ 31 ] = self::intToChr( ( self::chrToInt( $az[ 31 ] ) & 63 ) | 64 );
 
         # crypto_hash_sha512_init(&hs);
         # crypto_hash_sha512_update(&hs, az + 32, 32);
         # crypto_hash_sha512_update(&hs, m, mlen);
         # crypto_hash_sha512_final(&hs, nonce);
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($az, 32, 32));
-        self::hash_update($hs, $message);
-        $nonceHash = hash_final($hs, true);
+        $hs = hash_init( 'sha512' );
+        self::hash_update( $hs, self::substr( $az, 32, 32 ) );
+        self::hash_update( $hs, $message );
+        $nonceHash = hash_final( $hs, true );
 
         # memmove(sig + 32, sk + 32, 32);
-        $pk = self::substr($sk, 32, 32);
+        $pk = self::substr( $sk, 32, 32 );
 
         # sc_reduce(nonce);
         # ge_scalarmult_base(&R, nonce);
         # ge_p3_tobytes(sig, &R);
-        $nonce = self::sc_reduce($nonceHash) . self::substr($nonceHash, 32);
+        $nonce = self::sc_reduce( $nonceHash ) . self::substr( $nonceHash, 32 );
         $sig = self::ge_p3_tobytes(
-            self::ge_scalarmult_base($nonce)
+            self::ge_scalarmult_base( $nonce )
         );
 
         # crypto_hash_sha512_init(&hs);
         # crypto_hash_sha512_update(&hs, sig, 64);
         # crypto_hash_sha512_update(&hs, m, mlen);
         # crypto_hash_sha512_final(&hs, hram);
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($sig, 0, 32));
-        self::hash_update($hs, self::substr($pk, 0, 32));
-        self::hash_update($hs, $message);
-        $hramHash = hash_final($hs, true);
+        $hs = hash_init( 'sha512' );
+        self::hash_update( $hs, self::substr( $sig, 0, 32 ) );
+        self::hash_update( $hs, self::substr( $pk, 0, 32 ) );
+        self::hash_update( $hs, $message );
+        $hramHash = hash_final( $hs, true );
 
         # sc_reduce(hram);
         # sc_muladd(sig + 32, hram, az, nonce);
-        $hram = self::sc_reduce($hramHash);
-        $sigAfter = self::sc_muladd($hram, $az, $nonce);
-        $sig = self::substr($sig, 0, 32) . self::substr($sigAfter, 0, 32);
+        $hram = self::sc_reduce( $hramHash );
+        $sigAfter = self::sc_muladd( $hram, $az, $nonce );
+        $sig = self::substr( $sig, 0, 32 ) . self::substr( $sigAfter, 0, 32 );
 
         try {
-            ParagonIE_Sodium_Compat::memzero($az);
-        } catch (SodiumException $ex) {
+            ParagonIE_Sodium_Compat::memzero( $az );
+        } catch ( SodiumException $ex ) {
             $az = null;
         }
         return $sig;
@@ -274,26 +274,26 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function verify_detached($sig, $message, $pk)
+    public static function verify_detached( $sig, $message, $pk )
     {
-        if (self::strlen($sig) < 64) {
-            throw new SodiumException('Signature is too short');
+        if ( self::strlen( $sig ) < 64 ) {
+            throw new SodiumException( 'Signature is too short' );
         }
-        if ((self::chrToInt($sig[63]) & 240) && self::check_S_lt_L(self::substr($sig, 32, 32))) {
-            throw new SodiumException('S < L - Invalid signature');
+        if ( ( self::chrToInt( $sig[ 63 ] ) & 240 ) && self::check_S_lt_L( self::substr( $sig, 32, 32 ) ) ) {
+            throw new SodiumException( 'S < L - Invalid signature' );
         }
-        if (self::small_order($sig)) {
-            throw new SodiumException('Signature is on too small of an order');
+        if ( self::small_order( $sig ) ) {
+            throw new SodiumException( 'Signature is on too small of an order' );
         }
-        if ((self::chrToInt($sig[63]) & 224) !== 0) {
-            throw new SodiumException('Invalid signature');
+        if ( ( self::chrToInt( $sig[ 63 ] ) & 224 ) !== 0 ) {
+            throw new SodiumException( 'Invalid signature' );
         }
         $d = 0;
-        for ($i = 0; $i < 32; ++$i) {
-            $d |= self::chrToInt($pk[$i]);
+        for ( $i = 0; $i < 32; ++$i ) {
+            $d |= self::chrToInt( $pk[ $i ] );
         }
-        if ($d === 0) {
-            throw new SodiumException('All zero public key');
+        if ( $d === 0 ) {
+            throw new SodiumException( 'All zero public key' );
         }
 
         /** @var bool The original value of ParagonIE_Sodium_Compat::$fastMult */
@@ -303,34 +303,34 @@ 
         ParagonIE_Sodium_Compat::$fastMult = true;
 
         /** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P3 $A */
-        $A = self::ge_frombytes_negate_vartime($pk);
+        $A = self::ge_frombytes_negate_vartime( $pk );
 
         /** @var string $hDigest */
         $hDigest = hash(
             'sha512',
-            self::substr($sig, 0, 32) .
-            self::substr($pk, 0, 32) .
+            self::substr( $sig, 0, 32 ) .
+            self::substr( $pk, 0, 32 ) .
             $message,
             true
         );
 
         /** @var string $h */
-        $h = self::sc_reduce($hDigest) . self::substr($hDigest, 32);
+        $h = self::sc_reduce( $hDigest ) . self::substr( $hDigest, 32 );
 
         /** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P2 $R */
         $R = self::ge_double_scalarmult_vartime(
             $h,
             $A,
-            self::substr($sig, 32)
+            self::substr( $sig, 32 )
         );
 
         /** @var string $rcheck */
-        $rcheck = self::ge_tobytes($R);
+        $rcheck = self::ge_tobytes( $R );
 
         // Reset ParagonIE_Sodium_Compat::$fastMult to what it was before.
         ParagonIE_Sodium_Compat::$fastMult = $orig;
 
-        return self::verify_32($rcheck, self::substr($sig, 0, 32));
+        return self::verify_32( $rcheck, self::substr( $sig, 0, 32 ) );
     }
 
     /**
@@ -341,10 +341,10 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function check_S_lt_L($S)
+    public static function check_S_lt_L( $S )
     {
-        if (self::strlen($S) < 32) {
-            throw new SodiumException('Signature must be 32 bytes');
+        if ( self::strlen( $S ) < 32 ) {
+            throw new SodiumException( 'Signature must be 32 bytes' );
         }
         static $L = array(
             0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58,
@@ -359,14 +359,14 @@ 
 
         do {
             --$i;
-            $x = self::chrToInt($S[$i]);
+            $x = self::chrToInt( $S[ $i ] );
             $c |= (
-                (($x - $L[$i]) >> 8) & $n
+                ( ( $x - $L[ $i ] ) >> 8 ) & $n
             );
             $n &= (
-                (($x ^ $L[$i]) - 1) >> 8
+                ( ( $x ^ $L[ $i ] ) - 1 ) >> 8
             );
-        } while ($i !== 0);
+        } while ( $i !== 0 );
 
         return $c === 0;
     }
@@ -377,7 +377,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function small_order($R)
+    public static function small_order( $R )
     {
         static $blocklist = array(
             /* 0 (order 4) */
@@ -466,14 +466,14 @@ 
             )
         );
         /** @var array<int, array<int, int>> $blocklist */
-        $countBlocklist = count($blocklist);
+        $countBlocklist = count( $blocklist );
 
-        for ($i = 0; $i < $countBlocklist; ++$i) {
+        for ( $i = 0; $i < $countBlocklist; ++$i ) {
             $c = 0;
-            for ($j = 0; $j < 32; ++$j) {
-                $c |= self::chrToInt($R[$j]) ^ $blocklist[$i][$j];
+            for ( $j = 0; $j < 32; ++$j ) {
+                $c |= self::chrToInt( $R[ $j ] ) ^ $blocklist[ $i ][ $j ];
             }
-            if ($c === 0) {
+            if ( $c === 0 ) {
                 return true;
             }
         }

Braces +14 added lines, -28 removed lines

@@ -7,8 +7,7 @@ 
 /**
  * Class ParagonIE_Sodium_Core32_Ed25519
  */
-abstract class ParagonIE_Sodium_Core32_Ed25519 extends ParagonIE_Sodium_Core32_Curve25519
-{
+abstract class ParagonIE_Sodium_Core32_Ed25519 extends ParagonIE_Sodium_Core32_Curve25519 {
     const KEYPAIR_BYTES = 96;
     const SEED_BYTES = 32;
 
@@ -20,8 +19,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function keypair()
-    {
+    public static function keypair() {
         $seed = random_bytes(self::SEED_BYTES);
         $pk = '';
         $sk = '';
@@ -39,8 +37,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function seed_keypair(&$pk, &$sk, $seed)
-    {
+    public static function seed_keypair(&$pk, &$sk, $seed) {
         if (self::strlen($seed) !== self::SEED_BYTES) {
             throw new RangeException('crypto_sign keypair seed must be 32 bytes long');
         }
@@ -58,8 +55,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function secretkey($keypair)
-    {
+    public static function secretkey($keypair) {
         if (self::strlen($keypair) !== self::KEYPAIR_BYTES) {
             throw new RangeException('crypto_sign keypair must be 96 bytes long');
         }
@@ -74,8 +70,7 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function publickey($keypair)
-    {
+    public static function publickey($keypair) {
         if (self::strlen($keypair) !== self::KEYPAIR_BYTES) {
             throw new RangeException('crypto_sign keypair must be 96 bytes long');
         }
@@ -90,8 +85,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function publickey_from_secretkey($sk)
-    {
+    public static function publickey_from_secretkey($sk) {
         /** @var string $sk */
         $sk = hash('sha512', self::substr($sk, 0, 32), true);
         $sk[0] = self::intToChr(
@@ -109,8 +103,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function pk_to_curve25519($pk)
-    {
+    public static function pk_to_curve25519($pk) {
         if (self::small_order($pk)) {
             throw new SodiumException('Public key is on a small order');
         }
@@ -151,8 +144,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sk_to_pk($sk)
-    {
+    public static function sk_to_pk($sk) {
         return self::ge_p3_tobytes(
             self::ge_scalarmult_base(
                 self::substr($sk, 0, 32)
@@ -169,8 +161,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign($message, $sk)
-    {
+    public static function sign($message, $sk) {
         /** @var string $signature */
         $signature = self::sign_detached($message, $sk);
         return $signature . $message;
@@ -185,8 +176,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign_open($message, $pk)
-    {
+    public static function sign_open($message, $pk) {
         /** @var string $signature */
         $signature = self::substr($message, 0, 64);
 
@@ -209,8 +199,7 @@ 
      * @throws TypeError
      * @psalm-suppress PossiblyInvalidArgument
      */
-    public static function sign_detached($message, $sk)
-    {
+    public static function sign_detached($message, $sk) {
         # crypto_hash_sha512(az, sk, 32);
         $az =  hash('sha512', self::substr($sk, 0, 32), true);
 
@@ -274,8 +263,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function verify_detached($sig, $message, $pk)
-    {
+    public static function verify_detached($sig, $message, $pk) {
         if (self::strlen($sig) < 64) {
             throw new SodiumException('Signature is too short');
         }
@@ -341,8 +329,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function check_S_lt_L($S)
-    {
+    public static function check_S_lt_L($S) {
         if (self::strlen($S) < 32) {
             throw new SodiumException('Signature must be 32 bytes');
         }
@@ -377,8 +364,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function small_order($R)
-    {
+    public static function small_order($R) {
         static $blocklist = array(
             /* 0 (order 4) */
             array(

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

Indentation +1 added lines, -1 removed lines

@@ -1,7 +1,7 @@
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core32_Util', false)) {
-    return;
+	return;
 }
 
 /**

Spacing +1 added lines, -1 removed lines

@@ -1,6 +1,6 @@
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core32_Util', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core32_Util', false ) ) {
     return;
 }
 

Braces +1 added lines, -2 removed lines

@@ -7,7 +7,6 @@
 /**
  * Class ParagonIE_Sodium_Core_Util
  */
-abstract class ParagonIE_Sodium_Core32_Util extends ParagonIE_Sodium_Core_Util
-{
+abstract class ParagonIE_Sodium_Core32_Util extends ParagonIE_Sodium_Core_Util {
 
 }

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

Indentation +225 added lines, -225 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core32_SipHash', false)) {
-    return;
+	return;
 }
 
 /**
@@ -11,228 +11,228 @@ 
  */
 class ParagonIE_Sodium_Core32_SipHash extends ParagonIE_Sodium_Core32_Util
 {
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param array<int, ParagonIE_Sodium_Core32_Int64> $v
-     * @return array<int, ParagonIE_Sodium_Core32_Int64>
-     */
-    public static function sipRound(array $v)
-    {
-        # v0 += v1;
-        $v[0] = $v[0]->addInt64($v[1]);
-
-        # v1 = ROTL(v1, 13);
-        $v[1] = $v[1]->rotateLeft(13);
-
-        #  v1 ^= v0;
-        $v[1] = $v[1]->xorInt64($v[0]);
-
-        #  v0=ROTL(v0,32);
-        $v[0] = $v[0]->rotateLeft(32);
-
-        # v2 += v3;
-        $v[2] = $v[2]->addInt64($v[3]);
-
-        # v3=ROTL(v3,16);
-        $v[3] = $v[3]->rotateLeft(16);
-
-        #  v3 ^= v2;
-        $v[3] = $v[3]->xorInt64($v[2]);
-
-        # v0 += v3;
-        $v[0] = $v[0]->addInt64($v[3]);
-
-        # v3=ROTL(v3,21);
-        $v[3] = $v[3]->rotateLeft(21);
-
-        # v3 ^= v0;
-        $v[3] = $v[3]->xorInt64($v[0]);
-
-        # v2 += v1;
-        $v[2] = $v[2]->addInt64($v[1]);
-
-        # v1=ROTL(v1,17);
-        $v[1] = $v[1]->rotateLeft(17);
-
-        #  v1 ^= v2;
-        $v[1] = $v[1]->xorInt64($v[2]);
-
-        # v2=ROTL(v2,32)
-        $v[2] = $v[2]->rotateLeft(32);
-
-        return $v;
-    }
-
-    /**
-     * @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(
-            new ParagonIE_Sodium_Core32_Int64(
-                array(0x736f, 0x6d65, 0x7073, 0x6575)
-            ),
-            new ParagonIE_Sodium_Core32_Int64(
-                array(0x646f, 0x7261, 0x6e64, 0x6f6d)
-            ),
-            new ParagonIE_Sodium_Core32_Int64(
-                array(0x6c79, 0x6765, 0x6e65, 0x7261)
-            ),
-            new ParagonIE_Sodium_Core32_Int64(
-                array(0x7465, 0x6462, 0x7974, 0x6573)
-            )
-        );
-
-        # u64 k0 = LOAD64_LE( k );
-        # u64 k1 = LOAD64_LE( k + 8 );
-        $k = array(
-            ParagonIE_Sodium_Core32_Int64::fromReverseString(
-                self::substr($key, 0, 8)
-            ),
-            ParagonIE_Sodium_Core32_Int64::fromReverseString(
-                self::substr($key, 8, 8)
-            )
-        );
-
-        # b = ( ( u64 )inlen ) << 56;
-        $b = new ParagonIE_Sodium_Core32_Int64(
-            array(($inlen << 8) & 0xffff, 0, 0, 0)
-        );
-
-        # v3 ^= k1;
-        $v[3] = $v[3]->xorInt64($k[1]);
-        # v2 ^= k0;
-        $v[2] = $v[2]->xorInt64($k[0]);
-        # v1 ^= k1;
-        $v[1] = $v[1]->xorInt64($k[1]);
-        # v0 ^= k0;
-        $v[0] = $v[0]->xorInt64($k[0]);
-
-        $left = $inlen;
-        # for ( ; in != end; in += 8 )
-        while ($left >= 8) {
-            # m = LOAD64_LE( in );
-            $m = ParagonIE_Sodium_Core32_Int64::fromReverseString(
-                self::substr($in, 0, 8)
-            );
-
-            # v3 ^= m;
-            $v[3] = $v[3]->xorInt64($m);
-
-            # SIPROUND;
-            # SIPROUND;
-            $v = self::sipRound($v);
-            $v = self::sipRound($v);
-
-            # v0 ^= m;
-            $v[0] = $v[0]->xorInt64($m);
-
-            $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 = $b->orInt64(
-                    ParagonIE_Sodium_Core32_Int64::fromInts(
-                        0, self::chrToInt($in[6]) << 16
-                    )
-                );
-            case 6:
-                $b = $b->orInt64(
-                    ParagonIE_Sodium_Core32_Int64::fromInts(
-                        0, self::chrToInt($in[5]) << 8
-                    )
-                );
-            case 5:
-                $b = $b->orInt64(
-                    ParagonIE_Sodium_Core32_Int64::fromInts(
-                        0, self::chrToInt($in[4])
-                    )
-                );
-            case 4:
-                $b = $b->orInt64(
-                    ParagonIE_Sodium_Core32_Int64::fromInts(
-                        self::chrToInt($in[3]) << 24, 0
-                    )
-                );
-            case 3:
-                $b = $b->orInt64(
-                    ParagonIE_Sodium_Core32_Int64::fromInts(
-                        self::chrToInt($in[2]) << 16, 0
-                    )
-                );
-            case 2:
-                $b = $b->orInt64(
-                    ParagonIE_Sodium_Core32_Int64::fromInts(
-                        self::chrToInt($in[1]) << 8, 0
-                    )
-                );
-            case 1:
-                $b = $b->orInt64(
-                    ParagonIE_Sodium_Core32_Int64::fromInts(
-                        self::chrToInt($in[0]), 0
-                    )
-                );
-            case 0:
-                break;
-        }
-
-        # v3 ^= b;
-        $v[3] = $v[3]->xorInt64($b);
-
-        # SIPROUND;
-        # SIPROUND;
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
-
-        # v0 ^= b;
-        $v[0] = $v[0]->xorInt64($b);
-
-        // Flip the lower 8 bits of v2 which is ($v[4], $v[5]) in our implementation
-        # v2 ^= 0xff;
-        $v[2]->limbs[3] ^= 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 $v[0]
-            ->xorInt64($v[1])
-            ->xorInt64($v[2])
-            ->xorInt64($v[3])
-            ->toReverseString();
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param array<int, ParagonIE_Sodium_Core32_Int64> $v
+	 * @return array<int, ParagonIE_Sodium_Core32_Int64>
+	 */
+	public static function sipRound(array $v)
+	{
+		# v0 += v1;
+		$v[0] = $v[0]->addInt64($v[1]);
+
+		# v1 = ROTL(v1, 13);
+		$v[1] = $v[1]->rotateLeft(13);
+
+		#  v1 ^= v0;
+		$v[1] = $v[1]->xorInt64($v[0]);
+
+		#  v0=ROTL(v0,32);
+		$v[0] = $v[0]->rotateLeft(32);
+
+		# v2 += v3;
+		$v[2] = $v[2]->addInt64($v[3]);
+
+		# v3=ROTL(v3,16);
+		$v[3] = $v[3]->rotateLeft(16);
+
+		#  v3 ^= v2;
+		$v[3] = $v[3]->xorInt64($v[2]);
+
+		# v0 += v3;
+		$v[0] = $v[0]->addInt64($v[3]);
+
+		# v3=ROTL(v3,21);
+		$v[3] = $v[3]->rotateLeft(21);
+
+		# v3 ^= v0;
+		$v[3] = $v[3]->xorInt64($v[0]);
+
+		# v2 += v1;
+		$v[2] = $v[2]->addInt64($v[1]);
+
+		# v1=ROTL(v1,17);
+		$v[1] = $v[1]->rotateLeft(17);
+
+		#  v1 ^= v2;
+		$v[1] = $v[1]->xorInt64($v[2]);
+
+		# v2=ROTL(v2,32)
+		$v[2] = $v[2]->rotateLeft(32);
+
+		return $v;
+	}
+
+	/**
+	 * @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(
+			new ParagonIE_Sodium_Core32_Int64(
+				array(0x736f, 0x6d65, 0x7073, 0x6575)
+			),
+			new ParagonIE_Sodium_Core32_Int64(
+				array(0x646f, 0x7261, 0x6e64, 0x6f6d)
+			),
+			new ParagonIE_Sodium_Core32_Int64(
+				array(0x6c79, 0x6765, 0x6e65, 0x7261)
+			),
+			new ParagonIE_Sodium_Core32_Int64(
+				array(0x7465, 0x6462, 0x7974, 0x6573)
+			)
+		);
+
+		# u64 k0 = LOAD64_LE( k );
+		# u64 k1 = LOAD64_LE( k + 8 );
+		$k = array(
+			ParagonIE_Sodium_Core32_Int64::fromReverseString(
+				self::substr($key, 0, 8)
+			),
+			ParagonIE_Sodium_Core32_Int64::fromReverseString(
+				self::substr($key, 8, 8)
+			)
+		);
+
+		# b = ( ( u64 )inlen ) << 56;
+		$b = new ParagonIE_Sodium_Core32_Int64(
+			array(($inlen << 8) & 0xffff, 0, 0, 0)
+		);
+
+		# v3 ^= k1;
+		$v[3] = $v[3]->xorInt64($k[1]);
+		# v2 ^= k0;
+		$v[2] = $v[2]->xorInt64($k[0]);
+		# v1 ^= k1;
+		$v[1] = $v[1]->xorInt64($k[1]);
+		# v0 ^= k0;
+		$v[0] = $v[0]->xorInt64($k[0]);
+
+		$left = $inlen;
+		# for ( ; in != end; in += 8 )
+		while ($left >= 8) {
+			# m = LOAD64_LE( in );
+			$m = ParagonIE_Sodium_Core32_Int64::fromReverseString(
+				self::substr($in, 0, 8)
+			);
+
+			# v3 ^= m;
+			$v[3] = $v[3]->xorInt64($m);
+
+			# SIPROUND;
+			# SIPROUND;
+			$v = self::sipRound($v);
+			$v = self::sipRound($v);
+
+			# v0 ^= m;
+			$v[0] = $v[0]->xorInt64($m);
+
+			$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 = $b->orInt64(
+					ParagonIE_Sodium_Core32_Int64::fromInts(
+						0, self::chrToInt($in[6]) << 16
+					)
+				);
+			case 6:
+				$b = $b->orInt64(
+					ParagonIE_Sodium_Core32_Int64::fromInts(
+						0, self::chrToInt($in[5]) << 8
+					)
+				);
+			case 5:
+				$b = $b->orInt64(
+					ParagonIE_Sodium_Core32_Int64::fromInts(
+						0, self::chrToInt($in[4])
+					)
+				);
+			case 4:
+				$b = $b->orInt64(
+					ParagonIE_Sodium_Core32_Int64::fromInts(
+						self::chrToInt($in[3]) << 24, 0
+					)
+				);
+			case 3:
+				$b = $b->orInt64(
+					ParagonIE_Sodium_Core32_Int64::fromInts(
+						self::chrToInt($in[2]) << 16, 0
+					)
+				);
+			case 2:
+				$b = $b->orInt64(
+					ParagonIE_Sodium_Core32_Int64::fromInts(
+						self::chrToInt($in[1]) << 8, 0
+					)
+				);
+			case 1:
+				$b = $b->orInt64(
+					ParagonIE_Sodium_Core32_Int64::fromInts(
+						self::chrToInt($in[0]), 0
+					)
+				);
+			case 0:
+				break;
+		}
+
+		# v3 ^= b;
+		$v[3] = $v[3]->xorInt64($b);
+
+		# SIPROUND;
+		# SIPROUND;
+		$v = self::sipRound($v);
+		$v = self::sipRound($v);
+
+		# v0 ^= b;
+		$v[0] = $v[0]->xorInt64($b);
+
+		// Flip the lower 8 bits of v2 which is ($v[4], $v[5]) in our implementation
+		# v2 ^= 0xff;
+		$v[2]->limbs[3] ^= 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 $v[0]
+			->xorInt64($v[1])
+			->xorInt64($v[2])
+			->xorInt64($v[3])
+			->toReverseString();
+	}
 }

Spacing +57 added lines, -57 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core32_SipHash', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core32_SipHash', false ) ) {
     return;
 }
 
@@ -17,49 +17,49 @@ 
      * @param array<int, ParagonIE_Sodium_Core32_Int64> $v
      * @return array<int, ParagonIE_Sodium_Core32_Int64>
      */
-    public static function sipRound(array $v)
+    public static function sipRound( array $v )
     {
         # v0 += v1;
-        $v[0] = $v[0]->addInt64($v[1]);
+        $v[ 0 ] = $v[ 0 ]->addInt64( $v[ 1 ] );
 
         # v1 = ROTL(v1, 13);
-        $v[1] = $v[1]->rotateLeft(13);
+        $v[ 1 ] = $v[ 1 ]->rotateLeft( 13 );
 
         #  v1 ^= v0;
-        $v[1] = $v[1]->xorInt64($v[0]);
+        $v[ 1 ] = $v[ 1 ]->xorInt64( $v[ 0 ] );
 
         #  v0=ROTL(v0,32);
-        $v[0] = $v[0]->rotateLeft(32);
+        $v[ 0 ] = $v[ 0 ]->rotateLeft( 32 );
 
         # v2 += v3;
-        $v[2] = $v[2]->addInt64($v[3]);
+        $v[ 2 ] = $v[ 2 ]->addInt64( $v[ 3 ] );
 
         # v3=ROTL(v3,16);
-        $v[3] = $v[3]->rotateLeft(16);
+        $v[ 3 ] = $v[ 3 ]->rotateLeft( 16 );
 
         #  v3 ^= v2;
-        $v[3] = $v[3]->xorInt64($v[2]);
+        $v[ 3 ] = $v[ 3 ]->xorInt64( $v[ 2 ] );
 
         # v0 += v3;
-        $v[0] = $v[0]->addInt64($v[3]);
+        $v[ 0 ] = $v[ 0 ]->addInt64( $v[ 3 ] );
 
         # v3=ROTL(v3,21);
-        $v[3] = $v[3]->rotateLeft(21);
+        $v[ 3 ] = $v[ 3 ]->rotateLeft( 21 );
 
         # v3 ^= v0;
-        $v[3] = $v[3]->xorInt64($v[0]);
+        $v[ 3 ] = $v[ 3 ]->xorInt64( $v[ 0 ] );
 
         # v2 += v1;
-        $v[2] = $v[2]->addInt64($v[1]);
+        $v[ 2 ] = $v[ 2 ]->addInt64( $v[ 1 ] );
 
         # v1=ROTL(v1,17);
-        $v[1] = $v[1]->rotateLeft(17);
+        $v[ 1 ] = $v[ 1 ]->rotateLeft( 17 );
 
         #  v1 ^= v2;
-        $v[1] = $v[1]->xorInt64($v[2]);
+        $v[ 1 ] = $v[ 1 ]->xorInt64( $v[ 2 ] );
 
         # v2=ROTL(v2,32)
-        $v[2] = $v[2]->rotateLeft(32);
+        $v[ 2 ] = $v[ 2 ]->rotateLeft( 32 );
 
         return $v;
     }
@@ -73,9 +73,9 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sipHash24($in, $key)
+    public static function sipHash24( $in, $key )
     {
-        $inlen = self::strlen($in);
+        $inlen = self::strlen( $in );
 
         # /* "somepseudorandomlygeneratedbytes" */
         # u64 v0 = 0x736f6d6570736575ULL;
@@ -84,16 +84,16 @@ 
         # u64 v3 = 0x7465646279746573ULL;
         $v = array(
             new ParagonIE_Sodium_Core32_Int64(
-                array(0x736f, 0x6d65, 0x7073, 0x6575)
+                array( 0x736f, 0x6d65, 0x7073, 0x6575 )
             ),
             new ParagonIE_Sodium_Core32_Int64(
-                array(0x646f, 0x7261, 0x6e64, 0x6f6d)
+                array( 0x646f, 0x7261, 0x6e64, 0x6f6d )
             ),
             new ParagonIE_Sodium_Core32_Int64(
-                array(0x6c79, 0x6765, 0x6e65, 0x7261)
+                array( 0x6c79, 0x6765, 0x6e65, 0x7261 )
             ),
             new ParagonIE_Sodium_Core32_Int64(
-                array(0x7465, 0x6462, 0x7974, 0x6573)
+                array( 0x7465, 0x6462, 0x7974, 0x6573 )
             )
         );
 
@@ -101,47 +101,47 @@ 
         # u64 k1 = LOAD64_LE( k + 8 );
         $k = array(
             ParagonIE_Sodium_Core32_Int64::fromReverseString(
-                self::substr($key, 0, 8)
+                self::substr( $key, 0, 8 )
             ),
             ParagonIE_Sodium_Core32_Int64::fromReverseString(
-                self::substr($key, 8, 8)
+                self::substr( $key, 8, 8 )
             )
         );
 
         # b = ( ( u64 )inlen ) << 56;
         $b = new ParagonIE_Sodium_Core32_Int64(
-            array(($inlen << 8) & 0xffff, 0, 0, 0)
+            array( ( $inlen << 8 ) & 0xffff, 0, 0, 0 )
         );
 
         # v3 ^= k1;
-        $v[3] = $v[3]->xorInt64($k[1]);
+        $v[ 3 ] = $v[ 3 ]->xorInt64( $k[ 1 ] );
         # v2 ^= k0;
-        $v[2] = $v[2]->xorInt64($k[0]);
+        $v[ 2 ] = $v[ 2 ]->xorInt64( $k[ 0 ] );
         # v1 ^= k1;
-        $v[1] = $v[1]->xorInt64($k[1]);
+        $v[ 1 ] = $v[ 1 ]->xorInt64( $k[ 1 ] );
         # v0 ^= k0;
-        $v[0] = $v[0]->xorInt64($k[0]);
+        $v[ 0 ] = $v[ 0 ]->xorInt64( $k[ 0 ] );
 
         $left = $inlen;
         # for ( ; in != end; in += 8 )
-        while ($left >= 8) {
+        while ( $left >= 8 ) {
             # m = LOAD64_LE( in );
             $m = ParagonIE_Sodium_Core32_Int64::fromReverseString(
-                self::substr($in, 0, 8)
+                self::substr( $in, 0, 8 )
             );
 
             # v3 ^= m;
-            $v[3] = $v[3]->xorInt64($m);
+            $v[ 3 ] = $v[ 3 ]->xorInt64( $m );
 
             # SIPROUND;
             # SIPROUND;
-            $v = self::sipRound($v);
-            $v = self::sipRound($v);
+            $v = self::sipRound( $v );
+            $v = self::sipRound( $v );
 
             # v0 ^= m;
-            $v[0] = $v[0]->xorInt64($m);
+            $v[ 0 ] = $v[ 0 ]->xorInt64( $m );
 
-            $in = self::substr($in, 8);
+            $in = self::substr( $in, 8 );
             $left -= 8;
         }
 
@@ -156,47 +156,47 @@ 
         #     case 1: b |= ( ( u64 )in[ 0] ); break;
         #     case 0: break;
         # }
-        switch ($left) {
+        switch ( $left ) {
             case 7:
                 $b = $b->orInt64(
                     ParagonIE_Sodium_Core32_Int64::fromInts(
-                        0, self::chrToInt($in[6]) << 16
+                        0, self::chrToInt( $in[ 6 ] ) << 16
                     )
                 );
             case 6:
                 $b = $b->orInt64(
                     ParagonIE_Sodium_Core32_Int64::fromInts(
-                        0, self::chrToInt($in[5]) << 8
+                        0, self::chrToInt( $in[ 5 ] ) << 8
                     )
                 );
             case 5:
                 $b = $b->orInt64(
                     ParagonIE_Sodium_Core32_Int64::fromInts(
-                        0, self::chrToInt($in[4])
+                        0, self::chrToInt( $in[ 4 ] )
                     )
                 );
             case 4:
                 $b = $b->orInt64(
                     ParagonIE_Sodium_Core32_Int64::fromInts(
-                        self::chrToInt($in[3]) << 24, 0
+                        self::chrToInt( $in[ 3 ] ) << 24, 0
                     )
                 );
             case 3:
                 $b = $b->orInt64(
                     ParagonIE_Sodium_Core32_Int64::fromInts(
-                        self::chrToInt($in[2]) << 16, 0
+                        self::chrToInt( $in[ 2 ] ) << 16, 0
                     )
                 );
             case 2:
                 $b = $b->orInt64(
                     ParagonIE_Sodium_Core32_Int64::fromInts(
-                        self::chrToInt($in[1]) << 8, 0
+                        self::chrToInt( $in[ 1 ] ) << 8, 0
                     )
                 );
             case 1:
                 $b = $b->orInt64(
                     ParagonIE_Sodium_Core32_Int64::fromInts(
-                        self::chrToInt($in[0]), 0
+                        self::chrToInt( $in[ 0 ] ), 0
                     )
                 );
             case 0:
@@ -204,35 +204,35 @@ 
         }
 
         # v3 ^= b;
-        $v[3] = $v[3]->xorInt64($b);
+        $v[ 3 ] = $v[ 3 ]->xorInt64( $b );
 
         # SIPROUND;
         # SIPROUND;
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
+        $v = self::sipRound( $v );
+        $v = self::sipRound( $v );
 
         # v0 ^= b;
-        $v[0] = $v[0]->xorInt64($b);
+        $v[ 0 ] = $v[ 0 ]->xorInt64( $b );
 
         // Flip the lower 8 bits of v2 which is ($v[4], $v[5]) in our implementation
         # v2 ^= 0xff;
-        $v[2]->limbs[3] ^= 0xff;
+        $v[ 2 ]->limbs[ 3 ] ^= 0xff;
 
         # SIPROUND;
         # SIPROUND;
         # SIPROUND;
         # SIPROUND;
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
+        $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 $v[0]
-            ->xorInt64($v[1])
-            ->xorInt64($v[2])
-            ->xorInt64($v[3])
+        return $v[ 0 ]
+            ->xorInt64( $v[ 1 ] )
+            ->xorInt64( $v[ 2 ] )
+            ->xorInt64( $v[ 3 ] )
             ->toReverseString();
     }
 }

Braces +3 added lines, -6 removed lines

@@ -9,16 +9,14 @@ 
  *
  * Only uses 32-bit arithmetic, while the original SipHash used 64-bit integers
  */
-class ParagonIE_Sodium_Core32_SipHash extends ParagonIE_Sodium_Core32_Util
-{
+class ParagonIE_Sodium_Core32_SipHash extends ParagonIE_Sodium_Core32_Util {
     /**
      * @internal You should not use this directly from another application
      *
      * @param array<int, ParagonIE_Sodium_Core32_Int64> $v
      * @return array<int, ParagonIE_Sodium_Core32_Int64>
      */
-    public static function sipRound(array $v)
-    {
+    public static function sipRound(array $v) {
         # v0 += v1;
         $v[0] = $v[0]->addInt64($v[1]);
 
@@ -73,8 +71,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sipHash24($in, $key)
-    {
+    public static function sipHash24($in, $key) {
         $inlen = self::strlen($in);
 
         # /* "somepseudorandomlygeneratedbytes" */

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

Indentation +52 added lines, -52 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core32_XChaCha20', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,56 +9,56 @@ 
  */
 class ParagonIE_Sodium_Core32_XChaCha20 extends ParagonIE_Sodium_Core32_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_Core32_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_Core32_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 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_Core32_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_Core32_ChaCha20_Ctx(
+				self::hChaCha20(self::substr($nonce, 0, 16), $key),
+				self::substr($nonce, 16, 8),
+				$ic
+			),
+			$message
+		);
+	}
 }

Spacing +12 added lines, -12 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core32_XChaCha20', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core32_XChaCha20', false ) ) {
     return;
 }
 
@@ -19,20 +19,20 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function stream($len = 64, $nonce = '', $key = '')
+    public static function stream( $len = 64, $nonce = '', $key = '' )
     {
-        if (self::strlen($nonce) !== 24) {
-            throw new SodiumException('Nonce must be 24 bytes long');
+        if ( self::strlen( $nonce ) !== 24 ) {
+            throw new SodiumException( 'Nonce must be 24 bytes long' );
         }
         return self::encryptBytes(
             new ParagonIE_Sodium_Core32_ChaCha20_Ctx(
                 self::hChaCha20(
-                    self::substr($nonce, 0, 16),
+                    self::substr( $nonce, 0, 16 ),
                     $key
                 ),
-                self::substr($nonce, 16, 8)
+                self::substr( $nonce, 16, 8 )
             ),
-            str_repeat("\x00", $len)
+            str_repeat( "\x00", $len )
         );
     }
 
@@ -47,15 +47,15 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function streamXorIc($message, $nonce = '', $key = '', $ic = '')
+    public static function streamXorIc( $message, $nonce = '', $key = '', $ic = '' )
     {
-        if (self::strlen($nonce) !== 24) {
-            throw new SodiumException('Nonce must be 24 bytes long');
+        if ( self::strlen( $nonce ) !== 24 ) {
+            throw new SodiumException( 'Nonce must be 24 bytes long' );
         }
         return self::encryptBytes(
             new ParagonIE_Sodium_Core32_ChaCha20_Ctx(
-                self::hChaCha20(self::substr($nonce, 0, 16), $key),
-                self::substr($nonce, 16, 8),
+                self::hChaCha20( self::substr( $nonce, 0, 16 ), $key ),
+                self::substr( $nonce, 16, 8 ),
                 $ic
             ),
             $message

Braces +3 added lines, -6 removed lines

@@ -7,8 +7,7 @@ 
 /**
  * Class ParagonIE_Sodium_Core32_XChaCha20
  */
-class ParagonIE_Sodium_Core32_XChaCha20 extends ParagonIE_Sodium_Core32_HChaCha20
-{
+class ParagonIE_Sodium_Core32_XChaCha20 extends ParagonIE_Sodium_Core32_HChaCha20 {
     /**
      * @internal You should not use this directly from another application
      *
@@ -19,8 +18,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function stream($len = 64, $nonce = '', $key = '')
-    {
+    public static function stream($len = 64, $nonce = '', $key = '') {
         if (self::strlen($nonce) !== 24) {
             throw new SodiumException('Nonce must be 24 bytes long');
         }
@@ -47,8 +45,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function streamXorIc($message, $nonce = '', $key = '', $ic = '')
-    {
+    public static function streamXorIc($message, $nonce = '', $key = '', $ic = '') {
         if (self::strlen($nonce) !== 24) {
             throw new SodiumException('Nonce must be 24 bytes long');
         }

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

Indentation +334 added lines, -334 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core32_X25519', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,337 +9,337 @@ 
  */
 abstract class ParagonIE_Sodium_Core32_X25519 extends ParagonIE_Sodium_Core32_Curve25519
 {
-    /**
-     * Alters the objects passed to this method in place.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param ParagonIE_Sodium_Core32_Curve25519_Fe $f
-     * @param ParagonIE_Sodium_Core32_Curve25519_Fe $g
-     * @param int $b
-     * @return void
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedMethodCall
-     */
-    public static function fe_cswap(
-        ParagonIE_Sodium_Core32_Curve25519_Fe $f,
-        ParagonIE_Sodium_Core32_Curve25519_Fe $g,
-        $b = 0
-    ) {
-        $f0 = (int) $f[0]->toInt();
-        $f1 = (int) $f[1]->toInt();
-        $f2 = (int) $f[2]->toInt();
-        $f3 = (int) $f[3]->toInt();
-        $f4 = (int) $f[4]->toInt();
-        $f5 = (int) $f[5]->toInt();
-        $f6 = (int) $f[6]->toInt();
-        $f7 = (int) $f[7]->toInt();
-        $f8 = (int) $f[8]->toInt();
-        $f9 = (int) $f[9]->toInt();
-        $g0 = (int) $g[0]->toInt();
-        $g1 = (int) $g[1]->toInt();
-        $g2 = (int) $g[2]->toInt();
-        $g3 = (int) $g[3]->toInt();
-        $g4 = (int) $g[4]->toInt();
-        $g5 = (int) $g[5]->toInt();
-        $g6 = (int) $g[6]->toInt();
-        $g7 = (int) $g[7]->toInt();
-        $g8 = (int) $g[8]->toInt();
-        $g9 = (int) $g[9]->toInt();
-        $b = -$b;
-        /** @var int $x0 */
-        $x0 = ($f0 ^ $g0) & $b;
-        /** @var int $x1 */
-        $x1 = ($f1 ^ $g1) & $b;
-        /** @var int $x2 */
-        $x2 = ($f2 ^ $g2) & $b;
-        /** @var int $x3 */
-        $x3 = ($f3 ^ $g3) & $b;
-        /** @var int $x4 */
-        $x4 = ($f4 ^ $g4) & $b;
-        /** @var int $x5 */
-        $x5 = ($f5 ^ $g5) & $b;
-        /** @var int $x6 */
-        $x6 = ($f6 ^ $g6) & $b;
-        /** @var int $x7 */
-        $x7 = ($f7 ^ $g7) & $b;
-        /** @var int $x8 */
-        $x8 = ($f8 ^ $g8) & $b;
-        /** @var int $x9 */
-        $x9 = ($f9 ^ $g9) & $b;
-        $f[0] = ParagonIE_Sodium_Core32_Int32::fromInt($f0 ^ $x0);
-        $f[1] = ParagonIE_Sodium_Core32_Int32::fromInt($f1 ^ $x1);
-        $f[2] = ParagonIE_Sodium_Core32_Int32::fromInt($f2 ^ $x2);
-        $f[3] = ParagonIE_Sodium_Core32_Int32::fromInt($f3 ^ $x3);
-        $f[4] = ParagonIE_Sodium_Core32_Int32::fromInt($f4 ^ $x4);
-        $f[5] = ParagonIE_Sodium_Core32_Int32::fromInt($f5 ^ $x5);
-        $f[6] = ParagonIE_Sodium_Core32_Int32::fromInt($f6 ^ $x6);
-        $f[7] = ParagonIE_Sodium_Core32_Int32::fromInt($f7 ^ $x7);
-        $f[8] = ParagonIE_Sodium_Core32_Int32::fromInt($f8 ^ $x8);
-        $f[9] = ParagonIE_Sodium_Core32_Int32::fromInt($f9 ^ $x9);
-        $g[0] = ParagonIE_Sodium_Core32_Int32::fromInt($g0 ^ $x0);
-        $g[1] = ParagonIE_Sodium_Core32_Int32::fromInt($g1 ^ $x1);
-        $g[2] = ParagonIE_Sodium_Core32_Int32::fromInt($g2 ^ $x2);
-        $g[3] = ParagonIE_Sodium_Core32_Int32::fromInt($g3 ^ $x3);
-        $g[4] = ParagonIE_Sodium_Core32_Int32::fromInt($g4 ^ $x4);
-        $g[5] = ParagonIE_Sodium_Core32_Int32::fromInt($g5 ^ $x5);
-        $g[6] = ParagonIE_Sodium_Core32_Int32::fromInt($g6 ^ $x6);
-        $g[7] = ParagonIE_Sodium_Core32_Int32::fromInt($g7 ^ $x7);
-        $g[8] = ParagonIE_Sodium_Core32_Int32::fromInt($g8 ^ $x8);
-        $g[9] = ParagonIE_Sodium_Core32_Int32::fromInt($g9 ^ $x9);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param ParagonIE_Sodium_Core32_Curve25519_Fe $f
-     * @return ParagonIE_Sodium_Core32_Curve25519_Fe
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedAssignment
-     * @psalm-suppress MixedMethodCall
-     */
-    public static function fe_mul121666(ParagonIE_Sodium_Core32_Curve25519_Fe $f)
-    {
-        /** @var array<int, ParagonIE_Sodium_Core32_Int64> $h */
-        $h = array();
-        for ($i = 0; $i < 10; ++$i) {
-            $h[$i] = $f[$i]->toInt64()->mulInt(121666, 17);
-        }
-
-        $carry9 = $h[9]->addInt(1 << 24)->shiftRight(25);
-        $h[0] = $h[0]->addInt64($carry9->mulInt(19, 5));
-        $h[9] = $h[9]->subInt64($carry9->shiftLeft(25));
-
-        $carry1 = $h[1]->addInt(1 << 24)->shiftRight(25);
-        $h[2] = $h[2]->addInt64($carry1);
-        $h[1] = $h[1]->subInt64($carry1->shiftLeft(25));
-
-        $carry3 = $h[3]->addInt(1 << 24)->shiftRight(25);
-        $h[4] = $h[4]->addInt64($carry3);
-        $h[3] = $h[3]->subInt64($carry3->shiftLeft(25));
-
-        $carry5 = $h[5]->addInt(1 << 24)->shiftRight(25);
-        $h[6] = $h[6]->addInt64($carry5);
-        $h[5] = $h[5]->subInt64($carry5->shiftLeft(25));
-
-        $carry7 = $h[7]->addInt(1 << 24)->shiftRight(25);
-        $h[8] = $h[8]->addInt64($carry7);
-        $h[7] = $h[7]->subInt64($carry7->shiftLeft(25));
-
-        $carry0 = $h[0]->addInt(1 << 25)->shiftRight(26);
-        $h[1] = $h[1]->addInt64($carry0);
-        $h[0] = $h[0]->subInt64($carry0->shiftLeft(26));
-
-        $carry2 = $h[2]->addInt(1 << 25)->shiftRight(26);
-        $h[3] = $h[3]->addInt64($carry2);
-        $h[2] = $h[2]->subInt64($carry2->shiftLeft(26));
-
-        $carry4 = $h[4]->addInt(1 << 25)->shiftRight(26);
-        $h[5] = $h[5]->addInt64($carry4);
-        $h[4] = $h[4]->subInt64($carry4->shiftLeft(26));
-
-        $carry6 = $h[6]->addInt(1 << 25)->shiftRight(26);
-        $h[7] = $h[7]->addInt64($carry6);
-        $h[6] = $h[6]->subInt64($carry6->shiftLeft(26));
-
-        $carry8 = $h[8]->addInt(1 << 25)->shiftRight(26);
-        $h[9] = $h[9]->addInt64($carry8);
-        $h[8] = $h[8]->subInt64($carry8->shiftLeft(26));
-
-        for ($i = 0; $i < 10; ++$i) {
-            $h[$i] = $h[$i]->toInt32();
-        }
-        /** @var array<int, ParagonIE_Sodium_Core32_Int32> $h2 */
-        $h2 = $h;
-        return ParagonIE_Sodium_Core32_Curve25519_Fe::fromArray($h2);
-    }
-
-    /**
-     * @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;
-            /** @var int $swap */
-            $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 (string) self::fe_tobytes($x2);
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param ParagonIE_Sodium_Core32_Curve25519_Fe $edwardsY
-     * @param ParagonIE_Sodium_Core32_Curve25519_Fe $edwardsZ
-     * @return ParagonIE_Sodium_Core32_Curve25519_Fe
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function edwards_to_montgomery(
-        ParagonIE_Sodium_Core32_Curve25519_Fe $edwardsY,
-        ParagonIE_Sodium_Core32_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_Core32_Curve25519_Fe)
-                ||
-            !($A->Z instanceof ParagonIE_Sodium_Core32_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_Core32_Curve25519_Fe $f
+	 * @param ParagonIE_Sodium_Core32_Curve25519_Fe $g
+	 * @param int $b
+	 * @return void
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedMethodCall
+	 */
+	public static function fe_cswap(
+		ParagonIE_Sodium_Core32_Curve25519_Fe $f,
+		ParagonIE_Sodium_Core32_Curve25519_Fe $g,
+		$b = 0
+	) {
+		$f0 = (int) $f[0]->toInt();
+		$f1 = (int) $f[1]->toInt();
+		$f2 = (int) $f[2]->toInt();
+		$f3 = (int) $f[3]->toInt();
+		$f4 = (int) $f[4]->toInt();
+		$f5 = (int) $f[5]->toInt();
+		$f6 = (int) $f[6]->toInt();
+		$f7 = (int) $f[7]->toInt();
+		$f8 = (int) $f[8]->toInt();
+		$f9 = (int) $f[9]->toInt();
+		$g0 = (int) $g[0]->toInt();
+		$g1 = (int) $g[1]->toInt();
+		$g2 = (int) $g[2]->toInt();
+		$g3 = (int) $g[3]->toInt();
+		$g4 = (int) $g[4]->toInt();
+		$g5 = (int) $g[5]->toInt();
+		$g6 = (int) $g[6]->toInt();
+		$g7 = (int) $g[7]->toInt();
+		$g8 = (int) $g[8]->toInt();
+		$g9 = (int) $g[9]->toInt();
+		$b = -$b;
+		/** @var int $x0 */
+		$x0 = ($f0 ^ $g0) & $b;
+		/** @var int $x1 */
+		$x1 = ($f1 ^ $g1) & $b;
+		/** @var int $x2 */
+		$x2 = ($f2 ^ $g2) & $b;
+		/** @var int $x3 */
+		$x3 = ($f3 ^ $g3) & $b;
+		/** @var int $x4 */
+		$x4 = ($f4 ^ $g4) & $b;
+		/** @var int $x5 */
+		$x5 = ($f5 ^ $g5) & $b;
+		/** @var int $x6 */
+		$x6 = ($f6 ^ $g6) & $b;
+		/** @var int $x7 */
+		$x7 = ($f7 ^ $g7) & $b;
+		/** @var int $x8 */
+		$x8 = ($f8 ^ $g8) & $b;
+		/** @var int $x9 */
+		$x9 = ($f9 ^ $g9) & $b;
+		$f[0] = ParagonIE_Sodium_Core32_Int32::fromInt($f0 ^ $x0);
+		$f[1] = ParagonIE_Sodium_Core32_Int32::fromInt($f1 ^ $x1);
+		$f[2] = ParagonIE_Sodium_Core32_Int32::fromInt($f2 ^ $x2);
+		$f[3] = ParagonIE_Sodium_Core32_Int32::fromInt($f3 ^ $x3);
+		$f[4] = ParagonIE_Sodium_Core32_Int32::fromInt($f4 ^ $x4);
+		$f[5] = ParagonIE_Sodium_Core32_Int32::fromInt($f5 ^ $x5);
+		$f[6] = ParagonIE_Sodium_Core32_Int32::fromInt($f6 ^ $x6);
+		$f[7] = ParagonIE_Sodium_Core32_Int32::fromInt($f7 ^ $x7);
+		$f[8] = ParagonIE_Sodium_Core32_Int32::fromInt($f8 ^ $x8);
+		$f[9] = ParagonIE_Sodium_Core32_Int32::fromInt($f9 ^ $x9);
+		$g[0] = ParagonIE_Sodium_Core32_Int32::fromInt($g0 ^ $x0);
+		$g[1] = ParagonIE_Sodium_Core32_Int32::fromInt($g1 ^ $x1);
+		$g[2] = ParagonIE_Sodium_Core32_Int32::fromInt($g2 ^ $x2);
+		$g[3] = ParagonIE_Sodium_Core32_Int32::fromInt($g3 ^ $x3);
+		$g[4] = ParagonIE_Sodium_Core32_Int32::fromInt($g4 ^ $x4);
+		$g[5] = ParagonIE_Sodium_Core32_Int32::fromInt($g5 ^ $x5);
+		$g[6] = ParagonIE_Sodium_Core32_Int32::fromInt($g6 ^ $x6);
+		$g[7] = ParagonIE_Sodium_Core32_Int32::fromInt($g7 ^ $x7);
+		$g[8] = ParagonIE_Sodium_Core32_Int32::fromInt($g8 ^ $x8);
+		$g[9] = ParagonIE_Sodium_Core32_Int32::fromInt($g9 ^ $x9);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param ParagonIE_Sodium_Core32_Curve25519_Fe $f
+	 * @return ParagonIE_Sodium_Core32_Curve25519_Fe
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedAssignment
+	 * @psalm-suppress MixedMethodCall
+	 */
+	public static function fe_mul121666(ParagonIE_Sodium_Core32_Curve25519_Fe $f)
+	{
+		/** @var array<int, ParagonIE_Sodium_Core32_Int64> $h */
+		$h = array();
+		for ($i = 0; $i < 10; ++$i) {
+			$h[$i] = $f[$i]->toInt64()->mulInt(121666, 17);
+		}
+
+		$carry9 = $h[9]->addInt(1 << 24)->shiftRight(25);
+		$h[0] = $h[0]->addInt64($carry9->mulInt(19, 5));
+		$h[9] = $h[9]->subInt64($carry9->shiftLeft(25));
+
+		$carry1 = $h[1]->addInt(1 << 24)->shiftRight(25);
+		$h[2] = $h[2]->addInt64($carry1);
+		$h[1] = $h[1]->subInt64($carry1->shiftLeft(25));
+
+		$carry3 = $h[3]->addInt(1 << 24)->shiftRight(25);
+		$h[4] = $h[4]->addInt64($carry3);
+		$h[3] = $h[3]->subInt64($carry3->shiftLeft(25));
+
+		$carry5 = $h[5]->addInt(1 << 24)->shiftRight(25);
+		$h[6] = $h[6]->addInt64($carry5);
+		$h[5] = $h[5]->subInt64($carry5->shiftLeft(25));
+
+		$carry7 = $h[7]->addInt(1 << 24)->shiftRight(25);
+		$h[8] = $h[8]->addInt64($carry7);
+		$h[7] = $h[7]->subInt64($carry7->shiftLeft(25));
+
+		$carry0 = $h[0]->addInt(1 << 25)->shiftRight(26);
+		$h[1] = $h[1]->addInt64($carry0);
+		$h[0] = $h[0]->subInt64($carry0->shiftLeft(26));
+
+		$carry2 = $h[2]->addInt(1 << 25)->shiftRight(26);
+		$h[3] = $h[3]->addInt64($carry2);
+		$h[2] = $h[2]->subInt64($carry2->shiftLeft(26));
+
+		$carry4 = $h[4]->addInt(1 << 25)->shiftRight(26);
+		$h[5] = $h[5]->addInt64($carry4);
+		$h[4] = $h[4]->subInt64($carry4->shiftLeft(26));
+
+		$carry6 = $h[6]->addInt(1 << 25)->shiftRight(26);
+		$h[7] = $h[7]->addInt64($carry6);
+		$h[6] = $h[6]->subInt64($carry6->shiftLeft(26));
+
+		$carry8 = $h[8]->addInt(1 << 25)->shiftRight(26);
+		$h[9] = $h[9]->addInt64($carry8);
+		$h[8] = $h[8]->subInt64($carry8->shiftLeft(26));
+
+		for ($i = 0; $i < 10; ++$i) {
+			$h[$i] = $h[$i]->toInt32();
+		}
+		/** @var array<int, ParagonIE_Sodium_Core32_Int32> $h2 */
+		$h2 = $h;
+		return ParagonIE_Sodium_Core32_Curve25519_Fe::fromArray($h2);
+	}
+
+	/**
+	 * @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;
+			/** @var int $swap */
+			$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 (string) self::fe_tobytes($x2);
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param ParagonIE_Sodium_Core32_Curve25519_Fe $edwardsY
+	 * @param ParagonIE_Sodium_Core32_Curve25519_Fe $edwardsZ
+	 * @return ParagonIE_Sodium_Core32_Curve25519_Fe
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function edwards_to_montgomery(
+		ParagonIE_Sodium_Core32_Curve25519_Fe $edwardsY,
+		ParagonIE_Sodium_Core32_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_Core32_Curve25519_Fe)
+				||
+			!($A->Z instanceof ParagonIE_Sodium_Core32_Curve25519_Fe)
+		) {
+			throw new TypeError('Null points encountered');
+		}
+		$pk = self::edwards_to_montgomery($A->Y, $A->Z);
+		return self::fe_tobytes($pk);
+	}
 }

Spacing +137 added lines, -137 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core32_X25519', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core32_X25519', false ) ) {
     return;
 }
 
@@ -27,67 +27,67 @@ 
         ParagonIE_Sodium_Core32_Curve25519_Fe $g,
         $b = 0
     ) {
-        $f0 = (int) $f[0]->toInt();
-        $f1 = (int) $f[1]->toInt();
-        $f2 = (int) $f[2]->toInt();
-        $f3 = (int) $f[3]->toInt();
-        $f4 = (int) $f[4]->toInt();
-        $f5 = (int) $f[5]->toInt();
-        $f6 = (int) $f[6]->toInt();
-        $f7 = (int) $f[7]->toInt();
-        $f8 = (int) $f[8]->toInt();
-        $f9 = (int) $f[9]->toInt();
-        $g0 = (int) $g[0]->toInt();
-        $g1 = (int) $g[1]->toInt();
-        $g2 = (int) $g[2]->toInt();
-        $g3 = (int) $g[3]->toInt();
-        $g4 = (int) $g[4]->toInt();
-        $g5 = (int) $g[5]->toInt();
-        $g6 = (int) $g[6]->toInt();
-        $g7 = (int) $g[7]->toInt();
-        $g8 = (int) $g[8]->toInt();
-        $g9 = (int) $g[9]->toInt();
+        $f0 = (int)$f[ 0 ]->toInt();
+        $f1 = (int)$f[ 1 ]->toInt();
+        $f2 = (int)$f[ 2 ]->toInt();
+        $f3 = (int)$f[ 3 ]->toInt();
+        $f4 = (int)$f[ 4 ]->toInt();
+        $f5 = (int)$f[ 5 ]->toInt();
+        $f6 = (int)$f[ 6 ]->toInt();
+        $f7 = (int)$f[ 7 ]->toInt();
+        $f8 = (int)$f[ 8 ]->toInt();
+        $f9 = (int)$f[ 9 ]->toInt();
+        $g0 = (int)$g[ 0 ]->toInt();
+        $g1 = (int)$g[ 1 ]->toInt();
+        $g2 = (int)$g[ 2 ]->toInt();
+        $g3 = (int)$g[ 3 ]->toInt();
+        $g4 = (int)$g[ 4 ]->toInt();
+        $g5 = (int)$g[ 5 ]->toInt();
+        $g6 = (int)$g[ 6 ]->toInt();
+        $g7 = (int)$g[ 7 ]->toInt();
+        $g8 = (int)$g[ 8 ]->toInt();
+        $g9 = (int)$g[ 9 ]->toInt();
         $b = -$b;
         /** @var int $x0 */
-        $x0 = ($f0 ^ $g0) & $b;
+        $x0 = ( $f0 ^ $g0 ) & $b;
         /** @var int $x1 */
-        $x1 = ($f1 ^ $g1) & $b;
+        $x1 = ( $f1 ^ $g1 ) & $b;
         /** @var int $x2 */
-        $x2 = ($f2 ^ $g2) & $b;
+        $x2 = ( $f2 ^ $g2 ) & $b;
         /** @var int $x3 */
-        $x3 = ($f3 ^ $g3) & $b;
+        $x3 = ( $f3 ^ $g3 ) & $b;
         /** @var int $x4 */
-        $x4 = ($f4 ^ $g4) & $b;
+        $x4 = ( $f4 ^ $g4 ) & $b;
         /** @var int $x5 */
-        $x5 = ($f5 ^ $g5) & $b;
+        $x5 = ( $f5 ^ $g5 ) & $b;
         /** @var int $x6 */
-        $x6 = ($f6 ^ $g6) & $b;
+        $x6 = ( $f6 ^ $g6 ) & $b;
         /** @var int $x7 */
-        $x7 = ($f7 ^ $g7) & $b;
+        $x7 = ( $f7 ^ $g7 ) & $b;
         /** @var int $x8 */
-        $x8 = ($f8 ^ $g8) & $b;
+        $x8 = ( $f8 ^ $g8 ) & $b;
         /** @var int $x9 */
-        $x9 = ($f9 ^ $g9) & $b;
-        $f[0] = ParagonIE_Sodium_Core32_Int32::fromInt($f0 ^ $x0);
-        $f[1] = ParagonIE_Sodium_Core32_Int32::fromInt($f1 ^ $x1);
-        $f[2] = ParagonIE_Sodium_Core32_Int32::fromInt($f2 ^ $x2);
-        $f[3] = ParagonIE_Sodium_Core32_Int32::fromInt($f3 ^ $x3);
-        $f[4] = ParagonIE_Sodium_Core32_Int32::fromInt($f4 ^ $x4);
-        $f[5] = ParagonIE_Sodium_Core32_Int32::fromInt($f5 ^ $x5);
-        $f[6] = ParagonIE_Sodium_Core32_Int32::fromInt($f6 ^ $x6);
-        $f[7] = ParagonIE_Sodium_Core32_Int32::fromInt($f7 ^ $x7);
-        $f[8] = ParagonIE_Sodium_Core32_Int32::fromInt($f8 ^ $x8);
-        $f[9] = ParagonIE_Sodium_Core32_Int32::fromInt($f9 ^ $x9);
-        $g[0] = ParagonIE_Sodium_Core32_Int32::fromInt($g0 ^ $x0);
-        $g[1] = ParagonIE_Sodium_Core32_Int32::fromInt($g1 ^ $x1);
-        $g[2] = ParagonIE_Sodium_Core32_Int32::fromInt($g2 ^ $x2);
-        $g[3] = ParagonIE_Sodium_Core32_Int32::fromInt($g3 ^ $x3);
-        $g[4] = ParagonIE_Sodium_Core32_Int32::fromInt($g4 ^ $x4);
-        $g[5] = ParagonIE_Sodium_Core32_Int32::fromInt($g5 ^ $x5);
-        $g[6] = ParagonIE_Sodium_Core32_Int32::fromInt($g6 ^ $x6);
-        $g[7] = ParagonIE_Sodium_Core32_Int32::fromInt($g7 ^ $x7);
-        $g[8] = ParagonIE_Sodium_Core32_Int32::fromInt($g8 ^ $x8);
-        $g[9] = ParagonIE_Sodium_Core32_Int32::fromInt($g9 ^ $x9);
+        $x9 = ( $f9 ^ $g9 ) & $b;
+        $f[ 0 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $f0 ^ $x0 );
+        $f[ 1 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $f1 ^ $x1 );
+        $f[ 2 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $f2 ^ $x2 );
+        $f[ 3 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $f3 ^ $x3 );
+        $f[ 4 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $f4 ^ $x4 );
+        $f[ 5 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $f5 ^ $x5 );
+        $f[ 6 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $f6 ^ $x6 );
+        $f[ 7 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $f7 ^ $x7 );
+        $f[ 8 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $f8 ^ $x8 );
+        $f[ 9 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $f9 ^ $x9 );
+        $g[ 0 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $g0 ^ $x0 );
+        $g[ 1 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $g1 ^ $x1 );
+        $g[ 2 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $g2 ^ $x2 );
+        $g[ 3 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $g3 ^ $x3 );
+        $g[ 4 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $g4 ^ $x4 );
+        $g[ 5 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $g5 ^ $x5 );
+        $g[ 6 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $g6 ^ $x6 );
+        $g[ 7 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $g7 ^ $x7 );
+        $g[ 8 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $g8 ^ $x8 );
+        $g[ 9 ] = ParagonIE_Sodium_Core32_Int32::fromInt( $g9 ^ $x9 );
     }
 
     /**
@@ -100,60 +100,60 @@ 
      * @psalm-suppress MixedAssignment
      * @psalm-suppress MixedMethodCall
      */
-    public static function fe_mul121666(ParagonIE_Sodium_Core32_Curve25519_Fe $f)
+    public static function fe_mul121666( ParagonIE_Sodium_Core32_Curve25519_Fe $f )
     {
         /** @var array<int, ParagonIE_Sodium_Core32_Int64> $h */
         $h = array();
-        for ($i = 0; $i < 10; ++$i) {
-            $h[$i] = $f[$i]->toInt64()->mulInt(121666, 17);
+        for ( $i = 0; $i < 10; ++$i ) {
+            $h[ $i ] = $f[ $i ]->toInt64()->mulInt( 121666, 17 );
         }
 
-        $carry9 = $h[9]->addInt(1 << 24)->shiftRight(25);
-        $h[0] = $h[0]->addInt64($carry9->mulInt(19, 5));
-        $h[9] = $h[9]->subInt64($carry9->shiftLeft(25));
+        $carry9 = $h[ 9 ]->addInt( 1 << 24 )->shiftRight( 25 );
+        $h[ 0 ] = $h[ 0 ]->addInt64( $carry9->mulInt( 19, 5 ) );
+        $h[ 9 ] = $h[ 9 ]->subInt64( $carry9->shiftLeft( 25 ) );
 
-        $carry1 = $h[1]->addInt(1 << 24)->shiftRight(25);
-        $h[2] = $h[2]->addInt64($carry1);
-        $h[1] = $h[1]->subInt64($carry1->shiftLeft(25));
+        $carry1 = $h[ 1 ]->addInt( 1 << 24 )->shiftRight( 25 );
+        $h[ 2 ] = $h[ 2 ]->addInt64( $carry1 );
+        $h[ 1 ] = $h[ 1 ]->subInt64( $carry1->shiftLeft( 25 ) );
 
-        $carry3 = $h[3]->addInt(1 << 24)->shiftRight(25);
-        $h[4] = $h[4]->addInt64($carry3);
-        $h[3] = $h[3]->subInt64($carry3->shiftLeft(25));
+        $carry3 = $h[ 3 ]->addInt( 1 << 24 )->shiftRight( 25 );
+        $h[ 4 ] = $h[ 4 ]->addInt64( $carry3 );
+        $h[ 3 ] = $h[ 3 ]->subInt64( $carry3->shiftLeft( 25 ) );
 
-        $carry5 = $h[5]->addInt(1 << 24)->shiftRight(25);
-        $h[6] = $h[6]->addInt64($carry5);
-        $h[5] = $h[5]->subInt64($carry5->shiftLeft(25));
+        $carry5 = $h[ 5 ]->addInt( 1 << 24 )->shiftRight( 25 );
+        $h[ 6 ] = $h[ 6 ]->addInt64( $carry5 );
+        $h[ 5 ] = $h[ 5 ]->subInt64( $carry5->shiftLeft( 25 ) );
 
-        $carry7 = $h[7]->addInt(1 << 24)->shiftRight(25);
-        $h[8] = $h[8]->addInt64($carry7);
-        $h[7] = $h[7]->subInt64($carry7->shiftLeft(25));
+        $carry7 = $h[ 7 ]->addInt( 1 << 24 )->shiftRight( 25 );
+        $h[ 8 ] = $h[ 8 ]->addInt64( $carry7 );
+        $h[ 7 ] = $h[ 7 ]->subInt64( $carry7->shiftLeft( 25 ) );
 
-        $carry0 = $h[0]->addInt(1 << 25)->shiftRight(26);
-        $h[1] = $h[1]->addInt64($carry0);
-        $h[0] = $h[0]->subInt64($carry0->shiftLeft(26));
+        $carry0 = $h[ 0 ]->addInt( 1 << 25 )->shiftRight( 26 );
+        $h[ 1 ] = $h[ 1 ]->addInt64( $carry0 );
+        $h[ 0 ] = $h[ 0 ]->subInt64( $carry0->shiftLeft( 26 ) );
 
-        $carry2 = $h[2]->addInt(1 << 25)->shiftRight(26);
-        $h[3] = $h[3]->addInt64($carry2);
-        $h[2] = $h[2]->subInt64($carry2->shiftLeft(26));
+        $carry2 = $h[ 2 ]->addInt( 1 << 25 )->shiftRight( 26 );
+        $h[ 3 ] = $h[ 3 ]->addInt64( $carry2 );
+        $h[ 2 ] = $h[ 2 ]->subInt64( $carry2->shiftLeft( 26 ) );
 
-        $carry4 = $h[4]->addInt(1 << 25)->shiftRight(26);
-        $h[5] = $h[5]->addInt64($carry4);
-        $h[4] = $h[4]->subInt64($carry4->shiftLeft(26));
+        $carry4 = $h[ 4 ]->addInt( 1 << 25 )->shiftRight( 26 );
+        $h[ 5 ] = $h[ 5 ]->addInt64( $carry4 );
+        $h[ 4 ] = $h[ 4 ]->subInt64( $carry4->shiftLeft( 26 ) );
 
-        $carry6 = $h[6]->addInt(1 << 25)->shiftRight(26);
-        $h[7] = $h[7]->addInt64($carry6);
-        $h[6] = $h[6]->subInt64($carry6->shiftLeft(26));
+        $carry6 = $h[ 6 ]->addInt( 1 << 25 )->shiftRight( 26 );
+        $h[ 7 ] = $h[ 7 ]->addInt64( $carry6 );
+        $h[ 6 ] = $h[ 6 ]->subInt64( $carry6->shiftLeft( 26 ) );
 
-        $carry8 = $h[8]->addInt(1 << 25)->shiftRight(26);
-        $h[9] = $h[9]->addInt64($carry8);
-        $h[8] = $h[8]->subInt64($carry8->shiftLeft(26));
+        $carry8 = $h[ 8 ]->addInt( 1 << 25 )->shiftRight( 26 );
+        $h[ 9 ] = $h[ 9 ]->addInt64( $carry8 );
+        $h[ 8 ] = $h[ 8 ]->subInt64( $carry8->shiftLeft( 26 ) );
 
-        for ($i = 0; $i < 10; ++$i) {
-            $h[$i] = $h[$i]->toInt32();
+        for ( $i = 0; $i < 10; ++$i ) {
+            $h[ $i ] = $h[ $i ]->toInt32();
         }
         /** @var array<int, ParagonIE_Sodium_Core32_Int32> $h2 */
         $h2 = $h;
-        return ParagonIE_Sodium_Core32_Curve25519_Fe::fromArray($h2);
+        return ParagonIE_Sodium_Core32_Curve25519_Fe::fromArray( $h2 );
     }
 
     /**
@@ -167,27 +167,27 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function crypto_scalarmult_curve25519_ref10($n, $p)
+    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[ 0 ] = self::intToChr(
+            self::chrToInt( $e[ 0 ] ) & 248
         );
         # e[31] &= 127;
         # e[31] |= 64;
-        $e[31] = self::intToChr(
-            (self::chrToInt($e[31]) & 127) | 64
+        $e[ 31 ] = self::intToChr(
+            ( self::chrToInt( $e[ 31 ] ) & 127 ) | 64
         );
         # fe_frombytes(x1,p);
-        $x1 = self::fe_frombytes($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);
+        $x3 = self::fe_copy( $x1 );
         # fe_1(z3);
         $z3 = self::fe_1();
 
@@ -196,12 +196,12 @@ 
         $swap = 0;
 
         # for (pos = 254;pos >= 0;--pos) {
-        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);
+                    $e[ (int)floor( $pos / 8 ) ]
+                ) >> ( $pos & 7 );
             # b &= 1;
             $b &= 1;
 
@@ -209,83 +209,83 @@ 
             $swap ^= $b;
 
             # fe_cswap(x2,x3,swap);
-            self::fe_cswap($x2, $x3, $swap);
+            self::fe_cswap( $x2, $x3, $swap );
 
             # fe_cswap(z2,z3,swap);
-            self::fe_cswap($z2, $z3, $swap);
+            self::fe_cswap( $z2, $z3, $swap );
 
             # swap = b;
             /** @var int $swap */
             $swap = $b;
 
             # fe_sub(tmp0,x3,z3);
-            $tmp0 = self::fe_sub($x3, $z3);
+            $tmp0 = self::fe_sub( $x3, $z3 );
 
             # fe_sub(tmp1,x2,z2);
-            $tmp1 = self::fe_sub($x2, $z2);
+            $tmp1 = self::fe_sub( $x2, $z2 );
 
             # fe_add(x2,x2,z2);
-            $x2 = self::fe_add($x2, $z2);
+            $x2 = self::fe_add( $x2, $z2 );
 
             # fe_add(z2,x3,z3);
-            $z2 = self::fe_add($x3, $z3);
+            $z2 = self::fe_add( $x3, $z3 );
 
             # fe_mul(z3,tmp0,x2);
-            $z3 = self::fe_mul($tmp0, $x2);
+            $z3 = self::fe_mul( $tmp0, $x2 );
 
             # fe_mul(z2,z2,tmp1);
-            $z2 = self::fe_mul($z2, $tmp1);
+            $z2 = self::fe_mul( $z2, $tmp1 );
 
             # fe_sq(tmp0,tmp1);
-            $tmp0 = self::fe_sq($tmp1);
+            $tmp0 = self::fe_sq( $tmp1 );
 
             # fe_sq(tmp1,x2);
-            $tmp1 = self::fe_sq($x2);
+            $tmp1 = self::fe_sq( $x2 );
 
             # fe_add(x3,z3,z2);
-            $x3 = self::fe_add($z3, $z2);
+            $x3 = self::fe_add( $z3, $z2 );
 
             # fe_sub(z2,z3,z2);
-            $z2 = self::fe_sub($z3, $z2);
+            $z2 = self::fe_sub( $z3, $z2 );
 
             # fe_mul(x2,tmp1,tmp0);
-            $x2 = self::fe_mul($tmp1, $tmp0);
+            $x2 = self::fe_mul( $tmp1, $tmp0 );
 
             # fe_sub(tmp1,tmp1,tmp0);
-            $tmp1 = self::fe_sub($tmp1, $tmp0);
+            $tmp1 = self::fe_sub( $tmp1, $tmp0 );
 
             # fe_sq(z2,z2);
-            $z2 = self::fe_sq($z2);
+            $z2 = self::fe_sq( $z2 );
 
             # fe_mul121666(z3,tmp1);
-            $z3 = self::fe_mul121666($tmp1);
+            $z3 = self::fe_mul121666( $tmp1 );
 
             # fe_sq(x3,x3);
-            $x3 = self::fe_sq($x3);
+            $x3 = self::fe_sq( $x3 );
 
             # fe_add(tmp0,tmp0,z3);
-            $tmp0 = self::fe_add($tmp0, $z3);
+            $tmp0 = self::fe_add( $tmp0, $z3 );
 
             # fe_mul(z3,x1,z2);
-            $z3 = self::fe_mul($x1, $z2);
+            $z3 = self::fe_mul( $x1, $z2 );
 
             # fe_mul(z2,tmp1,tmp0);
-            $z2 = self::fe_mul($tmp1, $tmp0);
+            $z2 = self::fe_mul( $tmp1, $tmp0 );
         }
 
         # fe_cswap(x2,x3,swap);
-        self::fe_cswap($x2, $x3, $swap);
+        self::fe_cswap( $x2, $x3, $swap );
 
         # fe_cswap(z2,z3,swap);
-        self::fe_cswap($z2, $z3, $swap);
+        self::fe_cswap( $z2, $z3, $swap );
 
         # fe_invert(z2,z2);
-        $z2 = self::fe_invert($z2);
+        $z2 = self::fe_invert( $z2 );
 
         # fe_mul(x2,x2,z2);
-        $x2 = self::fe_mul($x2, $z2);
+        $x2 = self::fe_mul( $x2, $z2 );
         # fe_tobytes(q,x2);
-        return (string) self::fe_tobytes($x2);
+        return (string)self::fe_tobytes( $x2 );
     }
 
     /**
@@ -301,10 +301,10 @@ 
         ParagonIE_Sodium_Core32_Curve25519_Fe $edwardsY,
         ParagonIE_Sodium_Core32_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);
+        $tempX = self::fe_add( $edwardsZ, $edwardsY );
+        $tempZ = self::fe_sub( $edwardsZ, $edwardsY );
+        $tempZ = self::fe_invert( $tempZ );
+        return self::fe_mul( $tempX, $tempZ );
     }
 
     /**
@@ -315,31 +315,31 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function crypto_scalarmult_curve25519_ref10_base($n)
+    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[ 0 ] = self::intToChr(
+            self::chrToInt( $e[ 0 ] ) & 248
         );
 
         # e[31] &= 127;
         # e[31] |= 64;
-        $e[31] = self::intToChr(
-            (self::chrToInt($e[31]) & 127) | 64
+        $e[ 31 ] = self::intToChr(
+            ( self::chrToInt( $e[ 31 ] ) & 127 ) | 64
         );
 
-        $A = self::ge_scalarmult_base($e);
+        $A = self::ge_scalarmult_base( $e );
         if (
-            !($A->Y instanceof ParagonIE_Sodium_Core32_Curve25519_Fe)
+            ! ( $A->Y instanceof ParagonIE_Sodium_Core32_Curve25519_Fe )
                 ||
-            !($A->Z instanceof ParagonIE_Sodium_Core32_Curve25519_Fe)
+            ! ( $A->Z instanceof ParagonIE_Sodium_Core32_Curve25519_Fe )
         ) {
-            throw new TypeError('Null points encountered');
+            throw new TypeError( 'Null points encountered' );
         }
-        $pk = self::edwards_to_montgomery($A->Y, $A->Z);
-        return self::fe_tobytes($pk);
+        $pk = self::edwards_to_montgomery( $A->Y, $A->Z );
+        return self::fe_tobytes( $pk );
     }
 }

Braces +4 added lines, -8 removed lines

@@ -7,8 +7,7 @@ 
 /**
  * Class ParagonIE_Sodium_Core32_X25519
  */
-abstract class ParagonIE_Sodium_Core32_X25519 extends ParagonIE_Sodium_Core32_Curve25519
-{
+abstract class ParagonIE_Sodium_Core32_X25519 extends ParagonIE_Sodium_Core32_Curve25519 {
     /**
      * Alters the objects passed to this method in place.
      *
@@ -100,8 +99,7 @@ 
      * @psalm-suppress MixedAssignment
      * @psalm-suppress MixedMethodCall
      */
-    public static function fe_mul121666(ParagonIE_Sodium_Core32_Curve25519_Fe $f)
-    {
+    public static function fe_mul121666(ParagonIE_Sodium_Core32_Curve25519_Fe $f) {
         /** @var array<int, ParagonIE_Sodium_Core32_Int64> $h */
         $h = array();
         for ($i = 0; $i < 10; ++$i) {
@@ -167,8 +165,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function crypto_scalarmult_curve25519_ref10($n, $p)
-    {
+    public static function crypto_scalarmult_curve25519_ref10($n, $p) {
         # for (i = 0;i < 32;++i) e[i] = n[i];
         $e = '' . $n;
         # e[0] &= 248;
@@ -315,8 +312,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function crypto_scalarmult_curve25519_ref10_base($n)
-    {
+    public static function crypto_scalarmult_curve25519_ref10_base($n) {
         # for (i = 0;i < 32;++i) e[i] = n[i];
         $e = '' . $n;
 

vendor/paragonie/sodium_compat/src/Core32/Int32.php

Indentation +859 added lines, -859 removed lines

@@ -9,863 +9,863 @@
  */
 class ParagonIE_Sodium_Core32_Int32
 {
-    /**
-     * @var array<int, int> - two 16-bit integers
-     *
-     * 0 is the higher 16 bits
-     * 1 is the lower 16 bits
-     */
-    public $limbs = array(0, 0);
-
-    /**
-     * @var int
-     */
-    public $overflow = 0;
-
-    /**
-     * @var bool
-     */
-    public $unsignedInt = false;
-
-    /**
-     * ParagonIE_Sodium_Core32_Int32 constructor.
-     * @param array $array
-     * @param bool $unsignedInt
-     */
-    public function __construct($array = array(0, 0), $unsignedInt = false)
-    {
-        $this->limbs = array(
-            (int) $array[0],
-            (int) $array[1]
-        );
-        $this->overflow = 0;
-        $this->unsignedInt = $unsignedInt;
-    }
-
-    /**
-     * Adds two int32 objects
-     *
-     * @param ParagonIE_Sodium_Core32_Int32 $addend
-     * @return ParagonIE_Sodium_Core32_Int32
-     */
-    public function addInt32(ParagonIE_Sodium_Core32_Int32 $addend)
-    {
-        $i0 = $this->limbs[0];
-        $i1 = $this->limbs[1];
-        $j0 = $addend->limbs[0];
-        $j1 = $addend->limbs[1];
-
-        $r1 = $i1 + ($j1 & 0xffff);
-        $carry = $r1 >> 16;
-
-        $r0 = $i0 + ($j0 & 0xffff) + $carry;
-        $carry = $r0 >> 16;
-
-        $r0 &= 0xffff;
-        $r1 &= 0xffff;
-
-        $return = new ParagonIE_Sodium_Core32_Int32(
-            array($r0, $r1)
-        );
-        $return->overflow = $carry;
-        $return->unsignedInt = $this->unsignedInt;
-        return $return;
-    }
-
-    /**
-     * Adds a normal integer to an int32 object
-     *
-     * @param int $int
-     * @return ParagonIE_Sodium_Core32_Int32
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public function addInt($int)
-    {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
-        /** @var int $int */
-        $int = (int) $int;
-
-        $int = (int) $int;
-
-        $i0 = $this->limbs[0];
-        $i1 = $this->limbs[1];
-
-        $r1 = $i1 + ($int & 0xffff);
-        $carry = $r1 >> 16;
-
-        $r0 = $i0 + (($int >> 16) & 0xffff) + $carry;
-        $carry = $r0 >> 16;
-        $r0 &= 0xffff;
-        $r1 &= 0xffff;
-        $return = new ParagonIE_Sodium_Core32_Int32(
-            array($r0, $r1)
-        );
-        $return->overflow = $carry;
-        $return->unsignedInt = $this->unsignedInt;
-        return $return;
-    }
-
-    /**
-     * @param int $b
-     * @return int
-     */
-    public function compareInt($b = 0)
-    {
-        $gt = 0;
-        $eq = 1;
-
-        $i = 2;
-        $j = 0;
-        while ($i > 0) {
-            --$i;
-            /** @var int $x1 */
-            $x1 = $this->limbs[$i];
-            /** @var int $x2 */
-            $x2 = ($b >> ($j << 4)) & 0xffff;
-            /** @var int $gt */
-            $gt |= (($x2 - $x1) >> 8) & $eq;
-            /** @var int $eq */
-            $eq &= (($x2 ^ $x1) - 1) >> 8;
-        }
-        return ($gt + $gt - $eq) + 1;
-    }
-
-    /**
-     * @param int $m
-     * @return ParagonIE_Sodium_Core32_Int32
-     */
-    public function mask($m = 0)
-    {
-        /** @var int $hi */
-        $hi = ($m >> 16) & 0xffff;
-        /** @var int $lo */
-        $lo = ($m & 0xffff);
-        return new ParagonIE_Sodium_Core32_Int32(
-            array(
-                (int) ($this->limbs[0] & $hi),
-                (int) ($this->limbs[1] & $lo)
-            ),
-            $this->unsignedInt
-        );
-    }
-
-    /**
-     * @param array<int, int> $a
-     * @param array<int, int> $b
-     * @param int $baseLog2
-     * @return array<int, int>
-     */
-    public function multiplyLong(array $a, array $b, $baseLog2 = 16)
-    {
-        $a_l = count($a);
-        $b_l = count($b);
-        /** @var array<int, int> $r */
-        $r = array_fill(0, $a_l + $b_l + 1, 0);
-        $base = 1 << $baseLog2;
-        for ($i = 0; $i < $a_l; ++$i) {
-            $a_i = $a[$i];
-            for ($j = 0; $j < $a_l; ++$j) {
-                $b_j = $b[$j];
-                $product = ($a_i * $b_j) + $r[$i + $j];
-                $carry = ($product >> $baseLog2 & 0xffff);
-                $r[$i + $j] = ($product - (int) ($carry * $base)) & 0xffff;
-                $r[$i + $j + 1] += $carry;
-            }
-        }
-        return array_slice($r, 0, 5);
-    }
-
-    /**
-     * @param int $int
-     * @return ParagonIE_Sodium_Core32_Int32
-     */
-    public function mulIntFast($int)
-    {
-        // Handle negative numbers
-        $aNeg = ($this->limbs[0] >> 15) & 1;
-        $bNeg = ($int >> 31) & 1;
-        $a = array_reverse($this->limbs);
-        $b = array(
-            $int & 0xffff,
-            ($int >> 16) & 0xffff
-        );
-        if ($aNeg) {
-            for ($i = 0; $i < 2; ++$i) {
-                $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;
-            }
-            ++$a[0];
-        }
-        if ($bNeg) {
-            for ($i = 0; $i < 2; ++$i) {
-                $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;
-            }
-            ++$b[0];
-        }
-        // Multiply
-        $res = $this->multiplyLong($a, $b);
-
-        // Re-apply negation to results
-        if ($aNeg !== $bNeg) {
-            for ($i = 0; $i < 2; ++$i) {
-                $res[$i] = (0xffff ^ $res[$i]) & 0xffff;
-            }
-            // Handle integer overflow
-            $c = 1;
-            for ($i = 0; $i < 2; ++$i) {
-                $res[$i] += $c;
-                $c = $res[$i] >> 16;
-                $res[$i] &= 0xffff;
-            }
-        }
-
-        // Return our values
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->limbs = array(
-            $res[1] & 0xffff,
-            $res[0] & 0xffff
-        );
-        if (count($res) > 2) {
-            $return->overflow = $res[2] & 0xffff;
-        }
-        $return->unsignedInt = $this->unsignedInt;
-        return $return;
-    }
-
-    /**
-     * @param ParagonIE_Sodium_Core32_Int32 $right
-     * @return ParagonIE_Sodium_Core32_Int32
-     */
-    public function mulInt32Fast(ParagonIE_Sodium_Core32_Int32 $right)
-    {
-        $aNeg = ($this->limbs[0] >> 15) & 1;
-        $bNeg = ($right->limbs[0] >> 15) & 1;
-
-        $a = array_reverse($this->limbs);
-        $b = array_reverse($right->limbs);
-        if ($aNeg) {
-            for ($i = 0; $i < 2; ++$i) {
-                $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;
-            }
-            ++$a[0];
-        }
-        if ($bNeg) {
-            for ($i = 0; $i < 2; ++$i) {
-                $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;
-            }
-            ++$b[0];
-        }
-        $res = $this->multiplyLong($a, $b);
-        if ($aNeg !== $bNeg) {
-            if ($aNeg !== $bNeg) {
-                for ($i = 0; $i < 2; ++$i) {
-                    $res[$i] = ($res[$i] ^ 0xffff) & 0xffff;
-                }
-                $c = 1;
-                for ($i = 0; $i < 2; ++$i) {
-                    $res[$i] += $c;
-                    $c = $res[$i] >> 16;
-                    $res[$i] &= 0xffff;
-                }
-            }
-        }
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->limbs = array(
-            $res[1] & 0xffff,
-            $res[0] & 0xffff
-        );
-        if (count($res) > 2) {
-            $return->overflow = $res[2];
-        }
-        return $return;
-    }
-
-    /**
-     * @param int $int
-     * @param int $size
-     * @return ParagonIE_Sodium_Core32_Int32
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public function mulInt($int = 0, $size = 0)
-    {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
-        ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
-        if (ParagonIE_Sodium_Compat::$fastMult) {
-            return $this->mulIntFast((int) $int);
-        }
-        /** @var int $int */
-        $int = (int) $int;
-        /** @var int $size */
-        $size = (int) $size;
-
-        if (!$size) {
-            $size = 31;
-        }
-        /** @var int $size */
-
-        $a = clone $this;
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->unsignedInt = $this->unsignedInt;
-
-        // Initialize:
-        $ret0 = 0;
-        $ret1 = 0;
-        $a0 = $a->limbs[0];
-        $a1 = $a->limbs[1];
-
-        /** @var int $size */
-        /** @var int $i */
-        for ($i = $size; $i >= 0; --$i) {
-            $m = (int) (-($int & 1));
-            $x0 = $a0 & $m;
-            $x1 = $a1 & $m;
-
-            $ret1 += $x1;
-            $c = $ret1 >> 16;
-
-            $ret0 += $x0 + $c;
-
-            $ret0 &= 0xffff;
-            $ret1 &= 0xffff;
-
-            $a1 = ($a1 << 1);
-            $x1 = $a1 >> 16;
-            $a0 = ($a0 << 1) | $x1;
-            $a0 &= 0xffff;
-            $a1 &= 0xffff;
-            $int >>= 1;
-        }
-        $return->limbs[0] = $ret0;
-        $return->limbs[1] = $ret1;
-        return $return;
-    }
-
-    /**
-     * @param ParagonIE_Sodium_Core32_Int32 $int
-     * @param int $size
-     * @return ParagonIE_Sodium_Core32_Int32
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public function mulInt32(ParagonIE_Sodium_Core32_Int32 $int, $size = 0)
-    {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
-        if (ParagonIE_Sodium_Compat::$fastMult) {
-            return $this->mulInt32Fast($int);
-        }
-        if (!$size) {
-            $size = 31;
-        }
-        /** @var int $size */
-
-        $a = clone $this;
-        $b = clone $int;
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->unsignedInt = $this->unsignedInt;
-
-        // Initialize:
-        $ret0 = 0;
-        $ret1 = 0;
-        $a0 = $a->limbs[0];
-        $a1 = $a->limbs[1];
-        $b0 = $b->limbs[0];
-        $b1 = $b->limbs[1];
-
-        /** @var int $size */
-        /** @var int $i */
-        for ($i = $size; $i >= 0; --$i) {
-            $m = (int) (-($b1 & 1));
-            $x0 = $a0 & $m;
-            $x1 = $a1 & $m;
-
-            $ret1 += $x1;
-            $c = $ret1 >> 16;
-
-            $ret0 += $x0 + $c;
-
-            $ret0 &= 0xffff;
-            $ret1 &= 0xffff;
-
-            $a1 = ($a1 << 1);
-            $x1 = $a1 >> 16;
-            $a0 = ($a0 << 1) | $x1;
-            $a0 &= 0xffff;
-            $a1 &= 0xffff;
-
-            $x0 = ($b0 & 1) << 16;
-            $b0 = ($b0 >> 1);
-            $b1 = (($b1 | $x0) >> 1);
-
-            $b0 &= 0xffff;
-            $b1 &= 0xffff;
-
-        }
-        $return->limbs[0] = $ret0;
-        $return->limbs[1] = $ret1;
-
-        return $return;
-    }
-
-    /**
-     * OR this 32-bit integer with another.
-     *
-     * @param ParagonIE_Sodium_Core32_Int32 $b
-     * @return ParagonIE_Sodium_Core32_Int32
-     */
-    public function orInt32(ParagonIE_Sodium_Core32_Int32 $b)
-    {
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->unsignedInt = $this->unsignedInt;
-        $return->limbs = array(
-            (int) ($this->limbs[0] | $b->limbs[0]),
-            (int) ($this->limbs[1] | $b->limbs[1])
-        );
-        /** @var int overflow */
-        $return->overflow = $this->overflow | $b->overflow;
-        return $return;
-    }
-
-    /**
-     * @param int $b
-     * @return bool
-     */
-    public function isGreaterThan($b = 0)
-    {
-        return $this->compareInt($b) > 0;
-    }
-
-    /**
-     * @param int $b
-     * @return bool
-     */
-    public function isLessThanInt($b = 0)
-    {
-        return $this->compareInt($b) < 0;
-    }
-
-    /**
-     * @param int $c
-     * @return ParagonIE_Sodium_Core32_Int32
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArrayAccess
-     */
-    public function rotateLeft($c = 0)
-    {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
-        /** @var int $c */
-        $c = (int) $c;
-
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->unsignedInt = $this->unsignedInt;
-        $c &= 31;
-        if ($c === 0) {
-            // NOP, but we want a copy.
-            $return->limbs = $this->limbs;
-        } else {
-            /** @var int $c */
-
-            /** @var int $idx_shift */
-            $idx_shift = ($c >> 4) & 1;
-
-            /** @var int $sub_shift */
-            $sub_shift = $c & 15;
-
-            /** @var array<int, int> $limbs */
-            $limbs =& $return->limbs;
-
-            /** @var array<int, int> $myLimbs */
-            $myLimbs =& $this->limbs;
-
-            for ($i = 1; $i >= 0; --$i) {
-                /** @var int $j */
-                $j = ($i + $idx_shift) & 1;
-                /** @var int $k */
-                $k = ($i + $idx_shift + 1) & 1;
-                $limbs[$i] = (int) (
-                    (
-                        ((int) ($myLimbs[$j]) << $sub_shift)
-                            |
-                        ((int) ($myLimbs[$k]) >> (16 - $sub_shift))
-                    ) & 0xffff
-                );
-            }
-        }
-        return $return;
-    }
-
-    /**
-     * Rotate to the right
-     *
-     * @param int $c
-     * @return ParagonIE_Sodium_Core32_Int32
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArrayAccess
-     */
-    public function rotateRight($c = 0)
-    {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
-        /** @var int $c */
-        $c = (int) $c;
-
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->unsignedInt = $this->unsignedInt;
-        $c &= 31;
-        /** @var int $c */
-        if ($c === 0) {
-            // NOP, but we want a copy.
-            $return->limbs = $this->limbs;
-        } else {
-            /** @var int $c */
-
-            /** @var int $idx_shift */
-            $idx_shift = ($c >> 4) & 1;
-
-            /** @var int $sub_shift */
-            $sub_shift = $c & 15;
-
-            /** @var array<int, int> $limbs */
-            $limbs =& $return->limbs;
-
-            /** @var array<int, int> $myLimbs */
-            $myLimbs =& $this->limbs;
-
-            for ($i = 1; $i >= 0; --$i) {
-                /** @var int $j */
-                $j = ($i - $idx_shift) & 1;
-                /** @var int $k */
-                $k = ($i - $idx_shift - 1) & 1;
-                $limbs[$i] = (int) (
-                    (
-                        ((int) ($myLimbs[$j]) >> (int) ($sub_shift))
-                            |
-                        ((int) ($myLimbs[$k]) << (16 - (int) ($sub_shift)))
-                    ) & 0xffff
-                );
-            }
-        }
-        return $return;
-    }
-
-    /**
-     * @param bool $bool
-     * @return self
-     */
-    public function setUnsignedInt($bool = false)
-    {
-        $this->unsignedInt = !empty($bool);
-        return $this;
-    }
-
-    /**
-     * @param int $c
-     * @return ParagonIE_Sodium_Core32_Int32
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public function shiftLeft($c = 0)
-    {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
-        /** @var int $c */
-        $c = (int) $c;
-
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->unsignedInt = $this->unsignedInt;
-        $c &= 63;
-        /** @var int $c */
-        if ($c === 0) {
-            $return->limbs = $this->limbs;
-        } elseif ($c < 0) {
-            /** @var int $c */
-            return $this->shiftRight(-$c);
-        } else {
-            /** @var int $c */
-            /** @var int $tmp */
-            $tmp = $this->limbs[1] << $c;
-            $return->limbs[1] = (int)($tmp & 0xffff);
-            /** @var int $carry */
-            $carry = $tmp >> 16;
-
-            /** @var int $tmp */
-            $tmp = ($this->limbs[0] << $c) | ($carry & 0xffff);
-            $return->limbs[0] = (int) ($tmp & 0xffff);
-        }
-        return $return;
-    }
-
-    /**
-     * @param int $c
-     * @return ParagonIE_Sodium_Core32_Int32
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedAssignment
-     * @psalm-suppress MixedOperand
-     */
-    public function shiftRight($c = 0)
-    {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
-        /** @var int $c */
-        $c = (int) $c;
-
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->unsignedInt = $this->unsignedInt;
-        $c &= 63;
-        /** @var int $c */
-        if ($c >= 16) {
-            $return->limbs = array(
-                (int) ($this->overflow & 0xffff),
-                (int) ($this->limbs[0])
-            );
-            $return->overflow = $this->overflow >> 16;
-            return $return->shiftRight($c & 15);
-        }
-        if ($c === 0) {
-            $return->limbs = $this->limbs;
-        } elseif ($c < 0) {
-            /** @var int $c */
-            return $this->shiftLeft(-$c);
-        } else {
-            if (!is_int($c)) {
-                throw new TypeError();
-            }
-            /** @var int $c */
-            // $return->limbs[0] = (int) (($this->limbs[0] >> $c) & 0xffff);
-            $carryLeft = (int) ($this->overflow & ((1 << ($c + 1)) - 1));
-            $return->limbs[0] = (int) ((($this->limbs[0] >> $c) | ($carryLeft << (16 - $c))) & 0xffff);
-            $carryRight = (int) ($this->limbs[0] & ((1 << ($c + 1)) - 1));
-            $return->limbs[1] = (int) ((($this->limbs[1] >> $c) | ($carryRight << (16 - $c))) & 0xffff);
-            $return->overflow >>= $c;
-        }
-        return $return;
-    }
-
-    /**
-     * Subtract a normal integer from an int32 object.
-     *
-     * @param int $int
-     * @return ParagonIE_Sodium_Core32_Int32
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public function subInt($int)
-    {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
-        /** @var int $int */
-        $int = (int) $int;
-
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->unsignedInt = $this->unsignedInt;
-
-        /** @var int $tmp */
-        $tmp = $this->limbs[1] - ($int & 0xffff);
-        /** @var int $carry */
-        $carry = $tmp >> 16;
-        $return->limbs[1] = (int) ($tmp & 0xffff);
-
-        /** @var int $tmp */
-        $tmp = $this->limbs[0] - (($int >> 16) & 0xffff) + $carry;
-        $return->limbs[0] = (int) ($tmp & 0xffff);
-        return $return;
-    }
-
-    /**
-     * Subtract two int32 objects from each other
-     *
-     * @param ParagonIE_Sodium_Core32_Int32 $b
-     * @return ParagonIE_Sodium_Core32_Int32
-     */
-    public function subInt32(ParagonIE_Sodium_Core32_Int32 $b)
-    {
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->unsignedInt = $this->unsignedInt;
-
-        /** @var int $tmp */
-        $tmp = $this->limbs[1] - ($b->limbs[1] & 0xffff);
-        /** @var int $carry */
-        $carry = $tmp >> 16;
-        $return->limbs[1] = (int) ($tmp & 0xffff);
-
-        /** @var int $tmp */
-        $tmp = $this->limbs[0] - ($b->limbs[0] & 0xffff) + $carry;
-        $return->limbs[0] = (int) ($tmp & 0xffff);
-        return $return;
-    }
-
-    /**
-     * XOR this 32-bit integer with another.
-     *
-     * @param ParagonIE_Sodium_Core32_Int32 $b
-     * @return ParagonIE_Sodium_Core32_Int32
-     */
-    public function xorInt32(ParagonIE_Sodium_Core32_Int32 $b)
-    {
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->unsignedInt = $this->unsignedInt;
-        $return->limbs = array(
-            (int) ($this->limbs[0] ^ $b->limbs[0]),
-            (int) ($this->limbs[1] ^ $b->limbs[1])
-        );
-        return $return;
-    }
-
-    /**
-     * @param int $signed
-     * @return self
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function fromInt($signed)
-    {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($signed, 'int', 1);;
-        /** @var int $signed */
-        $signed = (int) $signed;
-
-        return new ParagonIE_Sodium_Core32_Int32(
-            array(
-                (int) (($signed >> 16) & 0xffff),
-                (int) ($signed & 0xffff)
-            )
-        );
-    }
-
-    /**
-     * @param string $string
-     * @return self
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function fromString($string)
-    {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);
-        $string = (string) $string;
-        if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 4) {
-            throw new RangeException(
-                'String must be 4 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen($string) . ' given.'
-            );
-        }
-        $return = new ParagonIE_Sodium_Core32_Int32();
-
-        $return->limbs[0]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[0]) & 0xff) << 8);
-        $return->limbs[0] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[1]) & 0xff);
-        $return->limbs[1]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[2]) & 0xff) << 8);
-        $return->limbs[1] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[3]) & 0xff);
-        return $return;
-    }
-
-    /**
-     * @param string $string
-     * @return self
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function fromReverseString($string)
-    {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);
-        $string = (string) $string;
-        if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 4) {
-            throw new RangeException(
-                'String must be 4 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen($string) . ' given.'
-            );
-        }
-        $return = new ParagonIE_Sodium_Core32_Int32();
-
-        $return->limbs[0]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[3]) & 0xff) << 8);
-        $return->limbs[0] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[2]) & 0xff);
-        $return->limbs[1]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[1]) & 0xff) << 8);
-        $return->limbs[1] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[0]) & 0xff);
-        return $return;
-    }
-
-    /**
-     * @return array<int, int>
-     */
-    public function toArray()
-    {
-        return array((int) ($this->limbs[0] << 16 | $this->limbs[1]));
-    }
-
-    /**
-     * @return string
-     * @throws TypeError
-     */
-    public function toString()
-    {
-        return
-            ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[0] >> 8) & 0xff) .
-            ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[0] & 0xff) .
-            ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[1] >> 8) & 0xff) .
-            ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[1] & 0xff);
-    }
-
-    /**
-     * @return int
-     */
-    public function toInt()
-    {
-        return (int) (
-            (($this->limbs[0] & 0xffff) << 16)
-                |
-            ($this->limbs[1] & 0xffff)
-        );
-    }
-
-    /**
-     * @return ParagonIE_Sodium_Core32_Int32
-     */
-    public function toInt32()
-    {
-        $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->limbs[0] = (int) ($this->limbs[0] & 0xffff);
-        $return->limbs[1] = (int) ($this->limbs[1] & 0xffff);
-        $return->unsignedInt = $this->unsignedInt;
-        $return->overflow = (int) ($this->overflow & 0x7fffffff);
-        return $return;
-    }
-
-    /**
-     * @return ParagonIE_Sodium_Core32_Int64
-     */
-    public function toInt64()
-    {
-        $return = new ParagonIE_Sodium_Core32_Int64();
-        $return->unsignedInt = $this->unsignedInt;
-        if ($this->unsignedInt) {
-            $return->limbs[0] += (($this->overflow >> 16) & 0xffff);
-            $return->limbs[1] += (($this->overflow) & 0xffff);
-        } else {
-            $neg = -(($this->limbs[0] >> 15) & 1);
-            $return->limbs[0] = (int)($neg & 0xffff);
-            $return->limbs[1] = (int)($neg & 0xffff);
-        }
-        $return->limbs[2] = (int) ($this->limbs[0] & 0xffff);
-        $return->limbs[3] = (int) ($this->limbs[1] & 0xffff);
-        return $return;
-    }
-
-    /**
-     * @return string
-     * @throws TypeError
-     */
-    public function toReverseString()
-    {
-        return ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[1] & 0xff) .
-            ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[1] >> 8) & 0xff) .
-            ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[0] & 0xff) .
-            ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[0] >> 8) & 0xff);
-    }
-
-    /**
-     * @return string
-     */
-    public function __toString()
-    {
-        try {
-            return $this->toString();
-        } catch (TypeError $ex) {
-            // PHP engine can't handle exceptions from __toString()
-            return '';
-        }
-    }
+	/**
+	 * @var array<int, int> - two 16-bit integers
+	 *
+	 * 0 is the higher 16 bits
+	 * 1 is the lower 16 bits
+	 */
+	public $limbs = array(0, 0);
+
+	/**
+	 * @var int
+	 */
+	public $overflow = 0;
+
+	/**
+	 * @var bool
+	 */
+	public $unsignedInt = false;
+
+	/**
+	 * ParagonIE_Sodium_Core32_Int32 constructor.
+	 * @param array $array
+	 * @param bool $unsignedInt
+	 */
+	public function __construct($array = array(0, 0), $unsignedInt = false)
+	{
+		$this->limbs = array(
+			(int) $array[0],
+			(int) $array[1]
+		);
+		$this->overflow = 0;
+		$this->unsignedInt = $unsignedInt;
+	}
+
+	/**
+	 * Adds two int32 objects
+	 *
+	 * @param ParagonIE_Sodium_Core32_Int32 $addend
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 */
+	public function addInt32(ParagonIE_Sodium_Core32_Int32 $addend)
+	{
+		$i0 = $this->limbs[0];
+		$i1 = $this->limbs[1];
+		$j0 = $addend->limbs[0];
+		$j1 = $addend->limbs[1];
+
+		$r1 = $i1 + ($j1 & 0xffff);
+		$carry = $r1 >> 16;
+
+		$r0 = $i0 + ($j0 & 0xffff) + $carry;
+		$carry = $r0 >> 16;
+
+		$r0 &= 0xffff;
+		$r1 &= 0xffff;
+
+		$return = new ParagonIE_Sodium_Core32_Int32(
+			array($r0, $r1)
+		);
+		$return->overflow = $carry;
+		$return->unsignedInt = $this->unsignedInt;
+		return $return;
+	}
+
+	/**
+	 * Adds a normal integer to an int32 object
+	 *
+	 * @param int $int
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public function addInt($int)
+	{
+		ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
+		/** @var int $int */
+		$int = (int) $int;
+
+		$int = (int) $int;
+
+		$i0 = $this->limbs[0];
+		$i1 = $this->limbs[1];
+
+		$r1 = $i1 + ($int & 0xffff);
+		$carry = $r1 >> 16;
+
+		$r0 = $i0 + (($int >> 16) & 0xffff) + $carry;
+		$carry = $r0 >> 16;
+		$r0 &= 0xffff;
+		$r1 &= 0xffff;
+		$return = new ParagonIE_Sodium_Core32_Int32(
+			array($r0, $r1)
+		);
+		$return->overflow = $carry;
+		$return->unsignedInt = $this->unsignedInt;
+		return $return;
+	}
+
+	/**
+	 * @param int $b
+	 * @return int
+	 */
+	public function compareInt($b = 0)
+	{
+		$gt = 0;
+		$eq = 1;
+
+		$i = 2;
+		$j = 0;
+		while ($i > 0) {
+			--$i;
+			/** @var int $x1 */
+			$x1 = $this->limbs[$i];
+			/** @var int $x2 */
+			$x2 = ($b >> ($j << 4)) & 0xffff;
+			/** @var int $gt */
+			$gt |= (($x2 - $x1) >> 8) & $eq;
+			/** @var int $eq */
+			$eq &= (($x2 ^ $x1) - 1) >> 8;
+		}
+		return ($gt + $gt - $eq) + 1;
+	}
+
+	/**
+	 * @param int $m
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 */
+	public function mask($m = 0)
+	{
+		/** @var int $hi */
+		$hi = ($m >> 16) & 0xffff;
+		/** @var int $lo */
+		$lo = ($m & 0xffff);
+		return new ParagonIE_Sodium_Core32_Int32(
+			array(
+				(int) ($this->limbs[0] & $hi),
+				(int) ($this->limbs[1] & $lo)
+			),
+			$this->unsignedInt
+		);
+	}
+
+	/**
+	 * @param array<int, int> $a
+	 * @param array<int, int> $b
+	 * @param int $baseLog2
+	 * @return array<int, int>
+	 */
+	public function multiplyLong(array $a, array $b, $baseLog2 = 16)
+	{
+		$a_l = count($a);
+		$b_l = count($b);
+		/** @var array<int, int> $r */
+		$r = array_fill(0, $a_l + $b_l + 1, 0);
+		$base = 1 << $baseLog2;
+		for ($i = 0; $i < $a_l; ++$i) {
+			$a_i = $a[$i];
+			for ($j = 0; $j < $a_l; ++$j) {
+				$b_j = $b[$j];
+				$product = ($a_i * $b_j) + $r[$i + $j];
+				$carry = ($product >> $baseLog2 & 0xffff);
+				$r[$i + $j] = ($product - (int) ($carry * $base)) & 0xffff;
+				$r[$i + $j + 1] += $carry;
+			}
+		}
+		return array_slice($r, 0, 5);
+	}
+
+	/**
+	 * @param int $int
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 */
+	public function mulIntFast($int)
+	{
+		// Handle negative numbers
+		$aNeg = ($this->limbs[0] >> 15) & 1;
+		$bNeg = ($int >> 31) & 1;
+		$a = array_reverse($this->limbs);
+		$b = array(
+			$int & 0xffff,
+			($int >> 16) & 0xffff
+		);
+		if ($aNeg) {
+			for ($i = 0; $i < 2; ++$i) {
+				$a[$i] = ($a[$i] ^ 0xffff) & 0xffff;
+			}
+			++$a[0];
+		}
+		if ($bNeg) {
+			for ($i = 0; $i < 2; ++$i) {
+				$b[$i] = ($b[$i] ^ 0xffff) & 0xffff;
+			}
+			++$b[0];
+		}
+		// Multiply
+		$res = $this->multiplyLong($a, $b);
+
+		// Re-apply negation to results
+		if ($aNeg !== $bNeg) {
+			for ($i = 0; $i < 2; ++$i) {
+				$res[$i] = (0xffff ^ $res[$i]) & 0xffff;
+			}
+			// Handle integer overflow
+			$c = 1;
+			for ($i = 0; $i < 2; ++$i) {
+				$res[$i] += $c;
+				$c = $res[$i] >> 16;
+				$res[$i] &= 0xffff;
+			}
+		}
+
+		// Return our values
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->limbs = array(
+			$res[1] & 0xffff,
+			$res[0] & 0xffff
+		);
+		if (count($res) > 2) {
+			$return->overflow = $res[2] & 0xffff;
+		}
+		$return->unsignedInt = $this->unsignedInt;
+		return $return;
+	}
+
+	/**
+	 * @param ParagonIE_Sodium_Core32_Int32 $right
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 */
+	public function mulInt32Fast(ParagonIE_Sodium_Core32_Int32 $right)
+	{
+		$aNeg = ($this->limbs[0] >> 15) & 1;
+		$bNeg = ($right->limbs[0] >> 15) & 1;
+
+		$a = array_reverse($this->limbs);
+		$b = array_reverse($right->limbs);
+		if ($aNeg) {
+			for ($i = 0; $i < 2; ++$i) {
+				$a[$i] = ($a[$i] ^ 0xffff) & 0xffff;
+			}
+			++$a[0];
+		}
+		if ($bNeg) {
+			for ($i = 0; $i < 2; ++$i) {
+				$b[$i] = ($b[$i] ^ 0xffff) & 0xffff;
+			}
+			++$b[0];
+		}
+		$res = $this->multiplyLong($a, $b);
+		if ($aNeg !== $bNeg) {
+			if ($aNeg !== $bNeg) {
+				for ($i = 0; $i < 2; ++$i) {
+					$res[$i] = ($res[$i] ^ 0xffff) & 0xffff;
+				}
+				$c = 1;
+				for ($i = 0; $i < 2; ++$i) {
+					$res[$i] += $c;
+					$c = $res[$i] >> 16;
+					$res[$i] &= 0xffff;
+				}
+			}
+		}
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->limbs = array(
+			$res[1] & 0xffff,
+			$res[0] & 0xffff
+		);
+		if (count($res) > 2) {
+			$return->overflow = $res[2];
+		}
+		return $return;
+	}
+
+	/**
+	 * @param int $int
+	 * @param int $size
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public function mulInt($int = 0, $size = 0)
+	{
+		ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
+		ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
+		if (ParagonIE_Sodium_Compat::$fastMult) {
+			return $this->mulIntFast((int) $int);
+		}
+		/** @var int $int */
+		$int = (int) $int;
+		/** @var int $size */
+		$size = (int) $size;
+
+		if (!$size) {
+			$size = 31;
+		}
+		/** @var int $size */
+
+		$a = clone $this;
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->unsignedInt = $this->unsignedInt;
+
+		// Initialize:
+		$ret0 = 0;
+		$ret1 = 0;
+		$a0 = $a->limbs[0];
+		$a1 = $a->limbs[1];
+
+		/** @var int $size */
+		/** @var int $i */
+		for ($i = $size; $i >= 0; --$i) {
+			$m = (int) (-($int & 1));
+			$x0 = $a0 & $m;
+			$x1 = $a1 & $m;
+
+			$ret1 += $x1;
+			$c = $ret1 >> 16;
+
+			$ret0 += $x0 + $c;
+
+			$ret0 &= 0xffff;
+			$ret1 &= 0xffff;
+
+			$a1 = ($a1 << 1);
+			$x1 = $a1 >> 16;
+			$a0 = ($a0 << 1) | $x1;
+			$a0 &= 0xffff;
+			$a1 &= 0xffff;
+			$int >>= 1;
+		}
+		$return->limbs[0] = $ret0;
+		$return->limbs[1] = $ret1;
+		return $return;
+	}
+
+	/**
+	 * @param ParagonIE_Sodium_Core32_Int32 $int
+	 * @param int $size
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public function mulInt32(ParagonIE_Sodium_Core32_Int32 $int, $size = 0)
+	{
+		ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
+		if (ParagonIE_Sodium_Compat::$fastMult) {
+			return $this->mulInt32Fast($int);
+		}
+		if (!$size) {
+			$size = 31;
+		}
+		/** @var int $size */
+
+		$a = clone $this;
+		$b = clone $int;
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->unsignedInt = $this->unsignedInt;
+
+		// Initialize:
+		$ret0 = 0;
+		$ret1 = 0;
+		$a0 = $a->limbs[0];
+		$a1 = $a->limbs[1];
+		$b0 = $b->limbs[0];
+		$b1 = $b->limbs[1];
+
+		/** @var int $size */
+		/** @var int $i */
+		for ($i = $size; $i >= 0; --$i) {
+			$m = (int) (-($b1 & 1));
+			$x0 = $a0 & $m;
+			$x1 = $a1 & $m;
+
+			$ret1 += $x1;
+			$c = $ret1 >> 16;
+
+			$ret0 += $x0 + $c;
+
+			$ret0 &= 0xffff;
+			$ret1 &= 0xffff;
+
+			$a1 = ($a1 << 1);
+			$x1 = $a1 >> 16;
+			$a0 = ($a0 << 1) | $x1;
+			$a0 &= 0xffff;
+			$a1 &= 0xffff;
+
+			$x0 = ($b0 & 1) << 16;
+			$b0 = ($b0 >> 1);
+			$b1 = (($b1 | $x0) >> 1);
+
+			$b0 &= 0xffff;
+			$b1 &= 0xffff;
+
+		}
+		$return->limbs[0] = $ret0;
+		$return->limbs[1] = $ret1;
+
+		return $return;
+	}
+
+	/**
+	 * OR this 32-bit integer with another.
+	 *
+	 * @param ParagonIE_Sodium_Core32_Int32 $b
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 */
+	public function orInt32(ParagonIE_Sodium_Core32_Int32 $b)
+	{
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->unsignedInt = $this->unsignedInt;
+		$return->limbs = array(
+			(int) ($this->limbs[0] | $b->limbs[0]),
+			(int) ($this->limbs[1] | $b->limbs[1])
+		);
+		/** @var int overflow */
+		$return->overflow = $this->overflow | $b->overflow;
+		return $return;
+	}
+
+	/**
+	 * @param int $b
+	 * @return bool
+	 */
+	public function isGreaterThan($b = 0)
+	{
+		return $this->compareInt($b) > 0;
+	}
+
+	/**
+	 * @param int $b
+	 * @return bool
+	 */
+	public function isLessThanInt($b = 0)
+	{
+		return $this->compareInt($b) < 0;
+	}
+
+	/**
+	 * @param int $c
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArrayAccess
+	 */
+	public function rotateLeft($c = 0)
+	{
+		ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
+		/** @var int $c */
+		$c = (int) $c;
+
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->unsignedInt = $this->unsignedInt;
+		$c &= 31;
+		if ($c === 0) {
+			// NOP, but we want a copy.
+			$return->limbs = $this->limbs;
+		} else {
+			/** @var int $c */
+
+			/** @var int $idx_shift */
+			$idx_shift = ($c >> 4) & 1;
+
+			/** @var int $sub_shift */
+			$sub_shift = $c & 15;
+
+			/** @var array<int, int> $limbs */
+			$limbs =& $return->limbs;
+
+			/** @var array<int, int> $myLimbs */
+			$myLimbs =& $this->limbs;
+
+			for ($i = 1; $i >= 0; --$i) {
+				/** @var int $j */
+				$j = ($i + $idx_shift) & 1;
+				/** @var int $k */
+				$k = ($i + $idx_shift + 1) & 1;
+				$limbs[$i] = (int) (
+					(
+						((int) ($myLimbs[$j]) << $sub_shift)
+							|
+						((int) ($myLimbs[$k]) >> (16 - $sub_shift))
+					) & 0xffff
+				);
+			}
+		}
+		return $return;
+	}
+
+	/**
+	 * Rotate to the right
+	 *
+	 * @param int $c
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArrayAccess
+	 */
+	public function rotateRight($c = 0)
+	{
+		ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
+		/** @var int $c */
+		$c = (int) $c;
+
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->unsignedInt = $this->unsignedInt;
+		$c &= 31;
+		/** @var int $c */
+		if ($c === 0) {
+			// NOP, but we want a copy.
+			$return->limbs = $this->limbs;
+		} else {
+			/** @var int $c */
+
+			/** @var int $idx_shift */
+			$idx_shift = ($c >> 4) & 1;
+
+			/** @var int $sub_shift */
+			$sub_shift = $c & 15;
+
+			/** @var array<int, int> $limbs */
+			$limbs =& $return->limbs;
+
+			/** @var array<int, int> $myLimbs */
+			$myLimbs =& $this->limbs;
+
+			for ($i = 1; $i >= 0; --$i) {
+				/** @var int $j */
+				$j = ($i - $idx_shift) & 1;
+				/** @var int $k */
+				$k = ($i - $idx_shift - 1) & 1;
+				$limbs[$i] = (int) (
+					(
+						((int) ($myLimbs[$j]) >> (int) ($sub_shift))
+							|
+						((int) ($myLimbs[$k]) << (16 - (int) ($sub_shift)))
+					) & 0xffff
+				);
+			}
+		}
+		return $return;
+	}
+
+	/**
+	 * @param bool $bool
+	 * @return self
+	 */
+	public function setUnsignedInt($bool = false)
+	{
+		$this->unsignedInt = !empty($bool);
+		return $this;
+	}
+
+	/**
+	 * @param int $c
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public function shiftLeft($c = 0)
+	{
+		ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
+		/** @var int $c */
+		$c = (int) $c;
+
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->unsignedInt = $this->unsignedInt;
+		$c &= 63;
+		/** @var int $c */
+		if ($c === 0) {
+			$return->limbs = $this->limbs;
+		} elseif ($c < 0) {
+			/** @var int $c */
+			return $this->shiftRight(-$c);
+		} else {
+			/** @var int $c */
+			/** @var int $tmp */
+			$tmp = $this->limbs[1] << $c;
+			$return->limbs[1] = (int)($tmp & 0xffff);
+			/** @var int $carry */
+			$carry = $tmp >> 16;
+
+			/** @var int $tmp */
+			$tmp = ($this->limbs[0] << $c) | ($carry & 0xffff);
+			$return->limbs[0] = (int) ($tmp & 0xffff);
+		}
+		return $return;
+	}
+
+	/**
+	 * @param int $c
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedAssignment
+	 * @psalm-suppress MixedOperand
+	 */
+	public function shiftRight($c = 0)
+	{
+		ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
+		/** @var int $c */
+		$c = (int) $c;
+
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->unsignedInt = $this->unsignedInt;
+		$c &= 63;
+		/** @var int $c */
+		if ($c >= 16) {
+			$return->limbs = array(
+				(int) ($this->overflow & 0xffff),
+				(int) ($this->limbs[0])
+			);
+			$return->overflow = $this->overflow >> 16;
+			return $return->shiftRight($c & 15);
+		}
+		if ($c === 0) {
+			$return->limbs = $this->limbs;
+		} elseif ($c < 0) {
+			/** @var int $c */
+			return $this->shiftLeft(-$c);
+		} else {
+			if (!is_int($c)) {
+				throw new TypeError();
+			}
+			/** @var int $c */
+			// $return->limbs[0] = (int) (($this->limbs[0] >> $c) & 0xffff);
+			$carryLeft = (int) ($this->overflow & ((1 << ($c + 1)) - 1));
+			$return->limbs[0] = (int) ((($this->limbs[0] >> $c) | ($carryLeft << (16 - $c))) & 0xffff);
+			$carryRight = (int) ($this->limbs[0] & ((1 << ($c + 1)) - 1));
+			$return->limbs[1] = (int) ((($this->limbs[1] >> $c) | ($carryRight << (16 - $c))) & 0xffff);
+			$return->overflow >>= $c;
+		}
+		return $return;
+	}
+
+	/**
+	 * Subtract a normal integer from an int32 object.
+	 *
+	 * @param int $int
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public function subInt($int)
+	{
+		ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
+		/** @var int $int */
+		$int = (int) $int;
+
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->unsignedInt = $this->unsignedInt;
+
+		/** @var int $tmp */
+		$tmp = $this->limbs[1] - ($int & 0xffff);
+		/** @var int $carry */
+		$carry = $tmp >> 16;
+		$return->limbs[1] = (int) ($tmp & 0xffff);
+
+		/** @var int $tmp */
+		$tmp = $this->limbs[0] - (($int >> 16) & 0xffff) + $carry;
+		$return->limbs[0] = (int) ($tmp & 0xffff);
+		return $return;
+	}
+
+	/**
+	 * Subtract two int32 objects from each other
+	 *
+	 * @param ParagonIE_Sodium_Core32_Int32 $b
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 */
+	public function subInt32(ParagonIE_Sodium_Core32_Int32 $b)
+	{
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->unsignedInt = $this->unsignedInt;
+
+		/** @var int $tmp */
+		$tmp = $this->limbs[1] - ($b->limbs[1] & 0xffff);
+		/** @var int $carry */
+		$carry = $tmp >> 16;
+		$return->limbs[1] = (int) ($tmp & 0xffff);
+
+		/** @var int $tmp */
+		$tmp = $this->limbs[0] - ($b->limbs[0] & 0xffff) + $carry;
+		$return->limbs[0] = (int) ($tmp & 0xffff);
+		return $return;
+	}
+
+	/**
+	 * XOR this 32-bit integer with another.
+	 *
+	 * @param ParagonIE_Sodium_Core32_Int32 $b
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 */
+	public function xorInt32(ParagonIE_Sodium_Core32_Int32 $b)
+	{
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->unsignedInt = $this->unsignedInt;
+		$return->limbs = array(
+			(int) ($this->limbs[0] ^ $b->limbs[0]),
+			(int) ($this->limbs[1] ^ $b->limbs[1])
+		);
+		return $return;
+	}
+
+	/**
+	 * @param int $signed
+	 * @return self
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function fromInt($signed)
+	{
+		ParagonIE_Sodium_Core32_Util::declareScalarType($signed, 'int', 1);;
+		/** @var int $signed */
+		$signed = (int) $signed;
+
+		return new ParagonIE_Sodium_Core32_Int32(
+			array(
+				(int) (($signed >> 16) & 0xffff),
+				(int) ($signed & 0xffff)
+			)
+		);
+	}
+
+	/**
+	 * @param string $string
+	 * @return self
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function fromString($string)
+	{
+		ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);
+		$string = (string) $string;
+		if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 4) {
+			throw new RangeException(
+				'String must be 4 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen($string) . ' given.'
+			);
+		}
+		$return = new ParagonIE_Sodium_Core32_Int32();
+
+		$return->limbs[0]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[0]) & 0xff) << 8);
+		$return->limbs[0] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[1]) & 0xff);
+		$return->limbs[1]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[2]) & 0xff) << 8);
+		$return->limbs[1] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[3]) & 0xff);
+		return $return;
+	}
+
+	/**
+	 * @param string $string
+	 * @return self
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function fromReverseString($string)
+	{
+		ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);
+		$string = (string) $string;
+		if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 4) {
+			throw new RangeException(
+				'String must be 4 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen($string) . ' given.'
+			);
+		}
+		$return = new ParagonIE_Sodium_Core32_Int32();
+
+		$return->limbs[0]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[3]) & 0xff) << 8);
+		$return->limbs[0] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[2]) & 0xff);
+		$return->limbs[1]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[1]) & 0xff) << 8);
+		$return->limbs[1] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[0]) & 0xff);
+		return $return;
+	}
+
+	/**
+	 * @return array<int, int>
+	 */
+	public function toArray()
+	{
+		return array((int) ($this->limbs[0] << 16 | $this->limbs[1]));
+	}
+
+	/**
+	 * @return string
+	 * @throws TypeError
+	 */
+	public function toString()
+	{
+		return
+			ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[0] >> 8) & 0xff) .
+			ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[0] & 0xff) .
+			ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[1] >> 8) & 0xff) .
+			ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[1] & 0xff);
+	}
+
+	/**
+	 * @return int
+	 */
+	public function toInt()
+	{
+		return (int) (
+			(($this->limbs[0] & 0xffff) << 16)
+				|
+			($this->limbs[1] & 0xffff)
+		);
+	}
+
+	/**
+	 * @return ParagonIE_Sodium_Core32_Int32
+	 */
+	public function toInt32()
+	{
+		$return = new ParagonIE_Sodium_Core32_Int32();
+		$return->limbs[0] = (int) ($this->limbs[0] & 0xffff);
+		$return->limbs[1] = (int) ($this->limbs[1] & 0xffff);
+		$return->unsignedInt = $this->unsignedInt;
+		$return->overflow = (int) ($this->overflow & 0x7fffffff);
+		return $return;
+	}
+
+	/**
+	 * @return ParagonIE_Sodium_Core32_Int64
+	 */
+	public function toInt64()
+	{
+		$return = new ParagonIE_Sodium_Core32_Int64();
+		$return->unsignedInt = $this->unsignedInt;
+		if ($this->unsignedInt) {
+			$return->limbs[0] += (($this->overflow >> 16) & 0xffff);
+			$return->limbs[1] += (($this->overflow) & 0xffff);
+		} else {
+			$neg = -(($this->limbs[0] >> 15) & 1);
+			$return->limbs[0] = (int)($neg & 0xffff);
+			$return->limbs[1] = (int)($neg & 0xffff);
+		}
+		$return->limbs[2] = (int) ($this->limbs[0] & 0xffff);
+		$return->limbs[3] = (int) ($this->limbs[1] & 0xffff);
+		return $return;
+	}
+
+	/**
+	 * @return string
+	 * @throws TypeError
+	 */
+	public function toReverseString()
+	{
+		return ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[1] & 0xff) .
+			ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[1] >> 8) & 0xff) .
+			ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[0] & 0xff) .
+			ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[0] >> 8) & 0xff);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function __toString()
+	{
+		try {
+			return $this->toString();
+		} catch (TypeError $ex) {
+			// PHP engine can't handle exceptions from __toString()
+			return '';
+		}
+	}
 }

Spacing +252 added lines, -252 removed lines

@@ -15,7 +15,7 @@ 
      * 0 is the higher 16 bits
      * 1 is the lower 16 bits
      */
-    public $limbs = array(0, 0);
+    public $limbs = array( 0, 0 );
 
     /**
      * @var int
@@ -32,11 +32,11 @@ 
      * @param array $array
      * @param bool $unsignedInt
      */
-    public function __construct($array = array(0, 0), $unsignedInt = false)
+    public function __construct( $array = array( 0, 0 ), $unsignedInt = false )
     {
         $this->limbs = array(
-            (int) $array[0],
-            (int) $array[1]
+            (int)$array[ 0 ],
+            (int)$array[ 1 ]
         );
         $this->overflow = 0;
         $this->unsignedInt = $unsignedInt;
@@ -48,24 +48,24 @@ 
      * @param ParagonIE_Sodium_Core32_Int32 $addend
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function addInt32(ParagonIE_Sodium_Core32_Int32 $addend)
+    public function addInt32( ParagonIE_Sodium_Core32_Int32 $addend )
     {
-        $i0 = $this->limbs[0];
-        $i1 = $this->limbs[1];
-        $j0 = $addend->limbs[0];
-        $j1 = $addend->limbs[1];
+        $i0 = $this->limbs[ 0 ];
+        $i1 = $this->limbs[ 1 ];
+        $j0 = $addend->limbs[ 0 ];
+        $j1 = $addend->limbs[ 1 ];
 
-        $r1 = $i1 + ($j1 & 0xffff);
+        $r1 = $i1 + ( $j1 & 0xffff );
         $carry = $r1 >> 16;
 
-        $r0 = $i0 + ($j0 & 0xffff) + $carry;
+        $r0 = $i0 + ( $j0 & 0xffff ) + $carry;
         $carry = $r0 >> 16;
 
         $r0 &= 0xffff;
         $r1 &= 0xffff;
 
         $return = new ParagonIE_Sodium_Core32_Int32(
-            array($r0, $r1)
+            array( $r0, $r1 )
         );
         $return->overflow = $carry;
         $return->unsignedInt = $this->unsignedInt;
@@ -80,26 +80,26 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public function addInt($int)
+    public function addInt( $int )
     {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
+        ParagonIE_Sodium_Core32_Util::declareScalarType( $int, 'int', 1 );
         /** @var int $int */
-        $int = (int) $int;
+        $int = (int)$int;
 
-        $int = (int) $int;
+        $int = (int)$int;
 
-        $i0 = $this->limbs[0];
-        $i1 = $this->limbs[1];
+        $i0 = $this->limbs[ 0 ];
+        $i1 = $this->limbs[ 1 ];
 
-        $r1 = $i1 + ($int & 0xffff);
+        $r1 = $i1 + ( $int & 0xffff );
         $carry = $r1 >> 16;
 
-        $r0 = $i0 + (($int >> 16) & 0xffff) + $carry;
+        $r0 = $i0 + ( ( $int >> 16 ) & 0xffff ) + $carry;
         $carry = $r0 >> 16;
         $r0 &= 0xffff;
         $r1 &= 0xffff;
         $return = new ParagonIE_Sodium_Core32_Int32(
-            array($r0, $r1)
+            array( $r0, $r1 )
         );
         $return->overflow = $carry;
         $return->unsignedInt = $this->unsignedInt;
@@ -110,41 +110,41 @@ 
      * @param int $b
      * @return int
      */
-    public function compareInt($b = 0)
+    public function compareInt( $b = 0 )
     {
         $gt = 0;
         $eq = 1;
 
         $i = 2;
         $j = 0;
-        while ($i > 0) {
+        while ( $i > 0 ) {
             --$i;
             /** @var int $x1 */
-            $x1 = $this->limbs[$i];
+            $x1 = $this->limbs[ $i ];
             /** @var int $x2 */
-            $x2 = ($b >> ($j << 4)) & 0xffff;
+            $x2 = ( $b >> ( $j << 4 ) ) & 0xffff;
             /** @var int $gt */
-            $gt |= (($x2 - $x1) >> 8) & $eq;
+            $gt |= ( ( $x2 - $x1 ) >> 8 ) & $eq;
             /** @var int $eq */
-            $eq &= (($x2 ^ $x1) - 1) >> 8;
+            $eq &= ( ( $x2 ^ $x1 ) - 1 ) >> 8;
         }
-        return ($gt + $gt - $eq) + 1;
+        return ( $gt + $gt - $eq ) + 1;
     }
 
     /**
      * @param int $m
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function mask($m = 0)
+    public function mask( $m = 0 )
     {
         /** @var int $hi */
-        $hi = ($m >> 16) & 0xffff;
+        $hi = ( $m >> 16 ) & 0xffff;
         /** @var int $lo */
-        $lo = ($m & 0xffff);
+        $lo = ( $m & 0xffff );
         return new ParagonIE_Sodium_Core32_Int32(
             array(
-                (int) ($this->limbs[0] & $hi),
-                (int) ($this->limbs[1] & $lo)
+                (int)( $this->limbs[ 0 ] & $hi ),
+                (int)( $this->limbs[ 1 ] & $lo )
             ),
             $this->unsignedInt
         );
@@ -156,77 +156,77 @@ 
      * @param int $baseLog2
      * @return array<int, int>
      */
-    public function multiplyLong(array $a, array $b, $baseLog2 = 16)
+    public function multiplyLong( array $a, array $b, $baseLog2 = 16 )
     {
-        $a_l = count($a);
-        $b_l = count($b);
+        $a_l = count( $a );
+        $b_l = count( $b );
         /** @var array<int, int> $r */
-        $r = array_fill(0, $a_l + $b_l + 1, 0);
+        $r = array_fill( 0, $a_l + $b_l + 1, 0 );
         $base = 1 << $baseLog2;
-        for ($i = 0; $i < $a_l; ++$i) {
-            $a_i = $a[$i];
-            for ($j = 0; $j < $a_l; ++$j) {
-                $b_j = $b[$j];
-                $product = ($a_i * $b_j) + $r[$i + $j];
-                $carry = ($product >> $baseLog2 & 0xffff);
-                $r[$i + $j] = ($product - (int) ($carry * $base)) & 0xffff;
-                $r[$i + $j + 1] += $carry;
+        for ( $i = 0; $i < $a_l; ++$i ) {
+            $a_i = $a[ $i ];
+            for ( $j = 0; $j < $a_l; ++$j ) {
+                $b_j = $b[ $j ];
+                $product = ( $a_i * $b_j ) + $r[ $i + $j ];
+                $carry = ( $product >> $baseLog2 & 0xffff );
+                $r[ $i + $j ] = ( $product - (int)( $carry * $base ) ) & 0xffff;
+                $r[ $i + $j + 1 ] += $carry;
             }
         }
-        return array_slice($r, 0, 5);
+        return array_slice( $r, 0, 5 );
     }
 
     /**
      * @param int $int
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function mulIntFast($int)
+    public function mulIntFast( $int )
     {
         // Handle negative numbers
-        $aNeg = ($this->limbs[0] >> 15) & 1;
-        $bNeg = ($int >> 31) & 1;
-        $a = array_reverse($this->limbs);
+        $aNeg = ( $this->limbs[ 0 ] >> 15 ) & 1;
+        $bNeg = ( $int >> 31 ) & 1;
+        $a = array_reverse( $this->limbs );
         $b = array(
             $int & 0xffff,
-            ($int >> 16) & 0xffff
+            ( $int >> 16 ) & 0xffff
         );
-        if ($aNeg) {
-            for ($i = 0; $i < 2; ++$i) {
-                $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;
+        if ( $aNeg ) {
+            for ( $i = 0; $i < 2; ++$i ) {
+                $a[ $i ] = ( $a[ $i ] ^ 0xffff ) & 0xffff;
             }
-            ++$a[0];
+            ++$a[ 0 ];
         }
-        if ($bNeg) {
-            for ($i = 0; $i < 2; ++$i) {
-                $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;
+        if ( $bNeg ) {
+            for ( $i = 0; $i < 2; ++$i ) {
+                $b[ $i ] = ( $b[ $i ] ^ 0xffff ) & 0xffff;
             }
-            ++$b[0];
+            ++$b[ 0 ];
         }
         // Multiply
-        $res = $this->multiplyLong($a, $b);
+        $res = $this->multiplyLong( $a, $b );
 
         // Re-apply negation to results
-        if ($aNeg !== $bNeg) {
-            for ($i = 0; $i < 2; ++$i) {
-                $res[$i] = (0xffff ^ $res[$i]) & 0xffff;
+        if ( $aNeg !== $bNeg ) {
+            for ( $i = 0; $i < 2; ++$i ) {
+                $res[ $i ] = ( 0xffff ^ $res[ $i ] ) & 0xffff;
             }
             // Handle integer overflow
             $c = 1;
-            for ($i = 0; $i < 2; ++$i) {
-                $res[$i] += $c;
-                $c = $res[$i] >> 16;
-                $res[$i] &= 0xffff;
+            for ( $i = 0; $i < 2; ++$i ) {
+                $res[ $i ] += $c;
+                $c = $res[ $i ] >> 16;
+                $res[ $i ] &= 0xffff;
             }
         }
 
         // Return our values
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->limbs = array(
-            $res[1] & 0xffff,
-            $res[0] & 0xffff
+            $res[ 1 ] & 0xffff,
+            $res[ 0 ] & 0xffff
         );
-        if (count($res) > 2) {
-            $return->overflow = $res[2] & 0xffff;
+        if ( count( $res ) > 2 ) {
+            $return->overflow = $res[ 2 ] & 0xffff;
         }
         $return->unsignedInt = $this->unsignedInt;
         return $return;
@@ -236,46 +236,46 @@ 
      * @param ParagonIE_Sodium_Core32_Int32 $right
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function mulInt32Fast(ParagonIE_Sodium_Core32_Int32 $right)
+    public function mulInt32Fast( ParagonIE_Sodium_Core32_Int32 $right )
     {
-        $aNeg = ($this->limbs[0] >> 15) & 1;
-        $bNeg = ($right->limbs[0] >> 15) & 1;
-
-        $a = array_reverse($this->limbs);
-        $b = array_reverse($right->limbs);
-        if ($aNeg) {
-            for ($i = 0; $i < 2; ++$i) {
-                $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;
+        $aNeg = ( $this->limbs[ 0 ] >> 15 ) & 1;
+        $bNeg = ( $right->limbs[ 0 ] >> 15 ) & 1;
+
+        $a = array_reverse( $this->limbs );
+        $b = array_reverse( $right->limbs );
+        if ( $aNeg ) {
+            for ( $i = 0; $i < 2; ++$i ) {
+                $a[ $i ] = ( $a[ $i ] ^ 0xffff ) & 0xffff;
             }
-            ++$a[0];
+            ++$a[ 0 ];
         }
-        if ($bNeg) {
-            for ($i = 0; $i < 2; ++$i) {
-                $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;
+        if ( $bNeg ) {
+            for ( $i = 0; $i < 2; ++$i ) {
+                $b[ $i ] = ( $b[ $i ] ^ 0xffff ) & 0xffff;
             }
-            ++$b[0];
+            ++$b[ 0 ];
         }
-        $res = $this->multiplyLong($a, $b);
-        if ($aNeg !== $bNeg) {
-            if ($aNeg !== $bNeg) {
-                for ($i = 0; $i < 2; ++$i) {
-                    $res[$i] = ($res[$i] ^ 0xffff) & 0xffff;
+        $res = $this->multiplyLong( $a, $b );
+        if ( $aNeg !== $bNeg ) {
+            if ( $aNeg !== $bNeg ) {
+                for ( $i = 0; $i < 2; ++$i ) {
+                    $res[ $i ] = ( $res[ $i ] ^ 0xffff ) & 0xffff;
                 }
                 $c = 1;
-                for ($i = 0; $i < 2; ++$i) {
-                    $res[$i] += $c;
-                    $c = $res[$i] >> 16;
-                    $res[$i] &= 0xffff;
+                for ( $i = 0; $i < 2; ++$i ) {
+                    $res[ $i ] += $c;
+                    $c = $res[ $i ] >> 16;
+                    $res[ $i ] &= 0xffff;
                 }
             }
         }
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->limbs = array(
-            $res[1] & 0xffff,
-            $res[0] & 0xffff
+            $res[ 1 ] & 0xffff,
+            $res[ 0 ] & 0xffff
         );
-        if (count($res) > 2) {
-            $return->overflow = $res[2];
+        if ( count( $res ) > 2 ) {
+            $return->overflow = $res[ 2 ];
         }
         return $return;
     }
@@ -287,19 +287,19 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public function mulInt($int = 0, $size = 0)
+    public function mulInt( $int = 0, $size = 0 )
     {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
-        ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
-        if (ParagonIE_Sodium_Compat::$fastMult) {
-            return $this->mulIntFast((int) $int);
+        ParagonIE_Sodium_Core32_Util::declareScalarType( $int, 'int', 1 );
+        ParagonIE_Sodium_Core32_Util::declareScalarType( $size, 'int', 2 );
+        if ( ParagonIE_Sodium_Compat::$fastMult ) {
+            return $this->mulIntFast( (int)$int );
         }
         /** @var int $int */
-        $int = (int) $int;
+        $int = (int)$int;
         /** @var int $size */
-        $size = (int) $size;
+        $size = (int)$size;
 
-        if (!$size) {
+        if ( ! $size ) {
             $size = 31;
         }
         /** @var int $size */
@@ -311,13 +311,13 @@ 
         // Initialize:
         $ret0 = 0;
         $ret1 = 0;
-        $a0 = $a->limbs[0];
-        $a1 = $a->limbs[1];
+        $a0 = $a->limbs[ 0 ];
+        $a1 = $a->limbs[ 1 ];
 
         /** @var int $size */
         /** @var int $i */
-        for ($i = $size; $i >= 0; --$i) {
-            $m = (int) (-($int & 1));
+        for ( $i = $size; $i >= 0; --$i ) {
+            $m = (int)(-( $int & 1 ));
             $x0 = $a0 & $m;
             $x1 = $a1 & $m;
 
@@ -329,15 +329,15 @@ 
             $ret0 &= 0xffff;
             $ret1 &= 0xffff;
 
-            $a1 = ($a1 << 1);
+            $a1 = ( $a1 << 1 );
             $x1 = $a1 >> 16;
-            $a0 = ($a0 << 1) | $x1;
+            $a0 = ( $a0 << 1 ) | $x1;
             $a0 &= 0xffff;
             $a1 &= 0xffff;
             $int >>= 1;
         }
-        $return->limbs[0] = $ret0;
-        $return->limbs[1] = $ret1;
+        $return->limbs[ 0 ] = $ret0;
+        $return->limbs[ 1 ] = $ret1;
         return $return;
     }
 
@@ -348,13 +348,13 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public function mulInt32(ParagonIE_Sodium_Core32_Int32 $int, $size = 0)
+    public function mulInt32( ParagonIE_Sodium_Core32_Int32 $int, $size = 0 )
     {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
-        if (ParagonIE_Sodium_Compat::$fastMult) {
-            return $this->mulInt32Fast($int);
+        ParagonIE_Sodium_Core32_Util::declareScalarType( $size, 'int', 2 );
+        if ( ParagonIE_Sodium_Compat::$fastMult ) {
+            return $this->mulInt32Fast( $int );
         }
-        if (!$size) {
+        if ( ! $size ) {
             $size = 31;
         }
         /** @var int $size */
@@ -367,15 +367,15 @@ 
         // Initialize:
         $ret0 = 0;
         $ret1 = 0;
-        $a0 = $a->limbs[0];
-        $a1 = $a->limbs[1];
-        $b0 = $b->limbs[0];
-        $b1 = $b->limbs[1];
+        $a0 = $a->limbs[ 0 ];
+        $a1 = $a->limbs[ 1 ];
+        $b0 = $b->limbs[ 0 ];
+        $b1 = $b->limbs[ 1 ];
 
         /** @var int $size */
         /** @var int $i */
-        for ($i = $size; $i >= 0; --$i) {
-            $m = (int) (-($b1 & 1));
+        for ( $i = $size; $i >= 0; --$i ) {
+            $m = (int)(-( $b1 & 1 ));
             $x0 = $a0 & $m;
             $x1 = $a1 & $m;
 
@@ -387,22 +387,22 @@ 
             $ret0 &= 0xffff;
             $ret1 &= 0xffff;
 
-            $a1 = ($a1 << 1);
+            $a1 = ( $a1 << 1 );
             $x1 = $a1 >> 16;
-            $a0 = ($a0 << 1) | $x1;
+            $a0 = ( $a0 << 1 ) | $x1;
             $a0 &= 0xffff;
             $a1 &= 0xffff;
 
-            $x0 = ($b0 & 1) << 16;
-            $b0 = ($b0 >> 1);
-            $b1 = (($b1 | $x0) >> 1);
+            $x0 = ( $b0 & 1 ) << 16;
+            $b0 = ( $b0 >> 1 );
+            $b1 = ( ( $b1 | $x0 ) >> 1 );
 
             $b0 &= 0xffff;
             $b1 &= 0xffff;
 
         }
-        $return->limbs[0] = $ret0;
-        $return->limbs[1] = $ret1;
+        $return->limbs[ 0 ] = $ret0;
+        $return->limbs[ 1 ] = $ret1;
 
         return $return;
     }
@@ -413,13 +413,13 @@ 
      * @param ParagonIE_Sodium_Core32_Int32 $b
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function orInt32(ParagonIE_Sodium_Core32_Int32 $b)
+    public function orInt32( ParagonIE_Sodium_Core32_Int32 $b )
     {
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->unsignedInt = $this->unsignedInt;
         $return->limbs = array(
-            (int) ($this->limbs[0] | $b->limbs[0]),
-            (int) ($this->limbs[1] | $b->limbs[1])
+            (int)( $this->limbs[ 0 ] | $b->limbs[ 0 ] ),
+            (int)( $this->limbs[ 1 ] | $b->limbs[ 1 ] )
         );
         /** @var int overflow */
         $return->overflow = $this->overflow | $b->overflow;
@@ -430,18 +430,18 @@ 
      * @param int $b
      * @return bool
      */
-    public function isGreaterThan($b = 0)
+    public function isGreaterThan( $b = 0 )
     {
-        return $this->compareInt($b) > 0;
+        return $this->compareInt( $b ) > 0;
     }
 
     /**
      * @param int $b
      * @return bool
      */
-    public function isLessThanInt($b = 0)
+    public function isLessThanInt( $b = 0 )
     {
-        return $this->compareInt($b) < 0;
+        return $this->compareInt( $b ) < 0;
     }
 
     /**
@@ -451,43 +451,43 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArrayAccess
      */
-    public function rotateLeft($c = 0)
+    public function rotateLeft( $c = 0 )
     {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
+        ParagonIE_Sodium_Core32_Util::declareScalarType( $c, 'int', 1 );
         /** @var int $c */
-        $c = (int) $c;
+        $c = (int)$c;
 
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->unsignedInt = $this->unsignedInt;
         $c &= 31;
-        if ($c === 0) {
+        if ( $c === 0 ) {
             // NOP, but we want a copy.
             $return->limbs = $this->limbs;
         } else {
             /** @var int $c */
 
             /** @var int $idx_shift */
-            $idx_shift = ($c >> 4) & 1;
+            $idx_shift = ( $c >> 4 ) & 1;
 
             /** @var int $sub_shift */
             $sub_shift = $c & 15;
 
             /** @var array<int, int> $limbs */
-            $limbs =& $return->limbs;
+            $limbs = & $return->limbs;
 
             /** @var array<int, int> $myLimbs */
-            $myLimbs =& $this->limbs;
+            $myLimbs = & $this->limbs;
 
-            for ($i = 1; $i >= 0; --$i) {
+            for ( $i = 1; $i >= 0; --$i ) {
                 /** @var int $j */
-                $j = ($i + $idx_shift) & 1;
+                $j = ( $i + $idx_shift ) & 1;
                 /** @var int $k */
-                $k = ($i + $idx_shift + 1) & 1;
-                $limbs[$i] = (int) (
+                $k = ( $i + $idx_shift + 1 ) & 1;
+                $limbs[ $i ] = (int)(
                     (
-                        ((int) ($myLimbs[$j]) << $sub_shift)
+                        ( (int)( $myLimbs[ $j ] ) << $sub_shift )
                             |
-                        ((int) ($myLimbs[$k]) >> (16 - $sub_shift))
+                        ( (int)( $myLimbs[ $k ] ) >> ( 16 - $sub_shift ) )
                     ) & 0xffff
                 );
             }
@@ -504,44 +504,44 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArrayAccess
      */
-    public function rotateRight($c = 0)
+    public function rotateRight( $c = 0 )
     {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
+        ParagonIE_Sodium_Core32_Util::declareScalarType( $c, 'int', 1 );
         /** @var int $c */
-        $c = (int) $c;
+        $c = (int)$c;
 
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->unsignedInt = $this->unsignedInt;
         $c &= 31;
         /** @var int $c */
-        if ($c === 0) {
+        if ( $c === 0 ) {
             // NOP, but we want a copy.
             $return->limbs = $this->limbs;
         } else {
             /** @var int $c */
 
             /** @var int $idx_shift */
-            $idx_shift = ($c >> 4) & 1;
+            $idx_shift = ( $c >> 4 ) & 1;
 
             /** @var int $sub_shift */
             $sub_shift = $c & 15;
 
             /** @var array<int, int> $limbs */
-            $limbs =& $return->limbs;
+            $limbs = & $return->limbs;
 
             /** @var array<int, int> $myLimbs */
-            $myLimbs =& $this->limbs;
+            $myLimbs = & $this->limbs;
 
-            for ($i = 1; $i >= 0; --$i) {
+            for ( $i = 1; $i >= 0; --$i ) {
                 /** @var int $j */
-                $j = ($i - $idx_shift) & 1;
+                $j = ( $i - $idx_shift ) & 1;
                 /** @var int $k */
-                $k = ($i - $idx_shift - 1) & 1;
-                $limbs[$i] = (int) (
+                $k = ( $i - $idx_shift - 1 ) & 1;
+                $limbs[ $i ] = (int)(
                     (
-                        ((int) ($myLimbs[$j]) >> (int) ($sub_shift))
+                        ( (int)( $myLimbs[ $j ] ) >> (int)( $sub_shift ) )
                             |
-                        ((int) ($myLimbs[$k]) << (16 - (int) ($sub_shift)))
+                        ( (int)( $myLimbs[ $k ] ) << ( 16 - (int)( $sub_shift ) ) )
                     ) & 0xffff
                 );
             }
@@ -553,9 +553,9 @@ 
      * @param bool $bool
      * @return self
      */
-    public function setUnsignedInt($bool = false)
+    public function setUnsignedInt( $bool = false )
     {
-        $this->unsignedInt = !empty($bool);
+        $this->unsignedInt = ! empty( $bool );
         return $this;
     }
 
@@ -565,32 +565,32 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public function shiftLeft($c = 0)
+    public function shiftLeft( $c = 0 )
     {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
+        ParagonIE_Sodium_Core32_Util::declareScalarType( $c, 'int', 1 );
         /** @var int $c */
-        $c = (int) $c;
+        $c = (int)$c;
 
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->unsignedInt = $this->unsignedInt;
         $c &= 63;
         /** @var int $c */
-        if ($c === 0) {
+        if ( $c === 0 ) {
             $return->limbs = $this->limbs;
-        } elseif ($c < 0) {
+        } elseif ( $c < 0 ) {
             /** @var int $c */
             return $this->shiftRight(-$c);
         } else {
             /** @var int $c */
             /** @var int $tmp */
-            $tmp = $this->limbs[1] << $c;
-            $return->limbs[1] = (int)($tmp & 0xffff);
+            $tmp = $this->limbs[ 1 ] << $c;
+            $return->limbs[ 1 ] = (int)( $tmp & 0xffff );
             /** @var int $carry */
             $carry = $tmp >> 16;
 
             /** @var int $tmp */
-            $tmp = ($this->limbs[0] << $c) | ($carry & 0xffff);
-            $return->limbs[0] = (int) ($tmp & 0xffff);
+            $tmp = ( $this->limbs[ 0 ] << $c ) | ( $carry & 0xffff );
+            $return->limbs[ 0 ] = (int)( $tmp & 0xffff );
         }
         return $return;
     }
@@ -603,39 +603,39 @@ 
      * @psalm-suppress MixedAssignment
      * @psalm-suppress MixedOperand
      */
-    public function shiftRight($c = 0)
+    public function shiftRight( $c = 0 )
     {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
+        ParagonIE_Sodium_Core32_Util::declareScalarType( $c, 'int', 1 );
         /** @var int $c */
-        $c = (int) $c;
+        $c = (int)$c;
 
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->unsignedInt = $this->unsignedInt;
         $c &= 63;
         /** @var int $c */
-        if ($c >= 16) {
+        if ( $c >= 16 ) {
             $return->limbs = array(
-                (int) ($this->overflow & 0xffff),
-                (int) ($this->limbs[0])
+                (int)( $this->overflow & 0xffff ),
+                (int)( $this->limbs[ 0 ] )
             );
             $return->overflow = $this->overflow >> 16;
-            return $return->shiftRight($c & 15);
+            return $return->shiftRight( $c & 15 );
         }
-        if ($c === 0) {
+        if ( $c === 0 ) {
             $return->limbs = $this->limbs;
-        } elseif ($c < 0) {
+        } elseif ( $c < 0 ) {
             /** @var int $c */
             return $this->shiftLeft(-$c);
         } else {
-            if (!is_int($c)) {
+            if ( ! is_int( $c ) ) {
                 throw new TypeError();
             }
             /** @var int $c */
             // $return->limbs[0] = (int) (($this->limbs[0] >> $c) & 0xffff);
-            $carryLeft = (int) ($this->overflow & ((1 << ($c + 1)) - 1));
-            $return->limbs[0] = (int) ((($this->limbs[0] >> $c) | ($carryLeft << (16 - $c))) & 0xffff);
-            $carryRight = (int) ($this->limbs[0] & ((1 << ($c + 1)) - 1));
-            $return->limbs[1] = (int) ((($this->limbs[1] >> $c) | ($carryRight << (16 - $c))) & 0xffff);
+            $carryLeft = (int)( $this->overflow & ( ( 1 << ( $c + 1 ) ) - 1 ) );
+            $return->limbs[ 0 ] = (int)( ( ( $this->limbs[ 0 ] >> $c ) | ( $carryLeft << ( 16 - $c ) ) ) & 0xffff );
+            $carryRight = (int)( $this->limbs[ 0 ] & ( ( 1 << ( $c + 1 ) ) - 1 ) );
+            $return->limbs[ 1 ] = (int)( ( ( $this->limbs[ 1 ] >> $c ) | ( $carryRight << ( 16 - $c ) ) ) & 0xffff );
             $return->overflow >>= $c;
         }
         return $return;
@@ -649,24 +649,24 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public function subInt($int)
+    public function subInt( $int )
     {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
+        ParagonIE_Sodium_Core32_Util::declareScalarType( $int, 'int', 1 );
         /** @var int $int */
-        $int = (int) $int;
+        $int = (int)$int;
 
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->unsignedInt = $this->unsignedInt;
 
         /** @var int $tmp */
-        $tmp = $this->limbs[1] - ($int & 0xffff);
+        $tmp = $this->limbs[ 1 ] - ( $int & 0xffff );
         /** @var int $carry */
         $carry = $tmp >> 16;
-        $return->limbs[1] = (int) ($tmp & 0xffff);
+        $return->limbs[ 1 ] = (int)( $tmp & 0xffff );
 
         /** @var int $tmp */
-        $tmp = $this->limbs[0] - (($int >> 16) & 0xffff) + $carry;
-        $return->limbs[0] = (int) ($tmp & 0xffff);
+        $tmp = $this->limbs[ 0 ] - ( ( $int >> 16 ) & 0xffff ) + $carry;
+        $return->limbs[ 0 ] = (int)( $tmp & 0xffff );
         return $return;
     }
 
@@ -676,20 +676,20 @@ 
      * @param ParagonIE_Sodium_Core32_Int32 $b
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function subInt32(ParagonIE_Sodium_Core32_Int32 $b)
+    public function subInt32( ParagonIE_Sodium_Core32_Int32 $b )
     {
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->unsignedInt = $this->unsignedInt;
 
         /** @var int $tmp */
-        $tmp = $this->limbs[1] - ($b->limbs[1] & 0xffff);
+        $tmp = $this->limbs[ 1 ] - ( $b->limbs[ 1 ] & 0xffff );
         /** @var int $carry */
         $carry = $tmp >> 16;
-        $return->limbs[1] = (int) ($tmp & 0xffff);
+        $return->limbs[ 1 ] = (int)( $tmp & 0xffff );
 
         /** @var int $tmp */
-        $tmp = $this->limbs[0] - ($b->limbs[0] & 0xffff) + $carry;
-        $return->limbs[0] = (int) ($tmp & 0xffff);
+        $tmp = $this->limbs[ 0 ] - ( $b->limbs[ 0 ] & 0xffff ) + $carry;
+        $return->limbs[ 0 ] = (int)( $tmp & 0xffff );
         return $return;
     }
 
@@ -699,13 +699,13 @@ 
      * @param ParagonIE_Sodium_Core32_Int32 $b
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function xorInt32(ParagonIE_Sodium_Core32_Int32 $b)
+    public function xorInt32( ParagonIE_Sodium_Core32_Int32 $b )
     {
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->unsignedInt = $this->unsignedInt;
         $return->limbs = array(
-            (int) ($this->limbs[0] ^ $b->limbs[0]),
-            (int) ($this->limbs[1] ^ $b->limbs[1])
+            (int)( $this->limbs[ 0 ] ^ $b->limbs[ 0 ] ),
+            (int)( $this->limbs[ 1 ] ^ $b->limbs[ 1 ] )
         );
         return $return;
     }
@@ -716,16 +716,16 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function fromInt($signed)
+    public static function fromInt( $signed )
     {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($signed, 'int', 1);;
+        ParagonIE_Sodium_Core32_Util::declareScalarType( $signed, 'int', 1 ); ;
         /** @var int $signed */
-        $signed = (int) $signed;
+        $signed = (int)$signed;
 
         return new ParagonIE_Sodium_Core32_Int32(
             array(
-                (int) (($signed >> 16) & 0xffff),
-                (int) ($signed & 0xffff)
+                (int)( ( $signed >> 16 ) & 0xffff ),
+                (int)( $signed & 0xffff )
             )
         );
     }
@@ -736,21 +736,21 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function fromString($string)
+    public static function fromString( $string )
     {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);
-        $string = (string) $string;
-        if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 4) {
+        ParagonIE_Sodium_Core32_Util::declareScalarType( $string, 'string', 1 );
+        $string = (string)$string;
+        if ( ParagonIE_Sodium_Core32_Util::strlen( $string ) !== 4 ) {
             throw new RangeException(
-                'String must be 4 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen($string) . ' given.'
+                'String must be 4 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen( $string ) . ' given.'
             );
         }
         $return = new ParagonIE_Sodium_Core32_Int32();
 
-        $return->limbs[0]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[0]) & 0xff) << 8);
-        $return->limbs[0] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[1]) & 0xff);
-        $return->limbs[1]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[2]) & 0xff) << 8);
-        $return->limbs[1] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[3]) & 0xff);
+        $return->limbs[ 0 ]  = (int)( ( ParagonIE_Sodium_Core32_Util::chrToInt( $string[ 0 ] ) & 0xff ) << 8 );
+        $return->limbs[ 0 ] |= ( ParagonIE_Sodium_Core32_Util::chrToInt( $string[ 1 ] ) & 0xff );
+        $return->limbs[ 1 ]  = (int)( ( ParagonIE_Sodium_Core32_Util::chrToInt( $string[ 2 ] ) & 0xff ) << 8 );
+        $return->limbs[ 1 ] |= ( ParagonIE_Sodium_Core32_Util::chrToInt( $string[ 3 ] ) & 0xff );
         return $return;
     }
 
@@ -760,21 +760,21 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function fromReverseString($string)
+    public static function fromReverseString( $string )
     {
-        ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);
-        $string = (string) $string;
-        if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 4) {
+        ParagonIE_Sodium_Core32_Util::declareScalarType( $string, 'string', 1 );
+        $string = (string)$string;
+        if ( ParagonIE_Sodium_Core32_Util::strlen( $string ) !== 4 ) {
             throw new RangeException(
-                'String must be 4 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen($string) . ' given.'
+                'String must be 4 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen( $string ) . ' given.'
             );
         }
         $return = new ParagonIE_Sodium_Core32_Int32();
 
-        $return->limbs[0]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[3]) & 0xff) << 8);
-        $return->limbs[0] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[2]) & 0xff);
-        $return->limbs[1]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[1]) & 0xff) << 8);
-        $return->limbs[1] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[0]) & 0xff);
+        $return->limbs[ 0 ]  = (int)( ( ParagonIE_Sodium_Core32_Util::chrToInt( $string[ 3 ] ) & 0xff ) << 8 );
+        $return->limbs[ 0 ] |= ( ParagonIE_Sodium_Core32_Util::chrToInt( $string[ 2 ] ) & 0xff );
+        $return->limbs[ 1 ]  = (int)( ( ParagonIE_Sodium_Core32_Util::chrToInt( $string[ 1 ] ) & 0xff ) << 8 );
+        $return->limbs[ 1 ] |= ( ParagonIE_Sodium_Core32_Util::chrToInt( $string[ 0 ] ) & 0xff );
         return $return;
     }
 
@@ -783,7 +783,7 @@ 
      */
     public function toArray()
     {
-        return array((int) ($this->limbs[0] << 16 | $this->limbs[1]));
+        return array( (int)( $this->limbs[ 0 ] << 16 | $this->limbs[ 1 ] ) );
     }
 
     /**
@@ -793,10 +793,10 @@ 
     public function toString()
     {
         return
-            ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[0] >> 8) & 0xff) .
-            ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[0] & 0xff) .
-            ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[1] >> 8) & 0xff) .
-            ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[1] & 0xff);
+            ParagonIE_Sodium_Core32_Util::intToChr( ( $this->limbs[ 0 ] >> 8 ) & 0xff ) .
+            ParagonIE_Sodium_Core32_Util::intToChr( $this->limbs[ 0 ] & 0xff ) .
+            ParagonIE_Sodium_Core32_Util::intToChr( ( $this->limbs[ 1 ] >> 8 ) & 0xff ) .
+            ParagonIE_Sodium_Core32_Util::intToChr( $this->limbs[ 1 ] & 0xff );
     }
 
     /**
@@ -804,10 +804,10 @@ 
      */
     public function toInt()
     {
-        return (int) (
-            (($this->limbs[0] & 0xffff) << 16)
+        return (int)(
+            ( ( $this->limbs[ 0 ] & 0xffff ) << 16 )
                 |
-            ($this->limbs[1] & 0xffff)
+            ( $this->limbs[ 1 ] & 0xffff )
         );
     }
 
@@ -817,10 +817,10 @@ 
     public function toInt32()
     {
         $return = new ParagonIE_Sodium_Core32_Int32();
-        $return->limbs[0] = (int) ($this->limbs[0] & 0xffff);
-        $return->limbs[1] = (int) ($this->limbs[1] & 0xffff);
+        $return->limbs[ 0 ] = (int)( $this->limbs[ 0 ] & 0xffff );
+        $return->limbs[ 1 ] = (int)( $this->limbs[ 1 ] & 0xffff );
         $return->unsignedInt = $this->unsignedInt;
-        $return->overflow = (int) ($this->overflow & 0x7fffffff);
+        $return->overflow = (int)( $this->overflow & 0x7fffffff );
         return $return;
     }
 
@@ -831,16 +831,16 @@ 
     {
         $return = new ParagonIE_Sodium_Core32_Int64();
         $return->unsignedInt = $this->unsignedInt;
-        if ($this->unsignedInt) {
-            $return->limbs[0] += (($this->overflow >> 16) & 0xffff);
-            $return->limbs[1] += (($this->overflow) & 0xffff);
+        if ( $this->unsignedInt ) {
+            $return->limbs[ 0 ] += ( ( $this->overflow >> 16 ) & 0xffff );
+            $return->limbs[ 1 ] += ( ( $this->overflow ) & 0xffff );
         } else {
-            $neg = -(($this->limbs[0] >> 15) & 1);
-            $return->limbs[0] = (int)($neg & 0xffff);
-            $return->limbs[1] = (int)($neg & 0xffff);
+            $neg = -( ( $this->limbs[ 0 ] >> 15 ) & 1 );
+            $return->limbs[ 0 ] = (int)( $neg & 0xffff );
+            $return->limbs[ 1 ] = (int)( $neg & 0xffff );
         }
-        $return->limbs[2] = (int) ($this->limbs[0] & 0xffff);
-        $return->limbs[3] = (int) ($this->limbs[1] & 0xffff);
+        $return->limbs[ 2 ] = (int)( $this->limbs[ 0 ] & 0xffff );
+        $return->limbs[ 3 ] = (int)( $this->limbs[ 1 ] & 0xffff );
         return $return;
     }
 
@@ -850,10 +850,10 @@ 
      */
     public function toReverseString()
     {
-        return ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[1] & 0xff) .
-            ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[1] >> 8) & 0xff) .
-            ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[0] & 0xff) .
-            ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[0] >> 8) & 0xff);
+        return ParagonIE_Sodium_Core32_Util::intToChr( $this->limbs[ 1 ] & 0xff ) .
+            ParagonIE_Sodium_Core32_Util::intToChr( ( $this->limbs[ 1 ] >> 8 ) & 0xff ) .
+            ParagonIE_Sodium_Core32_Util::intToChr( $this->limbs[ 0 ] & 0xff ) .
+            ParagonIE_Sodium_Core32_Util::intToChr( ( $this->limbs[ 0 ] >> 8 ) & 0xff );
     }
 
     /**
@@ -863,7 +863,7 @@ 
     {
         try {
             return $this->toString();
-        } catch (TypeError $ex) {
+        } catch ( TypeError $ex ) {
             // PHP engine can't handle exceptions from __toString()
             return '';
         }

Braces +32 added lines, -64 removed lines

@@ -7,8 +7,7 @@ 
  *
  * These are immutable. It always returns a new instance.
  */
-class ParagonIE_Sodium_Core32_Int32
-{
+class ParagonIE_Sodium_Core32_Int32 {
     /**
      * @var array<int, int> - two 16-bit integers
      *
@@ -32,8 +31,7 @@ 
      * @param array $array
      * @param bool $unsignedInt
      */
-    public function __construct($array = array(0, 0), $unsignedInt = false)
-    {
+    public function __construct($array = array(0, 0), $unsignedInt = false) {
         $this->limbs = array(
             (int) $array[0],
             (int) $array[1]
@@ -48,8 +46,7 @@ 
      * @param ParagonIE_Sodium_Core32_Int32 $addend
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function addInt32(ParagonIE_Sodium_Core32_Int32 $addend)
-    {
+    public function addInt32(ParagonIE_Sodium_Core32_Int32 $addend) {
         $i0 = $this->limbs[0];
         $i1 = $this->limbs[1];
         $j0 = $addend->limbs[0];
@@ -80,8 +77,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public function addInt($int)
-    {
+    public function addInt($int) {
         ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
         /** @var int $int */
         $int = (int) $int;
@@ -110,8 +106,7 @@ 
      * @param int $b
      * @return int
      */
-    public function compareInt($b = 0)
-    {
+    public function compareInt($b = 0) {
         $gt = 0;
         $eq = 1;
 
@@ -135,8 +130,7 @@ 
      * @param int $m
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function mask($m = 0)
-    {
+    public function mask($m = 0) {
         /** @var int $hi */
         $hi = ($m >> 16) & 0xffff;
         /** @var int $lo */
@@ -156,8 +150,7 @@ 
      * @param int $baseLog2
      * @return array<int, int>
      */
-    public function multiplyLong(array $a, array $b, $baseLog2 = 16)
-    {
+    public function multiplyLong(array $a, array $b, $baseLog2 = 16) {
         $a_l = count($a);
         $b_l = count($b);
         /** @var array<int, int> $r */
@@ -180,8 +173,7 @@ 
      * @param int $int
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function mulIntFast($int)
-    {
+    public function mulIntFast($int) {
         // Handle negative numbers
         $aNeg = ($this->limbs[0] >> 15) & 1;
         $bNeg = ($int >> 31) & 1;
@@ -236,8 +228,7 @@ 
      * @param ParagonIE_Sodium_Core32_Int32 $right
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function mulInt32Fast(ParagonIE_Sodium_Core32_Int32 $right)
-    {
+    public function mulInt32Fast(ParagonIE_Sodium_Core32_Int32 $right) {
         $aNeg = ($this->limbs[0] >> 15) & 1;
         $bNeg = ($right->limbs[0] >> 15) & 1;
 
@@ -287,8 +278,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public function mulInt($int = 0, $size = 0)
-    {
+    public function mulInt($int = 0, $size = 0) {
         ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
         ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
         if (ParagonIE_Sodium_Compat::$fastMult) {
@@ -348,8 +338,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public function mulInt32(ParagonIE_Sodium_Core32_Int32 $int, $size = 0)
-    {
+    public function mulInt32(ParagonIE_Sodium_Core32_Int32 $int, $size = 0) {
         ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
         if (ParagonIE_Sodium_Compat::$fastMult) {
             return $this->mulInt32Fast($int);
@@ -413,8 +402,7 @@ 
      * @param ParagonIE_Sodium_Core32_Int32 $b
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function orInt32(ParagonIE_Sodium_Core32_Int32 $b)
-    {
+    public function orInt32(ParagonIE_Sodium_Core32_Int32 $b) {
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->unsignedInt = $this->unsignedInt;
         $return->limbs = array(
@@ -430,8 +418,7 @@ 
      * @param int $b
      * @return bool
      */
-    public function isGreaterThan($b = 0)
-    {
+    public function isGreaterThan($b = 0) {
         return $this->compareInt($b) > 0;
     }
 
@@ -439,8 +426,7 @@ 
      * @param int $b
      * @return bool
      */
-    public function isLessThanInt($b = 0)
-    {
+    public function isLessThanInt($b = 0) {
         return $this->compareInt($b) < 0;
     }
 
@@ -451,8 +437,7 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArrayAccess
      */
-    public function rotateLeft($c = 0)
-    {
+    public function rotateLeft($c = 0) {
         ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
         /** @var int $c */
         $c = (int) $c;
@@ -504,8 +489,7 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArrayAccess
      */
-    public function rotateRight($c = 0)
-    {
+    public function rotateRight($c = 0) {
         ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
         /** @var int $c */
         $c = (int) $c;
@@ -553,8 +537,7 @@ 
      * @param bool $bool
      * @return self
      */
-    public function setUnsignedInt($bool = false)
-    {
+    public function setUnsignedInt($bool = false) {
         $this->unsignedInt = !empty($bool);
         return $this;
     }
@@ -565,8 +548,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public function shiftLeft($c = 0)
-    {
+    public function shiftLeft($c = 0) {
         ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
         /** @var int $c */
         $c = (int) $c;
@@ -603,8 +585,7 @@ 
      * @psalm-suppress MixedAssignment
      * @psalm-suppress MixedOperand
      */
-    public function shiftRight($c = 0)
-    {
+    public function shiftRight($c = 0) {
         ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
         /** @var int $c */
         $c = (int) $c;
@@ -649,8 +630,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public function subInt($int)
-    {
+    public function subInt($int) {
         ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
         /** @var int $int */
         $int = (int) $int;
@@ -676,8 +656,7 @@ 
      * @param ParagonIE_Sodium_Core32_Int32 $b
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function subInt32(ParagonIE_Sodium_Core32_Int32 $b)
-    {
+    public function subInt32(ParagonIE_Sodium_Core32_Int32 $b) {
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->unsignedInt = $this->unsignedInt;
 
@@ -699,8 +678,7 @@ 
      * @param ParagonIE_Sodium_Core32_Int32 $b
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function xorInt32(ParagonIE_Sodium_Core32_Int32 $b)
-    {
+    public function xorInt32(ParagonIE_Sodium_Core32_Int32 $b) {
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->unsignedInt = $this->unsignedInt;
         $return->limbs = array(
@@ -716,8 +694,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function fromInt($signed)
-    {
+    public static function fromInt($signed) {
         ParagonIE_Sodium_Core32_Util::declareScalarType($signed, 'int', 1);;
         /** @var int $signed */
         $signed = (int) $signed;
@@ -736,8 +713,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function fromString($string)
-    {
+    public static function fromString($string) {
         ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);
         $string = (string) $string;
         if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 4) {
@@ -760,8 +736,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function fromReverseString($string)
-    {
+    public static function fromReverseString($string) {
         ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);
         $string = (string) $string;
         if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 4) {
@@ -781,8 +756,7 @@ 
     /**
      * @return array<int, int>
      */
-    public function toArray()
-    {
+    public function toArray() {
         return array((int) ($this->limbs[0] << 16 | $this->limbs[1]));
     }
 
@@ -790,8 +764,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public function toString()
-    {
+    public function toString() {
         return
             ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[0] >> 8) & 0xff) .
             ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[0] & 0xff) .
@@ -802,8 +775,7 @@ 
     /**
      * @return int
      */
-    public function toInt()
-    {
+    public function toInt() {
         return (int) (
             (($this->limbs[0] & 0xffff) << 16)
                 |
@@ -814,8 +786,7 @@ 
     /**
      * @return ParagonIE_Sodium_Core32_Int32
      */
-    public function toInt32()
-    {
+    public function toInt32() {
         $return = new ParagonIE_Sodium_Core32_Int32();
         $return->limbs[0] = (int) ($this->limbs[0] & 0xffff);
         $return->limbs[1] = (int) ($this->limbs[1] & 0xffff);
@@ -827,8 +798,7 @@ 
     /**
      * @return ParagonIE_Sodium_Core32_Int64
      */
-    public function toInt64()
-    {
+    public function toInt64() {
         $return = new ParagonIE_Sodium_Core32_Int64();
         $return->unsignedInt = $this->unsignedInt;
         if ($this->unsignedInt) {
@@ -848,8 +818,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public function toReverseString()
-    {
+    public function toReverseString() {
         return ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[1] & 0xff) .
             ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[1] >> 8) & 0xff) .
             ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[0] & 0xff) .
@@ -859,8 +828,7 @@ 
     /**
      * @return string
      */
-    public function __toString()
-    {
+    public function __toString() {
         try {
             return $this->toString();
         } catch (TypeError $ex) {

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

Indentation +50 added lines, -50 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core32_Poly1305', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,55 +9,55 @@ 
  */
 abstract class ParagonIE_Sodium_Core32_Poly1305 extends ParagonIE_Sodium_Core32_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_Core32_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_Core32_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_Core32_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_Core32_Poly1305_State(
+			self::substr($key, 0, 32)
+		);
+		$calc = $state
+			->update($m)
+			->finish();
+		return self::verify_16($calc, $mac);
+	}
 }

Spacing +10 added lines, -10 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core32_Poly1305', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core32_Poly1305', false ) ) {
     return;
 }
 
@@ -20,18 +20,18 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function onetimeauth($m, $key)
+    public static function onetimeauth( $m, $key )
     {
-        if (self::strlen($key) < 32) {
+        if ( self::strlen( $key ) < 32 ) {
             throw new InvalidArgumentException(
                 'Key must be 32 bytes long.'
             );
         }
         $state = new ParagonIE_Sodium_Core32_Poly1305_State(
-            self::substr($key, 0, 32)
+            self::substr( $key, 0, 32 )
         );
         return $state
-            ->update($m)
+            ->update( $m )
             ->finish();
     }
 
@@ -45,19 +45,19 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function onetimeauth_verify($mac, $m, $key)
+    public static function onetimeauth_verify( $mac, $m, $key )
     {
-        if (self::strlen($key) < 32) {
+        if ( self::strlen( $key ) < 32 ) {
             throw new InvalidArgumentException(
                 'Key must be 32 bytes long.'
             );
         }
         $state = new ParagonIE_Sodium_Core32_Poly1305_State(
-            self::substr($key, 0, 32)
+            self::substr( $key, 0, 32 )
         );
         $calc = $state
-            ->update($m)
+            ->update( $m )
             ->finish();
-        return self::verify_16($calc, $mac);
+        return self::verify_16( $calc, $mac );
     }
 }

Braces +3 added lines, -6 removed lines

@@ -7,8 +7,7 @@ 
 /**
  * Class ParagonIE_Sodium_Core32_Poly1305
  */
-abstract class ParagonIE_Sodium_Core32_Poly1305 extends ParagonIE_Sodium_Core32_Util
-{
+abstract class ParagonIE_Sodium_Core32_Poly1305 extends ParagonIE_Sodium_Core32_Util {
     const BLOCK_SIZE = 16;
 
     /**
@@ -20,8 +19,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function onetimeauth($m, $key)
-    {
+    public static function onetimeauth($m, $key) {
         if (self::strlen($key) < 32) {
             throw new InvalidArgumentException(
                 'Key must be 32 bytes long.'
@@ -45,8 +43,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function onetimeauth_verify($mac, $m, $key)
-    {
+    public static function onetimeauth_verify($mac, $m, $key) {
         if (self::strlen($key) < 32) {
             throw new InvalidArgumentException(
                 'Key must be 32 bytes long.'