gravityview / GravityView

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

Indentation +699 added lines, -699 removed lines

@@ -5,703 +5,703 @@
  */
 class ParagonIE_Sodium_Core_Ristretto255 extends ParagonIE_Sodium_Core_Ed25519
 {
-    const crypto_core_ristretto255_HASHBYTES = 64;
-    const HASH_SC_L = 48;
-    const CORE_H2C_SHA256 = 1;
-    const CORE_H2C_SHA512 = 2;
-
-    /**
-     * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
-     * @param int $b
-     * @return ParagonIE_Sodium_Core_Curve25519_Fe
-     */
-    public static function fe_cneg(ParagonIE_Sodium_Core_Curve25519_Fe $f, $b)
-    {
-        $negf = self::fe_neg($f);
-        return self::fe_cmov($f, $negf, $b);
-    }
-
-    /**
-     * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
-     * @return ParagonIE_Sodium_Core_Curve25519_Fe
-     * @throws SodiumException
-     */
-    public static function fe_abs(ParagonIE_Sodium_Core_Curve25519_Fe $f)
-    {
-        return self::fe_cneg($f, self::fe_isnegative($f));
-    }
-
-    /**
-     * Returns 0 if this field element results in all NUL bytes.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
-     * @return int
-     * @throws SodiumException
-     */
-    public static function fe_iszero(ParagonIE_Sodium_Core_Curve25519_Fe $f)
-    {
-        static $zero;
-        if ($zero === null) {
-            $zero = str_repeat("\x00", 32);
-        }
-        /** @var string $zero */
-        $str = self::fe_tobytes($f);
-
-        $d = 0;
-        for ($i = 0; $i < 32; ++$i) {
-            $d |= self::chrToInt($str[$i]);
-        }
-        return (($d - 1) >> 31) & 1;
-    }
-
-
-    /**
-     * @param ParagonIE_Sodium_Core_Curve25519_Fe $u
-     * @param ParagonIE_Sodium_Core_Curve25519_Fe $v
-     * @return array{x: ParagonIE_Sodium_Core_Curve25519_Fe, nonsquare: int}
-     *
-     * @throws SodiumException
-     */
-    public static function ristretto255_sqrt_ratio_m1(
-        ParagonIE_Sodium_Core_Curve25519_Fe $u,
-        ParagonIE_Sodium_Core_Curve25519_Fe $v
-    ) {
-        $sqrtm1 = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$sqrtm1);
-
-        $v3 = self::fe_mul(
-            self::fe_sq($v),
-            $v
-        ); /* v3 = v^3 */
-        $x = self::fe_mul(
-            self::fe_mul(
-                self::fe_sq($v3),
-                $u
-            ),
-            $v
-        ); /* x = uv^7 */
-
-        $x = self::fe_mul(
-            self::fe_mul(
-                self::fe_pow22523($x), /* x = (uv^7)^((q-5)/8) */
-                $v3
-            ),
-            $u
-        ); /* x = uv^3(uv^7)^((q-5)/8) */
-
-        $vxx = self::fe_mul(
-            self::fe_sq($x),
-            $v
-        ); /* vx^2 */
-
-        $m_root_check = self::fe_sub($vxx, $u); /* vx^2-u */
-        $p_root_check = self::fe_add($vxx, $u); /* vx^2+u */
-        $f_root_check = self::fe_mul($u, $sqrtm1); /* u*sqrt(-1) */
-        $f_root_check = self::fe_add($vxx, $f_root_check); /* vx^2+u*sqrt(-1) */
-
-        $has_m_root = self::fe_iszero($m_root_check);
-        $has_p_root = self::fe_iszero($p_root_check);
-        $has_f_root = self::fe_iszero($f_root_check);
-
-        $x_sqrtm1 = self::fe_mul($x, $sqrtm1); /* x*sqrt(-1) */
-
-        $x = self::fe_abs(
-            self::fe_cmov($x, $x_sqrtm1, $has_p_root | $has_f_root)
-        );
-        return array(
-            'x' => $x,
-            'nonsquare' => $has_m_root | $has_p_root
-        );
-    }
-
-    /**
-     * @param string $s
-     * @return int
-     * @throws SodiumException
-     */
-    public static function ristretto255_point_is_canonical($s)
-    {
-        $c = (self::chrToInt($s[31]) & 0x7f) ^ 0x7f;
-        for ($i = 30; $i > 0; --$i) {
-            $c |= self::chrToInt($s[$i]) ^ 0xff;
-        }
-        $c = ($c - 1) >> 8;
-        $d = (0xed - 1 - self::chrToInt($s[0])) >> 8;
-        $e = self::chrToInt($s[31]) >> 7;
-
-        return 1 - ((($c & $d) | $e | self::chrToInt($s[0])) & 1);
-    }
-
-    /**
-     * @param string $s
-     * @param bool $skipCanonicalCheck
-     * @return array{h: ParagonIE_Sodium_Core_Curve25519_Ge_P3, res: int}
-     * @throws SodiumException
-     */
-    public static function ristretto255_frombytes($s, $skipCanonicalCheck = false)
-    {
-        if (!$skipCanonicalCheck) {
-            if (!self::ristretto255_point_is_canonical($s)) {
-                throw new SodiumException('S is not canonical');
-            }
-        }
-
-        $s_ = self::fe_frombytes($s);
-        $ss = self::fe_sq($s_); /* ss = s^2 */
-
-        $u1 = self::fe_sub(self::fe_1(), $ss); /* u1 = 1-ss */
-        $u1u1 = self::fe_sq($u1); /* u1u1 = u1^2 */
-
-        $u2 = self::fe_add(self::fe_1(), $ss); /* u2 = 1+ss */
-        $u2u2 = self::fe_sq($u2); /* u2u2 = u2^2 */
-
-        $v = self::fe_mul(
-            ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$d),
-            $u1u1
-        ); /* v = d*u1^2 */
-        $v = self::fe_neg($v); /* v = -d*u1^2 */
-        $v = self::fe_sub($v, $u2u2); /* v = -(d*u1^2)-u2^2 */
-        $v_u2u2 = self::fe_mul($v, $u2u2); /* v_u2u2 = v*u2^2 */
-
-        // fe25519_1(one);
-        // notsquare = ristretto255_sqrt_ratio_m1(inv_sqrt, one, v_u2u2);
-        $one = self::fe_1();
-        $result = self::ristretto255_sqrt_ratio_m1($one, $v_u2u2);
-        $inv_sqrt = $result['x'];
-        $notsquare = $result['nonsquare'];
-
-        $h = new ParagonIE_Sodium_Core_Curve25519_Ge_P3();
-
-        $h->X = self::fe_mul($inv_sqrt, $u2);
-        $h->Y = self::fe_mul(self::fe_mul($inv_sqrt, $h->X), $v);
-
-        $h->X = self::fe_mul($h->X, $s_);
-        $h->X = self::fe_abs(
-            self::fe_add($h->X, $h->X)
-        );
-        $h->Y = self::fe_mul($u1, $h->Y);
-        $h->Z = self::fe_1();
-        $h->T = self::fe_mul($h->X, $h->Y);
-
-        $res = - ((1 - $notsquare) | self::fe_isnegative($h->T) | self::fe_iszero($h->Y));
-        return array('h' => $h, 'res' => $res);
-    }
-
-    /**
-     * @param ParagonIE_Sodium_Core_Curve25519_Ge_P3 $h
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_p3_tobytes(ParagonIE_Sodium_Core_Curve25519_Ge_P3 $h)
-    {
-        $sqrtm1 = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$sqrtm1);
-        $invsqrtamd = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$invsqrtamd);
-
-        $u1 = self::fe_add($h->Z, $h->Y); /* u1 = Z+Y */
-        $zmy = self::fe_sub($h->Z, $h->Y); /* zmy = Z-Y */
-        $u1 = self::fe_mul($u1, $zmy); /* u1 = (Z+Y)*(Z-Y) */
-        $u2 = self::fe_mul($h->X, $h->Y); /* u2 = X*Y */
-
-        $u1_u2u2 = self::fe_mul(self::fe_sq($u2), $u1); /* u1_u2u2 = u1*u2^2 */
-        $one = self::fe_1();
-
-        // fe25519_1(one);
-        // (void) ristretto255_sqrt_ratio_m1(inv_sqrt, one, u1_u2u2);
-        $result = self::ristretto255_sqrt_ratio_m1($one, $u1_u2u2);
-        $inv_sqrt = $result['x'];
-
-        $den1 = self::fe_mul($inv_sqrt, $u1); /* den1 = inv_sqrt*u1 */
-        $den2 = self::fe_mul($inv_sqrt, $u2); /* den2 = inv_sqrt*u2 */
-        $z_inv = self::fe_mul($h->T, self::fe_mul($den1, $den2)); /* z_inv = den1*den2*T */
-
-        $ix = self::fe_mul($h->X, $sqrtm1); /* ix = X*sqrt(-1) */
-        $iy = self::fe_mul($h->Y, $sqrtm1); /* iy = Y*sqrt(-1) */
-        $eden = self::fe_mul($den1, $invsqrtamd);
-
-        $t_z_inv =  self::fe_mul($h->T, $z_inv); /* t_z_inv = T*z_inv */
-        $rotate = self::fe_isnegative($t_z_inv);
-
-        $x_ = self::fe_copy($h->X);
-        $y_ = self::fe_copy($h->Y);
-        $den_inv = self::fe_copy($den2);
-
-        $x_ = self::fe_cmov($x_, $iy, $rotate);
-        $y_ = self::fe_cmov($y_, $ix, $rotate);
-        $den_inv = self::fe_cmov($den_inv, $eden, $rotate);
-
-        $x_z_inv = self::fe_mul($x_, $z_inv);
-        $y_ = self::fe_cneg($y_, self::fe_isnegative($x_z_inv));
-
-
-        // fe25519_sub(s_, h->Z, y_);
-        // fe25519_mul(s_, den_inv, s_);
-        // fe25519_abs(s_, s_);
-        // fe25519_tobytes(s, s_);
-        return self::fe_tobytes(
-            self::fe_abs(
-                self::fe_mul(
-                    $den_inv,
-                    self::fe_sub($h->Z, $y_)
-                )
-            )
-        );
-    }
-
-    /**
-     * @param ParagonIE_Sodium_Core_Curve25519_Fe $t
-     * @return ParagonIE_Sodium_Core_Curve25519_Ge_P3
-     *
-     * @throws SodiumException
-     */
-    public static function ristretto255_elligator(ParagonIE_Sodium_Core_Curve25519_Fe $t)
-    {
-        $sqrtm1   = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$sqrtm1);
-        $onemsqd  = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$onemsqd);
-        $d        = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$d);
-        $sqdmone  = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$sqdmone);
-        $sqrtadm1 = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$sqrtadm1);
-
-        $one = self::fe_1();
-        $r   = self::fe_mul($sqrtm1, self::fe_sq($t));         /* r = sqrt(-1)*t^2 */
-        $u   = self::fe_mul(self::fe_add($r, $one), $onemsqd); /* u = (r+1)*(1-d^2) */
-        $c   = self::fe_neg(self::fe_1());                     /* c = -1 */
-        $rpd = self::fe_add($r, $d);                           /* rpd = r+d */
-
-        $v = self::fe_mul(
-            self::fe_sub(
-                $c,
-                self::fe_mul($r, $d)
-            ),
-            $rpd
-        ); /* v = (c-r*d)*(r+d) */
-
-        $result = self::ristretto255_sqrt_ratio_m1($u, $v);
-        $s = $result['x'];
-        $wasnt_square = 1 - $result['nonsquare'];
-
-        $s_prime = self::fe_neg(
-            self::fe_abs(
-                self::fe_mul($s, $t)
-            )
-        ); /* s_prime = -|s*t| */
-        $s = self::fe_cmov($s, $s_prime, $wasnt_square);
-        $c = self::fe_cmov($c, $r, $wasnt_square);
-
-        // fe25519_sub(n, r, one);            /* n = r-1 */
-        // fe25519_mul(n, n, c);              /* n = c*(r-1) */
-        // fe25519_mul(n, n, ed25519_sqdmone); /* n = c*(r-1)*(d-1)^2 */
-        // fe25519_sub(n, n, v);              /* n =  c*(r-1)*(d-1)^2-v */
-        $n = self::fe_sub(
-            self::fe_mul(
-                self::fe_mul(
-                    self::fe_sub($r, $one),
-                    $c
-                ),
-                $sqdmone
-            ),
-            $v
-        ); /* n =  c*(r-1)*(d-1)^2-v */
-
-        $w0 = self::fe_mul(
-            self::fe_add($s, $s),
-            $v
-        ); /* w0 = 2s*v */
-
-        $w1 = self::fe_mul($n, $sqrtadm1); /* w1 = n*sqrt(ad-1) */
-        $ss = self::fe_sq($s); /* ss = s^2 */
-        $w2 = self::fe_sub($one, $ss); /* w2 = 1-s^2 */
-        $w3 = self::fe_add($one, $ss); /* w3 = 1+s^2 */
-
-        return new ParagonIE_Sodium_Core_Curve25519_Ge_P3(
-            self::fe_mul($w0, $w3),
-            self::fe_mul($w2, $w1),
-            self::fe_mul($w1, $w3),
-            self::fe_mul($w0, $w2)
-        );
-    }
-
-    /**
-     * @param string $h
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_from_hash($h)
-    {
-        if (self::strlen($h) !== 64) {
-            throw new SodiumException('Hash must be 64 bytes');
-        }
-        //fe25519_frombytes(r0, h);
-        //fe25519_frombytes(r1, h + 32);
-        $r0 = self::fe_frombytes(self::substr($h, 0, 32));
-        $r1 = self::fe_frombytes(self::substr($h, 32, 32));
-
-        //ristretto255_elligator(&p0, r0);
-        //ristretto255_elligator(&p1, r1);
-        $p0 = self::ristretto255_elligator($r0);
-        $p1 = self::ristretto255_elligator($r1);
-
-        //ge25519_p3_to_cached(&p1_cached, &p1);
-        //ge25519_add_cached(&p_p1p1, &p0, &p1_cached);
-        $p_p1p1 = self::ge_add(
-            $p0,
-            self::ge_p3_to_cached($p1)
-        );
-
-        //ge25519_p1p1_to_p3(&p, &p_p1p1);
-        //ristretto255_p3_tobytes(s, &p);
-        return self::ristretto255_p3_tobytes(
-            self::ge_p1p1_to_p3($p_p1p1)
-        );
-    }
-
-    /**
-     * @param string $p
-     * @return int
-     * @throws SodiumException
-     */
-    public static function is_valid_point($p)
-    {
-        $result = self::ristretto255_frombytes($p);
-        if ($result['res'] !== 0) {
-            return 0;
-        }
-        return 1;
-    }
-
-    /**
-     * @param string $p
-     * @param string $q
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_add($p, $q)
-    {
-        $p_res = self::ristretto255_frombytes($p);
-        $q_res = self::ristretto255_frombytes($q);
-        if ($p_res['res'] !== 0 || $q_res['res'] !== 0) {
-            throw new SodiumException('Could not add points');
-        }
-        $p_p3 = $p_res['h'];
-        $q_p3 = $q_res['h'];
-        $q_cached = self::ge_p3_to_cached($q_p3);
-        $r_p1p1 = self::ge_add($p_p3, $q_cached);
-        $r_p3 = self::ge_p1p1_to_p3($r_p1p1);
-        return self::ristretto255_p3_tobytes($r_p3);
-    }
-
-    /**
-     * @param string $p
-     * @param string $q
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_sub($p, $q)
-    {
-        $p_res = self::ristretto255_frombytes($p);
-        $q_res = self::ristretto255_frombytes($q);
-        if ($p_res['res'] !== 0 || $q_res['res'] !== 0) {
-            throw new SodiumException('Could not add points');
-        }
-        $p_p3 = $p_res['h'];
-        $q_p3 = $q_res['h'];
-        $q_cached = self::ge_p3_to_cached($q_p3);
-        $r_p1p1 = self::ge_sub($p_p3, $q_cached);
-        $r_p3 = self::ge_p1p1_to_p3($r_p1p1);
-        return self::ristretto255_p3_tobytes($r_p3);
-    }
-
-
-    /**
-     * @param int $hLen
-     * @param ?string $ctx
-     * @param string $msg
-     * @return string
-     * @throws SodiumException
-     * @psalm-suppress PossiblyInvalidArgument hash API
-     */
-    protected static function h2c_string_to_hash_sha256($hLen, $ctx, $msg)
-    {
-        $h = array_fill(0, $hLen, 0);
-        $ctx_len = !is_null($ctx) ? self::strlen($ctx) : 0;
-        if ($hLen > 0xff) {
-            throw new SodiumException('Hash must be less than 256 bytes');
-        }
-
-        if ($ctx_len > 0xff) {
-            $st = hash_init('sha256');
-            self::hash_update($st, "H2C-OVERSIZE-DST-");
-            self::hash_update($st, $ctx);
-            $ctx = hash_final($st, true);
-            $ctx_len = 32;
-        }
-        $t = array(0, $hLen, 0);
-        $ux = str_repeat("\0", 64);
-        $st = hash_init('sha256');
-        self::hash_update($st, $ux);
-        self::hash_update($st, $msg);
-        self::hash_update($st, self::intArrayToString($t));
-        self::hash_update($st, $ctx);
-        self::hash_update($st, self::intToChr($ctx_len));
-        $u0 = hash_final($st, true);
-
-        for ($i = 0; $i < $hLen; $i += 64) {
-            $ux = self::xorStrings($ux, $u0);
-            ++$t[2];
-            $st = hash_init('sha256');
-            self::hash_update($st, $ux);
-            self::hash_update($st, self::intToChr($t[2]));
-            self::hash_update($st, $ctx);
-            self::hash_update($st, self::intToChr($ctx_len));
-            $ux = hash_final($st, true);
-            $amount = min($hLen - $i, 64);
-            for ($j = 0; $j < $amount; ++$j) {
-                $h[$i + $j] = self::chrToInt($ux[$i]);
-            }
-        }
-        return self::intArrayToString(array_slice($h, 0, $hLen));
-    }
-
-    /**
-     * @param int $hLen
-     * @param ?string $ctx
-     * @param string $msg
-     * @return string
-     * @throws SodiumException
-     * @psalm-suppress PossiblyInvalidArgument hash API
-     */
-    protected static function h2c_string_to_hash_sha512($hLen, $ctx, $msg)
-    {
-        $h = array_fill(0, $hLen, 0);
-        $ctx_len = !is_null($ctx) ? self::strlen($ctx) : 0;
-        if ($hLen > 0xff) {
-            throw new SodiumException('Hash must be less than 256 bytes');
-        }
-
-        if ($ctx_len > 0xff) {
-            $st = hash_init('sha256');
-            self::hash_update($st, "H2C-OVERSIZE-DST-");
-            self::hash_update($st, $ctx);
-            $ctx = hash_final($st, true);
-            $ctx_len = 32;
-        }
-        $t = array(0, $hLen, 0);
-        $ux = str_repeat("\0", 128);
-        $st = hash_init('sha512');
-        self::hash_update($st, $ux);
-        self::hash_update($st, $msg);
-        self::hash_update($st, self::intArrayToString($t));
-        self::hash_update($st, $ctx);
-        self::hash_update($st, self::intToChr($ctx_len));
-        $u0 = hash_final($st, true);
-
-        for ($i = 0; $i < $hLen; $i += 128) {
-            $ux = self::xorStrings($ux, $u0);
-            ++$t[2];
-            $st = hash_init('sha512');
-            self::hash_update($st, $ux);
-            self::hash_update($st, self::intToChr($t[2]));
-            self::hash_update($st, $ctx);
-            self::hash_update($st, self::intToChr($ctx_len));
-            $ux = hash_final($st, true);
-            $amount = min($hLen - $i, 128);
-            for ($j = 0; $j < $amount; ++$j) {
-                $h[$i + $j] = self::chrToInt($ux[$i]);
-            }
-        }
-        return self::intArrayToString(array_slice($h, 0, $hLen));
-    }
-
-    /**
-     * @param int $hLen
-     * @param ?string $ctx
-     * @param string $msg
-     * @param int $hash_alg
-     * @return string
-     * @throws SodiumException
-     */
-    public static function h2c_string_to_hash($hLen, $ctx, $msg, $hash_alg)
-    {
-        switch ($hash_alg) {
-            case self::CORE_H2C_SHA256:
-                return self::h2c_string_to_hash_sha256($hLen, $ctx, $msg);
-            case self::CORE_H2C_SHA512:
-                return self::h2c_string_to_hash_sha512($hLen, $ctx, $msg);
-            default:
-                throw new SodiumException('Invalid H2C hash algorithm');
-        }
-    }
-
-    /**
-     * @param ?string $ctx
-     * @param string $msg
-     * @param int $hash_alg
-     * @return string
-     * @throws SodiumException
-     */
-    protected static function _string_to_element($ctx, $msg, $hash_alg)
-    {
-        return self::ristretto255_from_hash(
-            self::h2c_string_to_hash(self::crypto_core_ristretto255_HASHBYTES, $ctx, $msg, $hash_alg)
-        );
-    }
-
-    /**
-     * @return string
-     * @throws SodiumException
-     * @throws Exception
-     */
-    public static function ristretto255_random()
-    {
-        return self::ristretto255_from_hash(
-            ParagonIE_Sodium_Compat::randombytes_buf(self::crypto_core_ristretto255_HASHBYTES)
-        );
-    }
-
-    /**
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_scalar_random()
-    {
-        return self::scalar_random();
-    }
-
-    /**
-     * @param string $s
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_scalar_complement($s)
-    {
-        return self::scalar_complement($s);
-    }
-
-
-    /**
-     * @param string $s
-     * @return string
-     */
-    public static function ristretto255_scalar_invert($s)
-    {
-        return self::sc25519_invert($s);
-    }
-
-    /**
-     * @param string $s
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_scalar_negate($s)
-    {
-        return self::scalar_negate($s);
-    }
-
-    /**
-     * @param string $x
-     * @param string $y
-     * @return string
-     */
-    public static function ristretto255_scalar_add($x, $y)
-    {
-        return self::scalar_add($x, $y);
-    }
-
-    /**
-     * @param string $x
-     * @param string $y
-     * @return string
-     */
-    public static function ristretto255_scalar_sub($x, $y)
-    {
-        return self::scalar_sub($x, $y);
-    }
-
-    /**
-     * @param string $x
-     * @param string $y
-     * @return string
-     */
-    public static function ristretto255_scalar_mul($x, $y)
-    {
-        return self::sc25519_mul($x, $y);
-    }
-
-    /**
-     * @param string $ctx
-     * @param string $msg
-     * @param int $hash_alg
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_scalar_from_string($ctx, $msg, $hash_alg)
-    {
-        $h = array_fill(0, 64, 0);
-        $h_be = self::stringToIntArray(
-            self::h2c_string_to_hash(
-                self::HASH_SC_L, $ctx, $msg, $hash_alg
-            )
-        );
-
-        for ($i = 0; $i < self::HASH_SC_L; ++$i) {
-            $h[$i] = $h_be[self::HASH_SC_L - 1 - $i];
-        }
-        return self::ristretto255_scalar_reduce(self::intArrayToString($h));
-    }
-
-    /**
-     * @param string $s
-     * @return string
-     */
-    public static function ristretto255_scalar_reduce($s)
-    {
-        return self::sc_reduce($s);
-    }
-
-    /**
-     * @param string $n
-     * @param string $p
-     * @return string
-     * @throws SodiumException
-     */
-    public static function scalarmult_ristretto255($n, $p)
-    {
-        if (self::strlen($n) !== 32) {
-            throw new SodiumException('Scalar must be 32 bytes, ' . self::strlen($p) . ' given.');
-        }
-        if (self::strlen($p) !== 32) {
-            throw new SodiumException('Point must be 32 bytes, ' . self::strlen($p) . ' given.');
-        }
-        $result = self::ristretto255_frombytes($p);
-        if ($result['res'] !== 0) {
-            throw new SodiumException('Could not multiply points');
-        }
-        $P = $result['h'];
-
-        $t = self::stringToIntArray($n);
-        $t[31] &= 0x7f;
-        $Q = self::ge_scalarmult(self::intArrayToString($t), $P);
-        $q = self::ristretto255_p3_tobytes($Q);
-        if (ParagonIE_Sodium_Compat::is_zero($q)) {
-            throw new SodiumException('An unknown error has occurred');
-        }
-        return $q;
-    }
-
-    /**
-     * @param string $n
-     * @return string
-     * @throws SodiumException
-     */
-    public static function scalarmult_ristretto255_base($n)
-    {
-        $t = self::stringToIntArray($n);
-        $t[31] &= 0x7f;
-        $Q = self::ge_scalarmult_base(self::intArrayToString($t));
-        $q = self::ristretto255_p3_tobytes($Q);
-        if (ParagonIE_Sodium_Compat::is_zero($q)) {
-            throw new SodiumException('An unknown error has occurred');
-        }
-        return $q;
-    }
+	const crypto_core_ristretto255_HASHBYTES = 64;
+	const HASH_SC_L = 48;
+	const CORE_H2C_SHA256 = 1;
+	const CORE_H2C_SHA512 = 2;
+
+	/**
+	 * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
+	 * @param int $b
+	 * @return ParagonIE_Sodium_Core_Curve25519_Fe
+	 */
+	public static function fe_cneg(ParagonIE_Sodium_Core_Curve25519_Fe $f, $b)
+	{
+		$negf = self::fe_neg($f);
+		return self::fe_cmov($f, $negf, $b);
+	}
+
+	/**
+	 * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
+	 * @return ParagonIE_Sodium_Core_Curve25519_Fe
+	 * @throws SodiumException
+	 */
+	public static function fe_abs(ParagonIE_Sodium_Core_Curve25519_Fe $f)
+	{
+		return self::fe_cneg($f, self::fe_isnegative($f));
+	}
+
+	/**
+	 * Returns 0 if this field element results in all NUL bytes.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
+	 * @return int
+	 * @throws SodiumException
+	 */
+	public static function fe_iszero(ParagonIE_Sodium_Core_Curve25519_Fe $f)
+	{
+		static $zero;
+		if ($zero === null) {
+			$zero = str_repeat("\x00", 32);
+		}
+		/** @var string $zero */
+		$str = self::fe_tobytes($f);
+
+		$d = 0;
+		for ($i = 0; $i < 32; ++$i) {
+			$d |= self::chrToInt($str[$i]);
+		}
+		return (($d - 1) >> 31) & 1;
+	}
+
+
+	/**
+	 * @param ParagonIE_Sodium_Core_Curve25519_Fe $u
+	 * @param ParagonIE_Sodium_Core_Curve25519_Fe $v
+	 * @return array{x: ParagonIE_Sodium_Core_Curve25519_Fe, nonsquare: int}
+	 *
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_sqrt_ratio_m1(
+		ParagonIE_Sodium_Core_Curve25519_Fe $u,
+		ParagonIE_Sodium_Core_Curve25519_Fe $v
+	) {
+		$sqrtm1 = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$sqrtm1);
+
+		$v3 = self::fe_mul(
+			self::fe_sq($v),
+			$v
+		); /* v3 = v^3 */
+		$x = self::fe_mul(
+			self::fe_mul(
+				self::fe_sq($v3),
+				$u
+			),
+			$v
+		); /* x = uv^7 */
+
+		$x = self::fe_mul(
+			self::fe_mul(
+				self::fe_pow22523($x), /* x = (uv^7)^((q-5)/8) */
+				$v3
+			),
+			$u
+		); /* x = uv^3(uv^7)^((q-5)/8) */
+
+		$vxx = self::fe_mul(
+			self::fe_sq($x),
+			$v
+		); /* vx^2 */
+
+		$m_root_check = self::fe_sub($vxx, $u); /* vx^2-u */
+		$p_root_check = self::fe_add($vxx, $u); /* vx^2+u */
+		$f_root_check = self::fe_mul($u, $sqrtm1); /* u*sqrt(-1) */
+		$f_root_check = self::fe_add($vxx, $f_root_check); /* vx^2+u*sqrt(-1) */
+
+		$has_m_root = self::fe_iszero($m_root_check);
+		$has_p_root = self::fe_iszero($p_root_check);
+		$has_f_root = self::fe_iszero($f_root_check);
+
+		$x_sqrtm1 = self::fe_mul($x, $sqrtm1); /* x*sqrt(-1) */
+
+		$x = self::fe_abs(
+			self::fe_cmov($x, $x_sqrtm1, $has_p_root | $has_f_root)
+		);
+		return array(
+			'x' => $x,
+			'nonsquare' => $has_m_root | $has_p_root
+		);
+	}
+
+	/**
+	 * @param string $s
+	 * @return int
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_point_is_canonical($s)
+	{
+		$c = (self::chrToInt($s[31]) & 0x7f) ^ 0x7f;
+		for ($i = 30; $i > 0; --$i) {
+			$c |= self::chrToInt($s[$i]) ^ 0xff;
+		}
+		$c = ($c - 1) >> 8;
+		$d = (0xed - 1 - self::chrToInt($s[0])) >> 8;
+		$e = self::chrToInt($s[31]) >> 7;
+
+		return 1 - ((($c & $d) | $e | self::chrToInt($s[0])) & 1);
+	}
+
+	/**
+	 * @param string $s
+	 * @param bool $skipCanonicalCheck
+	 * @return array{h: ParagonIE_Sodium_Core_Curve25519_Ge_P3, res: int}
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_frombytes($s, $skipCanonicalCheck = false)
+	{
+		if (!$skipCanonicalCheck) {
+			if (!self::ristretto255_point_is_canonical($s)) {
+				throw new SodiumException('S is not canonical');
+			}
+		}
+
+		$s_ = self::fe_frombytes($s);
+		$ss = self::fe_sq($s_); /* ss = s^2 */
+
+		$u1 = self::fe_sub(self::fe_1(), $ss); /* u1 = 1-ss */
+		$u1u1 = self::fe_sq($u1); /* u1u1 = u1^2 */
+
+		$u2 = self::fe_add(self::fe_1(), $ss); /* u2 = 1+ss */
+		$u2u2 = self::fe_sq($u2); /* u2u2 = u2^2 */
+
+		$v = self::fe_mul(
+			ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$d),
+			$u1u1
+		); /* v = d*u1^2 */
+		$v = self::fe_neg($v); /* v = -d*u1^2 */
+		$v = self::fe_sub($v, $u2u2); /* v = -(d*u1^2)-u2^2 */
+		$v_u2u2 = self::fe_mul($v, $u2u2); /* v_u2u2 = v*u2^2 */
+
+		// fe25519_1(one);
+		// notsquare = ristretto255_sqrt_ratio_m1(inv_sqrt, one, v_u2u2);
+		$one = self::fe_1();
+		$result = self::ristretto255_sqrt_ratio_m1($one, $v_u2u2);
+		$inv_sqrt = $result['x'];
+		$notsquare = $result['nonsquare'];
+
+		$h = new ParagonIE_Sodium_Core_Curve25519_Ge_P3();
+
+		$h->X = self::fe_mul($inv_sqrt, $u2);
+		$h->Y = self::fe_mul(self::fe_mul($inv_sqrt, $h->X), $v);
+
+		$h->X = self::fe_mul($h->X, $s_);
+		$h->X = self::fe_abs(
+			self::fe_add($h->X, $h->X)
+		);
+		$h->Y = self::fe_mul($u1, $h->Y);
+		$h->Z = self::fe_1();
+		$h->T = self::fe_mul($h->X, $h->Y);
+
+		$res = - ((1 - $notsquare) | self::fe_isnegative($h->T) | self::fe_iszero($h->Y));
+		return array('h' => $h, 'res' => $res);
+	}
+
+	/**
+	 * @param ParagonIE_Sodium_Core_Curve25519_Ge_P3 $h
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_p3_tobytes(ParagonIE_Sodium_Core_Curve25519_Ge_P3 $h)
+	{
+		$sqrtm1 = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$sqrtm1);
+		$invsqrtamd = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$invsqrtamd);
+
+		$u1 = self::fe_add($h->Z, $h->Y); /* u1 = Z+Y */
+		$zmy = self::fe_sub($h->Z, $h->Y); /* zmy = Z-Y */
+		$u1 = self::fe_mul($u1, $zmy); /* u1 = (Z+Y)*(Z-Y) */
+		$u2 = self::fe_mul($h->X, $h->Y); /* u2 = X*Y */
+
+		$u1_u2u2 = self::fe_mul(self::fe_sq($u2), $u1); /* u1_u2u2 = u1*u2^2 */
+		$one = self::fe_1();
+
+		// fe25519_1(one);
+		// (void) ristretto255_sqrt_ratio_m1(inv_sqrt, one, u1_u2u2);
+		$result = self::ristretto255_sqrt_ratio_m1($one, $u1_u2u2);
+		$inv_sqrt = $result['x'];
+
+		$den1 = self::fe_mul($inv_sqrt, $u1); /* den1 = inv_sqrt*u1 */
+		$den2 = self::fe_mul($inv_sqrt, $u2); /* den2 = inv_sqrt*u2 */
+		$z_inv = self::fe_mul($h->T, self::fe_mul($den1, $den2)); /* z_inv = den1*den2*T */
+
+		$ix = self::fe_mul($h->X, $sqrtm1); /* ix = X*sqrt(-1) */
+		$iy = self::fe_mul($h->Y, $sqrtm1); /* iy = Y*sqrt(-1) */
+		$eden = self::fe_mul($den1, $invsqrtamd);
+
+		$t_z_inv =  self::fe_mul($h->T, $z_inv); /* t_z_inv = T*z_inv */
+		$rotate = self::fe_isnegative($t_z_inv);
+
+		$x_ = self::fe_copy($h->X);
+		$y_ = self::fe_copy($h->Y);
+		$den_inv = self::fe_copy($den2);
+
+		$x_ = self::fe_cmov($x_, $iy, $rotate);
+		$y_ = self::fe_cmov($y_, $ix, $rotate);
+		$den_inv = self::fe_cmov($den_inv, $eden, $rotate);
+
+		$x_z_inv = self::fe_mul($x_, $z_inv);
+		$y_ = self::fe_cneg($y_, self::fe_isnegative($x_z_inv));
+
+
+		// fe25519_sub(s_, h->Z, y_);
+		// fe25519_mul(s_, den_inv, s_);
+		// fe25519_abs(s_, s_);
+		// fe25519_tobytes(s, s_);
+		return self::fe_tobytes(
+			self::fe_abs(
+				self::fe_mul(
+					$den_inv,
+					self::fe_sub($h->Z, $y_)
+				)
+			)
+		);
+	}
+
+	/**
+	 * @param ParagonIE_Sodium_Core_Curve25519_Fe $t
+	 * @return ParagonIE_Sodium_Core_Curve25519_Ge_P3
+	 *
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_elligator(ParagonIE_Sodium_Core_Curve25519_Fe $t)
+	{
+		$sqrtm1   = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$sqrtm1);
+		$onemsqd  = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$onemsqd);
+		$d        = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$d);
+		$sqdmone  = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$sqdmone);
+		$sqrtadm1 = ParagonIE_Sodium_Core_Curve25519_Fe::fromArray(self::$sqrtadm1);
+
+		$one = self::fe_1();
+		$r   = self::fe_mul($sqrtm1, self::fe_sq($t));         /* r = sqrt(-1)*t^2 */
+		$u   = self::fe_mul(self::fe_add($r, $one), $onemsqd); /* u = (r+1)*(1-d^2) */
+		$c   = self::fe_neg(self::fe_1());                     /* c = -1 */
+		$rpd = self::fe_add($r, $d);                           /* rpd = r+d */
+
+		$v = self::fe_mul(
+			self::fe_sub(
+				$c,
+				self::fe_mul($r, $d)
+			),
+			$rpd
+		); /* v = (c-r*d)*(r+d) */
+
+		$result = self::ristretto255_sqrt_ratio_m1($u, $v);
+		$s = $result['x'];
+		$wasnt_square = 1 - $result['nonsquare'];
+
+		$s_prime = self::fe_neg(
+			self::fe_abs(
+				self::fe_mul($s, $t)
+			)
+		); /* s_prime = -|s*t| */
+		$s = self::fe_cmov($s, $s_prime, $wasnt_square);
+		$c = self::fe_cmov($c, $r, $wasnt_square);
+
+		// fe25519_sub(n, r, one);            /* n = r-1 */
+		// fe25519_mul(n, n, c);              /* n = c*(r-1) */
+		// fe25519_mul(n, n, ed25519_sqdmone); /* n = c*(r-1)*(d-1)^2 */
+		// fe25519_sub(n, n, v);              /* n =  c*(r-1)*(d-1)^2-v */
+		$n = self::fe_sub(
+			self::fe_mul(
+				self::fe_mul(
+					self::fe_sub($r, $one),
+					$c
+				),
+				$sqdmone
+			),
+			$v
+		); /* n =  c*(r-1)*(d-1)^2-v */
+
+		$w0 = self::fe_mul(
+			self::fe_add($s, $s),
+			$v
+		); /* w0 = 2s*v */
+
+		$w1 = self::fe_mul($n, $sqrtadm1); /* w1 = n*sqrt(ad-1) */
+		$ss = self::fe_sq($s); /* ss = s^2 */
+		$w2 = self::fe_sub($one, $ss); /* w2 = 1-s^2 */
+		$w3 = self::fe_add($one, $ss); /* w3 = 1+s^2 */
+
+		return new ParagonIE_Sodium_Core_Curve25519_Ge_P3(
+			self::fe_mul($w0, $w3),
+			self::fe_mul($w2, $w1),
+			self::fe_mul($w1, $w3),
+			self::fe_mul($w0, $w2)
+		);
+	}
+
+	/**
+	 * @param string $h
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_from_hash($h)
+	{
+		if (self::strlen($h) !== 64) {
+			throw new SodiumException('Hash must be 64 bytes');
+		}
+		//fe25519_frombytes(r0, h);
+		//fe25519_frombytes(r1, h + 32);
+		$r0 = self::fe_frombytes(self::substr($h, 0, 32));
+		$r1 = self::fe_frombytes(self::substr($h, 32, 32));
+
+		//ristretto255_elligator(&p0, r0);
+		//ristretto255_elligator(&p1, r1);
+		$p0 = self::ristretto255_elligator($r0);
+		$p1 = self::ristretto255_elligator($r1);
+
+		//ge25519_p3_to_cached(&p1_cached, &p1);
+		//ge25519_add_cached(&p_p1p1, &p0, &p1_cached);
+		$p_p1p1 = self::ge_add(
+			$p0,
+			self::ge_p3_to_cached($p1)
+		);
+
+		//ge25519_p1p1_to_p3(&p, &p_p1p1);
+		//ristretto255_p3_tobytes(s, &p);
+		return self::ristretto255_p3_tobytes(
+			self::ge_p1p1_to_p3($p_p1p1)
+		);
+	}
+
+	/**
+	 * @param string $p
+	 * @return int
+	 * @throws SodiumException
+	 */
+	public static function is_valid_point($p)
+	{
+		$result = self::ristretto255_frombytes($p);
+		if ($result['res'] !== 0) {
+			return 0;
+		}
+		return 1;
+	}
+
+	/**
+	 * @param string $p
+	 * @param string $q
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_add($p, $q)
+	{
+		$p_res = self::ristretto255_frombytes($p);
+		$q_res = self::ristretto255_frombytes($q);
+		if ($p_res['res'] !== 0 || $q_res['res'] !== 0) {
+			throw new SodiumException('Could not add points');
+		}
+		$p_p3 = $p_res['h'];
+		$q_p3 = $q_res['h'];
+		$q_cached = self::ge_p3_to_cached($q_p3);
+		$r_p1p1 = self::ge_add($p_p3, $q_cached);
+		$r_p3 = self::ge_p1p1_to_p3($r_p1p1);
+		return self::ristretto255_p3_tobytes($r_p3);
+	}
+
+	/**
+	 * @param string $p
+	 * @param string $q
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_sub($p, $q)
+	{
+		$p_res = self::ristretto255_frombytes($p);
+		$q_res = self::ristretto255_frombytes($q);
+		if ($p_res['res'] !== 0 || $q_res['res'] !== 0) {
+			throw new SodiumException('Could not add points');
+		}
+		$p_p3 = $p_res['h'];
+		$q_p3 = $q_res['h'];
+		$q_cached = self::ge_p3_to_cached($q_p3);
+		$r_p1p1 = self::ge_sub($p_p3, $q_cached);
+		$r_p3 = self::ge_p1p1_to_p3($r_p1p1);
+		return self::ristretto255_p3_tobytes($r_p3);
+	}
+
+
+	/**
+	 * @param int $hLen
+	 * @param ?string $ctx
+	 * @param string $msg
+	 * @return string
+	 * @throws SodiumException
+	 * @psalm-suppress PossiblyInvalidArgument hash API
+	 */
+	protected static function h2c_string_to_hash_sha256($hLen, $ctx, $msg)
+	{
+		$h = array_fill(0, $hLen, 0);
+		$ctx_len = !is_null($ctx) ? self::strlen($ctx) : 0;
+		if ($hLen > 0xff) {
+			throw new SodiumException('Hash must be less than 256 bytes');
+		}
+
+		if ($ctx_len > 0xff) {
+			$st = hash_init('sha256');
+			self::hash_update($st, "H2C-OVERSIZE-DST-");
+			self::hash_update($st, $ctx);
+			$ctx = hash_final($st, true);
+			$ctx_len = 32;
+		}
+		$t = array(0, $hLen, 0);
+		$ux = str_repeat("\0", 64);
+		$st = hash_init('sha256');
+		self::hash_update($st, $ux);
+		self::hash_update($st, $msg);
+		self::hash_update($st, self::intArrayToString($t));
+		self::hash_update($st, $ctx);
+		self::hash_update($st, self::intToChr($ctx_len));
+		$u0 = hash_final($st, true);
+
+		for ($i = 0; $i < $hLen; $i += 64) {
+			$ux = self::xorStrings($ux, $u0);
+			++$t[2];
+			$st = hash_init('sha256');
+			self::hash_update($st, $ux);
+			self::hash_update($st, self::intToChr($t[2]));
+			self::hash_update($st, $ctx);
+			self::hash_update($st, self::intToChr($ctx_len));
+			$ux = hash_final($st, true);
+			$amount = min($hLen - $i, 64);
+			for ($j = 0; $j < $amount; ++$j) {
+				$h[$i + $j] = self::chrToInt($ux[$i]);
+			}
+		}
+		return self::intArrayToString(array_slice($h, 0, $hLen));
+	}
+
+	/**
+	 * @param int $hLen
+	 * @param ?string $ctx
+	 * @param string $msg
+	 * @return string
+	 * @throws SodiumException
+	 * @psalm-suppress PossiblyInvalidArgument hash API
+	 */
+	protected static function h2c_string_to_hash_sha512($hLen, $ctx, $msg)
+	{
+		$h = array_fill(0, $hLen, 0);
+		$ctx_len = !is_null($ctx) ? self::strlen($ctx) : 0;
+		if ($hLen > 0xff) {
+			throw new SodiumException('Hash must be less than 256 bytes');
+		}
+
+		if ($ctx_len > 0xff) {
+			$st = hash_init('sha256');
+			self::hash_update($st, "H2C-OVERSIZE-DST-");
+			self::hash_update($st, $ctx);
+			$ctx = hash_final($st, true);
+			$ctx_len = 32;
+		}
+		$t = array(0, $hLen, 0);
+		$ux = str_repeat("\0", 128);
+		$st = hash_init('sha512');
+		self::hash_update($st, $ux);
+		self::hash_update($st, $msg);
+		self::hash_update($st, self::intArrayToString($t));
+		self::hash_update($st, $ctx);
+		self::hash_update($st, self::intToChr($ctx_len));
+		$u0 = hash_final($st, true);
+
+		for ($i = 0; $i < $hLen; $i += 128) {
+			$ux = self::xorStrings($ux, $u0);
+			++$t[2];
+			$st = hash_init('sha512');
+			self::hash_update($st, $ux);
+			self::hash_update($st, self::intToChr($t[2]));
+			self::hash_update($st, $ctx);
+			self::hash_update($st, self::intToChr($ctx_len));
+			$ux = hash_final($st, true);
+			$amount = min($hLen - $i, 128);
+			for ($j = 0; $j < $amount; ++$j) {
+				$h[$i + $j] = self::chrToInt($ux[$i]);
+			}
+		}
+		return self::intArrayToString(array_slice($h, 0, $hLen));
+	}
+
+	/**
+	 * @param int $hLen
+	 * @param ?string $ctx
+	 * @param string $msg
+	 * @param int $hash_alg
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function h2c_string_to_hash($hLen, $ctx, $msg, $hash_alg)
+	{
+		switch ($hash_alg) {
+			case self::CORE_H2C_SHA256:
+				return self::h2c_string_to_hash_sha256($hLen, $ctx, $msg);
+			case self::CORE_H2C_SHA512:
+				return self::h2c_string_to_hash_sha512($hLen, $ctx, $msg);
+			default:
+				throw new SodiumException('Invalid H2C hash algorithm');
+		}
+	}
+
+	/**
+	 * @param ?string $ctx
+	 * @param string $msg
+	 * @param int $hash_alg
+	 * @return string
+	 * @throws SodiumException
+	 */
+	protected static function _string_to_element($ctx, $msg, $hash_alg)
+	{
+		return self::ristretto255_from_hash(
+			self::h2c_string_to_hash(self::crypto_core_ristretto255_HASHBYTES, $ctx, $msg, $hash_alg)
+		);
+	}
+
+	/**
+	 * @return string
+	 * @throws SodiumException
+	 * @throws Exception
+	 */
+	public static function ristretto255_random()
+	{
+		return self::ristretto255_from_hash(
+			ParagonIE_Sodium_Compat::randombytes_buf(self::crypto_core_ristretto255_HASHBYTES)
+		);
+	}
+
+	/**
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_scalar_random()
+	{
+		return self::scalar_random();
+	}
+
+	/**
+	 * @param string $s
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_scalar_complement($s)
+	{
+		return self::scalar_complement($s);
+	}
+
+
+	/**
+	 * @param string $s
+	 * @return string
+	 */
+	public static function ristretto255_scalar_invert($s)
+	{
+		return self::sc25519_invert($s);
+	}
+
+	/**
+	 * @param string $s
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_scalar_negate($s)
+	{
+		return self::scalar_negate($s);
+	}
+
+	/**
+	 * @param string $x
+	 * @param string $y
+	 * @return string
+	 */
+	public static function ristretto255_scalar_add($x, $y)
+	{
+		return self::scalar_add($x, $y);
+	}
+
+	/**
+	 * @param string $x
+	 * @param string $y
+	 * @return string
+	 */
+	public static function ristretto255_scalar_sub($x, $y)
+	{
+		return self::scalar_sub($x, $y);
+	}
+
+	/**
+	 * @param string $x
+	 * @param string $y
+	 * @return string
+	 */
+	public static function ristretto255_scalar_mul($x, $y)
+	{
+		return self::sc25519_mul($x, $y);
+	}
+
+	/**
+	 * @param string $ctx
+	 * @param string $msg
+	 * @param int $hash_alg
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_scalar_from_string($ctx, $msg, $hash_alg)
+	{
+		$h = array_fill(0, 64, 0);
+		$h_be = self::stringToIntArray(
+			self::h2c_string_to_hash(
+				self::HASH_SC_L, $ctx, $msg, $hash_alg
+			)
+		);
+
+		for ($i = 0; $i < self::HASH_SC_L; ++$i) {
+			$h[$i] = $h_be[self::HASH_SC_L - 1 - $i];
+		}
+		return self::ristretto255_scalar_reduce(self::intArrayToString($h));
+	}
+
+	/**
+	 * @param string $s
+	 * @return string
+	 */
+	public static function ristretto255_scalar_reduce($s)
+	{
+		return self::sc_reduce($s);
+	}
+
+	/**
+	 * @param string $n
+	 * @param string $p
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function scalarmult_ristretto255($n, $p)
+	{
+		if (self::strlen($n) !== 32) {
+			throw new SodiumException('Scalar must be 32 bytes, ' . self::strlen($p) . ' given.');
+		}
+		if (self::strlen($p) !== 32) {
+			throw new SodiumException('Point must be 32 bytes, ' . self::strlen($p) . ' given.');
+		}
+		$result = self::ristretto255_frombytes($p);
+		if ($result['res'] !== 0) {
+			throw new SodiumException('Could not multiply points');
+		}
+		$P = $result['h'];
+
+		$t = self::stringToIntArray($n);
+		$t[31] &= 0x7f;
+		$Q = self::ge_scalarmult(self::intArrayToString($t), $P);
+		$q = self::ristretto255_p3_tobytes($Q);
+		if (ParagonIE_Sodium_Compat::is_zero($q)) {
+			throw new SodiumException('An unknown error has occurred');
+		}
+		return $q;
+	}
+
+	/**
+	 * @param string $n
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function scalarmult_ristretto255_base($n)
+	{
+		$t = self::stringToIntArray($n);
+		$t[31] &= 0x7f;
+		$Q = self::ge_scalarmult_base(self::intArrayToString($t));
+		$q = self::ristretto255_p3_tobytes($Q);
+		if (ParagonIE_Sodium_Compat::is_zero($q)) {
+			throw new SodiumException('An unknown error has occurred');
+		}
+		return $q;
+	}
 }

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

Indentation +105 added lines, -105 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_ChaCha20_Ctx', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,115 +9,115 @@ 
  */
 class ParagonIE_Sodium_Core_ChaCha20_Ctx extends ParagonIE_Sodium_Core_Util implements ArrayAccess
 {
-    /**
-     * @var SplFixedArray internally, <int, int>
-     */
-    protected $container;
+	/**
+	 * @var SplFixedArray internally, <int, int>
+	 */
+	protected $container;
 
-    /**
-     * ParagonIE_Sodium_Core_ChaCha20_Ctx constructor.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $key     ChaCha20 key.
-     * @param string $iv      Initialization Vector (a.k.a. nonce).
-     * @param string $counter The initial counter value.
-     *                        Defaults to 8 0x00 bytes.
-     * @throws InvalidArgumentException
-     * @throws TypeError
-     */
-    public function __construct($key = '', $iv = '', $counter = '')
-    {
-        if (self::strlen($key) !== 32) {
-            throw new InvalidArgumentException('ChaCha20 expects a 256-bit key.');
-        }
-        if (self::strlen($iv) !== 8) {
-            throw new InvalidArgumentException('ChaCha20 expects a 64-bit nonce.');
-        }
-        $this->container = new SplFixedArray(16);
+	/**
+	 * ParagonIE_Sodium_Core_ChaCha20_Ctx constructor.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $key     ChaCha20 key.
+	 * @param string $iv      Initialization Vector (a.k.a. nonce).
+	 * @param string $counter The initial counter value.
+	 *                        Defaults to 8 0x00 bytes.
+	 * @throws InvalidArgumentException
+	 * @throws TypeError
+	 */
+	public function __construct($key = '', $iv = '', $counter = '')
+	{
+		if (self::strlen($key) !== 32) {
+			throw new InvalidArgumentException('ChaCha20 expects a 256-bit key.');
+		}
+		if (self::strlen($iv) !== 8) {
+			throw new InvalidArgumentException('ChaCha20 expects a 64-bit nonce.');
+		}
+		$this->container = new SplFixedArray(16);
 
-        /* "expand 32-byte k" as per ChaCha20 spec */
-        $this->container[0]  = 0x61707865;
-        $this->container[1]  = 0x3320646e;
-        $this->container[2]  = 0x79622d32;
-        $this->container[3]  = 0x6b206574;
-        $this->container[4]  = self::load_4(self::substr($key, 0, 4));
-        $this->container[5]  = self::load_4(self::substr($key, 4, 4));
-        $this->container[6]  = self::load_4(self::substr($key, 8, 4));
-        $this->container[7]  = self::load_4(self::substr($key, 12, 4));
-        $this->container[8]  = self::load_4(self::substr($key, 16, 4));
-        $this->container[9]  = self::load_4(self::substr($key, 20, 4));
-        $this->container[10] = self::load_4(self::substr($key, 24, 4));
-        $this->container[11] = self::load_4(self::substr($key, 28, 4));
+		/* "expand 32-byte k" as per ChaCha20 spec */
+		$this->container[0]  = 0x61707865;
+		$this->container[1]  = 0x3320646e;
+		$this->container[2]  = 0x79622d32;
+		$this->container[3]  = 0x6b206574;
+		$this->container[4]  = self::load_4(self::substr($key, 0, 4));
+		$this->container[5]  = self::load_4(self::substr($key, 4, 4));
+		$this->container[6]  = self::load_4(self::substr($key, 8, 4));
+		$this->container[7]  = self::load_4(self::substr($key, 12, 4));
+		$this->container[8]  = self::load_4(self::substr($key, 16, 4));
+		$this->container[9]  = self::load_4(self::substr($key, 20, 4));
+		$this->container[10] = self::load_4(self::substr($key, 24, 4));
+		$this->container[11] = self::load_4(self::substr($key, 28, 4));
 
-        if (empty($counter)) {
-            $this->container[12] = 0;
-            $this->container[13] = 0;
-        } else {
-            $this->container[12] = self::load_4(self::substr($counter, 0, 4));
-            $this->container[13] = self::load_4(self::substr($counter, 4, 4));
-        }
-        $this->container[14] = self::load_4(self::substr($iv, 0, 4));
-        $this->container[15] = self::load_4(self::substr($iv, 4, 4));
-    }
+		if (empty($counter)) {
+			$this->container[12] = 0;
+			$this->container[13] = 0;
+		} else {
+			$this->container[12] = self::load_4(self::substr($counter, 0, 4));
+			$this->container[13] = self::load_4(self::substr($counter, 4, 4));
+		}
+		$this->container[14] = self::load_4(self::substr($iv, 0, 4));
+		$this->container[15] = self::load_4(self::substr($iv, 4, 4));
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param int $offset
-     * @param int $value
-     * @return void
-     * @psalm-suppress MixedArrayOffset
-     */
-    #[ReturnTypeWillChange]
-    public function offsetSet($offset, $value)
-    {
-        if (!is_int($offset)) {
-            throw new InvalidArgumentException('Expected an integer');
-        }
-        if (!is_int($value)) {
-            throw new InvalidArgumentException('Expected an integer');
-        }
-        $this->container[$offset] = $value;
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $offset
+	 * @param int $value
+	 * @return void
+	 * @psalm-suppress MixedArrayOffset
+	 */
+	#[ReturnTypeWillChange]
+	public function offsetSet($offset, $value)
+	{
+		if (!is_int($offset)) {
+			throw new InvalidArgumentException('Expected an integer');
+		}
+		if (!is_int($value)) {
+			throw new InvalidArgumentException('Expected an integer');
+		}
+		$this->container[$offset] = $value;
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param int $offset
-     * @return bool
-     */
-    #[ReturnTypeWillChange]
-    public function offsetExists($offset)
-    {
-        return isset($this->container[$offset]);
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $offset
+	 * @return bool
+	 */
+	#[ReturnTypeWillChange]
+	public function offsetExists($offset)
+	{
+		return isset($this->container[$offset]);
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param int $offset
-     * @return void
-     * @psalm-suppress MixedArrayOffset
-     */
-    #[ReturnTypeWillChange]
-    public function offsetUnset($offset)
-    {
-        unset($this->container[$offset]);
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $offset
+	 * @return void
+	 * @psalm-suppress MixedArrayOffset
+	 */
+	#[ReturnTypeWillChange]
+	public function offsetUnset($offset)
+	{
+		unset($this->container[$offset]);
+	}
 
-    /**
-     * @internal You should not use this directly from another application
-     *
-     * @param int $offset
-     * @return mixed|null
-     * @psalm-suppress MixedArrayOffset
-     */
-    #[ReturnTypeWillChange]
-    public function offsetGet($offset)
-    {
-        return isset($this->container[$offset])
-            ? $this->container[$offset]
-            : null;
-    }
+	/**
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param int $offset
+	 * @return mixed|null
+	 * @psalm-suppress MixedArrayOffset
+	 */
+	#[ReturnTypeWillChange]
+	public function offsetGet($offset)
+	{
+		return isset($this->container[$offset])
+			? $this->container[$offset]
+			: null;
+	}
 }

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

Indentation +26 added lines, -26 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Core_ChaCha20_IetfCtx', false)) {
-    return;
+	return;
 }
 
 /**
@@ -9,30 +9,30 @@ 
  */
 class ParagonIE_Sodium_Core_ChaCha20_IetfCtx extends ParagonIE_Sodium_Core_ChaCha20_Ctx
 {
-    /**
-     * ParagonIE_Sodium_Core_ChaCha20_IetfCtx constructor.
-     *
-     * @internal You should not use this directly from another application
-     *
-     * @param string $key     ChaCha20 key.
-     * @param string $iv      Initialization Vector (a.k.a. nonce).
-     * @param string $counter The initial counter value.
-     *                        Defaults to 4 0x00 bytes.
-     * @throws InvalidArgumentException
-     * @throws TypeError
-     */
-    public function __construct($key = '', $iv = '', $counter = '')
-    {
-        if (self::strlen($iv) !== 12) {
-            throw new InvalidArgumentException('ChaCha20 expects a 96-bit nonce in IETF mode.');
-        }
-        parent::__construct($key, self::substr($iv, 0, 8), $counter);
+	/**
+	 * ParagonIE_Sodium_Core_ChaCha20_IetfCtx constructor.
+	 *
+	 * @internal You should not use this directly from another application
+	 *
+	 * @param string $key     ChaCha20 key.
+	 * @param string $iv      Initialization Vector (a.k.a. nonce).
+	 * @param string $counter The initial counter value.
+	 *                        Defaults to 4 0x00 bytes.
+	 * @throws InvalidArgumentException
+	 * @throws TypeError
+	 */
+	public function __construct($key = '', $iv = '', $counter = '')
+	{
+		if (self::strlen($iv) !== 12) {
+			throw new InvalidArgumentException('ChaCha20 expects a 96-bit nonce in IETF mode.');
+		}
+		parent::__construct($key, self::substr($iv, 0, 8), $counter);
 
-        if (!empty($counter)) {
-            $this->container[12] = self::load_4(self::substr($counter, 0, 4));
-        }
-        $this->container[13] = self::load_4(self::substr($iv, 0, 4));
-        $this->container[14] = self::load_4(self::substr($iv, 4, 4));
-        $this->container[15] = self::load_4(self::substr($iv, 8, 4));
-    }
+		if (!empty($counter)) {
+			$this->container[12] = self::load_4(self::substr($counter, 0, 4));
+		}
+		$this->container[13] = self::load_4(self::substr($iv, 0, 4));
+		$this->container[14] = self::load_4(self::substr($iv, 4, 4));
+		$this->container[15] = self::load_4(self::substr($iv, 8, 4));
+	}
 }

vendor/paragonie/sodium_compat/src/SodiumException.php

Indentation +6 added lines, -6 removed lines

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

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

Indentation +701 added lines, -701 removed lines

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

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

Indentation +471 added lines, -471 removed lines

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

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

Indentation +1 added lines, -1 removed lines

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

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

Indentation +225 added lines, -225 removed lines

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

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

Indentation +52 added lines, -52 removed lines

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