gravityview / GravityView

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

Indentation +540 added lines, -540 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_Ed25519', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,543 +9,543 @@ 
  */
 abstract class ParagonIE_Sodium_Core_Ed25519 extends ParagonIE_Sodium_Core_Curve25519
 {
-    const KEYPAIR_BYTES = 96;
-    const SEED_BYTES = 32;
-    const SCALAR_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 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(self::substr($pk, 0, 32));
-        $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
-     */
-    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');
-        hash_update($hs, self::substr($az, 32, 32));
-        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');
-        hash_update($hs, self::substr($sig, 0, 32));
-        hash_update($hs, self::substr($pk, 0, 32));
-        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_Core_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_Core_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');
-        }
-        $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
-        );
-        $c = 0;
-        $n = 1;
-        $i = 32;
-
-        /** @var array<int, int> $L */
-        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)
-    {
-        /** @var array<int, array<int, int>> $blocklist */
-        $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 int $countBlocklist */
-        $countBlocklist = count($blocklist);
-
-        for ($i = 0; $i < $countBlocklist; ++$i) {
-            $c = 0;
-            for ($j = 0; $j < 32; ++$j) {
-                $c |= self::chrToInt($R[$j]) ^ (int) $blocklist[$i][$j];
-            }
-            if ($c === 0) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * @param string $s
-     * @return string
-     * @throws SodiumException
-     */
-    public static function scalar_complement($s)
-    {
-        $t_ = self::L . str_repeat("\x00", 32);
-        sodium_increment($t_);
-        $s_ = $s . str_repeat("\x00", 32);
-        ParagonIE_Sodium_Compat::sub($t_, $s_);
-        return self::sc_reduce($t_);
-    }
-
-    /**
-     * @return string
-     * @throws SodiumException
-     */
-    public static function scalar_random()
-    {
-        do {
-            $r = ParagonIE_Sodium_Compat::randombytes_buf(self::SCALAR_BYTES);
-            $r[self::SCALAR_BYTES - 1] = self::intToChr(
-                self::chrToInt($r[self::SCALAR_BYTES - 1]) & 0x1f
-            );
-        } while (
-            !self::check_S_lt_L($r) || ParagonIE_Sodium_Compat::is_zero($r)
-        );
-        return $r;
-    }
-
-    /**
-     * @param string $s
-     * @return string
-     * @throws SodiumException
-     */
-    public static function scalar_negate($s)
-    {
-        $t_ = self::L . str_repeat("\x00", 32) ;
-        $s_ = $s . str_repeat("\x00", 32) ;
-        ParagonIE_Sodium_Compat::sub($t_, $s_);
-        return self::sc_reduce($t_);
-    }
-
-    /**
-     * @param string $a
-     * @param string $b
-     * @return string
-     * @throws SodiumException
-     */
-    public static function scalar_add($a, $b)
-    {
-        $a_ = $a . str_repeat("\x00", 32);
-        $b_ = $b . str_repeat("\x00", 32);
-        ParagonIE_Sodium_Compat::add($a_, $b_);
-        return self::sc_reduce($a_);
-    }
-
-    /**
-     * @param string $x
-     * @param string $y
-     * @return string
-     * @throws SodiumException
-     */
-    public static function scalar_sub($x, $y)
-    {
-        $yn = self::scalar_negate($y);
-        return self::scalar_add($x, $yn);
-    }
+	const KEYPAIR_BYTES = 96;
+	const SEED_BYTES = 32;
+	const SCALAR_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 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(self::substr($pk, 0, 32));
+		$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
+	 */
+	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');
+		hash_update($hs, self::substr($az, 32, 32));
+		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');
+		hash_update($hs, self::substr($sig, 0, 32));
+		hash_update($hs, self::substr($pk, 0, 32));
+		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_Core_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_Core_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');
+		}
+		$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
+		);
+		$c = 0;
+		$n = 1;
+		$i = 32;
+
+		/** @var array<int, int> $L */
+		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)
+	{
+		/** @var array<int, array<int, int>> $blocklist */
+		$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 int $countBlocklist */
+		$countBlocklist = count($blocklist);
+
+		for ($i = 0; $i < $countBlocklist; ++$i) {
+			$c = 0;
+			for ($j = 0; $j < 32; ++$j) {
+				$c |= self::chrToInt($R[$j]) ^ (int) $blocklist[$i][$j];
+			}
+			if ($c === 0) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * @param string $s
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function scalar_complement($s)
+	{
+		$t_ = self::L . str_repeat("\x00", 32);
+		sodium_increment($t_);
+		$s_ = $s . str_repeat("\x00", 32);
+		ParagonIE_Sodium_Compat::sub($t_, $s_);
+		return self::sc_reduce($t_);
+	}
+
+	/**
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function scalar_random()
+	{
+		do {
+			$r = ParagonIE_Sodium_Compat::randombytes_buf(self::SCALAR_BYTES);
+			$r[self::SCALAR_BYTES - 1] = self::intToChr(
+				self::chrToInt($r[self::SCALAR_BYTES - 1]) & 0x1f
+			);
+		} while (
+			!self::check_S_lt_L($r) || ParagonIE_Sodium_Compat::is_zero($r)
+		);
+		return $r;
+	}
+
+	/**
+	 * @param string $s
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function scalar_negate($s)
+	{
+		$t_ = self::L . str_repeat("\x00", 32) ;
+		$s_ = $s . str_repeat("\x00", 32) ;
+		ParagonIE_Sodium_Compat::sub($t_, $s_);
+		return self::sc_reduce($t_);
+	}
+
+	/**
+	 * @param string $a
+	 * @param string $b
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function scalar_add($a, $b)
+	{
+		$a_ = $a . str_repeat("\x00", 32);
+		$b_ = $b . str_repeat("\x00", 32);
+		ParagonIE_Sodium_Compat::add($a_, $b_);
+		return self::sc_reduce($a_);
+	}
+
+	/**
+	 * @param string $x
+	 * @param string $y
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function scalar_sub($x, $y)
+	{
+		$yn = self::scalar_negate($y);
+		return self::scalar_add($x, $yn);
+	}
 }

Spacing +117 added lines, -117 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_Ed25519', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_Ed25519', false ) ) {
     return;
 }
 
@@ -23,10 +23,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;
     }
 
@@ -40,14 +40,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;
     }
@@ -59,12 +59,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 @@ 
      * @return string
      * @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(self::substr($pk, 0, 32));
-        $p1 = self::ge_mul_l($A);
-        if (!self::fe_isnonzero($p1->X)) {
-            throw new SodiumException('Unexpected zero result');
+        $A = self::ge_frombytes_negate_vartime( self::substr( $pk, 0, 32 ) );
+        $p1 = self::ge_mul_l( $A );
+        if ( ! self::fe_isnonzero( $p1->X ) ) {
+            throw new SodiumException( 'Unexpected zero result' );
         }
 
         # fe_1(one_minus_y);
@@ -134,12 +134,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 );
     }
 
     /**
@@ -150,11 +150,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 )
             )
         );
     }
@@ -168,10 +168,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;
     }
 
@@ -184,18 +184,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' );
     }
 
     /**
@@ -207,56 +207,56 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    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');
-        hash_update($hs, self::substr($az, 32, 32));
-        hash_update($hs, $message);
-        $nonceHash = hash_final($hs, true);
+        $hs = hash_init( 'sha512' );
+        hash_update( $hs, self::substr( $az, 32, 32 ) );
+        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');
-        hash_update($hs, self::substr($sig, 0, 32));
-        hash_update($hs, self::substr($pk, 0, 32));
-        hash_update($hs, $message);
-        $hramHash = hash_final($hs, true);
+        $hs = hash_init( 'sha512' );
+        hash_update( $hs, self::substr( $sig, 0, 32 ) );
+        hash_update( $hs, self::substr( $pk, 0, 32 ) );
+        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;
@@ -272,26 +272,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 */
@@ -301,34 +301,34 @@ 
         ParagonIE_Sodium_Compat::$fastMult = true;
 
         /** @var ParagonIE_Sodium_Core_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_Core_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 ) );
     }
 
     /**
@@ -339,10 +339,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' );
         }
         $L = array(
             0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58,
@@ -357,14 +357,14 @@ 
         /** @var array<int, int> $L */
         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;
     }
@@ -375,7 +375,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function small_order($R)
+    public static function small_order( $R )
     {
         /** @var array<int, array<int, int>> $blocklist */
         $blocklist = array(
@@ -465,14 +465,14 @@ 
             )
         );
         /** @var int $countBlocklist */
-        $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]) ^ (int) $blocklist[$i][$j];
+            for ( $j = 0; $j < 32; ++$j ) {
+                $c |= self::chrToInt( $R[ $j ] ) ^ (int)$blocklist[ $i ][ $j ];
             }
-            if ($c === 0) {
+            if ( $c === 0 ) {
                 return true;
             }
         }
@@ -484,13 +484,13 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_complement($s)
+    public static function scalar_complement( $s )
     {
-        $t_ = self::L . str_repeat("\x00", 32);
-        sodium_increment($t_);
-        $s_ = $s . str_repeat("\x00", 32);
-        ParagonIE_Sodium_Compat::sub($t_, $s_);
-        return self::sc_reduce($t_);
+        $t_ = self::L . str_repeat( "\x00", 32 );
+        sodium_increment( $t_ );
+        $s_ = $s . str_repeat( "\x00", 32 );
+        ParagonIE_Sodium_Compat::sub( $t_, $s_ );
+        return self::sc_reduce( $t_ );
     }
 
     /**
@@ -500,12 +500,12 @@ 
     public static function scalar_random()
     {
         do {
-            $r = ParagonIE_Sodium_Compat::randombytes_buf(self::SCALAR_BYTES);
-            $r[self::SCALAR_BYTES - 1] = self::intToChr(
-                self::chrToInt($r[self::SCALAR_BYTES - 1]) & 0x1f
+            $r = ParagonIE_Sodium_Compat::randombytes_buf( self::SCALAR_BYTES );
+            $r[ self::SCALAR_BYTES - 1 ] = self::intToChr(
+                self::chrToInt( $r[ self::SCALAR_BYTES - 1 ] ) & 0x1f
             );
         } while (
-            !self::check_S_lt_L($r) || ParagonIE_Sodium_Compat::is_zero($r)
+            ! self::check_S_lt_L( $r ) || ParagonIE_Sodium_Compat::is_zero( $r )
         );
         return $r;
     }
@@ -515,12 +515,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_negate($s)
+    public static function scalar_negate( $s )
     {
-        $t_ = self::L . str_repeat("\x00", 32) ;
-        $s_ = $s . str_repeat("\x00", 32) ;
-        ParagonIE_Sodium_Compat::sub($t_, $s_);
-        return self::sc_reduce($t_);
+        $t_ = self::L . str_repeat( "\x00", 32 );
+        $s_ = $s . str_repeat( "\x00", 32 );
+        ParagonIE_Sodium_Compat::sub( $t_, $s_ );
+        return self::sc_reduce( $t_ );
     }
 
     /**
@@ -529,12 +529,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_add($a, $b)
+    public static function scalar_add( $a, $b )
     {
-        $a_ = $a . str_repeat("\x00", 32);
-        $b_ = $b . str_repeat("\x00", 32);
-        ParagonIE_Sodium_Compat::add($a_, $b_);
-        return self::sc_reduce($a_);
+        $a_ = $a . str_repeat( "\x00", 32 );
+        $b_ = $b . str_repeat( "\x00", 32 );
+        ParagonIE_Sodium_Compat::add( $a_, $b_ );
+        return self::sc_reduce( $a_ );
     }
 
     /**
@@ -543,9 +543,9 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_sub($x, $y)
+    public static function scalar_sub( $x, $y )
     {
-        $yn = self::scalar_negate($y);
-        return self::scalar_add($x, $yn);
+        $yn = self::scalar_negate( $y );
+        return self::scalar_add( $x, $yn );
     }
 }

Braces +19 added lines, -38 removed lines

@@ -7,8 +7,7 @@ 
 /**
  * Class ParagonIE_Sodium_Core_Ed25519
  */
-abstract class ParagonIE_Sodium_Core_Ed25519 extends ParagonIE_Sodium_Core_Curve25519
-{
+abstract class ParagonIE_Sodium_Core_Ed25519 extends ParagonIE_Sodium_Core_Curve25519 {
     const KEYPAIR_BYTES = 96;
     const SEED_BYTES = 32;
     const SCALAR_BYTES = 32;
@@ -21,8 +20,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function keypair()
-    {
+    public static function keypair() {
         $seed = random_bytes(self::SEED_BYTES);
         $pk = '';
         $sk = '';
@@ -40,8 +38,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');
         }
@@ -59,8 +56,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 @@ 
      * @return string
      * @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');
         }
@@ -150,8 +143,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)
@@ -168,8 +160,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;
@@ -184,8 +175,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);
 
@@ -207,8 +197,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    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);
 
@@ -272,8 +261,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');
         }
@@ -339,8 +327,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');
         }
@@ -375,8 +362,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function small_order($R)
-    {
+    public static function small_order($R) {
         /** @var array<int, array<int, int>> $blocklist */
         $blocklist = array(
             /* 0 (order 4) */
@@ -484,8 +470,7 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_complement($s)
-    {
+    public static function scalar_complement($s) {
         $t_ = self::L . str_repeat("\x00", 32);
         sodium_increment($t_);
         $s_ = $s . str_repeat("\x00", 32);
@@ -497,8 +482,7 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_random()
-    {
+    public static function scalar_random() {
         do {
             $r = ParagonIE_Sodium_Compat::randombytes_buf(self::SCALAR_BYTES);
             $r[self::SCALAR_BYTES - 1] = self::intToChr(
@@ -515,8 +499,7 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_negate($s)
-    {
+    public static function scalar_negate($s) {
         $t_ = self::L . str_repeat("\x00", 32) ;
         $s_ = $s . str_repeat("\x00", 32) ;
         ParagonIE_Sodium_Compat::sub($t_, $s_);
@@ -529,8 +512,7 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_add($a, $b)
-    {
+    public static function scalar_add($a, $b) {
         $a_ = $a . str_repeat("\x00", 32);
         $b_ = $b . str_repeat("\x00", 32);
         ParagonIE_Sodium_Compat::add($a_, $b_);
@@ -543,8 +525,7 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_sub($x, $y)
-    {
+    public static function scalar_sub($x, $y) {
         $yn = self::scalar_negate($y);
         return self::scalar_add($x, $yn);
     }

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

Indentation +936 added lines, -936 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_Util', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,939 +9,939 @@ 
  */
 abstract class ParagonIE_Sodium_Core_Util
 {
-    /**
-     * @param int $integer
-     * @param int $size (16, 32, 64)
-     * @return int
-     */
-    public static function abs($integer, $size = 0)
-    {
-        /** @var int $realSize */
-        $realSize = (PHP_INT_SIZE << 3) - 1;
-        if ($size) {
-            --$size;
-        } else {
-            /** @var int $size */
-            $size = $realSize;
-        }
-
-        $negative = -(($integer >> $size) & 1);
-        return (int) (
-            ($integer ^ $negative)
-                +
-            (($negative >> $realSize) & 1)
-        );
-    }
-
-    /**
-     * Convert a binary string into a hexadecimal string without cache-timing
-     * leaks
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $binaryString (raw binary)
-     * @return string
-     * @throws TypeError
-     */
-    public static function bin2hex($binaryString)
-    {
-        /* Type checks: */
-        if (!is_string($binaryString)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($binaryString) . ' given.');
-        }
-
-        $hex = '';
-        $len = self::strlen($binaryString);
-        for ($i = 0; $i < $len; ++$i) {
-            /** @var array<int, int> $chunk */
-            $chunk = unpack('C', $binaryString[$i]);
-            /** @var int $c */
-            $c = $chunk[1] & 0xf;
-            /** @var int $b */
-            $b = $chunk[1] >> 4;
-            $hex .= pack(
-                'CC',
-                (87 + $b + ((($b - 10) >> 8) & ~38)),
-                (87 + $c + ((($c - 10) >> 8) & ~38))
-            );
-        }
-        return $hex;
-    }
-
-    /**
-     * Convert a binary string into a hexadecimal string without cache-timing
-     * leaks, returning uppercase letters (as per RFC 4648)
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $bin_string (raw binary)
-     * @return string
-     * @throws TypeError
-     */
-    public static function bin2hexUpper($bin_string)
-    {
-        $hex = '';
-        $len = self::strlen($bin_string);
-        for ($i = 0; $i < $len; ++$i) {
-            /** @var array<int, int> $chunk */
-            $chunk = unpack('C', $bin_string[$i]);
-            /**
-             * Lower 16 bits
-             *
-             * @var int $c
-             */
-            $c = $chunk[1] & 0xf;
-
-            /**
-             * Upper 16 bits
-             * @var int $b
-             */
-            $b = $chunk[1] >> 4;
-
-            /**
-             * Use pack() and binary operators to turn the two integers
-             * into hexadecimal characters. We don't use chr() here, because
-             * it uses a lookup table internally and we want to avoid
-             * cache-timing side-channels.
-             */
-            $hex .= pack(
-                'CC',
-                (55 + $b + ((($b - 10) >> 8) & ~6)),
-                (55 + $c + ((($c - 10) >> 8) & ~6))
-            );
-        }
-        return $hex;
-    }
-
-    /**
-     * Cache-timing-safe variant of ord()
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $chr
-     * @return int
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function chrToInt($chr)
-    {
-        /* Type checks: */
-        if (!is_string($chr)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($chr) . ' given.');
-        }
-        if (self::strlen($chr) !== 1) {
-            throw new SodiumException('chrToInt() expects a string that is exactly 1 character long');
-        }
-        /** @var array<int, int> $chunk */
-        $chunk = unpack('C', $chr);
-        return (int) ($chunk[1]);
-    }
-
-    /**
-     * Compares two strings.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $left
-     * @param string $right
-     * @param int $len
-     * @return int
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function compare($left, $right, $len = null)
-    {
-        $leftLen = self::strlen($left);
-        $rightLen = self::strlen($right);
-        if ($len === null) {
-            $len = max($leftLen, $rightLen);
-            $left = str_pad($left, $len, "\x00", STR_PAD_RIGHT);
-            $right = str_pad($right, $len, "\x00", STR_PAD_RIGHT);
-        }
-
-        $gt = 0;
-        $eq = 1;
-        $i = $len;
-        while ($i !== 0) {
-            --$i;
-            $gt |= ((self::chrToInt($right[$i]) - self::chrToInt($left[$i])) >> 8) & $eq;
-            $eq &= ((self::chrToInt($right[$i]) ^ self::chrToInt($left[$i])) - 1) >> 8;
-        }
-        return ($gt + $gt + $eq) - 1;
-    }
-
-    /**
-     * If a variable does not match a given type, throw a TypeError.
-     *
-     * @param mixed $mixedVar
-     * @param string $type
-     * @param int $argumentIndex
-     * @throws TypeError
-     * @throws SodiumException
-     * @return void
-     */
-    public static function declareScalarType(&$mixedVar = null, $type = 'void', $argumentIndex = 0)
-    {
-        if (func_num_args() === 0) {
-            /* Tautology, by default */
-            return;
-        }
-        if (func_num_args() === 1) {
-            throw new TypeError('Declared void, but passed a variable');
-        }
-        $realType = strtolower(gettype($mixedVar));
-        $type = strtolower($type);
-        switch ($type) {
-            case 'null':
-                if ($mixedVar !== null) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be null, ' . $realType . ' given.');
-                }
-                break;
-            case 'integer':
-            case 'int':
-                $allow = array('int', 'integer');
-                if (!in_array($type, $allow)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be an integer, ' . $realType . ' given.');
-                }
-                $mixedVar = (int) $mixedVar;
-                break;
-            case 'boolean':
-            case 'bool':
-                $allow = array('bool', 'boolean');
-                if (!in_array($type, $allow)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be a boolean, ' . $realType . ' given.');
-                }
-                $mixedVar = (bool) $mixedVar;
-                break;
-            case 'string':
-                if (!is_string($mixedVar)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be a string, ' . $realType . ' given.');
-                }
-                $mixedVar = (string) $mixedVar;
-                break;
-            case 'decimal':
-            case 'double':
-            case 'float':
-                $allow = array('decimal', 'double', 'float');
-                if (!in_array($type, $allow)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be a float, ' . $realType . ' given.');
-                }
-                $mixedVar = (float) $mixedVar;
-                break;
-            case 'object':
-                if (!is_object($mixedVar)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be an object, ' . $realType . ' given.');
-                }
-                break;
-            case 'array':
-                if (!is_array($mixedVar)) {
-                    if (is_object($mixedVar)) {
-                        if ($mixedVar instanceof ArrayAccess) {
-                            return;
-                        }
-                    }
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be an array, ' . $realType . ' given.');
-                }
-                break;
-            default:
-                throw new SodiumException('Unknown type (' . $realType .') does not match expect type (' . $type . ')');
-        }
-    }
-
-    /**
-     * Evaluate whether or not two strings are equal (in constant-time)
-     *
-     * @param string $left
-     * @param string $right
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function hashEquals($left, $right)
-    {
-        /* Type checks: */
-        if (!is_string($left)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($left) . ' given.');
-        }
-        if (!is_string($right)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($right) . ' given.');
-        }
-
-        if (is_callable('hash_equals')) {
-            return hash_equals($left, $right);
-        }
-        $d = 0;
-        /** @var int $len */
-        $len = self::strlen($left);
-        if ($len !== self::strlen($right)) {
-            return false;
-        }
-        for ($i = 0; $i < $len; ++$i) {
-            $d |= self::chrToInt($left[$i]) ^ self::chrToInt($right[$i]);
-        }
-
-        if ($d !== 0) {
-            return false;
-        }
-        return $left === $right;
-    }
-
-    /**
-     * Catch hash_update() failures and throw instead of silently proceeding
-     *
-     * @param HashContext|resource &$hs
-     * @param string $data
-     * @return void
-     * @throws SodiumException
-     * @psalm-suppress PossiblyInvalidArgument
-     */
-    protected static function hash_update(&$hs, $data)
-    {
-        if (!hash_update($hs, $data)) {
-            throw new SodiumException('hash_update() failed');
-        }
-    }
-
-    /**
-     * Convert a hexadecimal string into a binary string without cache-timing
-     * leaks
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $hexString
-     * @param bool $strictPadding
-     * @return string (raw binary)
-     * @throws RangeException
-     * @throws TypeError
-     */
-    public static function hex2bin($hexString, $strictPadding = false)
-    {
-        /* Type checks: */
-        if (!is_string($hexString)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($hexString) . ' given.');
-        }
-
-        /** @var int $hex_pos */
-        $hex_pos = 0;
-        /** @var string $bin */
-        $bin = '';
-        /** @var int $c_acc */
-        $c_acc = 0;
-        /** @var int $hex_len */
-        $hex_len = self::strlen($hexString);
-        /** @var int $state */
-        $state = 0;
-        if (($hex_len & 1) !== 0) {
-            if ($strictPadding) {
-                throw new RangeException(
-                    'Expected an even number of hexadecimal characters'
-                );
-            } else {
-                $hexString = '0' . $hexString;
-                ++$hex_len;
-            }
-        }
-
-        $chunk = unpack('C*', $hexString);
-        while ($hex_pos < $hex_len) {
-            ++$hex_pos;
-            /** @var int $c */
-            $c = $chunk[$hex_pos];
-            /** @var int $c_num */
-            $c_num = $c ^ 48;
-            /** @var int $c_num0 */
-            $c_num0 = ($c_num - 10) >> 8;
-            /** @var int $c_alpha */
-            $c_alpha = ($c & ~32) - 55;
-            /** @var int $c_alpha0 */
-            $c_alpha0 = (($c_alpha - 10) ^ ($c_alpha - 16)) >> 8;
-            if (($c_num0 | $c_alpha0) === 0) {
-                throw new RangeException(
-                    'hex2bin() only expects hexadecimal characters'
-                );
-            }
-            /** @var int $c_val */
-            $c_val = ($c_num0 & $c_num) | ($c_alpha & $c_alpha0);
-            if ($state === 0) {
-                $c_acc = $c_val * 16;
-            } else {
-                $bin .= pack('C', $c_acc | $c_val);
-            }
-            $state ^= 1;
-        }
-        return $bin;
-    }
-
-    /**
-     * Turn an array of integers into a string
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param array<int, int> $ints
-     * @return string
-     */
-    public static function intArrayToString(array $ints)
-    {
-        /** @var array<int, int> $args */
-        $args = $ints;
-        foreach ($args as $i => $v) {
-            $args[$i] = (int) ($v & 0xff);
-        }
-        array_unshift($args, str_repeat('C', count($ints)));
-        return (string) (call_user_func_array('pack', $args));
-    }
-
-    /**
-     * Cache-timing-safe variant of ord()
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int $int
-     * @return string
-     * @throws TypeError
-     */
-    public static function intToChr($int)
-    {
-        return pack('C', $int);
-    }
-
-    /**
-     * Load a 3 character substring into an integer
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $string
-     * @return int
-     * @throws RangeException
-     * @throws TypeError
-     */
-    public static function load_3($string)
-    {
-        /* Type checks: */
-        if (!is_string($string)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($string) < 3) {
-            throw new RangeException(
-                'String must be 3 bytes or more; ' . self::strlen($string) . ' given.'
-            );
-        }
-        /** @var array<int, int> $unpacked */
-        $unpacked = unpack('V', $string . "\0");
-        return (int) ($unpacked[1] & 0xffffff);
-    }
-
-    /**
-     * Load a 4 character substring into an integer
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $string
-     * @return int
-     * @throws RangeException
-     * @throws TypeError
-     */
-    public static function load_4($string)
-    {
-        /* Type checks: */
-        if (!is_string($string)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($string) < 4) {
-            throw new RangeException(
-                'String must be 4 bytes or more; ' . self::strlen($string) . ' given.'
-            );
-        }
-        /** @var array<int, int> $unpacked */
-        $unpacked = unpack('V', $string);
-        return (int) ($unpacked[1] & 0xffffffff);
-    }
-
-    /**
-     * Load a 8 character substring into an integer
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $string
-     * @return int
-     * @throws RangeException
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function load64_le($string)
-    {
-        /* Type checks: */
-        if (!is_string($string)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($string) < 4) {
-            throw new RangeException(
-                'String must be 4 bytes or more; ' . self::strlen($string) . ' given.'
-            );
-        }
-        if (PHP_VERSION_ID >= 50603 && PHP_INT_SIZE === 8) {
-            /** @var array<int, int> $unpacked */
-            $unpacked = unpack('P', $string);
-            return (int) $unpacked[1];
-        }
-
-        /** @var int $result */
-        $result  = (self::chrToInt($string[0]) & 0xff);
-        $result |= (self::chrToInt($string[1]) & 0xff) <<  8;
-        $result |= (self::chrToInt($string[2]) & 0xff) << 16;
-        $result |= (self::chrToInt($string[3]) & 0xff) << 24;
-        $result |= (self::chrToInt($string[4]) & 0xff) << 32;
-        $result |= (self::chrToInt($string[5]) & 0xff) << 40;
-        $result |= (self::chrToInt($string[6]) & 0xff) << 48;
-        $result |= (self::chrToInt($string[7]) & 0xff) << 56;
-        return (int) $result;
-    }
-
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param string $left
-     * @param string $right
-     * @return int
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function memcmp($left, $right)
-    {
-        if (self::hashEquals($left, $right)) {
-            return 0;
-        }
-        return -1;
-    }
-
-    /**
-     * Multiply two integers in constant-time
-     *
-     * Micro-architecture timing side-channels caused by how your CPU
-     * implements multiplication are best prevented by never using the
-     * multiplication operators and ensuring that our code always takes
-     * the same number of operations to complete, regardless of the values
-     * of $a and $b.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int $a
-     * @param int $b
-     * @param int $size Limits the number of operations (useful for small,
-     *                  constant operands)
-     * @return int
-     */
-    public static function mul($a, $b, $size = 0)
-    {
-        if (ParagonIE_Sodium_Compat::$fastMult) {
-            return (int) ($a * $b);
-        }
-
-        static $defaultSize = null;
-        /** @var int $defaultSize */
-        if (!$defaultSize) {
-            /** @var int $defaultSize */
-            $defaultSize = (PHP_INT_SIZE << 3) - 1;
-        }
-        if ($size < 1) {
-            /** @var int $size */
-            $size = $defaultSize;
-        }
-        /** @var int $size */
-
-        $c = 0;
-
-        /**
-         * Mask is either -1 or 0.
-         *
-         * -1 in binary looks like 0x1111 ... 1111
-         *  0 in binary looks like 0x0000 ... 0000
-         *
-         * @var int
-         */
-        $mask = -(($b >> ((int) $defaultSize)) & 1);
-
-        /**
-         * Ensure $b is a positive integer, without creating
-         * a branching side-channel
-         *
-         * @var int $b
-         */
-        $b = ($b & ~$mask) | ($mask & -$b);
-
-        /**
-         * Unless $size is provided:
-         *
-         * This loop always runs 32 times when PHP_INT_SIZE is 4.
-         * This loop always runs 64 times when PHP_INT_SIZE is 8.
-         */
-        for ($i = $size; $i >= 0; --$i) {
-            $c += (int) ($a & -($b & 1));
-            $a <<= 1;
-            $b >>= 1;
-        }
-        $c = (int) @($c & -1);
-
-        /**
-         * If $b was negative, we then apply the same value to $c here.
-         * It doesn't matter much if $a was negative; the $c += above would
-         * have produced a negative integer to begin with. But a negative $b
-         * makes $b >>= 1 never return 0, so we would end up with incorrect
-         * results.
-         *
-         * The end result is what we'd expect from integer multiplication.
-         */
-        return (int) (($c & ~$mask) | ($mask & -$c));
-    }
-
-    /**
-     * Convert any arbitrary numbers into two 32-bit integers that represent
-     * a 64-bit integer.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int|float $num
-     * @return array<int, int>
-     */
-    public static function numericTo64BitInteger($num)
-    {
-        $high = 0;
-        /** @var int $low */
-        $low = $num & 0xffffffff;
-
-        if ((+(abs($num))) >= 1) {
-            if ($num > 0) {
-                /** @var int $high */
-                $high = min((+(floor($num/4294967296))), 4294967295);
-            } else {
-                /** @var int $high */
-                $high = ~~((+(ceil(($num - (+((~~($num)))))/4294967296))));
-            }
-        }
-        return array((int) $high, (int) $low);
-    }
-
-    /**
-     * Store a 24-bit integer into a string, treating it as big-endian.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int $int
-     * @return string
-     * @throws TypeError
-     */
-    public static function store_3($int)
-    {
-        /* Type checks: */
-        if (!is_int($int)) {
-            if (is_numeric($int)) {
-                $int = (int) $int;
-            } else {
-                throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
-            }
-        }
-        /** @var string $packed */
-        $packed = pack('N', $int);
-        return self::substr($packed, 1, 3);
-    }
-
-    /**
-     * Store a 32-bit integer into a string, treating it as little-endian.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int $int
-     * @return string
-     * @throws TypeError
-     */
-    public static function store32_le($int)
-    {
-        /* Type checks: */
-        if (!is_int($int)) {
-            if (is_numeric($int)) {
-                $int = (int) $int;
-            } else {
-                throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
-            }
-        }
-
-        /** @var string $packed */
-        $packed = pack('V', $int);
-        return $packed;
-    }
-
-    /**
-     * Store a 32-bit integer into a string, treating it as big-endian.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int $int
-     * @return string
-     * @throws TypeError
-     */
-    public static function store_4($int)
-    {
-        /* Type checks: */
-        if (!is_int($int)) {
-            if (is_numeric($int)) {
-                $int = (int) $int;
-            } else {
-                throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
-            }
-        }
-
-        /** @var string $packed */
-        $packed = pack('N', $int);
-        return $packed;
-    }
-
-    /**
-     * Stores a 64-bit integer as an string, treating it as little-endian.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param int $int
-     * @return string
-     * @throws TypeError
-     */
-    public static function store64_le($int)
-    {
-        /* Type checks: */
-        if (!is_int($int)) {
-            if (is_numeric($int)) {
-                $int = (int) $int;
-            } else {
-                throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
-            }
-        }
-
-        if (PHP_INT_SIZE === 8) {
-            if (PHP_VERSION_ID >= 50603) {
-                /** @var string $packed */
-                $packed = pack('P', $int);
-                return $packed;
-            }
-            return self::intToChr($int & 0xff) .
-                self::intToChr(($int >>  8) & 0xff) .
-                self::intToChr(($int >> 16) & 0xff) .
-                self::intToChr(($int >> 24) & 0xff) .
-                self::intToChr(($int >> 32) & 0xff) .
-                self::intToChr(($int >> 40) & 0xff) .
-                self::intToChr(($int >> 48) & 0xff) .
-                self::intToChr(($int >> 56) & 0xff);
-        }
-        if ($int > PHP_INT_MAX) {
-            list($hiB, $int) = self::numericTo64BitInteger($int);
-        } else {
-            $hiB = 0;
-        }
-        return
-            self::intToChr(($int      ) & 0xff) .
-            self::intToChr(($int >>  8) & 0xff) .
-            self::intToChr(($int >> 16) & 0xff) .
-            self::intToChr(($int >> 24) & 0xff) .
-            self::intToChr($hiB & 0xff) .
-            self::intToChr(($hiB >>  8) & 0xff) .
-            self::intToChr(($hiB >> 16) & 0xff) .
-            self::intToChr(($hiB >> 24) & 0xff);
-    }
-
-    /**
-     * Safe string length
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @ref mbstring.func_overload
-     *
-     * @param string $str
-     * @return int
-     * @throws TypeError
-     */
-    public static function strlen($str)
-    {
-        /* Type checks: */
-        if (!is_string($str)) {
-            throw new TypeError('String expected');
-        }
-
-        return (int) (
-        self::isMbStringOverride()
-            ? mb_strlen($str, '8bit')
-            : strlen($str)
-        );
-    }
-
-    /**
-     * Turn a string into an array of integers
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $string
-     * @return array<int, int>
-     * @throws TypeError
-     */
-    public static function stringToIntArray($string)
-    {
-        if (!is_string($string)) {
-            throw new TypeError('String expected');
-        }
-        /**
-         * @var array<int, int>
-         */
-        $values = array_values(
-            unpack('C*', $string)
-        );
-        return $values;
-    }
-
-    /**
-     * Safe substring
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @ref mbstring.func_overload
-     *
-     * @param string $str
-     * @param int $start
-     * @param int $length
-     * @return string
-     * @throws TypeError
-     */
-    public static function substr($str, $start = 0, $length = null)
-    {
-        /* Type checks: */
-        if (!is_string($str)) {
-            throw new TypeError('String expected');
-        }
-
-        if ($length === 0) {
-            return '';
-        }
-
-        if (self::isMbStringOverride()) {
-            if (PHP_VERSION_ID < 50400 && $length === null) {
-                $length = self::strlen($str);
-            }
-            $sub = (string) mb_substr($str, $start, $length, '8bit');
-        } elseif ($length === null) {
-            $sub = (string) substr($str, $start);
-        } else {
-            $sub = (string) substr($str, $start, $length);
-        }
-        if ($sub !== '') {
-            return $sub;
-        }
-        return '';
-    }
-
-    /**
-     * Compare a 16-character byte string in constant time.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $a
-     * @param string $b
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function verify_16($a, $b)
-    {
-        /* Type checks: */
-        if (!is_string($a)) {
-            throw new TypeError('String expected');
-        }
-        if (!is_string($b)) {
-            throw new TypeError('String expected');
-        }
-        return self::hashEquals(
-            self::substr($a, 0, 16),
-            self::substr($b, 0, 16)
-        );
-    }
-
-    /**
-     * Compare a 32-character byte string in constant time.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $a
-     * @param string $b
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function verify_32($a, $b)
-    {
-        /* Type checks: */
-        if (!is_string($a)) {
-            throw new TypeError('String expected');
-        }
-        if (!is_string($b)) {
-            throw new TypeError('String expected');
-        }
-        return self::hashEquals(
-            self::substr($a, 0, 32),
-            self::substr($b, 0, 32)
-        );
-    }
-
-    /**
-     * Calculate $a ^ $b for two strings.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $a
-     * @param string $b
-     * @return string
-     * @throws TypeError
-     */
-    public static function xorStrings($a, $b)
-    {
-        /* Type checks: */
-        if (!is_string($a)) {
-            throw new TypeError('Argument 1 must be a string');
-        }
-        if (!is_string($b)) {
-            throw new TypeError('Argument 2 must be a string');
-        }
-
-        return (string) ($a ^ $b);
-    }
-
-    /**
-     * Returns whether or not mbstring.func_overload is in effect.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * Note: MB_OVERLOAD_STRING === 2, but we don't reference the constant
-     * (for nuisance-free PHP 8 support)
-     *
-     * @return bool
-     */
-    protected static function isMbStringOverride()
-    {
-        static $mbstring = null;
-
-        if ($mbstring === null) {
-            if (!defined('MB_OVERLOAD_STRING')) {
-                $mbstring = false;
-                return $mbstring;
-            }
-            $mbstring = extension_loaded('mbstring')
-                && defined('MB_OVERLOAD_STRING')
-                &&
-            ((int) (ini_get('mbstring.func_overload')) & 2);
-            // MB_OVERLOAD_STRING === 2
-        }
-        /** @var bool $mbstring */
-
-        return $mbstring;
-    }
+	/**
+	 * @param int $integer
+	 * @param int $size (16, 32, 64)
+	 * @return int
+	 */
+	public static function abs($integer, $size = 0)
+	{
+		/** @var int $realSize */
+		$realSize = (PHP_INT_SIZE << 3) - 1;
+		if ($size) {
+			--$size;
+		} else {
+			/** @var int $size */
+			$size = $realSize;
+		}
+
+		$negative = -(($integer >> $size) & 1);
+		return (int) (
+			($integer ^ $negative)
+				+
+			(($negative >> $realSize) & 1)
+		);
+	}
+
+	/**
+	 * Convert a binary string into a hexadecimal string without cache-timing
+	 * leaks
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $binaryString (raw binary)
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function bin2hex($binaryString)
+	{
+		/* Type checks: */
+		if (!is_string($binaryString)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($binaryString) . ' given.');
+		}
+
+		$hex = '';
+		$len = self::strlen($binaryString);
+		for ($i = 0; $i < $len; ++$i) {
+			/** @var array<int, int> $chunk */
+			$chunk = unpack('C', $binaryString[$i]);
+			/** @var int $c */
+			$c = $chunk[1] & 0xf;
+			/** @var int $b */
+			$b = $chunk[1] >> 4;
+			$hex .= pack(
+				'CC',
+				(87 + $b + ((($b - 10) >> 8) & ~38)),
+				(87 + $c + ((($c - 10) >> 8) & ~38))
+			);
+		}
+		return $hex;
+	}
+
+	/**
+	 * Convert a binary string into a hexadecimal string without cache-timing
+	 * leaks, returning uppercase letters (as per RFC 4648)
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $bin_string (raw binary)
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function bin2hexUpper($bin_string)
+	{
+		$hex = '';
+		$len = self::strlen($bin_string);
+		for ($i = 0; $i < $len; ++$i) {
+			/** @var array<int, int> $chunk */
+			$chunk = unpack('C', $bin_string[$i]);
+			/**
+			 * Lower 16 bits
+			 *
+			 * @var int $c
+			 */
+			$c = $chunk[1] & 0xf;
+
+			/**
+			 * Upper 16 bits
+			 * @var int $b
+			 */
+			$b = $chunk[1] >> 4;
+
+			/**
+			 * Use pack() and binary operators to turn the two integers
+			 * into hexadecimal characters. We don't use chr() here, because
+			 * it uses a lookup table internally and we want to avoid
+			 * cache-timing side-channels.
+			 */
+			$hex .= pack(
+				'CC',
+				(55 + $b + ((($b - 10) >> 8) & ~6)),
+				(55 + $c + ((($c - 10) >> 8) & ~6))
+			);
+		}
+		return $hex;
+	}
+
+	/**
+	 * Cache-timing-safe variant of ord()
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $chr
+	 * @return int
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function chrToInt($chr)
+	{
+		/* Type checks: */
+		if (!is_string($chr)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($chr) . ' given.');
+		}
+		if (self::strlen($chr) !== 1) {
+			throw new SodiumException('chrToInt() expects a string that is exactly 1 character long');
+		}
+		/** @var array<int, int> $chunk */
+		$chunk = unpack('C', $chr);
+		return (int) ($chunk[1]);
+	}
+
+	/**
+	 * Compares two strings.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $left
+	 * @param string $right
+	 * @param int $len
+	 * @return int
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function compare($left, $right, $len = null)
+	{
+		$leftLen = self::strlen($left);
+		$rightLen = self::strlen($right);
+		if ($len === null) {
+			$len = max($leftLen, $rightLen);
+			$left = str_pad($left, $len, "\x00", STR_PAD_RIGHT);
+			$right = str_pad($right, $len, "\x00", STR_PAD_RIGHT);
+		}
+
+		$gt = 0;
+		$eq = 1;
+		$i = $len;
+		while ($i !== 0) {
+			--$i;
+			$gt |= ((self::chrToInt($right[$i]) - self::chrToInt($left[$i])) >> 8) & $eq;
+			$eq &= ((self::chrToInt($right[$i]) ^ self::chrToInt($left[$i])) - 1) >> 8;
+		}
+		return ($gt + $gt + $eq) - 1;
+	}
+
+	/**
+	 * If a variable does not match a given type, throw a TypeError.
+	 *
+	 * @param mixed $mixedVar
+	 * @param string $type
+	 * @param int $argumentIndex
+	 * @throws TypeError
+	 * @throws SodiumException
+	 * @return void
+	 */
+	public static function declareScalarType(&$mixedVar = null, $type = 'void', $argumentIndex = 0)
+	{
+		if (func_num_args() === 0) {
+			/* Tautology, by default */
+			return;
+		}
+		if (func_num_args() === 1) {
+			throw new TypeError('Declared void, but passed a variable');
+		}
+		$realType = strtolower(gettype($mixedVar));
+		$type = strtolower($type);
+		switch ($type) {
+			case 'null':
+				if ($mixedVar !== null) {
+					throw new TypeError('Argument ' . $argumentIndex . ' must be null, ' . $realType . ' given.');
+				}
+				break;
+			case 'integer':
+			case 'int':
+				$allow = array('int', 'integer');
+				if (!in_array($type, $allow)) {
+					throw new TypeError('Argument ' . $argumentIndex . ' must be an integer, ' . $realType . ' given.');
+				}
+				$mixedVar = (int) $mixedVar;
+				break;
+			case 'boolean':
+			case 'bool':
+				$allow = array('bool', 'boolean');
+				if (!in_array($type, $allow)) {
+					throw new TypeError('Argument ' . $argumentIndex . ' must be a boolean, ' . $realType . ' given.');
+				}
+				$mixedVar = (bool) $mixedVar;
+				break;
+			case 'string':
+				if (!is_string($mixedVar)) {
+					throw new TypeError('Argument ' . $argumentIndex . ' must be a string, ' . $realType . ' given.');
+				}
+				$mixedVar = (string) $mixedVar;
+				break;
+			case 'decimal':
+			case 'double':
+			case 'float':
+				$allow = array('decimal', 'double', 'float');
+				if (!in_array($type, $allow)) {
+					throw new TypeError('Argument ' . $argumentIndex . ' must be a float, ' . $realType . ' given.');
+				}
+				$mixedVar = (float) $mixedVar;
+				break;
+			case 'object':
+				if (!is_object($mixedVar)) {
+					throw new TypeError('Argument ' . $argumentIndex . ' must be an object, ' . $realType . ' given.');
+				}
+				break;
+			case 'array':
+				if (!is_array($mixedVar)) {
+					if (is_object($mixedVar)) {
+						if ($mixedVar instanceof ArrayAccess) {
+							return;
+						}
+					}
+					throw new TypeError('Argument ' . $argumentIndex . ' must be an array, ' . $realType . ' given.');
+				}
+				break;
+			default:
+				throw new SodiumException('Unknown type (' . $realType .') does not match expect type (' . $type . ')');
+		}
+	}
+
+	/**
+	 * Evaluate whether or not two strings are equal (in constant-time)
+	 *
+	 * @param string $left
+	 * @param string $right
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function hashEquals($left, $right)
+	{
+		/* Type checks: */
+		if (!is_string($left)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($left) . ' given.');
+		}
+		if (!is_string($right)) {
+			throw new TypeError('Argument 2 must be a string, ' . gettype($right) . ' given.');
+		}
+
+		if (is_callable('hash_equals')) {
+			return hash_equals($left, $right);
+		}
+		$d = 0;
+		/** @var int $len */
+		$len = self::strlen($left);
+		if ($len !== self::strlen($right)) {
+			return false;
+		}
+		for ($i = 0; $i < $len; ++$i) {
+			$d |= self::chrToInt($left[$i]) ^ self::chrToInt($right[$i]);
+		}
+
+		if ($d !== 0) {
+			return false;
+		}
+		return $left === $right;
+	}
+
+	/**
+	 * Catch hash_update() failures and throw instead of silently proceeding
+	 *
+	 * @param HashContext|resource &$hs
+	 * @param string $data
+	 * @return void
+	 * @throws SodiumException
+	 * @psalm-suppress PossiblyInvalidArgument
+	 */
+	protected static function hash_update(&$hs, $data)
+	{
+		if (!hash_update($hs, $data)) {
+			throw new SodiumException('hash_update() failed');
+		}
+	}
+
+	/**
+	 * Convert a hexadecimal string into a binary string without cache-timing
+	 * leaks
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $hexString
+	 * @param bool $strictPadding
+	 * @return string (raw binary)
+	 * @throws RangeException
+	 * @throws TypeError
+	 */
+	public static function hex2bin($hexString, $strictPadding = false)
+	{
+		/* Type checks: */
+		if (!is_string($hexString)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($hexString) . ' given.');
+		}
+
+		/** @var int $hex_pos */
+		$hex_pos = 0;
+		/** @var string $bin */
+		$bin = '';
+		/** @var int $c_acc */
+		$c_acc = 0;
+		/** @var int $hex_len */
+		$hex_len = self::strlen($hexString);
+		/** @var int $state */
+		$state = 0;
+		if (($hex_len & 1) !== 0) {
+			if ($strictPadding) {
+				throw new RangeException(
+					'Expected an even number of hexadecimal characters'
+				);
+			} else {
+				$hexString = '0' . $hexString;
+				++$hex_len;
+			}
+		}
+
+		$chunk = unpack('C*', $hexString);
+		while ($hex_pos < $hex_len) {
+			++$hex_pos;
+			/** @var int $c */
+			$c = $chunk[$hex_pos];
+			/** @var int $c_num */
+			$c_num = $c ^ 48;
+			/** @var int $c_num0 */
+			$c_num0 = ($c_num - 10) >> 8;
+			/** @var int $c_alpha */
+			$c_alpha = ($c & ~32) - 55;
+			/** @var int $c_alpha0 */
+			$c_alpha0 = (($c_alpha - 10) ^ ($c_alpha - 16)) >> 8;
+			if (($c_num0 | $c_alpha0) === 0) {
+				throw new RangeException(
+					'hex2bin() only expects hexadecimal characters'
+				);
+			}
+			/** @var int $c_val */
+			$c_val = ($c_num0 & $c_num) | ($c_alpha & $c_alpha0);
+			if ($state === 0) {
+				$c_acc = $c_val * 16;
+			} else {
+				$bin .= pack('C', $c_acc | $c_val);
+			}
+			$state ^= 1;
+		}
+		return $bin;
+	}
+
+	/**
+	 * Turn an array of integers into a string
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param array<int, int> $ints
+	 * @return string
+	 */
+	public static function intArrayToString(array $ints)
+	{
+		/** @var array<int, int> $args */
+		$args = $ints;
+		foreach ($args as $i => $v) {
+			$args[$i] = (int) ($v & 0xff);
+		}
+		array_unshift($args, str_repeat('C', count($ints)));
+		return (string) (call_user_func_array('pack', $args));
+	}
+
+	/**
+	 * Cache-timing-safe variant of ord()
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $int
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function intToChr($int)
+	{
+		return pack('C', $int);
+	}
+
+	/**
+	 * Load a 3 character substring into an integer
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $string
+	 * @return int
+	 * @throws RangeException
+	 * @throws TypeError
+	 */
+	public static function load_3($string)
+	{
+		/* Type checks: */
+		if (!is_string($string)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($string) < 3) {
+			throw new RangeException(
+				'String must be 3 bytes or more; ' . self::strlen($string) . ' given.'
+			);
+		}
+		/** @var array<int, int> $unpacked */
+		$unpacked = unpack('V', $string . "\0");
+		return (int) ($unpacked[1] & 0xffffff);
+	}
+
+	/**
+	 * Load a 4 character substring into an integer
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $string
+	 * @return int
+	 * @throws RangeException
+	 * @throws TypeError
+	 */
+	public static function load_4($string)
+	{
+		/* Type checks: */
+		if (!is_string($string)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($string) < 4) {
+			throw new RangeException(
+				'String must be 4 bytes or more; ' . self::strlen($string) . ' given.'
+			);
+		}
+		/** @var array<int, int> $unpacked */
+		$unpacked = unpack('V', $string);
+		return (int) ($unpacked[1] & 0xffffffff);
+	}
+
+	/**
+	 * Load a 8 character substring into an integer
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $string
+	 * @return int
+	 * @throws RangeException
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function load64_le($string)
+	{
+		/* Type checks: */
+		if (!is_string($string)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($string) < 4) {
+			throw new RangeException(
+				'String must be 4 bytes or more; ' . self::strlen($string) . ' given.'
+			);
+		}
+		if (PHP_VERSION_ID >= 50603 && PHP_INT_SIZE === 8) {
+			/** @var array<int, int> $unpacked */
+			$unpacked = unpack('P', $string);
+			return (int) $unpacked[1];
+		}
+
+		/** @var int $result */
+		$result  = (self::chrToInt($string[0]) & 0xff);
+		$result |= (self::chrToInt($string[1]) & 0xff) <<  8;
+		$result |= (self::chrToInt($string[2]) & 0xff) << 16;
+		$result |= (self::chrToInt($string[3]) & 0xff) << 24;
+		$result |= (self::chrToInt($string[4]) & 0xff) << 32;
+		$result |= (self::chrToInt($string[5]) & 0xff) << 40;
+		$result |= (self::chrToInt($string[6]) & 0xff) << 48;
+		$result |= (self::chrToInt($string[7]) & 0xff) << 56;
+		return (int) $result;
+	}
+
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $left
+	 * @param string $right
+	 * @return int
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function memcmp($left, $right)
+	{
+		if (self::hashEquals($left, $right)) {
+			return 0;
+		}
+		return -1;
+	}
+
+	/**
+	 * Multiply two integers in constant-time
+	 *
+	 * Micro-architecture timing side-channels caused by how your CPU
+	 * implements multiplication are best prevented by never using the
+	 * multiplication operators and ensuring that our code always takes
+	 * the same number of operations to complete, regardless of the values
+	 * of $a and $b.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $a
+	 * @param int $b
+	 * @param int $size Limits the number of operations (useful for small,
+	 *                  constant operands)
+	 * @return int
+	 */
+	public static function mul($a, $b, $size = 0)
+	{
+		if (ParagonIE_Sodium_Compat::$fastMult) {
+			return (int) ($a * $b);
+		}
+
+		static $defaultSize = null;
+		/** @var int $defaultSize */
+		if (!$defaultSize) {
+			/** @var int $defaultSize */
+			$defaultSize = (PHP_INT_SIZE << 3) - 1;
+		}
+		if ($size < 1) {
+			/** @var int $size */
+			$size = $defaultSize;
+		}
+		/** @var int $size */
+
+		$c = 0;
+
+		/**
+		 * Mask is either -1 or 0.
+		 *
+		 * -1 in binary looks like 0x1111 ... 1111
+		 *  0 in binary looks like 0x0000 ... 0000
+		 *
+		 * @var int
+		 */
+		$mask = -(($b >> ((int) $defaultSize)) & 1);
+
+		/**
+		 * Ensure $b is a positive integer, without creating
+		 * a branching side-channel
+		 *
+		 * @var int $b
+		 */
+		$b = ($b & ~$mask) | ($mask & -$b);
+
+		/**
+		 * Unless $size is provided:
+		 *
+		 * This loop always runs 32 times when PHP_INT_SIZE is 4.
+		 * This loop always runs 64 times when PHP_INT_SIZE is 8.
+		 */
+		for ($i = $size; $i >= 0; --$i) {
+			$c += (int) ($a & -($b & 1));
+			$a <<= 1;
+			$b >>= 1;
+		}
+		$c = (int) @($c & -1);
+
+		/**
+		 * If $b was negative, we then apply the same value to $c here.
+		 * It doesn't matter much if $a was negative; the $c += above would
+		 * have produced a negative integer to begin with. But a negative $b
+		 * makes $b >>= 1 never return 0, so we would end up with incorrect
+		 * results.
+		 *
+		 * The end result is what we'd expect from integer multiplication.
+		 */
+		return (int) (($c & ~$mask) | ($mask & -$c));
+	}
+
+	/**
+	 * Convert any arbitrary numbers into two 32-bit integers that represent
+	 * a 64-bit integer.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int|float $num
+	 * @return array<int, int>
+	 */
+	public static function numericTo64BitInteger($num)
+	{
+		$high = 0;
+		/** @var int $low */
+		$low = $num & 0xffffffff;
+
+		if ((+(abs($num))) >= 1) {
+			if ($num > 0) {
+				/** @var int $high */
+				$high = min((+(floor($num/4294967296))), 4294967295);
+			} else {
+				/** @var int $high */
+				$high = ~~((+(ceil(($num - (+((~~($num)))))/4294967296))));
+			}
+		}
+		return array((int) $high, (int) $low);
+	}
+
+	/**
+	 * Store a 24-bit integer into a string, treating it as big-endian.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $int
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function store_3($int)
+	{
+		/* Type checks: */
+		if (!is_int($int)) {
+			if (is_numeric($int)) {
+				$int = (int) $int;
+			} else {
+				throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+			}
+		}
+		/** @var string $packed */
+		$packed = pack('N', $int);
+		return self::substr($packed, 1, 3);
+	}
+
+	/**
+	 * Store a 32-bit integer into a string, treating it as little-endian.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $int
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function store32_le($int)
+	{
+		/* Type checks: */
+		if (!is_int($int)) {
+			if (is_numeric($int)) {
+				$int = (int) $int;
+			} else {
+				throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+			}
+		}
+
+		/** @var string $packed */
+		$packed = pack('V', $int);
+		return $packed;
+	}
+
+	/**
+	 * Store a 32-bit integer into a string, treating it as big-endian.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $int
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function store_4($int)
+	{
+		/* Type checks: */
+		if (!is_int($int)) {
+			if (is_numeric($int)) {
+				$int = (int) $int;
+			} else {
+				throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+			}
+		}
+
+		/** @var string $packed */
+		$packed = pack('N', $int);
+		return $packed;
+	}
+
+	/**
+	 * Stores a 64-bit integer as an string, treating it as little-endian.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $int
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function store64_le($int)
+	{
+		/* Type checks: */
+		if (!is_int($int)) {
+			if (is_numeric($int)) {
+				$int = (int) $int;
+			} else {
+				throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+			}
+		}
+
+		if (PHP_INT_SIZE === 8) {
+			if (PHP_VERSION_ID >= 50603) {
+				/** @var string $packed */
+				$packed = pack('P', $int);
+				return $packed;
+			}
+			return self::intToChr($int & 0xff) .
+				self::intToChr(($int >>  8) & 0xff) .
+				self::intToChr(($int >> 16) & 0xff) .
+				self::intToChr(($int >> 24) & 0xff) .
+				self::intToChr(($int >> 32) & 0xff) .
+				self::intToChr(($int >> 40) & 0xff) .
+				self::intToChr(($int >> 48) & 0xff) .
+				self::intToChr(($int >> 56) & 0xff);
+		}
+		if ($int > PHP_INT_MAX) {
+			list($hiB, $int) = self::numericTo64BitInteger($int);
+		} else {
+			$hiB = 0;
+		}
+		return
+			self::intToChr(($int      ) & 0xff) .
+			self::intToChr(($int >>  8) & 0xff) .
+			self::intToChr(($int >> 16) & 0xff) .
+			self::intToChr(($int >> 24) & 0xff) .
+			self::intToChr($hiB & 0xff) .
+			self::intToChr(($hiB >>  8) & 0xff) .
+			self::intToChr(($hiB >> 16) & 0xff) .
+			self::intToChr(($hiB >> 24) & 0xff);
+	}
+
+	/**
+	 * Safe string length
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @ref mbstring.func_overload
+	 *
+	 * @param string $str
+	 * @return int
+	 * @throws TypeError
+	 */
+	public static function strlen($str)
+	{
+		/* Type checks: */
+		if (!is_string($str)) {
+			throw new TypeError('String expected');
+		}
+
+		return (int) (
+		self::isMbStringOverride()
+			? mb_strlen($str, '8bit')
+			: strlen($str)
+		);
+	}
+
+	/**
+	 * Turn a string into an array of integers
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $string
+	 * @return array<int, int>
+	 * @throws TypeError
+	 */
+	public static function stringToIntArray($string)
+	{
+		if (!is_string($string)) {
+			throw new TypeError('String expected');
+		}
+		/**
+		 * @var array<int, int>
+		 */
+		$values = array_values(
+			unpack('C*', $string)
+		);
+		return $values;
+	}
+
+	/**
+	 * Safe substring
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @ref mbstring.func_overload
+	 *
+	 * @param string $str
+	 * @param int $start
+	 * @param int $length
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function substr($str, $start = 0, $length = null)
+	{
+		/* Type checks: */
+		if (!is_string($str)) {
+			throw new TypeError('String expected');
+		}
+
+		if ($length === 0) {
+			return '';
+		}
+
+		if (self::isMbStringOverride()) {
+			if (PHP_VERSION_ID < 50400 && $length === null) {
+				$length = self::strlen($str);
+			}
+			$sub = (string) mb_substr($str, $start, $length, '8bit');
+		} elseif ($length === null) {
+			$sub = (string) substr($str, $start);
+		} else {
+			$sub = (string) substr($str, $start, $length);
+		}
+		if ($sub !== '') {
+			return $sub;
+		}
+		return '';
+	}
+
+	/**
+	 * Compare a 16-character byte string in constant time.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $a
+	 * @param string $b
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function verify_16($a, $b)
+	{
+		/* Type checks: */
+		if (!is_string($a)) {
+			throw new TypeError('String expected');
+		}
+		if (!is_string($b)) {
+			throw new TypeError('String expected');
+		}
+		return self::hashEquals(
+			self::substr($a, 0, 16),
+			self::substr($b, 0, 16)
+		);
+	}
+
+	/**
+	 * Compare a 32-character byte string in constant time.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $a
+	 * @param string $b
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function verify_32($a, $b)
+	{
+		/* Type checks: */
+		if (!is_string($a)) {
+			throw new TypeError('String expected');
+		}
+		if (!is_string($b)) {
+			throw new TypeError('String expected');
+		}
+		return self::hashEquals(
+			self::substr($a, 0, 32),
+			self::substr($b, 0, 32)
+		);
+	}
+
+	/**
+	 * Calculate $a ^ $b for two strings.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $a
+	 * @param string $b
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function xorStrings($a, $b)
+	{
+		/* Type checks: */
+		if (!is_string($a)) {
+			throw new TypeError('Argument 1 must be a string');
+		}
+		if (!is_string($b)) {
+			throw new TypeError('Argument 2 must be a string');
+		}
+
+		return (string) ($a ^ $b);
+	}
+
+	/**
+	 * Returns whether or not mbstring.func_overload is in effect.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * Note: MB_OVERLOAD_STRING === 2, but we don't reference the constant
+	 * (for nuisance-free PHP 8 support)
+	 *
+	 * @return bool
+	 */
+	protected static function isMbStringOverride()
+	{
+		static $mbstring = null;
+
+		if ($mbstring === null) {
+			if (!defined('MB_OVERLOAD_STRING')) {
+				$mbstring = false;
+				return $mbstring;
+			}
+			$mbstring = extension_loaded('mbstring')
+				&& defined('MB_OVERLOAD_STRING')
+				&&
+			((int) (ini_get('mbstring.func_overload')) & 2);
+			// MB_OVERLOAD_STRING === 2
+		}
+		/** @var bool $mbstring */
+
+		return $mbstring;
+	}
 }

Spacing +257 added lines, -257 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_Util', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_Util', false ) ) {
     return;
 }
 
@@ -14,22 +14,22 @@ 
      * @param int $size (16, 32, 64)
      * @return int
      */
-    public static function abs($integer, $size = 0)
+    public static function abs( $integer, $size = 0 )
     {
         /** @var int $realSize */
-        $realSize = (PHP_INT_SIZE << 3) - 1;
-        if ($size) {
+        $realSize = ( PHP_INT_SIZE << 3 ) - 1;
+        if ( $size ) {
             --$size;
         } else {
             /** @var int $size */
             $size = $realSize;
         }
 
-        $negative = -(($integer >> $size) & 1);
-        return (int) (
-            ($integer ^ $negative)
+        $negative = -( ( $integer >> $size ) & 1 );
+        return (int)(
+            ( $integer ^ $negative )
                 +
-            (($negative >> $realSize) & 1)
+            ( ( $negative >> $realSize ) & 1 )
         );
     }
 
@@ -43,26 +43,26 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function bin2hex($binaryString)
+    public static function bin2hex( $binaryString )
     {
         /* Type checks: */
-        if (!is_string($binaryString)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($binaryString) . ' given.');
+        if ( ! is_string( $binaryString ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $binaryString ) . ' given.' );
         }
 
         $hex = '';
-        $len = self::strlen($binaryString);
-        for ($i = 0; $i < $len; ++$i) {
+        $len = self::strlen( $binaryString );
+        for ( $i = 0; $i < $len; ++$i ) {
             /** @var array<int, int> $chunk */
-            $chunk = unpack('C', $binaryString[$i]);
+            $chunk = unpack( 'C', $binaryString[ $i ] );
             /** @var int $c */
-            $c = $chunk[1] & 0xf;
+            $c = $chunk[ 1 ] & 0xf;
             /** @var int $b */
-            $b = $chunk[1] >> 4;
+            $b = $chunk[ 1 ] >> 4;
             $hex .= pack(
                 'CC',
-                (87 + $b + ((($b - 10) >> 8) & ~38)),
-                (87 + $c + ((($c - 10) >> 8) & ~38))
+                ( 87 + $b + ( ( ( $b - 10 ) >> 8 ) & ~38 ) ),
+                ( 87 + $c + ( ( ( $c - 10 ) >> 8 ) & ~38 ) )
             );
         }
         return $hex;
@@ -78,25 +78,25 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function bin2hexUpper($bin_string)
+    public static function bin2hexUpper( $bin_string )
     {
         $hex = '';
-        $len = self::strlen($bin_string);
-        for ($i = 0; $i < $len; ++$i) {
+        $len = self::strlen( $bin_string );
+        for ( $i = 0; $i < $len; ++$i ) {
             /** @var array<int, int> $chunk */
-            $chunk = unpack('C', $bin_string[$i]);
+            $chunk = unpack( 'C', $bin_string[ $i ] );
             /**
              * Lower 16 bits
              *
              * @var int $c
              */
-            $c = $chunk[1] & 0xf;
+            $c = $chunk[ 1 ] & 0xf;
 
             /**
              * Upper 16 bits
              * @var int $b
              */
-            $b = $chunk[1] >> 4;
+            $b = $chunk[ 1 ] >> 4;
 
             /**
              * Use pack() and binary operators to turn the two integers
@@ -106,8 +106,8 @@ 
              */
             $hex .= pack(
                 'CC',
-                (55 + $b + ((($b - 10) >> 8) & ~6)),
-                (55 + $c + ((($c - 10) >> 8) & ~6))
+                ( 55 + $b + ( ( ( $b - 10 ) >> 8 ) & ~6 ) ),
+                ( 55 + $c + ( ( ( $c - 10 ) >> 8 ) & ~6 ) )
             );
         }
         return $hex;
@@ -123,18 +123,18 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function chrToInt($chr)
+    public static function chrToInt( $chr )
     {
         /* Type checks: */
-        if (!is_string($chr)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($chr) . ' given.');
+        if ( ! is_string( $chr ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $chr ) . ' given.' );
         }
-        if (self::strlen($chr) !== 1) {
-            throw new SodiumException('chrToInt() expects a string that is exactly 1 character long');
+        if ( self::strlen( $chr ) !== 1 ) {
+            throw new SodiumException( 'chrToInt() expects a string that is exactly 1 character long' );
         }
         /** @var array<int, int> $chunk */
-        $chunk = unpack('C', $chr);
-        return (int) ($chunk[1]);
+        $chunk = unpack( 'C', $chr );
+        return (int)( $chunk[ 1 ] );
     }
 
     /**
@@ -149,25 +149,25 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function compare($left, $right, $len = null)
+    public static function compare( $left, $right, $len = null )
     {
-        $leftLen = self::strlen($left);
-        $rightLen = self::strlen($right);
-        if ($len === null) {
-            $len = max($leftLen, $rightLen);
-            $left = str_pad($left, $len, "\x00", STR_PAD_RIGHT);
-            $right = str_pad($right, $len, "\x00", STR_PAD_RIGHT);
+        $leftLen = self::strlen( $left );
+        $rightLen = self::strlen( $right );
+        if ( $len === null ) {
+            $len = max( $leftLen, $rightLen );
+            $left = str_pad( $left, $len, "\x00", STR_PAD_RIGHT );
+            $right = str_pad( $right, $len, "\x00", STR_PAD_RIGHT );
         }
 
         $gt = 0;
         $eq = 1;
         $i = $len;
-        while ($i !== 0) {
+        while ( $i !== 0 ) {
             --$i;
-            $gt |= ((self::chrToInt($right[$i]) - self::chrToInt($left[$i])) >> 8) & $eq;
-            $eq &= ((self::chrToInt($right[$i]) ^ self::chrToInt($left[$i])) - 1) >> 8;
+            $gt |= ( ( self::chrToInt( $right[ $i ] ) - self::chrToInt( $left[ $i ] ) ) >> 8 ) & $eq;
+            $eq &= ( ( self::chrToInt( $right[ $i ] ) ^ self::chrToInt( $left[ $i ] ) ) - 1 ) >> 8;
         }
-        return ($gt + $gt + $eq) - 1;
+        return ( $gt + $gt + $eq ) - 1;
     }
 
     /**
@@ -180,71 +180,71 @@ 
      * @throws SodiumException
      * @return void
      */
-    public static function declareScalarType(&$mixedVar = null, $type = 'void', $argumentIndex = 0)
+    public static function declareScalarType( &$mixedVar = null, $type = 'void', $argumentIndex = 0 )
     {
-        if (func_num_args() === 0) {
+        if ( func_num_args() === 0 ) {
             /* Tautology, by default */
             return;
         }
-        if (func_num_args() === 1) {
-            throw new TypeError('Declared void, but passed a variable');
+        if ( func_num_args() === 1 ) {
+            throw new TypeError( 'Declared void, but passed a variable' );
         }
-        $realType = strtolower(gettype($mixedVar));
-        $type = strtolower($type);
-        switch ($type) {
+        $realType = strtolower( gettype( $mixedVar ) );
+        $type = strtolower( $type );
+        switch ( $type ) {
             case 'null':
-                if ($mixedVar !== null) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be null, ' . $realType . ' given.');
+                if ( $mixedVar !== null ) {
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be null, ' . $realType . ' given.' );
                 }
                 break;
             case 'integer':
             case 'int':
-                $allow = array('int', 'integer');
-                if (!in_array($type, $allow)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be an integer, ' . $realType . ' given.');
+                $allow = array( 'int', 'integer' );
+                if ( ! in_array( $type, $allow ) ) {
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be an integer, ' . $realType . ' given.' );
                 }
-                $mixedVar = (int) $mixedVar;
+                $mixedVar = (int)$mixedVar;
                 break;
             case 'boolean':
             case 'bool':
-                $allow = array('bool', 'boolean');
-                if (!in_array($type, $allow)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be a boolean, ' . $realType . ' given.');
+                $allow = array( 'bool', 'boolean' );
+                if ( ! in_array( $type, $allow ) ) {
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be a boolean, ' . $realType . ' given.' );
                 }
-                $mixedVar = (bool) $mixedVar;
+                $mixedVar = (bool)$mixedVar;
                 break;
             case 'string':
-                if (!is_string($mixedVar)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be a string, ' . $realType . ' given.');
+                if ( ! is_string( $mixedVar ) ) {
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be a string, ' . $realType . ' given.' );
                 }
-                $mixedVar = (string) $mixedVar;
+                $mixedVar = (string)$mixedVar;
                 break;
             case 'decimal':
             case 'double':
             case 'float':
-                $allow = array('decimal', 'double', 'float');
-                if (!in_array($type, $allow)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be a float, ' . $realType . ' given.');
+                $allow = array( 'decimal', 'double', 'float' );
+                if ( ! in_array( $type, $allow ) ) {
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be a float, ' . $realType . ' given.' );
                 }
-                $mixedVar = (float) $mixedVar;
+                $mixedVar = (float)$mixedVar;
                 break;
             case 'object':
-                if (!is_object($mixedVar)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be an object, ' . $realType . ' given.');
+                if ( ! is_object( $mixedVar ) ) {
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be an object, ' . $realType . ' given.' );
                 }
                 break;
             case 'array':
-                if (!is_array($mixedVar)) {
-                    if (is_object($mixedVar)) {
-                        if ($mixedVar instanceof ArrayAccess) {
+                if ( ! is_array( $mixedVar ) ) {
+                    if ( is_object( $mixedVar ) ) {
+                        if ( $mixedVar instanceof ArrayAccess ) {
                             return;
                         }
                     }
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be an array, ' . $realType . ' given.');
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be an array, ' . $realType . ' given.' );
                 }
                 break;
             default:
-                throw new SodiumException('Unknown type (' . $realType .') does not match expect type (' . $type . ')');
+                throw new SodiumException( 'Unknown type (' . $realType . ') does not match expect type (' . $type . ')' );
         }
     }
 
@@ -257,30 +257,30 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function hashEquals($left, $right)
+    public static function hashEquals( $left, $right )
     {
         /* Type checks: */
-        if (!is_string($left)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($left) . ' given.');
+        if ( ! is_string( $left ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $left ) . ' given.' );
         }
-        if (!is_string($right)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($right) . ' given.');
+        if ( ! is_string( $right ) ) {
+            throw new TypeError( 'Argument 2 must be a string, ' . gettype( $right ) . ' given.' );
         }
 
-        if (is_callable('hash_equals')) {
-            return hash_equals($left, $right);
+        if ( is_callable( 'hash_equals' ) ) {
+            return hash_equals( $left, $right );
         }
         $d = 0;
         /** @var int $len */
-        $len = self::strlen($left);
-        if ($len !== self::strlen($right)) {
+        $len = self::strlen( $left );
+        if ( $len !== self::strlen( $right ) ) {
             return false;
         }
-        for ($i = 0; $i < $len; ++$i) {
-            $d |= self::chrToInt($left[$i]) ^ self::chrToInt($right[$i]);
+        for ( $i = 0; $i < $len; ++$i ) {
+            $d |= self::chrToInt( $left[ $i ] ) ^ self::chrToInt( $right[ $i ] );
         }
 
-        if ($d !== 0) {
+        if ( $d !== 0 ) {
             return false;
         }
         return $left === $right;
@@ -295,10 +295,10 @@ 
      * @throws SodiumException
      * @psalm-suppress PossiblyInvalidArgument
      */
-    protected static function hash_update(&$hs, $data)
+    protected static function hash_update( &$hs, $data )
     {
-        if (!hash_update($hs, $data)) {
-            throw new SodiumException('hash_update() failed');
+        if ( ! hash_update( $hs, $data ) ) {
+            throw new SodiumException( 'hash_update() failed' );
         }
     }
 
@@ -314,11 +314,11 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function hex2bin($hexString, $strictPadding = false)
+    public static function hex2bin( $hexString, $strictPadding = false )
     {
         /* Type checks: */
-        if (!is_string($hexString)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($hexString) . ' given.');
+        if ( ! is_string( $hexString ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $hexString ) . ' given.' );
         }
 
         /** @var int $hex_pos */
@@ -328,11 +328,11 @@ 
         /** @var int $c_acc */
         $c_acc = 0;
         /** @var int $hex_len */
-        $hex_len = self::strlen($hexString);
+        $hex_len = self::strlen( $hexString );
         /** @var int $state */
         $state = 0;
-        if (($hex_len & 1) !== 0) {
-            if ($strictPadding) {
+        if ( ( $hex_len & 1 ) !== 0 ) {
+            if ( $strictPadding ) {
                 throw new RangeException(
                     'Expected an even number of hexadecimal characters'
                 );
@@ -342,30 +342,30 @@ 
             }
         }
 
-        $chunk = unpack('C*', $hexString);
-        while ($hex_pos < $hex_len) {
+        $chunk = unpack( 'C*', $hexString );
+        while ( $hex_pos < $hex_len ) {
             ++$hex_pos;
             /** @var int $c */
-            $c = $chunk[$hex_pos];
+            $c = $chunk[ $hex_pos ];
             /** @var int $c_num */
             $c_num = $c ^ 48;
             /** @var int $c_num0 */
-            $c_num0 = ($c_num - 10) >> 8;
+            $c_num0 = ( $c_num - 10 ) >> 8;
             /** @var int $c_alpha */
-            $c_alpha = ($c & ~32) - 55;
+            $c_alpha = ( $c & ~32 ) - 55;
             /** @var int $c_alpha0 */
-            $c_alpha0 = (($c_alpha - 10) ^ ($c_alpha - 16)) >> 8;
-            if (($c_num0 | $c_alpha0) === 0) {
+            $c_alpha0 = ( ( $c_alpha - 10 ) ^ ( $c_alpha - 16 ) ) >> 8;
+            if ( ( $c_num0 | $c_alpha0 ) === 0 ) {
                 throw new RangeException(
                     'hex2bin() only expects hexadecimal characters'
                 );
             }
             /** @var int $c_val */
-            $c_val = ($c_num0 & $c_num) | ($c_alpha & $c_alpha0);
-            if ($state === 0) {
+            $c_val = ( $c_num0 & $c_num ) | ( $c_alpha & $c_alpha0 );
+            if ( $state === 0 ) {
                 $c_acc = $c_val * 16;
             } else {
-                $bin .= pack('C', $c_acc | $c_val);
+                $bin .= pack( 'C', $c_acc | $c_val );
             }
             $state ^= 1;
         }
@@ -380,15 +380,15 @@ 
      * @param array<int, int> $ints
      * @return string
      */
-    public static function intArrayToString(array $ints)
+    public static function intArrayToString( array $ints )
     {
         /** @var array<int, int> $args */
         $args = $ints;
-        foreach ($args as $i => $v) {
-            $args[$i] = (int) ($v & 0xff);
+        foreach ( $args as $i => $v ) {
+            $args[ $i ] = (int)( $v & 0xff );
         }
-        array_unshift($args, str_repeat('C', count($ints)));
-        return (string) (call_user_func_array('pack', $args));
+        array_unshift( $args, str_repeat( 'C', count( $ints ) ) );
+        return (string)( call_user_func_array( 'pack', $args ) );
     }
 
     /**
@@ -400,9 +400,9 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function intToChr($int)
+    public static function intToChr( $int )
     {
-        return pack('C', $int);
+        return pack( 'C', $int );
     }
 
     /**
@@ -415,22 +415,22 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function load_3($string)
+    public static function load_3( $string )
     {
         /* Type checks: */
-        if (!is_string($string)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
+        if ( ! is_string( $string ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $string ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($string) < 3) {
+        if ( self::strlen( $string ) < 3 ) {
             throw new RangeException(
-                'String must be 3 bytes or more; ' . self::strlen($string) . ' given.'
+                'String must be 3 bytes or more; ' . self::strlen( $string ) . ' given.'
             );
         }
         /** @var array<int, int> $unpacked */
-        $unpacked = unpack('V', $string . "\0");
-        return (int) ($unpacked[1] & 0xffffff);
+        $unpacked = unpack( 'V', $string . "\0" );
+        return (int)( $unpacked[ 1 ] & 0xffffff );
     }
 
     /**
@@ -443,22 +443,22 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function load_4($string)
+    public static function load_4( $string )
     {
         /* Type checks: */
-        if (!is_string($string)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
+        if ( ! is_string( $string ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $string ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($string) < 4) {
+        if ( self::strlen( $string ) < 4 ) {
             throw new RangeException(
-                'String must be 4 bytes or more; ' . self::strlen($string) . ' given.'
+                'String must be 4 bytes or more; ' . self::strlen( $string ) . ' given.'
             );
         }
         /** @var array<int, int> $unpacked */
-        $unpacked = unpack('V', $string);
-        return (int) ($unpacked[1] & 0xffffffff);
+        $unpacked = unpack( 'V', $string );
+        return (int)( $unpacked[ 1 ] & 0xffffffff );
     }
 
     /**
@@ -472,35 +472,35 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function load64_le($string)
+    public static function load64_le( $string )
     {
         /* Type checks: */
-        if (!is_string($string)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
+        if ( ! is_string( $string ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $string ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($string) < 4) {
+        if ( self::strlen( $string ) < 4 ) {
             throw new RangeException(
-                'String must be 4 bytes or more; ' . self::strlen($string) . ' given.'
+                'String must be 4 bytes or more; ' . self::strlen( $string ) . ' given.'
             );
         }
-        if (PHP_VERSION_ID >= 50603 && PHP_INT_SIZE === 8) {
+        if ( PHP_VERSION_ID >= 50603 && PHP_INT_SIZE === 8 ) {
             /** @var array<int, int> $unpacked */
-            $unpacked = unpack('P', $string);
-            return (int) $unpacked[1];
+            $unpacked = unpack( 'P', $string );
+            return (int)$unpacked[ 1 ];
         }
 
         /** @var int $result */
-        $result  = (self::chrToInt($string[0]) & 0xff);
-        $result |= (self::chrToInt($string[1]) & 0xff) <<  8;
-        $result |= (self::chrToInt($string[2]) & 0xff) << 16;
-        $result |= (self::chrToInt($string[3]) & 0xff) << 24;
-        $result |= (self::chrToInt($string[4]) & 0xff) << 32;
-        $result |= (self::chrToInt($string[5]) & 0xff) << 40;
-        $result |= (self::chrToInt($string[6]) & 0xff) << 48;
-        $result |= (self::chrToInt($string[7]) & 0xff) << 56;
-        return (int) $result;
+        $result  = ( self::chrToInt( $string[ 0 ] ) & 0xff );
+        $result |= ( self::chrToInt( $string[ 1 ] ) & 0xff ) << 8;
+        $result |= ( self::chrToInt( $string[ 2 ] ) & 0xff ) << 16;
+        $result |= ( self::chrToInt( $string[ 3 ] ) & 0xff ) << 24;
+        $result |= ( self::chrToInt( $string[ 4 ] ) & 0xff ) << 32;
+        $result |= ( self::chrToInt( $string[ 5 ] ) & 0xff ) << 40;
+        $result |= ( self::chrToInt( $string[ 6 ] ) & 0xff ) << 48;
+        $result |= ( self::chrToInt( $string[ 7 ] ) & 0xff ) << 56;
+        return (int)$result;
     }
 
     /**
@@ -512,9 +512,9 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function memcmp($left, $right)
+    public static function memcmp( $left, $right )
     {
-        if (self::hashEquals($left, $right)) {
+        if ( self::hashEquals( $left, $right ) ) {
             return 0;
         }
         return -1;
@@ -537,19 +537,19 @@ 
      *                  constant operands)
      * @return int
      */
-    public static function mul($a, $b, $size = 0)
+    public static function mul( $a, $b, $size = 0 )
     {
-        if (ParagonIE_Sodium_Compat::$fastMult) {
-            return (int) ($a * $b);
+        if ( ParagonIE_Sodium_Compat::$fastMult ) {
+            return (int)( $a * $b );
         }
 
         static $defaultSize = null;
         /** @var int $defaultSize */
-        if (!$defaultSize) {
+        if ( ! $defaultSize ) {
             /** @var int $defaultSize */
-            $defaultSize = (PHP_INT_SIZE << 3) - 1;
+            $defaultSize = ( PHP_INT_SIZE << 3 ) - 1;
         }
-        if ($size < 1) {
+        if ( $size < 1 ) {
             /** @var int $size */
             $size = $defaultSize;
         }
@@ -565,7 +565,7 @@ 
          *
          * @var int
          */
-        $mask = -(($b >> ((int) $defaultSize)) & 1);
+        $mask = -( ( $b >> ( (int)$defaultSize ) ) & 1 );
 
         /**
          * Ensure $b is a positive integer, without creating
@@ -573,7 +573,7 @@ 
          *
          * @var int $b
          */
-        $b = ($b & ~$mask) | ($mask & -$b);
+        $b = ( $b & ~$mask ) | ( $mask & -$b );
 
         /**
          * Unless $size is provided:
@@ -581,12 +581,12 @@ 
          * This loop always runs 32 times when PHP_INT_SIZE is 4.
          * This loop always runs 64 times when PHP_INT_SIZE is 8.
          */
-        for ($i = $size; $i >= 0; --$i) {
-            $c += (int) ($a & -($b & 1));
+        for ( $i = $size; $i >= 0; --$i ) {
+            $c += (int)( $a & -( $b & 1 ) );
             $a <<= 1;
             $b >>= 1;
         }
-        $c = (int) @($c & -1);
+        $c = (int)@( $c & -1 );
 
         /**
          * If $b was negative, we then apply the same value to $c here.
@@ -597,7 +597,7 @@ 
          *
          * The end result is what we'd expect from integer multiplication.
          */
-        return (int) (($c & ~$mask) | ($mask & -$c));
+        return (int)( ( $c & ~$mask ) | ( $mask & -$c ) );
     }
 
     /**
@@ -609,22 +609,22 @@ 
      * @param int|float $num
      * @return array<int, int>
      */
-    public static function numericTo64BitInteger($num)
+    public static function numericTo64BitInteger( $num )
     {
         $high = 0;
         /** @var int $low */
         $low = $num & 0xffffffff;
 
-        if ((+(abs($num))) >= 1) {
-            if ($num > 0) {
+        if ( (+( abs( $num ) )) >= 1 ) {
+            if ( $num > 0 ) {
                 /** @var int $high */
-                $high = min((+(floor($num/4294967296))), 4294967295);
+                $high = min( (+( floor( $num / 4294967296 ) )), 4294967295 );
             } else {
                 /** @var int $high */
-                $high = ~~((+(ceil(($num - (+((~~($num)))))/4294967296))));
+                $high = ~~( (+( ceil( ( $num - (+( ( ~~( $num ) ) )) ) / 4294967296 ) )) );
             }
         }
-        return array((int) $high, (int) $low);
+        return array( (int)$high, (int)$low );
     }
 
     /**
@@ -636,19 +636,19 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function store_3($int)
+    public static function store_3( $int )
     {
         /* Type checks: */
-        if (!is_int($int)) {
-            if (is_numeric($int)) {
-                $int = (int) $int;
+        if ( ! is_int( $int ) ) {
+            if ( is_numeric( $int ) ) {
+                $int = (int)$int;
             } else {
-                throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+                throw new TypeError( 'Argument 1 must be an integer, ' . gettype( $int ) . ' given.' );
             }
         }
         /** @var string $packed */
-        $packed = pack('N', $int);
-        return self::substr($packed, 1, 3);
+        $packed = pack( 'N', $int );
+        return self::substr( $packed, 1, 3 );
     }
 
     /**
@@ -660,19 +660,19 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function store32_le($int)
+    public static function store32_le( $int )
     {
         /* Type checks: */
-        if (!is_int($int)) {
-            if (is_numeric($int)) {
-                $int = (int) $int;
+        if ( ! is_int( $int ) ) {
+            if ( is_numeric( $int ) ) {
+                $int = (int)$int;
             } else {
-                throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+                throw new TypeError( 'Argument 1 must be an integer, ' . gettype( $int ) . ' given.' );
             }
         }
 
         /** @var string $packed */
-        $packed = pack('V', $int);
+        $packed = pack( 'V', $int );
         return $packed;
     }
 
@@ -685,19 +685,19 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function store_4($int)
+    public static function store_4( $int )
     {
         /* Type checks: */
-        if (!is_int($int)) {
-            if (is_numeric($int)) {
-                $int = (int) $int;
+        if ( ! is_int( $int ) ) {
+            if ( is_numeric( $int ) ) {
+                $int = (int)$int;
             } else {
-                throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+                throw new TypeError( 'Argument 1 must be an integer, ' . gettype( $int ) . ' given.' );
             }
         }
 
         /** @var string $packed */
-        $packed = pack('N', $int);
+        $packed = pack( 'N', $int );
         return $packed;
     }
 
@@ -710,46 +710,46 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function store64_le($int)
+    public static function store64_le( $int )
     {
         /* Type checks: */
-        if (!is_int($int)) {
-            if (is_numeric($int)) {
-                $int = (int) $int;
+        if ( ! is_int( $int ) ) {
+            if ( is_numeric( $int ) ) {
+                $int = (int)$int;
             } else {
-                throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+                throw new TypeError( 'Argument 1 must be an integer, ' . gettype( $int ) . ' given.' );
             }
         }
 
-        if (PHP_INT_SIZE === 8) {
-            if (PHP_VERSION_ID >= 50603) {
+        if ( PHP_INT_SIZE === 8 ) {
+            if ( PHP_VERSION_ID >= 50603 ) {
                 /** @var string $packed */
-                $packed = pack('P', $int);
+                $packed = pack( 'P', $int );
                 return $packed;
             }
-            return self::intToChr($int & 0xff) .
-                self::intToChr(($int >>  8) & 0xff) .
-                self::intToChr(($int >> 16) & 0xff) .
-                self::intToChr(($int >> 24) & 0xff) .
-                self::intToChr(($int >> 32) & 0xff) .
-                self::intToChr(($int >> 40) & 0xff) .
-                self::intToChr(($int >> 48) & 0xff) .
-                self::intToChr(($int >> 56) & 0xff);
-        }
-        if ($int > PHP_INT_MAX) {
-            list($hiB, $int) = self::numericTo64BitInteger($int);
+            return self::intToChr( $int & 0xff ) .
+                self::intToChr( ( $int >> 8 ) & 0xff ) .
+                self::intToChr( ( $int >> 16 ) & 0xff ) .
+                self::intToChr( ( $int >> 24 ) & 0xff ) .
+                self::intToChr( ( $int >> 32 ) & 0xff ) .
+                self::intToChr( ( $int >> 40 ) & 0xff ) .
+                self::intToChr( ( $int >> 48 ) & 0xff ) .
+                self::intToChr( ( $int >> 56 ) & 0xff );
+        }
+        if ( $int > PHP_INT_MAX ) {
+            list( $hiB, $int ) = self::numericTo64BitInteger( $int );
         } else {
             $hiB = 0;
         }
         return
-            self::intToChr(($int      ) & 0xff) .
-            self::intToChr(($int >>  8) & 0xff) .
-            self::intToChr(($int >> 16) & 0xff) .
-            self::intToChr(($int >> 24) & 0xff) .
-            self::intToChr($hiB & 0xff) .
-            self::intToChr(($hiB >>  8) & 0xff) .
-            self::intToChr(($hiB >> 16) & 0xff) .
-            self::intToChr(($hiB >> 24) & 0xff);
+            self::intToChr( ( $int ) & 0xff ) .
+            self::intToChr( ( $int >> 8 ) & 0xff ) .
+            self::intToChr( ( $int >> 16 ) & 0xff ) .
+            self::intToChr( ( $int >> 24 ) & 0xff ) .
+            self::intToChr( $hiB & 0xff ) .
+            self::intToChr( ( $hiB >> 8 ) & 0xff ) .
+            self::intToChr( ( $hiB >> 16 ) & 0xff ) .
+            self::intToChr( ( $hiB >> 24 ) & 0xff );
     }
 
     /**
@@ -763,17 +763,17 @@ 
      * @return int
      * @throws TypeError
      */
-    public static function strlen($str)
+    public static function strlen( $str )
     {
         /* Type checks: */
-        if (!is_string($str)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $str ) ) {
+            throw new TypeError( 'String expected' );
         }
 
-        return (int) (
+        return (int)(
         self::isMbStringOverride()
-            ? mb_strlen($str, '8bit')
-            : strlen($str)
+            ? mb_strlen( $str, '8bit' )
+            : strlen( $str )
         );
     }
 
@@ -786,16 +786,16 @@ 
      * @return array<int, int>
      * @throws TypeError
      */
-    public static function stringToIntArray($string)
+    public static function stringToIntArray( $string )
     {
-        if (!is_string($string)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $string ) ) {
+            throw new TypeError( 'String expected' );
         }
         /**
          * @var array<int, int>
          */
         $values = array_values(
-            unpack('C*', $string)
+            unpack( 'C*', $string )
         );
         return $values;
     }
@@ -813,28 +813,28 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function substr($str, $start = 0, $length = null)
+    public static function substr( $str, $start = 0, $length = null )
     {
         /* Type checks: */
-        if (!is_string($str)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $str ) ) {
+            throw new TypeError( 'String expected' );
         }
 
-        if ($length === 0) {
+        if ( $length === 0 ) {
             return '';
         }
 
-        if (self::isMbStringOverride()) {
-            if (PHP_VERSION_ID < 50400 && $length === null) {
-                $length = self::strlen($str);
+        if ( self::isMbStringOverride() ) {
+            if ( PHP_VERSION_ID < 50400 && $length === null ) {
+                $length = self::strlen( $str );
             }
-            $sub = (string) mb_substr($str, $start, $length, '8bit');
-        } elseif ($length === null) {
-            $sub = (string) substr($str, $start);
+            $sub = (string)mb_substr( $str, $start, $length, '8bit' );
+        } elseif ( $length === null ) {
+            $sub = (string)substr( $str, $start );
         } else {
-            $sub = (string) substr($str, $start, $length);
+            $sub = (string)substr( $str, $start, $length );
         }
-        if ($sub !== '') {
+        if ( $sub !== '' ) {
             return $sub;
         }
         return '';
@@ -851,18 +851,18 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function verify_16($a, $b)
+    public static function verify_16( $a, $b )
     {
         /* Type checks: */
-        if (!is_string($a)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $a ) ) {
+            throw new TypeError( 'String expected' );
         }
-        if (!is_string($b)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $b ) ) {
+            throw new TypeError( 'String expected' );
         }
         return self::hashEquals(
-            self::substr($a, 0, 16),
-            self::substr($b, 0, 16)
+            self::substr( $a, 0, 16 ),
+            self::substr( $b, 0, 16 )
         );
     }
 
@@ -877,18 +877,18 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function verify_32($a, $b)
+    public static function verify_32( $a, $b )
     {
         /* Type checks: */
-        if (!is_string($a)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $a ) ) {
+            throw new TypeError( 'String expected' );
         }
-        if (!is_string($b)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $b ) ) {
+            throw new TypeError( 'String expected' );
         }
         return self::hashEquals(
-            self::substr($a, 0, 32),
-            self::substr($b, 0, 32)
+            self::substr( $a, 0, 32 ),
+            self::substr( $b, 0, 32 )
         );
     }
 
@@ -902,17 +902,17 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function xorStrings($a, $b)
+    public static function xorStrings( $a, $b )
     {
         /* Type checks: */
-        if (!is_string($a)) {
-            throw new TypeError('Argument 1 must be a string');
+        if ( ! is_string( $a ) ) {
+            throw new TypeError( 'Argument 1 must be a string' );
         }
-        if (!is_string($b)) {
-            throw new TypeError('Argument 2 must be a string');
+        if ( ! is_string( $b ) ) {
+            throw new TypeError( 'Argument 2 must be a string' );
         }
 
-        return (string) ($a ^ $b);
+        return (string)( $a ^ $b );
     }
 
     /**
@@ -929,15 +929,15 @@ 
     {
         static $mbstring = null;
 
-        if ($mbstring === null) {
-            if (!defined('MB_OVERLOAD_STRING')) {
+        if ( $mbstring === null ) {
+            if ( ! defined( 'MB_OVERLOAD_STRING' ) ) {
                 $mbstring = false;
                 return $mbstring;
             }
-            $mbstring = extension_loaded('mbstring')
-                && defined('MB_OVERLOAD_STRING')
+            $mbstring = extension_loaded( 'mbstring' )
+                && defined( 'MB_OVERLOAD_STRING' )
                 &&
-            ((int) (ini_get('mbstring.func_overload')) & 2);
+            ( (int)( ini_get( 'mbstring.func_overload' ) ) & 2 );
             // MB_OVERLOAD_STRING === 2
         }
         /** @var bool $mbstring */

Braces +29 added lines, -58 removed lines

@@ -7,15 +7,13 @@ 
 /**
  * Class ParagonIE_Sodium_Core_Util
  */
-abstract class ParagonIE_Sodium_Core_Util
-{
+abstract class ParagonIE_Sodium_Core_Util {
     /**
      * @param int $integer
      * @param int $size (16, 32, 64)
      * @return int
      */
-    public static function abs($integer, $size = 0)
-    {
+    public static function abs($integer, $size = 0) {
         /** @var int $realSize */
         $realSize = (PHP_INT_SIZE << 3) - 1;
         if ($size) {
@@ -43,8 +41,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function bin2hex($binaryString)
-    {
+    public static function bin2hex($binaryString) {
         /* Type checks: */
         if (!is_string($binaryString)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($binaryString) . ' given.');
@@ -78,8 +75,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function bin2hexUpper($bin_string)
-    {
+    public static function bin2hexUpper($bin_string) {
         $hex = '';
         $len = self::strlen($bin_string);
         for ($i = 0; $i < $len; ++$i) {
@@ -123,8 +119,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function chrToInt($chr)
-    {
+    public static function chrToInt($chr) {
         /* Type checks: */
         if (!is_string($chr)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($chr) . ' given.');
@@ -149,8 +144,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function compare($left, $right, $len = null)
-    {
+    public static function compare($left, $right, $len = null) {
         $leftLen = self::strlen($left);
         $rightLen = self::strlen($right);
         if ($len === null) {
@@ -180,8 +174,7 @@ 
      * @throws SodiumException
      * @return void
      */
-    public static function declareScalarType(&$mixedVar = null, $type = 'void', $argumentIndex = 0)
-    {
+    public static function declareScalarType(&$mixedVar = null, $type = 'void', $argumentIndex = 0) {
         if (func_num_args() === 0) {
             /* Tautology, by default */
             return;
@@ -257,8 +250,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function hashEquals($left, $right)
-    {
+    public static function hashEquals($left, $right) {
         /* Type checks: */
         if (!is_string($left)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($left) . ' given.');
@@ -295,8 +287,7 @@ 
      * @throws SodiumException
      * @psalm-suppress PossiblyInvalidArgument
      */
-    protected static function hash_update(&$hs, $data)
-    {
+    protected static function hash_update(&$hs, $data) {
         if (!hash_update($hs, $data)) {
             throw new SodiumException('hash_update() failed');
         }
@@ -314,8 +305,7 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function hex2bin($hexString, $strictPadding = false)
-    {
+    public static function hex2bin($hexString, $strictPadding = false) {
         /* Type checks: */
         if (!is_string($hexString)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($hexString) . ' given.');
@@ -380,8 +370,7 @@ 
      * @param array<int, int> $ints
      * @return string
      */
-    public static function intArrayToString(array $ints)
-    {
+    public static function intArrayToString(array $ints) {
         /** @var array<int, int> $args */
         $args = $ints;
         foreach ($args as $i => $v) {
@@ -400,8 +389,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function intToChr($int)
-    {
+    public static function intToChr($int) {
         return pack('C', $int);
     }
 
@@ -415,8 +403,7 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function load_3($string)
-    {
+    public static function load_3($string) {
         /* Type checks: */
         if (!is_string($string)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
@@ -443,8 +430,7 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function load_4($string)
-    {
+    public static function load_4($string) {
         /* Type checks: */
         if (!is_string($string)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
@@ -472,8 +458,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function load64_le($string)
-    {
+    public static function load64_le($string) {
         /* Type checks: */
         if (!is_string($string)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
@@ -512,8 +497,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function memcmp($left, $right)
-    {
+    public static function memcmp($left, $right) {
         if (self::hashEquals($left, $right)) {
             return 0;
         }
@@ -537,8 +521,7 @@ 
      *                  constant operands)
      * @return int
      */
-    public static function mul($a, $b, $size = 0)
-    {
+    public static function mul($a, $b, $size = 0) {
         if (ParagonIE_Sodium_Compat::$fastMult) {
             return (int) ($a * $b);
         }
@@ -609,8 +592,7 @@ 
      * @param int|float $num
      * @return array<int, int>
      */
-    public static function numericTo64BitInteger($num)
-    {
+    public static function numericTo64BitInteger($num) {
         $high = 0;
         /** @var int $low */
         $low = $num & 0xffffffff;
@@ -636,8 +618,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function store_3($int)
-    {
+    public static function store_3($int) {
         /* Type checks: */
         if (!is_int($int)) {
             if (is_numeric($int)) {
@@ -660,8 +641,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function store32_le($int)
-    {
+    public static function store32_le($int) {
         /* Type checks: */
         if (!is_int($int)) {
             if (is_numeric($int)) {
@@ -685,8 +665,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function store_4($int)
-    {
+    public static function store_4($int) {
         /* Type checks: */
         if (!is_int($int)) {
             if (is_numeric($int)) {
@@ -710,8 +689,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function store64_le($int)
-    {
+    public static function store64_le($int) {
         /* Type checks: */
         if (!is_int($int)) {
             if (is_numeric($int)) {
@@ -763,8 +741,7 @@ 
      * @return int
      * @throws TypeError
      */
-    public static function strlen($str)
-    {
+    public static function strlen($str) {
         /* Type checks: */
         if (!is_string($str)) {
             throw new TypeError('String expected');
@@ -786,8 +763,7 @@ 
      * @return array<int, int>
      * @throws TypeError
      */
-    public static function stringToIntArray($string)
-    {
+    public static function stringToIntArray($string) {
         if (!is_string($string)) {
             throw new TypeError('String expected');
         }
@@ -813,8 +789,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function substr($str, $start = 0, $length = null)
-    {
+    public static function substr($str, $start = 0, $length = null) {
         /* Type checks: */
         if (!is_string($str)) {
             throw new TypeError('String expected');
@@ -851,8 +826,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function verify_16($a, $b)
-    {
+    public static function verify_16($a, $b) {
         /* Type checks: */
         if (!is_string($a)) {
             throw new TypeError('String expected');
@@ -877,8 +851,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function verify_32($a, $b)
-    {
+    public static function verify_32($a, $b) {
         /* Type checks: */
         if (!is_string($a)) {
             throw new TypeError('String expected');
@@ -902,8 +875,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function xorStrings($a, $b)
-    {
+    public static function xorStrings($a, $b) {
         /* Type checks: */
         if (!is_string($a)) {
             throw new TypeError('Argument 1 must be a string');
@@ -925,8 +897,7 @@ 
      *
      * @return bool
      */
-    protected static function isMbStringOverride()
-    {
+    protected static function isMbStringOverride() {
         static $mbstring = null;
 
         if ($mbstring === null) {

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

Indentation +293 added lines, -293 removed lines

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

Spacing +86 added lines, -86 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_SipHash', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_SipHash', false ) ) {
     return;
 }
 
@@ -18,65 +18,65 @@ 
      * @return int[]
      *
      */
-    public static function sipRound(array $v)
+    public static function sipRound( array $v )
     {
         # v0 += v1;
-        list($v[0], $v[1]) = self::add(
-            array($v[0], $v[1]),
-            array($v[2], $v[3])
+        list( $v[ 0 ], $v[ 1 ] ) = self::add(
+            array( $v[ 0 ], $v[ 1 ] ),
+            array( $v[ 2 ], $v[ 3 ] )
         );
 
         #  v1=ROTL(v1,13);
-        list($v[2], $v[3]) = self::rotl_64((int) $v[2], (int) $v[3], 13);
+        list( $v[ 2 ], $v[ 3 ] ) = self::rotl_64( (int)$v[ 2 ], (int)$v[ 3 ], 13 );
 
         #  v1 ^= v0;
-        $v[2] = (int) $v[2] ^ (int) $v[0];
-        $v[3] = (int) $v[3] ^ (int) $v[1];
+        $v[ 2 ] = (int)$v[ 2 ] ^ (int)$v[ 0 ];
+        $v[ 3 ] = (int)$v[ 3 ] ^ (int)$v[ 1 ];
 
         #  v0=ROTL(v0,32);
-        list($v[0], $v[1]) = self::rotl_64((int) $v[0], (int) $v[1], 32);
+        list( $v[ 0 ], $v[ 1 ] ) = self::rotl_64( (int)$v[ 0 ], (int)$v[ 1 ], 32 );
 
         # v2 += v3;
-        list($v[4], $v[5]) = self::add(
-            array((int) $v[4], (int) $v[5]),
-            array((int) $v[6], (int) $v[7])
+        list( $v[ 4 ], $v[ 5 ] ) = self::add(
+            array( (int)$v[ 4 ], (int)$v[ 5 ] ),
+            array( (int)$v[ 6 ], (int)$v[ 7 ] )
         );
 
         # v3=ROTL(v3,16);
-        list($v[6], $v[7]) = self::rotl_64((int) $v[6], (int) $v[7], 16);
+        list( $v[ 6 ], $v[ 7 ] ) = self::rotl_64( (int)$v[ 6 ], (int)$v[ 7 ], 16 );
 
         #  v3 ^= v2;
-        $v[6] = (int) $v[6] ^ (int) $v[4];
-        $v[7] = (int) $v[7] ^ (int) $v[5];
+        $v[ 6 ] = (int)$v[ 6 ] ^ (int)$v[ 4 ];
+        $v[ 7 ] = (int)$v[ 7 ] ^ (int)$v[ 5 ];
 
         # v0 += v3;
-        list($v[0], $v[1]) = self::add(
-            array((int) $v[0], (int) $v[1]),
-            array((int) $v[6], (int) $v[7])
+        list( $v[ 0 ], $v[ 1 ] ) = self::add(
+            array( (int)$v[ 0 ], (int)$v[ 1 ] ),
+            array( (int)$v[ 6 ], (int)$v[ 7 ] )
         );
 
         # v3=ROTL(v3,21);
-        list($v[6], $v[7]) = self::rotl_64((int) $v[6], (int) $v[7], 21);
+        list( $v[ 6 ], $v[ 7 ] ) = self::rotl_64( (int)$v[ 6 ], (int)$v[ 7 ], 21 );
 
         # v3 ^= v0;
-        $v[6] = (int) $v[6] ^ (int) $v[0];
-        $v[7] = (int) $v[7] ^ (int) $v[1];
+        $v[ 6 ] = (int)$v[ 6 ] ^ (int)$v[ 0 ];
+        $v[ 7 ] = (int)$v[ 7 ] ^ (int)$v[ 1 ];
 
         # v2 += v1;
-        list($v[4], $v[5]) = self::add(
-            array((int) $v[4], (int) $v[5]),
-            array((int) $v[2], (int) $v[3])
+        list( $v[ 4 ], $v[ 5 ] ) = self::add(
+            array( (int)$v[ 4 ], (int)$v[ 5 ] ),
+            array( (int)$v[ 2 ], (int)$v[ 3 ] )
         );
 
         # v1=ROTL(v1,17);
-        list($v[2], $v[3]) = self::rotl_64((int) $v[2], (int) $v[3], 17);
+        list( $v[ 2 ], $v[ 3 ] ) = self::rotl_64( (int)$v[ 2 ], (int)$v[ 3 ], 17 );
 
         #  v1 ^= v2;;
-        $v[2] = (int) $v[2] ^ (int) $v[4];
-        $v[3] = (int) $v[3] ^ (int) $v[5];
+        $v[ 2 ] = (int)$v[ 2 ] ^ (int)$v[ 4 ];
+        $v[ 3 ] = (int)$v[ 3 ] ^ (int)$v[ 5 ];
 
         # v2=ROTL(v2,32)
-        list($v[4], $v[5]) = self::rotl_64((int) $v[4], (int) $v[5], 32);
+        list( $v[ 4 ], $v[ 5 ] ) = self::rotl_64( (int)$v[ 4 ], (int)$v[ 5 ], 32 );
 
         return $v;
     }
@@ -90,14 +90,14 @@ 
      * @param int[] $b
      * @return array<int, mixed>
      */
-    public static function add(array $a, array $b)
+    public static function add( array $a, array $b )
     {
         /** @var int $x1 */
-        $x1 = $a[1] + $b[1];
+        $x1 = $a[ 1 ] + $b[ 1 ];
         /** @var int $c */
         $c = $x1 >> 32; // Carry if ($a + $b) > 0xffffffff
         /** @var int $x0 */
-        $x0 = $a[0] + $b[0] + $c;
+        $x0 = $a[ 0 ] + $b[ 0 ] + $c;
         return array(
             $x0 & 0xffffffff,
             $x1 & 0xffffffff
@@ -112,33 +112,33 @@ 
      * @param int $c
      * @return array<int, mixed>
      */
-    public static function rotl_64($int0, $int1, $c)
+    public static function rotl_64( $int0, $int1, $c )
     {
         $int0 &= 0xffffffff;
         $int1 &= 0xffffffff;
         $c &= 63;
-        if ($c === 32) {
-            return array($int1, $int0);
+        if ( $c === 32 ) {
+            return array( $int1, $int0 );
         }
-        if ($c > 31) {
+        if ( $c > 31 ) {
             $tmp = $int1;
             $int1 = $int0;
             $int0 = $tmp;
             $c &= 31;
         }
-        if ($c === 0) {
-            return array($int0, $int1);
+        if ( $c === 0 ) {
+            return array( $int0, $int1 );
         }
         return array(
             0xffffffff & (
-                ($int0 << $c)
+                ( $int0 << $c )
                     |
-                ($int1 >> (32 - $c))
+                ( $int1 >> ( 32 - $c ) )
             ),
             0xffffffff & (
-                ($int1 << $c)
+                ( $int1 << $c )
                     |
-                ($int0 >> (32 - $c))
+                ( $int0 >> ( 32 - $c ) )
             ),
         );
     }
@@ -160,9 +160,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;
@@ -187,10 +187,10 @@ 
         # u64 k0 = LOAD64_LE( k );
         # u64 k1 = LOAD64_LE( k + 8 );
         $k = array(
-            self::load_4(self::substr($key, 4, 4)),
-            self::load_4(self::substr($key, 0, 4)),
-            self::load_4(self::substr($key, 12, 4)),
-            self::load_4(self::substr($key, 8, 4))
+            self::load_4( self::substr( $key, 4, 4 ) ),
+            self::load_4( self::substr( $key, 0, 4 ) ),
+            self::load_4( self::substr( $key, 12, 4 ) ),
+            self::load_4( self::substr( $key, 8, 4 ) )
         );
         // k0 => $k[0], $k[1]
         // k1 => $k[2], $k[3]
@@ -203,41 +203,41 @@ 
         // See docblock for why the 0th index gets the higher bits.
 
         # v3 ^= k1;
-        $v[6] ^= $k[2];
-        $v[7] ^= $k[3];
+        $v[ 6 ] ^= $k[ 2 ];
+        $v[ 7 ] ^= $k[ 3 ];
         # v2 ^= k0;
-        $v[4] ^= $k[0];
-        $v[5] ^= $k[1];
+        $v[ 4 ] ^= $k[ 0 ];
+        $v[ 5 ] ^= $k[ 1 ];
         # v1 ^= k1;
-        $v[2] ^= $k[2];
-        $v[3] ^= $k[3];
+        $v[ 2 ] ^= $k[ 2 ];
+        $v[ 3 ] ^= $k[ 3 ];
         # v0 ^= k0;
-        $v[0] ^= $k[0];
-        $v[1] ^= $k[1];
+        $v[ 0 ] ^= $k[ 0 ];
+        $v[ 1 ] ^= $k[ 1 ];
 
         $left = $inlen;
         # for ( ; in != end; in += 8 )
-        while ($left >= 8) {
+        while ( $left >= 8 ) {
             # m = LOAD64_LE( in );
             $m = array(
-                self::load_4(self::substr($in, 4, 4)),
-                self::load_4(self::substr($in, 0, 4))
+                self::load_4( self::substr( $in, 4, 4 ) ),
+                self::load_4( self::substr( $in, 0, 4 ) )
             );
 
             # v3 ^= m;
-            $v[6] ^= $m[0];
-            $v[7] ^= $m[1];
+            $v[ 6 ] ^= $m[ 0 ];
+            $v[ 7 ] ^= $m[ 1 ];
 
             # SIPROUND;
             # SIPROUND;
-            $v = self::sipRound($v);
-            $v = self::sipRound($v);
+            $v = self::sipRound( $v );
+            $v = self::sipRound( $v );
 
             # v0 ^= m;
-            $v[0] ^= $m[0];
-            $v[1] ^= $m[1];
+            $v[ 0 ] ^= $m[ 0 ];
+            $v[ 1 ] ^= $m[ 1 ];
 
-            $in = self::substr($in, 8);
+            $in = self::substr( $in, 8 );
             $left -= 8;
         }
 
@@ -252,55 +252,55 @@ 
         #     case 1: b |= ( ( u64 )in[ 0] ); break;
         #     case 0: break;
         # }
-        switch ($left) {
+        switch ( $left ) {
             case 7:
-                $b[0] |= self::chrToInt($in[6]) << 16;
+                $b[ 0 ] |= self::chrToInt( $in[ 6 ] ) << 16;
             case 6:
-                $b[0] |= self::chrToInt($in[5]) << 8;
+                $b[ 0 ] |= self::chrToInt( $in[ 5 ] ) << 8;
             case 5:
-                $b[0] |= self::chrToInt($in[4]);
+                $b[ 0 ] |= self::chrToInt( $in[ 4 ] );
             case 4:
-                $b[1] |= self::chrToInt($in[3]) << 24;
+                $b[ 1 ] |= self::chrToInt( $in[ 3 ] ) << 24;
             case 3:
-                $b[1] |= self::chrToInt($in[2]) << 16;
+                $b[ 1 ] |= self::chrToInt( $in[ 2 ] ) << 16;
             case 2:
-                $b[1] |= self::chrToInt($in[1]) << 8;
+                $b[ 1 ] |= self::chrToInt( $in[ 1 ] ) << 8;
             case 1:
-                $b[1] |= self::chrToInt($in[0]);
+                $b[ 1 ] |= self::chrToInt( $in[ 0 ] );
             case 0:
                 break;
         }
         // See docblock for why the 0th index gets the higher bits.
 
         # v3 ^= b;
-        $v[6] ^= $b[0];
-        $v[7] ^= $b[1];
+        $v[ 6 ] ^= $b[ 0 ];
+        $v[ 7 ] ^= $b[ 1 ];
 
         # SIPROUND;
         # SIPROUND;
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
+        $v = self::sipRound( $v );
+        $v = self::sipRound( $v );
 
         # v0 ^= b;
-        $v[0] ^= $b[0];
-        $v[1] ^= $b[1];
+        $v[ 0 ] ^= $b[ 0 ];
+        $v[ 1 ] ^= $b[ 1 ];
 
         // Flip the lower 8 bits of v2 which is ($v[4], $v[5]) in our implementation
         # v2 ^= 0xff;
-        $v[5] ^= 0xff;
+        $v[ 5 ] ^= 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  self::store32_le($v[1] ^ $v[3] ^ $v[5] ^ $v[7]) .
-            self::store32_le($v[0] ^ $v[2] ^ $v[4] ^ $v[6]);
+        return  self::store32_le( $v[ 1 ] ^ $v[ 3 ] ^ $v[ 5 ] ^ $v[ 7 ] ) .
+            self::store32_le( $v[ 0 ] ^ $v[ 2 ] ^ $v[ 4 ] ^ $v[ 6 ] );
     }
 }

Braces +5 added lines, -10 removed lines

@@ -9,8 +9,7 @@ 
  *
  * Only uses 32-bit arithmetic, while the original SipHash used 64-bit integers
  */
-class ParagonIE_Sodium_Core_SipHash extends ParagonIE_Sodium_Core_Util
-{
+class ParagonIE_Sodium_Core_SipHash extends ParagonIE_Sodium_Core_Util {
     /**
      * @internal You should not use this directly from another application
      *
@@ -18,8 +17,7 @@ 
      * @return int[]
      *
      */
-    public static function sipRound(array $v)
-    {
+    public static function sipRound(array $v) {
         # v0 += v1;
         list($v[0], $v[1]) = self::add(
             array($v[0], $v[1]),
@@ -90,8 +88,7 @@ 
      * @param int[] $b
      * @return array<int, mixed>
      */
-    public static function add(array $a, array $b)
-    {
+    public static function add(array $a, array $b) {
         /** @var int $x1 */
         $x1 = $a[1] + $b[1];
         /** @var int $c */
@@ -112,8 +109,7 @@ 
      * @param int $c
      * @return array<int, mixed>
      */
-    public static function rotl_64($int0, $int1, $c)
-    {
+    public static function rotl_64($int0, $int1, $c) {
         $int0 &= 0xffffffff;
         $int1 &= 0xffffffff;
         $c &= 63;
@@ -160,8 +156,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/Core/XChaCha20.php

Indentation +103 added lines, -103 removed lines

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

Spacing +23 added lines, -23 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_XChaCha20', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_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_Core_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 )
         );
     }
 
@@ -46,20 +46,20 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function ietfStream($len = 64, $nonce = '', $key = '')
+    public static function ietfStream( $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_Core_ChaCha20_IetfCtx(
                 self::hChaCha20(
-                    self::substr($nonce, 0, 16),
+                    self::substr( $nonce, 0, 16 ),
                     $key
                 ),
-                "\x00\x00\x00\x00" . self::substr($nonce, 16, 8)
+                "\x00\x00\x00\x00" . self::substr( $nonce, 16, 8 )
             ),
-            str_repeat("\x00", $len)
+            str_repeat( "\x00", $len )
         );
     }
 
@@ -74,15 +74,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_Core_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
@@ -100,15 +100,15 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function ietfStreamXorIc($message, $nonce = '', $key = '', $ic = '')
+    public static function ietfStreamXorIc( $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_Core_ChaCha20_IetfCtx(
-                self::hChaCha20(self::substr($nonce, 0, 16), $key),
-                "\x00\x00\x00\x00" . self::substr($nonce, 16, 8),
+                self::hChaCha20( self::substr( $nonce, 0, 16 ), $key ),
+                "\x00\x00\x00\x00" . self::substr( $nonce, 16, 8 ),
                 $ic
             ),
             $message

Braces +5 added lines, -10 removed lines

@@ -7,8 +7,7 @@ 
 /**
  * Class ParagonIE_Sodium_Core_XChaCha20
  */
-class ParagonIE_Sodium_Core_XChaCha20 extends ParagonIE_Sodium_Core_HChaCha20
-{
+class ParagonIE_Sodium_Core_XChaCha20 extends ParagonIE_Sodium_Core_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');
         }
@@ -46,8 +44,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function ietfStream($len = 64, $nonce = '', $key = '')
-    {
+    public static function ietfStream($len = 64, $nonce = '', $key = '') {
         if (self::strlen($nonce) !== 24) {
             throw new SodiumException('Nonce must be 24 bytes long');
         }
@@ -74,8 +71,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');
         }
@@ -100,8 +96,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function ietfStreamXorIc($message, $nonce = '', $key = '', $ic = '')
-    {
+    public static function ietfStreamXorIc($message, $nonce = '', $key = '', $ic = '') {
         if (self::strlen($nonce) !== 24) {
             throw new SodiumException('Nonce must be 24 bytes long');
         }

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

Indentation +316 added lines, -316 removed lines

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

Spacing +145 added lines, -145 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_X25519', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_X25519', false ) ) {
     return;
 }
 
@@ -25,57 +25,57 @@ 
         ParagonIE_Sodium_Core_Curve25519_Fe $g,
         $b = 0
     ) {
-        $f0 = (int) $f[0];
-        $f1 = (int) $f[1];
-        $f2 = (int) $f[2];
-        $f3 = (int) $f[3];
-        $f4 = (int) $f[4];
-        $f5 = (int) $f[5];
-        $f6 = (int) $f[6];
-        $f7 = (int) $f[7];
-        $f8 = (int) $f[8];
-        $f9 = (int) $f[9];
-        $g0 = (int) $g[0];
-        $g1 = (int) $g[1];
-        $g2 = (int) $g[2];
-        $g3 = (int) $g[3];
-        $g4 = (int) $g[4];
-        $g5 = (int) $g[5];
-        $g6 = (int) $g[6];
-        $g7 = (int) $g[7];
-        $g8 = (int) $g[8];
-        $g9 = (int) $g[9];
+        $f0 = (int)$f[ 0 ];
+        $f1 = (int)$f[ 1 ];
+        $f2 = (int)$f[ 2 ];
+        $f3 = (int)$f[ 3 ];
+        $f4 = (int)$f[ 4 ];
+        $f5 = (int)$f[ 5 ];
+        $f6 = (int)$f[ 6 ];
+        $f7 = (int)$f[ 7 ];
+        $f8 = (int)$f[ 8 ];
+        $f9 = (int)$f[ 9 ];
+        $g0 = (int)$g[ 0 ];
+        $g1 = (int)$g[ 1 ];
+        $g2 = (int)$g[ 2 ];
+        $g3 = (int)$g[ 3 ];
+        $g4 = (int)$g[ 4 ];
+        $g5 = (int)$g[ 5 ];
+        $g6 = (int)$g[ 6 ];
+        $g7 = (int)$g[ 7 ];
+        $g8 = (int)$g[ 8 ];
+        $g9 = (int)$g[ 9 ];
         $b = -$b;
-        $x0 = ($f0 ^ $g0) & $b;
-        $x1 = ($f1 ^ $g1) & $b;
-        $x2 = ($f2 ^ $g2) & $b;
-        $x3 = ($f3 ^ $g3) & $b;
-        $x4 = ($f4 ^ $g4) & $b;
-        $x5 = ($f5 ^ $g5) & $b;
-        $x6 = ($f6 ^ $g6) & $b;
-        $x7 = ($f7 ^ $g7) & $b;
-        $x8 = ($f8 ^ $g8) & $b;
-        $x9 = ($f9 ^ $g9) & $b;
-        $f[0] = $f0 ^ $x0;
-        $f[1] = $f1 ^ $x1;
-        $f[2] = $f2 ^ $x2;
-        $f[3] = $f3 ^ $x3;
-        $f[4] = $f4 ^ $x4;
-        $f[5] = $f5 ^ $x5;
-        $f[6] = $f6 ^ $x6;
-        $f[7] = $f7 ^ $x7;
-        $f[8] = $f8 ^ $x8;
-        $f[9] = $f9 ^ $x9;
-        $g[0] = $g0 ^ $x0;
-        $g[1] = $g1 ^ $x1;
-        $g[2] = $g2 ^ $x2;
-        $g[3] = $g3 ^ $x3;
-        $g[4] = $g4 ^ $x4;
-        $g[5] = $g5 ^ $x5;
-        $g[6] = $g6 ^ $x6;
-        $g[7] = $g7 ^ $x7;
-        $g[8] = $g8 ^ $x8;
-        $g[9] = $g9 ^ $x9;
+        $x0 = ( $f0 ^ $g0 ) & $b;
+        $x1 = ( $f1 ^ $g1 ) & $b;
+        $x2 = ( $f2 ^ $g2 ) & $b;
+        $x3 = ( $f3 ^ $g3 ) & $b;
+        $x4 = ( $f4 ^ $g4 ) & $b;
+        $x5 = ( $f5 ^ $g5 ) & $b;
+        $x6 = ( $f6 ^ $g6 ) & $b;
+        $x7 = ( $f7 ^ $g7 ) & $b;
+        $x8 = ( $f8 ^ $g8 ) & $b;
+        $x9 = ( $f9 ^ $g9 ) & $b;
+        $f[ 0 ] = $f0 ^ $x0;
+        $f[ 1 ] = $f1 ^ $x1;
+        $f[ 2 ] = $f2 ^ $x2;
+        $f[ 3 ] = $f3 ^ $x3;
+        $f[ 4 ] = $f4 ^ $x4;
+        $f[ 5 ] = $f5 ^ $x5;
+        $f[ 6 ] = $f6 ^ $x6;
+        $f[ 7 ] = $f7 ^ $x7;
+        $f[ 8 ] = $f8 ^ $x8;
+        $f[ 9 ] = $f9 ^ $x9;
+        $g[ 0 ] = $g0 ^ $x0;
+        $g[ 1 ] = $g1 ^ $x1;
+        $g[ 2 ] = $g2 ^ $x2;
+        $g[ 3 ] = $g3 ^ $x3;
+        $g[ 4 ] = $g4 ^ $x4;
+        $g[ 5 ] = $g5 ^ $x5;
+        $g[ 6 ] = $g6 ^ $x6;
+        $g[ 7 ] = $g7 ^ $x7;
+        $g[ 8 ] = $g8 ^ $x8;
+        $g[ 9 ] = $g9 ^ $x9;
     }
 
     /**
@@ -84,67 +84,67 @@ 
      * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
      * @return ParagonIE_Sodium_Core_Curve25519_Fe
      */
-    public static function fe_mul121666(ParagonIE_Sodium_Core_Curve25519_Fe $f)
+    public static function fe_mul121666( ParagonIE_Sodium_Core_Curve25519_Fe $f )
     {
         $h = array(
-            self::mul((int) $f[0], 121666, 17),
-            self::mul((int) $f[1], 121666, 17),
-            self::mul((int) $f[2], 121666, 17),
-            self::mul((int) $f[3], 121666, 17),
-            self::mul((int) $f[4], 121666, 17),
-            self::mul((int) $f[5], 121666, 17),
-            self::mul((int) $f[6], 121666, 17),
-            self::mul((int) $f[7], 121666, 17),
-            self::mul((int) $f[8], 121666, 17),
-            self::mul((int) $f[9], 121666, 17)
+            self::mul( (int)$f[ 0 ], 121666, 17 ),
+            self::mul( (int)$f[ 1 ], 121666, 17 ),
+            self::mul( (int)$f[ 2 ], 121666, 17 ),
+            self::mul( (int)$f[ 3 ], 121666, 17 ),
+            self::mul( (int)$f[ 4 ], 121666, 17 ),
+            self::mul( (int)$f[ 5 ], 121666, 17 ),
+            self::mul( (int)$f[ 6 ], 121666, 17 ),
+            self::mul( (int)$f[ 7 ], 121666, 17 ),
+            self::mul( (int)$f[ 8 ], 121666, 17 ),
+            self::mul( (int)$f[ 9 ], 121666, 17 )
         );
 
         /** @var int $carry9 */
-        $carry9 = ($h[9] + (1 << 24)) >> 25;
-        $h[0] += self::mul($carry9, 19, 5);
-        $h[9] -= $carry9 << 25;
+        $carry9 = ( $h[ 9 ] + ( 1 << 24 ) ) >> 25;
+        $h[ 0 ] += self::mul( $carry9, 19, 5 );
+        $h[ 9 ] -= $carry9 << 25;
         /** @var int $carry1 */
-        $carry1 = ($h[1] + (1 << 24)) >> 25;
-        $h[2] += $carry1;
-        $h[1] -= $carry1 << 25;
+        $carry1 = ( $h[ 1 ] + ( 1 << 24 ) ) >> 25;
+        $h[ 2 ] += $carry1;
+        $h[ 1 ] -= $carry1 << 25;
         /** @var int $carry3 */
-        $carry3 = ($h[3] + (1 << 24)) >> 25;
-        $h[4] += $carry3;
-        $h[3] -= $carry3 << 25;
+        $carry3 = ( $h[ 3 ] + ( 1 << 24 ) ) >> 25;
+        $h[ 4 ] += $carry3;
+        $h[ 3 ] -= $carry3 << 25;
         /** @var int $carry5 */
-        $carry5 = ($h[5] + (1 << 24)) >> 25;
-        $h[6] += $carry5;
-        $h[5] -= $carry5 << 25;
+        $carry5 = ( $h[ 5 ] + ( 1 << 24 ) ) >> 25;
+        $h[ 6 ] += $carry5;
+        $h[ 5 ] -= $carry5 << 25;
         /** @var int $carry7 */
-        $carry7 = ($h[7] + (1 << 24)) >> 25;
-        $h[8] += $carry7;
-        $h[7] -= $carry7 << 25;
+        $carry7 = ( $h[ 7 ] + ( 1 << 24 ) ) >> 25;
+        $h[ 8 ] += $carry7;
+        $h[ 7 ] -= $carry7 << 25;
 
         /** @var int $carry0 */
-        $carry0 = ($h[0] + (1 << 25)) >> 26;
-        $h[1] += $carry0;
-        $h[0] -= $carry0 << 26;
+        $carry0 = ( $h[ 0 ] + ( 1 << 25 ) ) >> 26;
+        $h[ 1 ] += $carry0;
+        $h[ 0 ] -= $carry0 << 26;
         /** @var int $carry2 */
-        $carry2 = ($h[2] + (1 << 25)) >> 26;
-        $h[3] += $carry2;
-        $h[2] -= $carry2 << 26;
+        $carry2 = ( $h[ 2 ] + ( 1 << 25 ) ) >> 26;
+        $h[ 3 ] += $carry2;
+        $h[ 2 ] -= $carry2 << 26;
         /** @var int $carry4 */
-        $carry4 = ($h[4] + (1 << 25)) >> 26;
-        $h[5] += $carry4;
-        $h[4] -= $carry4 << 26;
+        $carry4 = ( $h[ 4 ] + ( 1 << 25 ) ) >> 26;
+        $h[ 5 ] += $carry4;
+        $h[ 4 ] -= $carry4 << 26;
         /** @var int $carry6 */
-        $carry6 = ($h[6] + (1 << 25)) >> 26;
-        $h[7] += $carry6;
-        $h[6] -= $carry6 << 26;
+        $carry6 = ( $h[ 6 ] + ( 1 << 25 ) ) >> 26;
+        $h[ 7 ] += $carry6;
+        $h[ 6 ] -= $carry6 << 26;
         /** @var int $carry8 */
-        $carry8 = ($h[8] + (1 << 25)) >> 26;
-        $h[9] += $carry8;
-        $h[8] -= $carry8 << 26;
+        $carry8 = ( $h[ 8 ] + ( 1 << 25 ) ) >> 26;
+        $h[ 9 ] += $carry8;
+        $h[ 8 ] -= $carry8 << 26;
 
-        foreach ($h as $i => $value) {
-            $h[$i] = (int) $value;
+        foreach ( $h as $i => $value ) {
+            $h[ $i ] = (int)$value;
         }
-        return ParagonIE_Sodium_Core_Curve25519_Fe::fromArray($h);
+        return ParagonIE_Sodium_Core_Curve25519_Fe::fromArray( $h );
     }
 
     /**
@@ -158,27 +158,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();
 
@@ -187,89 +187,89 @@ 
         $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;
             # swap ^= b;
             $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;
             $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 self::fe_tobytes($x2);
+        return self::fe_tobytes( $x2 );
     }
 
     /**
@@ -283,10 +283,10 @@ 
         ParagonIE_Sodium_Core_Curve25519_Fe $edwardsY,
         ParagonIE_Sodium_Core_Curve25519_Fe $edwardsZ
     ) {
-        $tempX = self::fe_add($edwardsZ, $edwardsY);
-        $tempZ = self::fe_sub($edwardsZ, $edwardsY);
-        $tempZ = self::fe_invert($tempZ);
-        return self::fe_mul($tempX, $tempZ);
+        $tempX = self::fe_add( $edwardsZ, $edwardsY );
+        $tempZ = self::fe_sub( $edwardsZ, $edwardsY );
+        $tempZ = self::fe_invert( $tempZ );
+        return self::fe_mul( $tempX, $tempZ );
     }
 
     /**
@@ -297,31 +297,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_Core_Curve25519_Fe)
+            ! ( $A->Y instanceof ParagonIE_Sodium_Core_Curve25519_Fe )
                 ||
-            !($A->Z instanceof ParagonIE_Sodium_Core_Curve25519_Fe)
+            ! ( $A->Z instanceof ParagonIE_Sodium_Core_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_Core_X25519
  */
-abstract class ParagonIE_Sodium_Core_X25519 extends ParagonIE_Sodium_Core_Curve25519
-{
+abstract class ParagonIE_Sodium_Core_X25519 extends ParagonIE_Sodium_Core_Curve25519 {
     /**
      * Alters the objects passed to this method in place.
      *
@@ -84,8 +83,7 @@ 
      * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
      * @return ParagonIE_Sodium_Core_Curve25519_Fe
      */
-    public static function fe_mul121666(ParagonIE_Sodium_Core_Curve25519_Fe $f)
-    {
+    public static function fe_mul121666(ParagonIE_Sodium_Core_Curve25519_Fe $f) {
         $h = array(
             self::mul((int) $f[0], 121666, 17),
             self::mul((int) $f[1], 121666, 17),
@@ -158,8 +156,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;
@@ -297,8 +294,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/Core/Poly1305.php

Indentation +50 added lines, -50 removed lines

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

Spacing +10 added lines, -10 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_Poly1305', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_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_Core_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_Core_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_Core_Poly1305
  */
-abstract class ParagonIE_Sodium_Core_Poly1305 extends ParagonIE_Sodium_Core_Util
-{
+abstract class ParagonIE_Sodium_Core_Poly1305 extends ParagonIE_Sodium_Core_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.'

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

Indentation +45 added lines, -45 removed lines

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

Spacing +6 added lines, -6 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_XSalsa20', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_XSalsa20', false ) ) {
     return;
 }
 
@@ -21,12 +21,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function xsalsa20($len, $nonce, $key)
+    public static function xsalsa20( $len, $nonce, $key )
     {
         $ret = self::salsa20(
             $len,
-            self::substr($nonce, 16, 8),
-            self::hsalsa20($nonce, $key)
+            self::substr( $nonce, 16, 8 ),
+            self::hsalsa20( $nonce, $key )
         );
         return $ret;
     }
@@ -43,12 +43,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function xsalsa20_xor($message, $nonce, $key)
+    public static function xsalsa20_xor( $message, $nonce, $key )
     {
         return self::xorStrings(
             $message,
             self::xsalsa20(
-                self::strlen($message),
+                self::strlen( $message ),
                 $nonce,
                 $key
             )

Braces +3 added lines, -6 removed lines

@@ -7,8 +7,7 @@ 
 /**
  * Class ParagonIE_Sodium_Core_XSalsa20
  */
-abstract class ParagonIE_Sodium_Core_XSalsa20 extends ParagonIE_Sodium_Core_HSalsa20
-{
+abstract class ParagonIE_Sodium_Core_XSalsa20 extends ParagonIE_Sodium_Core_HSalsa20 {
     /**
      * Expand a key and nonce into an xsalsa20 keystream.
      *
@@ -21,8 +20,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function xsalsa20($len, $nonce, $key)
-    {
+    public static function xsalsa20($len, $nonce, $key) {
         $ret = self::salsa20(
             $len,
             self::substr($nonce, 16, 8),
@@ -43,8 +41,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function xsalsa20_xor($message, $nonce, $key)
-    {
+    public static function xsalsa20_xor($message, $nonce, $key) {
         return self::xorStrings(
             $message,
             self::xsalsa20(

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

Indentation +285 added lines, -285 removed lines

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

Braces +7 added lines, -14 removed lines

@@ -7,8 +7,7 @@ 
 /**
  * Class ParagonIE_Sodium_Core_ChaCha20
  */
-class ParagonIE_Sodium_Core_ChaCha20 extends ParagonIE_Sodium_Core_Util
-{
+class ParagonIE_Sodium_Core_ChaCha20 extends ParagonIE_Sodium_Core_Util {
     /**
      * Bitwise left rotation
      *
@@ -18,8 +17,7 @@ 
      * @param int $n
      * @return int
      */
-    public static function rotate($v, $n)
-    {
+    public static function rotate($v, $n) {
         $v &= 0xffffffff;
         $n &= 31;
         return (int) (
@@ -42,8 +40,7 @@ 
      * @param int $d
      * @return array<int, int>
      */
-    protected static function quarterRound($a, $b, $c, $d)
-    {
+    protected static function quarterRound($a, $b, $c, $d) {
         # a = PLUS(a,b); d = ROTATE(XOR(d,a),16);
         /** @var int $a */
         $a = ($a + $b) & 0xffffffff;
@@ -329,8 +326,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function stream($len = 64, $nonce = '', $key = '')
-    {
+    public static function stream($len = 64, $nonce = '', $key = '') {
         return self::encryptBytes(
             new ParagonIE_Sodium_Core_ChaCha20_Ctx($key, $nonce),
             str_repeat("\x00", $len)
@@ -347,8 +343,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function ietfStream($len, $nonce = '', $key = '')
-    {
+    public static function ietfStream($len, $nonce = '', $key = '') {
         return self::encryptBytes(
             new ParagonIE_Sodium_Core_ChaCha20_IetfCtx($key, $nonce),
             str_repeat("\x00", $len)
@@ -366,8 +361,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function ietfStreamXorIc($message, $nonce = '', $key = '', $ic = '')
-    {
+    public static function ietfStreamXorIc($message, $nonce = '', $key = '', $ic = '') {
         return self::encryptBytes(
             new ParagonIE_Sodium_Core_ChaCha20_IetfCtx($key, $nonce, $ic),
             $message
@@ -385,8 +379,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function streamXorIc($message, $nonce = '', $key = '', $ic = '')
-    {
+    public static function streamXorIc($message, $nonce = '', $key = '', $ic = '') {
         return self::encryptBytes(
             new ParagonIE_Sodium_Core_ChaCha20_Ctx($key, $nonce, $ic),
             $message

Spacing +126 added lines, -126 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_ChaCha20', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_ChaCha20', false ) ) {
     return;
 }
 
@@ -18,15 +18,15 @@ 
      * @param int $n
      * @return int
      */
-    public static function rotate($v, $n)
+    public static function rotate( $v, $n )
     {
         $v &= 0xffffffff;
         $n &= 31;
-        return (int) (
+        return (int)(
             0xffffffff & (
-                ($v << $n)
+                ( $v << $n )
                     |
-                ($v >> (32 - $n))
+                ( $v >> ( 32 - $n ) )
             )
         );
     }
@@ -42,28 +42,28 @@ 
      * @param int $d
      * @return array<int, int>
      */
-    protected static function quarterRound($a, $b, $c, $d)
+    protected static function quarterRound( $a, $b, $c, $d )
     {
         # a = PLUS(a,b); d = ROTATE(XOR(d,a),16);
         /** @var int $a */
-        $a = ($a + $b) & 0xffffffff;
-        $d = self::rotate($d ^ $a, 16);
+        $a = ( $a + $b ) & 0xffffffff;
+        $d = self::rotate( $d ^ $a, 16 );
 
         # c = PLUS(c,d); b = ROTATE(XOR(b,c),12);
         /** @var int $c */
-        $c = ($c + $d) & 0xffffffff;
-        $b = self::rotate($b ^ $c, 12);
+        $c = ( $c + $d ) & 0xffffffff;
+        $b = self::rotate( $b ^ $c, 12 );
 
         # a = PLUS(a,b); d = ROTATE(XOR(d,a), 8);
         /** @var int $a */
-        $a = ($a + $b) & 0xffffffff;
-        $d = self::rotate($d ^ $a, 8);
+        $a = ( $a + $b ) & 0xffffffff;
+        $d = self::rotate( $d ^ $a, 8 );
 
         # c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
         /** @var int $c */
-        $c = ($c + $d) & 0xffffffff;
-        $b = self::rotate($b ^ $c, 7);
-        return array((int) $a, (int) $b, (int) $c, (int) $d);
+        $c = ( $c + $d ) & 0xffffffff;
+        $b = self::rotate( $b ^ $c, 7 );
+        return array( (int)$a, (int)$b, (int)$c, (int)$d );
     }
 
     /**
@@ -80,7 +80,7 @@ 
         ParagonIE_Sodium_Core_ChaCha20_Ctx $ctx,
         $message = ''
     ) {
-        $bytes = self::strlen($message);
+        $bytes = self::strlen( $message );
 
         /*
         j0 = ctx->input[0];
@@ -100,71 +100,71 @@ 
         j14 = ctx->input[14];
         j15 = ctx->input[15];
         */
-        $j0  = (int) $ctx[0];
-        $j1  = (int) $ctx[1];
-        $j2  = (int) $ctx[2];
-        $j3  = (int) $ctx[3];
-        $j4  = (int) $ctx[4];
-        $j5  = (int) $ctx[5];
-        $j6  = (int) $ctx[6];
-        $j7  = (int) $ctx[7];
-        $j8  = (int) $ctx[8];
-        $j9  = (int) $ctx[9];
-        $j10 = (int) $ctx[10];
-        $j11 = (int) $ctx[11];
-        $j12 = (int) $ctx[12];
-        $j13 = (int) $ctx[13];
-        $j14 = (int) $ctx[14];
-        $j15 = (int) $ctx[15];
+        $j0  = (int)$ctx[ 0 ];
+        $j1  = (int)$ctx[ 1 ];
+        $j2  = (int)$ctx[ 2 ];
+        $j3  = (int)$ctx[ 3 ];
+        $j4  = (int)$ctx[ 4 ];
+        $j5  = (int)$ctx[ 5 ];
+        $j6  = (int)$ctx[ 6 ];
+        $j7  = (int)$ctx[ 7 ];
+        $j8  = (int)$ctx[ 8 ];
+        $j9  = (int)$ctx[ 9 ];
+        $j10 = (int)$ctx[ 10 ];
+        $j11 = (int)$ctx[ 11 ];
+        $j12 = (int)$ctx[ 12 ];
+        $j13 = (int)$ctx[ 13 ];
+        $j14 = (int)$ctx[ 14 ];
+        $j15 = (int)$ctx[ 15 ];
 
         $c = '';
-        for (;;) {
-            if ($bytes < 64) {
-                $message .= str_repeat("\x00", 64 - $bytes);
+        for ( ;; ) {
+            if ( $bytes < 64 ) {
+                $message .= str_repeat( "\x00", 64 - $bytes );
             }
 
-            $x0 =  (int) $j0;
-            $x1 =  (int) $j1;
-            $x2 =  (int) $j2;
-            $x3 =  (int) $j3;
-            $x4 =  (int) $j4;
-            $x5 =  (int) $j5;
-            $x6 =  (int) $j6;
-            $x7 =  (int) $j7;
-            $x8 =  (int) $j8;
-            $x9 =  (int) $j9;
-            $x10 = (int) $j10;
-            $x11 = (int) $j11;
-            $x12 = (int) $j12;
-            $x13 = (int) $j13;
-            $x14 = (int) $j14;
-            $x15 = (int) $j15;
+            $x0 = (int)$j0;
+            $x1 = (int)$j1;
+            $x2 = (int)$j2;
+            $x3 = (int)$j3;
+            $x4 = (int)$j4;
+            $x5 = (int)$j5;
+            $x6 = (int)$j6;
+            $x7 = (int)$j7;
+            $x8 = (int)$j8;
+            $x9 = (int)$j9;
+            $x10 = (int)$j10;
+            $x11 = (int)$j11;
+            $x12 = (int)$j12;
+            $x13 = (int)$j13;
+            $x14 = (int)$j14;
+            $x15 = (int)$j15;
 
             # for (i = 20; i > 0; i -= 2) {
-            for ($i = 20; $i > 0; $i -= 2) {
+            for ( $i = 20; $i > 0; $i -= 2 ) {
                 # QUARTERROUND( x0,  x4,  x8,  x12)
-                list($x0, $x4, $x8, $x12) = self::quarterRound($x0, $x4, $x8, $x12);
+                list( $x0, $x4, $x8, $x12 ) = self::quarterRound( $x0, $x4, $x8, $x12 );
 
                 # QUARTERROUND( x1,  x5,  x9,  x13)
-                list($x1, $x5, $x9, $x13) = self::quarterRound($x1, $x5, $x9, $x13);
+                list( $x1, $x5, $x9, $x13 ) = self::quarterRound( $x1, $x5, $x9, $x13 );
 
                 # QUARTERROUND( x2,  x6,  x10,  x14)
-                list($x2, $x6, $x10, $x14) = self::quarterRound($x2, $x6, $x10, $x14);
+                list( $x2, $x6, $x10, $x14 ) = self::quarterRound( $x2, $x6, $x10, $x14 );
 
                 # QUARTERROUND( x3,  x7,  x11,  x15)
-                list($x3, $x7, $x11, $x15) = self::quarterRound($x3, $x7, $x11, $x15);
+                list( $x3, $x7, $x11, $x15 ) = self::quarterRound( $x3, $x7, $x11, $x15 );
 
                 # QUARTERROUND( x0,  x5,  x10,  x15)
-                list($x0, $x5, $x10, $x15) = self::quarterRound($x0, $x5, $x10, $x15);
+                list( $x0, $x5, $x10, $x15 ) = self::quarterRound( $x0, $x5, $x10, $x15 );
 
                 # QUARTERROUND( x1,  x6,  x11,  x12)
-                list($x1, $x6, $x11, $x12) = self::quarterRound($x1, $x6, $x11, $x12);
+                list( $x1, $x6, $x11, $x12 ) = self::quarterRound( $x1, $x6, $x11, $x12 );
 
                 # QUARTERROUND( x2,  x7,  x8,  x13)
-                list($x2, $x7, $x8, $x13) = self::quarterRound($x2, $x7, $x8, $x13);
+                list( $x2, $x7, $x8, $x13 ) = self::quarterRound( $x2, $x7, $x8, $x13 );
 
                 # QUARTERROUND( x3,  x4,  x9,  x14)
-                list($x3, $x4, $x9, $x14) = self::quarterRound($x3, $x4, $x9, $x14);
+                list( $x3, $x4, $x9, $x14 ) = self::quarterRound( $x3, $x4, $x9, $x14 );
             }
             /*
             x0 = PLUS(x0, j0);
@@ -185,37 +185,37 @@ 
             x15 = PLUS(x15, j15);
             */
             /** @var int $x0 */
-            $x0  = ($x0 & 0xffffffff) + $j0;
+            $x0  = ( $x0 & 0xffffffff ) + $j0;
             /** @var int $x1 */
-            $x1  = ($x1 & 0xffffffff) + $j1;
+            $x1  = ( $x1 & 0xffffffff ) + $j1;
             /** @var int $x2 */
-            $x2  = ($x2 & 0xffffffff) + $j2;
+            $x2  = ( $x2 & 0xffffffff ) + $j2;
             /** @var int $x3 */
-            $x3  = ($x3 & 0xffffffff) + $j3;
+            $x3  = ( $x3 & 0xffffffff ) + $j3;
             /** @var int $x4 */
-            $x4  = ($x4 & 0xffffffff) + $j4;
+            $x4  = ( $x4 & 0xffffffff ) + $j4;
             /** @var int $x5 */
-            $x5  = ($x5 & 0xffffffff) + $j5;
+            $x5  = ( $x5 & 0xffffffff ) + $j5;
             /** @var int $x6 */
-            $x6  = ($x6 & 0xffffffff) + $j6;
+            $x6  = ( $x6 & 0xffffffff ) + $j6;
             /** @var int $x7 */
-            $x7  = ($x7 & 0xffffffff) + $j7;
+            $x7  = ( $x7 & 0xffffffff ) + $j7;
             /** @var int $x8 */
-            $x8  = ($x8 & 0xffffffff) + $j8;
+            $x8  = ( $x8 & 0xffffffff ) + $j8;
             /** @var int $x9 */
-            $x9  = ($x9 & 0xffffffff) + $j9;
+            $x9  = ( $x9 & 0xffffffff ) + $j9;
             /** @var int $x10 */
-            $x10 = ($x10 & 0xffffffff) + $j10;
+            $x10 = ( $x10 & 0xffffffff ) + $j10;
             /** @var int $x11 */
-            $x11 = ($x11 & 0xffffffff) + $j11;
+            $x11 = ( $x11 & 0xffffffff ) + $j11;
             /** @var int $x12 */
-            $x12 = ($x12 & 0xffffffff) + $j12;
+            $x12 = ( $x12 & 0xffffffff ) + $j12;
             /** @var int $x13 */
-            $x13 = ($x13 & 0xffffffff) + $j13;
+            $x13 = ( $x13 & 0xffffffff ) + $j13;
             /** @var int $x14 */
-            $x14 = ($x14 & 0xffffffff) + $j14;
+            $x14 = ( $x14 & 0xffffffff ) + $j14;
             /** @var int $x15 */
-            $x15 = ($x15 & 0xffffffff) + $j15;
+            $x15 = ( $x15 & 0xffffffff ) + $j15;
 
             /*
             x0 = XOR(x0, LOAD32_LE(m + 0));
@@ -235,22 +235,22 @@ 
             x14 = XOR(x14, LOAD32_LE(m + 56));
             x15 = XOR(x15, LOAD32_LE(m + 60));
             */
-            $x0  ^= self::load_4(self::substr($message, 0, 4));
-            $x1  ^= self::load_4(self::substr($message, 4, 4));
-            $x2  ^= self::load_4(self::substr($message, 8, 4));
-            $x3  ^= self::load_4(self::substr($message, 12, 4));
-            $x4  ^= self::load_4(self::substr($message, 16, 4));
-            $x5  ^= self::load_4(self::substr($message, 20, 4));
-            $x6  ^= self::load_4(self::substr($message, 24, 4));
-            $x7  ^= self::load_4(self::substr($message, 28, 4));
-            $x8  ^= self::load_4(self::substr($message, 32, 4));
-            $x9  ^= self::load_4(self::substr($message, 36, 4));
-            $x10 ^= self::load_4(self::substr($message, 40, 4));
-            $x11 ^= self::load_4(self::substr($message, 44, 4));
-            $x12 ^= self::load_4(self::substr($message, 48, 4));
-            $x13 ^= self::load_4(self::substr($message, 52, 4));
-            $x14 ^= self::load_4(self::substr($message, 56, 4));
-            $x15 ^= self::load_4(self::substr($message, 60, 4));
+            $x0  ^= self::load_4( self::substr( $message, 0, 4 ) );
+            $x1  ^= self::load_4( self::substr( $message, 4, 4 ) );
+            $x2  ^= self::load_4( self::substr( $message, 8, 4 ) );
+            $x3  ^= self::load_4( self::substr( $message, 12, 4 ) );
+            $x4  ^= self::load_4( self::substr( $message, 16, 4 ) );
+            $x5  ^= self::load_4( self::substr( $message, 20, 4 ) );
+            $x6  ^= self::load_4( self::substr( $message, 24, 4 ) );
+            $x7  ^= self::load_4( self::substr( $message, 28, 4 ) );
+            $x8  ^= self::load_4( self::substr( $message, 32, 4 ) );
+            $x9  ^= self::load_4( self::substr( $message, 36, 4 ) );
+            $x10 ^= self::load_4( self::substr( $message, 40, 4 ) );
+            $x11 ^= self::load_4( self::substr( $message, 44, 4 ) );
+            $x12 ^= self::load_4( self::substr( $message, 48, 4 ) );
+            $x13 ^= self::load_4( self::substr( $message, 52, 4 ) );
+            $x14 ^= self::load_4( self::substr( $message, 56, 4 ) );
+            $x15 ^= self::load_4( self::substr( $message, 60, 4 ) );
 
             /*
                 j12 = PLUSONE(j12);
@@ -259,8 +259,8 @@ 
                 }
              */
             ++$j12;
-            if ($j12 & 0xf0000000) {
-                throw new SodiumException('Overflow');
+            if ( $j12 & 0xf0000000 ) {
+                throw new SodiumException( 'Overflow' );
             }
 
             /*
@@ -281,41 +281,41 @@ 
             STORE32_LE(c + 56, x14);
             STORE32_LE(c + 60, x15);
             */
-            $block = self::store32_le((int) ($x0  & 0xffffffff)) .
-                 self::store32_le((int) ($x1  & 0xffffffff)) .
-                 self::store32_le((int) ($x2  & 0xffffffff)) .
-                 self::store32_le((int) ($x3  & 0xffffffff)) .
-                 self::store32_le((int) ($x4  & 0xffffffff)) .
-                 self::store32_le((int) ($x5  & 0xffffffff)) .
-                 self::store32_le((int) ($x6  & 0xffffffff)) .
-                 self::store32_le((int) ($x7  & 0xffffffff)) .
-                 self::store32_le((int) ($x8  & 0xffffffff)) .
-                 self::store32_le((int) ($x9  & 0xffffffff)) .
-                 self::store32_le((int) ($x10 & 0xffffffff)) .
-                 self::store32_le((int) ($x11 & 0xffffffff)) .
-                 self::store32_le((int) ($x12 & 0xffffffff)) .
-                 self::store32_le((int) ($x13 & 0xffffffff)) .
-                 self::store32_le((int) ($x14 & 0xffffffff)) .
-                 self::store32_le((int) ($x15 & 0xffffffff));
+            $block = self::store32_le( (int)( $x0  & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x1  & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x2  & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x3  & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x4  & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x5  & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x6  & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x7  & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x8  & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x9  & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x10 & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x11 & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x12 & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x13 & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x14 & 0xffffffff ) ) .
+                 self::store32_le( (int)( $x15 & 0xffffffff ) );
 
             /* Partial block */
-            if ($bytes < 64) {
-                $c .= self::substr($block, 0, $bytes);
+            if ( $bytes < 64 ) {
+                $c .= self::substr( $block, 0, $bytes );
                 break;
             }
 
             /* Full block */
             $c .= $block;
             $bytes -= 64;
-            if ($bytes <= 0) {
+            if ( $bytes <= 0 ) {
                 break;
             }
-            $message = self::substr($message, 64);
+            $message = self::substr( $message, 64 );
         }
         /* end for(;;) loop */
 
-        $ctx[12] = $j12;
-        $ctx[13] = $j13;
+        $ctx[ 12 ] = $j12;
+        $ctx[ 13 ] = $j13;
         return $c;
     }
 
@@ -329,11 +329,11 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function stream($len = 64, $nonce = '', $key = '')
+    public static function stream( $len = 64, $nonce = '', $key = '' )
     {
         return self::encryptBytes(
-            new ParagonIE_Sodium_Core_ChaCha20_Ctx($key, $nonce),
-            str_repeat("\x00", $len)
+            new ParagonIE_Sodium_Core_ChaCha20_Ctx( $key, $nonce ),
+            str_repeat( "\x00", $len )
         );
     }
 
@@ -347,11 +347,11 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function ietfStream($len, $nonce = '', $key = '')
+    public static function ietfStream( $len, $nonce = '', $key = '' )
     {
         return self::encryptBytes(
-            new ParagonIE_Sodium_Core_ChaCha20_IetfCtx($key, $nonce),
-            str_repeat("\x00", $len)
+            new ParagonIE_Sodium_Core_ChaCha20_IetfCtx( $key, $nonce ),
+            str_repeat( "\x00", $len )
         );
     }
 
@@ -366,10 +366,10 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function ietfStreamXorIc($message, $nonce = '', $key = '', $ic = '')
+    public static function ietfStreamXorIc( $message, $nonce = '', $key = '', $ic = '' )
     {
         return self::encryptBytes(
-            new ParagonIE_Sodium_Core_ChaCha20_IetfCtx($key, $nonce, $ic),
+            new ParagonIE_Sodium_Core_ChaCha20_IetfCtx( $key, $nonce, $ic ),
             $message
         );
     }
@@ -385,10 +385,10 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function streamXorIc($message, $nonce = '', $key = '', $ic = '')
+    public static function streamXorIc( $message, $nonce = '', $key = '', $ic = '' )
     {
         return self::encryptBytes(
-            new ParagonIE_Sodium_Core_ChaCha20_Ctx($key, $nonce, $ic),
+            new ParagonIE_Sodium_Core_ChaCha20_Ctx( $key, $nonce, $ic ),
             $message
         );
     }

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

Indentation +86 added lines, -86 removed lines

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

Braces +3 added lines, -6 removed lines

@@ -7,8 +7,7 @@ 
 /**
  * Class ParagonIE_Sodium_Core_HChaCha20
  */
-class ParagonIE_Sodium_Core_HChaCha20 extends ParagonIE_Sodium_Core_ChaCha20
-{
+class ParagonIE_Sodium_Core_HChaCha20 extends ParagonIE_Sodium_Core_ChaCha20 {
     /**
      * @param string $in
      * @param string $key
@@ -16,8 +15,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function hChaCha20($in = '', $key = '', $c = null)
-    {
+    public static function hChaCha20($in = '', $key = '', $c = null) {
         $ctx = array();
 
         if ($c === null) {
@@ -51,8 +49,7 @@ 
      * @return string
      * @throws TypeError
      */
-    protected static function hChaCha20Bytes(array $ctx)
-    {
+    protected static function hChaCha20Bytes(array $ctx) {
         $x0  = (int) $ctx[0];
         $x1  = (int) $ctx[1];
         $x2  = (int) $ctx[2];

Spacing +58 added lines, -58 removed lines

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